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

pip install numpy pandas matplotlib scikit-learn tensorflow keras pytorch

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.model_selection import train_test_split
import tensorflow as tf

# Пример создания синтетических данных
X = np.random.rand(1000, 20) # 1000 примеров с 20 признаками
y = np.random.randint(0, 2, size=(1000, 1)) # Бинарные метки классов

# Разделение на обучающую и тестовую выборки
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

print(f"Форма обучающих данных: {X_train.shape}")
print(f"Форма тестовых данных: {X_test.shape}")

import tensorflow as tf
from tensorflow.keras.datasets import mnist
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.utils import to_categorical

# Загрузка датасета MNIST (рукописные цифры)
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Нормализация данных
x_train = x_train / 255.0
x_test = x_test / 255.0

# Преобразование меток в one-hot векторы
y_train = to_categorical(y_train, 10)
y_test = to_categorical(y_test, 10)

print(f"Форма обучающих изображений: {x_train.shape}")
print(f"Форма обучающих меток: {y_train.shape}")

# Создаем последовательную модель
model = Sequential([
Flatten(input_shape=(28, 28)), # Преобразуем 28x28 изображения в вектор размерности 784
Dense(128, activation='relu'), # Скрытый слой с 128 нейронами и ReLU активацией
Dense(64, activation='relu'), # Еще один скрытый слой
Dense(10, activation='softmax') # Выходной слой с 10 классами (цифры 0-9)
])

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

# Выводим архитектуру модели
model.summary()

# Обучаем модель
history = model.fit(
x_train, y_train,
epochs=5,
batch_size=64,
validation_split=0.2,
verbose=1
)

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

# Сделаем предсказание для первого тестового изображения
import numpy as np
prediction = model.predict(np.expand_dims(x_test[0], axis=0))
predicted_class = np.argmax(prediction)
print(f"Предсказанная цифра: {predicted_class}")

import matplotlib.pyplot as plt

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

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

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

plt.tight_layout()
plt.show()

import torch
import torch.nn as nn
import torch.optim as optim
import torchvision
import torchvision.transforms as transforms
import matplotlib.pyplot as plt
import numpy as np

# Проверяем доступность GPU
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
print(f"Используемое устройство: {device}")

# Настраиваем преобразования данных
transform = transforms.Compose([
transforms.ToTensor(),
transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))
])

# Загружаем обучающий и тестовый датасеты
trainset = torchvision.datasets.CIFAR10(root='./data', train=True,
download=True, transform=transform)
trainloader = torch.utils.data.DataLoader(trainset, batch_size=4,
shuffle=True, num_workers=2)

testset = torchvision.datasets.CIFAR10(root='./data', train=False,
download=True, transform=transform)
testloader = torch.utils.data.DataLoader(testset, batch_size=4,
shuffle=False, num_workers=2)

classes = ('самолет', 'автомобиль', 'птица', 'кот', 'олень',
'собака', 'лягушка', 'лошадь', 'корабль', 'грузовик')

class CNN(nn.Module):
def __init__(self):
super(CNN, self).__init__()
# Первый сверточный слой
self.conv1 = nn.Conv2d(3, 16, 3, padding=1)
self.relu1 = nn.ReLU()
self.pool1 = nn.MaxPool2d(2, 2)

# Второй сверточный слой
self.conv2 = nn.Conv2d(16, 32, 3, padding=1)
self.relu2 = nn.ReLU()
self.pool2 = nn.MaxPool2d(2, 2)

# Полносвязные слои
self.fc1 = nn.Linear(32 * 8 * 8, 128)
self.relu3 = nn.ReLU()
self.fc2 = nn.Linear(128, 10)

def forward(self, x):
# Прямой проход через сеть
x = self.pool1(self.relu1(self.conv1(x)))
x = self.pool2(self.relu2(self.conv2(x)))
x = x.view(-1, 32 * 8 * 8) # Преобразуем в одномерный вектор
x = self.relu3(self.fc1(x))
x = self.fc2(x)
return x

# Создаем экземпляр модели и перемещаем на устройство
model = CNN().to(device)

# Функция потерь и оптимизатор
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.001, momentum=0.9)

# Функция для обучения модели
def train_model(epochs=5):
for epoch in range(epochs):
running_loss = 0.0
for i, data in enumerate(trainloader, 0):
# Получаем входные данные и метки
inputs, labels = data[0].to(device), data[1].to(device)

