Как создать искусственный интеллект? (Почти) исчерпывающее руководство. Самая простая нейронная сеть на Python Искусственный интеллект на питоне

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

Стадия 1. Разочарование

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

Линейная алгебра;

• Теория графов;

  Теория вероятностей и математическая статистика.

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

Стадия 2. Принятие

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

Стадия 3. Развитие

Теперь переходим непосредственно к теории ИИ. Их условно можно разделить на 3 категории:

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

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

Совершенные ИИ – будущее, машинный мозг, который превзойдёт наши возможности. Именно об опасности таких разработок предупреждают Стивен Хоккинг, Элон Маск и кинофраншиза «Терминатор».

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

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

Стадия 5. Работа

Теперь же, когда вы уже вполне ясно представляете, как ИИ создавать и чем при этом пользоваться, пора выводить свои знания на новый уровень. Во-первых, для этого потребуется изучение дисциплины, которое носит название «Машинное обучение» . Во-вторых, необходимо научиться работать с соответствующими библиотеками выбранного языка программирования. Для рассматриваемого нами Python это Scikit-learn, NLTK, SciPy, PyBrain и Nump. В-третьих, в развитии никуда не обойтись от

Мы сейчас переживаем настоящий бум нейронных сетей. Их применяют для распознания, локализации и обработки изображений. Нейронные сети уже сейчас умеют многое что не доступно человеку. Нужно же и самим вклиниваться в это дело! Рассмотрим нейтронную сеть которая будет распознавать числа на входном изображении. Все очень просто: всего один слой и функция активации. Это не позволит нам распознать абсолютно все тестовые изображения, но мы справимся с подавляющим большинством. В качестве данных будем использовать известную в мире распознания чисел подборку данных MNIST.

Для работы с ней в Python есть библиотека python-mnist. Что-бы установить:

Pip install python-mnist

Теперь можем загрузить данные

From mnist import MNIST mndata = MNIST("/path_to_mnist_data_folder/") tr_images, tr_labels = mndata.load_training() test_images, test_labels = mndata.load_testing()

Архивы с данными нужно загрузить самостоятельно, а программе указать путь к каталогу с ними. Теперь переменные tr_images и test_images содержат изображения для тренировки сети и тестирования соотвественно. А переменные tr_labels и test_labels - метки с правильной классификацией (т.е. цифры с изображений). Все изображения имеют размер 28х28. Зададим переменную с размером.

Img_shape = (28, 28)

Преобразуем все данные в массивы numpy и нормализуем их (приведем к размеру от -1 до 1). Это увеличит точность вычислений.

Import numpy as np for i in range(0, len(test_images)): test_images[i] = np.array(test_images[i]) / 255 for i in range(0, len(tr_images)): tr_images[i] = np.array(tr_images[i]) / 255

Отмечу, что хоть и изображения принято представлять в виде двумерного массива мы будем использовать одномерный, это проще для вычислений. Теперь нужно понять "что же такое нейронная сеть"! А это просто уравнение с большим количеством коэффициентов. Мы имеем на входе массив из 28*28=784 элементов и еще по 784 веса для определения каждой цифры. В процессе работы нейронной сети нужно перемножить значения входов на веса. Сложить полученные данные и добавить смещение. Полученный результат подать на функцию активации. В нашем случае это будет Relu. Эта функция равна нулю для всех отрицательных аргументов и аргументу для всех положительных.

Есть еще много функций активации! Но это же самая простая нейронная сеть! Определим эту функцию при помощи numpy

Def relu(x): return np.maximum(x, 0)

Теперь чтобы вычислить изображение на картинке нужно просчитать результат для 10 наборов коэффициентов.

Def nn_calculate(img): resp = list(range(0, 10)) for i in range(0,10): r = w[:, i] * img r = relu(np.sum(r) + b[i]) resp[i] = r return np.argmax(resp)

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

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

W = (2*np.random.rand(10, 784) - 1) / 10 b = (2*np.random.rand(10) - 1) / 10 for n in range(len(tr_images)): img = tr_images[n] cls = tr_labels[n] #forward propagation resp = np.zeros(10, dtype=np.float32) for i in range(0,10): r = w[i] * img r = relu(np.sum(r) + b[i]) resp[i] = r resp_cls = np.argmax(resp) resp = np.zeros(10, dtype=np.float32) resp = 1.0 #back propagation true_resp = np.zeros(10, dtype=np.float32) true_resp = 1.0 error = resp - true_resp delta = error * ((resp >= 0) * np.ones(10)) for i in range(0,10): w[i] -= np.dot(img, delta[i]) b[i] -= delta[i]

В процессе обучения коэффициенты станут слегка похожи на числа:

Проверим точность работы:

