Здравствуйте.
Сегодня решил начать тему по практическому применению нейронных сетей для шахмат.
Надеюсь к обсуждению и объяснению, как это работает - присоединится автор движка booot.
Позволю себе процитировать его:
"Помню, как нейросети изучал . В 2018 году в Стокгольме на чемпионате мира среди компьютерных программ уже играла Leela (мой движок с ней вничью сыграл), и смотрели мы тогда на нее как на диковинку - непонятно что это за зверь был такой. И уже витали в воздухе идеи использования нейросети для оценки позиции. По моему где-то именно в это уже время толковый японец для сеги их пробовал использовать и получил результат. Тогда я с Штефаном (автором Шреддера) и Йоханом (автором Jonny) обсуждали возможности такого применения и я понял что знаний мне не хватает. Вернулся домой и начал изучать вопрос. Тоже в начале казалось просто неподьемной космической техникой. Пришлось разобрать по винтикам всю математику, чтобы понять как это все функционирует, почему именно матричная алгебра, где и зачем нужны частные производные и т.д . Это намного проще все изучать, если сразу пробовать разобраться на практике, а не просто читать. "

Итак, чтобы начать практическую работу нам нужно:
Цитата - "Лично я обхожусь следующими (хватает за глаза да еще и с запасом)
а) Делфи (святое)
б) установленный питон (я через Анаконду это делаю всегда). В питоне нужен какой-то ИДЕ где код набирать (я использую Spyder) и набор необходимых библиотек для работы с нейросетями. Я использую Keras (оказался самым легким с точки зрения изучения работы с нейросетями) и tensorflow как бекенд для него. В шахматном мире используется больше Pytorch - он более низкого уровня чем Керас , эдакий конструктор собери сам, и позволяет типа больше контролировать и вмешиваться в процесс. Керас больше напоминает уже готовое коробочное решение с небольшим количеством рычажков. Мне Кераса с головой для этих целей. Да и проще он в освоении. "

Я подготовил для себя инструментарий
1. Embarcadero® Delphi® XE5 Version 19.0.13476.4176 - для 64 битных приложений
прим. "под 32 бита можно будет на самом начальном этапе создать какой-то макет , проверяющий совсем уж простые вещи (ну там в медленных циклах в паскале посчитать проход по нейросети и получить какой-то результат), но для чего-то работающего это не пригодиться увы ... 64-бита обязательно! Иначе все просто работать нормально не будет. Я не уверен что под 32 вообще реально запустить будет движок с нейросетью из-за специфики использования регистровых соглашений."
2. Pyton локально
3. Временно Google Colab, потом возможно установлю на комп.

Немного вышло скомкано
Но надеюсь цель понятна
У меня в голове есть идея для примера, чтобы попытаться реализовать с помощью нейросетей.
Я думал, что ближе всего к шахматам.
Конечно же шахматы!
И это старая добрая задача о неприкосновенном короле.

Что скажет на это уважаемый booot76?

Переименовано в №2 как продолжение quantoforum.ru/mathematics/3391-nejronnye-seti-dlya-shakhmat
Традиция

Да! Добрый день всем. У меня действительно есть некоторый практический опыт написания как "стандартных" альфа-бета движков (тут и шахматы и шашки) так и "альфазеровских" (пробовал несколько крестико-ноликовых игр, получилось). Так что чем смогу то и обьясню если интерес есть

Алексей.

А что касается задачки о неприкосновенном короле, то мне таки тоже есть что сказать . В далеком 1995 году доводилось эту задачку в институте для курсовой работы сдавать. Она , правда, не из "переборных", а из "ретроградного анализа", которым эндшпильные таблицы строятся. На тогдашних древнейших пентиумах просчитывалась на лету за несколько секунд. Сейчас в моем движке есть подобная же задачка : в момент старта движка на лету просчитывается и сохраняется в память эндшпиль kpk (король с пешкой против короля) для последующего использования в переборе.

Я бы хотел попробовать нейросеть в этой задаче.
Вопрос
Какие входные данные нужны подать на сеть?
Что на выходе должны получить?
Конечно вопросы могут показаться не корректными, но я так это вижу.

А вот для начала я бы советовал на что-то попроще все же замахиваться. Для учебных примеров, чтобы разобраться где у нейросетей что я предложу классическую задачку на распознавание образов, где мы сможем пощупать "шахматную" нейросеть и поиграться с ее гиперпараметрами. Ну а для чреализации чего-то практического, после обучения, можно придумать что-то простое, но интересное. Но для того чтобы начинать нам все же придется сначала определиться : что именно мы пишем. Потому что только на первый взгляд все околошахматные задачи похожи друг на друга и почти одно и тоже. На самом же деле я уже вижу 3 АБСОЛЮТНО разных по подходу, архитектуре и реализации задчаи :

