Réseau neuronal paramétrique

À propos du réseau neuronal

Écoulement brutal en premier lieu

1. Passez la valeur de la fonction d'activation au nœud suivant en fonction des informations d'entrée
2. Joignez linéairement toutes les informations reçues en fonction du poids $ w $ et du biais $ b $.
3. Entrez la valeur couplée linéairement dans la fonction d'activation et passez-la au nœud suivant
4. Répétez les étapes 2 et 3 pour sortir la valeur du nœud final
5. Calculez la fonction de perte à partir de la sortie finale (bien que PNN n'ait qu'un seul nœud dans la dernière couche): les étapes 1 à 6 sont la propagation vers l'avant
6. Ensuite, utilisez la fonction de perte pour calculer le poids à chaque branche: propagation arrière
7. Les étapes 1 à 7 complètent une session de formation. Après cela, répétez ceci un nombre spécifié de fois pour créer un ensemble de poids = réseau de neurones qui décrit mieux la bonne réponse.

A l'étape 6, une méthode de descente de gradient (une méthode de mise à jour des poids utilisant le coefficient différentiel de la fonction de perte) est généralement adoptée. Par conséquent, la fonction de perte doit avoir une distribution divisible. Dans ce qui suit, la fonction d'activation, la fonction de perte et la méthode de descente de gradient sont brièvement décrites.

À propos de la fonction d'activation

Les valeurs d'entrée calculées dans la couche précédente sont d'abord combinées linéairement en fonction de chaque poids et biais. Ensuite, en les utilisant comme arguments de la fonction d'activation, transmettez la valeur de sortie de la fonction d'activation à la couche suivante ... et ainsi de suite, c'est l'apprentissage automatique. Donc, la signification importante de la fonction d'activation n'est pas la forme de la formule ("Pourquoi exponentiel, pourquoi xxx fractionnaire ..." est un argument dénué de sens), mais quelle valeur et quelle plage Il est important de produire à travers. Les deux types de fonctions d'activation utilisées cette fois sont résumés.

relu (fonction de rampe)

Lorsque x est égal ou supérieur à 0, il a une forme proportionnelle directe. Puisque la fonction sigmoïde et le gradient disparaissent au fur et à mesure que la distance à l'origine augmente (le coefficient différentiel s'approche de 0), il existe un problème selon lequel l'apprentissage stagne une fois que l'unité a une valeur élevée. On sait que la fonction de rampe résout empiriquement le problème de la disparition du gradient.

f(x) = x~~(x>0)

sigmoïde (fonction sigmoïde)

La valeur de sortie de la fonction est comprise entre 0 et 1.

f(x) = \frac{1}{1-e^x}

