Notes De Révision Du Cours D'apprentissage Automatique

1. Introduction

Concept de l’apprentissage automatique

Donner à une machine une compétence sans programmation déterministe

Performance Tâche Expérience, le programme a amélioré P sur T en utilisant E, c’est l’apprentissage

Classé par type de tâche : régression, classification, regroupement, réduction de dimension

Classé par méthode d’apprentissage : supervisé, non supervisé, apprentissage par renforcement

2. Évaluation et sélection des modèles

Chapitre clé Divers indicateurs d’évaluation, y compris l’écriture de code, l’appel de fonctions de bibliothèque

Exemples tels que la matrice de covariance, la précision, la matrice de confusion, la courbe ROC

Points de connaissance de base tels que le problème de surapprentissage et les solutions

Erreur empirique : erreur sur l’ensemble d’entraînement (erreur d’entraînement)

Erreur de généralisation : erreur sur les futurs échantillons

Plus l’erreur de généralisation est faible, mieux c’est, mais l’erreur empirique ne l’est pas nécessairement.

Méthodes d’évaluation

Méthode de répartition

X_train,X_test,y_train,y_test=train_test_split()

• Maintenir la distribution des données cohérente
• Divisions aléatoires multiples, répéter l’expérience pour obtenir une moyenne
• Proportion appropriée de l’ensemble de test

Validation croisée

Diviser d’abord l’ensemble de données en k sous-ensembles de taille égale et mutuellement exclusifs, en garantissant que la distribution des données de chaque sous-ensemble est cohérente, puis sélectionner k-1 sous-ensembles comme ensemble d’entraînement, le reste comme ensemble de test. Cela permet d’obtenir k ensembles d’entraînement/test, et de procéder à k entraînements et tests.

1
2
3
4
5
6
7

model = linear_model.Lasso()
cv_results = sklearn.model_selection.cross_validate(model,X,y,cv=3)
# Deuxième méthode
kf = KFold(3)
for train_idx,test_idx in kf.split(X):
	X_train,X_test = X[train_idx],X[test_idx]
	y_train,y_test = y[train_idx],y[test_idx]

En particulier, si $k=m$, la validation croisée devient la méthode Leave One Out :

• Non affectée par la méthode de division aléatoire des échantillons, car il n’y a qu’une seule méthode de division - chaque sous-ensemble contient un échantillon ;
• L’ensemble d’entraînement contient autant d’échantillons que possible, rendant le modèle évalué très similaire au modèle souhaité ;
• Coût d’entraînement élevé
• Les résultats estimés ne sont pas nécessairement plus précis que d’autres méthodes d’évaluation

Méthode bootstrap

Utiliser un échantillonnage avec remise pour construire un ensemble de données, il y aura $\frac{1}{e} = 0.368$ des données originales qui ne seront jamais échantillonnées, cette partie sera utilisée comme ensemble de test.

Mesures de performance

$$MSE = \frac{1}{m}\sum_{i=1}^{m}(f(x_i)-y_i)^2$$ $$MAE = \frac{1}{m}\sum_{i=1}^{m}\vert f(x_i)-y_{i}\vert$$

L’axe des abscisses de la courbe ROC est le taux de faux négatifs, l’axe des ordonnées est le taux de vrais positifs, et l’aire sous la courbe (AUC) est meilleure lorsqu’elle est plus grande.

Test de comparaison

Les performances sur l’ensemble de test ne peuvent pas refléter les performances réelles du modèle, il est nécessaire de procéder à un test d’hypothèse statistique pour déduire si c’est meilleur d’un point de vue statistique. Raisons :

• Les performances de test ne sont pas égales aux performances de généralisation
• Les performances de test varient avec l’ensemble de test
• L’algorithme d’apprentissage automatique lui-même a une certaine part de hasard Biais et variance Pour les tâches de régression, l’erreur de généralisation peut être décomposée en biais, variance et bruit. $$E(f;D)= bias^{2}(x)+var(x)+ \epsilon^2 $$

