Мой месячный квест стать мастером шахмат с нуля

Таким образом, эта функция оценки потребует от меня выполнения всего 3 168 255 операций.

Подсчет необходимого объема памяти

Чтобы выполнить этот мысленный расчет, мне нужно будет не только выполнить эти операции, но и иметь достаточный объем памяти.

В частности, мне нужно будет предварительно запомнить все значения матрицы W¹, которая состоит из 1 583 104 чисел, и вектора w², который состоит из 2048 чисел. Мне также нужно запомнить h при вычислении f¹, чтобы я мог использовать результат для вычисления f², что требует, чтобы я запомнил еще 2048 чисел.

Давайте теперь преобразуем эти усилия по запоминанию в конкретные операции с памятью.

Для 1583 104 веса W¹ и 2048 веса w² мне потребовалась бы только операция чтения из моей памяти для каждого (во время игры - расчет времени).

Для 2048 цифр h мне потребовались бы как операция записи, так и операция чтения для каждого.

Таким образом, мне потребуется 1 587 200 операций чтения и 2048 операций записи, или всего 1 589 248.

Как долго это займет?

Теперь мы знаем, что мне нужно будет выполнить 3 168 255 математических операций и 1 589 248 операций с памятью для оценки данной шахматной позиции. Сколько времени это займет?

Это, конечно, зависит от размера умножения и деления, а также от размеров чисел, хранящихся в памяти. Вскоре я подробнее расскажу об этом размере, а пока просто предоставлю свои оценки.

По моим оценкам, я мог выполнить одну математическую операцию за 3 секунды и одну операцию с памятью за 1 секунду. Таким образом, я мог оценить одну шахматную позицию за 11 094 013 секунд или чуть более четырех месяцев.

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

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

Так как средняя шахматная партия оценивается в 40 ходов, это будет примерно 500 оценок за партию.

Следовательно, чтобы сыграть всю шахматную партию с использованием этого метода, мне потребовалось бы 2000 месяцев или 167 лет, чтобы сыграть в эту игру.

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

Следующий шаг

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

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

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

Компьютерам нравятся единицы и нули, и они не слишком заботятся о «больших числах», таких как 773, поэтому растровое представление оптимально для компьютеров.

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

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

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

Прошлой ночью я забрался в кровать, готовый заснуть. Как только я закрыл глаза, я понял, что сделал большую ошибку в расчетах вчера.

Что ж, технически я не ошибся. Алгоритм вычисления шахматной доски, который я описал вчера, действительно требует 3 168 255 математических операций и 1 589 248 операций с памятью. Однако я не осознавал, что большинство этих операций неуместны.

Позволь мне объяснить…

Если вы еще не читали вчерашнюю запись, было бы очень полезно сначала прочитать ее. Прочтите здесь.

Устранение моей ошибки

Вчера я представил битовую доску, которая позволяет полностью описать состояние шахматной доски с помощью 773 единиц и нулей. Битовое представление - это входной вектор для моей оценочной функции.

При подсчете количества математических операций, которые потребуются этой оценочной функции, я упустил из виду тот факт, что только максимум 37 цифр из 773 в представлении битовой доски могут быть 1, а остальные - 0.

Это важно по двум причинам:

1. Функция f¹ (x), которая преобразует входное представление битовой доски x в скрытый вектор h, на самом деле не требует никаких операций умножения. , поскольку я либо умножаю на 0 (в этом случае термин можно полностью игнорировать), либо я умножаю на 1 (в этом случае исходный термин можно использовать без изменений). Таким образом, все 1 583 104 операции умножения, которые я оценил вчера, больше не нужны.
2. f¹ (x) требует только операций сложения между всеми единицами в представлении битовой доски, которое мы теперь правильно ограничили до 37. Следовательно, вместо 1 581 056 операций сложения, как оценивалось вчера, алгоритм требует только 36 x 2048 = 73728 операций.

f² по-прежнему требует тех же 4095 операций, что означает, что в целом алгоритм оценки требует всего 77 823 математических операций.

Это в 40 раз больше, чем вчера.

Кроме того, операции с памятью масштабируются таким же образом: для f¹ мне нужно только (37 x 2048) + 2048 = 77 824 операции чтения и 2048 операций записи, что в сумме составляет 79 872 операций с памятью.

Таким образом, в целом описанный вчера алгоритм оценки требует всего 157 695 операций.

Расчет новых требований ко времени

Если я снова предполагаю, что могу выполнить одну математическую операцию за 3 секунды и одну операцию с памятью за 1 секунду, я смогу оценить одну шахматную позицию за 313 341 секунду или 3,6 дня, что значительно меньше, чем вчерашние четыре месяца.

Тем не менее, если мы предположим, что мне нужно будет выполнить 500 оценок за игру, мне потребуется 3,6 дня x 500 оценок = 5 лет, чтобы сыграть в одну игру.

5 лет - это все еще слишком долго, но, по крайней мере, теперь я могу завершить одну партию (вычислительно прекрасную) в шахматы за свою жизнь.

Но, думаю, у меня получится лучше ...

Использование «порогового поиска»

Вчера я предположил, что мне нужно будет оценить 10–15 вариантов на ход, чтобы найти оптимальный вариант. Другими словами, я бы выполнил 15 оценок, определил, какой ход принес наибольший оценочный результат, и затем сыграл бы этот ход в игре.

Однако что, если нет необходимости искать самый лучший ход? Что, если нужно только найти ход с оценкой выше определенного порога?

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

Хотя, по моим оценкам, в среднем я смог бы найти ход для преодоления порога в 2,5 оценки.

Следовательно, если я смогу реализовать это пороговое значение в моем алгоритме оценки, я могу уменьшить количество оценок с 500 до 100.

Но я все еще могу лучше ...

Игра в дебюте

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

Вы заметите, что 8 из моих 49 ходов были ниже порога (я играл белыми).

Интересно, однако, что, проходя все свои партии, я, кажется, делаю ходы исключительно в категориях «Отлично» и «Хорошо» примерно до 12–15 ходов, после чего игра становится слишком сложной, и у меня возникают проблемы.

Я также обнаружил, что к концу игры я делаю очень мало ходов ниже порога.

Основываясь на этих данных, предположим, что мне нужно провести мысленную оценку только для 24 из 40 ходов, найденных в средней игре.

Таким образом, в одной игре мне потребовалось бы всего 60 общих оценок, а за 3,6 дня на одну оценку я мог бы пройти полную игру за 7 месяцев.

Это приближается, но я все еще могу сделать лучше ...

Поиск сокращений с помощью «Операций обновления»

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

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

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

Таким образом, в этом случае каждое из 2048 значений h необходимо обновить четырьмя операциями: одна соответствует ходу, сделанному оппозицией, другая - компенсировать то место, где фигура противника находилась перед ходом. ход, один соответствует рассматриваемому ходу, а другой отменяет то место, где эта фигура находилась до рассмотрения.

Таким образом, для обновления h необходимо всего 4 x 2048 = 8192 математических операции (сложения).

Если я готовлю определенный дебют белыми, и Магнус отвечает теоретически определенными ходами, я могу войти в игру, предварительно запомнив первый вектор h, который мне понадобится, поэтому мне придется только когда-либо выполнять обновления.

Конечно, если игра отклонится от сценария, мне нужно будет выполнить полную оценку для первого хода, но никогда после этого.

Таким образом, в общей сложности, поскольку для преобразования h в выходной y все еще требуется 4095 операций, для оценка обновления.

Требуемый объем памяти также уменьшается при таком подходе к обновлению, так что для одной оценки требуется только 8192 x 2 + 4096 = 20 480 операций с памятью.

Если оценка является вторым, третьим и т. Д. Для конкретного хода, то h отличается только в зависимости от ранее рассматриваемого хода и рассматриваемого в настоящее время хода. Таким образом, опять же, каждое из 2048 значений h необходимо обновить с помощью четырех операций.

Таким образом, для этого вида обновления также требуется 12 287 математических операций и 20 480 операций с памятью.

Опять же, предполагая, что я могу выполнить одну математическую операцию за 3 секунды и одну операцию с памятью за 1 секунду, используя этот подход обновления, я мог бы оценить одну шахматную позицию за 57, 341 секунду или 16 часов .

Это означает, что я мог пройти одну полную шахматную партию за 16 часов x 60 оценок = 40 дней.

Ясно, что по-прежнему требуется дополнительная оптимизация, но все выглядит лучше.

Фактически, мы начинаем приближаться к тому диапазону, когда я мог бы сделать трюк в стиле Дэвида Блейна, где я провожу 40 дней в тюремной камере, вычисляя шахматные ходы для расширенной выставки с одной игрой.

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

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

Надеюсь, в следующие два дня я смогу закончить все теоретическое планирование, иметь четкий план и начать компьютерную работу, необходимую для создания реального алгоритма.

Вчера, благодаря дальнейшей оптимизации, я смог уменьшить время выполнения моего алгоритма оценки шахмат до 16 часов на одну оценку, что потребовало около 40 дней для всей партии.

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

Это слишком много параметров, чтобы пытаться запомнить.

Хорошая новость заключается в том, что, вероятно, нет необходимости в таком большом количестве параметров. Фактически, алгоритм беспилотного автомобиля, который я построил в мае и основывался на модели автопилота NVIDIA, требовал всего 250 000 параметров.

Имея это в виду, я подозреваю, что для хорошего шахматного алгоритма требуется всего около 20 000–25 000 параметров - на порядок меньше, чем для беспилотного автомобиля, учитывая, что беспилотный автомобиль должен иметь смысл гораздо менее структурированного и гораздо менее сложного. содержал данные.

Если этого достаточно, я полностью готов предварительно запомнить 20 000 параметров.

Для сравнения: в октябре 2015 года Суреш Кумар Шарма запомнил и произнес 70 030 цифр числа пи.

Таким образом, запоминание 20000 случайных чисел полностью в пределах возможного для человека. (я буду усекать параметры, которые варьируются от значений от 0 до 1, до двух цифр, что должно поддерживать целостность функции, а также ограничивать количество цифр, которые мне нужно запомнить, до 40 000).

Уменьшение необходимого количества параметров

В моем вчерашнем алгоритме большинство параметров было получено в результате умножения 773 цифр представления битовой доски на 2048 строк скрытого вектора h.

Таким образом, чтобы уменьшить количество необходимых параметров, я могу либо сжать битовое представление, либо выбрать меньшую ширину для скрытого слоя.

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

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

Таким образом, мой лучший вариант - уменьшить ширину скрытого слоя.

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

Я предполагаю, что могу создать достаточно хороший шахматный алгоритм с двумя скрытыми слоями шириной 16, что потребует от меня запоминания 12640 параметров.

