首先了解下Iris鳶尾花數據集：

Iris數據集（https://en.wikipedia.org/wiki/Iris_flower_data_set）是常用的分類實驗數據集，由Fisher,1936收集整理。Iris也稱鳶尾花卉數據集，是一類多重變量分析的數據集。數據集包含150個數據集，分為3類，每類50個數據，每個數據包含4個屬性。可通過花萼長度，花萼寬度，花瓣長度，花瓣寬度4個屬性預測鳶尾花卉屬於（Setosa，Versicolour，Virginica）三個種類中的哪一類。
iris以鳶尾花的特征作為數據來源，常用在分類操作中。該數據集由3種不同類型的鳶尾花的50個樣本數據構成。其中的一個種類與另外兩個種類是線性可分離的，後兩個種類是非線性可分離的。

該數據集包含了4個屬性：
Sepal.Length（花萼長度），單位是cm;
Sepal.Width（花萼寬度），單位是cm;
Petal.Length（花瓣長度），單位是cm;
Petal.Width（花瓣寬度），單位是cm;
種類：Iris Setosa（1.山鳶尾）、Iris Versicolour（2.雜色鳶尾），以及Iris Virginica（3.維吉尼亞鳶尾）。

Python源碼：

  1 from __future__ import division
  2 import math
  3 import random
  4
 
 import pandas as pd
  5  
  6  
  7 flowerLables = {0: ‘Iris-setosa‘,
  8                 1: ‘Iris-versicolor‘,
  9                 2: ‘Iris-virginica‘}
 10  
 11 random.seed(0)
 12  
 13  
 14 # 生成區間[a, b)內的隨機數
 15 def rand(a, b):
 16     return (b - a) * random.random() + a
 17  
 18  
 19 # 生成大小 I*J 的矩陣，默認零矩陣
 

 20 def makeMatrix(I, J, fill=0.0):
 21     m = []
 22     for i in range(I):
 23         m.append([fill] * J)
 24     return m
 25  
 26  
 27 # 函數 sigmoid
 28 def sigmoid(x):
 29     return 1.0 / (1.0 + math.exp(-x))
 30  
 31  
 32 # 函數 sigmoid 的導數
 33 def dsigmoid(x):
 34     return x * (1 - x)
 35  
 36  
 37 class NN:
 38     """ 三層反向傳播神經網絡 """
 39  
 40     def __init__(self, ni, nh, no):
 41         # 輸入層、隱藏層、輸出層的節點（數）
 42         self.ni = ni + 1  # 增加一個偏差節點
 43         self.nh = nh + 1
 44         self.no = no
 45  
 46         # 激活神經網絡的所有節點（向量）
 47         self.ai = [1.0] * self.ni
 48         self.ah = [1.0] * self.nh
 49         self.ao = [1.0] * self.no
 50  
 51         # 建立權重（矩陣）
 52         self.wi = makeMatrix(self.ni, self.nh)
 53         self.wo = makeMatrix(self.nh, self.no)
 54         # 設為隨機值
 55         for i in range(self.ni):
 56             for j in range(self.nh):
 57                 self.wi[i][j] = rand(-0.2, 0.2)
 58         for j in range(self.nh):
 59             for k in range(self.no):
 60                 self.wo[j][k] = rand(-2, 2)
 61  
 62     def update(self, inputs):
 63         if len(inputs) != self.ni - 1:
 64             raise ValueError(‘與輸入層節點數不符！‘)
 65  
 66         # 激活輸入層
 67         for i in range(self.ni - 1):
 68             self.ai[i] = inputs[i]
 69  
 70         # 激活隱藏層
 71         for j in range(self.nh):
 72             sum = 0.0
 73             for i in range(self.ni):
 74                 sum = sum + self.ai[i] * self.wi[i][j]
 75             self.ah[j] = sigmoid(sum)
 76  
 77         # 激活輸出層
 78         for k in range(self.no):
 79             sum = 0.0
 80             for j in range(self.nh):
 81                 sum = sum + self.ah[j] * self.wo[j][k]
 82             self.ao[k] = sigmoid(sum)
 83  
 84         return self.ao[:]
 85  
 86     def backPropagate(self, targets, lr):
 87         """ 反向傳播 """
 88  
 89         # 計算輸出層的誤差
 90         output_deltas = [0.0] * self.no
 91         for k in range(self.no):
 92             error = targets[k] - self.ao[k]
 93             output_deltas[k] = dsigmoid(self.ao[k]) * error
 94  
 95         # 計算隱藏層的誤差
 96         hidden_deltas = [0.0] * self.nh
 97         for j in range(self.nh):
 98             error = 0.0
 99             for k in range(self.no):
100                 error = error + output_deltas[k] * self.wo[j][k]
101             hidden_deltas[j] = dsigmoid(self.ah[j]) * error
102  
103         # 更新輸出層權重
104         for j in range(self.nh):
105             for k in range(self.no):
106                 change = output_deltas[k] * self.ah[j]
107                 self.wo[j][k] = self.wo[j][k] + lr * change
108  
109         # 更新輸入層權重
110         for i in range(self.ni):
111             for j in range(self.nh):
112                 change = hidden_deltas[j] * self.ai[i]
113                 self.wi[i][j] = self.wi[i][j] + lr * change
114  
115         # 計算誤差
116         error = 0.0
117         error += 0.5 * (targets[k] - self.ao[k]) ** 2
118         return error
119  
120     def test(self, patterns):
121         count = 0
122         for p in patterns:
123             target = flowerLables[(p[1].index(1))]
124             result = self.update(p[0])
125             index = result.index(max(result))
126             print(p[0], ‘:‘, target, ‘->‘, flowerLables[index])
127             count += (target == flowerLables[index])
128         accuracy = float(count / len(patterns))
129         print(‘accuracy: %-.9f‘ % accuracy)
130  
131     def weights(self):
132         print(‘輸入層權重:‘)
133         for i in range(self.ni):
134             print(self.wi[i])
135         print()
136         print(‘輸出層權重:‘)
137         for j in range(self.nh):
138             print(self.wo[j])
139  
140     def train(self, patterns, iterations=1000, lr=0.1):
141         # lr: 學習速率(learning rate)
142         for i in range(iterations):
143             error = 0.0
144             for p in patterns:
145                 inputs = p[0]
146                 targets = p[1]
147                 self.update(inputs)
148                 error = error + self.backPropagate(targets, lr)
149             if i % 100 == 0:
150                 print(‘error: %-.9f‘ % error)
151  
152  
153  
154 def iris():
155     data = []
156     # 讀取數據
157     raw = pd.read_csv(‘iris.csv‘)
158     raw_data = raw.values
159     raw_feature = raw_data[0:, 0:4]
160     for i in range(len(raw_feature)):
161         ele = []
162         ele.append(list(raw_feature[i]))
163         if raw_data[i][4] == ‘Iris-setosa‘:
164             ele.append([1, 0, 0])
165         elif raw_data[i][4] == ‘Iris-versicolor‘:
166             ele.append([0, 1, 0])
167         else:
168             ele.append([0, 0, 1])
169         data.append(ele)
170     # 隨機排列數據
171     random.shuffle(data)
172     training = data[0:100]
173     test = data[101:]
174     nn = NN(4, 7, 3)
175     nn.train(training, iterations=10000)
176     nn.test(test)
177  
178  
179 if __name__ == ‘__main__‘:
180     iris()

BP算法實例—鳶尾花的分類（Python）