Def nn_calculate(img): resp = list(range(0, 10)) for i in range(0,10): r = w[i] * img r = np.maximum(np.sum(r) + b[i], 0) #relu resp[i] = r return np.argmax(resp) total = len(test_images) valid = 0 invalid = for i in range(0, total): img = test_images[i] predicted = nn_calculate(img) true = test_labels[i] if predicted == true: valid = valid + 1 else: invalid.append({"image":img, "predicted":predicted, "true":true}) print("accuracy {}".format(valid/total))

У меня получилось 88%. Не так уж круто, но очень интересно!

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

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

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

Если все установлено и настроено, можно начинать.

Переменные

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

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

Слева мы объявляем переменную с именем x . Это равносильно тому, что мы приклеили на коробку именной ярлык. Далее идет знак равенства и число 10. Знак равенства здесь играет необычную роль. Он не означает, что «x равно 10». Равенство в данном случае кладет число 10 в коробку. Если говорить более корректно, то мы присваиваем переменной x число 10.

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

Можно просто вывести значение этой переменной на экран:

X=10 print(x)

Надпись print(x) представляет собой вызов функции. Их мы будем рассматривать далее. Сейчас важно то, что эта функция выводит в консоль то, что расположено между скобками. Между скобками у нас стоит x . Ранее мы присвоили x значение 10. Именно 10 и выводится в консоли, если вы выполните программу выше.

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

X = 2 y = 3 # Сложение z = x + y print(z) # 5 # Разность z = x - y print(z) # -1 # Произведение z = x * y print(z) # 6 # Деление z = x / y print(z) # 0.66666... # Возведение в степень z = x ** y print(z) # 8

В коде выше мы вначале создаем две переменные, содержащие 2 и 3. Затем создаем переменную z , которая хранит результат операции с x и y и выводит результаты в консоль. На этом примере хорошо видно, что переменная может менять свое значение в ходе выполнения программы. Так, наша переменная z меняет свое значение аж 5 раз.

Функции

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

«Это очень важный текст!»
«Этот текст нильзя ни прочитать»
«Ошибка в верхней строчке допущена специально»
«Привет и пока»
«Конец»

Наш код будет выглядеть так:

X = 10 y = x + 8 - 2 print("Это очень важный текст!") print("Этот текст нильзя не прочитать") print("Ошибка в верхней строчке допущена специально") print("Привет и пока") print("Конец") z = x + y print("Это очень важный текст!") print("Этот текст нильзя не прочитать") print("Ошибка в верхней строчке допущена специально") print("Привет и пока") print("Конец") test = z print("Это очень важный текст!") print("Этот текст нильзя не прочитать") print("Ошибка в верхней строчке допущена специально") print("Привет и пока") print("Конец")

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

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

Функция - отдельный блок кода, который можно вызывать по имени.

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

Def print_5_lines(): print("Это очень важный текст!") print("Этот текст нильзя не прочитать") print("Ошибка в верхней строчке допущена специально") print("Привет и пока") print("Конец")

Теперь мы определили функцию print_5_lines() . Теперь, если в нашем проекте нам в очередной раз надо вставить пять строчек, то мы просто вызываем нашу функцию. Она автоматически выполнит все действия.

# Определяем функцию def print_5_lines(): print("Это очень важный текст!") print("Этот текст нильзя не прочитать") print("Ошибка в верхней строчке допущена специально") print("Привет и пока") print("Конец") # Код нашего проекта x = 10 y = x + 8 - 2 print_5_lines() z = x + y print_5_lines() test = z print_5_lines()

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

Функции с параметрами

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

Переменные, которые мы передаем в функцию, называются аргументами .

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

Def sum(a, b): result = a + b return result

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

Параметры можно использовать внутри функции как обычные переменные. На второй строчке мы создаем переменную result , которая равна сумме параметров a и b . На третьей строчке мы возвращаем значение переменной result .

Теперь, в дальнейшем коде мы можем писать что-то вроде:

New = sum(2, 3) print(new)

Мы вызываем функцию sum и по очереди передаем ей два аргумента: 2 и 3. 2 становится значением переменной a , а 3 становится значением переменной b . Наша функция возвращает значение (сумму 2 и 3), и мы используем его для создания новой переменной new .

Запомните. В коде выше числа 2 и 3 - аргументы функции sum . А в самой функции sum переменные a и b - параметры. Другими словами, переменные, которые мы передаем функции при ее вызове называются аргументами. А вот внутри функции эти переданные переменные называются параметрами. По сути, это два названия одного и того же, но путать их не стоит.

Рассмотрим еще один пример. Создадим функцию square(a) , которая принимает какое-то одно число и возводит его в квадрат:

Def square(a): return a * a

Наша функция состоит всего из одной строчки. Она сразу возвращает результат умножения параметра a на a .

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

Массивы

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

Array =

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

Array = print(array)