Au cours de l’entraînement, on passe généralement d’une domination par le biais à une domination par la variance.

 1
 2
 3
 4
 5
 6
 7
 8
 9
10
11
12
13
14
15
16
17
18
19

//Méthode de répartition
x_train,x_test,y_train,y_test=train_test_split(x,y,test_size=0.25)
//Validation croisée k-fold
kf=KFold(n_split=3)
//Validation croisée k-fold répétée p fois
rkf=RepeateKFold(n_split=3,n_repeats=2)
//Validation croisée k-fold stratifiée
skf=StratifiedKFold(n_split=4)
//Méthode Leave One Out
loo=LeaveOneOut()
//Mesures de performance
metrics.mean_squared_error(y_true,y_pred)
np.sqrt(metrics.mean_squared_error(y_true,y_pred))
metrics.mean_absolute_error(y_true,y_pred)
//Matrice de confusion
confusion_matrix(y_true,y_pred,labels=[0,1,2])
//Tracer le graphique P-R
precision, recall, thresholds = precision_recall_curve(y_true, y _pred)
plt.plot(recall, precision)

3. Modèles linéaires

Concept de gradient (covariance), calcul, résolution (manuel, code)

Méthode des moindres carrés : dériver la fonction de perte, poser la dérivée = 0, résoudre : $$w= \frac{\sum\limits_{i=1}^{m}y_{i}(x_{i}-\bar x)}{\sum\limits_{i=1}^{m}x_{i}^{2}-\frac{1}{m}(\sum\limits_{i=1}^{m}x_{i})^2}$$ $$b = \frac{1}{m}\sum\limits_{i=1}^{m}(y_{i}- wx_{i})$$ Régression logistique : utiliser un modèle linéaire pour les tâches de classification, fonction logistique (sigmoïde)

Analyse discriminante linéaire LDA : Étant donné un ensemble d’exemples d’entraînement, essayer de projeter les exemples sur une ligne droite de manière à ce que les points de la même classe soient aussi proches que possible et les points de classes différentes aussi éloignés que possible, en utilisant la covariance, l’objectif d’optimisation est de maximiser le quotient de Rayleigh.

Apprentissage multi-classe : un contre un ($\frac{n*(n-1)}{2}$) classificateurs, un contre le reste (n classificateurs), multi contre multi (ECOC)

1
2
3
4
5
6
7
8
9

def train(epoches = 1 ,l r = 0.01):
	for epoch in range(epoches):
		# Propagation avant
		output = inputs.mv(w) # Calculer la sortie y'=wx
		loss = (target - output).pow(2).sum()
		loss.backward()
		w.data -=  lr* w.grad
		w.grad.zero_()
sklearn.linear_model.LinearRegression()

Descente de gradient : $w^{t+1} = w^{t} - \eta \frac{\partial L}{\partial w}$ $$Conv(x,y) = \frac{\sum_{i=1}^{n} (x_{i}-\bar x)(y_{i} - \bar y)}{n-1}$$ $$Conv(x,y) = Conv(y,x)$$ $$Conv(x,x) = Var(x)$$

1
2
3
4

a = np.array([1,3,4,5])
b = np.array([2,6,2,2])
z = np.stack((a,b))
np.cov(z)

4. Réseaux neuronaux

Chapitre clé

Dérivation BP, calcul, calcul d’erreur, algorithme

Perceptron

Forme originale

Où $L(w,b)$ est la fonction de perte, qui est liée à la distance de tous les points mal classés au plan hyper. Le processus d’entraînement est le processus de convergence de la fonction de perte. L’algorithme du perceptron est convergent : lorsque les données sont linéairement séparables, le perceptron peut trouver un plan hyper de séparation qui sépare complètement les données d’entraînement après un nombre fini de recherches.

Forme duale

Réseaux neuronaux

Rétropropagation

