Introduction à l'apprentissage automatique à partir de Simple Perceptron

1. Qu'est-ce que Simple Perceptron?

Les données d'entrée sont classées en deux classes à l'aide de la fonction discriminante linéaire ci-dessous.

f(x)=g(w^{T}x+\theta)\\
ici,\theta = x_Si vous le définissez sur 0\\
    =g(\sum _{i=0}^{d}w_ix_i)

Fonction d'activation non linéaire: g(a) = \left\{
\begin{array}{ll}
+1 & (a \geq 0) \\
-1 & (a \lt 0)
\end{array}
\right.

Poids: w=(w_0,w_1,...,w_{d})、　\\
Données d'entrée: x=(x_0=\theta,x_1,x_2,...,x_{d})、
\\d: nombre de dimensions,

biais:\theta(Nombre arbitraire)

f(x) \Lorsque geq 0, x\in C_{1}

f(x) \Lorsque lt 0, x\in C_{2}

C_1:Classe 1, C_2:Classe 2

Parmi ce qui précède, le processus de détermination du paramètre de weight_w_ est appelé "apprentissage". Bias_θ_ (paramètre de biais) peut être utilisé par défaut, mais il est manuellement ajusté (réglé) pour de meilleurs résultats. Ceux qui sont ajustés manuellement comme ce biais sont généralement appelés paramètres (hyper paramètres ou paramètres de réglage), et l'ajustement des paramètres est parfois appelé réglage des paramètres.

~ Exemple de paramètre ~ "Si vous réglez les paramètres avec un simple perceptron, vous obtiendrez des résultats."

En outre, il existe diverses méthodes de réglage, telles qu'une méthode dans laquelle une personne essaie simplement manuellement, une recherche de grille et un échantillonnage aléatoire.

1.1. À quoi peut-il servir?

Il peut être utilisé pour des problèmes linéairement séparables dans des problèmes à deux classes. En gros, un problème linéairement séparable est un problème dans lequel un ensemble de classe 1 et un ensemble de classe 2 peuvent être séparés par une seule ligne droite dans le cas de deux dimensions. En généralisant cela, la capacité de séparer un ensemble de classe 1 et un ensemble de classe 2 dans l'espace _n_dimensionnel sur un superplan dimensionnel n-1 est également appelée séparation linéaire. Un exemple de cas où la séparation linéaire est possible et un cas où la séparation linéaire n'est pas possible est illustré ci-dessous.

Un exemple courant d'application spécifique d'un algorithme d'apprentissage supervisé tel que Perceptron est la détermination des spams. En gros, les spams sont jugés selon la procédure suivante.

1. Supposons deux classes, le courrier indésirable et le courrier ordinaire.
2. Ensuite, créez un vecteur de fonction (ou quantité de fonction ou identité) et une étiquette d'enseignant (spam ou étiquette normale) à partir des deux e-mails.

• En passant, dans le domaine du traitement du langage naturel, le terme «authentique» est souvent utilisé.

3. Entrez le vecteur de caractéristiques et l'étiquette de l'enseignant dans l'apprenant (cette fois le perceptron simple) et effectuez l'apprentissage.
4. Faire un jugement en utilisant le modèle mathématique complet (cette fois, le modèle de fonction discriminante linéaire).

Le vecteur de caractéristiques doit être quantifié à partir de données qualitatives, laissant bien les caractéristiques des données. Cela peut modifier considérablement la précision et constitue une tâche très importante. Un exemple spécifique de la méthode de création de vecteurs de caractéristiques est donné ci-dessous.