В консоли вы увидите число 89. Но почему 89, а не 1? Все дело в том, что в Python, как и во многих других языках программирования, нумерация массивов начинается с 0. Поэтому array дает нам второй элемент массива, а не первый. Для вызова первого надо было написать array .

Размер массива

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

Array = print(len(array))

В консоли выведется число 4.

Условия и циклы

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

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

В первой ситуации помогают условия, а во второй - циклы.

Условия

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

В Python условия можно записывать с помощью конструкции if: ... else: ... . Пусть у нас есть некоторая переменная x = 10 . Если x меньше 10, то мы хотим разделить x на 2. Если же x больше или равно 10, то мы хотим создать другую переменную new , которая равна сумме x и числа 100. Вот так будет выглядеть код:

X = 10 if(x < 10): x = x / 2 print(x) else: new = x + 100 print(new)

После создания переменной x мы начинаем записывать наше условие.

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

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

Если она больше или равна 10, то мы создаем новую переменную new , которая равна x + 100 и тоже выводим ее в консоль.

Циклы

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

Print("Квадрат 1 равен " + str(1**2)) print("Квадрат 2 равен " + str(2**2)) print("Квадрат 3 равен " + str(3**2)) print("Квадрат 4 равен " + str(4**2)) print("Квадрат 5 равен " + str(5**2)) print("Квадрат 6 равен " + str(6**2)) print("Квадрат 7 равен " + str(7**2)) print("Квадрат 8 равен " + str(8**2)) print("Квадрат 9 равен " + str(9**2)) print("Квадрат 10 равен " + str(10**2))

Пусть вас не удивляет тот факт, что мы складываем строки. «начало строки» + «конец» в Python означает просто соединение строк: «начало строкиконец». Так же и выше мы складываем строку «Квадрат x равен » и преобразованный с помощью функции str(x**2) результат возведения числа во 2 степень.

Выглядит код выше очень избыточно. А что, если нам надо вывести квадраты первых 100 чисел? Замучаемся выводить…

Именно для таких случаев и существуют циклы. Всего в Python 2 вида циклов: while и for . Разберемся с ними по очереди.

Цикл while повторяет необходимые команды до тех пор, пока остается истинным условие.

X = 1 while x <= 100: print("Квадрат числа " + str(x) + " равен " + str(x**2)) x = x + 1

Сначала мы создаем переменную и присваиваем ей число 1. Затем создаем цикл while и проверяем, меньше (или равен) ли 100 наш x . Если меньше (или равен) то мы выполняем два действия:

1. Выводим квадрат x
2. Увеличиваем x на 1

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

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

For x in range(1,101): print("Квадрат числа " + str(x) + " равен " + str(x**2))

Разберем первую строку. Мы используем ключевое слово for для создания цикла. Далее мы указываем, что хотим повторить определенные действия для всех x в диапазоне от 1 до 100. Функция range(1,101) создает массив из 100 чисел, начиная с 1 и заканчивая 100.

Вот еще пример перебора массива с помощью цикла for:

For i in : print(i * 2)

Код выше выводит 4 цифры: 2, 20, 200 и 2000. Тут наглядно видно, как берет каждый элемент массива и выполняет набор действий. Затем берет следующий элемент и повторяет тот же набор действий. И так пока элементы в массиве не кончатся.

Классы и объекты

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

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

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

Важно понимать разницу между классом и объектом. Класс - схема , которая описывает объект. Объект - ее материальное воплощение . Класс кошки - описание ее свойств и действий. Объект кошки и есть сама реальная кошка. Может быть много разных реальных кошек - много объектов-кошек. Но класс кошки только один. Хорошей демонстрацией служит картинка ниже:

Классы

Для создания класса (схемы нашей кошки) надо написать ключевое слово class и затем указать имя этого класса:

Class Cat:

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

Метод - функция, определенная внутри класса.

Словесно мы уже описали методы кошки выше: мурлыкать, шипеть, царапаться. Теперь сделаем это на языке Python.

# Класс кошки class Cat: # Мурлыкать def purr(self): print("Муррр!") # Шипеть def hiss(self): print("Кшшш!") # Царапаться def scrabble(self): print("Царап-царап!")

Вот так все просто! Мы взяли и определили три обычные функции, но только внутри класса.

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

# Класс кошки class Cat: # Мурлыкать def purr(self): print("Муррр!") # Шипеть def hiss(self): print("Кшшш!") # Царапаться def scrabble(self): print("Царап-царап!") # Все вместе def all_in_one(self): self.purr() self.hiss() self.scrabble()

Как видите, обязательный для любого метода параметр self позволяет нам обращаться к методами и переменным самого класса! Без этого аргумента выполнить подобные действия мы бы не смогли.

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

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

Что означает эта строчка?

Self.wool_color = wool_color

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

Атрибут - переменная, которая относится к какому-то классу.

