Кто каким ИИ пользуется для написания скетчей?

BABOS · 21.Февраль.2026 10:17:43

BOOM покажите пж это на примере кода, как оно влияет ? я помогаю только достойным, хоть и не всегда могу помочь)))
с правописанием пусть народ наймет работника и обучит за 5кк а потом будет про него говорить)))
так что пока вы не платите, вы так говорите… лентяи вы в общем…
как минимум совет дайте, как определить того кому нужна помощь, и он реально готов прилагать усилия что бы решить свой вопрос, а не ждет что все сделают за него, чисто для этого форума это ооочень пригодится мне… как минимум я в такие заказы не полезу, и не буду даже спрашивать о сумме за проект)))

MMM · 23.Февраль.2026 11:51:35

Возвращаясь к теме ветки.
А кто-нибудь пробовал обучать ИИ под свои собственные задачи?
Мне представляется, что наиболее ценным может быть участие ИИ в решении проблем, которые трудно сформулировать формально. Или для которых сложно задать начальные условия в привычном алфавитно-цифровом виде.
Например , при работе с лед матрицами иногда попадаются панели, в которых пиксели идут не по рядам, а сложными зигзами. Чтобы написать для них процедуру вывода, нужно и свой мозг завернуть зигзагом.
Как я себе представляю обучение - показываешь ИИ картинки узора на панели и к ним соответствующий код. Показать так 20-30 разных вариантов - а потом ии сам будет подбирать код по картинке…
Это возможно? Или обучение не так происходит?

andriano · 23.Февраль.2026 18:37:06

Немножечко ковырялся с нейроными сетями. Но нейронов там было немного - не более дюжины. Время обучения на ПК измерялось часами.

ЕвгенийП · 23.Февраль.2026 18:40:40

Во! Это примерно то, я предлагал на Uno замутить. С десяток нейронов, пара часов обучения для простенькой задачи. Зато безо всяких библиотек - всё прямым кодом - отличная возможность пощупать и понять технологию.

andriano · 23.Февраль.2026 18:56:37

Мне кажется, цифры не сходятся.
Веса для нейронов - числа с плавающей точкой.
Если на гигагерцовом+ ПК с FPU обучение занимает 5-10 часов, мне кажется маловероятным, что Ардуина справится с подобной задачей за пару часов.

MMM · 23.Февраль.2026 19:09:31

Зависит от задачи… Петрович, помнится, предлагал научить ИИ отличать четные числа от нечетных…

andriano · 23.Февраль.2026 19:44:15

Думаю, если число в двоичном виде, достаточно одного нейрона.

MMM · 23.Февраль.2026 20:24:53

у меня создалось впечатление, что этот уровень близок к максимуму того, чего может достичь ИИ на УНО

BABOS · 23.Февраль.2026 22:00:02

а вот мне реально интересно на какую задачу обучить нейросеть… что бы была простая
четное нечетное число не подходит

