首页分享纯Python实现鸢尾属植物数据集神经网络模型

纯Python实现鸢尾属植物数据集神经网络模型

来源：花匠小妙招时间：2025-05-03 13:57

摘要：本文以Python代码完成整个鸾尾花图像分类任务，没有调用任何的数据包，适合新手阅读理解，并动手实践体验下机器学习方法的大致流程。

尝试使用过各大公司推出的植物识别APP吗？比如微软识花、花伴侣等这些APP。当你看到一朵不知道学名的花时，只需要打开植物识别APP，拍摄一张你所想辨认的植物照片并上传，APP会自动识别出该花的品种及详细介绍，感觉手机中装了一个知识渊博的生物学家，是不是很神奇？其实，背后的原理很简单，是一个图像分类的过程，将上传的图像与手机中预存的数据集或联网数据进行匹配，将其分类到对应的类别即可。随着深度学习方法的应用，图像分类的精度越来越高，在部分数据集上已经超越了人眼的能力。
相对于传统神经网络的方法而言，深度学习方法一般对数据集规模、硬件平台有着比较高的要求，如果只是单纯的想尝试了解图像分类任务的基本流程，建议采用小数据集样本及传统的神经网络方法实现。本文将带领读者采用鸢尾属植物数据集（Iris Data Set）来实现一个分类任务，整个鸢尾属植物数据集是机器学习中历史悠久的数据集，比现在常用的数字手写体数据集（Mnist Data Set）数据集还要早得多，该数据集来源于英国著名的统计学家、生物学家Ronald Fiser。本文在不使用相关软件库的情况下，从头开始构建针对鸢尾属植物数据的神经网络模型，对其进行训练并获得好的结果。

鸢尾属植物数据集是用于测试机器学习算法的最常用数据集。该数据包含四种特征，萼片长度、萼片宽度、花瓣长度和花瓣宽度，用于鸢尾属植物的不同物种（versicolor, virginica和setosa）。此外，每个物种有50个实例（数据行），下面让我们看看样本数据分布情况。

我们将在这个数据集上使用神经网络构建分类模型。为了简单起见，使用花瓣长度和花瓣宽度作为特征，且只有两类物种：versicolor和virginica。下面就让我们在Python中逐步训练针对该样本数据集的神经网络：

步骤1：准备鸢尾属植物数据集

将Iris数据集导入python并对数据进行子集划分以保留行之间的相关性：

#import libraries

import os

import pandas as pd

#Set working directory and load data

os.chdir('C:UsersrohanDocumentsAnalyticsData')

iris = pd.read_csv('iris.csv')

#Create numeric classes for species (0,1,2)

iris.loc[iris['Name']=='virginica','species']=0

iris.loc[iris['Name']=='versicolor','species']=1

iris.loc[iris['Name']=='setosa','species'] = 2

iris = iris[iris['species']!=2]

#Create Input and Output columns

X = iris[['PetalLength', 'PetalWidth']].values.T

Y = iris[['species']].values.T

Y = Y.astype('uint8')

#Make a scatter plot

plt.scatter(X[0, :], X[1, :], c=Y[0,:], s=40, cmap=plt.cm.Spectral);

plt.title("IRIS DATA | Blue - Versicolor, Red - Virginica ")

plt.xlabel('Petal Length')

plt.ylabel('Petal Width')

plt.show()

蓝色点代表Versicolor物种，红色点代表Virginica物种。本文构建的神经网络将在这些数据上进行训练，以期最后能正确地分类物种。

步骤2：初始化参数（权重和偏置）

下面构建一个具有单个隐藏层的神经网络。此外，将隐藏图层的大小设置为6：

def initialize_parameters(n_x, n_h, n_y):

np.random.seed(2) # we set up a seed so that our

output matches ours although the initialization is random.

W1 = np.random.randn(n_h, n_x) * 0.01 #weight matrix of shape (n_h, n_x)

b1 = np.zeros(shape=(n_h, 1)) #bias vector of shape (n_h, 1)

W2 = np.random.randn(n_y, n_h) * 0.01 #weight matrix of shape (n_y, n_h)

b2 = np.zeros(shape=(n_y, 1)) #bias vector of shape (n_y, 1)

#store parameters into a dictionary

parameters = {"W1": W1,

"b1": b1,

"W2": W2,

"b2": b2}

return parameters

步骤3：前向传播（forward propagation）

在前向传播过程中，使用tanh激活函数作为第一层的激活函数，使用sigmoid激活函数作为第二层的激活函数：

def forward_propagation(X, parameters):

#retrieve intialized parameters from dictionary

W1 = parameters['W1']

b1 = parameters['b1']

W2 = parameters['W2']

b2 = parameters['b2']

# Implement Forward Propagation to calculate A2 (probability)

Z1 = np.dot(W1, X) + b1

A1 = np.tanh(Z1) #tanh activation function

Z2 = np.dot(W2, A1) + b2

A2 = 1/(1+np.exp(-Z2)) #sigmoid activation function

cache = {"Z1": Z1,

"A1": A1,

"Z2": Z2,

"A2": A2}

return A2, cache

步骤4：计算代价函数（cost function）

目标是使得计算的代价函数小化，本文采用交叉熵（cross-entropy）作为代价函数：

def compute_cost(A2, Y, parameters):

m = Y.shape[1] # number of training examples

# Retrieve W1 and W2 from parameters

W1 = parameters['W1']

W2 = parameters['W2']

# Compute the cross-entropy cost

logprobs = np.multiply(np.log(A2), Y) + np.multiply((1 - Y), np.log(1 - A2))

