Машинное обучение в Python: Концепции и примеры

Python стал лучшим выбором для проектов машинного обучения благодаря своей простоте, гибкости и обширной экосистеме библиотек. В этом подробном руководстве мы рассмотрим, как использовать Python для машинного обучения, начиная с выбора подходящих библиотек и заканчивая реализацией основных алгоритмов и методов.

Table of Contents

Почему стоит выбрать Python для машинного обучения

Python стал основным языком программирования для проектов машинного обучения благодаря нескольким факторам:

Простота использования: Простой и понятный синтаксис Python позволяет разработчикам сосредоточиться на логике проектов машинного обучения, а не на тонкостях языка.
Обширные библиотеки: Python может похвастаться обширной экосистемой библиотек, специально разработанных для машинного обучения, таких как TensorFlow, scikit-learn и PyTorch.
Сильное сообщество: Широкое распространение Python способствовало формированию большого и активного сообщества, которое постоянно вносит свой вклад в разработку новых инструментов и ресурсов для машинного обучения.
Кросс-платформенная совместимость: Python не зависит от платформы, что означает, что проекты машинного обучения, разработанные на Python, могут работать на различных операционных системах.

Вот некоторые из наиболее популярных библиотек Python для машинного обучения:

Scikit-learn

Scikit-learn - это библиотека с открытым исходным кодом, которая предоставляет простые и эффективные инструменты для добычи данных, анализа данных и машинного обучения. Она предлагает широкий спектр алгоритмов, таких как классификация, регрессия, кластеризация и уменьшение размерности.

Пример: Обучение простого классификатора с помощью Scikit-learn

В этом примере мы обучим классификатор k-Nearest Neighbors (KNN) на наборе данных Iris, который является популярным набором данных для начинающих пользователей машинного обучения. Набор данных содержит 150 образцов цветов ириса с четырьмя характеристиками: длина чашелистика, ширина чашелистика, длина лепестка и ширина лепестка. Цель состоит в том, чтобы отнести цветы к одному из трех видов: setosa, versicolor или virginica.

from sklearn import datasets
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score

# Загрузить набор данных Iris
iris = datasets.load_iris()
X = iris.data
y = iris.target

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

# Создать классификатор KNN
knn = KNeighborsClassifier(n_neighbors=3)

# Обучить классификатор на обучающем множестве
knn.fit(X_train, y_train)

# Делать прогнозы на тестовом множестве
y_pred = knn.predict(X_test)

# Вычислить точность классификатора
accuracy = accuracy_score(y_test, y_pred)
print("Accuracy:", accuracy)

from sklearn import datasets

from sklearn.model_selection import train_test_split

from sklearn.neighbors import KNeighborsClassifier

from sklearn.metrics import accuracy_score

# Загрузить набор данных Iris

iris = datasets.load_iris()

X = iris.data

y = iris.target

# Разделите набор данных на обучающий и тестовый наборы

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# Создать классификатор KNN

knn = KNeighborsClassifier(n_neighbors=3)

# Обучить классификатор на обучающем множестве

knn.fit(X_train, y_train)

# Делать прогнозы на тестовом множестве

y_pred = knn.predict(X_test)

# Вычислить точность классификатора

accuracy = accuracy_score(y_test, y_pred)

print("Accuracy:", accuracy)

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

TensorFlow

TensorFlow - это библиотека с открытым исходным кодом, разработанная компанией Google, которая предлагает гибкую платформу для приложений машинного обучения и глубокого обучения. Она широко используется для создания нейронных сетей и уделяет большое внимание производительности и масштабируемости.

Пример: Создание простой нейронной сети с помощью TensorFlow

В этом примере мы создадим простую нейронную сеть с помощью TensorFlow для классификации рукописных цифр из набора данных MNIST. Набор данных содержит 60 000 обучающих изображений и 10 000 тестовых изображений рукописных цифр, каждое размером 28×28 пикселей. Наша нейронная сеть будет иметь входной слой, два скрытых слоя и выходной слой.

import tensorflow as tf
from tensorflow.keras import layers

# Создание последовательной модели
model = tf.keras.Sequential()

# Добавить слои в модель
model.add(layers.Dense(64, activation='relu', input_shape=(784,)))
model.add(layers.Dense(64, activation='relu'))
model.add(layers.Dense(10, activation='softmax'))

# Скомпилировать модель
model.compile(optimizer=tf.keras.optimizers.Adam(0.001),
              loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

# Обучение и оценка модели
history = model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

import tensorflow as tf

from tensorflow.keras import layers

# Создание последовательной модели

model = tf.keras.Sequential()

# Добавить слои в модель

model.add(layers.Dense(64, activation='relu', input_shape=(784,)))

model.add(layers.Dense(64, activation='relu'))

model.add(layers.Dense(10, activation='softmax'))

# Скомпилировать модель

model.compile(optimizer=tf.keras.optimizers.Adam(0.001),

loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True),

metrics=['accuracy'])

# Обучение и оценка модели

history = model.fit(X_train, y_train, epochs=10, validation_data=(X_test, y_test))

В этом примере мы сначала создаем последовательную модель с помощью API Keras для TensorFlow. Затем мы добавляем в модель три плотных слоя, причем первые два слоя имеют 64 нейрона и функцию активации ReLU. Входная форма первого слоя установлена на 784, так как изображения 28×28 будут сплющены в одномерный массив. Выходной слой имеет 10 нейронов, соответствующих 10 классам цифр, и функцию активации softmax для вывода вероятностей.