0,0,0,0,0,0,0,1,1
0,0,0,0,0,0,1,0,0
0,0,0,0,0,0,1,1,1
0,0,0,0,0,1,0,0,0
0,0,0,0,0,1,0,1,1
0,0,0,0,0,1,1,0,0
0,0,0,0,0,1,1,1,1
0,0,0,0,1,0,0,0,0
0,0,0,0,1,0,0,1,1
0,0,0,0,1,0,1,0,0
0,0,0,0,1,0,1,1,1
0,0,0,0,1,1,0,0,0
0,0,0,0,1,1,0,1,1
0,0,0,0,1,1,1,0,0
0,0,0,0,1,1,1,1,1
0,0,0,1,0,0,0,0,0
0,0,0,1,0,0,0,1,1
0,0,0,1,0,0,1,0,0
0,0,0,1,0,0,1,1,1
0,0,0,1,0,1,0,0,0
0,0,0,1,0,1,0,1,1
0,0,0,1,0,1,1,0,0
0,0,0,1,0,1,1,1,1
0,0,0,1,1,0,0,0,0
0,0,0,1,1,0,0,1,1
0,0,0,1,1,0,1,0,0
0,0,0,1,1,0,1,1,1
0,0,0,1,1,1,0,0,0
0,0,0,1,1,1,0,1,1
0,0,0,1,1,1,1,0,0
0,0,0,1,1,1,1,1,1
0,0,1,0,0,0,0,0,0
0,0,1,0,0,0,0,1,1
0,0,1,0,0,0,1,0,0
0,0,1,0,0,0,1,1,1
0,0,1,0,0,1,0,0,0
0,0,1,0,0,1,0,1,1
0,0,1,0,0,1,1,0,0
0,0,1,0,0,1,1,1,1
0,0,1,0,1,0,0,0,0
0,0,1,0,1,0,0,1,1
0,0,1,0,1,0,1,0,0
0,0,1,0,1,0,1,1,1
0,0,1,0,1,1,0,0,0
0,0,1,0,1,1,0,1,1
0,0,1,0,1,1,1,0,0
0,0,1,0,1,1,1,1,1
0,0,1,1,0,0,0,0,0
0,0,1,1,0,0,0,1,1
0,0,1,1,0,0,1,0,0
0,0,1,1,0,0,1,1,1
0,0,1,1,0,1,0,0,0
0,0,1,1,0,1,0,1,1
0,0,1,1,0,1,1,0,0
0,0,1,1,0,1,1,1,1
0,0,1,1,1,0,0,0,0
0,0,1,1,1,0,0,1,1
0,0,1,1,1,0,1,0,0
0,0,1,1,1,0,1,1,1
0,0,1,1,1,1,0,0,0
0,0,1,1,1,1,0,1,1
0,0,1,1,1,1,1,0,0
0,0,1,1,1,1,1,1,1
0,1,0,0,0,0,0,0,0
0,1,0,0,0,0,0,1,1
0,1,0,0,0,0,1,0,0
0,1,0,0,0,0,1,1,1
0,1,0,0,0,1,0,0,0
0,1,0,0,0,1,0,1,1
0,1,0,0,0,1,1,0,0
0,1,0,0,0,1,1,1,1
0,1,0,0,1,0,0,0,0
0,1,0,0,1,0,0,1,1
0,1,0,0,1,0,1,0,0
0,1,0,0,1,0,1,1,1
0,1,0,0,1,1,0,0,0
0,1,0,0,1,1,0,1,1
0,1,0,0,1,1,1,0,0
0,1,0,0,1,1,1,1,1
0,1,0,1,0,0,0,0,0
0,1,0,1,0,0,0,1,1
0,1,0,1,0,0,1,0,0
0,1,0,1,0,0,1,1,1
0,1,0,1,0,1,0,0,0
0,1,0,1,0,1,0,1,1
0,1,0,1,0,1,1,0,0
0,1,0,1,0,1,1,1,1
0,1,0,1,1,0,0,0,0
0,1,0,1,1,0,0,1,1
0,1,0,1,1,0,1,0,0
0,1,0,1,1,0,1,1,1
0,1,0,1,1,1,0,0,0
0,1,0,1,1,1,0,1,1
0,1,0,1,1,1,1,0,0
0,1,0,1,1,1,1,1,1
0,1,1,0,0,0,0,0,0
0,1,1,0,0,0,0,1,1
0,1,1,0,0,0,1,0,0
0,1,1,0,0,0,1,1,1
0,1,1,0,0,1,0,0,0
0,1,1,0,0,1,0,1,1
0,1,1,0,0,1,1,0,0
0,1,1,0,0,1,1,1,1
0,1,1,0,1,0,0,0,0
0,1,1,0,1,0,0,1,1
0,1,1,0,1,0,1,0,0
0,1,1,0,1,0,1,1,1
0,1,1,0,1,1,0,0,0
0,1,1,0,1,1,0,1,1
0,1,1,0,1,1,1,0,0
0,1,1,0,1,1,1,1,1
0,1,1,1,0,0,0,0,0
0,1,1,1,0,0,0,1,1
0,1,1,1,0,0,1,0,0
0,1,1,1,0,0,1,1,1
0,1,1,1,0,1,0,0,0
0,1,1,1,0,1,0,1,1
0,1,1,1,0,1,1,0,0
0,1,1,1,0,1,1,1,1
0,1,1,1,1,0,0,0,0
0,1,1,1,1,0,0,1,1
0,1,1,1,1,0,1,0,0
0,1,1,1,1,0,1,1,1
0,1,1,1,1,1,0,0,0
0,1,1,1,1,1,0,1,1
0,1,1,1,1,1,1,0,0
0,1,1,1,1,1,1,1,1
1,0,0,0,0,0,0,0,0
1,0,0,0,0,0,0,1,1
1,0,0,0,0,0,1,0,0
1,0,0,0,0,0,1,1,1
1,0,0,0,0,1,0,0,0
1,0,0,0,0,1,0,1,1
1,0,0,0,0,1,1,0,0
1,0,0,0,0,1,1,1,1
1,0,0,0,1,0,0,0,0
1,0,0,0,1,0,0,1,1
1,0,0,0,1,0,1,0,0
1,0,0,0,1,0,1,1,1
1,0,0,0,1,1,0,0,0
1,0,0,0,1,1,0,1,1
1,0,0,0,1,1,1,0,0
1,0,0,0,1,1,1,1,1
1,0,0,1,0,0,0,0,0
1,0,0,1,0,0,0,1,1
1,0,0,1,0,0,1,0,0
1,0,0,1,0,0,1,1,1
1,0,0,1,0,1,0,0,0
1,0,0,1,0,1,0,1,1
1,0,0,1,0,1,1,0,0
1,0,0,1,0,1,1,1,1
1,0,0,1,1,0,0,0,0
1,0,0,1,1,0,0,1,1
1,0,0,1,1,0,1,0,0
1,0,0,1,1,0,1,1,1
1,0,0,1,1,1,0,0,0
1,0,0,1,1,1,0,1,1
1,0,0,1,1,1,1,0,0
1,0,0,1,1,1,1,1,1
1,0,1,0,0,0,0,0,0
1,0,1,0,0,0,0,1,1
1,0,1,0,0,0,1,0,0
1,0,1,0,0,0,1,1,1
1,0,1,0,0,1,0,0,0
1,0,1,0,0,1,0,1,1
1,0,1,0,0,1,1,0,0
1,0,1,0,0,1,1,1,1
1,0,1,0,1,0,0,0,0
1,0,1,0,1,0,0,1,1
1,0,1,0,1,0,1,0,0
1,0,1,0,1,0,1,1,1
1,0,1,0,1,1,0,0,0
1,0,1,0,1,1,0,1,1
1,0,1,0,1,1,1,0,0
1,0,1,0,1,1,1,1,1
1,0,1,1,0,0,0,0,0
1,0,1,1,0,0,0,1,1
1,0,1,1,0,0,1,0,0
1,0,1,1,0,0,1,1,1
1,0,1,1,0,1,0,0,0
1,0,1,1,0,1,0,1,1
1,0,1,1,0,1,1,0,0
1,0,1,1,0,1,1,1,1
1,0,1,1,1,0,0,0,0
1,0,1,1,1,0,0,1,1
1,0,1,1,1,0,1,0,0
1,0,1,1,1,0,1,1,1
1,0,1,1,1,1,0,0,0
1,0,1,1,1,1,0,1,1
1,0,1,1,1,1,1,0,0
1,0,1,1,1,1,1,1,1
1,1,0,0,0,0,0,0,0
1,1,0,0,0,0,0,1,1
1,1,0,0,0,0,1,0,0
1,1,0,0,0,0,1,1,1
1,1,0,0,0,1,0,0,0
1,1,0,0,0,1,0,1,1
1,1,0,0,0,1,1,0,0
1,1,0,0,0,1,1,1,1
1,1,0,0,1,0,0,0,0
1,1,0,0,1,0,0,1,1
1,1,0,0,1,0,1,0,0
1,1,0,0,1,0,1,1,1
1,1,0,0,1,1,0,0,0
1,1,0,0,1,1,0,1,1
1,1,0,0,1,1,1,0,0
1,1,0,0,1,1,1,1,1
1,1,0,1,0,0,0,0,0
1,1,0,1,0,0,0,1,1
1,1,0,1,0,0,1,0,0
1,1,0,1,0,0,1,1,1
1,1,0,1,0,1,0,0,0
1,1,0,1,0,1,0,1,1
1,1,0,1,0,1,1,0,0
1,1,0,1,0,1,1,1,1
1,1,0,1,1,0,0,0,0
1,1,0,1,1,0,0,1,1
1,1,0,1,1,0,1,0,0
1,1,0,1,1,0,1,1,1
1,1,0,1,1,1,0,0,0
1,1,0,1,1,1,0,1,1
1,1,0,1,1,1,1,0,0
1,1,0,1,1,1,1,1,1
1,1,1,0,0,0,0,0,0
1,1,1,0,0,0,0,1,1
1,1,1,0,0,0,1,0,0
1,1,1,0,0,0,1,1,1
1,1,1,0,0,1,0,0,0
1,1,1,0,0,1,0,1,1
1,1,1,0,0,1,1,0,0
1,1,1,0,0,1,1,1,1
1,1,1,0,1,0,0,0,0
1,1,1,0,1,0,0,1,1
1,1,1,0,1,0,1,0,0
1,1,1,0,1,0,1,1,1
1,1,1,0,1,1,0,0,0
1,1,1,0,1,1,0,1,1
1,1,1,0,1,1,1,0,0
1,1,1,0,1,1,1,1,1
1,1,1,1,0,0,0,0,0
1,1,1,1,0,0,0,1,1
1,1,1,1,0,0,1,0,0
1,1,1,1,0,0,1,1,1
1,1,1,1,0,1,0,0,0
1,1,1,1,0,1,0,1,1
1,1,1,1,0,1,1,0,0
1,1,1,1,0,1,1,1,1
1,1,1,1,1,0,0,0,0
1,1,1,1,1,0,0,1,1
1,1,1,1,1,0,1,0,0
1,1,1,1,1,0,1,1,1
1,1,1,1,1,1,0,0,0
1,1,1,1,1,1,0,1,1
1,1,1,1,1,1,1,0,0
1,1,1,1,1,1,1,1,1