1. Классический альфа-бета алгоритм перебора, который лежит в основе моего движка, Стокфиша и всего такого же.
2. Альфазеровский Монте-Карло. Где в принципе все другое и общего есть только название "там тоже какие-то нейросети"
3. Задача о неподвижном короле, где общего вообще ничего нет кроме названия "про шахматы"

Вот попалась статья на хабре.
Как кодировать данные
Стандартный и важнейший вопрос при обработке данных - в каком виде предоставить данные для обучения

booot76 wrote: Это интересно.
PS
Расскажите поподробнее об этом

Определимся сразу в категориях "что такое нейроспеть и нафиг она вообще"? Применительно к шахматам (я просто там ее только и использовал). Так сразу проще будет понять что мы с ней можем,а чего не можем.
Так вот нейросеть это математический алгоритм, который по сути может выполнять (в шахматах!) всего 2 задачи :
1. "распознавание позиции". На вход дается произвольная позиция и на выходе сеть классифицирует ее по заранее предложенному классификатору.
2. Регрессия. На входе - нейросеть, на выходе ее оценка (в каких-то попугаях -пока неважно).

Если ставить вопрос передо мной ребром : "вот хочу к задаче о неподвижном короле присобачить нейросеть и хоть ты потрескайся", то тогда выход может быть только один : задача номер 1 - распознавание : на входе позиция, на выходе классификация на "позиция м ожет быть выиграна" и "позиция ничейна". Больше там вымутить ничего не получится.
Соответственно и подход к решению у нее такой :

1. решить задачу о неподвижном короле классическим способом (ретроградный анализ). Меньше секунды на современных компах будет.
2. Полученные позиции выписать в датасет для обучения в виде "кодировка позиции - ее оценка либо 0 ничья илибо 1 выиграно"
3. Обучить неро сеть на этом датасете.
4. проверить и выдохнуть

Можно ли какой нибудь простой пример разобрать практически?
Не обязательно про шахматы.

Мельком прочитал статью на хабре - вот тут уже можем от чего-то оттолкнуться. Написана она, конечно, весьма корявым языком так что кровь из глаз и ушей идет, но твердое (для наших с вами задач) у нее есть. Что могу предложить, чтобы было :
1. Не очень долго (мотивацию потеряете в процессе если результат сразу не получается)
2. Посильно (три этажа кода без сотен человеко-часов проведенных за получением знаний просто не получатся - слона надо жрать по частям)
3. Было интересно практически (какой-то практический результат на уровне "у, блин, железяка, а работает").

Можем пойти почти как "в статье" :

1. взять кусок данных для обучения (уж чего-чего, а мой движок их сотнями миллионами генерирует от версии к версии - поделюсь)
2. Выберем архитектуру нейросети (простенькую, но вполне себе сьедобную)
3. Обучим нейросетку.
4. Кто-то из вас (я просто не умею) сможет присобачить ее в виде какой-то веб-странички, которая умеет получить от пользователя позицию (на доске расставить), нейросеть ее оценит, алгоритм отдельно из этой позиции сгенерирует все возможные ходы (опять же нейросеть оценит каждый) и будет выбран ход с максимальной оценкой из нерйосети ("лучший"). Чудес в виде силы игры ожидать не следует, но с точки зрения "новая форма жизни таки фишки двигает!" будет небезынтересно.

Классический учебный пример, чтобы пощупать нейросети это задча на распознавание образов (рукописных цифр). Удобна она тем, что встроена прямо в Керас и сам учебный пример занимает полстранички несложного кода на питоне. Позволяя при этом построить весьма приличную (как для задачи для шахмат так с головой) саму нейросетку, разобраться что у ней и для чего, обучить ее, поиграться, замерить результаты и сделать выводы. Например вот здесь описано весьма достойно : кто не поленится пройти этот обучающий пример шаг за шагом. не пожалеет

habr.com/ru/articles/705306/

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

booot76 wrote: И все же это мне ближе.
Т.е. шахматы мне ближе.
Я уже набросал сегодня простенький GUI - пользовательский интерфейс на Delphi® XE5.
Сейчас заброшу его на codeberg.