# Обнуляем градиенты
optimizer.zero_grad()

# Прямой проход, вычисление потерь, обратное распространение и оптимизация
outputs = model(inputs)
loss = criterion(outputs, labels)
loss.backward()
optimizer.step()

# Вывод статистики
running_loss += loss.item()
if i % 2000 == 1999:
print(f'[{epoch + 1}, {i + 1}] loss: {running_loss / 2000:.3f}')
running_loss = 0.0

print('Обучение завершено!')

# Обучаем модель
train_model(epochs=5)

# Оценка модели
correct = 0
total = 0
with torch.no_grad(): # Отключаем вычисление градиентов
for data in testloader:
images, labels = data[0].to(device), data[1].to(device)
outputs = model(images)
_, predicted = torch.max(outputs.data, 1)
total += labels.size(0)
correct += (predicted == labels).sum().item()

print(f'Точность модели на 10000 тестовых изображениях: {100 * correct / total}%')

import tensorflow as tf
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Dropout, concatenate, Conv2DTranspose

# Функция для создания U-Net архитектуры
def unet_model(input_size=(256, 256, 1)):
inputs = Input(input_size)

# Кодирующий путь (сжатие)
conv1 = Conv2D(64, 3, activation='relu', padding='same')(inputs)
conv1 = Conv2D(64, 3, activation='relu', padding='same')(conv1)
pool1 = MaxPooling2D(pool_size=(2, 2))(conv1)

conv2 = Conv2D(128, 3, activation='relu', padding='same')(pool1)
conv2 = Conv2D(128, 3, activation='relu', padding='same')(conv2)
pool2 = MaxPooling2D(pool_size=(2, 2))(conv2)

conv3 = Conv2D(256, 3, activation='relu', padding='same')(pool2)
conv3 = Conv2D(256, 3, activation='relu', padding='same')(conv3)
pool3 = MaxPooling2D(pool_size=(2, 2))(conv3)

conv4 = Conv2D(512, 3, activation='relu', padding='same')(pool3)
conv4 = Conv2D(512, 3, activation='relu', padding='same')(conv4)
drop4 = Dropout(0.5)(conv4)
pool4 = MaxPooling2D(pool_size=(2, 2))(drop4)

# Нижняя точка (переход)
conv5 = Conv2D(1024, 3, activation='relu', padding='same')(pool4)
conv5 = Conv2D(1024, 3, activation='relu', padding='same')(conv5)
drop5 = Dropout(0.5)(conv5)

# Декодирующий путь (восстановление)
up6 = Conv2DTranspose(512, 2, strides=(2, 2), padding='same')(drop5)
merge6 = concatenate([drop4, up6], axis=3)
conv6 = Conv2D(512, 3, activation='relu', padding='same')(merge6)
conv6 = Conv2D(512, 3, activation='relu', padding='same')(conv6)

up7 = Conv2DTranspose(256, 2, strides=(2, 2), padding='same')(conv6)
merge7 = concatenate([conv3, up7], axis=3)
conv7 = Conv2D(256, 3, activation='relu', padding='same')(merge7)
conv7 = Conv2D(256, 3, activation='relu', padding='same')(conv7)

up8 = Conv2DTranspose(128, 2, strides=(2, 2), padding='same')(conv7)
merge8 = concatenate([conv2, up8], axis=3)
conv8 = Conv2D(128, 3, activation='relu', padding='same')(merge8)
conv8 = Conv2D(128, 3, activation='relu', padding='same')(conv8)

up9 = Conv2DTranspose(64, 2, strides=(2, 2), padding='same')(conv8)
merge9 = concatenate([conv1, up9], axis=3)
conv9 = Conv2D(64, 3, activation='relu', padding='same')(merge9)
conv9 = Conv2D(64, 3, activation='relu', padding='same')(conv9)

# Выходной слой – карта сегментации
outputs = Conv2D(1, 1, activation='sigmoid')(conv9)

model = Model(inputs=inputs, outputs=outputs)
return model

# Создаем модель
model = unet_model()
model.summary()

# Функция потерь для задач сегментации – Dice Loss
def dice_loss(y_true, y_pred):
smooth = 1.0
y_true_f = tf.reshape(y_true, [-1])
y_pred_f = tf.reshape(y_pred, [-1])
intersection = tf.reduce_sum(y_true_f * y_pred_f)
return 1 – (2. * intersection + smooth) / (tf.reduce_sum(y_true_f) + tf.reduce_sum(y_pred_f) + smooth)