Конечно, мне нужно практически подтвердить эту гипотезу, создав и запустив алгоритм, но пока предположим, что этот алгоритм будет работать. Даже если это сработает, это может оказаться неэффективным по времени, и в этом случае его не стоит строить.

Итак, давайте сначала проверим это ...

Новый предполагаемый алгоритм

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

Этот алгоритм принимает 773 цифры представления битовой доски, преобразует эти 773 цифры в 16 цифр (настроенных на 12368 параметров), преобразует эти 16 цифр в другой набор из 16 цифр (настроенных на 256 параметров) и выводит оценку (настроенную с помощью 16 параметров).

Этот алгоритм потребует (36 x 16) + (16 x 16) + (15 x 16) + 16 + 15 = 1103 математических операции, (36 x 16) + (16 x 16) + 16 = 848 операций чтения из памяти и 16 + 16 = 32 операции записи из памяти.

Таким образом, все еще предполагая, что время выполнения одной математической операции составляет 3 секунды, а время выполнения одной операции памяти - 1 секунда, для одной оценки потребуется (3 x 1 103) + 880 = 4 189 секунд = 1,2 часа для выполнения. .

Конечно, как объяснялось вчера, большинство оценок будут лишь обновлением предыдущих оценок. Используя этот новый алгоритм, оценка обновления потребует (4 x 16) + (16 x 16) + (15 x 16) + (16 + 15) = 591 математическая операция, 16 + (4 x 16) + 16 + (16 x 16) + 16 = 368 операций чтения из памяти и 16 + 16 = 32 операции записи в память.

Следовательно, для выполнения оценки обновления потребуется (3 x 591) + 400 = 2173 секунды = 36 минут.

Таким образом, на полную игру можно сыграть за 36 минут x 60 оценок = 36 часов = 1,5 дня.

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

Этот новый алгоритм имеет время выполнения 1,5 дня на игру, что почти приемлемо, и требует запоминания 12640 параметров, что очень близко к человеческому диапазону.

Другими словами, с некоторыми дополнительными оптимизациями этот алгоритм действительно можно играть, предполагая, что структура имеет достаточно встроенных соединений для правильной оценки шахматных позиций.

Если это так, у меня может быть шанс. Если нет, скорее всего, у меня проблемы.

Пора начать проверку этого предположения…

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

Мне еще предстоит поработать над этим и еще много чем поделиться.

Но сегодня я сделал перерыв в работе, чтобы поиграть в обычные партии в шахматы на Chess.com. В конце концов, чем лучше я могу оценивать позиции без алгоритма, тем эффективнее я буду его использовать.

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

Тем не менее, в последние несколько дней некоторые из моих друзей задались вопросом, действительно ли я «учусь шахматам». А в традиционном смысле - нет.

Но это только в традиционном смысле.

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

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

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

Завтра я продолжу работу и напишу об этом новом подходе к изучению шахмат. Я очень рад видеть, как далеко я смогу зайти ...

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

Когда я начал работать, я очень быстро понял, что сначала мне нужно точно определить, как я планирую выполнять все свои мысленные вычисления. Этот мысленный процесс будет определять, как я структурирую данные в моей модели глубокого обучения.

Поэтому я использовал этот пост как способ продумать и задокументировать именно этот процесс. В частности, я собираюсь показать, как я планирую мысленно преобразовать любую шахматную доску в числовую оценку позиции.

Ментальная механика моего алгоритма

Сначала я смотрю на доску:

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

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

В моей памяти восемь дворцов разума, соответствующих каждой из буквенных колонок от a до h. Дворец разума, как объяснялось в ноябрьском испытании на запоминание карточек, представляет собой фиксированное, визуализируемое место, к которому я могу прикрепить воспоминания или информацию. Например, одним из таких мест может быть дом моего детства.

В каждом дворце разума есть девять комнат, по одной соответствующей строке от 1 до 8, и дополнительная комната для хранения данных, связанных с правами на рокировку. Например, одна из таких комнат может быть моей спальней в доме моего детства.

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

К каждому ориентиру прикреплены два двузначных числа, которые представляют соответствующие алгоритмические параметры.

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

Итак, глядя на доску выше, я начинаю мысленно перемещаться в первый дворец разума (столбец a), в первую комнату (строка 1), во вторую. ориентир (для Белой Ладьи и Слона) и к первому 2-значному числу (для Белой Ладьи).

Я беру это двузначное число и добавляю его к промежуточной сумме.

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

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

На этом этапе я беру итоговую сумму и сохраняю ее в моем отдельном дворце разума с 16 знаками, который содержит значения для первого внутреннего вывода (то есть значения для вектора h¹ первого скрытого слоя ).

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

Другими словами, мне действительно нужно 16 различных вселенных разума, в каждой из которых есть восемь дворцов разума, восемь комнат с шестью ориентирами и одна комната с четырьмя ориентирами.

Выполнив процесс 16 раз и сохранив каждое выведенное значение во дворце разума h¹, я могу перейти ко второму скрытому слою, преобразовав h¹ в h² путем передачи значений h¹ через матрицу из 256 алгоритмических параметров.

Эти параметры хранятся в едином дворце из 16 комнат. Каждая комната имеет восемь ориентиров, и каждый ориентир имеет два двузначных параметра.

В отличие от преобразования шахматной доски в h¹, для преобразования h¹ в h² мне почти наверняка нужно использовать все 256 параметров в строке ( если я не реализую какую-то функцию сжатия между h¹ и h², уменьшая некоторые из значений h¹ до нуля… Я изучу этот вариант позже ).

Таким образом, я начинаю с того, что беру первое значение h¹ и умножаю его (посредством умножения в уме) на первое значение в первой комнате дворца разума h². Затем я беру второе значение h², умножаю его на второе значение в первой комнате и добавляю результат к предыдущему результату. Я продолжаю таким образом, пока не закончу умножение и добавление всех членов в первой комнате, после чего я сохраняю итоговое значение как первое значение h².

Я продолжаю работать с остальной частью комнаты, пока не будут вычислены все значения h².

Наконец, мне нужно преобразовать h² в одно число, которое представляет собой числовую оценку данной шахматной позиции.

Для этого я попадаю в последнюю комнату во дворце разума h², где есть восемь ориентиров, каждая из которых содержит два двузначных числа. Я умножаю первое число в этом дворце разума на первое значение h², второе число на второе значение h² и т. Д., Добавляя результаты попутно .

В конце концов, у меня остается одна сумма, которая должна примерно соответствовать истинной оценке шахматной позиции.

Если это число больше определенного порогового значения, то я должен сделать ход, соответствующий этому вычислению. Если нет, то мне нужно начинать все сначала, имея в виду другой потенциальный ход.

Некоторые примечания:

1. Мне все еще нужно решить, как я планирую хранить отрицательные числа в своей зрительной памяти.
2. В настоящее время я создал только одну вселенную разума, поэтому, если я могу подтвердить свой алгоритмический подход с помощью вычислений, мне нужно будет создать еще 15 вселенных. Мне также нужно будет создать схему именования более высокого уровня или мнемоническую систему для вселенных, которую я могу использовать, чтобы держать их прямо в моем мозгу.
3. Есть потенциальная вероятность, что мне понадобится больше слоев, меньше слоев или слои разного размера в моей модели глубокого обучения. В любом из этих случаев мне придется повторить или удалить процедуры, как описано выше, соответственно.

Когда детали моего алгоритма мысленной оценки проработаны, у меня есть все необходимое для вычислительной части процесса.

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

В частности, я попытался ответить на вопрос: «Если это сработает, каков идеальный результат?».

Этот ответ состоит из двух частей ...

1. Скорость исполнения.

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

Для сравнения: Алекс Маллен, спортсмен №1 в мире по запоминанию, запомнил 520 случайных цифр за пять минут. В то время как одна полная шахматная оценка требует манипулирования 816 цифрами, если все фигуры находятся на доске, и 560 цифрами, если половина фигур находится на доске.

Хотя эти задачи не совсем одно и то же, по моему опыту, запись чисел в память занимает примерно столько же времени, что и чтение чисел из памяти с последующим их сложением.

Тем не менее, чтобы быть консервативным, я добавил пятиминутное время Алекса, предсказав, что опытный специалист по вычислениям в мысленных шахматах может выполнить одну шахматную оценку за 10 минут.

При 60 оценках за игру (это то, что я предсказываю для себя), вся игра может быть завершена за 10 часов, что, по крайней мере, на мой взгляд, вполне разумно. Многие партии этого чемпионата мира по шахматам длятся шесть, семь или восемь часов.

Конечно, если более опытный игрок сможет более разумно реализовать алгоритм, я подозреваю, что он сможет сократить количество оценок в игре примерно до 30, сократив время игры до довольно стандартных пяти часов для классической игры.

2. Широкое распространение

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

На самом деле, мне интересно, может ли сильный игрок (2200–2600), который дополняет свою игру таким подходом, стать серьезной угрозой для лучших игроков мира.

Я хотел бы думать, что если это сработает, это вызовет некоторый переполох в шахматном мире.

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

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

Сначала я думал о чем-то скучном, например, о «вычислительных шахматах для человека», но я просто собираюсь придерживаться более корыстного подхода:

Представляем Max Chess: стиль игры в шахматы, в котором используется комбинация интуитивных ходов и интеллектуальных алгоритмических вычислений. Эти мысленные вычисления известны как вычисления максимума.

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

Теперь, если предположить, что Max Chess вообще работает, давайте посмотрим, приживется ли он…

Сегодня, чтобы ускорить свой прогресс, я подумал, что было бы неплохо попросить помощи извне у кого-то с немного большим опытом шахматного ИИ.

Итак, сегодня утром я отправил кучу электронных писем и, что удивительно, очень быстро получил много ответов. К сожалению, все ответы были в одной и той же форме ...

Другими словами, никто не был заинтересован в сотрудничестве над этим проектом - или, по крайней мере, никто не был заинтересован в сотрудничестве над этим проектом, начав сразу и в полную силу.

Это понятно.

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

Но в каком-то смысле я рад, что меня отвергли. Потому что теперь у меня нет оправдания, кроме как разобраться во всем самостоятельно.

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

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

Дополнительное примечание: чтобы полностью опровергнуть все, что я сказал выше, если вы действительно думаете, что у вас есть соответствующий опыт и вы заинтересованы в помощи, оставьте комментарий, и мы что-то выясним. Всегда рад поучиться у кого-то еще, когда появится возможность. (И, конечно же, всегда рад сам разобраться, когда это не так).

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

На самом деле, это не волшебство - это просто так кажется, потому что я еще не формализовал осязаемый подход. Итак, давайте сделаем это в этом посте.

Есть четыре шага для создания окончательного алгоритма Max Chess:

Шаг 1. Создание набора данных

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

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