Затем мы составляем модель с помощью оптимизатора Adam с коэффициентом обучения 0,001, категориальной потерей перекрестной энтропии и точностью в качестве метрики. Наконец, мы обучаем модель в течение 10 эпох на тренировочных данных и оцениваем ее на тестовых данных.

PyTorch

PyTorch - это библиотека с открытым исходным кодом, разработанная компанией Facebook, которая предоставляет гибкую платформу для приложений глубокого обучения. Она имеет динамический граф вычислений, что делает ее особенно подходящей для проектов, связанных с рекуррентными нейронными сетями и обработкой естественного языка.

Пример: Обучение простого классификатора с помощью PyTorch

В этом примере мы создадим простую нейронную сеть с помощью PyTorch для классификации рукописных цифр из набора данных MNIST, аналогично предыдущему примеру с TensorFlow. Набор данных содержит 60 000 обучающих изображений и 10 000 тестовых изображений рукописных цифр, каждое размером 28×28 пикселей. Наша нейронная сеть будет иметь входной слой, два скрытых слоя и выходной слой.

import torch
import torch.nn as nn
import torch.optim as optim
from torchvision import datasets, transforms

# Определите модель нейронной сети
class SimpleClassifier(nn.Module):
    def __init__(self):
        super(SimpleClassifier, self).__init__()
        self.fc1 = nn.Linear(784, 128)
        self.fc2 = nn.Linear(128, 64)
        self.fc3 = nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        x = torch.relu(self.fc1(x))
        x = torch.relu(self.fc2(x))
        x = self.fc3(x)
        return x

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

trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)
testset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)
testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

# Создание модели, функции потерь и оптимизатора
model = SimpleClassifier()
criterion = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# Обучить модель
num_epochs = 10
for epoch in range(num_epochs):
    running_loss = 0.0
    for images, labels in trainloader:
        optimizer.zero_grad()

        output = model(images)
        loss = criterion(output, labels)

        loss.backward()
        optimizer.step()

        running_loss += loss.item()

    print(f"Epoch {epoch + 1}, Loss: {running_loss / len(trainloader)}")

import torch

import torch.nn as nn

import torch.optim as optim

from torchvision import datasets, transforms

# Определите модель нейронной сети

class SimpleClassifier(nn.Module):

def __init__(self):

super(SimpleClassifier, self).__init__()

self.fc1 = nn.Linear(784, 128)

self.fc2 = nn.Linear(128, 64)

self.fc3 = nn.Linear(64, 10)

def forward(self, x):

x = x.view(-1, 784)

x = torch.relu(self.fc1(x))

x = torch.relu(self.fc2(x))

x = self.fc3(x)

return x

# Загрузить набор данных и применить преобразования

transform = transforms.Compose([transforms.ToTensor(),

transforms.Normalize((0.5,), (0.5,))])

trainset = datasets.MNIST(root='./data', train=True, download=True, transform=transform)

testset = datasets.MNIST(root='./data', train=False, download=True, transform=transform)

trainloader = torch.utils.data.DataLoader(trainset, batch_size=64, shuffle=True)

testloader = torch.utils.data.DataLoader(testset, batch_size=64, shuffle=False)

# Создание модели, функции потерь и оптимизатора

model = SimpleClassifier()

criterion = nn.CrossEntropyLoss()

optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.9)

# Обучить модель

num_epochs = 10

for epoch in range(num_epochs):

running_loss = 0.0

for images, labels in trainloader:

optimizer.zero_grad()

output = model(images)

loss = criterion(output, labels)

loss.backward()

optimizer.step()

running_loss += loss.item()

print(f"Epoch {epoch + 1}, Loss: {running_loss / len(trainloader)}")

В этом примере мы сначала определяем модель нейронной сети SimpleClassifier с тремя полностью связанными слоями (также известными как плотные слои), используя класс PyTorch nn.Module. Входной слой состоит из 784 нейронов (соответствующих сплющенным изображениям 28×28), скрытые слои состоят из 128 и 64 нейронов, а выходной слой состоит из 10 нейронов, представляющих 10 классов цифр.

Затем мы загружаем набор данных MNIST и применяем преобразования с помощью метода transforms.Compose. Набор данных делится на обучающий и тестовый наборы, и создаются загрузчики данных для обработки пакетной обработки и перетасовки данных.

Далее мы создаем экземпляр модели SimpleClassifier, определяем функцию потерь как кросс-энтропийные потери и выбираем оптимизатор стохастического градиентного спуска (SGD) со скоростью обучения 0,01 и импульсом 0,9.

Наконец, мы обучаем модель в течение 10 эпох, выполняя итерации через загрузчик обучающих данных, рассчитывая потери, выполняя обратное распространение и обновляя параметры модели. Убыток для каждой эпохи выводится для отслеживания прогресса обучения.

Заключение

В этом руководстве мы рассмотрели преимущества использования Python для проектов машинного обучения и углубились в основы работы с такими популярными библиотеками, как scikit-learn, TensorFlow и PyTorch. Благодаря приведенным практическим примерам у вас теперь есть прочный фундамент, на который вы можете опираться, отправляясь в путешествие по машинному обучению на Python. Помните, что практика делает совершенным, поэтому экспериментируйте с различными алгоритмами и техниками, чтобы улучшить свои навыки.