Étapes de l’algorithme : initialisation - calcul avant de la sortie de l’échantillon - calcul du gradient de la couche de sortie $g$ - calcul du gradient de la couche cachée $e$ - mise à jour des poids de connexion et des seuils

Calcul avant : la valeur de biais doit être soustraite

Rétropropagation : gradient des nœuds de la couche de sortie :

$$ g = \hat y_{j}(1- \hat y_{j})(y_{j}- \hat y_j) $$ Où $\hat y_j$ est la valeur de sortie calculée, et $y_{j}$ est la valeur attendue (valeur réelle, étiquette)

Gradient des nœuds de la couche cachée :

$$e = b_n(1-b_n)\sum_{j=1}^{l}w_{hj}g_{j}$$

Surapprentissage

Stratégies de réponse : arrêt précoce et régularisation

Arrêt précoce

• Si l’erreur d’entraînement change peu pendant plusieurs tours consécutifs, arrêter l’entraînement
• Utiliser un ensemble de validation : si l’erreur d’entraînement diminue mais que l’erreur de validation augmente, arrêter l’entraînement

Régularisation

Ajouter un terme décrivant la complexité du réseau à la fonction objectif d’erreur, de sorte que le réseau préfère des poids de connexion et des seuils plus petits, rendant la sortie du réseau plus lisse.

Minima locaux

Recuit simulé, perturbation aléatoire, algorithme génétique, mécanisme de momentum….

Fonction d’activation

Le rôle est d’augmenter la capacité d’expression non linéaire du réseau. Exigences :

• Fonction non linéaire continue et dérivable
• La fonction et sa dérivée doivent être aussi simples que possible, facilitant le calcul
• Le domaine de valeurs de la dérivée doit être dans une plage appropriée, sinon cela affectera l’efficacité et la stabilité de l’entraînement $$sigmoid = \frac{1}{1+e^{-x}}$$

5. Théorie et méthodes d’optimisation

Prouver un ensemble convexe, une fonction convexe, méthode graphique, problème dual

Introduction

Ensemble convexe : dans un espace euclidien n-dimensionnel, si la ligne reliant deux points quelconques est toujours dans cet espace, alors c’est un ensemble convexe. Description formelle : $\lambda x_{1}+ (1-\lambda) x_{2} \in S$

Fonction convexe : Dans le domaine de définition, pour tout $x$, $f(\lambda x_{1}+ (1-\lambda ) x_{2}) <= \lambda f(x_{1}+ (1- \lambda)f(x_2))$ est une fonction convexe, une fonction convexe est concave, une fonction concave est convexe. Matrice de Hesse semi-définie positive, la fonction est convexe, définie positive pour une fonction strictement convexe.

Programmation convexe : résoudre le point minimum d’une fonction convexe sur un ensemble convexe. Le point minimum local de la programmation convexe est le point minimum global, et l’ensemble des points minimums est un ensemble convexe. La fonction objectif est une fonction strictement convexe + point minimum existant = point minimum unique.

Programmation linéaire

La forme standard de la programmation linéaire est : $$
\begin{align*} min \quad cx \ s.t. \quad Ax = b, \ x \geq 0, \end{align*} $$

1. Méthode graphique
2. Propriétés de base

• Le domaine faisable de la programmation linéaire est un ensemble convexe
• Si une solution optimale existe, elle est atteinte à un sommet

3. Solution faisable Dans la forme standard de la programmation linéaire, supposons que la matrice A a un rang de m, et supposons également $A=[B,N]$, où B est une matrice m x m inversible, alors $$ x= \begin{bmatrix} x_{B} \ x_{N} \end{bmatrix} = \begin{bmatrix} B^{-1}b \ 0 \end{bmatrix} $$ $$$$ est une solution de base. B est la matrice de base, ses composants sont des variables de base, si la solution de base ne contient pas de nombres négatifs, alors c’est une solution de base faisable. Les exemples peuvent aider à comprendre.

6. Machines à vecteurs de support

