Problème de surajustement des modèles d'apprentissage automatique

Le problème du surajustement des modèles d'apprentissage automatique et sa solution

Dans le domaine de l'apprentissage automatique, le surajustement des modèles est un problème courant et difficile. Lorsqu'un modèle fonctionne bien sur l'ensemble d'entraînement mais fonctionne mal sur l'ensemble de test, cela indique que le modèle est surajusté. Cet article présentera les causes des problèmes de surajustement et leurs solutions, et fournira des exemples de code spécifiques.

1. Cause du problème de surajustement
   Le problème de surajustement est principalement dû au fait que le modèle est trop complexe et comporte trop de paramètres. Lorsque le modèle comporte trop de paramètres, il accordera trop d'attention au bruit et aux valeurs aberrantes dans l'ensemble d'apprentissage, ce qui entraînera de mauvaises performances sur les nouvelles données. De plus, l’insuffisance des données est également l’une des causes des problèmes de surapprentissage. Lorsqu'il y a moins d'échantillons dans l'ensemble d'apprentissage, le modèle a tendance à mémoriser les détails de chaque échantillon et ne peut pas généraliser à des données invisibles.
2. Méthodes pour résoudre le surajustement
   Afin de résoudre le problème du surajustement, nous pouvons utiliser les méthodes suivantes :

2.1 Augmentation des données
L'augmentation des données fait référence à l'exécution d'une série de transformations sur l'ensemble d'entraînement pour générer plus de nombreux des échantillons. Par exemple, dans les tâches de classification d'images, les images peuvent être pivotées, mises à l'échelle, retournées, etc. pour augmenter les données. Cela augmente la taille de l’ensemble de formation et aide le modèle à mieux se généraliser.

Ce qui suit est un exemple de code utilisant la bibliothèque Keras pour l'expansion des données d'image :

from keras.preprocessing.image import ImageDataGenerator

# 定义数据扩充器
datagen = ImageDataGenerator(
    rotation_range=20,  # 随机旋转角度范围
    width_shift_range=0.1,  # 水平平移范围
    height_shift_range=0.1,  # 垂直平移范围
    shear_range=0.2,  # 剪切变换范围
    zoom_range=0.2,  # 缩放范围
    horizontal_flip=True,  # 随机水平翻转
    fill_mode='nearest'  # 填充模式
)

# 加载图像数据集
train_data = datagen.flow_from_directory("train/", target_size=(224, 224), batch_size=32, class_mode='binary')
test_data = datagen.flow_from_directory("test/", target_size=(224, 224), batch_size=32, class_mode='binary')

# 训练模型
model.fit_generator(train_data, steps_per_epoch=len(train_data), epochs=10, validation_data=test_data, validation_steps=len(test_data))

2.2 Régularisation (régularisation)
La régularisation consiste à pénaliser la complexité du modèle en ajoutant un terme de régularisation à la fonction de perte du modèle, réduisant ainsi le risque de surajustement du modèle. Les méthodes de régularisation courantes incluent la régularisation L1 et la régularisation L2.

Ce qui suit est un exemple de code pour la régularisation L2 à l'aide de la bibliothèque PyTorch :

import torch
import torch.nn as nn

# 定义模型
class MyModel(nn.Module):
    def __init__(self):
        super(MyModel, self).__init__()
        self.fc1 = nn.Linear(10, 10)
        self.fc2 = nn.Linear(10, 1)
    
    def forward(self, x):
        x = self.fc1(x)
        x = nn.ReLU()(x)
        x = self.fc2(x)
        return x

model = MyModel()

# 定义损失函数
criterion = nn.MSELoss()

# 定义优化器
optimizer = torch.optim.SGD(model.parameters(), lr=0.01, weight_decay=0.001)  # 注意weight_decay参数即为正则化项的系数

# 训练模型
for epoch in range(100):
    optimizer.zero_grad()
    outputs = model(inputs)
    loss = criterion(outputs, labels)
    loss.backward()
    optimizer.step()

2.3 Dropout
Le dropout est une technique de régularisation couramment utilisée qui réduit le surajustement du modèle en supprimant aléatoirement certains neurones pendant le processus d'entraînement. Plus précisément, à chaque itération d’entraînement, nous sélectionnons au hasard certains neurones à éliminer avec une certaine probabilité p.

Voici un exemple de code pour Dropout utilisant la bibliothèque TensorFlow :

import tensorflow as tf

# 定义模型
model = tf.keras.models.Sequential([
    tf.keras.layers.Dense(10, activation=tf.nn.relu, input_shape=(10,)),
    tf.keras.layers.Dropout(0.5),  # dropout率为0.5
    tf.keras.layers.Dense(1)
])

# 编译模型
model.compile(optimizer='adam', loss=tf.keras.losses.BinaryCrossentropy(from_logits=True))

# 训练模型
model.fit(x_train, y_train, epochs=10, validation_data=(x_test, y_test))

3. Résumé
   Le surajustement est un problème courant dans les modèles d'apprentissage automatique, mais nous pouvons utiliser certaines méthodes pour le résoudre. L'augmentation des données, la régularisation et l'abandon sont toutes des méthodes couramment utilisées pour résoudre le problème du surapprentissage. Nous pouvons choisir des méthodes appropriées pour traiter les problèmes de surajustement en fonction de scénarios d'application spécifiques, et optimiser davantage les performances du modèle en ajustant les paramètres et d'autres méthodes.

Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!