[人工智能]利用python基础神经网络来实现鸢尾花的分类（AI人工智能，tensorflow插入tensorflow图片）

配置环境

在开始正式学习tensorflow时，我们需要先配置好相应的环境。
如果大家电脑上装有Anaconda我们可以直接在pycharm中安装tensorflow,pandas,sklearn，matplotlib等软件包。
如果有人没有使用Pycharm，大家也可以直接在cmd中下载，例如Tensorflow下载方式就是在cmd中输入pip install tensorflow==2.1

开始编写

这里我们需要先导入我们需要用到的软件包：

import matplotlib.pyplot as plt
import pandas as pd
from sklearn import datasets
from pandas import DataFrame
import tensorflow as tf
import numpy as np

然后大家需要了解一下鸢尾花的数据集在Python中的表达式为iris，在接下来的程序中我们会使用到。
首先我们将鸢尾花的输入特征和标签数据导入出来，操作如下：

x_data=datasets.load_iris().data
y_data=datasets.load_iris().target

然后为了获得更好的测试效果，我们需要将训练集打乱：

np.random.seed(116)
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)

这里的np.random.seed(116)，其实是假乱序，如果使用的是相同的seed值，表明种子数相同，那么产生的随机数也相同。
也可以这么说：np.random.seed()函数用于生成指定的随机数。

当seed()确定后，np,random.random()可以按顺序产生一组固定的数组，如果使用相同的seed()值，则每次生成的随机数都相同，如果不设置这个值，那么每次生成的随机数不同。但是，只在调用的时候seed()一下并不能使生成的随机数相同，需要每次调用都seed()一下，表示种子相同，从而生成的随机数相同。
这里就是在每次使用的时候都对seed进行一个相同的赋值，这样就时产生的随机数都想同，这样做的目的是保证了我们的测试结果一样，如果不一样，就是其他地方错了，当然实际应用时我们一般不这样做，这样做的话时假随机，较大概率无法得到最优值

这里需要将这150个数据集分为永不相见的训练集和测试集
这里我提一下，我认为如果有测试集在训练集中，那么这个测试结果已经确定了，这个结果就是训练集中所对应的结果。

然后转换x的数据类型，否则矩阵乘时会报错

x_train=tf.cast(x_train,tf.float32)
x_test=tf.cast(x_test,tf.float32)

from_tensor_slices使输入特征和标签值一一对应。（把数据集分批次的进行测试，每个批次为batch组的数据。每32个数据分为一个batch）

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)

然后生成神经网络参数，有四个输入特征，故有4个输入节点，因为分3类，则有三个神经元。

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,seed=1))
lr=0.1#学习率
train_loss_results=[]#记录每轮loss值，为后续话loss图形提供数据
test_acc=[]#记录每轮acc值，为后续话acc图形提供数据
epoch=500#循环500轮
loss_all=0

这里的训练神经元和测试结果下次再细讲，我先把大致的代码和解释写出来，感兴趣的话可以先看一下。

训练神经元：

这里我们在使用训练集中的数据时，需要先把它定义为可训练的才能进行下面的操作

for epoch in range(epoch):
    for step,(x_train,y_train) in enumerate(train_db):
        with tf.GradientTape() as tape:
            y=tf.matmul(x_train,w1)+b1
            y=tf.nn.softmax(y)
            y_=tf.one_hot(y_train,depth=3)#这里用到了独热码
            loss = tf.reduce_mean(tf.square(y_-y))
            loss_all +=loss.numpy()

        grads=tape.gradient(loss,[w1,b1])

        w1.assign_sub(lr * grads[0])
        b1.assign_sub(lr * grads[1])

    print("Epoch{}, Loss{}".format(epoch,loss_all/4))
    train_loss_results.append(loss_all/4)
    loss_all=0#归零，为计算下一个loss值作准备

测试部分：

total_correct,total_number=0,0
            for x_test,y_test in test_db:
                y = tf.matmul(x_test, w1) + b1
                y = tf.nn.softmax(y)
                pred=tf.argmax(y,axis=1)
                pred=tf.cast(pred,dtype=tf.int32)
                correct=tf.cast(tf.equal(pred,y_test),dtype=tf.int32)
                correct=tf.reduce_sum(correct)
                total_correct +=int(correct)
                total_number +=x_test.shape[0]
                acc=total_correct/total_number
                test_acc.append(acc)
                print("Test_acc",acc)

loss图像部分：

plt.title("Loss")
plt.xlabel("epoch")
plt.ylabel("loss")
plt.plot(train_loss_results,label="$loss$")
plt.legend()
plt.show()

acc图像格式和loss图像格式一样 ，就不写了。

源代码：