Fonction de perte (= fonction d'erreur)

Évaluez la sortie de dimension $ n $ d'un réseau de neurones à l'aide d'une fonction de perte. Conceptuellement, plus la différence est petite, plus la valeur de la fonction de perte est petite par rapport à la valeur de dimension $ n $ correcte. Par conséquent, un bon réseau neuronal a une petite valeur de sortie de la fonction de perte.

• binary_crossentropy -Utilisé pour la classification de 2 classes (souvent utilisé pour une énergie élevée telle que 0 ou 1, événement de fond ou événement de signal)

E(w) = -\sum_n^{N} \left( d_n\log y_n + (1-d_n)\log(1-y_n) \right)

Méthode de gradient

La mise à jour du poids à l'aide de la fonction de perte est l'élément clé du réseau neuronal. Ici, un ODD général sera décrit. SDG utilise le coefficient différentiel de la fonction de perte pour calculer le poids à utiliser pour la prochaine formation. Pour les paramètres utilisés à ce moment

• $ \ eta $: coefficient d'apprentissage, taux d'apprentissage, taux d'apprentissage
• $ \ Alpha $: Momentum
• $ h $: taux de décroissance d'apprentissage

w^{t+1} = w^{t} - \eta\frac{1}{\sqrt{h}}\frac{\partial E(w^{t})}{\partial w^{t}} + \alpha\Delta w

Calculez selon la formule ci-dessus. Ici, comme une vue d'ensemble des connaissances sur la méthode du gradient

• Si le coefficient d'apprentissage est trop grand, les valeurs de poids différeront considérablement entre $ t $ et $ t + 1 $, ce qui rendra difficile la convergence de la formation.
• Si le coefficient d'apprentissage est trop petit, le degré de mise à jour du poids sera faible et il faudra du temps pour apprendre. --En introduisant le taux d'atténuation, le coefficient d'apprentissage est également mis à jour en fonction de la formation.

Peut être mentionné.

Méthode d'apprentissage

Généralement, la méthode d'apprentissage du réseau neuronal est expliquée en gardant à l'esprit le "mini-apprentissage par lots". Ici, il est expliqué à quel moment la fonction de perte est utilisée pour mettre à jour le paramètre (= mettre à jour le poids = mettre à jour le modèle).

--Apprentissage en ligne

• Une méthode pour mettre à jour le modèle à chaque fois en fonction de la fonction de perte calculée à partir des informations d'entrée.
• Par exemple, si vous avez 1000 images, vous ferez l'expérience de 1000 mises à jour de paramètres.
• Apprentissage par lots
• Une méthode pour mettre à jour le modèle en unités de lots (= toutes les données à la fois).
• Par exemple, si vous avez 1000 images, vous ferez l'expérience d'une mise à jour de paramètre. La fonction de perte utilisée à ce moment est la moyenne des fonctions de perte pour chacune des 1000 images.

L=\frac{1}{N}\sum_{i=1}^{N} l_i

--Mini apprentissage par lots

• Une méthode de division de toutes les données en mini-lots et de mise à jour du modèle pour chaque processus de mini-lots
• Pour chaque traitement du nombre de données incluses dans le mini-lot (= taille du lot), la fonction de perte est moyennée et calculée, et le modèle est mis à jour. Ensuite, selon le modèle mis à jour, la formation dans le mini-lot suivant est lancée. --Par exemple, disons que vous avez 1000 images et que vous souhaitez les diviser en 100 tailles de lots. Pour le moment, il existe 10 sous-ensembles, nous allons donc expérimenter 10 mises à jour de paramètres.

Comme mentionné ci-dessus, la méthode d'apprentissage par mini-lots est généralement largement utilisée. Au stade où 10 sous-ensembles sont traités dans l'exemple précédent, 1 époque est comptée.

PNN Le BDT est souvent utilisé à haute énergie. Il est fort dans les petites statistiques, et comme il s'agit essentiellement d'un DT, il y a de nombreux avantages tels que d'éviter autant que possible de devenir une boîte noire. Puisque le DNN a déjà été utilisé pour l'identification des particules, nous avons décidé d'utiliser un réseau neuronal pour améliorer le rapport S / N sous la forme «d'utilisation et perte» comme dans ProfileLL. Le modèle proposé en 2016 est le PNN (Parametrised Neural Network), qui est construit à l'aide d'une bibliothèque python générale. La bibliothèque utilisée cette fois est

• uproot
• Le format ROOT utilisé dans la zone à haute énergie est changé en trame de données avec python. --sklearn (scikit-learn)
• bibliothèque d'apprentissage automatique en python
• keras --Une bibliothèque de réseaux de neurones fonctionnant sur TensorFlow

Lire le fichier ROOT (traitement pré-étape à haute énergie)

uproot Bibliothèque CERN Un module Python pour lire les données au format ROOT. Le simple changement de ROOT Ntuple en python DataFrame ne change pas la structure. Les lignes correspondent aux événements et les colonnes correspondent à chaque variable.

import uproot
f = uproot.open("data.root")
print(f.keys())
# ['data;1', 'background;1", ....]

f['data'].pandas.df()
#        Btag  EventFlavour  EventNumber  FourBodyMass  Jet0CorrTLV  ...  mass  mass_scaled           sT      sTNoMet  signal    weight  weight_scaled
#entry                                                               ...                                                                              
#9        2.0           8.0     560044.0   1666.098145   542.301636  ...  900     0.352941  #1566.298340  1404.298218       1  0.003898       0.028524
#10       1.0           5.0     560480.0   1606.993896   241.007111  ...  900     0.352941  #1841.925049  1434.105713       1  0.004255       0.031135
#11       2.0           0.0     561592.0   1857.901245   721.780457  ...  900     0.352941  #2444.058105  1910.263306       1  0.002577       0.018855
#15       2.0           5.0     561088.0   1348.327515   174.501556  ...  900     0.352941  #1328.051147  1029.908447       1  0.003360       0.024585

f['data'].pandas.df('EventNumber')
#        EventNumber
#entry              
#0      2.148751e+08
#1      2.143515e+08
#2      6.018242e+07
#3      2.868989e+07
...

Ce qui précède est la trame de données immédiatement après la lecture et crée une trame de données qui ne récupère que les valeurs d'informations nécessaires (informations d'entrée à utiliser) à partir d'ici. La méthode de découpage de la trame de données utilisée dans l'étape suivante sera brièvement décrite. La trame de données d'origine lue par déracinement a mass_scaled à la fin, alors coupez-la avec X [:,: -1]. Il s'agit d'une méthode de découpage qui signifie "toutes les lignes, les colonnes sont du début à la dernière". Sur la base de ce qui précède, nous passerons au cœur du suivant.