Похоже, в Интернете есть множество шахматных партий, которые я могу скачать, в том числе 2600 партий, которые Магнус сыграл официально.

Задача для этой части процесса будет: A. Преобразование данных в мое измененное представление битовой доски (чтобы данные отображались один в один с моим мысленным процессом) и Б. Генерация оценок для каждого из представлений битовой доски с использованием открытого- исходный шахматный движок Stockfish (у которого шахматный рейтинг около 3100).

Шаг 2: Создание модели

Следующим шагом является создание модели глубокого обучения. По сути, это основа для построения алгоритма.

Модель предназначена для описания формы, которую должна принимать функция (между входами и выходами в наборе данных). Однако до обучения модели специфика функции неизвестна. Модель просто раскрывает функциональную форму.

Теоретически эта модель не должна слишком сильно отклоняться от уже хорошо изученных моделей глубокого обучения.

Я смогу без особых трудностей реализовать модель в Tensorflow (библиотеке Google для машинного обучения).

Шаг 3. Обучение модели на наборе данных

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

Фактический тренировочный процесс должен происходить в непосредственной близости. Обычно сложнее всего заставить модель и набор данных хорошо взаимодействовать друг с другом, на что, честно говоря, я потратил 70% времени во время майского испытания беспилотных автомобилей.

Шаг 4: Тестирование модели и повторение

Как только алгоритм сгенерирован, я должен проверить, на каком уровне он может играть в шахматы.

Если алгоритм работает на уровне, намного превышающем уровень Магнуса, я могу упростить и переобучить свою модель, создав более простой для изучения и выполнения алгоритм оценки.

Если алгоритм работает на уровне ниже Магнуса, мне нужно будет создать более сложную модель в рамках того, что я смогу изучить и выполнить как человек.

На этом этапе я наконец выясню, есть ли у Max Chess какие-либо достоинства.

Теперь, когда у меня есть четкий план, я приступлю к шагу 1 завтра.

Вчера я изложил свой четырехэтапный план построения шахматного алгоритма, исполняемого человеком.

Сегодня я начал работу над первым шагом: создание набора данных.

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

К счастью, на Github есть замечательная библиотека под названием Python Chess, которая значительно упрощает эту задачу.

Как объясняется на Github, Python Chess - это «чистая шахматная библиотека Python с генерацией и проверкой ходов, синтаксическим анализом и записью PGN, чтением вводной книги Polyglot, проверкой табличной базы Gaviota, проверкой табличной базы Syzygy и взаимодействием движка UCI».

Меня особенно интересуют…

1. Анализ PGN, который позволяет моей программе Python читать любую шахматную партию в формате PGN.
2. Обмен данными с движком UCI (универсальный шахматный интерфейс), который позволяет мне напрямую взаимодействовать с шахматным движком Stockfish и использовать его возможности для анализа.

Документация для Python Chess также очень хороша и наполнена множеством примеров.

Сегодня, используя библиотеку Python Chess, я смог написать небольшую программу, которая может: 1. Анализировать шахматную партию PGN, 2. Численно оценивать каждую позицию и 3. Распечатывать каждый ход, визуализацию доски после каждого хода, и оценка (в сантипешках), соответствующая каждой позиции на доске.

import chess
import chess.pgn
import chess.uci
board = chess.Board()
pgn = open("data/game1.pgn")
game = chess.pgn.read_game(pgn)
engine = chess.uci.popen_engine("stockfish")
engine.uci()
info_handler = chess.uci.InfoHandler()
engine.info_handlers.append(info_handler)
for move in game.main_line():
engine.position(board)
 engine.go(movetime=2000)
 evaluation = info_handler.info["score"][1].cp
if not board.turn:
  evaluation *= -1
 
 print move
 print evaluation
 board.push_uci(move.uci())
 print board

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

Я делаю успехи ...

Сегодня уже не было времени писать шахматный код. Итак, в сегодняшнем посте я подумал, что поделюсь другой частью моих приготовлений: собственно играми.

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

В частности, я практиковал 1. Выбирать правильные ходы для оценки и 2. Делать правильные ходы без алгоритма, когда я уверен на 100%.

Однако в последнее время я также практикую свои атакующие способности. Другими словами, я пытался агрессивно поставить мат королю соперника в середине игры (по сравнению с моим типичным подходом к обмену фигурами и попыткам выиграть в конце игры).

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

Игра 1 - я играю белыми и получаю черного ферзя на 15-м ходу.

Игра 2 - я играю черными и ставлю мат белыми за 12 ходов

Игра 3 - я играю белыми и ставлю мат черными за 26 ходов

Эти игры не идеальны. Я все еще делаю несколько серьезных ошибок за игру, как и мои оппоненты.

Фактически, это одна из самых больших проблем с Chess.com: меня сравнивают только с реальными людьми с таким же уровнем навыков, что не способствует оптимальному совершенствованию.

Но я все еще могу проверить свои новые идеи в этой среде, полагаясь при этом на алгоритмическую часть моего подхода для более масштабных улучшений.

Надеюсь, завтра у меня будет время, чтобы добиться большего алгоритмического прогресса ...

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

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

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

Сегодня, во время полета, я собираюсь изменить эту программу, чтобы вместо вывода числового значения она выводила либо «хороший ход», либо «плохой ход».

Другими словами, мне нужно определить порог между хорошим и плохим, а затем реализовать это пороговое значение в моей программе.

Я попытаюсь воспроизвести способ, которым Chess.com реализует свой порог между «хорошими» ходами и «неточностями».

Я заметил, что, как правило, ход считается неточным, если он отрицательно влияет на оценку игры более чем на 0,3 сантипешки, но я также заметил, что эта эвристика значительно меняется в зависимости от абсолютного размера оценка (например, неточности измеряются по-разному, если оценка составляет +0,75 против +15).

Итак, мне нужно будет пройтись по моим прошлым играм на Chess.com и попытаться реконструировать, как они производят эти вычисления.

Как только я это сделаю, я могу реализовать это пороговое значение в своей программе.

Пока я жду самолет, я реализовал наивную версию этого порогового значения, где неточности описываются фиксированной разницей в 0,3.

import chess
import chess.pgn
import chess.uci
board = chess.Board()
pgn = open("data/rickymerritt1_vs_maxdeutsch_2017-10-14_analysis.pgn")
test_game = chess.pgn.read_game(pgn)
engine = chess.uci.popen_engine("stockfish")
engine.uci()
info_handler = chess.uci.InfoHandler()
engine.info_handlers.append(info_handler)
prev_eval = 0
diff = 0
for move in test_game.main_line():
print move
engine.position(board)
 engine.go(movetime=2000)
 evaluation = info_handler.info["score"][1].cp
if board.turn:
  if prev_eval - evaluation > 0.3:
   print "bad move"
  else:
   print "good move"
 
 if not board.turn:
  evaluation *= -1
  if evaluation - prev_eval > 0.3:
   print "bad move"
  else:
   print "good move"
  
 prev_eval = evaluation
 
 board.push_uci(move.uci())
 print board

Вчера, в самолете, у меня возникла действительно интересная идея: Может ли комната, полная шахматистов-любителей, победить лучшего шахматиста мира менее чем за час коллективных тренировок?

Я думаю, что ответ - да, и, по сути, они могли бы использовать распределенную версию моего алгоритмического подхода (например, Max Chess) для этого.

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

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

В прошлом были попытки шахматных игр в стиле Wisdom of the Crowds, когда тысячи шахматистов сражались против одного гроссмейстера. В этих играх каждый член толпы рекомендует ход, и разыгрывается самый популярный ход, в то время как гроссмейстер играет как обычно.

В самой популярной из этих партий гроссмейстер Гарри Каспаров победил более 50 000 зрителей. Другими словами, толпа была не такой уж мудрой.

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

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

Чтобы быть ясным, это не означает, что я отказываюсь от подхода одного человека. Я все еще пытаюсь сделать это самостоятельно.

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

Может быть, после того, как я выполню задание в этом месяце, я попытаюсь организовать массовый шахматный матч, основанный на алгоритмах.

Сегодня я был на Манхэттене и, пока был там, заехал в Брайант-парк, чтобы сыграть несколько партий против шахматных болельщиков.

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

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

Цифровая доска выглядит так…

В то время как физическая доска выглядит так ...

Я определенно привыкаю к ​​цифровой доске, поэтому сегодняшние игры в парке были приятным изменением.

Я сыграл три игры против трех разных соперников, по 5 минут на каждого. Во всех трех случаях меня избивали ловко. Эти ребята были хороши.

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

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

def convertLetterToNumber(letter):
 if letter == 'K':
  return '100000000000'
 if letter == 'Q':
  return '010000000000'
 if letter == 'R':
  return '001000000000'
 if letter == 'B':
  return '000100000000'
 if letter == 'N':
  return '000010000000'
 if letter == 'P':
  return '000001000000'
 if letter == 'k':
  return '000000100000'
 if letter == 'q':
  return '000000010000'
 if letter == 'r':
  return '000000001000'
 if letter == 'b':
  return '000000000100'
 if letter == 'n':
  return '000000000010'
 if letter == 'p':
  return '000000000001'
 if letter == '1':
  return '000000000000'
 if letter == '2':
  return '000000000000000000000000'
 if letter == '3':
  return '000000000000000000000000000000000000'
 if letter == '4':
  return '000000000000000000000000000000000000000000000000'
 if letter == '5':
  return '000000000000000000000000000000000000000000000000000000000000'
 if letter == '6':
  return '000000000000000000000000000000000000000000000000000000000000000000000000'
 if letter == '7':
  return '000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
 if letter == '8':
  return '000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000000'
 if letter == '/':
  return ''
def convertToBB(board):
 bitBoard = ''
 board = str(board.fen()).split(' ')[0]
 for letter in board:
  bitBoard = bitBoard + convertLetterToNumber(letter)
 return bitBoard
print convertToBB(board)

Хотя я добился некоторого прогресса в алгоритме, с тех пор, как я был в Нью-Йорке, я не добился такого большого прогресса, как я надеялся, только потратил на это несколько минут то тут, то там.

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

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

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

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

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

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

Интересно, однако, что добавление к моим шахматным знаниям обычным способом не уменьшило моего интеллектуального удовольствия от игры, как я ожидал. Фактически, это увеличило его.

Чем больше я вижу и понимаю, тем больше могу оценить красоту отдельных шахматных линий или комбинаций ходов.

Конечно, есть определенные части моей игры, которые теперь более механичны, но это позволяет мне исследовать новые интеллектуальные курьезы и комбинации на более высоких уровнях. Кажется, всегда есть более высокий уровень для изучения (особенно с учетом того, что мой шахматный рейтинг составляет около 1200, в то время как Магнус - 2822, а компьютеры - около 3100).

