读万卷书，不如行万里路。之前看了不少机器学习方面的书籍，但是实战很少。这次因为项目接触到tensorflow，用一个最简单的深层神经网络实现分类和回归任务。
首先说分类任务，分类任务的两个思路：
如果是多分类，输出层为计算出的预测值Z3(1,classes)，可以利用softmax交叉熵损失函数，将Z3中的值转化为概率值，概率值最大的即为预测值。
在tensorflow中，多分类的损失函数为：
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z3, labels=Y)) 为了匹配Z3和Y的尺寸，需要将输入Y进行one-hot编码，
from keras.utils import to_categorical
Y_train = to_categorical(Y_train)
计算准确性：
correct_prediction = tf.equal(tf.argmax(Z3,axis=1), tf.argmax(Y,1) ) # tf.argmax找出每一列最大值的索引
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) # tf.cast转化数据类型
print("Train Accuracy:", sess.run(accuracy,feed_dict={X: X_train, Y: Y_train}))
print("Test Accuracy: ",sess.run(accuracy,feed_dict={X:X_test,Y:Y_test}))
完整代码如下：
# -*- coding: utf-8 -*- import numpy as np
import tensorflow as tf
import math
from sklearn.model_selection import train_test_split
from keras.utils import to_categorical
import keras
import scipy
import os
import csv
import pandas as pd
from keras.utils import to_categorical from sklearn.preprocessing import normalize #创建placeholders对象
def create_placeholders(n_x,n_y):
"""
placeholder是TensorFlow的占位符节点，由placeholder方法创建，其也是一种常量，但是由用户在调用run方法是传递的.
也可以将placeholder理解为一种形参。
即其不像constant那样直接可以使用，需要用户传递常数值。
"""
X=tf.placeholder(tf.float32,shape=[None,n_x],name='X')
Y=tf.placeholder(tf.float32,shape=[None,n_y],name='Y') return X,Y #初始化参数
def initialize_parameters(m,n):
#设置种子后，每次生成的参数都是相同的，保证重复实验的结果可以参考
tf.set_random_seed(1)
W1 = tf.get_variable("W1", shape=[n, n], initializer=tf.contrib.layers.xavier_initializer(seed=1))
b1 = tf.get_variable("b1", shape=[1, n], initializer=tf.zeros_initializer())
W2=tf.get_variable("W2",shape=[n,2],initializer=tf.contrib.layers.xavier_initializer(seed=1))
b2=tf.get_variable("b2",shape=[1,2],initializer=tf.zeros_initializer())
parameters={
"W1": W1,
"b1":b1,
"W2":W2,
"b2":b2
}
return parameters #前向传播
def forward_propagation(X,parameters,lambd):
W1=parameters['W1']
b1=parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2'] #使用L1正则化
tf.add_to_collection('losses',tf.contrib.layers.l1_regularizer(lambd)(W1))
tf.add_to_collection('losses', tf.contrib.layers.l1_regularizer(lambd)(W2)) A1=tf.nn.relu(tf.matmul(X,W1)+b1)
Z3=tf.matmul(A1,W2)+b2 return Z3 def compute_cost(Z3, Y):
cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z3, labels=Y))
tf.add_to_collection('losses',cost)
return tf.add_n(tf.get_collection('losses')) def model(X_train, Y_train,X_test,Y_test, learning_rate=0.01,minibatch_size=10, num_epochs=30000, print_cost=True): tf.set_random_seed(1)
(m, n_x) = X_train.shape
n_y = Y_train.shape[1]
costs = []
# 创建Placeholders,一个张量
X,Y=create_placeholders(n_x,n_y)
print(X.shape, Y.shape)
# 初始化参数
parameters=initialize_parameters(m,n_x)
# 前向传播
Z3=forward_propagation(X,parameters,0.002)
# 计算代价
cost = compute_cost(Z3, Y) # 后向传播: 定义tensorflow optimizer对象，这里使用AdamOptimizer.
optimizer=tf.train.AdadeltaOptimizer(learning_rate=learning_rate).minimize(cost)
# optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost)
# 初始化所有参数
init=tf.global_variables_initializer() # 启动session来计算tensorflow graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(num_epochs):
epoch_cost=sess.run([optimizer,cost],feed_dict={X:X_train,Y:Y_train})
test_cost=sess.run(cost,feed_dict={X:X_test,Y:Y_test})
epoch_cost=epoch_cost[1] if print_cost==True and epoch%100==0:
print("Cost after epoch %i: %f" %(epoch,epoch_cost))
print("test_cost: ",test_cost) # lets save the parameters in a variable
parameters = sess.run(parameters)
print("Parameters have been trained!")
# 神经网络经过训练后得到的值 correct_prediction = tf.equal(tf.argmax(Z3,axis=1), tf.argmax(Y,1) ) # tf.argmax找出每一列最大值的索引
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) # tf.cast转化数据类型
print("Train Accuracy:", sess.run(accuracy,feed_dict={X: X_train, Y: Y_train}))
print("Test Accuracy: ",sess.run(accuracy,feed_dict={X:X_test,Y:Y_test})) return parameters def loaddata(file): fr=open(file,'r', encoding='utf-8-sig')
reader = csv.reader(fr)
data=[]
fltLine=[]
for line in reader:
data.append(line)
data=np.mat(data)
data=data.astype(np.float32)
X=data[1:,0:-1]
Y=data[1:,-1]
X=normalize(X,axis=0,norm='max')
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3, random_state=42)
return X_train, X_test, Y_train, Y_test if __name__=='__main__': X_train, X_test, Y_train, Y_test= loaddata('./data3.csv')
Y_train=to_categorical(Y_train)
Y_test = to_categorical(Y_test)
parmeters=model(X_train,Y_train,X_test,Y_test)
另一种是单纯的针对二分类，主要有两点不同，一是损失函数的使用：
输出层Z3为(1,1)
cost= tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=Z3, labels=Y))
另一个就是计算准确率：
one = tf.ones_like(Z3)
zero = tf.zeros_like(Z3)
label = tf.where(tf.less(Z3, 0.5), x=zero, y=one) correct_prediction = tf.equal(label, Y) # tf.argmax找出每一列最大值的索引
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) # tf.cast转化数据类型
print("Train Accuracy:", sess.run(accuracy, feed_dict={X: X_train, Y: Y_train}))
print("Test Accuracy: ", sess.run(accuracy, feed_dict={X: X_test, Y: Y_test}))
完整代码如下：
# -*- coding: utf-8 -*- import numpy as np
import tensorflow as tf
import math
from sklearn.model_selection import train_test_split
from keras.utils import to_categorical
import keras
import scipy
import os
import csv
import pandas as pd
from keras.utils import to_categorical from sklearn.preprocessing import normalize # 创建placeholders对象
def create_placeholders(n_x, n_y):
"""
placeholder是TensorFlow的占位符节点，由placeholder方法创建，其也是一种常量，但是由用户在调用run方法是传递的.
也可以将placeholder理解为一种形参。
即其不像constant那样直接可以使用，需要用户传递常数值。
"""
X = tf.placeholder(tf.float32, shape=[None, n_x], name='X')
Y = tf.placeholder(tf.float32, shape=[None, n_y], name='Y') return X, Y # 初始化参数
def initialize_parameters(m, n):
# 设置种子后，每次生成的参数都是相同的，保证重复实验的结果可以参考
tf.set_random_seed(1)
W1 = tf.get_variable("W1", shape=[n, n], initializer=tf.contrib.layers.xavier_initializer(seed=1))
b1 = tf.get_variable("b1", shape=[1, n], initializer=tf.zeros_initializer())
W2 = tf.get_variable("W2", shape=[n, 1], initializer=tf.contrib.layers.xavier_initializer(seed=1))
b2 = tf.get_variable("b2", shape=[1, 1], initializer=tf.zeros_initializer())
parameters = {
"W1": W1,
"b1": b1,
"W2": W2,
"b2": b2
}
return parameters # 前向传播
def forward_propagation(X, parameters, lambd):
W1 = parameters['W1']
b1 = parameters['b1']
W2 = parameters['W2']
b2 = parameters['b2'] # 使用L1正则化
#tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(lambd)(W1))
#tf.add_to_collection('losses', tf.contrib.layers.l2_regularizer(lambd)(W2)) #A1 = tf.nn.relu(tf.matmul(X, W1) + b1)
Z3 = tf.matmul(X, W2) + b2
#Z3=tf.sigmoid(Z3) return Z3 def compute_cost(Z3, Y):
# 经过激活函数处理后的交叉熵
#cost = tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(logits=Z3, labels=Y))
cost= tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(logits=Z3, labels=Y))
#cost=-tf.reduce_mean(Y*tf.log(tf.clip_by_value(Z3,1e-10,1.0)))
tf.add_to_collection('losses', cost)
return tf.add_n(tf.get_collection('losses')) def model(X_train, Y_train, X_test, Y_test, learning_rate=0.05, minibatch_size=10, num_epochs=50000, print_cost=True):
tf.set_random_seed(1)
(m, n_x) = X_train.shape
n_y = Y_train.shape[1]
costs = []
# 创建Placeholders,一个张量
X, Y = create_placeholders(n_x, n_y)
print(X.shape, Y.shape)
# 初始化参数
parameters = initialize_parameters(m, n_x)
# 前向传播
Z3 = forward_propagation(X, parameters, 0.001)
# 计算代价
cost = compute_cost(Z3, Y) # 后向传播: 定义tensorflow optimizer对象，这里使用AdamOptimizer.
optimizer = tf.train.AdadeltaOptimizer(learning_rate=learning_rate).minimize(cost)
# optimizer = tf.train.GradientDescentOptimizer(learning_rate=learning_rate).minimize(cost)
# 初始化所有参数
init = tf.global_variables_initializer() # 启动session来计算tensorflow graph
with tf.Session() as sess:
sess.run(init)
for epoch in range(num_epochs):
epoch_cost = sess.run([optimizer, cost], feed_dict={X: X_train, Y: Y_train})
test_cost = sess.run(cost, feed_dict={X: X_test, Y: Y_test})
epoch_cost = epoch_cost[1] if print_cost == True and epoch % 100 == 0:
print("Cost after epoch %i: %f" % (epoch, epoch_cost))
print("test_cost: ", test_cost) # lets save the parameters in a variable
parameters = sess.run(parameters)
print("Parameters have been trained!")
# 神经网络经过训练后得到的值
# print(sess.run(Y,feed_dict={Y:Y_train}))
# Y=tf.cast(Y,tf.int64) one = tf.ones_like(Z3)
zero = tf.zeros_like(Z3)
label = tf.where(tf.less(Z3, 0.5), x=zero, y=one) correct_prediction = tf.equal(label, Y) # tf.argmax找出每一列最大值的索引
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float")) # tf.cast转化数据类型
print("Train Accuracy:", sess.run(accuracy, feed_dict={X: X_train, Y: Y_train}))
print("Test Accuracy: ", sess.run(accuracy, feed_dict={X: X_test, Y: Y_test})) return parameters def loaddata(file):
fr = open(file, 'r', encoding='utf-8-sig')
reader = csv.reader(fr)
data = []
fltLine = []
for line in reader:
data.append(line)
data = np.mat(data)
data = data.astype(np.float32)
X = data[1:, 0:-1]
Y = data[1:, -1]
X = normalize(X, axis=0, norm='max')
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.3, random_state=42)
return X_train, X_test, Y_train, Y_test if __name__ == '__main__': X_train, X_test, Y_train, Y_test = loaddata('./data3.csv')
#Y_train = to_categorical(Y_train)
#Y_test = to_categorical(Y_test) parmeters = model(X_train, Y_train, X_test, Y_test)