使用多层神经网络
我们展示如何用TensorFlow构建多层神经网络
###低出生率数据 Low Birthrate data:
#Columns Variable Abbreviation#---------------------------------------------------------------------# Low Birth Weight (0 = Birth Weight >= 2500g, LOW# 1 = Birth Weight < 2500g)# Age of the Mother in Years AGE# Weight in Pounds at the Last Menstrual Period LWT# Race (1 = White, 2 = Black, 3 = Other) RACE# Smoking Status During Pregnancy (1 = Yes, 0 = No) SMOKE# History of Premature Labor (0 = None 1 = One, etc.) PTL# History of Hypertension (1 = Yes, 0 = No) HT# Presence of Uterine Irritability (1 = Yes, 0 = No) UI# Birth Weight in Grams BWT#---------------------------------------------------------------------我们要创建的多层神经网络由三个全链接隐藏层组成, 节点数分别为 50, 25, 和 5
import tensorflow as tf
import matplotlib.pyplot as plt
import csv
import os
import os.path
import random
import numpy as np
import random
import requests
from tensorflow.python.framework import ops
name of data file
birth_weight_file = 'birth_weight.csv'
download data and create data file if file does not exist in current directory
if not os.path.exists(birth_weight_file):
birthdata_url = 'https://github.com/nfmcclure/tensorflow_cookbook/raw/master/01_Introduction/07_Working_with_Data_Sources/birthweight_data/birthweight.dat'
birth_file = requests.get(birthdata_url)
birth_data = birth_file.text.split('\r\n')
birth_header = birth_data[0].split('\t')
birth_data = [[float(x) for x in y.split('\t') if len(x)>=1] for y in birth_data[1:] if len(y)>=1]
with open(birth_weight_file, "w") as f:
writer = csv.writer(f)
writer.writerows([birth_header])
writer.writerows(birth_data)
f.close()
read birth weight data into memory
birth_data = []
with open(birth_weight_file, newline='') as csvfile:
csv_reader = csv.reader(csvfile)
birth_header = next(csv_reader)
for row in csv_reader:
birth_data.append(row)
birth_data = [[float(x) for x in row] for row in birth_data]
birth_data
Extract y-target (birth weight)
y_vals = np.array([x[8:9] for x in birth_data])
Filter for features of interest
cols_of_interest = ['AGE', 'LWT', 'RACE', 'SMOKE', 'PTL', 'HT', 'UI']
x_vals = np.array([[x[ix] for ix, feature in enumerate(birth_header) if feature in cols_of_interest] for x in birth_data])
set batch size for training
batch_size = 10
make results reproducible
seed = 3
np.random.seed(seed)
#tf.set_random_seed(seed)
Split data into train/test = 80%/20%
train_indices = np.random.choice(len(x_vals), round(len(x_vals)*0.8), replace=False)
test_indices = np.array(list(set(range(len(x_vals))) - set(train_indices)))
x_vals_train = x_vals[train_indices]
x_vals_test = x_vals[test_indices]
y_vals_train = y_vals[train_indices]
y_vals_test = y_vals[test_indices]
Record training column max and min for scaling of non-training data
train_max = np.max(x_vals_train, axis=0)
train_min = np.min(x_vals_train, axis=0)
Normalize by column (min-max norm to be between 0 and 1)
def normalize_cols(mat, max_vals, min_vals):
return (mat - min_vals) / (max_vals - min_vals)
x_vals_train = np.nan_to_num(normalize_cols(x_vals_train, train_max, train_min))
x_vals_test = np.nan_to_num(normalize_cols(x_vals_test, train_max, train_min))
#定义权重和偏置。
Define Variable Functions (weights and bias)
def init_weight(shape, st_dev):
weight = tf.Variable(tf.random.normal(shape, stddev=st_dev))
return(weight)
def init_bias(shape, st_dev):
bias = tf.Variable(tf.random.normal(shape, stddev=st_dev))
return(bias)
#定义模型!我们先创建一个根据变量生成全链接层的函数。
x_data = tf.Variable(np.random.randn(1,7),dtype=tf.float32)
y_target = tf.Variable(np.random.randn(1,1),dtype=tf.float32)
Create a fully connected layer:
def fully_connected(input_layer, weights, biases):
layer = tf.add(tf.matmul(input_layer, weights), biases)
return(tf.nn.relu(layer))
#我们初始化变量并开始训练循环。
learning_rate=0.001
Training loop
loss_vec = []
test_loss = []
weight_1 = init_weight(shape=[7, 25], st_dev=1.0)
bias_1 = init_bias(shape=[25], st_dev=10.0)
weight_2 = init_weight(shape=[25, 10], st_dev=1.0)
bias_2 = init_bias(shape=[10], st_dev=10.0)
weight_3 = init_weight(shape=[10, 3], st_dev=1.0)
bias_3 = init_bias(shape=[3], st_dev=10.0)
weight_4 = init_weight(shape=[3, 1], st_dev=1.0)
bias_4 = init_bias(shape=[1], st_dev=1.0)
for i in range(3000):
rand_index = np.random.choice(len(x_vals_train), size=batch_size)
rand_x = x_vals_train[rand_index]
rand_y = np.transpose([y_vals_train[rand_index]])
with tf.GradientTape() as tape:
#--------Create the first layer (50 hidden nodes)--------
layer_1 = fully_connected(x_data, weight_1, bias_1)
#--------Create second layer (25 hidden nodes)--------
layer_2 = fully_connected(layer_1, weight_2, bias_2)
#--------Create third layer (5 hidden nodes)--------
layer_3 = fully_connected(layer_2, weight_3, bias_3)
#--------Create output layer (1 output value)--------
final_output = fully_connected(layer_3, weight_4, bias_4)
Declare loss function (L1)
loss = tf.reduce_mean(tf.abs(y_target - final_output))
grads=tape.gradient(loss,[weight_1,bias_1,weight_2,bias_2,weight_3,bias_3,weight_4,bias_4])
loss_vec.append(loss)
weight_1.assign_sub(learning_rate*grads[0])
bias_1.assign_sub(learning_rate*grads[1])
weight_2.assign_sub(learning_rate*grads[2])
bias_2.assign_sub(learning_rate*grads[3])
weight_3.assign_sub(learning_rate*grads[4])
bias_3.assign_sub(learning_rate*grads[5])
weight_4.assign_sub(learning_rate*grads[6])
bias_4.assign_sub(learning_rate*grads[7])
#test_loss.append(test_temp_loss)
if (i+1) % 25 == 0:
print('Generation: ' + str(i+1) + '. Loss = ' + str(loss.numpy()))
#绘制损失函数。
%matplotlib inline
Plot loss (MSE) over time
plt.plot(loss_vec, 'k-', label='Train Loss')
#plt.plot(test_loss, 'r--', label='Test Loss')
plt.title('Loss (MSE) per Generation')
plt.legend(loc='upper right')
plt.xlabel('Generation')
plt.ylabel('Loss')
plt.show()
Create variable definition
def init_variable(shape):
return(tf.Variable(tf.random.normal(shape=shape)))
Create a logistic layer definition
def logistic(input_layer, multiplication_weight, bias_weight, activation = True):
linear_layer = tf.add(tf.matmul(input_layer, multiplication_weight), bias_weight)
We separate the activation at the end because the loss function will
implement the last sigmoid necessary
if activation:
return(tf.nn.sigmoid(linear_layer))
else:
return(linear_layer)
Declare optimizer
#my_opt = tf.train.AdamOptimizer(learning_rate = 0.002)
#train_step = my_opt.minimize(loss)
Actual Prediction
A1 = init_variable(shape=[7,14])
b1 = init_variable(shape=[14])
A2 = init_variable(shape=[14,5])
b2 = init_variable(shape=[5])
A3 = init_variable(shape=[5,1])
b3 = init_variable(shape=[1])
optimizer = tf.optimizers.SGD(learning_rate)
Training loop
loss_vec = []
train_acc = []
test_acc = []
for i in range(3000):
rand_index = np.random.choice(len(x_vals_train), size=batch_size)
rand_x = x_vals_train[rand_index]
rand_y = np.transpose([y_vals_train[rand_index]])
with tf.GradientTape() as tape:
First logistic layer (7 inputs to 14 hidden nodes)
logistic_layer1 = logistic(x_data, A1, b1)
Second logistic layer (14 hidden inputs to 5 hidden nodes)
logistic_layer2 = logistic(logistic_layer1, A2, b2)
Final output layer (5 hidden nodes to 1 output)
final_output = logistic(logistic_layer2, A3, b3, activation=False)
Declare loss function (Cross Entropy loss)
loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=final_output, labels=y_target))
grads=tape.gradient(loss,[A1,b1,A2,b2,A3,b3])
optimizer.apply_gradients(zip(grads, [A1,b1,A2,b2,A3,b3]))
loss_vec.append(loss)
#A1.assign_sub(learning_rate*grads[0])
#b1.assign_sub(learning_rate*grads[1])
#A2.assign_sub(learning_rate*grads[2])
#b2.assign_sub(learning_rate*grads[3])
#A3.assign_sub(learning_rate*grads[4])
#b3.assign_sub(learning_rate*grads[5])
if (i+1)%150==0:
print('Loss = ' + str(loss.numpy()))
%matplotlib inline
Plot loss over time
plt.plot(loss_vec, 'k-')
plt.title('Cross Entropy Loss per Generation')
plt.xlabel('Generation')
plt.ylabel('Cross Entropy Loss')
plt.show()