Чем больше обычных шахмат я выучил в этом месяце, тем больше меня тянет к традиционному подходу. В игре есть что-то интеллектуально красивое и есть потенциал для непрерывного прогресса, и я хотел бы исследовать этот мир дальше.

С учетом сказанного, этот мир нельзя полностью изучить за один месяц, поэтому я с радостью продолжаю уделять основное внимание моему алгоритмическому подходу.

Чтобы быть ясным, я не противопоставляю алгоритмический подход традиционному. Вместо этого я говорю: «В начале этого месяца я влюбился в математическую красоту алгоритмического подхода и возможность открыть новые горизонты. Буквально сегодня я наконец обнаружил похожую красоту в том, как традиционно играют и изучают шахматы, и тоже хочу исследовать это дальше ».

Другими словами, в этом месяце я развиваю два новых увлечения, которыми я могу наслаждаться, ценить и исследовать всю оставшуюся жизнь.

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

Сегодня мой мозг внезапно определил традиционные шахматы как одно из занятий на всю жизнь.

Если бы я так ценил традиционные шахматы в начале месяца, мне интересно, смог бы я так легко и быстро прибегнуть к алгоритмическому подходу, или я бы сдерживался своим романтизмом в пользу «нормального пути».

К счастью, этого не произошло, и теперь я могу исследовать и то, и другое параллельно.

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

Таким образом, сегодня пришло время приступить к построению самой модели машинного обучения.

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

Мне не пришлось особо искать: версия Hello World для машинного обучения называется MNIST, и она идеально подходит для моих целей.

MNIST - это набор данных, состоящий из изображений рукописных цифр размером 28 x 28 пикселей, таких как:

Набор данных также включает десять меток, указывающих, какая цифра представлена ​​на каждом изображении (т.е. метки для приведенных выше изображений будут 5, 0, 4, 1).

Цель состоит в том, чтобы создать модель, которая, учитывая набор из 28 x 28 = 784 значений, может точно предсказать правильную числовую цифру.

Точно так же цель моей шахматной модели, учитывая набор из 8 x 8 = 64 значений (где каждое значение представлено с использованием 12-значного горячего кодирования), состоит в том, чтобы точно предсказать, является ли шахматный ход правильным. хороший ход или плохой ход.

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

Вот код, который я нашел:

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import sys
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
FLAGS = None
def main(_):
  # Import data
  mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)
# Create the model
  x = tf.placeholder(tf.float32, [None, 784])
  W = tf.Variable(tf.zeros([784, 10]))
  b = tf.Variable(tf.zeros([10]))
  y = tf.matmul(x, W) + b
# Define loss and optimizer
  y_ = tf.placeholder(tf.float32, [None, 10])
# The raw formulation of cross-entropy,
  cross_entropy = tf.reduce_mean(
      tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
  train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
sess = tf.InteractiveSession()
  tf.global_variables_initializer().run()
  # Train
  for _ in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
# Test trained model
  correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
  accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
  print(sess.run(accuracy, feed_dict={x: mnist.test.images,
                                      y_: mnist.test.labels}))
if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument('--data_dir', type=str, default='/tmp/tensorflow/mnist/input_data',
                      help='Directory for storing input data')
  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

Завтра я попробую изменить этот код и посмотрю, смогу ли я заставить что-нибудь работать.

Закон Паркинсона гласит, что «работа расширяется, чтобы заполнить время, доступное для ее завершения», и я определенно испытываю это явление во время этой последней задачи M2M.

В частности, в начале месяца я решил продлить эту задачу до начала ноября, вместо того, чтобы сдерживать ее в течение одного месяца. Я сделал это по уважительной причине, которую вскоре объясню, но это дополнительное время мне не помогает.

Вместо этого я просто скорректировал свой темп, чтобы работа соответствовала расширенному графику.

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

Итак, чтобы бороться с замедлением темпов и начать набирать обороты, я решил установить промежуточный крайний срок: к воскресенью, 29 октября, я должен закончить создание своего шахматного алгоритма и полностью переключить свое внимание на изучение и отработку алгоритма.

Это дает мне одну неделю на: 1. Создание модели машинного обучения, 2. Завершение создания полного набора данных, 3. Тестирование обученной модели, 4. Выполнение дальнейших оптимизаций, 5. Проверка силы шахматного алгоритма и, в целом, 6. Подтверждение или признание подхода недействительным.

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

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

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

Вот код целиком:

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import sys
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
FLAGS = None
def main(_):
  # Import data
  mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)
# Create the model
  x = tf.placeholder(tf.float32, [None, 784])
  W = tf.Variable(tf.zeros([784, 10]))
  b = tf.Variable(tf.zeros([10]))
  y = tf.matmul(x, W) + b
# Define loss and optimizer
  y_ = tf.placeholder(tf.float32, [None, 10])
# The raw formulation of cross-entropy,
  cross_entropy = tf.reduce_mean(
      tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
  train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)
sess = tf.InteractiveSession()
  tf.global_variables_initializer().run()
  # Train
  for _ in range(1000):
    batch_xs, batch_ys = mnist.train.next_batch(100)
    sess.run(train_step, feed_dict={x: batch_xs, y_: batch_ys})
# Test trained model
  correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
  accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
  print(sess.run(accuracy, feed_dict={x: mnist.test.images,
                                      y_: mnist.test.labels}))
if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument('--data_dir', type=str, default='/tmp/tensorflow/mnist/input_data',
                      help='Directory for storing input data')
  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

Часть 1: Импорт необходимых библиотек и вспомогательных функций

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

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import sys
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf

Что наиболее важно, строка 6 («from tensorflow.examples.tutorials.mnist import input_data») используется для импорта набора данных, а строка 7 («импортировать тензорный поток как tf» ) используется для импорта фреймворка машинного обучения TensorFlow.

Я могу оставить эти семь строк как есть, за исключением строки 6, которая будет зависеть от формата моих шахматных данных.

Часть 2: Чтение набора данных

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

FLAGS = None
def main(_):
  # Import data
  mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)

Это часть кода, которая меня больше всего пугает, но у меня есть несколько идей.

Во-первых, судя по документации, прилагаемой к коду Github, кажется, что данные готовятся довольно просто и содержатся в двух матрицах:

1. Первая матрица имеет размеры 784 на 55 000, где 784 представляет количество пикселей в изображении, а 55 000 представляет количество изображений в наборе данных.
2. Вторая матрица имеет размеры 10 на 55000, где 10 представляет метки (то есть названия цифр) для каждого изображения, и снова 55000 представляет количество изображений.

Я должен быть в состоянии подготовить две похожие матрицы для моих шахматных данных, даже если я не буду делать это особенно изощренно. Фактически, я мог бы построить эти матрицы в формате Python, а затем просто скопировать и вставить их в тот же файл, что и остальной код, так что мне не нужно беспокоиться о фактическом считывании данных в программу и т. Д.

Это звучит немного взломано, но должно помочь.

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

from __future__ import absolute_import
from __future__ import division
from __future__ import print_function
import argparse
import sys
from tensorflow.examples.tutorials.mnist import input_data
import tensorflow as tf
FLAGS = None
def main(_):
  # Import data
  mnist = input_data.read_data_sets(FLAGS.data_dir, one_hot=True)
  
  print(mnist.test.images[0])
  
if __name__ == '__main__':
 parser = argparse.ArgumentParser()
 parser.add_argument('--data_dir', type=str, default='/tmp/tensorflow/mnist/input_data',
       help='Directory for storing input data')
 FLAGS, unparsed = parser.parse_known_args()
 tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

А вот что напечатано:

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

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

Что касается меток, в моем случае «хороший ход» и «плохой ход», мне нужно вложить двухзначные массивы (по одному массиву для каждой метки на шахматной доске) внутри большего массива.

В этом случае [1, 0] = хороший ход и [0,1] = плохой ход. Такая структура соответствует структуре one_hot = True исходной программы.

Исходная программа, вероятно, разделяет все метки таким образом, а не использует двоичную нотацию, чтобы указать, что метки не коррелированы друг с другом.

В случае с шахматами, хорошее или плохое качество хода технически коррелировано, но пока я остановлюсь на одной горячей структуре.

Часть 3: Создайте модель

Следующие пять строк кода используются для определения формы модели.

# Create the model
  x = tf.placeholder(tf.float32, [None, 784])
  W = tf.Variable(tf.zeros([784, 10]))
  b = tf.Variable(tf.zeros([10]))
  y = tf.matmul(x, W) + b

В этом случае скрытых слоев нет. Функция просто отображает входы напрямую в выходы, без промежуточных шагов.

В приведенном выше примере 784 представляет размер изображения, а 10 представляет количество возможных меток.

Точно так же для моей шахматной программы 773 представляет размер представления на шахматной доске, а 2 представляет количество возможных меток.

Итак, я могу обновить код для своих целей следующим образом:

# Create the model
  x = tf.placeholder(tf.float32, [None, 773])
  W = tf.Variable(tf.zeros([773, 2]))
  b = tf.Variable(tf.zeros([2]))
  y = tf.matmul(x, W) + b

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

# Create the model
  x = tf.placeholder(tf.float32, [None, 773])
  W1 = tf.Variable(tf.zeros([773, 16]))
  b1 = tf.Variable(tf.zeros([16]))
  h1 = tf.matmul(x, W1) + b1
  W2 = tf.Variable(tf.zeros([16, 16]))
  b2 = tf.Variable(tf.zeros([16]))
  h2 = tf.matmul(h1, W2) + b2
  W3 = tf.Variable(tf.zeros([16, 2]))
  b3 = tf.Variable(tf.zeros([2]))
  y = tf.matmul(h2, W3) + b3

Часть 4: Обучение модели

Теперь, когда у нас есть структура для настройки нашей модели, нам нужно ее обучить.

Другими словами, нам нужно указать программе, как распознать, хорошая или плохая модель. Хорошая модель хорошо аппроксимирует функцию, которая правильно сопоставляет шахматные позиции с оценками, а плохая - нет.

# Define loss and optimizer
  y_ = tf.placeholder(tf.float32, [None, 10])
# The raw formulation of cross-entropy,
  cross_entropy = tf.reduce_mean(
      tf.nn.softmax_cross_entropy_with_logits(labels=y_, logits=y))
  train_step = tf.train.GradientDescentOptimizer(0.5).minimize(cross_entropy)

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

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

Часть 5: Протестируйте обученную модель

После обучения модели мы хотим проверить, насколько хорошо она работает, сравнивая то, что модель предсказывает, с истинными метками в наборе данных.

# Test trained model
  correct_prediction = tf.equal(tf.argmax(y, 1), tf.argmax(y_, 1))
  accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
  print(sess.run(accuracy, feed_dict={x: mnist.test.images,
                                      y_: mnist.test.labels}))