Итак, мы создали готовый класс кошки. Вот его код:

# Класс кошки class Cat: # Действия, которые надо выполнять при создании объекта "Кошка" def __init__(self, wool_color, eyes_color, name): self.wool_color = wool_color self.eyes_color = eyes_color self.name = name # Мурлыкать def purr(self): print("Муррр!") # Шипеть def hiss(self): print("Кшшш!") # Царапаться def scrabble(self): print("Царап-царап!") # Все вместе def all_in_one(self): self.purr() self.hiss() self.scrabble()

Объекты

Мы создали схему кошки. Теперь давайте создадим по этой схеме реальный объект кошки:

My_cat = Cat("черный", "зеленые", "Зося")

В строке выше мы создаем переменную my_cat , а затем присваиваем ей объект класса Cat . Выглядит все этот как вызов некоторой функции Cat(...) . На самом деле так и есть. Этой записью мы вызываем метод __init__() класса Cat . Функция __init__() в нашем классе принимает 4 аргумента: сам объект класса self , который указывать не надо, а также еще 3 разных аргумента, которые затем становятся атрибутами нашей кошки.

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

Print(my_cat.wool_color) print(my_cat.eyes_color) print(my_cat.name)

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

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

My_cat.name = "Нюша"

Теперь, если вы вновь выведете в консоль имя кошки, то вместо Зоси увидите Нюшу.

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

My_cat.purr()

Выполнение данной команды выведет в консоль текст «Муррр!». Как видите, обращаться к методам объекта так же просто, как и обращаться к его атрибутам.

Модули

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

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

На данный момент другие Python программисты написали уже свыше 110 000 разнообразных модулей. Упоминавшийся выше модуль numpy позволяет быстро и удобно работать с матрицами и многомерными массивами. Модуль math предоставляет множество методов для работы с числами: синусы, косинусы, переводы градусов в радианы и прочее и прочее…

Установка модуля

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

Если вы хотите использовать модуль, который не входит в стандартный набор, то вам потребуется установить его. Для установки модуля откройте командую строку (Win + R, затем введите в появившемся поле «cmd») и введите в нее команду:

Pip install [название_модуля]

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

Подключение и использование модуля

Сторонний модуль подключается очень просто. Надо написать всего одну короткую строку кода:

Import [название_модуля]

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

Import math

Как обратиться к функции модуля? Надо написать название модуля, затем поставить точку и написать название функции/класса. Например, факториал 10 находится так:

Math.factorial(10)

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

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

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

Стадия 1. Разочарование

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

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

Стадия 2. Принятие

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

Стадия 3. Развитие

Теперь переходим непосредственно к теории ИИ. Их условно можно разделить на 3 категории:

• Слабый ИИ – боты, которых мы видим в компьютерных играх, или простые подручные помощники, вроде Siri. Они или выполняют узкоспециализированные задачи или являются незначительным комплексом таковых, а любая непредсказуемость взаимодействия ставит их в тупик.
• Сильный ИИ – это машины, интеллект которых сопоставим с человеческим мозгом. На сегодняшний день нет реальных представителей этого класса, но компьютеры, вроде Watson очень близки к достижению этой цели.
• Совершенные ИИ – будущее, машинный мозг, который превзойдёт наши возможности. Именно об опасности таких разработок предупреждают Стивен Хоккинг, Элон Маск и кинофраншиза «Терминатор».

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

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

К слову, если вы всё-таки взялись за язык Python, то создать довольно простого бота можно, обратившись к этому подробному мануалу . Для других языков, таких как C++ или Java , вам также не составит труда найти пошаговые материалы. Почувствовав, что за созданием ИИ нет ничего сверхъестественного, вы сможете смело закрыть браузер и приступить к личным экспериментам.

Стадия 4. Азарт

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

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

Стадия 5. Работа

Теперь же, когда вы уже вполне ясно представляете, как ИИ создавать и чем при этом пользоваться, пора выводить свои знания на новый уровень. Во-первых, для этого потребуется изучение дисциплины, которое носит название «Машинное обучение ». Во-вторых, необходимо научиться работать с соответствующими библиотеками выбранного языка программирования. Для рассматриваемого нами Python это Scikit-learn, NLTK, SciPy, PyBrain и Numpy. В-третьих, в развитии никуда не обойтись от . Ну и самое главное, вы теперь сможете читать литературу о ИИ с полным пониманием дела:

• Artificial Intelligence for Games , Ян Миллингтон;
• Game Programming Patterns , Роберт Найсторм;
• AI Algorithms, Data Structures, and Idioms in Prolog, Lisp, and Java , Джордж Люгер, Уильям Стбалфилд;
• Computational Cognitive Neuroscience , Рэнделл О’Рейли, Юко Мунаката;
• Artificial Intelligence: A Modern Approach , Стюарт Рассел, Питер Норвиг.

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