Ну раз ближе, то тогда сразу после обучающих примеров на понимание нейросети пойдем в него. Но начать все же предлагаю с распознавания рукописных цифр. Там просто уже преподготовленные данные, которые в задачах шахматных нам с вами еще нужно будет откуда-то достать и разложить. Ч о само по себе непросто. Поэтому лучше сначала разобраться с нейросетью как таковой а уж потом начинаем данные шахмат обсуждать. Там не то, чтобы сложно, но лучше не кидаться сразу на все одновременно.

booot76 wrote: Поразбираюсь ...

Смело задавайте по учебному примеру вопросы - расширенно отвечу. Благо кода там немного и все я могу внятно откомментировать и показать где там нюансы и где поиграться можно.

А пока коротко о самом необходимом минимуме знаний :

Один нейрон можно представить как 2 последовательные математические функции :
1. Сумматор. E = B+x1*w1+x2*w2 + .... xn*wn, где n -количество входов у нейрона, Xi - информация пришедшая на i-й вход, Wi - вес i-го входа, B - так называемый биас - тоже вес, но не привязанный ни к одному из входов, а принадлежит всему нейрону. Обучение нейрона это , собственно, подбор всех его весов. У нейрона может быть несколько входовт но только 1 выход который собственно и выдает результат активационной функции.

2. Активационная функция. Все что пришло от сумматора (Е) является аргументом этой функции f(E). В теории нейросетей их дофига, но для начала обучения нам важно знать про них только то, что они должны быть нелинейные (не вида y=ax+b) и обязательно дифференциируемые для всех нейронов, кроме, может быть, только последнего выходного, где часто бывает именно линейная вида y=x. На них в свое время была своя мода (в разные годы модными были разные активационные функции). В шахматах (да и вообще сейчас) используется простейшая из нелинейных функций - relu. Она выдает на вход такое же число, что ей пришло, если число положительное и 0 во всех остальных случаях. Эдакий "диод-выпрямитель".

Нейронный слой - множество нейронов одного вида и с одинаковой активационной функцией. Слоев в теории еще больше, чем дофига, но для шахмат (и для множества других несложных задач) нам достаточно только одного - Dense. Полносвязный слой прямого прохождения. Где на вход нейронов текущего слоя подаются все выходы слоя предыдущего.
Ес ли у нас схема сетки 256-32-1, это означает что в первом Dense слое у нас 256 нейронов, во втором - 32 (у каждого из которых 256 входов), а в третьем слое - 1 единственный нейрон с 32 входами. Выход нейросети - выход того самого единственного последнего нейрона. А вот вход может быть разным. Эти первые 256 нейронов примут на себя любое нужное нам количество входных данных.

Обучение сетки это алгоритм подбора весов (и биасов) ВСЕХ нейронов во всех слоях. Копать в него глубоко пока смысла не вижу, скажу лишь что критерием для того, чтобы алгоритм понимал что обучение таки идет и успешно является лосс-функция. В самом простой аналогии : у нас есть обучающая выборка данных с "идеальными" значениями, которым мы и хотим научить сетку. Мы подаем эти данные последовательно в сеть, получаем ее ответ. Потом все поданные значения и все ответы подаем в эту лосс функцию, задача которой их сравнить и выдать нам некоторое число, которое дает нам представление о том насколько близко сетка ответила к этим идеальным значениям. И если от итерации к итерации это число уменьшается - значит сетка все ближе и ближе к истине. Обучается. Если перестало уменьшаться - ну значит все, алгоритм можно прекращать.

