. 1 # _ * _ Codificación:. _ * _ 8 UTF- 2 # usando el iris conjunto de datos, propagación, propagación contador antes alcanzado, curva de pérdida visual . 3 . 4 # Módulo de importación deseada 5. Importación tensorflow AS TF 6. De sklearn Importar Conjuntos de datos . 7 de matplotlib importación pyplot aS PLT . 8 importación numpy aS NP . 9 10 # datos de importación, respectivamente, y la etiqueta de entidad de entrada . 11 x_data = datasets.load_iris (). de datos 12 se y_data = datasets.load_iris (). objetivo 13 es 14 # perturbado azar Datos (debido a que los datos originales son secuenciales, el orden no afectará la tasa de precisión) 15 # semilla: la semilla de número aleatorio es un entero. Después de la configuración, el número aleatorio generado cada vez es el mismo. 16 np.random.seed (1 16) # uso la misma semilla, y asegúrese de que la etiqueta correspondencia entidad de entrada. . 17 np.random.shuffle (x_data) 18 se np.random.seed (1 16 ) . 19 np.random.shuffle (y_data) 20 se tf.random.set_seed (1 16 ) 21 es 22 es # después de la interrupción de conjunto de datos se divide en un conjunto de entrenamiento Y el conjunto de prueba, el conjunto de entrenamiento son las primeras 120 líneas, el conjunto de prueba son las últimas 30 líneas 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 #Convierta el tipo de datos de x, de lo contrario, se informará un error debido a tipos de datos inconsistentes cuando la matriz se multiplique más tarde 30 x_train = tf.cast (x_train, tf.float32) 31 x_test = tf.cast (x_test, tf.float32) 32 33 # from_tensor_slices Las características de entrada corresponden a los valores de etiqueta uno a uno. (El conjunto de datos se divide en lotes y cada lote de datos de lote) 34 train_db = tf.data.Dataset.from_tensor_slices ((x_train, y_train)). Lote (32 ) 35 test_db = tf.data.Dataset.from_tensor_slices (( x_test, android.permission.FACTOR)) LOTE (32.. ) 36 37 [ # generada parámetros de la red neural, cuatro de entidad de entrada, de modo de entrada de capa de cuatro nodos de entrada; para 3 de clasificación, por lo que la capa de salida de tres neuronas 38 # con tf. variable () parámetro marcado formación 39 # utilizan la misma semilla de número aleatorio para que cada generación. 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 es 43 es LR = 0,1 # tasa de aprendizaje de 0,1 44 es train_loss_results = [] # la pérdida registrada en cada ronda en esta lista, para proporcionar datos para las subsiguientes curva de pérdida Videos 45 test_acc = [] # la acc registrada en cada ronda esta lista, para proporcionar datos para Videos posteriores acc curva 46 es Epoch 500 = # 500 ciclos de 47 loss_all = 0 # ronda dividido en cuatro pasos, loss_all grabación de cuatro y cuatro pérdida etapa de generación 48 49 # parte de formación 50 para época en rango (época):# Nivel de conjunto de datos de ciclos, cada ciclo de tiempo de datos época conjunto 51 es para paso, (x_train, y_train) en la enumerate (train_db): # ciclos de nivel de lote, cada ciclo de un lote paso 52 es con tf.GradientTape () Tape AS : # con una estructura de gradiente de la información de grabación 53 es y = tf.matmul (x_train, W1) + B1 # red neural suma operación 54 es y = tf.nn.softmax (y) # salida y se encuentran la distribución de probabilidad (y solamente después de esta operación código caliente del mismo orden, en relación pérdida buscando Save) 55 Y_ = tf.one_hot (y_train, profundidad = 3). # valor de etiqueta en un formato de código caliente para facilitar el cálculo y la pérdida de precisión 56 es la pérdida = tf.reduce_mean (TF. cuadrado (Y_ - Y)) # usando el error cuadrático medio = Mean función de pérdida de MSE (SUM (Y-OUT) ^ 2) 57 es + = Loss.numpy loss_all () # cada paso la pérdida acumulada calculada, tratan de proporcionar datos para la pérdida media posterior, la pérdida calculada de este modo con mayor precisión 58 # calcula los parámetros de su gradiente de pérdida de 59 GrADS = tape.gradient (Pérdida, [w1, B1]) 60 61 es # implementado gradiente actualización w1 = w1 - LR * w1_grad, B = B - LR * b_grad 62 es w1.assign_sub (LR * GrADS [0]) # parámetros w1 auto-refresh 63 es B1. assign_sub (LR * GrADS [. 1]) # actualización de parámetros de b 64 65 # de cada época, la pérdida de información de impresión 66 Imprimir ( " Epoch: {}, pérdida de: {} " . .formato (época, loss_all / 4 )) 67 train_loss_results.append (loss_all /. 4) # El paso de promedio de cuatro pérdida de grabación en esta variable 68 loss_all = 0 # loss_all cero, listo para la siguiente época de una pérdida récord 69 70 # sección de ensayo 71 es # total_correct de predicción del número de muestras, el número total de muestras TOTAL_NUMBER probados, las dos variables se inicializan a 0 72 total_correct, TOTAL_NUMBER = 0, 0 73 es para x_test, android.permission.FACTOR. en TEST_DB: 74 # usando los parámetros de predicción actualizados 75 y = tf.matmul (x_test, w1) + b1 76 y = tf.nn.softmax (y) 77 pred = tf.argmax (y, axis = 1) #Devuelve el índice del valor máximo en y, es decir, la clasificación pronosticada 78 # Convertir pred al tipo de datos de y_test 79 pred = tf.cast (pred, dtype = y_test.dtype) 80 # Si la clasificación es correcta, correcta = 1, de lo contrario es 0, el resultado se convierte en valor de tipo bool int 81 = correctas tf.cast (tf.equal (Pred, android.permission.FACTOR.), DTYPE = tf.int32) 82 # el número del lote para cada add correcta 83 correcta = TF. reduce_sum (correcto) 84 # el número de lote correcto juntos todo 85 total_correct + = int (correcto) 86 # TOTAL_NUM el número total de muestras analizadas, es decir, el número de filas x_test, forma [0] de la variable número de filas devueltas 87 total_number + = x_test.shape [0] 88 # La tasa global de precisión es igual total_correct / TOTAL_NUMBER 89 ACC = total_correct / TOTAL_NUMBER 90 test_acc.append (ACC) 91 es de impresión ( " Test_acc: " , ACC) 92 Imprimir ( " -------------- --------------------------- " ) 93 94 95 # dibujan curva de pérdida de 96 plt.title ( " función de pérdida de la curva " ) # título de la imagen 97 plt.xlabel ( " Epoch " ) # nombre de variable del eje x 98plt.ylabel ( " pérdida " ) # eje y los nombres de variables 99 plt.plot (train_loss_results, etiqueta = " $ $ Pérdida " ) # valores pointwise y conexión train_loss_results trazada, iconos de conexión son la pérdida de 100 plt.legend () # trazar la curva icono 101 plt.show () 102 103 104 # dibujo Precisión curvas 105 plt.title ( " Acc la curva " ) # título de la imagen 106 plt.xlabel ( " Epoch " ) # X eje nombre de variable 107 plt.ylabel ( " Acc" ) # Y eje nombre de variable 108 plt.plot (test_acc, label = " $ $ la Precisión " ) # punto por punto y la conexión test_acc dibujado, el icono de conexión es la precisión 109 plt.legend () 110 plt.show ()