Когда модель выводит прогноз, она выводит 10-значный массив, где каждая цифра массива представляет собой число от 0 до 1. Затем этот массив передается в функцию tf.argmax (y, 1) , который выводит метку, соответствующую позиции в массиве со значением, наиболее близким к 1.

Часть 6. Запускаем программу

Наконец, есть код, необходимый для запуска программы:

if __name__ == '__main__':
  parser = argparse.ArgumentParser()
  parser.add_argument('--data_dir', type=str, default='/tmp/tensorflow/mnist/input_data',
                      help='Directory for storing input data')
  FLAGS, unparsed = parser.parse_known_args()
  tf.app.run(main=main, argv=[sys.argv[0]] + unparsed)

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

Вчера я разобрал построчно код, который использую для генерации своего шахматного алгоритма. Сегодня я немного подробнее изучил этот код.

В частности, сегодня я хотел ответить на два вопроса:

Вопрос 1

После того, как я полностью обучу модель машинного обучения, как мне вывести полученные алгоритмические параметры в удобочитаемом формате (чтобы затем я мог приступить к их запоминанию)?

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

Однако, в отличие от обычного кода Python, Tensorflow не допускает такого синтаксиса.

Немного поигравшись, я обнаружил, что мне нужно запустить Tensorflow Interaction Session, чтобы извлечь значения W.

Теоретически в этом нет ничего необычного. Это просто синтаксис, который требует Tensorflow ...

sess = tf.InteractiveSession()
tf.global_variables_initializer().run()
for i in range(0,784):
  for j in range(0,10):
    param = sess.run(W)[i][j]
    print(round(param,2))

И вот результат - список всех 7840 параметров, содержащихся в W:

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

Мне все еще нужно выяснить, как обновить эти значения в W, а затем проверить, что модель по-прежнему достаточно хорошо работает с таким уровнем детализации. (Если нет, значит, у моего алгоритмического подхода большие проблемы).

вопрос 2

Действительно ли моя более сложная модель дает лучшие результаты? И если да, то насколько лучше результаты, чтобы оправдать дополнительную сложность?

Если я просто запустил образец кода как он (где код пытается идентифицировать рукописные числовые цифры во входных изображениях), модель предсказывает правильную цифру в 92% случаев, что неплохо.

Если я сделаю модель в образце кода более сложной, добавив два скрытых слоя и затем повторно протестировав ее прогнозы, она будет правильно определять цифры только в 11% случаев (т.е. по сути не лучше, чем случайное предположение).

Я не уверен, что у меня просто недостаточно данных для обучения этой более сложной модели, или есть пробел в моем понимании относительно построения более сложных моделей.

Если это проблема с данными, я могу это решить. Если это пробел в моем понимании, я тоже могу это исправить, но это может выявить некоторые потенциальные препятствия для моего алгоритмического шахматного подхода.

Надеюсь, я найду путь вперед. Надеюсь, есть хоть какой-то путь вперед.

Сегодня у меня появилась хорошая идея. Фактически, после мозгового штурма с другом я придумал верный способ выполнить задание этого месяца.

Важно отметить, что эта идея была в значительной степени вдохновлена ​​Натаном Филдером из Натана для тебя Comedy Central, который в настоящее время является единственным телешоу, которое я смотрю. Хотя юмор шоу, вероятно, не для всех, я нахожу шоу великолепным и чрезвычайно удовлетворительным.

Во всяком случае, вот идея:

Как я определил задачу этого месяца, мне нужно победить чемпиона мира Магнуса Карлсена в шахматной партии.

Оказывается, что в этом определении успеха есть одна небольшая лазейка: я не уточнил, что Магнус Карлсен должен быть чемпионом мира по шахматам. Скорее, я просто уточнил, что ему нужно быть чемпионом мира.

Другими словами, мне не нужно побеждать Магнуса Карлсена в шахматной партии. Мне просто нужно победить a Магнуса Карлсена в шахматной партии, если этот Магнус Карлсен является чемпионом мира во всем.

Во-первых, после быстрого поиска в Facebook я нашел десятки других Магнуса Карлсена, которые были бы идеальными кандидатами на мой шахматный матч. Думаю, Магнус Карлсен - довольно популярное скандинавское имя.

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

Как только у меня появится желающий Магнус Карлсен, мне нужно будет убедиться, что он в чем-то чемпион мира.

Это невероятно гибкое ограничение ...

Я мог бы даже попросить Магнуса Карлсена №2 изобрести новую настольную игру, правила которой знает только он, гарантируя, что он станет чемпионом мира. Конечно, на всякий случай я бы устроил чемпионат мира.

Затем, если предположить, что Магнус Карлсен №2 не очень хороший шахматист, мы сыграем партию в шахматы, и я легко одолею его, тем самым позволив мне официально победить чемпиона мира Магнуса Карлсена в шахматной партии.

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

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

Мой рейс из Нью-Йорка в Сан-Франциско только что приземлился, а это значит, что завтра я вернусь к своему обычному распорядку дня. В рамках этого «обычного распорядка» я планирую значительно ускорить свои шахматные усилия.

Последние восемь дней я был в Нью-Йорке, в основном на семейном мероприятии, которое длилось все выходные (с пятницы по воскресенье). В течение шести рабочих дней, что я был в Нью-Йорке, оставаясь в доме родителей, я все еще работал полный рабочий день. Это был не отпуск.

В результате мне нужно было принять решение о том, как я хочу проводить внеурочное время по вечерам.

Обычно я в основном использую это время для своего проекта M2M и связанных с ним мероприятий, но, учитывая, что я не видел своих родителей, сестер и родственников в течение нескольких месяцев и не часто их вижу, я хотел выделить много этого времени провести с ними.

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

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

Часто бывает сложно расставить приоритеты с друзьями, семьей и т. Д., И точно так же сложно расставить приоритеты со временем, чтобы расслабиться, поиграть и подумать, поскольку у этих мероприятий нет сроков, крайних сроков или способов измерения продуктивности или прогресс. Особенно сложно расставить приоритеты для этих действий, когда есть другие доступные действия, которые действительно предлагают большее ощущение прогресса, продуктивности или срочности.

Мы, люди, хотим чувствовать себя важными и часто используем прогресс или продуктивность (или даже ненужную занятость) как способ доказать себе, что мы важны.

Но мы также можем быть важны, просто наслаждаясь любовью, которую разделяем с другими (проводя время с друзьями и семьей), и наслаждаясь любовью, которую испытываем к себе (расслабляясь, играя, исследуя и т. Д.).

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

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

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

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

Я не идеален в сопротивлении этому искушению, но прошедшая неделя была хорошей практикой в ​​том, чтобы сделать это и пожинать плоды.

С учетом сказанного, теперь, когда я вернулся в Сан-Франциско, я собираюсь восстановить это массивное, в значительной степени искусственное чувство важности и безотлагательности, которое окружает задачу этого месяца.

Итак, я иду ...

Сегодня я наконец вернулся к работе над своим шахматным алгоритмом, который надеюсь закончить к вечеру воскресенья.

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

После просмотра нескольких руководств по Tensorflow на YouTube я смог написать новую программу, которая работает с наборами данных CSV. Мне даже удалось запустить его на крошечном тестовом наборе данных:

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

Вот как выглядят эти изменения:

import chess
import chess.pgn
import chess.uci
board = chess.Board()
pgn = open("data/caruana_carlsen_2017.pgn")
test_game = chess.pgn.read_game(pgn)
engine = chess.uci.popen_engine("stockfish")
engine.uci()
info_handler = chess.uci.InfoHandler()
engine.info_handlers.append(info_handler)
prev_eval = 0
diff = 0
output_data_string = ''
def convertLetterToNumber(letter):
 if letter == 'K':
  return '1,0,0,0,0,0,0,0,0,0,0,0,'
 if letter == 'Q':
  return '0,1,0,0,0,0,0,0,0,0,0,0,'
 if letter == 'R':
  return '0,0,1,0,0,0,0,0,0,0,0,0,'
 if letter == 'B':
  return '0,0,0,1,0,0,0,0,0,0,0,0,'
 if letter == 'N':
  return '0,0,0,0,1,0,0,0,0,0,0,0,'
 if letter == 'P':
  return '0,0,0,0,0,1,0,0,0,0,0,0,'
 if letter == 'k':
  return '0,0,0,0,0,0,1,0,0,0,0,0,'
 if letter == 'q':
  return '0,0,0,0,0,0,0,1,0,0,0,0,'
 if letter == 'r':
  return '0,0,0,0,0,0,0,0,1,0,0,0,'
 if letter == 'b':
  return '0,0,0,0,0,0,0,0,0,1,0,0,'
 if letter == 'n':
  return '0,0,0,0,0,0,0,0,0,0,1,0,'
 if letter == 'p':
  return '0,0,0,0,0,0,0,0,0,0,0,1,'
 if letter == '1':
  return '0,0,0,0,0,0,0,0,0,0,0,0,'
 if letter == '2':
  return '0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,'
 if letter == '3':
  return '0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,'
 if letter == '4':
  return '0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,'
 if letter == '5':
  return '0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,'
 if letter == '6':
  return '0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,'
 if letter == '7':
  return '0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,'
 if letter == '8':
  return '0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,0,'
 if letter == '/':
  return ''
def convertToBB(board):
 bitBoard = ''
 board = str(board.fen()).split(' ')[0]
 for letter in board:
  bitBoard = bitBoard + convertLetterToNumber(letter)
 bitBoard = bitBoard[1:-1]
 return bitBoard
for move in test_game.main_line():
 
 engine.position(board)
 engine.go(movetime=2000)
 evaluation = info_handler.info["score"][1].cp
 evaluation_label = ""
if board.turn:
  if prev_eval - evaluation > 0.3:
   evaluation_label = "B" #badmove
  else:
   evaluation_label = "G" #goodmove
 
 if not board.turn:
  evaluation *= -1
  if evaluation - prev_eval > 0.3:
   evaluation_label = "B" #badmove
  else:
   evaluation_label = "G" #goodmove
  
 prev_eval = evaluation
 
 board.push_uci(move.uci())
 out_board = convertToBB(board)
 
 output_data_string = output_data_string + out_board + ',' + evaluation_label + '\n'
 
f = open('chessdata.csv','w')
f.write(output_data_string)
f.close()

И вот результат… (Каждая строка имеет 768 столбцов с единицами и нулями, соответствующими битовому представлению шахматной позиции, а 769-й столбец - это либо G, либо B, что означает шахматную позицию как «хорошую» или "Плохо" соответственно. Я еще не закодировал права на рокировку. Я сделаю это, как только смогу заставить мою текущую настройку работать.)

