Создание нейронной сети на Python сейчас как никогда доступно. Я покажу вам несколько способов: от самого простого
Создание нейронной сети на Python сейчас как никогда доступно. Я покажу вам несколько способов: от самого простого (с помощью библиотек высокого уровня) до более глубокого понимания.
Способ 1: Самый простой (с помощью Keras/TensorFlow)
Это рекомендуемый способ для начинающих. Keras — это высокоуровневый API, который сильно упрощает работу.
1. Установите необходимые библиотеки: Откройте командную строку(терминал) и выполните:
```bash
pip install tensorflow numpy matplotlib
```
· tensorflow: Включает в себя Keras и все низкоуровневые операции.
· numpy: Для работы с массивами и математики.
· matplotlib: Для визуализации результатов.
2. Пример кода простой нейронной сети для распознавания цифр (MNIST):
Создайте файл my_first_nn.py и скопируйте в него следующий код:
```python
# Импорт необходимых библиотек
import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt
# 1. Загрузка и подготовка данных
# Загружаем самый популярный датасет для начала - рукописные цифры
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()
# Нормализуем значения пикселей от 0-255 к диапазону 0-1 (это важно для обучения)
x_train = x_train / 255.0
x_test = x_test / 255.0
# 2. Создание модели нейронной сети
model = keras.Sequential([
# "Вытягиваем" изображение 28x28 в вектор из 784 элементов
keras.layers.Flatten(input_shape=(28, 28)),
# Полносвязный (Dense) слой с 128 нейронами и функцией активации ReLU
keras.layers.Dense(128, activation='relu'),
# Второй скрытый слой (можно экспериментировать, добавлять/убирать)
keras.layers.Dense(64, activation='relu'),
# Выходной слой. 10 нейронов (по одному на каждую цифру от 0 до 9).
# Функция активации softmax преобразует выход в вероятность принадлежности к каждому классу.
keras.layers.Dense(10, activation='softmax')
])
# 3. Компиляция модели
# Задаем алгоритм оптимизации, функцию потерь и метрики для оценки.
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# 4. Обучение модели
# Передаем данные для обучения, количество эпох (проходов по всему датасету) и данные для валидации
history = model.fit(x_train, y_train, epochs=5, validation_data=(x_test, y_test))
# 5. Оценка качества модели на тестовых данных
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f'\nТочность на тестовых данных: {test_acc}')
# 6. Предсказание для одного примера
# Выберем случайное изображение из тестовой выборки
sample_index = 0 # Попробуйте поменять индекс (например, 1, 5, 100)
sample_image = x_test[sample_index]
sample_label = y_test[sample_index]
# Модель предсказывает вероятности для всех классов. Нам нужен класс с наибольшей вероятностью.
prediction = model.predict(np.array([sample_image])) # модель ожидает батч, поэтому добавляем измерение [ ]
predicted_label = np.argmax(prediction)
print(f"Предсказание: {predicted_label}")
print(f"Правильный ответ: {sample_label}")
# (Опционально) Визуализируем изображение и предсказание
plt.imshow(sample_image, cmap=plt.cm.binary)
plt.title(f"Предсказано: {predicted_label}, Правильно: {sample_label}")
plt.show()
```
3. Запустите код:
```bash
python my_first_nn.py
```
Что произойдет:
1. Скрипт скачает датасет с рукописными цифрами.
2. Создаст модель с тремя слоями.
3. Обучит ее в течение 5 эпох. Вы будете видеть, как точность растет, а ошибка падает.
4. Проверит точность на тестовых данных (обычно получается около 97-98%).
5. Сделает предсказание для одной цифры и покажет ее.
---
Способ 2: Более гибкий (с помощью PyTorch)
PyTorch — это другой популярный фреймворк, который многим нравится за его более "питоновский" и гибкий стиль.
1. Установка:
```bash
pip install torch torchvision matplotlib
```
2. Пример кода для той же задачи на PyTorch:
```python
import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
# 1. Определение архитектуры сети
class NeuralNetwork(nn.Module):
def __init__(self):
super(NeuralNetwork, self).__init__()
self.flatten = nn.Flatten()
self.linear_relu_stack = nn.Sequential(
nn.Linear(28*28, 128),
nn.ReLU(),
nn.Linear(128, 64),
nn.ReLU(),
nn.Linear(64, 10),
)
def forward(self, x):
x = self.flatten(x)
logits = self.linear_relu_stack(x)
return logits
# 2. Загрузка и подготовка данных
transform = transforms.Compose([transforms.ToTensor()])
train_dataset = torchvision.datasets.MNIST(root='./data', train=True, download=True, transform=transform)
test_dataset = torchvision.datasets.MNIST(root='./data', train=False, download=True, transform=transform)
train_loader = torch.utils.data.DataLoader(train_dataset, batch_size=64, shuffle=True)
test_loader = torch.utils.data.DataLoader(test_dataset, batch_size=64, shuffle=False)
# 3. Инициализация модели, функции потерь и оптимизатора
device = "cuda" if torch.cuda.is_available() else "cpu"
print(f"Using {device} device")
model = NeuralNetwork().to(device)
loss_fn = nn.CrossEntropyLoss()
optimizer = optim.Adam(model.parameters(), lr=1e-3)
# 4. Цикл обучения
def train(dataloader, model, loss_fn, optimizer):
size = len(dataloader.dataset)
model.train()
for batch, (X, y) in enumerate(dataloader):
X, y = X.to(device), y.to(device)
# Compute prediction error
pred = model(X)
loss = loss_fn(pred, y)
# Backpropagation
optimizer.zero_grad()
loss.backward()
optimizer.step()
if batch % 100 == 0:
loss, current = loss.item(), batch * len(X)
print(f"loss: {loss:>7f} [{current:>5d}/{size:>5d}]")
# 5. Запуск обучения
epochs = 5
for t in range(epochs):
print(f"Epoch {t+1}\n-------------------------------")
train(train_loader, model, loss_fn, optimizer)
print("Обучение завершено!")
```
---
С чего начать новичку?
1. Начните с Keras (Способ 1). Он проще для понимания базовых концепций.
2. Изучите основные понятия:
· Слой (Layer): Основной строительный блок.
· Нейрон (Neuron): Узел в слое.
· Функция активации (Activation Function): Например, ReLU или Softmax. Решает, "включать" ли нейрон.
· Эпоха (Epoch): Один полный проход по всем обучающим данным.
· Функция потерь (Loss Function): Показывает, насколько предсказание модели ошибочно.
· Оптимизатор (Optimizer): Алгоритм, который уменьшает ошибку (например, Adam).
3. Экспериментируйте: Меняйте количество слоев и нейронов, количество эпох, функции активации. Смотрите, как это влияет на точность.
4. Переходите к более сложным архитектурам: Сверточные сети (CNN) для изображений, Рекуррентные сети (RNN/LSTM) для текста и временных рядов.
Главное — начать с простого работающего примера и постепенно углублять знания. Удачи.
