. 1 # _ * _ codage:. _ * _ 8 UTF - 2 # en utilisant l'iris ensemble de données, la propagation, la lutte contre la propagation avant atteint, la courbe de perte visuelle . 3 . 4 # module d' importation désiré 5. Importation tensorflow AS TF 6. De sklearn importation Datasets . 7 de matplotlib import pyplot aS PLT . 8 import numpy aS NP . 9 10 # données d'importation, respectivement, et la variable de caractéristique d'entrée . 11 x_data = datasets.load_iris (). les données 12 est y_data = datasets.load_iris (). cible 13 est 14 # aléatoire perturbé Données (car les données d'origine sont séquentielles, la commande n'affectera pas le taux de précision) 15 # graine: la graine du nombre aléatoire est un entier. Après le réglage, le nombre aléatoire généré à chaque fois est le même. 16 np.random.seed (1 16) # utiliser le même germe, et de veiller à ce que la caractéristique d'entrée étiquette de correspondance. . 17 np.random.shuffle (x_data) 18 est np.random.seed (1 16 ) . 19 np.random.shuffle (y_data) 20 est tf.random.set_seed (1 16 ) 21 est 22 est # après l'interruption de jeu de données est divisé en un ensemble d'apprentissage Et l'ensemble de test, l'ensemble de formation est les 120 premières lignes, l'ensemble de test est les 30 dernières lignes 23 x_train = x_data [: -30 ] 24 y_train = y_data [: -30 ] 25 x_test = x_data [-30 :] 26 y_test = y_data [- 30 :] 27 28 29 #Convertissez le type de données de x, sinon une erreur sera signalée en raison de types de données incohérents lorsque la matrice sera multipliée plus tard 30 x_train = tf.cast (x_train, tf.float32) 31 x_test = tf.cast (x_test, tf.float32) 32 33 # from_tensor_slices function Les entités en entrée correspondent aux valeurs d'étiquette un à un. (L'ensemble de données est divisé en lots et chaque lot de données de lot) 34 train_db = tf.data.Dataset.from_tensor_slices ((x_train, y_train)). Lot (32 ) 35 test_db = tf.data.Dataset.from_tensor_slices ((( x_test, android.permission.FACTOR)) LOT (32. ) 36 37 [ # généré des paramètres du réseau de neurones, quatre caractéristiques d'entrée, de sorte que la couche d' entrée de quatre noeuds d'entrée; de 3 classification, de sorte que la couche de sortie de trois neurones 38 # avec tf. paramètre marqué formation variable () 39 # utilisent le même germe de nombre aléatoire de telle sorte que chaque génération. 40w1 = tf.Variable (tf.random.truncated_normal ([4, 3], stddev = 0,1, seed = 1 )) 41 b1 = tf.Variable (tf.random.truncated_normal ([3], stddev = 0,1, seed = . 1 )) 42 est 43 est LR = 0,1 # taux d' apprentissage de 0,1 44 est train_loss_results = [] # la perte enregistrée à chaque tour dans cette liste, pour fournir des données pour la courbe ultérieures de perte Vidéos 45 test_acc = [] # l'acc enregistré dans chaque cycle cette liste, pour fournir des données pour la suite Vidéos acc courbe 46 est Epoch 500 = # cycles 500 47 loss_all = 0 # tour divisé en quatre étapes, loss_all étape de génération d' enregistrement de quatre et quatre perte 48 49 # partie d'entraînement 50 pour l' époque dans la plage (époque):# Niveau du jeu de données de cycles, chaque donnée d'époque temps de cycle fixés 51 est pour l' étape (x_train, y_train) dans l'énumération (train_db): # cycles de niveau de BATCH, chaque cycle une étape BATCH 52 est avec tf.GradientTape () ruban : # avec une structure de gradient de l'information d'enregistrement 53 est y = tf.matmul (x_train, W1) + B1 # d'opération de somme de réseau de neurones 54 est y = tf.nn.softmax (y) # sortie y rencontrent la distribution de probabilité (et seulement après cette opération Code chaud du même ordre, perte relative à la recherche Enregistrer) 55 Y_ = tf.one_hot (y_train, profondeur =. 3) # valeur d'étiquette dans un format de code à chaud pour faciliter le calcul et la perte de précision 56 est la perte = tf.reduce_mean (TF. carré (Y_ - Y)) # en utilisant l'erreur quadratique moyenne = fonction de perte MSE Mean (SUM (Y-OUT) ^ 2) 57 est + = Loss.numpy loss_all () # chaque étape de la perte cumulée calculée, cherchent à fournir des données pour la perte moyenne ultérieure, la perte ainsi calculée avec plus de précision 58 # calcule les paramètres de son gradient de perte de 59 GrADS = tape.gradient (Perte, [w1, B1]) 60 61 est # mis en oeuvre gradient mise à jour w1 = w1 - LR * w1_grad, B = B - LR * b_grad 62 est w1.assign_sub (LR * GrADS [0]) # paramètres w1 auto-rafraîchissement 63 est B1. assign_sub (LR * GrADS [. 1]) # mise à jour des paramètres de b 64 65 # de chaque époque, les informations d'impression perte 66 impression ( " Epoch: {}, perte: {} " . .format (époque, loss_all / 4 )) 67 train_loss_results.append (loss_all /. 4) # L'étape de calcul de la moyenne de quatre perte de l' enregistrement de cette variable 68 loss_all = 0 # loss_all zéro, prêt pour la prochaine période d'un enregistrement de perte 69 70 # section d'essai 71 est # total_correct de la prédiction du nombre d'échantillons, le nombre total d'échantillons testés TOTAL_NUMBER, les deux variables sont initialisées à 0 72 total_correct, TOTAL_NUMBER = 0, 0 73 est pour x_test, android.permission.FACTOR. en TEST_DB: 74 # en utilisant les paramètres de prédiction mis à jour 75 y = tf.matmul (x_test, w1) + b1 76 y = tf.nn.softmax (y) 77 pred = tf.argmax (y, axe = 1) #Renvoie l'index de la valeur maximale en y, c'est-à-dire la classification prédite 78 # Convertit pred en type de données y_test 79 pred = tf.cast (pred, dtype = y_test.dtype) 80 # Si la classification est correcte, correcte = 1, sinon est 0, le résultat est converti en valeur de type bool int 81 correcte = tf.cast (tf.equal (Pred, android.permission.FACTOR.), DTYPE = tf.int32) 82 # le numéro du lot pour chaque correct ajouter 83 correcte = TF. reduce_sum (correct) 84 # le nombre de lot correct ensemble tout 85 total_correct + = int (correcte) 86 # de TOTAL_NUM le nombre total des échantillons testés, à savoir le nombre de lignes x_test, la forme [0] du nombre variable de lignes retournées 87 total_number + = x_test.shape [0] 88 # Taux de précision hors tout est égale total_correct / TOTAL_NUMBER 89 ACC = total_correct / TOTAL_NUMBER 90 test_acc.append (ACC) 91 est Imprimer ( " Test_acc: " , ACC) 92 Imprimer ( " -------------- --------------------------- " ) 93 94 95 # dessiner la courbe de perte 96 plt.title ( " Fonction de perte de la courbe " ) # titre de l' image 97 plt.xlabel ( " Epoch " ) # nom de la variable de l'axe x 98plt.ylabel ( " perte " ) # axe Y noms de variables 99 plt.plot (train_loss_results, label = " $ $ Perte " ) # valeurs et connexion de ponctuelles train_loss_results tracés, les icônes de connexion sont une perte de 100 plt.legend () # tracer la courbe icône 101 plt.show () 102 103 104 # dessiner des courbes de précision 105 plt.title ( " Acc la courbe " ) # titre de l' image 106 de plt.xlabel ( " Epoch " ) # X nom d' axe variable de 107 plt.ylabel ( " Acc" ) # Axe Y nom de la variable 108 plt.plot (test_acc, label = " $ $ de la précision " ) # point par point et tiré connexion test_acc, l'icône de connexion est la précision 109 plt.legend () 110 plt.show ()