Python-коды для ИИ: практические решения и варианты реализации

Генеративно-состязательная сеть (GAN) для генерации цифр MNIST

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

import tensorflow as tf
from tensorflow import keras
import numpy as np

latent_dim = 100

# Генератор
def build_generator():
    model = keras.Sequential([
        keras.layers.Dense(256, input_dim=latent_dim, activation='relu'),
        keras.layers.BatchNormalization(),
        keras.layers.Dense(512, activation='relu'),
        keras.layers.BatchNormalization(),
        keras.layers.Dense(784, activation='sigmoid'),
        keras.layers.Reshape((28, 28))
    ])
    return model

# Дискриминатор
def build_discriminator():
    model = keras.Sequential([
        keras.layers.Flatten(input_shape=(28, 28)),
        keras.layers.Dense(512, activation='relu'),
        keras.layers.Dropout(0.3),
        keras.layers.Dense(256, activation='relu'),
        keras.layers.Dropout(0.3),
        keras.layers.Dense(1, activation='sigmoid')
    ])
    return model

# Компиляция GAN
generator = build_generator()
discriminator = build_discriminator()
discriminator.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

gan_input = keras.Input(shape=(latent_dim,))
x = generator(gan_input)
gan_output = discriminator(x)
gan = keras.Model(gan_input, gan_output)
gan.compile(optimizer='adam', loss='binary_crossentropy')

# Данные для обучения
(x_train, _), _ = keras.datasets.mnist.load_data()
x_train = x_train / 255.0
x_train = np.expand_dims(x_train, axis=-1) if False else x_train
batch_size = 32
epochs = 50

for epoch in range(epochs):
    # Обучение дискриминатора
    idx = np.random.randint(0, x_train.shape[0], batch_size)
    real_imgs = x_train[idx]
    noise = np.random.normal(0, 1, (batch_size, latent_dim))
    fake_imgs = generator.predict(noise)
    
    d_loss_real = discriminator.train_on_batch(real_imgs, np.ones((batch_size, 1)))
    d_loss_fake = discriminator.train_on_batch(fake_imgs, np.zeros((batch_size, 1)))
    d_loss = 0.5 * np.add(d_loss_real, d_loss_fake)
    
    # Обучение GAN
    noise = np.random.normal(0, 1, (batch_size, latent_dim))
    g_loss = gan.train_on_batch(noise, np.ones((batch_size, 1)))
    
    if epoch % 10 == 0:
        print(f'Epoch {epoch}, d_loss: {d_loss[0]:.4f}, g_loss: {g_loss:.4f}')

# Генерация изображения после обучения
noise_test = np.random.normal(0, 1, (1, latent_dim))
gen_img = generator.predict(noise_test).reshape(28, 28)
print('Сгенерировано изображение размером 28x28')

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

Цель: создание новых реалистичных данных, аугментация.

Тонкая настройка BERT для задачи вопрос-ответ (QA)

Используется предобученный BERT из библиотеки transformers. Пример для датасета SQuAD.

from transformers import BertForQuestionAnswering, BertTokenizer
import torch

model_name = 'bert-large-uncased-whole-word-masking-finetuned-squad'
model = BertForQuestionAnswering.from_pretrained(model_name)
tokenizer = BertTokenizer.from_pretrained(model_name)

question = 'Какой язык используется для ИИ?'
context = 'Python является популярным языком для разработки искусственного интеллекта.'

inputs = tokenizer(question, context, return_tensors='pt')
with torch.no_grad():
    outputs = model(**inputs)
answer_start = torch.argmax(outputs.start_logits)
answer_end = torch.argmax(outputs.end_logits) + 1
answer = tokenizer.convert_tokens_to_string(tokenizer.convert_ids_to_tokens(inputs['input_ids'][0][answer_start:answer_end]))
print(f'Ответ: {answer}')

Ответ: Python

Пояснение: модель возвращает логиты для начала и конца ответа. Используется аргумент max_seq_length при длинных контекстах.

Проблемы: ответ вне контекста - проверить длину; медленная работа - использовать distillation-версии (distilbert).

