神经网络 python 代码

# -*- coding: utf-8 -*-

#import init
from sklearn.model_selection import train_test_split
import numpy as np
import tensorflow.compat.v1 as tf
tf.disable_v2_behavior()
import matplotlib.pyplot as plt
from sklearn import preprocessing
import pandas as pd


batch_size=6
nepoch=50

def loadData():
    datasource=pd.read_csv('./iris.data',names=['var1','var2','var3','var4','result'], keep_default_na=True)
    # 独热编号
    datasource['c1']=np.array(datasource['result']=='Iris-versicolor').astype(np.float32)
    datasource['c2']=np.array(datasource['result']=='Iris-virginica').astype(np.float32)
    datasource['c3']=np.array(datasource['result']=='Iris-setosa').astype(np.float32)
    del datasource['result']
    target=np.stack([datasource.c1.values,datasource.c2.values,datasource.c3.values]).T
    dataN=np.stack([datasource.var1.values,datasource.var2.values,datasource.var3.values,datasource.var4.values]).T
    data = dataN
    label = target
    data,label = normalization(data,label)
    return data,label


def normalization(data,target):
    min_max_scaler = preprocessing.MinMaxScaler()  
    data = min_max_scaler.fit_transform(data)
    label = np.zeros([150,3])
    for i in range(150):
        label[i]=target[i]
    return data,label


def compute_accuracy(v_xs, v_ys):
    global y_
    y_pre = sess.run(y_, feed_dict={xs: v_xs})
    correct_prediction = tf.equal(tf.argmax(y_pre,1), tf.argmax(v_ys,1))
    accuracy = tf.reduce_mean(tf.cast(correct_prediction, tf.float32))
    result = sess.run(accuracy, feed_dict={xs: v_xs, ys: v_ys})
    return result


def add_layer(inputs, in_size, out_size, activation_function=None):
    Weights = tf.Variable(tf.random_normal([in_size, out_size]))
    biases = tf.Variable(tf.zeros([1, out_size]) + 0.1,) #推荐值不为0
    Wx_plus_b = tf.matmul(inputs, Weights) + biases
    if activation_function is None:
        outputs = Wx_plus_b
    else:
        outputs = activation_function(Wx_plus_b,)
    return outputs


def next_batch(train_data, train_label, batch_size):  
    index = [ i for i in range(0,len(train_data)) ]  
    np.random.shuffle(index);  
    batch_data = []; 
    batch_target = [];  
    for i in range(0,batch_size):  
        batch_data.append(train_data[index[i]]);  
        batch_target.append(train_label[index[i]])  
    return batch_data, batch_target   


data,label = loadData()

train_data,test_data,train_label,test_label = train_test_split(data,label,test_size = 0.2,random_state=1)
print(test_label)
xs = tf.placeholder(tf.float32,[None,4])
ys = tf.placeholder(tf.float32,[None,3])

l1 = add_layer(xs, 4,8, activation_function=tf.nn.relu)
#l2 = add_layer(xs, 12,8, activation_function=tf.nn.relu)
y_  = add_layer(l1, 8, 3, activation_function=tf.nn.softmax)

loss = tf.reduce_mean(-tf.reduce_sum(ys * tf.log(y_),reduction_indices=[1])) 
train_step = tf.train.GradientDescentOptimizer(0.05).minimize(loss)


sess = tf.Session() 
sess.run(tf.initialize_all_variables())
for epoch in range(nepoch):
        for batch in range(20):
            batch_xs,batch_ys = next_batch(train_data,train_label,batch_size)
            sess.run(train_step,feed_dict={xs:batch_xs,ys:batch_ys})
            print(str(epoch) + ",accracy " + str(compute_accuracy(test_data, test_label)))

            
pre_ = sess.run(y_,feed_dict={xs:test_data})
for i in range(30):
    pre_label =np.argmax(pre_[i]) 
    real_label = np.argmax(test_label[i]) 
    print("prediction is: %d,real is: %d"%(pre_label,real_label))