Chapitre clé Fonction de noyau, marge fonctionnelle, marge géométrique, vecteurs de support, trois formes et problème dual Appel de machines à vecteurs de support avec sklearn

Marge fonctionnelle : $\hat \gamma_i = y(wx_i+b)$ La marge fonctionnelle de l’hyperplan par rapport à l’ensemble d’entraînement est la plus petite valeur de la marge fonctionnelle de tous les points d’échantillon. Marge géométrique : $\gamma = \frac{\hat \gamma_{i}}{\vert \vert w \vert \vert}$

SVM linéairement séparable

SVM linéaire

SVM non linéaire - technique de noyau

Vecteurs de support

Caractéristiques des SVM

■ Avantages

• Bonne capacité de généralisation, en particulier sur de petits ensembles d’entraînement, peut obtenir des résultats bien meilleurs que d’autres algorithmes. Cela est dû au fait que son objectif d’optimisation est le risque structurel minimum, et non le risque empirique minimum, donc grâce à la marge, il peut obtenir une description structurée de la distribution des données, réduisant ainsi les exigences en matière de taille et de distribution des données.
• Fort soutien théorique mathématique, impliquant peu de mesures de probabilité et de lois des grands nombres.
• L’introduction de fonctions de noyau peut résoudre des problèmes de classification non linéaire. ■ Inconvénients
• Pas pratique pour résoudre des problèmes de classification multiple.
• Existence de paramètres hyper qui influencent fortement le résultat, par exemple lors de l’utilisation d’un noyau rbf, le terme de pénalité C et le paramètre de noyau gamma, ne peuvent être obtenus que par énumération ou estimation empirique.

1
2
3
4
5
6
7
8
9

import numpy as np
from sklearn.svm import SVC

x = np.array([[-1, -1], [-2, -1], [1, 1], [2, 1]])  # Variables indépendantes
y = np.array([1, 1, 2, 2])  # Variables dépendantes
model = SVC()  # Définir le modèle
model.fit(x, y)  # Entraîner le modèle avec les données
pred = model.predict([[-0.8, -1]])  # Prédire le résultat pour x=[-0.8,-1]
print(pred)  # Afficher y=[1]

7. Apprentissage en ensemble

Algorithme Adaboost

Entrée de l’ensemble d’entraînement $D= {(x_1,y_1),(x_2,y_2),…,(x_m,y_{m})} \quad y={-1,1}$, sortie du classificateur final $H(x)$, étapes spécifiques comme suit :

1. Fixer le nombre de classificateurs faibles à $T$, poser $t=1$, utiliser une distribution uniforme pour initialiser la distribution des poids des échantillons de l’ensemble d’entraînement, poser le vecteur de dimension $m$ $D_1$ pour représenter les poids des échantillons à mettre à jour pour la première fois, la valeur initiale de $D_1$ est $$D_{t} = (\frac{1}{m},\frac{1}{m},…,\frac{1}{m})^T $$
2. Utiliser l’ensemble d’échantillons d’entraînement $D$ avec la distribution de poids $D_t$ pour apprendre le $t$-ème classificateur faible $h_t$
3. Calculer le taux de classification erronée de $h_t$ sur l’ensemble d’échantillons d’entraînement $D$, si $\epsilon_t>0.5$, alors abandonner
4. Déterminer le poids de combinaison du classificateur faible $h_t$, plus le taux d’erreur de $h_t$ est faible, plus le poids $\alpha_t$ doit être élevé, il y a $$\alpha_t = \frac{1}{2}ln\frac{1-\epsilon_t}{\epsilon_{t}}$$
5. Mettre à jour les poids des échantillons en fonction du taux d’erreur de classification du classificateur faible $h_t$ : $$D_{t+1}= \frac{D_{t,i}exp(-\alpha_{t} y_{i}h_{t}(x_{i}))}{Z_{t}}$$
6. Si $t<T$, poser $t= t+1$, et retourner à l’étape 2, sinon exécuter l’étape 7
7. Combiner les $T$ classificateurs $h_1,h_2,…,h_T$ en fonction de chaque poids $\alpha_t$ pour obtenir le classificateur final $$H(x) = sign(\sum_{t=1}^{t}\alpha_{t}h_{t}(x))$$