После этого у меня были две части, которые мне были нужны: 1. Способ преобразования шахматных позиций в файлы CSV и 2. Способ чтения файлов CSV в модель машинного обучения.

Однако когда я попытался собрать их вместе, программа не запустилась. Вместо этого у меня были только такие ошибки…

pandas.errors.ParserError: Ошибка токенизации данных. Ошибка C: ожидается 2 поля в строке 8, увидено 5

… Предполагая, что мой набор данных был в некоторой степени «грязным».

И этот…

ValueError: невозможно передать значение shape (43, 1) для тензор u’Placeholder_1: 0 ', который имеет shape ‘(?, 2)’

… Предполагая, что мои данные не соответствовали модели машинного обучения, что также, вероятно, является результатом «грязных» данных.

Я попытался очистить данные вручную, но продолжал получать сообщения об ошибках.

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

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

Наконец, он работал (в том смысле, что он работал), но не мог рассчитать «функцию затрат», которая является одним из наиболее важных компонентов процесса обучения машинному обучению.

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

Завтра попробую диагностировать проблему.

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

Вчера, после целенаправленного 90-минутного сеанса программирования, я почти смог заставить свою программу читать CSV-представление шахматной позиции, а затем использовать его для обучения модели машинного обучения.

Сегодня я смог идентифицировать и исправить ошибку во вчерашнем коде, что позволило мне успешно запустить программу и обучить мою модель.

Затем я написал код, который принимает параметры полученной модели и записывает их в файл CSV следующим образом:

После этого я официально завершил полный конвейер шахматных алгоритмов.

Вот что умеет конвейер:

1. Берет шахматную партию, загруженную из Интернета, и преобразует ее в правильно отформатированный CSV. Файл CSV содержит битовую доску (то есть 1 и 0), представляющую шахматную позицию, и помечает каждую шахматную позицию как «хорошую» или «плохую», используя шахматный движок Stockfish для вычисления всех оценок.
2. Считывает файл CSV в программу машинного обучения, рандомизирует порядок данных, разделяет данные на набор данных для обучения и набор данных для тестирования, обучает модель машинного обучения на наборе обучающих данных и проверяет производительность модели на наборе данных для тестирования.
3. После того, как модель настроена так, чтобы она могла правильно определять «хорошие» и «плохие» шахматные позиции, она выводит алгоритмические параметры в другой, правильно организованный файл CSV. Скоро я воспользуюсь этим файлом, чтобы запомнить все алгоритмические параметры, эффективно превратив мой мозг в шахматный компьютер.

Почти весь этот код был написан за последние два дня (в течение двух часов), что довольно удивительно, учитывая, что я добился значительного прогресса за последние две недели.

Ясно, что полностью сфокусированный и целеустремленный подход имеет большое значение.

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

Это был большой прогресс, но по состоянию на вчерашний день все еще оставалась проблема: та часть моей программы, которая предназначена для обозначения каждой шахматной позиции либо «хорошей», либо «плохой» (чтобы модель машинного обучения знала, как правильно оценка позиции) вообще не сработало…

Другими словами, программа выводила метки «хорошо» и «плохо» почти случайным образом, фактически не привязанные к истинной оценке шахматной позиции.

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

Итак, сегодня я работал над решением этой проблемы.

В частности, я постоянно настраивал свою программу, пока ее результаты не совпадали с «истинными» оценками позиций.

В качестве источника истины я использовал веб-сайт lichess.org, который позволяет пользователям импортировать и анализировать шахматные партии, явно выявляя все плохие ходы (неточности, ошибки и промахи) в данной партии:

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

Итак, я наконец был готов сгенерировать свой набор данных с правильной маркировкой.

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

Я использую шахматную базу данных с lichess.org (которая содержит более 200 миллионов шахматных партий) для создания правильного набора данных для этикеток.

Прямо сейчас я запускаю все игры сентября 2017 года (а это около 12 миллионов игр) через свою программу.

Поскольку программа должна глубоко оценивать каждую позицию, используя шахматный движок Stockfish с глубиной 22, выполнение программы занимает много времени. Похоже, что он сможет проходить только около 150 партий каждые 24 часа или примерно 6000 шахматных позиций, если я продолжу запускать его только на моем локальном компьютере.

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

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

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

Вчера я предсказывал, что смогу обрабатывать 150 шахматных партий каждые 24 часа. С момента этого прогноза прошло 24 часа, а на самом деле я обрабатываю около 350 игр каждые 24 часа.

Фактически, на данный момент я оценил 10 000 шахматных позиций (как хорошие, так и плохие) и записал эти оценки в свой CSV-файл training_dataset, готовый для использования моей моделью машинного обучения.

Хотя мне все еще нужно намного больше данных, сегодня, около 14:00, я начал обучать свою модель на имеющихся данных, просто чтобы посмотреть, что произойдет.

Вначале точность модели, измеренная на данных обучения, составляла лишь немногим более 50% (то есть полностью случайная оценка, хорошая или плохая, шахматных позиций).

Восемь часов спустя, после 10 000 итераций по 7 000 шахматных позиций (с тех пор было обработано 3 000 шахматных позиций), точность модели на обучающих данных выровнялась примерно до 99%.

Сначала я не понимал, что эта точность основана на обучающих данных, поэтому подумал, что это невероятно хорошо. Другими словами, я думал, что этот показатель точности отражает то, как модель работает с данными, которых она никогда раньше не видела (в то время как на самом деле модель оптимизировалась вокруг этих точных данных).

Когда я тестировал модель на подлинных тестовых данных (т. Е. Данных, которые модель никогда раньше не видела), она могла правильно оценить позицию только примерно в 70% случаев, что не очень хорошо.

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

Конечно, чем больше данных, тем дольше будет работать модель, а это означает, что тем медленнее я смогу повторять свой подход.

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

Я все еще добиваюсь прогресса, но производительность 70% - это немного разочарование после того, как я ждал почти восемь часов, чтобы увидеть результаты.

Вчера, после восьми часов обработки, я смог протестировать первую версию своего шахматного алгоритма.

К сожалению, он мог правильно оценивать шахматные позиции как хорошие или плохие только в 70% случаев, что не очень хорошо для моих целей.

Конечно, этот алгоритм был создан только на основе 300 шахматных партий, а у меня есть доступ к более чем 200 миллионам партий. Итак, надеюсь, алгоритм станет более точным, поскольку я скармливаю ему значительно больше данных.

Даже если я смогу создать алгоритм с точностью 99%, все равно неясно, насколько хорошо этот алгоритм можно использовать для игры в шахматы на высоком уровне.

Другими словами, даже если я могу определять «хорошие» шахматные ходы с точностью 99%, достаточно ли этого, чтобы победить лучшего шахматиста мира?

Чтобы выяснить это, я сегодня создал программу, которая позволяет мне протестировать мой алгоритм в реальном игровом процессе. Вот как это работает:

1. Поскольку я играю белыми, делаю первый ход. Для этого предлагаю перейти в программу.
2. Затем программа прогоняет этот ход по моему алгоритму и решает, хороший или плохой ход.
3. Если все в порядке, программа автоматически воспроизводит ход. Если нет, меня просят предложить другой ход, пока я не найду хороший ход.
4. Затем мой противник отвечает черными фигурами. Вношу в программу ход черных.
5. После того, как ход черных записан, я предлагаю свой следующий ход, который снова повторяется, если ход оценивается как хороший.
6. И так, пока игра не закончится.

Вот как выглядит программа, запущенная в моем Терминале:

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

Если я смогу найти алгоритм, который при таком использовании позволит мне победить Magnus Age 26 в приложении Play Magnus, тогда я смогу приступить к изучению алгоритма, чтобы полностью выполнить его в своем мозгу.

Сейчас, поскольку точность алгоритма составляет всего 70%, он все еще очень плохо играет в шахматы. Я играл в игру, слепо используя алгоритм, против Magnus Age 7 в приложении Play Magnus, и очень быстро проиграл.

Тем не менее, это захватывающая веха: наконец-то у меня есть все фигуры, которые мне нужны, чтобы играть в алгоритмические шахматы (например, Max Chess). Теперь мне просто нужно улучшить сам алгоритм ...

Сегодня 365-й день моего проекта M2M, и это 365-й пост в блоге подряд. Другими словами, я занимаюсь M2Ming ровно год, что безумно думать.

На самом деле, трудно вспомнить, какой была жизнь до M2M, когда мне не нужно было писать в блоге каждый день. Это ведение блога стало естественной, ожидаемой частью моей повседневной жизни.

В начале этого проекта сегодня должен был быть последний день. Завтра я проснусь, и проект закончится.

Но это не совсем то, что происходит ...

Как объяснялось 1 октября, я продлил задание этого месяца на ноябрь по причинам, о которых я очень скоро расскажу.

Первоначально я сказал, что закончу 9 ноября, но похоже, что могу продолжить вести блог до 17 ноября или около того.

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

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

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

В частности, я не могу использовать свой персональный компьютер для обработки объема данных, который мне нужен для построения моего шахматного алгоритма в разумные сроки. Мне нужен гораздо более быстрый и мощный компьютер.

К счастью, существуют облачные вычисления, когда я просто загружаю свой код на чужой компьютер (Amazon, Google и т. Д.) Через Интернет, а затем отправляю их специально оптимизированные машины в город.

Если бы только это было так просто ...

Некоторое время я пытался запустить свой код в Amazon Web Services, но без особого успеха. После базовой настройки я изо всех сил пытался поместить свой массивный набор данных в хранилище Amazon, чтобы к нему можно было получить доступ во время выполнения кода.

Но потом, исследуя свои возможности, я наткнулся на инструмент под названием Флойд, и это чистая магия.

Floyd - это слой, который находится поверх AWS и позволяет мне очень легко развертывать мой код:

1. Я открываю Терминал и перехожу в папку chess-ai на моем локальном компьютере.
2. Я запускаю две специальные команды Флойда
3. Мой код загружается на серверы Floyd и мгновенно запускается на их компьютерах, оптимизированных для графического процессора.

Мне нужно было разобраться с несколькими дополнительными вещами, такими как отдельная загрузка и «монтирование» моего набора данных, загрузка выходных файлов с серверов Floyd и т. Д.

Но в целом у меня все наладилось очень быстро.

В результате вот моя модель работает сейчас ...

Компьютеры Floyd кажутся примерно в 3 раза быстрее, чем мой персональный компьютер, и я могу выполнять несколько заданий параллельно, так что это определенно помогает. Floyd работает примерно на 75% скорости AWS, но простота использования с лихвой компенсирует это. Кроме того, самый крупный план составляет всего 99 долларов в месяц, и я с радостью заплачу за что-нибудь настолько хорошее.

Всегда здорово найти новый инструмент, который я могу добавить в свой арсенал.