Второй важный параметр кроме лоссфункции - оптимизатор. Это часть алгоритма обучения, призванная сделать процесс подбора всех весов всех неронов по возможности более быстрым. Там тонна сложной математики, но на практике надо знать волшебное слово ADAM (название одного из наиболее удачных и , главное, универсальных оптимизаторов, который можно использовать по началу вообще для любых задач и не париться.

Последний важный параметр - метрики. Это индикаторы для программиста. Которые в более удобной форме, чем лоссфункция показывают ему как идет обучение. Тоже должны уменьшаться тем активнее, чем лучше идет обучение. Так как функция их - информативная, то можно и вообще без них.

Ну и пара терминов :

Батч - размер порции данных, которые подаются за раз в нейросеть по результатам которых алгоритм подкручивает веса у всех наших нейронов перд получением следующей порции данных (следующего батча). По 1 примеру никто не подает (долго). Все за раз тоже не подают (шума много будет) . Выбирают что-то небольшое. Общего рецепта счастья нет. Методом тыка выбирается.

Эпоха. После того как мы по батч за батчем скормили сети ВСЕ обучающие данные и после каждого подкрутили веса - говорят что закончилась эпоха. Можем начинать следующую - начинать подавать данные с начала.

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

Вот собственно и весь процесс глазами программиста .

Загрузил ваш проект - симпатичная доска. Вот чего я точно никогда не умел - делать интерфейс. Вот что угодно, как угодно, но не его. Благо когда я начал заниматься шахматами там уже был протокол Винборд и мне не нужно было самому ничего рисовать.

Теперь по вашей задаче о неподвижном короле еще раз. В принципе чтобы не говорить вам "нет" мы с вами легко можем поднять эту задачу. Я , конечно, в качестве разминки быстренько в Делфи смастерю алгоритм ретроперебора после выходных и полностью задачу мы с вами в виде эндшпильной таблицы посчитаем. И данные для нейросетки из этой таблицы настругаем вообще без вопросов. Давайте прикинем с вами ЧЕМУ мы хотим нашу будущую сеть обучить? Что бы вы хотели от нее получать и отображать на красивом синеньком интерфейсе? Эту задачу просто я вижу, не то, чтобы подьмной, но даже очень быстро подьемной.

Вчера запустил учебный проект - распознавание рукописного ввода.
1 блок кода для обучения сети.
Обучение заняло время.
После обучения я не понял как воспользоваться результатом?
Как и где сохраняется результат обучения?
PS
Я имел ввиду, не запускать каждый раз обучение, а использовать результата этого обучения (2 блок кода)

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

k = 6
plt.imshow(X_test[k], cmap='binary')
plt.axis('off')
print(y_test[k])
print(
model.predict(np.array([X_test[k]]))
)

model.predict , куда на вход подаются данные в том же формате в котором они подавались для обучения.


model.save позволяет сохранить обученную модель

model.load соответственно загрузить (для дообучения илли использования)

Вернулся к примеру.
Попробовал сохранитьсяНе получилось



Еще вчера, я интуитивно заметил, что 50 эпох наверное лишне, уменьшил до 10.
"0" выдал правильно.
А дальше, сохраниться не получилось, чтобы проверить, значит надо решить этот вопрос, гугл курить

При сохранении(чтении ) обязательно указывайте имя файла с раширением .h5 Есть такой гемор в керасе, да - мелким шрифтом в документации пишется
Что касается количество эпох, то тут , как я писал, смотрим на то уменьшается ли лосс функция от эпохи к эпохе. Как перестала - так и обрываем.

booot76 wrote: Да, так получилось

Ну тогда поздавляю . Фактически вы , пусть и в учебной форме, но прошли цикл разработки приложения под нейросети. Поиграйтесь с количеством нейронов в слоях - там забавно наблюдать за точностью и ее зависимостью от количества. Пригодится нам потом.

Например любопытства ради просто выкиньте (закомментируйте) вот этот участок кода :

model.add(Dense(64, activation='relu'))
model.add(Dense(128, activation='relu'))
model.add(Dense(256, activation='relu'))
model.add(Dense(512, activation='relu'))

В этом случае у вас в нейросетке останется лишь 2 слоя (32 входных и 10 выходных) нейронов вместо 6. И обратите вниманние насколько упадет точность всей обученной нейросетки если выкинуть эти 4 слоя. С 96% которые при этой конфигурации сетка дает.

Только нейросеть придется новую переобучить заново, конечно. Потому и выбрал пример этот что это занимает не так много времени и с практической точки понятно о чем речь идет : можно руками пощупать и глазами посмотреть все

Решил я что нибудь попробовать (поэкспериментировать).
Подготовился немного

Хотя это и не шахматы, а задача о неприкосновенном короле (белый король ходить не может)
Q7/8/2K5/8/8/8/8/7k w - - 0 1

В python-chess, выглядит так

Проверил получилось






В python-chess,

chess.A1: chess.Square = 0

chess.B1: chess.Square = 1

И функция для нейросети вроде, должна быть простой.

Если бы нумерация была как у меня A8 - 0? H1 - 63, то оценка для alfa beta, просто позиция черного короля - чем меньше, тем ближе к мату.

Решение любой задачи начинается с ее грамотной постановки. Мы говорим сейчас о нейросетях. Сформулируйте (своими словами)
ЧТО вы хотите от нейросетей в конце проекта для задачи о неподвижном короле, и ЧЕМУ будете нейросеть обучать и на КАКИХ данных? Давайте с этого начнем. Дальше этот "скелет" будем наращивать каким-то "мясом".