Étapes de l’algorithme Bagging

Méthodes d’amélioration de la diversité

• Perturbation des échantillons de données Généralement basée sur des méthodes d’échantillonnage, comme Bagging utilise l’échantillonnage bootstrap, AdaBoost utilise l’échantillonnage séquentiel

• Perturbation des attributs d’entrée Sous-espace aléatoire : extraire plusieurs sous-ensembles d’attributs de l’ensemble d’attributs initial, puis entraîner un apprenant de base pour chaque sous-ensemble d’attributs

• Perturbation de la représentation de sortie Manipuler la représentation de sortie peut améliorer la diversité. Méthode de retournement : changer aléatoirement certaines étiquettes d’échantillons d’entraînement pour transformer la représentation de sortie Méthode de modulation de sortie : convertir la sortie de classification en sortie de régression, construire un apprenant de base pour résoudre une sous-tâche Méthode ECOC : utiliser un code de sortie correcteur d’erreurs pour décomposer une tâche de classification multiple en une série de classifications binaires pour entraîner des apprenants de base

• Perturbation des paramètres de l’algorithme Définir aléatoirement différents paramètres. Méthode de corrélation négative : forcer explicitement les réseaux neuronaux individuels à utiliser différents paramètres par un terme de régularisation.

Références

Référence note 1 orientée code

Examen réel de niveau 20

Un, 10 points

Question originale de l’examen des études supérieures de l’Académie chinoise des sciences, deux questions pour un total de 10 points

Deux, 10 points

1. Qu’est-ce que la méthode Leave One Out ?
2. Données suivantes, utiliser un modèle linéaire $y=wx+b$, calculer l’erreur quadratique moyenne (globale) avec la méthode Leave One Out.

   x	y
   0	2
   1	1
   2	2

(Il y a trois ensembles, mais les données spécifiques peuvent ne pas être celles-ci)

Trois, déterminer si les éléments suivants sont des fonctions convexes 10 points

(1) $ax_{1}^{2} + bx_{2}^{2} + cx_{1}x_{2} +dx_{1} +ex_2$ (2) $ax_{1}^{2} + bx_{2}^{2} + cx_{1}x_{2} +dx_{1} +ex_2$ (ils sont de cette forme, les chiffres spécifiques ne sont pas mémorisés)

Quatre, prouver un ensemble convexe 10 points

Étant donné $p \in C$, $C$ est un ensemble convexe sur $R^p$, maintenant $S = {x \vert x=A\rho ,\rho \in C}$ où $A$ est une matrice $n \times p$, prouver que $S$ est un ensemble convexe.

Cinq, méthode graphique pour trouver le minimum de la programmation linéaire. 10 points

Six, écrire la forme duale d’un problème de minimisation. 10 points

Sept, 15 points

1. Décrire l’algorithme AdaBoost
2. Décrire l’algorithme Bagging
3. Expliquer les méthodes d’amélioration de la diversité

Huit, 25 points Étant donné un réseau neuronal, entrée $d$-dimensionnelle $x = [x_{1},…,x_{d}]$, couche cachée unique avec $p$ nœuds cachés, couche de sortie avec $l$ nœuds, sortie $y = [\hat y_{1}^{k},…,\hat y_{l}^{k}]$

1. Écrire l’entrée de la couche cachée et l’entrée de la couche de sortie
2. Écrire la fonction de perte quadratique moyenne $E_{k}$
3. Étant donné un taux d’apprentissage $\eta$, calculer $\frac{\partial E_{k}}{w_{hj}}$ (montrer le processus de dérivation)
4. Donner le pseudo-code de la rétropropagation
5. Expliquer la descente de gradient et certaines variantes courantes, et comparer leurs différences