первые 8 цифр биты, последний правильный ответ, для определения четности достаточно 1го нейрона входного и выходного(просто берем последнюю цифру байта)
пришел 0 вышел 0…

#include <EEPROM.h>

// Структура нейросети
#define INPUT_NODES 8
#define HIDDEN_NODES 16
#define OUTPUT_NODES 1

// Параметры обучения
#define LEARNING_RATE 0.3
#define MOMENTUM 0.8

// Адреса EEPROM
#define EEPROM_START_HIDDEN 0
#define EEPROM_MAGIC_ADDR 1020

// Пины
#define LED_PIN 13

// ============================================================
// ==== ВАША ПОЛНАЯ ВЫБОРКА ДЛЯ ОБУЧЕНИЯ (255 примеров) ======
// ============================================================
// Первые 8 чисел - вход, последнее - правильный выход (0 или 1)
const byte trainingData[255][9] PROGMEM = {
  {0,0,0,0,0,0,0,1,1},  // 1 - нечетное
  {0,0,0,0,0,0,1,0,0},  // 2 - четное
  {0,0,0,0,0,0,1,1,1},  // 3 - нечетное
  {0,0,0,0,0,1,0,0,0},  // 4 - четное
  {0,0,0,0,0,1,0,1,1},  // 5 - нечетное
  {0,0,0,0,0,1,1,0,0},  // 6 - четное
  {0,0,0,0,0,1,1,1,1},  // 7 - нечетное
  {0,0,0,0,1,0,0,0,0},  // 8 - четное
  {0,0,0,0,1,0,0,1,1},  // 9 - нечетное
  {0,0,0,0,1,0,1,0,0},  // 10 - четное
  {0,0,0,0,1,0,1,1,1},  // 11 - нечетное
  {0,0,0,0,1,1,0,0,0},  // 12 - четное
  {0,0,0,0,1,1,0,1,1},  // 13 - нечетное
  {0,0,0,0,1,1,1,0,0},  // 14 - четное
  {0,0,0,0,1,1,1,1,1},  // 15 - нечетное
  {0,0,0,1,0,0,0,0,0},  // 16 - четное
  {0,0,0,1,0,0,0,1,1},  // 17 - нечетное
  {0,0,0,1,0,0,1,0,0},  // 18 - четное
  {0,0,0,1,0,0,1,1,1},  // 19 - нечетное
  {0,0,0,1,0,1,0,0,0},  // 20 - четное
  {0,0,0,1,0,1,0,1,1},  // 21 - нечетное
  {0,0,0,1,0,1,1,0,0},  // 22 - четное
  {0,0,0,1,0,1,1,1,1},  // 23 - нечетное
  {0,0,0,1,1,0,0,0,0},  // 24 - четное
  {0,0,0,1,1,0,0,1,1},  // 25 - нечетное
  {0,0,0,1,1,0,1,0,0},  // 26 - четное
  {0,0,0,1,1,0,1,1,1},  // 27 - нечетное
  {0,0,0,1,1,1,0,0,0},  // 28 - четное
  {0,0,0,1,1,1,0,1,1},  // 29 - нечетное
  {0,0,0,1,1,1,1,0,0},  // 30 - четное
  {0,0,0,1,1,1,1,1,1},  // 31 - нечетное
  {0,0,1,0,0,0,0,0,0},  // 32 - четное
  {0,0,1,0,0,0,0,1,1},  // 33 - нечетное
  {0,0,1,0,0,0,1,0,0},  // 34 - четное
  {0,0,1,0,0,0,1,1,1},  // 35 - нечетное
  {0,0,1,0,0,1,0,0,0},  // 36 - четное
  {0,0,1,0,0,1,0,1,1},  // 37 - нечетное
  {0,0,1,0,0,1,1,0,0},  // 38 - четное
  {0,0,1,0,0,1,1,1,1},  // 39 - нечетное
  {0,0,1,0,1,0,0,0,0},  // 40 - четное
  {0,0,1,0,1,0,0,1,1},  // 41 - нечетное
  {0,0,1,0,1,0,1,0,0},  // 42 - четное
  {0,0,1,0,1,0,1,1,1},  // 43 - нечетное
  {0,0,1,0,1,1,0,0,0},  // 44 - четное
  {0,0,1,0,1,1,0,1,1},  // 45 - нечетное
  {0,0,1,0,1,1,1,0,0},  // 46 - четное
  {0,0,1,0,1,1,1,1,1},  // 47 - нечетное
  {0,0,1,1,0,0,0,0,0},  // 48 - четное
  {0,0,1,1,0,0,0,1,1},  // 49 - нечетное
  {0,0,1,1,0,0,1,0,0},  // 50 - четное
  {0,0,1,1,0,0,1,1,1},  // 51 - нечетное
  {0,0,1,1,0,1,0,0,0},  // 52 - четное
  {0,0,1,1,0,1,0,1,1},  // 53 - нечетное
  {0,0,1,1,0,1,1,0,0},  // 54 - четное
  {0,0,1,1,0,1,1,1,1},  // 55 - нечетное
  {0,0,1,1,1,0,0,0,0},  // 56 - четное
  {0,0,1,1,1,0,0,1,1},  // 57 - нечетное
  {0,0,1,1,1,0,1,0,0},  // 58 - четное
  {0,0,1,1,1,0,1,1,1},  // 59 - нечетное
  {0,0,1,1,1,1,0,0,0},  // 60 - четное
  {0,0,1,1,1,1,0,1,1},  // 61 - нечетное
  {0,0,1,1,1,1,1,0,0},  // 62 - четное
  {0,0,1,1,1,1,1,1,1},  // 63 - нечетное
  {0,1,0,0,0,0,0,0,0},  // 64 - четное
  {0,1,0,0,0,0,0,1,1},  // 65 - нечетное
  {0,1,0,0,0,0,1,0,0},  // 66 - четное
  {0,1,0,0,0,0,1,1,1},  // 67 - нечетное
  {0,1,0,0,0,1,0,0,0},  // 68 - четное
  {0,1,0,0,0,1,0,1,1},  // 69 - нечетное
  {0,1,0,0,0,1,1,0,0},  // 70 - четное
  {0,1,0,0,0,1,1,1,1},  // 71 - нечетное
  {0,1,0,0,1,0,0,0,0},  // 72 - четное
  {0,1,0,0,1,0,0,1,1},  // 73 - нечетное
  {0,1,0,0,1,0,1,0,0},  // 74 - четное
  {0,1,0,0,1,0,1,1,1},  // 75 - нечетное
  {0,1,0,0,1,1,0,0,0},  // 76 - четное
  {0,1,0,0,1,1,0,1,1},  // 77 - нечетное
  {0,1,0,0,1,1,1,0,0},  // 78 - четное
  {0,1,0,0,1,1,1,1,1},  // 79 - нечетное
  {0,1,0,1,0,0,0,0,0},  // 80 - четное
  {0,1,0,1,0,0,0,1,1},  // 81 - нечетное
  {0,1,0,1,0,0,1,0,0},  // 82 - четное
  {0,1,0,1,0,0,1,1,1},  // 83 - нечетное
  {0,1,0,1,0,1,0,0,0},  // 84 - четное
  {0,1,0,1,0,1,0,1,1},  // 85 - нечетное
  {0,1,0,1,0,1,1,0,0},  // 86 - четное
  {0,1,0,1,0,1,1,1,1},  // 87 - нечетное
  {0,1,0,1,1,0,0,0,0},  // 88 - четное
  {0,1,0,1,1,0,0,1,1},  // 89 - нечетное
  {0,1,0,1,1,0,1,0,0},  // 90 - четное
  {0,1,0,1,1,0,1,1,1},  // 91 - нечетное
  {0,1,0,1,1,1,0,0,0},  // 92 - четное
  {0,1,0,1,1,1,0,1,1},  // 93 - нечетное
  {0,1,0,1,1,1,1,0,0},  // 94 - четное
  {0,1,0,1,1,1,1,1,1},  // 95 - нечетное
  {0,1,1,0,0,0,0,0,0},  // 96 - четное
  {0,1,1,0,0,0,0,1,1},  // 97 - нечетное
  {0,1,1,0,0,0,1,0,0},  // 98 - четное
  {0,1,1,0,0,0,1,1,1},  // 99 - нечетное
  {0,1,1,0,0,1,0,0,0},  // 100 - четное
  {0,1,1,0,0,1,0,1,1},  // 101 - нечетное
  {0,1,1,0,0,1,1,0,0},  // 102 - четное
  {0,1,1,0,0,1,1,1,1},  // 103 - нечетное
  {0,1,1,0,1,0,0,0,0},  // 104 - четное
  {0,1,1,0,1,0,0,1,1},  // 105 - нечетное
  {0,1,1,0,1,0,1,0,0},  // 106 - четное
  {0,1,1,0,1,0,1,1,1},  // 107 - нечетное
  {0,1,1,0,1,1,0,0,0},  // 108 - четное
  {0,1,1,0,1,1,0,1,1},  // 109 - нечетное
  {0,1,1,0,1,1,1,0,0},  // 110 - четное
  {0,1,1,0,1,1,1,1,1},  // 111 - нечетное
  {0,1,1,1,0,0,0,0,0},  // 112 - четное
  {0,1,1,1,0,0,0,1,1},  // 113 - нечетное
  {0,1,1,1,0,0,1,0,0},  // 114 - четное
  {0,1,1,1,0,0,1,1,1},  // 115 - нечетное
  {0,1,1,1,0,1,0,0,0},  // 116 - четное
  {0,1,1,1,0,1,0,1,1},  // 117 - нечетное
  {0,1,1,1,0,1,1,0,0},  // 118 - четное
  {0,1,1,1,0,1,1,1,1},  // 119 - нечетное
  {0,1,1,1,1,0,0,0,0},  // 120 - четное
  {0,1,1,1,1,0,0,1,1},  // 121 - нечетное
  {0,1,1,1,1,0,1,0,0},  // 122 - четное
  {0,1,1,1,1,0,1,1,1},  // 123 - нечетное
  {0,1,1,1,1,1,0,0,0},  // 124 - четное
  {0,1,1,1,1,1,0,1,1},  // 125 - нечетное
  {0,1,1,1,1,1,1,0,0},  // 126 - четное
  {0,1,1,1,1,1,1,1,1},  // 127 - нечетное
  {1,0,0,0,0,0,0,0,0},  // 128 - четное
  {1,0,0,0,0,0,0,1,1},  // 129 - нечетное
  {1,0,0,0,0,0,1,0,0},  // 130 - четное
  {1,0,0,0,0,0,1,1,1},  // 131 - нечетное
  {1,0,0,0,0,1,0,0,0},  // 132 - четное
  {1,0,0,0,0,1,0,1,1},  // 133 - нечетное
  {1,0,0,0,0,1,1,0,0},  // 134 - четное
  {1,0,0,0,0,1,1,1,1},  // 135 - нечетное
  {1,0,0,0,1,0,0,0,0},  // 136 - четное
  {1,0,0,0,1,0,0,1,1},  // 137 - нечетное
  {1,0,0,0,1,0,1,0,0},  // 138 - четное
  {1,0,0,0,1,0,1,1,1},  // 139 - нечетное
  {1,0,0,0,1,1,0,0,0},  // 140 - четное
  {1,0,0,0,1,1,0,1,1},  // 141 - нечетное
  {1,0,0,0,1,1,1,0,0},  // 142 - четное
  {1,0,0,0,1,1,1,1,1},  // 143 - нечетное
  {1,0,0,1,0,0,0,0,0},  // 144 - четное
  {1,0,0,1,0,0,0,1,1},  // 145 - нечетное
  {1,0,0,1,0,0,1,0,0},  // 146 - четное
  {1,0,0,1,0,0,1,1,1},  // 147 - нечетное
  {1,0,0,1,0,1,0,0,0},  // 148 - четное
  {1,0,0,1,0,1,0,1,1},  // 149 - нечетное
  {1,0,0,1,0,1,1,0,0},  // 150 - четное
  {1,0,0,1,0,1,1,1,1},  // 151 - нечетное
  {1,0,0,1,1,0,0,0,0},  // 152 - четное
  {1,0,0,1,1,0,0,1,1},  // 153 - нечетное
  {1,0,0,1,1,0,1,0,0},  // 154 - четное
  {1,0,0,1,1,0,1,1,1},  // 155 - нечетное
  {1,0,0,1,1,1,0,0,0},  // 156 - четное
  {1,0,0,1,1,1,0,1,1},  // 157 - нечетное
  {1,0,0,1,1,1,1,0,0},  // 158 - четное
  {1,0,0,1,1,1,1,1,1},  // 159 - нечетное
  {1,0,1,0,0,0,0,0,0},  // 160 - четное
  {1,0,1,0,0,0,0,1,1},  // 161 - нечетное
  {1,0,1,0,0,0,1,0,0},  // 162 - четное
  {1,0,1,0,0,0,1,1,1},  // 163 - нечетное
  {1,0,1,0,0,1,0,0,0},  // 164 - четное
  {1,0,1,0,0,1,0,1,1},  // 165 - нечетное
  {1,0,1,0,0,1,1,0,0},  // 166 - четное
  {1,0,1,0,0,1,1,1,1},  // 167 - нечетное
  {1,0,1,0,1,0,0,0,0},  // 168 - четное
  {1,0,1,0,1,0,0,1,1},  // 169 - нечетное
  {1,0,1,0,1,0,1,0,0},  // 170 - четное
  {1,0,1,0,1,0,1,1,1},  // 171 - нечетное
  {1,0,1,0,1,1,0,0,0},  // 172 - четное
  {1,0,1,0,1,1,0,1,1},  // 173 - нечетное
  {1,0,1,0,1,1,1,0,0},  // 174 - четное
  {1,0,1,0,1,1,1,1,1},  // 175 - нечетное
  {1,0,1,1,0,0,0,0,0},  // 176 - четное
  {1,0,1,1,0,0,0,1,1},  // 177 - нечетное
  {1,0,1,1,0,0,1,0,0},  // 178 - четное
  {1,0,1,1,0,0,1,1,1},  // 179 - нечетное
  {1,0,1,1,0,1,0,0,0},  // 180 - четное
  {1,0,1,1,0,1,0,1,1},  // 181 - нечетное
  {1,0,1,1,0,1,1,0,0},  // 182 - четное
  {1,0,1,1,0,1,1,1,1},  // 183 - нечетное
  {1,0,1,1,1,0,0,0,0},  // 184 - четное
  {1,0,1,1,1,0,0,1,1},  // 185 - нечетное
  {1,0,1,1,1,0,1,0,0},  // 186 - четное
  {1,0,1,1,1,0,1,1,1},  // 187 - нечетное
  {1,0,1,1,1,1,0,0,0},  // 188 - четное
  {1,0,1,1,1,1,0,1,1},  // 189 - нечетное
  {1,0,1,1,1,1,1,0,0},  // 190 - четное
  {1,0,1,1,1,1,1,1,1},  // 191 - нечетное
  {1,1,0,0,0,0,0,0,0},  // 192 - четное
  {1,1,0,0,0,0,0,1,1},  // 193 - нечетное
  {1,1,0,0,0,0,1,0,0},  // 194 - четное
  {1,1,0,0,0,0,1,1,1},  // 195 - нечетное
  {1,1,0,0,0,1,0,0,0},  // 196 - четное
  {1,1,0,0,0,1,0,1,1},  // 197 - нечетное
  {1,1,0,0,0,1,1,0,0},  // 198 - четное
  {1,1,0,0,0,1,1,1,1},  // 199 - нечетное
  {1,1,0,0,1,0,0,0,0},  // 200 - четное
  {1,1,0,0,1,0,0,1,1},  // 201 - нечетное
  {1,1,0,0,1,0,1,0,0},  // 202 - четное
  {1,1,0,0,1,0,1,1,1},  // 203 - нечетное
  {1,1,0,0,1,1,0,0,0},  // 204 - четное
  {1,1,0,0,1,1,0,1,1},  // 205 - нечетное
  {1,1,0,0,1,1,1,0,0},  // 206 - четное
  {1,1,0,0,1,1,1,1,1},  // 207 - нечетное
  {1,1,0,1,0,0,0,0,0},  // 208 - четное
  {1,1,0,1,0,0,0,1,1},  // 209 - нечетное
  {1,1,0,1,0,0,1,0,0},  // 210 - четное
  {1,1,0,1,0,0,1,1,1},  // 211 - нечетное
  {1,1,0,1,0,1,0,0,0},  // 212 - четное
  {1,1,0,1,0,1,0,1,1},  // 213 - нечетное
  {1,1,0,1,0,1,1,0,0},  // 214 - четное
  {1,1,0,1,0,1,1,1,1},  // 215 - нечетное
  {1,1,0,1,1,0,0,0,0},  // 216 - четное
  {1,1,0,1,1,0,0,1,1},  // 217 - нечетное
  {1,1,0,1,1,0,1,0,0},  // 218 - четное
  {1,1,0,1,1,0,1,1,1},  // 219 - нечетное
  {1,1,0,1,1,1,0,0,0},  // 220 - четное
  {1,1,0,1,1,1,0,1,1},  // 221 - нечетное
  {1,1,0,1,1,1,1,0,0},  // 222 - четное
  {1,1,0,1,1,1,1,1,1},  // 223 - нечетное
  {1,1,1,0,0,0,0,0,0},  // 224 - четное
  {1,1,1,0,0,0,0,1,1},  // 225 - нечетное
  {1,1,1,0,0,0,1,0,0},  // 226 - четное
  {1,1,1,0,0,0,1,1,1},  // 227 - нечетное
  {1,1,1,0,0,1,0,0,0},  // 228 - четное
  {1,1,1,0,0,1,0,1,1},  // 229 - нечетное
  {1,1,1,0,0,1,1,0,0},  // 230 - четное
  {1,1,1,0,0,1,1,1,1},  // 231 - нечетное
  {1,1,1,0,1,0,0,0,0},  // 232 - четное
  {1,1,1,0,1,0,0,1,1},  // 233 - нечетное
  {1,1,1,0,1,0,1,0,0},  // 234 - четное
  {1,1,1,0,1,0,1,1,1},  // 235 - нечетное
  {1,1,1,0,1,1,0,0,0},  // 236 - четное
  {1,1,1,0,1,1,0,1,1},  // 237 - нечетное
  {1,1,1,0,1,1,1,0,0},  // 238 - четное
  {1,1,1,0,1,1,1,1,1},  // 239 - нечетное
  {1,1,1,1,0,0,0,0,0},  // 240 - четное
  {1,1,1,1,0,0,0,1,1},  // 241 - нечетное
  {1,1,1,1,0,0,1,0,0},  // 242 - четное
  {1,1,1,1,0,0,1,1,1},  // 243 - нечетное
  {1,1,1,1,0,1,0,0,0},  // 244 - четное
  {1,1,1,1,0,1,0,1,1},  // 245 - нечетное
  {1,1,1,1,0,1,1,0,0},  // 246 - четное
  {1,1,1,1,0,1,1,1,1},  // 247 - нечетное
  {1,1,1,1,1,0,0,0,0},  // 248 - четное
  {1,1,1,1,1,0,0,1,1},  // 249 - нечетное
  {1,1,1,1,1,0,1,0,0},  // 250 - четное
  {1,1,1,1,1,0,1,1,1},  // 251 - нечетное
  {1,1,1,1,1,1,0,0,0},  // 252 - четное
  {1,1,1,1,1,1,0,1,1},  // 253 - нечетное
  {1,1,1,1,1,1,1,0,0},  // 254 - четное
  {1,1,1,1,1,1,1,1,1}   // 255 - нечетное
};
// ============================================================