Обучение с подкреплением с использованием PyTorch и среды CartPole

Реализация алгоритма DQN на PyTorch для классической задачи.

import gym
import torch
import torch.nn as nn
import torch.optim as optim
import random
from collections import deque

env = gym.make('CartPole-v1')
state_dim = env.observation_space.shape[0]
action_dim = env.action_space.n

class DQN(nn.Module):
    def __init__(self):
        super().__init__()
        self.fc = nn.Sequential(
            nn.Linear(state_dim, 128),
            nn.ReLU(),
            nn.Linear(128, 64),
            nn.ReLU(),
            nn.Linear(64, action_dim)
        )
    def forward(self, x):
        return self.fc(x)

model = DQN()
target = DQN()
target.load_state_dict(model.state_dict())
optimizer = optim.Adam(model.parameters(), lr=0.001)
memory = deque(maxlen=10000)

for episode in range(200):
    state = env.reset()
    total_reward = 0
    done = False
    while not done:
        if random.random() < 0.1:
            action = env.action_space.sample()
        else:
            with torch.no_grad():
                action = model(torch.FloatTensor(state)).argmax().item()
        next_state, reward, done, _ = env.step(action)
        memory.append((state, action, reward, next_state, done))
        state = next_state
        total_reward += reward
        
        if len(memory) > 32:
            batch = random.sample(memory, 32)
            states, actions, rewards, next_states, dones = zip(*batch)
            states = torch.FloatTensor(states)
            actions = torch.LongTensor(actions)
            rewards = torch.FloatTensor(rewards)
            next_states = torch.FloatTensor(next_states)
            dones = torch.FloatTensor(dones)
            
            q_values = model(states).gather(1, actions.unsqueeze(1)).squeeze()
            with torch.no_grad():
                max_next = target(next_states).max(1)[0]
                target_q = rewards + 0.99 * max_next * (1 - dones)
            loss = nn.MSELoss()(q_values, target_q)
            optimizer.zero_grad()
            loss.backward()
            optimizer.step()
    
    if episode % 10 == 0:
        target.load_state_dict(model.state_dict())
        print(f'Эпизод {episode}, награда: {total_reward}')

Пример вывода:
Эпизод 0, награда: 12
Эпизод 10, награда: 45
Эпизод 50, награда: 200 (решение задачи)

Цель: демонстрация базового Q-learning с нейросетью.

Экспорт модели в формат ONNX для кросс-платформенного использования

ONNX позволяет запускать модели в средах без Python (C++, Java). Пример экспорта обученной Keras модели.

import tf2onnx
import tensorflow as tf

# Предположим, что модель уже обучена (model)
model = tf.keras.models.load_model('mnist_model.h5')

# Конвертация
onnx_model, _ = tf2onnx.convert.from_keras(model, opset=13)

# Сохранение
with open('mnist_model.onnx', 'wb') as f:
    f.write(onnx_model.SerializeToString())
print('Модель экспортирована в ONNX')

Вывод: файл mnist_model.onnx создан.

Использование: загрузить в ONNX Runtime: onnxruntime.InferenceSession('mnist_model.onnx').

Проблемы: неподдерживаемые операции - использовать opset ниже; размер файла - применить квантизацию.

Создание API для предсказаний с помощью FastAPI и модели ИИ

FastAPI позволяет быстро развернуть модель как веб-сервис. Пример на основе предобученной модели для классификации текста.

from fastapi import FastAPI
from pydantic import BaseModel
from transformers import pipeline

app = FastAPI()
classifier = pipeline('sentiment-analysis')

class TextInput(BaseModel):
    text: str

@app.post('/predict')
def predict(input: TextInput):
    result = classifier(input.text)
    return {'label': result[0]['label'], 'score': result[0]['score']}

# Запуск: uvicorn app:app --reload

Тест через curl:
curl -X POST 'http://localhost:8000/predict' -H 'Content-Type: application/json' -d '{"text":"I love Python!"}'
Ответ: {"label":"POSITIVE","score":0.9998}

Цель: интеграция ИИ в приложения.