Нейронные сети на Python: пошаговое руководство для начинающих

# Создание виртуального окружения
python -m venv neural_net_env

# Активация окружения
# Для Windows
neural_net_env\Scripts\activate
# Для macOS/Linux
source neural_net_env/bin/activate

# Установка базовых библиотек
pip install numpy matplotlib pandas scikit-learn

import numpy as np

class SimpleNeuralNetwork:
def __init__(self, input_size, hidden_size, output_size):
# Инициализация весов со случайными значениями
self.W1 = np.random.randn(input_size, hidden_size) * 0.01
self.b1 = np.zeros((1, hidden_size))
self.W2 = np.random.randn(hidden_size, output_size) * 0.01
self.b2 = np.zeros((1, output_size))

def sigmoid(self, x):
# Сигмоидная функция активации
return 1 / (1 + np.exp(-x))

def sigmoid_derivative(self, x):
# Производная сигмоидной функции
return x * (1 – x)

def forward(self, X):
# Прямое распространение
self.z1 = np.dot(X, self.W1) + self.b1
self.a1 = self.sigmoid(self.z1)
self.z2 = np.dot(self.a1, self.W2) + self.b2
self.a2 = self.sigmoid(self.z2)
return self.a2

def backward(self, X, y, output, learning_rate):
# Обратное распространение ошибки
m = X.shape[0]

# Вычисление градиентов для второго слоя
dz2 = output – y
dW2 = (1/m) * np.dot(self.a1.T, dz2)
db2 = (1/m) * np.sum(dz2, axis=0, keepdims=True)

# Вычисление градиентов для первого слоя
dz1 = np.dot(dz2, self.W2.T) * self.sigmoid_derivative(self.a1)
dW1 = (1/m) * np.dot(X.T, dz1)
db1 = (1/m) * np.sum(dz1, axis=0, keepdims=True)

# Обновление весов
self.W2 -= learning_rate * dW2
self.b2 -= learning_rate * db2
self.W1 -= learning_rate * dW1
self.b1 -= learning_rate * db1

def train(self, X, y, epochs, learning_rate):
# Обучение нейросети
for epoch in range(epochs):
# Прямое распространение
output = self.forward(X)

# Вычисление функции потерь
loss = -np.mean(y * np.log(output) + (1 – y) * np.log(1 – output))

# Обратное распространение
self.backward(X, y, output, learning_rate)

# Вывод прогресса обучения
if epoch % 100 == 0:
print(f"Эпоха {epoch}, ошибка: {loss}")

return self

def predict(self, X):
# Предсказание на новых данных
return self.forward(X)

# Подготовка данных для XOR
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

# Создание и обучение нейросети
nn = SimpleNeuralNetwork(input_size=2, hidden_size=4, output_size=1)
nn.train(X, y, epochs=10000, learning_rate=0.1)

# Проверка предсказаний
predictions = nn.predict(X)
print("Предсказания:")
print(predictions)
print("Округленные предсказания:")
print(np.round(predictions))

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

# Подготовка данных
X = np.array([[0, 0], [0, 1], [1, 0], [1, 1]])
y = np.array([[0], [1], [1], [0]])

# Создание модели
model = keras.Sequential([
keras.layers.Dense(4, input_dim=2, activation='relu'),
keras.layers.Dense(1, activation='sigmoid')
])

# Компиляция модели
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])

# Обучение модели
history = model.fit(X, y, epochs=1000, verbose=0)

# Оценка модели
loss, accuracy = model.evaluate(X, y)
print(f"Точность: {accuracy*100:.2f}%")

# Получение предсказаний
predictions = model.predict(X)
print("Предсказания:")
print(predictions)
print("Округленные предсказания:")
print(np.round(predictions))

import torch
import torch.nn as nn
import torch.optim as optim
import numpy as np

# Преобразование данных в формат PyTorch
X = torch.tensor([[0, 0], [0, 1], [1, 0], [1, 1]], dtype=torch.float32)
y = torch.tensor([[0], [1], [1], [0]], dtype=torch.float32)

# Определение модели
class XORModel(nn.Module):
def __init__(self):
super(XORModel, self).__init__()
self.layer1 = nn.Linear(2, 4)
self.layer2 = nn.Linear(4, 1)
self.relu = nn.ReLU()
self.sigmoid = nn.Sigmoid()

def forward(self, x):
x = self.relu(self.layer1(x))
x = self.sigmoid(self.layer2(x))
return x