Теперь, когда мне понадобится заняться каким-либо проектом в области науки о данных или машинного обучения в будущем, я буду знать, где и как его развернуть, всего за несколько минут.

Вот почему изучение соединений с течением времени… Сегодня я проделал большую предварительную работу, чтобы найти лучший инструмент и научиться его использовать. Теперь я могу продолжать пожинать плоды вечно.

У меня может быть проблема ...

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

Несколько дней назад я мог заставить свой алгоритм правильно маркировать шахматную позицию как хорошую или плохую только в 70% случаев. Я решил, что смогу увеличить этот показатель примерно до 98–99%, просто увеличив масштаб своей деятельности.

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

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

Другими словами, после того, как мой алгоритм достиг отметки 70%, любая попытка его улучшить на самом деле приводила к его ухудшению ...

Например, после 6600 итераций точность теста составила 68,1%:

После 9900 итераций точность теста упала до 67,6%:

Итак, похоже, что моя модель в том виде, в котором она сейчас построена, достигает максимума в 70%, что не очень хорошо. На самом деле, я готов поспорить, причина того, что здесь наблюдается плато, довольно проста: 70% данных в наборе данных помечены как «хорошие», а остальные - как «плохие».

Другими словами, моя модель работает лучше всего, если просто угадать, что каждая шахматная позиция «хорошая», тем самым автоматически достигая 70% точности.

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

Что теперь?

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

В любом случае у меня есть несколько идей, как двигаться дальше, и я их обсудю завтра.

Вчера я столкнулся с небольшой проблемой: моя шахматная программа в том виде, в котором она существует сейчас, не поможет мне стать гроссмейстером. Напротив, это поможет мне правильно определять шахматные ходы как хорошие или плохие только в 70% случаев, что хуже, чем у меня, как у шахматиста-любителя.

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

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

Фактически, я был бы чрезвычайно удачлив (или умен…?), Если бы первый алгоритм (или класс алгоритмов), который я попробовал, был функциональным. Чаще всего, пытаясь создать новые технические решения, требуется несколько или больше итераций, чтобы найти работоспособное решение.

Конечно, это не случайные итерации. Мне все еще нужно хорошо продумать, что я попробую дальше ...

Итак, что мне попробовать дальше?

В алгоритмическом пространстве есть только два возможных пути, по которым я могу пойти, и они не совсем взаимоисключающие:

1. Постройте лучшую модель

Используйте тот же набор данных, но постройте более надежную модель, используя сверточные нейронные сети. Начните с очень сложной модели, даже если она неприемлема для исполнения человеком, просто чтобы посмотреть, можно ли вообще создать высокопроизводительный алгоритм. Если это возможно, то постепенно уменьшайте сложность модели до тех пор, пока она не будет работать на уровне Магнуса Карлсена, и надейтесь, что эту (или некоторую ее оптимизированную версию) сможет изучить и исполнить человек. Если нет, значит, мой набор данных некачественный, и мне нужно попробовать вариант №2.

2. Создайте лучший набор данных.

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

Вот мой план продвижения вперед:

1. Создайте сверточную нейронную сеть и пропустите через нее мой текущий набор данных.
2. Таким образом, подтвердите или аннулируйте совершенство моего набора данных.
3. Предполагая (очень сильно), что проблема в моем наборе данных, создайте новый набор данных и прогоните его через сверточную нейронную сеть.
4. Продолжайте этот процесс, пока я не найду хороший набор данных.
5. Затем начните отбрасывать модель (то есть сверточную нейронную сеть), пытаясь сохранить производительность.
6. Если модель может быть уменьшена так, чтобы ее мог выполнять человек, без чрезмерного ущерба для производительности, уезжайте в закат (и под этим я имею в виду ... потратьте нелепое количество времени и умственных способностей на изучение и отработку полученного алгоритма) .
7. Если модель не может быть уменьшена без ущерба для производительности, попробуйте найти другой хороший набор данных.

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

Но пока доктор философии. придется подождать, а вместо этого я посмотрю, чего я могу достичь за час в день в течение следующих нескольких дней.

У меня есть хорошие новости и плохие новости ...

Хорошая новость в том, что я гораздо лучше разбираюсь в создании, обучении и развертывании моделей машинного обучения. Сегодня всего за 30 минут я смог построить новую, более сложную модель машинного обучения (сверточную нейронную сеть) на основе моих шахматных данных, загрузить набор данных и модель на облачный компьютер (через Floyd) и начать обучение модели на графических процессорах, оптимизированных для машинного обучения.

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

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

С учетом сказанного интересно, насколько быстрее я могу создавать и развертывать новый код машинного обучения. Фактически, все, что я сделал для задачи этого месяца, теперь, скорее всего, я смогу выполнить за один день.

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

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

Задача этого месяца заключалась в единственном вопросе:

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

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

Я почти уверен, что это текущая проблема, с которой я столкнулся, и что я неправильно пометил большую часть своего набора данных.

Позвольте мне объяснить, в чем я ошибся (а затем расскажу, как я собираюсь это исправить)…

Маркировка моего набора данных v1

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

1. Для данной шахматной позиции вычислите ее оценку.
2. Затем для данной позиции вычислите оценку позиции, которая была непосредственно перед ней.
3. Найдите разницу между оценками (т. Е. Текущая оценка минус предыдущая).
4. Если эта разница превышает определенное пороговое значение, пометьте позицию как «хорошо». Если разница меньше того же порогового значения, пометьте позицию как «плохую».

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

Но здесь есть проблема ... Есть несколько способов достичь любой заданной позиции. И шаги, которые немедленно приводят к этой позиции, не обязательно должны быть «хорошими» или «плохими».

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

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

В таком случае неудивительно, что я не смог найти подходящую функцию для описания данных.

Первоначально я упустил эту проблему из виду по следующим причинам:

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

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

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

Маркировка моего набора данных v2

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

1. Загрузите кучу шахматных партий.
2. Для каждой партии определяйте, выиграли или проиграли белые.
3. Для каждой шахматной позиции в каждой партии пометьте все позиции как +1, если белые выиграли партию, и -1, если белые проиграли партию (и 0, если ничья).
4. Обработайте миллионы игр таким образом и ведите текущий счет для каждой отдельной позиции (т. Е. Если позиция никогда не была видна раньше, добавьте ее в список. Если позиция уже была просмотрена, увеличьте total ассоциируется с позицией либо +1, либо -1).
5. После того, как все игры обработаны, пройдите по каждой из отдельных позиций и пометьте позицию как «хорошую», если ее счет больше или равен нулю, и «плохой», если его счет меньше нуля.

Таким образом, каждая шахматная позиция имеет уникальный ярлык. И каждый ярлык должен быть очень точным, исходя из следующих двух соображений: «За миллионы партий эта шахматная позиция привела к большему количеству побед, чем проигрышей, так что это почти наверняка хорошая шахматная позиция» и «За миллионы партий эта шахматная позиция привела к большему количеству проигрышей, чем побед, так что это почти наверняка плохая шахматная позиция».

Кроме того, поскольку мне не нужно использовать движок Stockfish для оценки каких-либо ходов, моя новая программа create_data работает примерно в 10000 раз быстрее, чем моя предыдущая программа, поэтому я смогу подготовить гораздо больше. data (он обрабатывает 1000 шахматных партий или около 40 000 шахматных позиций каждые 15 секунд).

Прямо сейчас я настроил его на обработку 2 миллионов партий или около 80 миллионов шахматных позиций за ночь.

Он работает уже 30 минут и уже обработал 193 658 игр.

Честно говоря, сегодня утром я не был уверен, как и собираюсь ли я продвигаться вперед, но я очень оптимистично настроен по поводу этого нового подхода.

На самом деле, я не могу понять, почему эти данные не будут чистыми (поэтому, если у вас есть какие-то идеи, оставьте комментарий и дайте мне знать).

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

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

Напоминаем, что этот новый метод помечает все шахматные позиции из выигрышной партии как +1, а все шахматные позиции из проигрышной игры - как -1. Затем, каждый раз, когда программа видит одну и ту же шахматную позицию, она продолжает складывать эти метки +1 и -1, пока не будет достигнута окончательная сумма. Чем выше число, тем окончательно «хороший» ход, а чем меньше число, тем окончательно «плохой» ход.

Проснувшись сегодня утром, я увидел, что моя программа вылетела после обработки около 700 000 шахматных партий. Просто на моем компьютере закончилась доступная память.

К сожалению, в результате ни один вывод не был сохранен.

Таким образом, я перезапустил программу, установив отсечку примерно на 700 000 игр.

После успешного создания набора данных я загрузил его в Floyd (платформу облачных вычислений, которую я использую), подключил к моей программе train_model и начал обучение моей модели машинного обучения.

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

Итак, я уменьшил масштаб и создал набор данных на основе 100 000 шахматных партий… Это все равно сломало Флойда.

Я сократился до 25 000 шахматных партий, и, наконец, у Флойда было достаточно памяти, чтобы справиться с обучением.

Я провожу программу тренировок около четырех часов, и точность программы постоянно растет, но мне еще предстоит пройти долгий путь:

Он начался с точности около 45,5% на тестовых данных (хуже, чем случайное предположение, предполагая, что хорошие и плохие позиции примерно равны).

И через четыре часа точность тестовых данных достигла 54,4% (немного лучше, чем случайное предположение) ...

Надеюсь, если я позволю этой программе работать всю ночь, она продолжит неуклонно расти до 99%. (Программа выполняет только ~ 400 итераций в час, так что это может занять много времени).

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

Таким образом, я создаю несколько наборов данных, в которых обрабатываю значительно больше шахматных партий, но принимаю в свой помеченный набор данных только те шахматные позиции, которые были просмотрены несколько раз и демонстрируют окончательную метку (т. Е. Шахматная позиция имеет результат › 25, или ›50, или› 100).

Таким образом, я, вероятно, смогу исключить любые разовые позиции и создать набор данных, в котором будет четкое разделение между «хорошими» и «плохими» позициями.

У меня также всегда есть возможность ввести третий ярлык, называемый «нейтральным», который присваивается этим менее определенным шахматным позициям, но дополнительный ярлык значительно усложнит игру - так что оно того стоит, только если значительно повысит эффективность алгоритма.

Как бы то ни было, сегодня было много ожидания, нехватки памяти и обработки данных. Надеюсь, завтра у меня будет какое-то представление о том, иду ли я в правильном направлении.

Честно говоря, с точки зрения инфраструктуры и оптимизации это начинает казаться задачей Google Alpha Go или IBM Watson. Не слишком ли поздно начинать какое-то спонсорство / сотрудничество…?

Через несколько часов я сажусь в самолет в Германию. Я буду там до 10-го, а потом буду в Дании до 12-го.