[Exemple: méthode de création de vecteurs d'entités] Je veux déterminer s'il s'agit de spam par le sujet, même s'il existe les données suivantes.

・ Objet du courrier indésirable: mon petit ami est mort au combat avec Oarikui ・ Objet régulier de l'e-mail: demande de modification de l'heure de la réunion

Une technique souvent utilisée dans le domaine du traitement du langage naturel est une technique appelée analyse morphologique. MeCab et Cabocha sont des outils bien connus pour l'analyse morphologique. Par analyse morphologique, la phrase d'entrée peut être divisée en éléments morphologiques (la plus petite unité qui a un sens dans la langue). En conséquence, la phrase suivante est complétée. (Puisqu'il s'agit d'une analyse morphologique par une personne qui n'est pas bonne en japonais, la précision n'est pas garantie)

・ Objet du courrier indésirable: Petit ami / est / se bat / est mort / mort / ・ Objet régulier de l'e-mail: Réunion / Heure / Changement / De / Demande /

Ensuite, un dictionnaire morphologique est créé en utilisant les données ci-dessus. En conséquence, le dictionnaire ressemble à ceci:

dictionnaire\in\{copain,Mais,Oarikui,Quand,bats toi,Morte,J'ai fini,réunion,temps,Changement,de,demande\}

• Ce qui précède n'est pas une méthode générale dans le domaine du traitement du langage naturel car il est créé en utilisant les données d'un dictionnaire créé par quelqu'un ou en le saisissant manuellement. Lors de la création de ce dictionnaire, nous améliorerons la précision en convertissant tous les éléments morphologiques en formes de base et en les mettant dans le dictionnaire.

Enfin, à l'aide du dictionnaire créé précédemment, un vecteur de caractéristiques est créé comme suit.

Vecteur de fonctionnalité de courrier indésirable x_1=\{1,1,1,1,1,1,1,0,0,0,0,0\},Étiquette de l'enseignant t=\{-1\}

Vecteur de fonction de courrier normal x_2=\{0,0,0,0,0,0,0,1,1,1,1,1 \},Étiquette de l'enseignant t=\{+1\}

Quant à la création du vecteur de caractéristiques, la présence / absence (1: oui, 0: non) de l'apparence du mot inclus dans le dictionnaire est stockée dans le tableau. Cette méthode est appelée la méthode Bag-Of-Words. Dans certains cas, il est créé en fonction du nombre de fois où un mot apparaît, et non du fait qu'un mot apparaît ou non. De plus, comme extension de cela, il existe également une méthode de pondération appelée Tf-idf. Ceci est utilisé pour réduire l'importance des mots qui apparaissent dans de nombreux documents et augmenter l'importance des mots qui n'apparaissent que dans des documents spécifiques. En gros, le label enseignant est décidé, mais en général, 0 et 1 sont appliqués lorsqu'ils sont utilisés dans un modèle probabiliste, et -1 et 1 qui sont compatibles avec des fonctions d'activation telles que Perceptron sont souvent appliqués.

Ce qui précède est la procédure de création d'un vecteur d'entités.

De plus, les raisons pour lesquelles il peut être utilisé dans un problème linéairement séparable peuvent être expliquées par le "théorème de convergence de Perceptron". Voir ci-dessous pour la preuve. http://ocw.nagoya-u.jp/files/253/haifu%2804-4%29.pdf

2. Apprentissage de Perceptron (algorithme probabiliste de descente la plus raide)

Le concept de la méthode d'apprentissage est simple: si vous faites une erreur, mettez à jour la valeur de w à l'aide de la formule décrite ci-dessous et continuez la mise à jour jusqu'à ce qu'il n'y ait plus d'erreur. La série de données d'entraînement est définie comme suit.

X=\{X_1,X_2,...,X_M\} \\
M:Le nombre de données

Ici, un ensemble de données d'apprentissage mal classées est exprimé comme suit.

X_n=\{x_1,x_2,...,x_n\}

Je veux trouver le poids w tel que _f (x) _> 0 pour les données de classe 1 et _f (x) _ <0 pour les données de classe 2. Dans ce cas, en utilisant le libellé enseignant t = {+ 1, -1}, toutes les données satisfont à ce qui suit.

w^Tx_it_i>0

La fonction d'erreur suivante E (・) qui attribue une erreur de 0 à des données correctement classées peut être prise en compte.

E(w) =-\sum_{n \in X} w^Tx_nt_n

Si vous définissez la valeur de w de manière à minimiser cela (devenez 0), il peut être bien classé. Comme méthode pour minimiser cela, une méthode de descente de gradient stochastique est utilisée. Dans la méthode de descente de gradient probabiliste, lorsque la fonction d'erreur consiste en la somme de points de données comme _E (w) _ cette fois, lorsque les données n sont données, w est mis à jour par le calcul suivant.

w^{(r+1)}=w^{(r)}-\mu \nabla E_n \\
r: nombre de répétitions,\mu: paramètre de taux d'apprentissage\\
w^{(r)}:Poids w après mise à jour r fois

À partir de ce qui précède, la formule de mise à jour peut être dérivée comme suit.

w^{(r+1)}=w^{(r)}-\mu \nabla E(w) \\
=w^{(r)}+\mu x_nt_n 

Dans la zone où les données sont mal classées en fonction de la valeur de w, que la valeur de t soit +1 ou -1, l'erreur de données mal classées _E (w) _ La contribution est une fonction linéaire. De plus, selon la valeur de w, la contribution des données à l'erreur _E (w) _ est égale à 0 dans la zone où les données sont correctement classées. Par conséquent, _E (w) _ est une fonction linéaire compartimentée. Par conséquent, le gradient de _E (w) _ est calculé comme suit.

E(w) = \frac{\partial E(w)}{\partial w} \\
=x_nt_n 

3. Implémentation Python

Le code ci-dessous est un code qui doit être résolu par Perceptron pour une opération AND qui n'est ni conçue ni bâclée. L'état de l'apprentissage est maintenant tracé. Cela peut sembler être une classe ou une méthode, mais comprenez bien. Je le réécrirai quand j'en aurai envie. Pour exécuter, vous devez installer les bibliothèques numpy et matplotlib.

# coding:utf-8
import numpy as np
import matplotlib.pyplot as plt
import matplotlib.animation as animation

#Fonction d'inactivation g(x)méthode de
def predict(w,x):
  out = np.dot(w,x)
  if out >= 0:
    o = 1.0
  else:
    o = -1.0
  return o

#Méthode pour tracer
def plot(wvec,x1,x2):
  x_fig=np.arange(-2,5,0.1)
  fig = plt.figure(figsize=(8, 8),dpi=100)
  ims = []
  plt.xlim(-1,2.5)
  plt.ylim(-1,2.5)
  #Terrain
  for w in wvec:
    y_fig = [-(w[0] / w[1]) * xi - (w[2] / w[1]) for xi in x_fig]
    plt.scatter(x1[:,0],x1[:,1],marker='o',color='g',s=100)
    plt.scatter(x2[:,0],x2[:,1],marker='s',color='b',s=100)
    ims.append(plt.plot(x_fig,y_fig,"r"))
  for i in range(10):
    ims.append(plt.plot(x_fig,y_fig,"r"))
  ani = animation.ArtistAnimation(fig, ims, interval=1000)
  plt.show()

if __name__=='__main__':
  wvec=[np.array([1.0,0.5,0.8])]#Valeur initiale du vecteur de poids, appropriée
  mu = 0.3 #Coefficient d'apprentissage
  sita = 1 #Composant de biais

  #ET données de fonction(La rangée arrière est la composante de biais:1)
  x1=np.array([[0,0],[0,1],[1,0]]) #Classe 1(Le résultat du calcul est 0)Génération de matrice
  x2=np.array([[1,1]]) #Classe 2(Le résultat du calcul est 1)Génération de matrice
  bias = np.array([sita for i in range(len(x1))])
  x1 = np.c_[x1,bias] #Concaténer le biais à la fin des données de classe 1
  bias = np.array([sita for i in range(len(x2))])
  x2 = np.c_[x2,bias] #Concaténer le biais à la fin des données de classe 2
  class_x = np.r_[x1,x2] #Concaténation de matrice

  t = [-1,-1,-1,1] #ET étiquette de fonction
  # o:Demander une sortie
  o=[]
  while t != o:
    o = [] #Initialisation
    #Phase d'apprentissage
    for i in range(class_x.shape[0]):
      out = predict(wvec[-1], class_x[i,:])
      o.append(out)
      if t[i]*out<0: #Lorsque la sortie et l'étiquette de l'enseignant sont différentes
        wvectmp = mu*class_x[i,:]*t[i] #Montant à changer w
        wvec.append(wvec[-1] + wvectmp) #Mise à jour du poids
  plot(wvec,x1,x2)

4. Algorithme typique qui étend Simple Perceptron

・ SVM ・ Perceptron multicouche

5. Références

Reconnaissance de formes et apprentissage automatique

Première reconnaissance de formes

http://home.hiroshima-u.ac.jp/tkurita/lecture/prnn/node20.html

https://speakerdeck.com/kirikisinya/xin-zhe-renaiprmlmian-qiang-hui-at-ban-zang-men-number-2

http://tjo.hatenablog.com/entry/2013/05/01/190247

http://nlp.dse.ibaraki.ac.jp/~shinnou/zemi1ppt/iwasaki.pdf

http://ocw.nagoya-u.jp/files/253/haifu%2804-4%29.pdf