#Utilice los datos del iris para realizar la propagación hacia adelante y hacia atrás y visualizar la curva de pérdida
# Módulo de importación requiere de importación tensorflow TF AS de sklearn importación conjuntos de datos de importación matplotlib.pyplot AS PLT importación numpy, como NP Importación Tiempo # datos de importación, respectivamente, y la función de introducción de etiquetas x_data = datasets.load_iris (). Datos y_data = datasets.load_iris ( ) .target # de datos interrumpido al azar (porque los datos originales es el orden secuencial no se interrumpa afectar a la precisión) # la semilla: semilla de número aleatorio es un número entero, cuando se establece, cada número aleatorio generado son los mismos np. random.seed (1 16) # use la misma semilla, por ejemplo, etiquetas de garantía y características corresponden np.random.shuffle (x_data) np.random.seed ( 1 16 ) np.random.shuffle (y_data) tf.random.set_seed (116 ) # después el conjunto de datos de entrenamiento estilo molesto y de prueba, las primeras 120 líneas del conjunto de entrenamiento, un conjunto de prueba de 30 filas x_train x_data = [: - 30 ] y_train = y_data [: - 30 ] x_test = x_data [-30 :] android.permission.FACTOR. = y_data [-30 :] # tipos de datos de conversión de x, o porque los datos se matriz inconsistente siendo dado por la multiplicación de la parte posterior x_train = tf.cast (x_train, tf.float32) x_test = tf.cast ( x_test, tf.float32) La función # from_tensor_slices hace que las características de entrada se correspondan con los valores de las etiquetas una por una. (El conjunto de datos se divide en lotes y cada lote de datos de lote) train_db = tf.data.Dataset.from_tensor_slices ((x_train, y_train)). Batch (32 ) test_db = tf.data.Dataset.from_tensor_slices ((x_test, y_test)). batch (32 ) #Generación de un neurales parámetros de red, característica de entrada número 4, entrada de capa de cuatro nodos de entrada, clasificadas como 3, por lo que la neurona de salida se convierte en 3 # con tf.Variable () parámetros de entrenamiento pueden ser etiquetados # utilizado para hacer cada semilla generada El mismo número aleatorio w1 = tf.Variable (tf.random.truncated_normal ([4, 3], stddev = 0.1, seed = 1 )) b1 = tf.Variable (tf.random.truncated_normal ([3], stddev = 0.1, =. 1 SEED )) LR = 0,1 # tasa de aprendizaje 0.1 train_loss_results = [] # la pérdida registrada en cada ronda en esta lista, para proporcionar datos para posterior Videos curva test_acc = [] # la acc ronda registrada en esta lista para proporcionar datos para Videos posteriores acc curva Epoch 500 = # ciclos 500 loss_all = 0 # ronda divide en cuatro paso, paso de grabación loss_all 4 produjo 4 pérdida y # porción formación now_time = la time.time () para época en la gama (época): # nivel de conjunto de datos de circulación, cada ciclo de época colección de datos de tiempo de paso, (x_train, y_train) en la enumerate (train_db): # ciclos de nivel de lote, cada ciclo de un lote paso con TF .GradientTape () de cinta como: # con una estructura de gradiente de la información de grabación y = tf.matmul (x_train, W1) + B1 # operación suma red neural y = tf.nn.softmax (y) # salida Y se encuentran la distribución de probabilidad ( después de esto, el código caliente del mismo orden, la búsqueda relativa Guardar Pérdida) Y_ = tf.one_hot (y_train, profundidad = 3). # valor de etiqueta en formato de código caliente para facilitar el cálculo y precisión Pérdida = tf.reduce_mean ( tf.square (Y_ - Y)) # utilizando la función cuadrado medio error Mean = MSE (SUM (Y - OUT) ^ 2) loss_all + = Pérdida #Acumule la pérdida calculada en cada paso para proporcionar datos para el cálculo de pérdida promedio subsiguiente, de modo que la pérdida calculada sea más precisa # Calcule el gradiente de cada parámetro del gradiente graduados = tape.gradient (pérdida, [w1, b1]) # Implemente el gradiente * LR b_grad - actualización w1 = w1 - LR w1_grad B = B * w1.assign_sub (LR GrADS * [0]) # parámetros w1 auto-refresh b1.assign_sub (LR * GrADS [1.]) # parámetro b1 auto-refresh # cada epoch, print información de pérdida print ( " Epoch {}, loss: {} " .format (epoch, loss_all / 4 )) train_loss_results.append (loss_all / 4) # promedia la pérdida de 4 pasos y registra en esta variable loss_all = 0 # loss_all vuelve a cero, preparándose para registrar la pérdida de la próxima época # Parte de prueba #total_correct para predecir el número de muestras de, TOTAL_NUMBER el número total de muestras analizadas, las dos variables se inicializan a 0 total_correct, TOTAL_NUMBER = 0, 0 para x_test, android.permission.FACTOR. en TEST_DB: # usando los parámetros de predicción actualizados y = tf.matmul (x_test, W1) + B1 Y = tf.nn.softmax (y) pred = tf.argmax (y, = Eje. 1) # devuelve el índice y es el valor máximo, es decir, la clasificación predicha # para convertir pred y_test tipo de datos Pred = tf.cast (Pred, DTYPE = y_test.dtype) # Si se clasifican correctamente, la correcta = 1, de lo contrario a 0, el resultado de la bool tipo de conversión a int = correctas tf.cast (tf.equal (Pred, android.permission.FACTOR.), DTYPE = tf.int32) # el número del lote combinados para cada correctas = correctastf.reduce_sum (correcto) # el número de todo el lote combinado total_correct + = int (correcto) # Total-Número de número total de muestras analizadas, es decir, el número de filas x_test, forma [0] retorno número variable de filas total_number + = x_test.shape [0] # tasa general de precisión es / TOTAL_NUMBER igual total_correct ACC = total_correct / TOTAL_NUMBER test_acc.append (ACC) Imprimir ( " Test_acc: " , ACC) Imprimir ( " ----------- -------------------------- " ) total_time = time.time () -now_time print ( " total_time " , total_time) # 绘制 pérdida 曲线 plt.title ( " Curva de función de pérdida " ) plt.xlabel ( " Epoch " ) plt.ylabel ( " Loss " ) plt.plot (train_loss_results, " b-. " , Label = " $ Loss $ " ) plt.legend () plt.show () # 绘制 Precisión 曲线 plt.title ( " Acc Curve " ) plt.xlabel ( " Epoch " ) plt.ylabel ( " Acc " ) plt.plot (test_acc," b-. " , label = " $ Precisión $ " ) plt.legend () plt.show ()