# Метрика для оценки сегментации – Dice Coefficient
def dice_coef(y_true, y_pred):
return 1 – dice_loss(y_true, y_pred)

# Компилируем модель
model.compile(optimizer='adam', loss=dice_loss, metrics=[dice_coef, 'binary_accuracy'])

# 1. Sequential API (для последовательных моделей)
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Activation

sequential_model = Sequential([
Dense(32, input_shape=(10,)),
Activation('relu'),
Dense(1),
Activation('sigmoid')
])

# 2. Functional API (для произвольных графовых структур)
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Dense

inputs = Input(shape=(10,))
x = Dense(32, activation='relu')(inputs)
outputs = Dense(1, activation='sigmoid')(x)
functional_model = Model(inputs=inputs, outputs=outputs)

# 3. Model Subclassing (для максимальной гибкости)
import tensorflow as tf

class CustomModel(tf.keras.Model):
def __init__(self):
super(CustomModel, self).__init__()
self.dense1 = Dense(32, activation='relu')
self.dense2 = Dense(1, activation='sigmoid')

def call(self, inputs):
x = self.dense1(inputs)
return self.dense2(x)

subclass_model = CustomModel()

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.preprocessing import MinMaxScaler
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, LSTM, Dropout

# 1. Загрузим исторические данные акций (пример на основе Yahoo Finance)
# В реальном проекте здесь будет код загрузки данных через API
# Для примера создадим синтетические данные
dates = pd.date_range(start='2018-01-01', end='2023-01-01', freq='D')
prices = np.cumsum(np.random.randn(len(dates))) + 100 # Случайное блуждание
stock_data = pd.DataFrame({'Date': dates, 'Close': prices})

# 2. Предобработка данных
# Используем только цены закрытия и преобразуем их в массив
data = stock_data['Close'].values.reshape(-1, 1)

# Масштабирование данных в диапазон [0, 1]
scaler = MinMaxScaler(feature_range=(0, 1))
scaled_data = scaler.fit_transform(data)

# 3. Создание последовательностей для обучения
def create_sequences(data, seq_length):
X, y = [], []
for i in range(len(data) – seq_length):
X.append(data[i:i+seq_length, 0])
y.append(data[i+seq_length, 0])
return np.array(X), np.array(y)

# Определим длину последовательности (сколько предыдущих дней использовать для прогноза)
sequence_length = 60
X, y = create_sequences(scaled_data, sequence_length)

# Разделим данные на обучающую и тестовую выборки
train_size = int(len(X) * 0.8)
X_train, X_test = X[:train_size], X[train_size:]
y_train, y_test = y[:train_size], y[train_size:]

# Преобразуем данные в формат, подходящий для LSTM: [samples, time steps, features]
X_train = X_train.reshape(X_train.shape[0], X_train.shape[1], 1)
X_test = X_test.reshape(X_test.shape[0], X_test.shape[1], 1)

# 4. Создание и обучение LSTM модели
model = Sequential([
LSTM(units=50, return_sequences=True, input_shape=(X_train.shape[1], 1)),
Dropout(0.2),
LSTM(units=50, return_sequences=False),
Dropout(0.2),
Dense(units=1)
])

model.compile(optimizer='adam', loss='mean_squared_error')
history = model.fit(
X_train, y_train,
epochs=20,
batch_size=32,
validation_split=0.1,
verbose=1
)

# 5. Предсказание и визуализация результатов
predictions = model.predict(X_test)
predictions = scaler.inverse_transform(predictions)

# Преобразуем тестовые метки обратно к исходному масштабу
actual = scaler.inverse_transform(y_test.reshape(-1, 1))

# Визуализация результатов
plt.figure(figsize=(14, 7))
plt.plot(actual, label='Фактические цены')
plt.plot(predictions, label='Предсказанные цены')
plt.title('Прогнозирование цен на акции с помощью LSTM')
plt.xlabel('Время')
plt.ylabel('Цена')
plt.legend()
plt.grid(True)
plt.show()

# 6. Оценка модели
mse = np.mean((predictions – actual)**2)
rmse = np.sqrt(mse)
print(f'Среднеквадратичная ошибка (RMSE): {rmse:.2f}')