Другими словами, для остальной части этой задачи я в основном буду путешествовать.

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

Итак, давайте подведем итоги, где я сейчас нахожусь ...

Вчера вечером я начал запускать новую программу, которая выглядела многообещающей. Однако почти сразу после публикации вчерашнего сообщения и после 4,5 часов обработки программа завершилась ошибкой: размеры файлов снова стали слишком большими, и на этот раз кажется, что это не имело ничего общего с моей конфигурацией инфраструктуры, и вместо этого пришлось обойтись пределами Python и Tensorflow.

Ясно, что я упускаю из виду какую-то оптимизацию.

Этим утром я поставил кучу других экспериментов, разрезая набор данных всевозможными способами.

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

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

Тем не менее, хотя моя поездка в Европу может замедлить развитие моего шахматного кода, она все же является продолжением повествования об этой задаче. Я скоро объясню ...

Я прилетел в Германию сегодня около 18:00, поэтому большую часть дня я провел в попытках поспать в самолете.

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

Вчера, в 10 часов утра, когда модель заработала, она смогла правильно определить шахматные позиции как «хорошие» или «плохие» с точностью 68%:

Несколько минут назад точность модели составляет 75%:

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

Прогресс постепенный, но устойчивый.

Эта модель могла бы быть полностью…

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

Сегодня мой компьютер все еще работал, медленно тренируя мою модель машинного обучения, которая в конечном итоге, в случае успеха, выдаст мой человеческий шахматный алгоритм.

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

Итак, я подумал, что сегодня будет хороший день, чтобы попытаться сразиться с 26-летним Магнусом и посмотреть, смогу ли я выиграть партию в шахматы старомодным способом.

Конечно, я не особо практиковался в нормальных шахматах - учитывая, что я серьезно относился к своему алгоритмическому подходу - но, тем не менее, сегодня я отдал нормальную игру изо всех сил.

Я начал твердо играть первые дюжину ходов, но в итоге Магнус получил преимущество ...

Вскоре после этого он воспользовался этим преимуществом и поставил мат моему королю….

Ясно, что без алгоритма, на который можно было бы опереться, Магнус по-прежнему доминирует.

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

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

Однако бывают случаи, особенно когда у меня ограниченный опыт в соответствующей области, когда мои навыки оценки времени меня подводят.

Задача этого месяца - один из тех случаев ...

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

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

Другими словами, цикл итераций для чего-то подобного измеряется не часами, а скорее неделями.

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

Приступая к этой задаче, я довольно хорошо разбирался в математической и теоретической части науки о данных, но имел ограниченный практический опыт.

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

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

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

Кроме того, в течение месяца автономного управления автомобилем я смог запустить все на своем персональном компьютере, и мне не нужно было узнавать о развертывании в облаке, как в этот раз.

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

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

И даже если бы я смог завершить части своего алгоритмического шахматного подхода по машинному обучению и науке о данных, мне все равно нужно было бы запоминать и изучать алгоритм в оставшиеся дни месяца, что также было бы довольно сложно: изучение такого рода алгоритма было бы похоже на мою задачу запоминания карточек, но было бы задействовано примерно в 10 раз больше.

Другими словами, я сильно недооценил, сколько времени потребуется, чтобы победить чемпиона мира по шахматам. Оказывается, неудивительно, что это все-таки довольно амбициозный подвиг.

Я бы сказал, что более реалистично, эту задачу можно решить примерно за 3–6 месяцев, начиная с того места, где я начал, работая над ней полный рабочий день.

Тем не менее, победить лучшего шахматиста мира после шести месяцев подготовки было бы невероятно беспрецедентно и увлекательно, так что, возможно, стоит попробовать.

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

Я бы сказал, что сейчас я гораздо лучше понимаю «время науки о данных», и я уверен, что это то, что мне пригодится в будущем.

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

Сегодня я провел большую часть дня, исследуя Копенгаген пешком. Хотя было довольно холодно, день был солнечный, и мне очень понравился город.

Однако все пошло не так, как планировалось ...

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

Вместо того, чтобы возвращаться в отель, я решил, что продолжу путь без костыля Google Maps. Я решил просто бродить без определенного плана или направления, а затем, в конце дня, просто попытаться найти дорогу обратно.

Я верил, что разберусь.

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

Интересно, что это чувство прокладывания собственного пути очень похоже на то, которое я испытал во время шахматной задачи в этом месяце: я отправился в неизвестность, не имея плана или руководства, и нашел удовольствие в процессе продвижения вперед.

В конце концов я нашел свой путь обратно в отель, что, надеюсь, является сигналом того, что будет в эти последние несколько дней моего шахматного соревнования.

Я только что вылетел из Копенгагена обратно в Сан-Франциско двенадцатичасовым перелетом, так что я собираюсь сделать этот пост как можно более коротким ...

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

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

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

Я поделюсь еще завтра ...

Сегодня я закончил первую версию своего шахматного алгоритма, которая позволила мне хорошо играть в шахматы, как человеческий шахматный компьютер. Точность алгоритма составляет ~ 94%, чего может быть достаточно.

Вот десятиминутное видео, где я объясняю алгоритм и использую его для анализа шахматной партии на Chess.com, в которую я недавно играл:

(Обновление: это игра, в которую я играл против Магнуса, которую я позже раскрыл)

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

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

Похоже, Max Chess действительно могут стать реальностью ...

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

Сегодня я немного углубился в производительность алгоритма, и результаты все еще были хорошими, хотя и не идеальными.

Для первых 25 ходов любой шахматной партии алгоритм работает более или менее идеально. Он определяет хорошие ходы как хорошие, а плохие как плохие - удобно проводить пользователя через дебют шахматной партии и часть средней игры.

Алгоритм хуже работает в конце середины и в конце игры. В частности, во время этой части игры порог алгоритма для хороших ходов слишком низкий: он распознает слишком много неточных ходов как хорошие.

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

Я не особо удивлен таким результатом: эта итерация модели была обучена только на 1500 играх и около 50 000 шахматных позиций (я использовал этот сокращенный набор данных, чтобы версия 1 моей модели могла по крайней мере завершить обучение до того, как задача закончилась).

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

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

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

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

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

Таким образом, сегодня я начал обучать ту же модель, но на этот раз на наборе данных из 100 000 игр. Я также обрабатываю больше игр, надеясь собрать набор данных примерно из десяти миллионов игр.

Основываясь на том, что я видел до сих пор, я подозреваю, что эти модели с вводом гораздо большего количества данных будут почти идеальными по своим характеристикам. В конце концов, текущая модель невероятно точна, и ее производительность основана только на 1500 играх.

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

Что до сих пор неясно, так это то, приводит ли «идеальная производительность» в определении хороших и плохих ходов к игровому процессу на уровне Магнуса. Это еще предстоит определить ...

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

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

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

Даже если я не справлюсь с этим заданием в течение следующих двух дней, последние шесть недель были для меня особенно захватывающими:

1. Я был пионером нового способа обучения и игры в шахматы (и подтвердил, что у него есть потенциал), который, надеюсь, в какой-то мере повлияет на будущее шахмат.
2. Я выработал гораздо более сильное практическое понимание процесса непрерывного анализа данных и машинного обучения, что очень хорошо послужит мне в будущем.
3. Я обнаружил, что гораздо глубже ценил игру в шахматы и неизменно увлекался этой игрой лучших игроков мира. Я наконец понял красоту этой игры и, конечно же, продолжу играть в шахматы обычным, неалгоритмическим способом достаточно регулярно.
4. У меня появилось несколько интересных друзей в шахматном сообществе, о которых я расскажу подробнее в пятницу.

В целом, очень удачный «неудачный» вызов.

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

Это важный момент: оценивайте качество своей жизни не по результатам, а по стремлению к ним.

Если вы оптимизируете и цените преследование, в любом случае последуют благоприятные результаты, даже если они не являются теми результатами, которые вы планировали.

Если вы цените только результаты, вы упустите большую часть радостей своей жизни, поскольку мы проводим большую часть (всю) свою жизнь в погоне.

Как и во всех моих прошлых испытаниях, сегодня я решил подсчитать общее количество времени, которое я потратил на это последнее шахматное испытание.

Поскольку это испытание было фактически на 50% дольше, чем предыдущее, неудивительно, что я потратил на него немного больше времени. В частности, за последние шесть недель я потратил 34 часа на то, чтобы победить Магнуса.

Оказывается, 34 часов недостаточно, но, зная то, что я знаю сейчас, я не думаю, что это слишком далеко.

По моим оценкам, потребуется от 500 до 1000 часов, чтобы стать человеком-шахматным компьютером, способным победить чемпиона мира (если предположить, что алгоритмический подход на этом уровне игрового процесса возможен… вердикт еще не вынесен).

Хотя это значительно больше, чем 34 часа, которые я потратил, оно полностью затмевается десятками тысяч часов, которые Магнус провел за игрой в шахматы.

Конечно, эта оценка имеет значение только в том случае, если я действительно могу продемонстрировать результат.

А пока я собираюсь сделать небольшой перерыв в моих шахматных приготовлениях, но, если придет вдохновение, я могу продолжить.

1000 часов на самом деле не такое уж безумие. Это примерно шесть месяцев стандартной работы с 9 до 5.

Я подозреваю, что когда-нибудь в будущем я вернусь назад, потрачу эти 1000 часов и, при условии, что все пойдет по плану, сыграю в соревновательную игру против Магнуса (игра, которая, скорее всего, будет очень продолжительной).

А пока Магнус может продолжать наслаждаться своим местом на вершине ...

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

Это был невероятно вдохновляющий и приятный опыт, и я очень благодарен за возможность.

Чтобы отпраздновать завершение проекта, The Wall Street Journal написала историю матча и подготовила видео к ней:

FAQ 1: Как вы создали игру с Магнусом?

Я этого не сделал. Мне предложили игру (в результате сотрудничества команды Магнуса и Wall Street Journal), и я согласился. Мне не следовало отказываться от этого.

FAQ 2: Вы действительно думали, что выиграете?

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

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

В любом случае, этот год был очень веселым, и я уверен, что 2-й сезон M2M находится где-то в моем будущем.

А пока спасибо всем, кто следил за нами, вносил вклад и поддерживал проект в течение последних двенадцати месяцев. Это много значило (и продолжает значить) для меня.

Этот пост является частью моего годичного проекта ускоренного обучения Месяц до мастера.

Макс Дойч является соучредителем Monthly - онлайн-образовательной платформы, которая в партнерстве с некоторыми из крупнейших в мире пользователей YouTube создает месячные захватывающие онлайн-классы.

Чтобы получить эксклюзивный контент об ускоренном обучении, дисциплине и дизайне образа жизни, подпишитесь на мою периодическую рассылку новостей.