# Создание модели и оптимизатора
model = XORModel()
criterion = nn.BCELoss()
optimizer = optim.Adam(model.parameters(), lr=0.1)

# Обучение модели
for epoch in range(10000):
# Прямое распространение
outputs = model(X)
loss = criterion(outputs, y)

# Обратное распространение и оптимизация
optimizer.zero_grad()
loss.backward()
optimizer.step()

if (epoch+1) % 1000 == 0:
print(f'Эпоха {epoch+1}, Потери: {loss.item():.4f}')

# Оценка модели
model.eval()
with torch.no_grad():
outputs = model(X)
predicted = torch.round(outputs.data)
accuracy = (predicted == y).sum().item() / y.size(0)
print(f'Точность: {accuracy*100:.2f}%')
print("Предсказания:")
print(outputs)
print("Округленные предсказания:")
print(predicted)

import tensorflow as tf
from tensorflow import keras
import numpy as np
import matplotlib.pyplot as plt

# Загрузка данных MNIST
(x_train, y_train), (x_test, y_test) = keras.datasets.mnist.load_data()

# Предобработка данных
x_train = x_train.reshape(x_train.shape[0], 28*28) / 255.0
x_test = x_test.reshape(x_test.shape[0], 28*28) / 255.0
y_train = keras.utils.to_categorical(y_train, 10)
y_test = keras.utils.to_categorical(y_test, 10)

# Создание модели для классификации
model = keras.Sequential([
keras.layers.Dense(128, activation='relu', input_shape=(784,)),
keras.layers.Dropout(0.2),
keras.layers.Dense(64, activation='relu'),
keras.layers.Dropout(0.2),
keras.layers.Dense(10, activation='softmax')
])

# Компиляция модели
model.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])

# Обучение модели
history = model.fit(x_train, y_train,
batch_size=128,
epochs=10,
verbose=1,
validation_data=(x_test, y_test))

# Оценка модели
test_loss, test_acc = model.evaluate(x_test, y_test)
print(f'Точность на тестовых данных: {test_acc*100:.2f}%')

# Визуализация результатов обучения
plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(history.history['accuracy'], label='Обучающая выборка')
plt.plot(history.history['val_accuracy'], label='Проверочная выборка')
plt.title('Точность модели')
plt.ylabel('Точность')
plt.xlabel('Эпоха')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(history.history['loss'], label='Обучающая выборка')
plt.plot(history.history['val_loss'], label='Проверочная выборка')
plt.title('Потери модели')
plt.ylabel('Потери')
plt.xlabel('Эпоха')
plt.legend()

plt.tight_layout()
plt.show()

from tensorflow.keras.preprocessing.image import ImageDataGenerator

# Создаем генератор для аугментации данных
datagen = ImageDataGenerator(
rotation_range=10, # Случайный поворот изображения
width_shift_range=0.1, # Случайный сдвиг по горизонтали
height_shift_range=0.1, # Случайный сдвиг по вертикали
zoom_range=0.1, # Случайное масштабирование
horizontal_flip=True, # Случайное отражение по горизонтали
fill_mode='nearest' # Метод заполнения пикселей
)

# Применяем аугментацию к обучающим данным
x_train_reshaped = x_train.reshape(-1, 28, 28, 1)
datagen.fit(x_train_reshaped)

# Обучение модели с аугментацией
model_aug = keras.Sequential([
keras.layers.Flatten(input_shape=(28, 28, 1)),
keras.layers.Dense(128, activation='relu'),
keras.layers.Dropout(0.2),
keras.layers.Dense(64, activation='relu'),
keras.layers.Dense(10, activation='softmax')
])

model_aug.compile(optimizer='adam',
loss='categorical_crossentropy',
metrics=['accuracy'])

# Обучаем модель с аугментированными данными
batch_size = 128
history_aug = model_aug.fit(
datagen.flow(x_train_reshaped, y_train, batch_size=batch_size),
steps_per_epoch=len(x_train) // batch_size,
epochs=10,
validation_data=(x_test.reshape(-1, 28, 28, 1), y_test)
)

from sklearn.model_selection import RandomizedSearchCV
from tensorflow.keras.wrappers.scikit_learn import KerasClassifier
import numpy as np