// Веса сети
float hiddenWeights[INPUT_NODES][HIDDEN_NODES];
float outputWeights[HIDDEN_NODES][OUTPUT_NODES];
float hiddenBias[HIDDEN_NODES];
float outputBias[OUTPUT_NODES];

// Для момента
float hiddenDeltaWeights[INPUT_NODES][HIDDEN_NODES];
float outputDeltaWeights[HIDDEN_NODES][OUTPUT_NODES];
float hiddenDeltaBias[HIDDEN_NODES];
float outputDeltaBias[OUTPUT_NODES];

bool isTraining = false;
bool stopTraining = false;
unsigned long lastSaveTime = 0;
const unsigned long saveInterval = 600000;

float inputs[INPUT_NODES];

void getExample(int index, float* input, float* target) {
  byte example[9];
  for (int i = 0; i < 9; i++) {
    example[i] = pgm_read_byte(&trainingData[index][i]);
  }
  for (int i = 0; i < INPUT_NODES; i++) {
    input[i] = example[i];
  }
  *target = example[8];
}

float sigmoid(float x) {
  if (x < -10.0) return 0.0;
  if (x > 10.0) return 1.0;
  return 1.0 / (1.0 + exp(-x));
}

float sigmoidDerivative(float x) {
  return x * (1.0 - x);
}