# -*- coding =utf-8 -*-
# @Time :2022/7/3 19:30
# @Author :CHINA
# @File :AI.py
# @software:PyCharm
import matplotlib.pyplot as plt
import pandas as pd
from sklearn import datasets
from pandas import DataFrame
import tensorflow as tf
import numpy as np
x_data=datasets.load_iris().data
y_data=datasets.load_iris().target

np.random.seed(116)
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)

x_train=x_data[:-30]
y_train=y_data[:-30]
x_test=x_data[-30:]
y_test=y_data[-30:]
#转换x的数据类型，否则矩阵乘时会报错

x_train=tf.cast(x_train,tf.float32)
x_test=tf.cast(x_test,tf.float32)

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)

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,seed=1))
lr=0.1#学习率
train_loss_results=[]#记录每轮loss值，为后续话loss图形提供数据
test_acc=[]#记录每轮acc值，为后续话acc图形提供数据
epoch=500#循环500轮
loss_all=0

#训练神经网络

```python
for epoch in range(epoch):
    for step,(x_train,y_train) in enumerate(train_db):
        with tf.GradientTape() as tape:
            y=tf.matmul(x_train,w1)+b1
            y=tf.nn.softmax(y)
            y_=tf.one_hot(y_train,depth=3)
            loss = tf.reduce_mean(tf.square(y_-y))
            loss_all +=loss.numpy()

        grads=tape.gradient(loss,[w1,b1])

        w1.assign_sub(lr * grads[0])
        b1.assign_sub(lr * grads[1])

    print("Epoch{}, Loss{}".format(epoch,loss_all/4))
    train_loss_results.append(loss_all/4)
    loss_all=0

测试集结果：

total_correct,total_number=0,0
    for x_test,y_test in test_db:
        y = tf.matmul(x_test, w1) + b1
        y = tf.nn.softmax(y)
        pred=tf.argmax(y,axis=1)
        pred=tf.cast(pred,dtype=tf.int32)
        correct=tf.cast(tf.equal(pred,y_test),dtype=tf.int32)
        correct=tf.reduce_sum(correct)
        total_correct +=int(correct)
        total_number +=x_test.shape[0]
        acc=total_correct/total_number
        test_acc.append(acc)
        print("Test_acc",acc)

输出loss图像
acc和loss格式相同，这里只写loss了

plt.title("Loss")
plt.xlabel("epoch")
plt.ylabel("loss")
plt.plot(train_loss_results,label="$loss$")
plt.legend()
plt.show()

源代码:

# -*- coding =utf-8 -*-
# @Time :2022/7/3 19:30
# @Author :CHINA
# @File :神经网络.py
# @software:PyCharm
import matplotlib.pyplot as plt
import pandas as pd
from sklearn import datasets
from pandas import DataFrame
import tensorflow as tf
import numpy as np

x_data=datasets.load_iris().data
y_data=datasets.load_iris().target

np.random.seed(116)
np.random.shuffle(x_data)
np.random.seed(116)
np.random.shuffle(y_data)
tf.random.set_seed(116)

x_train=x_data[:-30]
y_train=y_data[:-30]
x_test=x_data[-30:]
y_test=y_data[-30:]
#转换x的数据类型，否则矩阵乘时会报错

x_train=tf.cast(x_train,tf.float32)
x_test=tf.cast(x_test,tf.float32)

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)

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,seed=1))
lr=0.1#学习率
train_loss_results=[]#记录每轮loss值，为后续话loss图形提供数据
test_acc=[]#记录每轮acc值，为后续话acc图形提供数据
epoch=500#循环500轮
loss_all=0

#训练神经网络
for epoch in range(epoch):
    for step,(x_train,y_train) in enumerate(train_db):
        with tf.GradientTape() as tape:
            y=tf.matmul(x_train,w1)+b1
            y=tf.nn.softmax(y)
            y_=tf.one_hot(y_train,depth=3)
            loss = tf.reduce_mean(tf.square(y_-y))
            loss_all +=loss.numpy()

        grads=tape.gradient(loss,[w1,b1])

        w1.assign_sub(lr * grads[0])
        b1.assign_sub(lr * grads[1])

    print("Epoch{}, Loss{}".format(epoch,loss_all/4))
    train_loss_results.append(loss_all/4)
    loss_all=0

    total_correct,total_number=0,0
    for x_test,y_test in test_db:
        y = tf.matmul(x_test, w1) + b1
        y = tf.nn.softmax(y)
        pred=tf.argmax(y,axis=1)
        pred=tf.cast(pred,dtype=tf.int32)
        correct=tf.cast(tf.equal(pred,y_test),dtype=tf.int32)
        correct=tf.reduce_sum(correct)
        total_correct +=int(correct)
        total_number +=x_test.shape[0]
        acc=total_correct/total_number
        test_acc.append(acc)
        print("Test_acc",acc)

plt.title("Loss")
plt.xlabel("epoch")
plt.ylabel("loss")
plt.plot(train_loss_results,label="$loss$")
plt.legend()
plt.show()