def create_model(neurons=64, dropout_rate=0.2, learning_rate=0.001):
model = keras.Sequential([
keras.layers.Dense(neurons, activation='relu', input_shape=(784,)),
keras.layers.Dropout(dropout_rate),
keras.layers.Dense(neurons // 2, activation='relu'),
keras.layers.Dropout(dropout_rate),
keras.layers.Dense(10, activation='softmax')
])

optimizer = keras.optimizers.Adam(learning_rate=learning_rate)
model.compile(optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy'])
return model

# Создаем обертку модели для использования в RandomizedSearchCV
model_wrapper = KerasClassifier(build_fn=create_model, epochs=10, batch_size=128, verbose=0)

# Определяем пространство гиперпараметров
param_dist = {
'neurons': [32, 64, 128, 256],
'dropout_rate': [0\.1, 0.2, 0.3, 0.4],
'learning_rate': [0\.0001, 0.001, 0.01],
'batch_size': [64, 128, 256],
'epochs': [5, 10, 15]
}

# Применяем случайный поиск
random_search = RandomizedSearchCV(
estimator=model_wrapper,
param_distributions=param_dist,
n_iter=10, # Количество комбинаций для проверки
cv=3, # Количество фолдов для кросс-валидации
n_jobs=1, # Для использования GPU лучше оставить 1
verbose=2
)

# Запускаем поиск (это может занять значительное время)
# random_search.fit(x_train, y_train)

# Лучшие параметры и результаты
# print(f"Лучшие параметры: {random_search.best_params_}")
# print(f"Лучшая точность: {random_search.best_score_*100:.2f}%")

def create_optimized_model(input_shape=(784,), num_classes=10):
inputs = keras.Input(shape=input_shape)

# Первый блок с L2-регуляризацией
x = keras.layers.Dense(128, 
kernel_regularizer=keras.regularizers.l2(0.001),
activation='relu')(inputs)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Dropout(0.3)(x)

# Второй блок с L1-регуляризацией
x = keras.layers.Dense(64, 
kernel_regularizer=keras.regularizers.l1(0.0001),
activation='relu')(x)
x = keras.layers.BatchNormalization()(x)
x = keras.layers.Dropout(0.2)(x)

# Выходной слой
outputs = keras.layers.Dense(num_classes, activation='softmax')(x)

model = keras.Model(inputs, outputs)

# Компиляция с планировщиком скорости обучения
lr_schedule = keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate=0.001,
decay_steps=10000,
decay_rate=0.9)
optimizer = keras.optimizers.Adam(learning_rate=lr_schedule)

model.compile(
optimizer=optimizer,
loss='categorical_crossentropy',
metrics=['accuracy']
)

return model

# Создание и обучение оптимизированной модели
optimized_model = create_optimized_model()

# Добавляем раннюю остановку для предотвращения переобучения
early_stopping = keras.callbacks.EarlyStopping(
monitor='val_loss', 
patience=3,
restore_best_weights=True
)

# Добавляем сохранение лучшей модели
model_checkpoint = keras.callbacks.ModelCheckpoint(
'best_model.h5',
monitor='val_accuracy',
save_best_only=True,
verbose=1
)

# Обучаем модель с колбэками
history_opt = optimized_model.fit(
x_train, y_train,
batch_size=128,
epochs=20, # Увеличиваем количество эпох
validation_data=(x_test, y_test),
callbacks=[early_stopping, model_checkpoint],
verbose=1
)

# Оценка модели
test_loss_opt, test_acc_opt = optimized_model.evaluate(x_test, y_test)
print(f'Точность оптимизированной модели: {test_acc_opt*100:.2f}%')

import seaborn as sns
from sklearn.metrics import confusion_matrix

# Получаем предсказания модели
y_pred_prob = optimized_model.predict(x_test)
y_pred = np.argmax(y_pred_prob, axis=1)
y_true = np.argmax(y_test, axis=1)

# Создаем матрицу ошибок
conf_matrix = confusion_matrix(y_true, y_pred)

# Визуализируем матрицу ошибок
plt.figure(figsize=(10, 8))
sns.heatmap(conf_matrix, annot=True, fmt='d', cmap='Blues')
plt.title('Матрица ошибок')
plt.xlabel('Предсказанный класс')
plt.ylabel('Истинный класс')
plt.show()

# Визуализируем неправильные предсказания
incorrect_indices = np.where(y_pred != y_true)[0]
if len(incorrect_indices) > 0:
plt.figure(figsize=(15, 10))
for i, idx in enumerate(incorrect_indices[:15]): # Показываем первые 15 ошибок
plt.subplot(3, 5, i + 1)
img = x_test[idx].reshape(28, 28)
plt.imshow(img, cmap='gray')
plt.title(f'Истина: {y_true[idx]}, Прогноз: {y_pred[idx]}')
plt.axis('off')
plt.tight_layout()
plt.show()