Привет, будущие разработчики! Сегодня я расскажу вам, как создать свою первую модель искусственного интеллекта. Это совсем для начинающих, так что не переживайте — никаких сложных терминов и запутанных выражений. Всё, что понадобится, — ваши идеи и немного кода.
Будем писать на Python и использовать TensorFlow — мощную библиотеку от Google для машинного обучения.
Почему Python, TensorFlow и как начать работу в Google Colab
Если спросить, почему так часто для работы над ИИ выбирают Python, ответ простой: он удобный, интуитивный и всегда под рукой. Он не нагружен лишними деталями, его синтаксис читается почти как обычный английский. Вместо того чтобы ломать голову над сложными конструкциями, можно сразу начать писать работающий код. Плюс, для работы с искусственным интеллектом существует огромное количество готовых библиотек, таких как TensorFlow, Keras, PyTorch и Hugging Face. Если что‑то пойдёт не так, всегда найдётся сообщество, готовое помочь, как в любом дружном клубе.
TensorFlow — это библиотека от Google, которая помогает превращать математические идеи в работающий код. Основные составляющие TensorFlow:
-
Тензоры: это многомерные массивы данных. Если проще, это как коробка с цифрами — будь то одно число (скаляр), ряд чисел (вектор) или таблица чисел (матрица).
-
Операции: функции, которые выполняют математические действия над этими тензорами. Например, сложение, умножение или даже более сложные вычисления.
-
Вычислительный граф: с помощью графов TensorFlow организует вычисления: строится граф, где узлы — это операции, а стрелки показывают, как данные передаются от одной операции к другой.
А так как мы только начинаем, не нужно заморачиваться с установкой библиотек на свой компьютер — используй Google Colab!
-
Google Colab — это бесплатная облачная среда, где уже предустановлены Python и многие необходимые библиотеки.
-
Всё, что нужно, — это Google‑аккаунт. Просто нужно зайти на Google Colab, создать новый блокнот и начать писать код.
-
Если вдруг нужно установить (а их придётся установить) дополнительные библиотеки, есть команда:
!pip install tensorflow keras numpy
Эта команда загрузит нужные библиотеки, и можно сразу работать.
Чтобы проверить, что всё работает, запусти простой пример:
import tensorflow as tf
a = tf.constant(5)
b = tf.constant(3)
c = tf.add(a, b)
print("Сумма:", c.numpy())Код выведет:
Сумма: 8Теоретическая база
Нейрон
Представь себе, что каждый нейрон — это крошечный математический элемент, который принимает сигнал, обрабатывает его и решает: «А стоит ли мне передавать этот сигнал дальше?» Вот как он это делает:
-
Умножение на веса:
Каждый элемент входного вектора (это набор чисел, представляющий данные) умножается на своё специальное число — вес. Вес можно представить как показатель важности: если какой‑то сигнал особенно важен, его вес будет высоким, а если не очень — вес будет маленьким. -
Суммирование:
После умножения все полученные значения складываются. Но это ещё не всё! К полученной сумме добавляют смещение (bias). Смещение можно сравнить с небольшой поправкой, которая помогает модели лучше адаптироваться к данным, как тонкая настройка ради идеального звука. -
Функция активации:
Теперь приходит время принять окончательное решение. Мы применяем функцию активации, например, ReLU (Rectified Linear Unit). ReLU работает так: если итоговая сумма меньше нуля, нейрон «засыпает» (выдает 0); если сумма положительная — нейрон «просыпается» и передает сигнал дальше. Это позволяет сети игнорировать «шум» и сосредоточиться на важных сигналах.
Посмотрим на пример кода:
def neuron_output(x, weights, bias):
"""
Имитация работы одного нейрона.
Параметры:
x - входной вектор (например, [1.0, 2.0, 3.0])
weights - список весов (например, [0.5, -0.6, 0.1])
bias - смещение (например, 0.2)
"""
# Каждый элемент x умножается на соответствующий вес, затем все значения складываются, и прибавляется bias.
linear_sum = sum(xi * wi for xi, wi in zip(x, weights)) + bias
# Функция активации ReLU: если сумма меньше 0, возвращаем 0, иначе возвращаем сумму.
activated_output = max(0, linear_sum)
return activated_output
# Пример работы нейрона:
input_vector = [1.0, 2.0, 3.0]
weights = [0.5, -0.6, 0.1]
bias = 0.2
print("Выход нейрона:", neuron_output(input_vector, weights, bias))В настоящей нейросети таких нейронов может быть миллионы, и они работают вместе, создавая сложную систему, способную учиться и принимать решения.
Токенизация
Компьютер не понимает слова так, как мы, поэтому нам нужно перевести текст в числа — и тут на помощь приходит токенизация. Это как создание секретного языка, где каждое слово заменяется на свой уникальный номер.
Например, возьми фразу «Привет, мир!». Мы разделяем её на отдельные слова, и каждое слово получает свой номер: «привет» может стать 1, «мир» — 2. Таким образом, фраза превращается в последовательность чисел, например, [1, 2].
Давайте посмотрим на код:
from tensorflow.keras.preprocessing.text import Tokenizer
texts = ["Привет, мир! Это моя первая модель ИИ."]
tokenizer = Tokenizer() # Создаем объект токенизатора
tokenizer.fit_on_texts(texts) # Обучаем его на нашем тексте
sequences = tokenizer.texts_to_sequences(texts) # Преобразуем текст в последовательность чисел
# При запуске код выведет:
# Токенизированный текст: [[1, 2, 3, 4, 5, 6, 7]]
# Словарь токенов: {'привет': 1, 'мир': 2, 'это': 3, 'моя': 4, 'первая': 5, 'модель': 6, 'ии': 7}
print("Токенизированный текст:", sequences)
print("Словарь токенов:", tokenizer.word_index)В результате, текст для ИИ становится набором чисел, с которым он может работать как с любыми другими данными. Это фундаментальный шаг, который позволяет модели обрабатывать и анализировать тексты.
Построение модели: собираем первую LSTM-модель
Перейдём к созданию модели, которая сможет предсказывать следующее слово в тексте. Обычные нейронные сети обрабатывают данные как отдельные точки и не учитывают порядок. Поэтому мы используем рекуррентные нейронные сети (RNN), а их улучшенная версия — LSTM (Long Short‑Term Memory).
Ячейка памяти LSTM хранит информацию о предыдущих словах, чтобы модель могла понимать контекст. Входной, забывающий и выходной слои внутри LSTM решают, какую информацию сохранить, а какую можно отбросить. Это позволяет модели учитывать, о чем шла речь до текущего слова, и делать более точные предсказания.
Создадим модель с помощью Keras. Ниже приведен пример, того, как мы превращаем текст в числа, создаем обучающие примеры и собираем модель:
import numpy as np
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.preprocessing.text import Tokenizer
# Исходный текст для обучения
texts = ["Привет, мир! Это моя первая модель ИИ."]
tokenizer = Tokenizer()
tokenizer.fit_on_texts(texts)
sequences = tokenizer.texts_to_sequences(texts)
word_index = tokenizer.word_index
vocab_size = len(word_index) + 1 # +1 для учета нулевого индекса
# Генерируем обучающие примеры: создаем подпоследовательности из каждого предложения
input_sequences = []
for seq in sequences:
# Для каждого предложения берем все возможные подпоследовательности
for i in range(1, len(seq)):
input_sequences.append(seq[:i+1])
# Приводим все последовательности к одной длине с помощью паддинга (дополняем нулями слева)
max_length = max(len(seq) for seq in input_sequences)
input_sequences = pad_sequences(input_sequences, maxlen=max_length, padding='pre')
# Делим данные: X — все слова, кроме последнего, а y — это следующее слово, которое нужно предсказать
X = input_sequences[:, :-1]
y = input_sequences[:, -1]
# Преобразуем y в one-hot представление (каждое число заменяем вектором, где соответствующая позиция равна 1)
y = np.eye(vocab_size)[y]
# Собираем модель:
model = Sequential()
# Слой Embedding переводит числовые индексы в векторные представления, например, число 5 превращается в вектор [0.1, 0.2, ...]
model.add(Embedding(vocab_size, 10, input_length=X.shape[1]))
# LSTM слой с 50 нейронами обрабатывает последовательность слов и запоминает контекст
model.add(LSTM(50))
# Dense слой с активацией softmax выдает вероятность для каждого слова из словаря
model.add(Dense(vocab_size, activation='softmax'))
# Выводим структуру модели. При запуске model.summary() ты увидишь, сколько параметров и слоев используется:
model.summary()Сначала текст преобразуется в последовательность чисел, затем создаются подпоследовательности, чтобы модель могла учиться предсказывать следующее слово, и все последовательности дополняются нулями до одинаковой длины; далее слой Embedding превращает эти числа в векторные представления, несущие смысловую нагрузку, затем слой LSTM обрабатывает последовательности, запоминая контекст, а последний слой Dense с softmax выдает распределение вероятностей по словарю, чтобы выбрать наиболее вероятное следующее слово. При запуске model.summary() можно будет схему модели с информацией о каждом слое — это поможет понять, сколько весов и параметров задействовано.
Обучение модели
После того как модель собрана, пора её обучать. Обучение — это процесс, когда модель смотрит на обучающие примеры, пытается предсказать следующее слово и, если ошибается, корректирует свои внутренние параметры.
# Обучаем модель в течение 100 эпох
history = model.fit(X, y, epochs=100, verbose=2)Что произойдет?
-
Эпоха — это один полный проход по всем обучающим данным.
-
В каждой эпохе модель предсказывает следующее слово для каждого примера, затем сравнивает своё предсказание с правильным ответом.
-
Функция потерь (loss) показывает, насколько сильно модель ошибается. Чем ниже значение, тем лучше.
-
Оптимизатор (например, Adam) изменяет веса модели так, чтобы ошибка уменьшалась с каждой эпохой.
-
Можно увидеть в консоли, как значение loss постепенно падает, а точность (accuracy) растет. Например:
Epoch 1/100 1/1 - 0s - loss: 6.5234 - accuracy: 0.0000 Epoch 2/100 1/1 - 0s - loss: 6.4211 - accuracy: 0.0312 ... Epoch 100/100 1/1 - 0s - loss: 2.1234 - accuracy: 0.8750
На первых шагах ошибки велики, а по мере обучения модель становится точнее.
Генерация текста
Самый интересный момент наступает, когда модель уже обучена, и можно попросить её сгенерировать текст. Улучшим функцию генерации, чтобы она была понятна и интересна даже для начинающих:
def generate_text(seed_text, next_words, model, max_length):
"""
Генерирует текст, начиная с seed_text, добавляя next_words.
Аргументы:
seed_text - начальное слово или фраза (например, "Привет")
next_words - сколько слов добавить к фразе
model - обученная модель ИИ
max_length - максимальная длина последовательности (с учетом паддинга)
"""
generated = seed_text
for _ in range(next_words):
# Преобразуем текущий текст в последовательность чисел
token_list = tokenizer.texts_to_sequences([generated])[0]
# Дополняем последовательность нулями, чтобы длина была max_length - 1
token_list = pad_sequences([token_list], maxlen=max_length-1, padding='pre')
# Модель предсказывает вероятности для каждого слова
predicted = model.predict(token_list, verbose=0)
# Выбираем индекс слова с максимальной вероятностью
predicted_index = np.argmax(predicted, axis=1)[0]
# Находим слово по этому индексу в словаре токенизатора
output_word = None
for word, index in tokenizer.word_index.items():
if index == predicted_index:
output_word = word
break
# Добавляем предсказанное слово к нашему сгенерированному тексту
generated += " " + output_word
return generated
# Пример генерации текста:
result = generate_text("Привет", 5, model, max_length)
# Если модель обучена хорошо, код выведет, например:
# "Сгенерированный текст: Привет мир это моя первая"
print("Сгенерированный текст:", result)Начинаем с заданного слова (например, «Привет»), которое преобразуется в последовательность чисел и дополняется нулями до нужной длины, чтобы модель могла его обработать; затем модель предсказывает, какое слово должно идти следующим, и мы выбираем слово с наивысшей вероятностью, добавляя его к тексту, после чего процесс повторяется указанное количество раз. В итоге получается продолжение исходной фразы, и если модель обучена хорошо, результат может выглядеть так: «Привет мир это моя первая». При этом можно поэкспериментировать, изменить начальное слово, количество предсказанных слов или даже настройки модели, чтобы увидеть, как изменится сгенерированный текст.
Не бойтесь сложных вещей — с практикой всё становится понятнее. Экспериментируйте, задавайте вопросы, отлаживайте код и, самое главное, получайте удовольствие от процесса.
Больше актуальных навыков будущие специалисты по ИИ могут освоить на новом онлайн‑курсе от Otus «Искусственный интеллект для подростков». Оставьте заявку на странице курса и получите бесплатное индивидуальное занятие-диагностику.
Автор: techevangelist
