（本人最初发布于HackMD：HackMD链接，链接内容为繁体字）
1.问题描述
自定义一个MLP来学习8位奇偶校验（8BPC）问题8BPC问题是从8位（1字节）二进制输入生成单个奇偶校验位 如果二进制输入中的数字1为奇数，则生成的奇偶校验位必须为1；否则，生成的奇偶校验位必须为零。
2.产生训练数据（data和labels）
八个二进制位，一共有256种不同的组合，也就是相当于把0-256转换为二进制的形式表示，然后根据奇偶，将得到1或0的label。
#首先生成训练和测试所用的data和labels
#八个二进制位，一共有256种不同的组合，也就是相当于把0-256转换为二进制的形式表示，然后根据奇偶，将得到1或0的label
import numpy as np
def getParityBit(bitString:str) -> int:
if type(bitString) is not str:
raise TypeError('Expected str; got %s' % type(bitString))
parityBit = False
for c in bitString:
if c == '1':
parityBit = not parityBit
rel = 1 if parityBit else 0
return rel
def createDataAndLabels():
data = []
labels = []
for i in range(256):
intToBinary = '{0:08b}'.format(i)
data.append(list(map(int, intToBinary)))
labels.append([getParityBit(intToBinary)])
return (np.array(data), np.array(labels))
3.定义所用到的激活函数
#定义需要用到的激活函数，tanh，ReLU，Sigmoid
import numpy as np
class tanh:
def __init__(self):
pass
def forward(self, x):
out = np.tanh(x)
self.o = out
return out
def backward(self, dout):
dx = dout*(1.0 - self.o**2)
return dx
class ReLU:
def __init__(self):
pass
def forward(self, x):
self.mask = (x<=0)
out = x
out[out<=0] = 0
return out
def backward(self, dout):
dx = dout
dx[self.mask] = 0
return dx
class Sigmoid:
def __init__(self):
pass
def forward(self, x):
out = 1.0/(1+np.exp(-x))
self.o = out
return out
def backward(self, dout):
dx = dout*self.o*(1-self.o)
return dx
#定义loss function
class Loss:
def __init__(self):
pass
def forward(self, y, ybar):
self.y = y
self.ybar = ybar
return np.sum((y-ybar)**2)
def backward(self, dout):
dy = -(2*(self.y -self.ybar))
return dy
#该神经网络使用线性神经网络
class Linear:
def __init__(self, m, n):
self.W = np.random.randn(m, n)/8.0
self.b = np.random.rand(1, n)/8.0
self.dW, self.db = None, None
def forward(self, x):
self.x = x
out = np.dot(x, self.W)+self.b
return out
def backward(self, dout):
dx = np.dot(dout, self.W.T)
self.dW = np.dot(self.x.T, dout)
self.db = np.sum(dout, axis=0)
return dx
4.创建MLP_Model类
#定义MLP_Model类，可以用来创建模型
class MLP_Model:
def __init__(self, inDegree:int, layerType:list, outDegree):
self.degree = list(map(int, str(inDegree))) + outDegree
layerType = [x.lower() for x in layerType]
self.supportFuncTable = {
'relu' : ReLU,
'sigmoid' : Sigmoid,
'tanh' : tanh
}
self.layers = []
self.actFunctions = []
self.last_dW ,self.last_db = [], []
for i in range(len(self.degree)-1):
self.layers.append(Linear(self.degree[i], self.degree[i+1]))
self.actFunctions.append(self.supportFuncTable[layerType[i]]())
self.last_dW.append(0)
self.last_db.append(0)
self.loss = Loss()
def forward(self, x):
for i in range(len(self.layers) - 1):
x = self.layers[i].forward(x)
x = self.actFunctions[i].forward(x)
x = self.layers[-1].forward(x)
self.ybar = self.actFunctions[-1].forward(x)
return self.ybar
def backward(self, y):
self.L = self.loss.forward(y, self.ybar)
g = self.loss.backward(1)
for i in range(len(self.layers)-1, -1, -1):
g = self.actFunctions[i].backward(g)
g = self.layers[i].backward(g)
def update(self, eta, alpha):
for i in range(len(self.layers)):
self.layers[i].W += -eta*self.layers[i].dW + alpha*self.last_dW[i]
self.layers[i].b += -eta*self.layers[i].db + alpha*self.last_db[i]
self.last_dW[i] = eta*self.layers[i].dW
self.last_db[i] = eta*self.layers[i].db
#predict方法用来预测结果
def predict(self, x):
self.forward(x)
return np.array([1]) if model.ybar > 0.5 else np.array([0])
5.创建并训练模型
使用刚才定义的createDataAndLabels函数，产生data和labels
Data, Labels = createDataAndLabels()
①使用两层神经网（ReLU+Sigmoid）
先创建一个具有一个Relu层和一个sigmoid层的模型
#定义模型model，每一笔data的维度为8，第一层的激活函数为relu，然后是sigmoid得到一个数值，也就是输出
model = MLP_Model(8,
['relu', 'sigmoid'],
[100, 1])
#设置eta和alpha为0.001和0.0001
eta, alpha = 0.001, 0.0001
#将epochs设置为20000，每隔100个epochs显示一次
max_epochs, check_epochs = 20000, 100
printPointOfEporch = []
printPointOfLoss = []
for e in range(max_epochs):
model.forward(Data)
model.backward(Labels)
model.update(eta, alpha)
#每隔100个epochs显示一次loss
if (e+1) % check_epochs == 0:
print('epoch:{0:2d}------loss:{1:2.4f}'.format(e+1, model.L))
printPointOfEporch.append(e), printPointOfLoss.append(model.L)
打印训练过程
#打印训练过程
import matplotlib.pyplot as plt
import numpy as np
plt.title("only one relu layer")
#根据刚才设置的20000÷100=200个loss结果，来打印训练过程
plt.plot(printPointOfEporch, printPointOfLoss)
plt.show()
②使用三层神经网（ReLU+ReLU+Sigmoid）
创建一个具有两个ReLU层和一个Sigmoid层的模型
#定义一个三层神经网的模型
model = MLP_Model(8,
['relu', 'relu', 'sigmoid'],
[100,40,1])
#设置eta和alpha为0.001和0.0001
eta, alpha = 0.001, 0.0001
#将epochs设置为20000，每隔100个epochs显示一次
max_epochs, check_epochs = 20000, 100
printPointOfEporch = []
printPointOfLoss = []
for e in range(max_epochs):
model.forward(Data)
model.backward(Labels)
model.update(eta, alpha)
#每隔100个epochs显示一次loss
if (e+1) % check_epochs == 0:
print('epoch:{0:2d}------loss:{1:2.4f}'.format(e+1, model.L))
printPointOfEporch.append(e), printPointOfLoss.append(model.L)
打印训练过程
#打印训练过程
import matplotlib.pyplot as plt
import numpy as np
plt.title("two relu layers")
#根据刚才设置的20000÷100=200个loss结果，来打印训练过程
plt.plot(printPointOfEporch, printPointOfLoss)
plt.show()
③使用四层神经网（ReLU+ReLU+ReLU+Sigmoid）
创建具有三个ReLU层和一个Sigmoid层的模型
#定义一个四层神经网的模型
model = MLP_Model(8,
['relu', 'relu', 'relu', 'sigmoid'],
[100,70,30,1])
#设置eta和alpha为0.001和0.0001
eta, alpha = 0.001, 0.0001
#将epochs设置为20000，每隔100个epochs显示一次
max_epochs, check_epochs = 20000, 100
printPointOfEporch = []
printPointOfLoss = []
for e in range(max_epochs):
model.forward(Data)
model.backward(Labels)
model.update(eta, alpha)
#每隔100个epochs显示一次loss
if (e+1) % check_epochs == 0:
print('epoch:{0:2d}------loss:{1:2.4f}'.format(e+1, model.L))
printPointOfEporch.append(e), printPointOfLoss.append(model.L)
打印训练过程
#打印训练过程
import matplotlib.pyplot as plt
import numpy as np
plt.title("three relu layers")
#根据刚才设置的20000÷100=200个loss结果，来打印训练过程
plt.plot(printPointOfEporch, printPointOfLoss)
plt.show()
6.测试模型
#预测一下结果
model.predict([1,0,1,1,0,1,1,0])
model.predict([0,1,0,1,1,1,0,0])
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