void forwardPass(float* hiddenOutput, float* finalOutput) {
  for (int j = 0; j < HIDDEN_NODES; j++) {
    float sum = hiddenBias[j];
    for (int i = 0; i < INPUT_NODES; i++) {
      sum += inputs[i] * hiddenWeights[i][j];
    }
    hiddenOutput[j] = sigmoid(sum);
  }
  
  float sum = outputBias[0];
  for (int j = 0; j < HIDDEN_NODES; j++) {
    sum += hiddenOutput[j] * outputWeights[j][0];
  }
  finalOutput[0] = sigmoid(sum);
}

void trainEpoch(int exampleIndex) {
  float target;
  getExample(exampleIndex, inputs, &target);
  
  float hiddenOutput[HIDDEN_NODES];
  float finalOutput[OUTPUT_NODES];
  forwardPass(hiddenOutput, finalOutput);
  
  float outputError = target - finalOutput[0];
  float outputDelta = outputError * sigmoidDerivative(finalOutput[0]);
  
  float hiddenDelta[HIDDEN_NODES];
  for (int j = 0; j < HIDDEN_NODES; j++) {
    float hiddenError = outputDelta * outputWeights[j][0];
    hiddenDelta[j] = hiddenError * sigmoidDerivative(hiddenOutput[j]);
  }
  
  for (int j = 0; j < HIDDEN_NODES; j++) {
    float delta = LEARNING_RATE * outputDelta * hiddenOutput[j];
    outputDeltaWeights[j][0] = MOMENTUM * outputDeltaWeights[j][0] + delta;
    outputWeights[j][0] += outputDeltaWeights[j][0];
  }
  
  outputDeltaBias[0] = MOMENTUM * outputDeltaBias[0] + LEARNING_RATE * outputDelta;
  outputBias[0] += outputDeltaBias[0];
  
  for (int i = 0; i < INPUT_NODES; i++) {
    for (int j = 0; j < HIDDEN_NODES; j++) {
      float delta = LEARNING_RATE * hiddenDelta[j] * inputs[i];
      hiddenDeltaWeights[i][j] = MOMENTUM * hiddenDeltaWeights[i][j] + delta;
      hiddenWeights[i][j] += hiddenDeltaWeights[i][j];
    }
  }
  
  for (int j = 0; j < HIDDEN_NODES; j++) {
    float delta = LEARNING_RATE * hiddenDelta[j];
    hiddenDeltaBias[j] = MOMENTUM * hiddenDeltaBias[j] + delta;
    hiddenBias[j] += hiddenDeltaBias[j];
  }
}