cost = - np.sum(logprobs) / m

return cost

步骤5：反向传播（back propagation）

计算反向传播过程，主要是计算代价函数的导数：

def backward_propagation(parameters, cache, X, Y):

# Number of training examples

m = X.shape[1]

# First, retrieve W1 and W2 from the dictionary "parameters".

W1 = parameters['W1']

W2 = parameters['W2']

### END CODE HERE ###

# Retrieve A1 and A2 from dictionary "cache".

A1 = cache['A1']

A2 = cache['A2']

# Backward propagation: calculate dW1, db1, dW2, db2.

dZ2= A2 - Y

dW2 = (1 / m) * np.dot(dZ2, A1.T)

db2 = (1 / m) * np.sum(dZ2, axis=1, keepdims=True)

dZ1 = np.multiply(np.dot(W2.T, dZ2), 1 - np.power(A1, 2))

dW1 = (1 / m) * np.dot(dZ1, X.T)

db1 = (1 / m) * np.sum(dZ1, axis=1, keepdims=True)

grads = {"dW1": dW1,

"db1": db1,

"dW2": dW2,

"db2": db2}

return grads

步骤6：更新参数

使用反向传播过程中计算的梯度来更新权重和偏置：

def update_parameters(parameters, grads, learning_rate=1.2):

# Retrieve each parameter from the dictionary "parameters"

W1 = parameters['W1']

b1 = parameters['b1']

W2 = parameters['W2']

b2 = parameters['b2']

# Retrieve each gradient from the dictionary "grads"

dW1 = grads['dW1']

db1 = grads['db1']

dW2 = grads['dW2']

db2 = grads['db2']

# Update rule for each parameter

W1 = W1 - learning_rate * dW1

b1 = b1 - learning_rate * db1

W2 = W2 - learning_rate * dW2

b2 = b2 - learning_rate * db2

parameters = {"W1": W1,

"b1": b1,

"W2": W2,

"b2": b2}

return parameters

步骤7：建立神经网络

将以上所有函数组合起来以创建设计的神经网络模型。总而言之，下面是模型函数的整体顺序：

初始化参数前向传播计算代价函数反向传播更新参数

def nn_model(X, Y, n_h, num_iterations=10000, print_cost=False):

np.random.seed(3)

n_x = layer_sizes(X, Y)[0]

n_y = layer_sizes(X, Y)[2]

# Initialize parameters, then retrieve W1, b1, W2, b2. Inputs: "n_x, n_h, n_y".

Outputs = "W1, b1, W2, b2, parameters".

parameters = initialize_parameters(n_x, n_h, n_y)

W1 = parameters['W1']

b1 = parameters['b1']

W2 = parameters['W2']

b2 = parameters['b2']

# Loop (gradient descent)

for i in range(0, num_iterations):

# Forward propagation. Inputs: "X, parameters". Outputs: "A2, cache".

A2, cache = forward_propagation(X, parameters)

# Cost function. Inputs: "A2, Y, parameters". Outputs: "cost".

cost = compute_cost(A2, Y, parameters)

# Backpropagation. Inputs: "parameters, cache, X, Y". Outputs: "grads".

grads = backward_propagation(parameters, cache, X, Y)

# Gradient descent parameter update. Inputs: "parameters, grads". Outputs: "parameters".

parameters = update_parameters(parameters, grads)

### END CODE HERE ###

# Print the cost every 1000 iterations

if print_cost and i % 1000 == 0:

print ("Cost after iteration %i: %f" % (i, cost))

return parameters,n_h

步骤8：跑动模型

将隐藏层节点设置为6，最大迭代次数设置为10,000次，并每隔1000次打印出训练的结果：

parameters = nn_model(X,Y , n_h = 6, num_iterations=10000, print_cost=True)

步骤9：画出分类边界

def plot_decision_boundary(model, X, y):

# Set min and max values and give it some padding

x_min, x_max = X[0, :].min() - 0.25, X[0, :].max() + 0.25

y_min, y_max = X[1, :].min() - 0.25, X[1, :].max() + 0.25

h = 0.01

# Generate a grid of points with distance h between them

xx, yy = np.meshgrid(np.arange(x_min, x_max, h), np.arange(y_min, y_max, h))

# Predict the function value for the whole grid

Z = model(np.c_[xx.ravel(), yy.ravel()])

Z = Z.reshape(xx.shape)

# Plot the contour and training examples

plt.contourf(xx, yy, Z, cmap=plt.cm.Spectral)

plt.ylabel('x2')

plt.xlabel('x1')

plt.scatter(X[0, :], X[1, :], c=y, cmap=plt.cm.Spectral)

plot_decision_boundary(lambda x: predict(parameters, x.T), X, Y[0,:])

plt.title("Decision Boundary for hidden layer size " + str(6))

plt.xlabel('Petal Length')

plt.ylabel('Petal Width')

从图中可以观察到，只有四个点被错误分类。虽然我们可以调整模型来进一步地提高模型训练精度，但该些操作显然会导致过拟合现象的出现。

资源

https://www.coursera.org/specializations/deep-learning

数十款阿里云产品限时折扣中，赶紧点击领劵开始云上实践吧！

作者信息

Rohan Joseph，数据科学家
个人主页：https://www.linkedin.com/in/rohan-joseph-b39a86aa/
本文由阿里云云栖社区组织翻译。
文章原标题《Neural network on iris data》，译者：海棠，审校：Uncle_LLD。
文章为简译，更为详细的内容，请查看原文。

原文链接