El segundo capítulo de la red neuronal misión y la regresión de combate - la tarea de regresión red neuronal temperatura

El primer paso: la función de visualización

Importación PANDAS como Pd
 importación numpy, como NP
 importación de fecha y hora
 de importación matplotlib.pyplot AS PLT 

Características = pd.read_csv ( ' temps.csv ' ) 

# visualizaciones 
Imprimir (features.head (. 5 )) 

# fechas utiliza visualización configurado 
fechas = [str (int (año)) + " - " + STR (int (mes El)) + " - " + STR (int (Día)) para el año, mes El Día en ZIP (Características [ ' años ' ], características [ ' meses El ' ], las características [' Día ' ])] 
fechas = [datetime.datetime.strptime (fecha, " % Y-% m-% d " ) para la fecha en fechas] 

# 进行画图操作 
plt.style.use ( " FiveThirtyEight " ) 

fig, ( (AX1, ax2), (ax3, AX4)) = plt.subplots (nRows = 2, ncols = 2, figsize = (10, 10 )) 
fig.autofmt_xdate (rotación = 45 ) 

ax1.plot (fechas, cuenta con [ " temp_1 " ]) 
ax1.set_xlabel ( '' ) 
ax1.set_ylabel ( ' Temperatura '  )
ax1.set_title (" Temperatura máx Anterior " ) 

ax2.plot (fechas, cuenta con [ " temp_2 " ]) 
ax2.set_xlabel ( '' ) 
ax2.set_ylabel ( ' Temperatura ' ) 
ax2.set_title ( " Dos días Prio temperatura máxima " ) 

ax3.plot ( fechas, características [ " amigo " ]) 
ax3.set_xlabel ( '' ) 
ax3.set_ylabel ( ' Temperatura ' ) 
ax3.set_title ( " amigo Estimación " ) 

ax4.plot (fechas,características [ " real" ]) 
Ax4.set_xlabel ( '' ) 
ax4.set_ylabel ( ' Temperatura ' ) 
ax4.set_title ( " Temperatura Max " ) 

plt.tight_layout (PAD = 2 ) 
plt.show ()

 

 Paso dos: la función es no-caliente valores codificados digitales, de temperatura reales como la etiqueta se retira como un rasgo característico de entrada del valor real, durante el uso de proceso de operación estandarizada

# Configurado caliente codificado 
# función de recorrido, lo que no características de eliminación digitales 
para feature_name a en features.columns:
     Imprimir (FEATURE_NAME a)
     el try : 
        un flotador (features.loc [0, FEATURE_NAME a]) 
    las excepto :
         para S en SET ([Características feature_name a]): 
            características [S] = 0 

        # añadido de acuerdo con cada fila de datos en el tiempo se caracteriza 1. 
        para F en Rango (lEN (características)): 
            features.loc [F, [features.iloc [F] [feature_name a]] ] = 1 # quitado características semana correspondiente 
        FEATURES = features.drop (feature_name a, Axis = 1 )

        

# Configurado utilizando uno en caliente de codificación puede 
# FEATURES = pd.get_dummies (características) 

# configurado etiqueta 
etiquetas = np.array (Características [ ' real ' ]) 

# Características estructurales 
Características features.drop = ( ' real ' , Axis =. 1 ) 

# para el entrenamiento de la red de la antorcha 
de importación antorcha 

# de las características de funcionamiento estándar 
de sklearn importación preprocesamiento 

input_feature = preprocessing.StandardScaler () fit_transform (características). 


impresión (input_feature [:., 5])

El tercer paso: las características y etiquetas torch.tensor proceso, se convierte en el formato de tensor, y pesan de inicialización sesgos, batch_size realizó utilizando una optimización iterativa, y el uso de weight.grad biases.grad gradiente de optimización de la tasa de aprendizaje

# 构建神经网络 
x = torch.tensor (input_feature, dtype = torch.float) 

y = torch.tensor (etiquetas, dtype = torch.float) 


de peso = torch.randn ((14, 128), dtype = torch.float, requires_grad = True) 
sesgos = torch.randn (128, dtype = torch.float, requires_grad = True) 

peso2 = torch.randn ((128, 1), dtype = torch.float, requires_grad = True) 
biases2 = torch.randn ( 1, dtype = torch.float, requires_grad = True) 

learning_rate = 0,001 
pérdidas = [] 
batch_size = 16 para i en rango (1000 ):
    


# 计算隐层 
    batch_loss = []
     para inicio en rango (0, len (input_feature), batch_size): 
        final = iniciar + batch_size si inicio + batch_size <len (input_feature) más len (input_feature) 
        xx = torch.tensor (input_feature [ inicio: fin], dtype = torch.float, requires_grad = True) 
        yy = torch.tensor (etiquetas [inicio: fin], dtype = torch.float, requires_grad = True) 
        oculto = xx.mm (peso) + sesgos
         # 加入激活函数 
        oculta = torch.sigmoid (oculto)
         # 预测结果
        predicciones = hidden.mm (Peso2) + biases2
         # 计算损失值 
        pérdida = torch.mean ((predicciones - yy) ** 2 ) 
        loss.backward () 

        # 更新参数 
        weight.data.add _ (- learning_rate * weight.grad. datos) 
        biases.data.add_ ( - learning_rate * biases.grad.data) 
        weight2.data.add_ ( - learning_rate * weight2.grad.data) 
        biases2.data.add_ ( - learning_rate * biases2.grad.data) 

        # 每次迭代都记得清空
        weight.grad.data.zero_ () 
        biases.grad.data.zero_ () 
        weight2.grad.data.zero_ ()
        biases2.grad.data.zero_ ()
        batch_loss.append (loss.data.numpy ()) 
    si i% 100 == 0: 
        losses.append (np.mean (batch_loss)) 
        de impresión (i, np.mean (batch_loss))

Paso 4: x para re-entrar en la red se calcula para obtener la predicción final, el trazado definitivo

oculto = x.mm (peso) + sesgos
 # 加入激活函数 
oculta = torch.sigmoid (oculto)
 # 预测结果 
predicción = hidden.mm (Peso2) + biases2 

predicción = prediction.detach (). numpy () 
plt.plot ( fechas, y, ' B- ' , label = ' real ' ) 
plt.plot (fechas, predicción, ' ro ' , label = ' PREDIT ' ) 
plt.xticks (rotación = 60 ) 
plt.title ( " Temperatura Predecir " ) 
plt.xlabel ( "Fecha " ) 
plt.ylabel ( " Temperatura " ) 
plt.show ()