void initializeWeights() {
  for (int i = 0; i < INPUT_NODES; i++) {
    for (int j = 0; j < HIDDEN_NODES; j++) {
      hiddenWeights[i][j] = random(-1000, 1001) / 1000.0;
      hiddenDeltaWeights[i][j] = 0;
    }
  }
  
  for (int j = 0; j < HIDDEN_NODES; j++) {
    hiddenBias[j] = random(-1000, 1001) / 1000.0;
    hiddenDeltaBias[j] = 0;
  }
  
  for (int j = 0; j < HIDDEN_NODES; j++) {
    outputWeights[j][0] = random(-1000, 1001) / 1000.0;
    outputDeltaWeights[j][0] = 0;
  }
  
  outputBias[0] = random(-1000, 1001) / 1000.0;
  outputDeltaBias[0] = 0;
}

void printWeightsForExport() {
  Serial.println(F("\n=== ВЕСА ДЛЯ ВСТАВКИ В КОД ===\n"));
  
  Serial.println(F("float hiddenWeights[INPUT_NODES][HIDDEN_NODES] = {"));
  for (int i = 0; i < INPUT_NODES; i++) {
    Serial.print(F("  {"));
    for (int j = 0; j < HIDDEN_NODES; j++) {
      Serial.print(hiddenWeights[i][j], 6);
      if (j < HIDDEN_NODES - 1) Serial.print(F(", "));
    }
    Serial.println(F("},"));
  }
  Serial.println(F("};"));
  
  Serial.println(F("\nfloat hiddenBias[HIDDEN_NODES] = {"));
  Serial.print(F("  "));
  for (int j = 0; j < HIDDEN_NODES; j++) {
    Serial.print(hiddenBias[j], 6);
    if (j < HIDDEN_NODES - 1) Serial.print(F(", "));
  }
  Serial.println(F("\n};"));
  
  Serial.println(F("\nfloat outputWeights[HIDDEN_NODES][OUTPUT_NODES] = {"));
  for (int j = 0; j < HIDDEN_NODES; j++) {
    Serial.print(F("  {"));
    Serial.print(outputWeights[j][0], 6);
    Serial.println(F("},"));
  }
  Serial.println(F("};"));
  
  Serial.println(F("\nfloat outputBias[OUTPUT_NODES] = {"));
  Serial.print(F("  "));
  Serial.print(outputBias[0], 6);
  Serial.println(F("\n};"));
}

void setup() {
  Serial.begin(9600);
  pinMode(LED_PIN, OUTPUT);
  randomSeed(analogRead(0));
  
  Serial.println(F("=== НЕЙРОСЕТЬ С ВАШЕЙ ВЫБОРКОЙ ==="));
  Serial.println(F("Команды:"));
  Serial.println(F("1 - Начать обучение"));
  Serial.println(F("2 - Проверить число (введите 8 бит)"));
  Serial.println(F("3 - Остановить обучение"));
  Serial.println(F("5 - Сбросить веса случайно"));
  Serial.println(F("7 - Экспортировать веса"));
  
  initializeWeights();
}

void loop() {
  if (Serial.available() > 0) {
    char command = Serial.read();
    while (Serial.available() > 0) Serial.read();
    
    switch (command) {
      case '1':
        isTraining = true;
        stopTraining = false;
        Serial.println(F("Обучение начато"));
        break;
      case '2':
        Serial.println(F("Введите 8 бит (0 или 1) через запятую:"));
        waitForInput();
        break;
      case '3':
        isTraining = false;
        stopTraining = true;
        Serial.println(F("Обучение остановлено"));
        break;
      case '5':
        initializeWeights();
        Serial.println(F("Веса сброшены случайно"));
        break;
      case '7':
        printWeightsForExport();
        break;
    }
  }
  
  if (isTraining && !stopTraining) {
    static int epoch = 0;
    static float totalError = 0;
    static int correct = 0;
    
    for (int e = 0; e < 10; e++) {  // 10 эпох за цикл
      for (int ex = 0; ex < 255; ex++) {
        trainEpoch(ex);
        
        float target;
        getExample(ex, inputs, &target);
        
        float hidden[HIDDEN_NODES];
        float out[1];
        forwardPass(hidden, out);
        
        totalError += pow(target - out[0], 2);
        if ((out[0] > 0.5 && target > 0.5) || (out[0] <= 0.5 && target <= 0.5)) {
          correct++;
        }
      }
    }
    
    epoch += 10;
    float avgError = totalError / (255 * 10);
    float accuracy = (float)correct / (255 * 10) * 100;
    
    Serial.print(F("Эпоха "));
    Serial.print(epoch);
    Serial.print(F(" | Ошибка: "));
    Serial.print(avgError, 6);
    Serial.print(F(" | Точность: "));
    Serial.print(accuracy, 2);
    Serial.println(F("%"));
    
    totalError = 0;
    correct = 0;
  }
}