• from sklearn.utils import shuffle
• Lors du fractionnement des données de test / formation, comment les trier au hasard, puis les diviser --Si vous ne faites rien, les données seront divisées dans l'ordre depuis le début.

Processus de formation réel

Pré-traitement (conversion d'échelle)

Il est nécessaire d'aligner l'échelle (= nombre de chiffres) des données à traiter. La méthode utilisée ici est sclearn, et cette fois nous utilisons "RobustSclaer", qui résiste aux valeurs aberrantes. S'il existe une valeur aberrante en premier lieu, la moyenne / dispersion de la quantité de caractéristique est grandement affectée par la valeur aberrante, de sorte que la normalisation ne fonctionne pas bien. Pensons-y comme à la réimpression d'informations faciles à gérer par la machine, tout en conservant la nature des données.

• StandardScaler --Standardiser la distribution des données
• RobustScaler ――Le processus utilisé cette fois est le suivant --Avec fit_transform, fit (calculer la moyenne et la variance du tableau X) et transform (), et stocker le tableau (X)

Modèle NN créé

--keras.layers: définit les propriétés des calques - Input - Dense --Couche de réseau neuronal entièrement couplée. Tous les perceptrons (nœuds) sont connectés à la couche suivante de perceptrons

• Le calque NN généralement dessiné dans les images perforées
• keras.model --Keras a deux façons de définir des modèles (sur Python)
• Modèle séquentiel et modèle d'API fonctionnel

Codage réel

1. Tout d'abord, définissez le nombre de dimensions des informations d'entrée avec Input
2. Définissez Dense (réseau neuronal entièrement connecté) pour chaque couche. La fonction d'activation utilisée à ce moment est définie.
3. Puisque la couche cachée est sortie vers la couche suivante telle quelle, il s'agit d'une sortie à 32 dimensions (cette fois, le réseau neuronal est défini par la couche à 3 dimensions à 32 dimensions de [32,32,32]). Et la dernière couche est un nœud et génère [0,1].
4. La fonction d'activation de la couche cachée est "relu" et la fonction d'activation de la dernière couche est "sigmoïde".

x = Input(shape=(n_input_vars,))
d = x 
for n in self.layer_size:
    d = Dense(n, activation=self.activation)(d)

y = Dense(1, activation="sigmoid")(d)
Model(x, y)

Méthode de gradient utilisée

La méthode du gradient utilisée cette fois est une SGD très orthodoxe (Stochastic Gradient Descent: stochastic gradient descente method). Chaque poids est mis à jour à l'aide de la fonction de perte $ E (w) $ dans la formule suivante.

w^{t+1} ← w^{t} - \eta \frac{\partial E(w^{t})}{\partial w^{t}} + \alpha \Delta w^{t}

Ici, $ \ eta $ représente le taux d'apprentissage (coefficient d'apprentissage), et $ \ alpha $ représente l'élan.

sgd = SGD(lr=self.learning_rate, momentum=self.momentum, nesterov=self.nesterov, decay=self.learning_rate_decay)

Formation avec Keras

compile En utilisant les connaissances décrites jusqu'à présent (avec plus de connaissances de base), les étapes suivantes sont prises pour former un réseau de neurones dans les keras. Tout d'abord, vous devez "compiler" le modèle

model.compile(...)

fit Ensuite, après la compilation, fit = faire l'entraînement réel.

• batch_size
• Le nombre de données contenues dans chaque sous-ensemble est appelé la taille du lot. --ex) La division des données de 10000 événements par taille de lot 10 crée un sous-ensemble de 1000.
• verbose --0: pas de sortie ―― 1: avec barre de progression ―― 2: pas de barre de progression
• callbacks
• Passez la liste des fonctions que vous souhaitez appeler à la fin de l'époque. ex. Votre propre fonction qui imprime certaines informations pour chaque époque, etc.

Au fait

PNN se caractérise par la prise de paramètres théoriques comme informations d'entrée séparément des informations d'entrée mécaniques utilisées. Il existe des paramètres théoriques corrects dans la simulation des événements de signal, mais qu'en est-il des paramètres théoriques des événements de fond? Par exemple, si le paramètre mass est utilisé comme information d'entrée, une valeur aléatoire est sélectionnée et entraînée lors de l'apprentissage d'un événement d'arrière-plan.

URL de référence

J'ai beaucoup fait référence aux sites suivants. Merci beaucoup.

• https://aizine.ai/preprocessing0614/
• https://qiita.com/tokkuman/items/1944c00415d129ca0ee9
• https://note.nkmk.me/python-tensorflow-keras-basics/
• https://products.sint.co.jp/aisia/blog/vol1-4
• https://qiita.com/kenta1984/items/bad75a37d552510e4682