void waitForInput() {
  String s = Serial.readStringUntil('\n');
  s.replace(',', ' ');
  
  float in[8];
  int idx = 0;
  int pos = 0;
  
  while (pos < s.length() && idx < 8) {
    int next = s.indexOf(' ', pos);
    if (next == -1) next = s.length();
    String val = s.substring(pos, next);
    val.trim();
    if (val.length() > 0) {
      in[idx++] = val.toInt();
    }
    pos = next + 1;
  }
  
  if (idx == 8) {
    for (int i = 0; i < 8; i++) inputs[i] = in[i];
    
    float hidden[HIDDEN_NODES];
    float out[1];
    forwardPass(hidden, out);
    
    Serial.print(F("Результат: "));
    Serial.println(out[0], 6);
    Serial.print(F("Это "));
    Serial.println(out[0] > 0.5 ? F("НЕЧЕТНОЕ (1)") : F("ЧЕТНОЕ (0)"));
  }
}

не факт что точное обучение… но с результатом вроде справилась))) вся выборка от обучения в коде и вставляется во второй скетч

// === РЕАЛЬНАЯ НЕЙРОСЕТЬ - ТОЛЬКО ПРОВЕРКА ===
// Вход: 8 бит (0 или 1) через запятую
// Выход: 0 (четное) или 1 (нечетное)

#define INPUT_NODES 8
#define HIDDEN_NODES 16
#define OUTPUT_NODES 1

// ==== ВСТАВЬ СВОИ ВЕСА СЮДА ====
float hiddenWeights[INPUT_NODES][HIDDEN_NODES] = {
  {-0.079066, -0.128745, -0.059653, 0.219035, 0.635150, 0.873139, -0.416879, -0.577560, 0.093488, -0.132049, 0.628492, 0.324989, 0.194184, -0.212656, -0.090484, 0.031422},
  {0.060806, -0.845425, -0.984292, 0.077687, 0.484351, -0.227241, 0.025188, 0.536575, 0.556735, 0.697163, -0.183019, 0.066549, 0.006144, 0.087376, 0.326479, 0.383525},
  {-0.497572, 0.208114, 0.718468, 0.609836, 0.084572, 0.603344, -0.112477, -0.385311, -0.952223, 0.411079, 0.214491, -0.405669, -0.166514, 0.417015, 0.395363, -0.439511},
  {-0.171603, 0.837536, -0.428455, -0.355473, -0.103834, -0.101161, 0.640123, -0.256922, -0.008670, -0.911507, -0.092966, -0.421727, -0.038180, 0.327279, -0.172622, 0.461865},
  {0.054024, -0.925128, -0.916711, 0.710920, -0.687938, 0.052202, 0.006793, -0.634173, 0.303689, -0.493394, 0.704852, 0.216253, 0.464473, -0.373576, 0.473273, -0.366538},
  {-0.648462, 0.631290, -0.096389, -0.587167, -0.746711, -0.238981, -0.101485, 0.656049, -0.894495, 0.560862, -0.318196, 0.710082, 0.207933, -0.344575, -0.646906, 0.590064},
  {0.342330, -0.467952, 0.915510, 0.065178, -0.103180, -0.547635, 0.570283, 0.061194, 0.049412, -0.494564, 0.079469, 0.519857, 0.152200, -0.617362, -0.948529, -0.594272},
  {2.806570, 1.199393, 0.505881, -2.234177, 0.748218, -2.189036, -1.599135, -0.488723, -0.903610, 0.805526, 0.550783, -2.282485, 2.130741, -2.403615, 2.325599, -0.553650},
};

float hiddenBias[HIDDEN_NODES] = {
  -0.596652, 0.431086, 0.078338, 0.326854, -0.481705, 0.407725, 0.160618, 0.935494, -0.369142, 0.593631, -0.018048, 0.176030, -1.171841, 1.234631, -0.329655, -0.713135
};

float outputWeights[HIDDEN_NODES][OUTPUT_NODES] = {
  {3.003768},
  {1.238738},
  {0.322690},
  {-2.498591},
  {0.794029},
  {-2.441890},
  {-1.811235},
  {-0.760803},
  {-0.936194},
  {0.888986},
  {0.506985},
  {-2.402586},
  {2.214101},
  {-2.618792},
  {2.346160},
  {-0.496051},
};

float outputBias[OUTPUT_NODES] = {
  -0.643683
};
// ==== КОНЕЦ ВСТАВКИ ====

float inputs[INPUT_NODES];

// Сигмоида с защитой от переполнения
float sigmoid(float x) {
  if (x < -15.0) return 0.0;
  if (x > 15.0) return 1.0;
  return 1.0 / (1.0 + exp(-x));
}

// Прямой проход - РЕАЛЬНЫЕ ВЫЧИСЛЕНИЯ
float forwardPass() {
  float hidden[HIDDEN_NODES];
  
  // Скрытый слой
  for (int j = 0; j < HIDDEN_NODES; j++) {
    float sum = hiddenBias[j];
    for (int i = 0; i < INPUT_NODES; i++) {
      sum += inputs[i] * hiddenWeights[i][j];
    }
    hidden[j] = sigmoid(sum);
    
    // Отладка - раскомментируй для проверки скрытого слоя
    // Serial.print("H"); Serial.print(j); Serial.print("="); Serial.println(hidden[j], 4);
  }
  
  // Выходной слой
  float sum = outputBias[0];
  for (int j = 0; j < HIDDEN_NODES; j++) {
    sum += hidden[j] * outputWeights[j][0];
  }
  
  return sigmoid(sum);
}

void setup() {
  Serial.begin(9600);
  Serial.println(F("==================================="));
  Serial.println(F("РЕАЛЬНАЯ НЕЙРОСЕТЬ - ПРОВЕРКА ВЕСОВ"));
  Serial.println(F("==================================="));
  Serial.println(F("Введи 8 бит (0 или 1) через запятую"));
  Serial.println(F("Пример: 1,0,1,0,1,0,1,0"));
  Serial.println(F("или числом от 0 до 255"));
  Serial.println(F("-----------------------------------"));
}

void loop() {
  if (Serial.available() > 0) {
    String input = Serial.readStringUntil('\n');
    input.trim();
    
    // Проверяем, может это число от 0 до 255
    if (input.indexOf(',') == -1 && input.toInt() > 0) {
      int num = input.toInt();
      if (num >= 0 && num <= 255) {
        // Конвертируем число в 8 бит
        for (int i = 0; i < 8; i++) {
          inputs[7 - i] = (num >> i) & 1;
        }
        
        Serial.print(F("Число "));
        Serial.print(num);
        Serial.print(F(" (биты: "));
        for (int i = 0; i < 8; i++) {
          Serial.print((int)inputs[i]);
        }
        Serial.print(F(") -> "));
      } else {
        Serial.println(F("Число должно быть от 0 до 255!"));
        return;
      }
    } 
    else {
      // Разбираем биты через запятую
      input.replace(',', ' ');
      int idx = 0;
      int pos = 0;
      
      while (pos < input.length() && idx < 8) {
        int next = input.indexOf(' ', pos);
        if (next == -1) next = input.length();
        String val = input.substring(pos, next);
        val.trim();
        if (val.length() > 0) {
          inputs[idx++] = val.toInt();
        }
        pos = next + 1;
      }
      
      if (idx != 8) {
        Serial.println(F("Ошибка: нужно 8 бит!"));
        return;
      }
      
      Serial.print(F("Биты: "));
      for (int i = 0; i < 8; i++) {
        Serial.print((int)inputs[i]);
      }
      Serial.print(F(" -> "));
    }
    
    // Вычисляем результат
    float result = forwardPass();
    
    Serial.print(F("Выход сети = "));
    Serial.print(result, 6);
    Serial.print(F(" -> "));
    
    if (result > 0.5) {
      Serial.println(F("НЕЧЕТНОЕ (1)"));
    } else {
      Serial.println(F("ЧЕТНОЕ (0)"));
    }
    
    // Проверяем правильность для отладки
    int lastBit = (int)inputs[7];
    if ((result > 0.5 && lastBit == 1) || (result <= 0.5 && lastBit == 0)) {
      Serial.println(F("✓ Правильно!"));
    } else {
      Serial.println(F("✗ Ошибка!"));
    }
    Serial.println();
  }
}

зачем это не знаю… скидывал ссылку https://habr.com/ru/articles/351922/ программа похоже не идет на win7+ но если будет легенькая задача, готов попытаться создать реальный конструктор нейросети, с обучением и на пк и на ардуино, или в крайнем случае на пк, и подстановкой результата в ардуино уно, использующий реальный алгоритм обучения, где скармливаешь нейросети данные и ответ, и она сама учится…

vvb333007 · 24.Февраль.2026 02:11:48

ESP32-S3 справляется прекрасно. Там и распознование предметов есть и прочее. Главное - там есть оптимизированная библиотека, на SIMD ассемблере. Матрицы, комплексные числа, дотпродакт и т.д. и т.п. Да и конверторы моделей есть и куча кода. Обучай - нехочу. 8 мегабайт озу.

andriano · 24.Февраль.2026 03:42:03

А какие SIMD есть в ESP?

vvb333007 · 24.Февраль.2026 04:48:24

В старом (ESP32) никаких. Но он уже в прошлое уходит, потихоньку. ESP32-S3 и старше (P4, например. Насчет S2 не уверен) имеет достаточно богатый набор инструкций векторных. Обнаковенная математика, комплексные числа. Регистры 128бит для этого используются. Вектор - это массив из 16 байт: 16 char, 8 shorts или 4 ints. Операции знаковые\беззнаковые\с насыщением. Аккумулятор 160 бит, если не путаю. Умножает и складывает в 160бит значение. Матоперации векторные, вроде как 1-2 такта: например, сложить вектор с вектором, получив результирующий вектор. Операции zip/unzip, которые позволяют взять два вектора и сделать interleaving или наоборот - “расстегнуть“ один длинный вектор на два. Команды для работы с невыровненными данными. Да там дофигища чего. А если глянуть в P4 то там еще больше.

У Espressif есть библиотеки математических примитивов, которые написаны на этом ассемблере. Посмотрите на Github репозиторий esp-dsp и esp-dl, например. Там оччень удобно разбито по файлам, которые можно накидать в свой ардуино-скетч и они скомпилируются.

FFT есть.

ЕвгенийП · 24.Февраль.2026 05:58:55

Не обязательно
Обычно, да, но при этом вполне достаточно даже не половинной точности. Широко используются 8-битовые и даже 4-битовые числа. Вы представляете себе 4-битовое число с плавающей точкой? А они используются!

Ну, это ещё и от задачи зависит. Я вовсе не собирался опухоли на рентгеновских снимках классифицировать.

Ну, на самом деле я предлагал просто поиграться признаками делимости. Не обязательно “на два”.

andriano · 24.Февраль.2026 13:58:37

Я не представляю, как с такими числами проводить обучение.

lilik · 24.Февраль.2026 14:45:10

А вот обучить по картинкам, подобное генерить в пределах скетча на esp32 можно?

ЕвгенийП · 24.Февраль.2026 15:08:06

Вот здесь подробно разобрано с примерами кода на питоне и для 8-ми, и 4-битовых чисел. Результаты вполне себе, т.е. жертва точности ради скорости вычислений вполне оправдана

ЕвгенийП · 24.Февраль.2026 15:09:15

Не знаю. Я бы не взялся.

lilik · 24.Февраль.2026 15:13:49

Я бы тоже. Просто подумалось - мозаика Вороного (примитивно) это по случайным точкам раскрасить области их ближайшего окружения. А что если по картинке (разноцветные области) получить комплект точек-сайтов? То есть решение обратной задачи.

BABOS · 24.Февраль.2026 15:29:45

я думаю слишком большая картинка)))
можно взять поменьше, и разбить фото при скармливании сети на черные и белые пиксели (чуть больше уже сложнее, ардуино не потянет код), и получить новое фото X c новым X размером пикселей

а получить мы его можем создав такую выборку,
0,0,0,0,0,0,0,0,1,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,
0,0,0,0,0,0,1,0,0,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,X,
где первые 9 цифр это пиксели изображения 3 на 3, которые преобразованы в оттенки черного и белого, а последние 16 это должны быть реальные значения цифр, в конечном итоге которые станут пикселями нового фото, можно создать такую выборку для обучения(которую делать сложнее чем сеть) и обучать ее на таких примерах вход - выход, пока сеть не усвоит это, и ее % точности не достигнет 90-100%

а далее при подачи настоящего изображения 3 на 3, она будет превращать его в 9 цифр 0 и1, прогоняя по своим весам, и выдавать столько пикселей сколько вы указали выходных слоев при обучении))) используя те веса, которые изменились в ходе обучения что бы выдавались те значения X что указывали при обучении, когда вы ей скармливали 9 цифр, и указывали какой правильный ответ надо получить используя 16X и так примерно для каждой задачи… но это знания поверхностные и не учитывают более сложных нейронов…

чем больше нейронов, тем больше обучение, и в конечном итоге если арендовать мощности огромные, вы может быть получим значения весов, которые загрузятся в ардуино)))

вообще используя такой примитивный метод можно наверное много чего творить, и не обучаться даже в построение этих самых сетей…
единственное что сложные модели сетей потребуют огромных мощностей для обучения))) и не всегда результат обучения и получения весов гарантирован… при отсутствии точности в 90% выборка для обучения удаляется, составляется заново, и обучение запускается по новой…

но если вы составите полный перечень всех вариантов входов и выходов, то результат практически всегда будет 100% однако часто сеть обучают только на частичных данных, иногда менее 1% от всех возможных вариантов указывают при обучении

lilik · 24.Февраль.2026 15:35:17

Конечно, мы ведём речь о секторе 1/8 или меньше. Суть в том, что линии листочков сеть сможет грубо повторить с помощью диаграммы Вороного.
…Вот реши обратную задачу с помощью ИИ.

Найди координаты точек-сайтов каждого локуса.