简 介： 对于MATLAB中的SimpleClass数据集合，对比了BP,RBF,SVM,SOFM,DHNN 等方法分类结果，可以看到BP，RBF，SVM，SOFM都具有非常好的分类效果。DHNN对于这样的问题处理能力非常差。

关键词： BF，SVM，MATLAB

§01 作业总体要求

1.1 作业要求

  根据 2021年人工神经网络第四次作业要求 中的要求，第七题要求对于来自于MATLAB中的六个用于分类的题目，尝试BP、RBF、SVM、SOM、DHNN网络进行分裂。这六个数据集合分别为：

*  simpleclass_dataset
*  iris_dataset
*  cancer_dataset
*  thynoid_dataset
*  glass_dataset
*  wine_dataset

1.2 数据集合

  上述数据集合都可以很方便在MATLAB环境里进行调入。如果不适用MATLAB完成作业，比如使用Python语言来实现算法，则需要重新寻找这些数据集合来源。

1.2.1 dataset

  这个数据集合可以使用 应用在机器学习中的聚类数据集产生方法 中的点簇形数据集产生改数据集合。

▲ 图1.2.1 SimpleClass_dataset

  借助于sklear.datasets中的 make_blobs 函数，可以产生不通中心分布的随机点簇。

（1）产生数据集合

x,y = make_blobs(n_samples = 2000, n_features=2,centers=[(0,0), (0, 1), (1,0), (1,1)],cluster_std=0.15,random_state=0)print("len(x): {}".format(len(x)), "len(y): {}".format(len(y)))plt.figure(figsize=(10,10))
plt.scatter(x[:,0],x[:,1], marker='+')
plt.show()

▲ 图1.2.4 利用sklearn_datasets产生数据

x,y = make_blobs(n_samples = 2000, n_features=2,centers=[(0,0), (0, 1), (1,0), (1,1)],cluster_std=0.15)print("len(x): {}".format(len(x)), "len(y): {}".format(len(y)))

1.2.2 Dataset

  在 GIthub Gist iris Dataset 直接给出了数据的数据。

  原始的数据可以在 Iris Data Set 下载。

▲ IRIS Dataset

• iris.data : https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.data
• iris.names : https://archive.ics.uci.edu/ml/machine-learning-databases/iris/iris.names

  在 The Iris Dataset? 回执了Iris数据分布。

▲ 图1.2.4 Iris数据3D视图

▲ 图1.2.5 Sepal Length yu Sepal Width 分布

§02 简单数据

  下面基于simpleclass_dataset，对比不同分类方法的方案。

2.1 BP算法

2.1.1 数据产生

  使用sklearn_dataset的make_blobs产生所需要的数据集合。

（1）产生2000训练样本

import sys,os,math,time
import matplotlib.pyplot as plt
from numpy import *from sklearn.datasets        import make_blobsx,y = make_blobs(n_samples = 2000, n_features=2,centers=[(0,0), (0, 1), (1,0), (1,1)],cluster_std=0.15,random_state=0)yset = list(set(y))
print("yset: {}".format(yset), "len(y): {}".format(len(y)))

yset: [0, 1, 2, 3]
len(y): 2000

（2）观察数据

plt.figure(figsize=(10,10))
colors = ['red', 'blue', 'green', 'cyan']
for id in yset:data = x[where(y==id)]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')

▲ 图4.1.1 测试数据分布

2.1.2 构建数据加载函数

import paddleclass Dataset(paddle.io.Dataset):def __init__(self, num_samples):super(Dataset, self).__init__()self.num_samples = num_samplesdef __getitem__(self, index):data = array(x[index])label = array([y[index]])return paddle.to_tensor(data,dtype='float32'), paddle.to_tensor(label,dtype='int64')def __len__(self):return self.num_samples_dataset = Dataset(len(x))
train_loader = paddle.io.DataLoader(_dataset, batch_size=10, shuffle=True)x,y = train_loader().next()
print("x: {}".format(x),"y: {}".format(y))

x: Tensor(shape=[10, 2], dtype=float32, place=CPUPlace, stop_gradient=True,[[-0.36563465,  1.16723871],[ 0.86872679, -0.08902805],[ 0.95345336,  1.01571321],[ 1.00709569,  1.03594363],[ 0.94699496,  1.11144269],[-0.22535948, -0.26665005],[-0.17097037,  0.11774363],[ 0.06393881,  0.10153621],[-0.07542250,  0.36186805],[-0.15472236,  0.78550130]])
y: Tensor(shape=[10, 1], dtype=int64, place=CPUPlace, stop_gradient=True,[[1],[2],[3],[3],[3],[0],[0],[0],[0],[1]])

2.1.3 构建BP网络

  利用paddle构建单隐层BP网络。

class bpnet(paddle.nn.Layer):def __init__(self, ):super(bpnet, self).__init__()self.L1 = paddle.nn.Linear(in_features=2, out_features=10)self.L2 = paddle.nn.Linear(in_features=10, out_features=4)def forward(self, x):x = self.L1(x)x = paddle.nn.functional.sigmoid(x)x = self.L2(x)return xmodel = bpnet()
paddle.summary(model, (10,2))

---------------------------------------------------------------------------Layer (type)       Input Shape          Output Shape         Param #
===========================================================================Linear-9          [[10, 2]]             [10, 10]             30       Linear-10         [[10, 10]]            [10, 4]              44
===========================================================================
Total params: 74
Trainable params: 74
Non-trainable params: 0
---------------------------------------------------------------------------
Input size (MB): 0.00
Forward/backward pass size (MB): 0.00
Params size (MB): 0.00
Estimated Total Size (MB): 0.00
---------------------------------------------------------------------------

2.1.4 训练网络

optimizer = paddle.optimizer.Adam(learning_rate=0.05, parameters=model.parameters())
def train(model):model.train()epochs = 100accdim = []lossdim = []for epoch in range(epochs):for batch, data in enumerate(train_loader()):out = model(data[0])loss = paddle.nn.functional.cross_entropy(out, data[1])acc = paddle.metric.accuracy(out, data[1])loss.backward()optimizer.step()optimizer.clear_grad()accdim.append(acc.numpy())lossdim.append(loss.numpy())if epoch%20==0 and epoch > 0:print('Epoch:{}, Loss:{}, Accuracys:{}'.format(epoch, loss.numpy(), acc.numpy()))plt.figure(figsize=(10, 6))plt.plot(accdim, label='Accuracy')plt.plot(lossdim, label='Loss')plt.xlabel('Step')plt.ylabel('Acc,Loss')plt.grid(True)plt.legend(loc='upper left')plt.tight_layout()plt.show()train(model)

▲ 图4.1.2 Lr=0.05, Epochs=100训练精度和损失函数

▲ 图4.1.3 Lr=0.1, Epochs=100训练精度和损失函数

2.1.5 观察分类界面

from paddle import to_tensor as TTGRID_NUM = 300
axisgrid = linspace(-0.75, 1.75, GRID_NUM)
gridxy = array([(a,b) for b in axisgrid for a in axisgrid])predict = model(TT(gridxy, dtype='float32'))
target = paddle.fluid.layers.argmax(predict, axis=1).numpy()
print("target: {}".format(target))plt.figure(figsize=(10,10))
colors = ['yellow', 'cyan', 'brown', 'black']
for id in yset:data = gridxy[where(target==id)]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')colors = ['red', 'blue', 'green', 'cyan']
for id in yset:data = x[where(y==id)]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')

▲ 图2.1.5 网络分类界面

2.1.6 动图展示训练边界变化

（1）01

▲ 图2.1.5 一百次训练步骤对应的Loss和Accuracy变化

▲ 图2.1.6 训练过程中分类边界的变化

gifpath = '/home/aistudio/GIF'
filedim = os.listdir(gifpath)
for f in filedim:fn = os.path.join(gifpath, f)if os.path.isfile(fn):os.remove(fn)axisgrid = linspace(-0.75, 1.75, GRID_NUM)
gridxy = array([(a,b) for b in axisgrid for a in axisgrid])optimizer = paddle.optimizer.Adam(learning_rate=0.01, parameters=model.parameters())def train(model):model.train()epochs = 5accdim = []lossdim = []count = 0for epoch in range(epochs):for batch, data in enumerate(train_loader()):out = model(data[0])loss = paddle.nn.functional.cross_entropy(out, data[1])acc = paddle.metric.accuracy(out, data[1])loss.backward()optimizer.step()optimizer.clear_grad()accdim.append(acc.numpy())lossdim.append(loss.numpy())predict = model(paddle.to_tensor(gridxy, dtype='float32'))target = paddle.fluid.layers.argmax(predict, axis=1).numpy()plt.figure(figsize=(10,10))colors = ['yellow', 'cyan', 'brown', 'black']for id in yset:data = gridxy[where(target==id)]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')colors = ['red', 'blue', 'green', 'cyan']for id in yset:data = x[where(y==id)]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')savefile = os.path.join(gifpath, '%03d.jpg'%count)plt.savefig(savefile)count += 1if epoch%20==0 and epoch > 0:print('Epoch:{}, Loss:{}, Accuracys:{}'.format(epoch, loss.numpy(), acc.numpy()))plt.figure(figsize=(10, 6))plt.plot(accdim, label='Accuracy')plt.plot(lossdim, label='Loss')plt.xlabel('Step')plt.ylabel('Acc,Loss')plt.grid(True)plt.legend(loc='upper left')plt.tight_layout()plt.show()train(model)

（2）1

▲ 图2.1.7 一百次训练步骤对应的Loss和Accuracy变化
▲ 图2.1.8 训练过程中分类边界线的变化

2.2 RBF算法

2.2.1 准备数据集合

  这个过程与BP算法是相通的。

import sys,os,math,time
import matplotlib.pyplot as plt
from numpy import *from sklearn.datasets        import make_blobsx,y = make_blobs(n_samples = 2000, n_features=2,centers=[(0,0), (0, 1), (1,0), (1,1)],cluster_std=0.15,random_state=0)yset = list(set(y))
print("yset: {}".format(yset), "len(y): {}".format(len(y)))plt.figure(figsize=(10,10))
colors = ['red', 'blue', 'green', 'cyan']
for id in yset:data = x[where(y==id)]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')

2.2.2 启发式设计隐层节点

（1）隐层节点个数与方差

RBF网络参数：

隐层节点个数：20
方差：0.5

（2）K均值聚类产生径向基中心

  初始化采用从样本中随机抽取20个节点作为中心的初始值。

K均值聚类参数：

学习速率：0.01
迭代步骤：50

▲ 图2.2.2 K均值聚类产生径向基函数中心节点

def k_mean_step(x, ratio, center):for xx in x:dist = [(xx-c).T.dot(xx-c) for c in center]id = where(dist==min(dist))[0][0]center[id] = (xx - center[id]) * ratio + center[id]return center

def drawpoint(x, y, c):plt.figure(figsize=(10,10))colors = ['red', 'blue', 'green', 'cyan']for id in range(4):data = x[where(y==id)]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')plt.scatter(rbf_center[:,0], rbf_center[:,1], color='purple', marker='o', s=100)plt.axis([-0.75,1.75,-0.75,1.75])

gifpath = '/home/aistudio/GIF'
filedim = os.listdir(gifpath)
for f in filedim:fn = os.path.join(gifpath, f)if os.path.isfile(fn):os.remove(fn)rbf_center = array([x[i].tolist() for i in randindex[:RBF_NODE_NUM]])
for i in range(50):rbf_center = k_mean_step(x, 0.01, rbf_center)drawpoint(x, y, rbf_center)plt.title('Step:%d'%(i+1))savefile = os.path.join(gifpath, '%03d.jpg'%i)plt.savefig(savefile)

（3）求解隐层到输出层权系数

  利用计算伪逆的方法求解隐层到输出层的权系数。

def rbfout(xx, center, delta):out = [exp(-d.T.dot(d)/delta) for d in xx-center]return outG = array([rbfout(xxx, rbf_center, RBF_DELTA) for xxx in x])def onehot(d,id):dim = [0]*ddim[id] = 1return dimY = array([onehot(4,i) for i in y])
print(G.shape, Y.shape)

W = linalg.inv(G.T.dot(G)).dot(G.T).dot(Y)
print("W.shape: {}".format(W.shape))
print("W: {}".format(W))

（4）测试网络

rbfo = array(rbfout(x[0], rbf_center, RBF_DELTA))predict = [array(rbfout(x[i], rbf_center, RBF_DELTA)).dot(W) for i in range(len(x))]
target = [where(x==max(x))[0][0] for x in predict]
print("predict[:10]: {}".format(predict[:10]))
print("target[:10]: {}".format(target[:10]))
print("y[:10].tolist(): {}".format(y[:10].tolist()))errorid = where(array(target) != y)[0][0]
print(errorid)
print("target[errorid]: {}".format(target[errorid]), "y[errorid]: {}".format(y[errorid]))

（5）分类界限

GRID_NUM = 300axisgrid = linspace(-0.75, 1.75, GRID_NUM)
gridxy = array([(a,b) for b in axisgrid for a in axisgrid])predict = [array(rbfout(i, rbf_center, RBF_DELTA)).dot(W) for i in gridxy]
target = array([where(x==max(x))[0][0] for x in predict])plt.figure(figsize=(10,10))
colors = ['yellow', 'cyan', 'brown', 'black']
plt.axis([-0.75,1.75,-0.75,1.75])for id in range(4):data = gridxy[where(target==id)[0]]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')colors = ['red', 'blue', 'green', 'cyan']
for id in range(4):data = x[where(y==id)]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')

▲ 图2.2.2 RBF分类界限

（6）改变中间隐层方差

 Ⅰ.01

▲ 图2.2.3 隐层的方差：0.01 对应的分界面

 Ⅱ.001

▲ 图2.2.4 隐层的方差：0.001 对应的分界面

 Ⅲ.0

▲ 图2.2.5 隐层的方差：1.0 对应的分界面

 Ⅳ.0

▲ 图2.2.6 隐层的方差：10.0 对应的分界面

2.3 SVM算法

  本质上将，如果在SVM中选择核函数为RBF，那么它的分类效果与RBF网络是相同的。

  根据 机器学习——支持向量机SVM之python实现简单实例一（含数据预处理、交叉验证、参数优化等） 介绍的方法逐步进行分类器的搭建。

2.3.1 构建数据

x,y = make_blobs(n_samples = 2000, n_features=2,centers=[(0,0), (0, 1), (1,0), (1,1)],cluster_std=0.15,random_state=0)yset = list(set(y))plt.figure(figsize=(10,10))
colors = ['red', 'blue', 'green', 'cyan']
for id in yset:data = x[where(y==id)]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')

2.3.2 建立SVM

import sys,os,math,time
import matplotlib.pyplot as plt
from numpy import *from sklearn.datasets        import make_blobs
from sklearn                import svm

classifier = svm.SVC(C=1, kernel='rbf', gamma=10, decision_function_shape='ovr')
classifier.fit(x, y)

2.3.3 测试SVM

classifier.score(x, y)

0.9995

2.3.4 观察分类界面

print(classifier.score(x, y))

▲ 图2.3.1 分类界面

▲ 图2.3.2 Gamma=0.1对应的分类界限

▲ 图2.3.3 Gamma=100 对应的分类界限

2.4 SOFM算法

  在SOFM算法中，如果采用WTA（胜者为王）算法，也就是邻域半径等于0，实际上就退化成竞争算法。其中的效果与RBF算法过程中，隐层节点通过K-均值进行聚类的效果一样。

  由于是出分类问题，对于SOFM算法，使用一维的拓扑结构就可以满足要求。

2.4.1 SOFM参数

设定SOFM的参数为：

神经元节点个数：20
拓扑结构：一维

  训练参数：采用收敛半径r=1，循环1000次；
  初始化方法：使用样本点对于SOFM的神经元进行初始化。

2.4.2 SOFM实现代码

（1）数据产生

import sys,os,math,time
import matplotlib.pyplot as plt
from numpy import *from sklearn.datasets        import make_blobs
from sklearn                import svm

（2）初始化竞争神经元

SOFM_NUM        = 50randindex = list(range(len(x)))
random.shuffle(randindex)
sofm_dim = array([x[randindex[i]].tolist() for i in range(SOFM_NUM)])

（3）显示神经元位置

def drawsofm():'''drawsofm: Draw all the SOFM dotReturn: NULL'''global x,y,sofm_dimplt.figure(figsize=(10,10))colors = ['purple', 'blue', 'green', 'cyan']for id in yset:data = x[where(y==id)]plt.scatter(data[:,0], data[:,1], color=colors[id], marker='+')plt.scatter(sofm_dim[:,0], sofm_dim[:,1], color='red', s=150, marker='o')plt.plot(sofm_dim[:,0], sofm_dim[:,1], 'm', '.', '--')plt.axis([-0.75,1.75,-0.75,1.75])

（4）训练算法

def WTAid(p):global sofm_dim'''WTAid: Find theParam p: dot positionReturn: NULL'''dif = sofm_dim-pdist = [d.T.dot(d) for d in dif]return where(dist==min(dist))[0][0]def sofmtrain(id, ratio, x):global sofm_dimp = sofm_dim[id]sofm_dim[id] = p + SOFM_TRAIN_ITA * (x-p)for i in range(ratio):iidd = id+iif iidd >= SOFM_NUM:iidd -= SOFM_NUMp = sofm_dim[iidd]sofm_dim[iidd] = p + SOFM_TRAIN_ITA * (x-p)iidd = id-iif iidd < 0: iidd += SOFM_NUMp = sofm_dim[iidd]sofm_dim[iidd] = p + SOFM_TRAIN_ITA * (x-p)

  下面是采用学习半径为2， 学习速率为 0.01:。可以看到隐层节点的位置并没有太大的改变。

▲ 图2.4.1 SOFM训练过程

  下面采用学习半径为2，学习速率为0.05，此时可以看到SOFM的竞争层比较充分的符合样本的分布的。

▲ 图2.4.2 训练半径：2，学习速率：0.05
▲ 图2.4.3 竞争层节点为50，学习速率为0.05

（5）三个阶段训练

def WTAid(p):global sofm_dim'''WTAid: Find theParam p: dot positionReturn: NULL'''dif = sofm_dim-pdist = [d.T.dot(d) for d in dif]return where(dist==min(dist))[0][0]def sofmtrain(id, ratio, x):global sofm_dimp = sofm_dim[id]sofm_dim[id] = p + SOFM_TRAIN_ITA * (x-p)for i in range(ratio):iidd = id+iif iidd >= SOFM_NUM:iidd -= SOFM_NUMp = sofm_dim[iidd]sofm_dim[iidd] = p + SOFM_TRAIN_ITA * (x-p)iidd = id-iif iidd < 0: iidd += SOFM_NUMp = sofm_dim[iidd]sofm_dim[iidd] = p + SOFM_TRAIN_ITA * (x-p)

▲ 图2.4.4 分三个阶段训练

2.5 DHNN算法

  利用DNHH网络，需要将输入的数据进行离散离散表示。

2.5.1 数据离散化表示

  利用样本的两个作品(x,y)\left( {x,y} \right)(x,y)，以0.01为单位，对应的整数长度的二进制来表示样本。由于样本的坐标会存在负数，所以将原来的x，y都加上0.5，然后再对小于0的数值截取为0。

(x,y)→(⌈100⋅(x+0.5)⌉,⌈100⋅(y+0.5)⌉)\left( {x,y} \right) \to \left( {\left\lceil {100 \cdot \left( {x + 0.5} \right)} \right\rceil ,\left\lceil {100 \cdot \left( {y + 0.5} \right)} \right\rceil } \right)(x,y)→(⌈100⋅(x+0.5)⌉,⌈100⋅(y+0.5)⌉)

def value2int(x):return min(max(0,int((x+0.5)*100)),255)

  测试该函数，可以看到该函(−0.5,2.05)\left( { - 0.5,2.05} \right)(−0.5,2.05)之间的书映射到KaTeX parse error: Can't use function '\~' in math mode at position 2: 0\̲~̲255的整数。

x = linspace(-2, 5, 1000)
y = [value2int(xx) for xx in x]plt.figure(figsize=(10,8))
plt.plot(x, y)
plt.xlabel("x")
plt.ylabel("y")
plt.grid(True)
plt.tight_layout()
plt.show()

▲ 图2.5.1 取证函数传递曲线

  然后将样本两个坐标分别转换成0,1字符串，再串联在一起。

def int2bits(n):global bitmaskbits = [0 if n&b == 0 else 1 for b in bitmask]return bitsdef xypoint2bits(x,y):return int2bits(value2int(x)) + int2bits(value2int(y))

  下面对于(0.3,1)\left( {0.3,1} \right)(0.3,1)数据点进行测试。

print(xypoint2bits(0.3, 1))

[0, 0, 0, 0, 1, 0, 1, 0, 0, 1, 1, 0, 1, 0, 0, 1]

2.5.2 设计DHNN网络

  选取样本中，每一类10个样本，通过外积方法获得获得DHNN矩阵。计算过程中，将（0,1）转换成（-1,1），矩阵对角线置零。

（1）选取样本

DHNN_CLASS_NUM  = 1
dhnn_dim = []for i in range(4):id = x[where(y==i)]for iidd in id[:DHNN_CLASS_NUM]:dhnn_dim.append(iidd)

（2）

dhnn_int = []
for d in dhnn_dim:bits = xypoint2bits(d[0], d[1])dhnn_int.append(bits)dhnn_bits = (array(dhnn_int).flatten()*2-1).reshape(array(dhnn_int).shape)
print("dhnn_bits: {}".format(dhnn_bits))

（3）求DHNN权系数

  外积方法计算DHNN的拒转，并将对角线置零。

W = dhnn_bits.T.dot(dhnn_bits)
W[diag_indices_from(W)] = 0
print(W)

W=XT⋅XW = X^T \cdot XW=XT⋅X

[[ 0 -4  4  2  0  0  0  2  0 -2  0  4 -4 -2  0  0][-4  0 -4 -2  0  0  0 -2  0  2  0 -4  4  2  0  0][ 4 -4  0  2  0  0  0  2  0 -2  0  4 -4 -2  0  0][ 2 -2  2  0  2 -2  2  0 -2 -4 -2  2 -2  0 -2 -2][ 0  0  0  2  0  0  0 -2 -4 -2  0  0  0  2 -4  0][ 0  0  0 -2  0  0  0 -2  0  2  0  0  0 -2  0  4][ 0  0  0  2  0  0  0 -2  0 -2 -4  0  0 -2  0  0][ 2 -2  2  0 -2 -2 -2  0  2  0  2  2 -2  0  2 -2][ 0  0  0 -2 -4  0  0  2  0  2  0  0  0 -2  4  0][-2  2 -2 -4 -2  2 -2  0  2  0  2 -2  2  0  2  2][ 0  0  0 -2  0  0 -4  2  0  2  0  0  0  2  0  0][ 4 -4  4  2  0  0  0  2  0 -2  0  0 -4 -2  0  0][-4  4 -4 -2  0  0  0 -2  0  2  0 -4  0  2  0  0][-2  2 -2  0  2 -2 -2  0 -2  0  2 -2  2  0 -2 -2][ 0  0  0 -2 -4  0  0  2  4  2  0  0  0 -2  0  0][ 0  0  0 -2  0  4  0 -2  0  2  0  0  0 -2  0  0]]

&emsp;&emsp;上面就是通过外积方法计算出DHNN 矩阵。#### <font  color=#e06030>（4）验证样本被正确存储</font>
```python
error = 0
for b in dhnn_bits:bb = [1 if a > 0 else -1 for a in W.dot(b)]if sum([abs(aa-bb) for aa,bb in zip(bb,b.tolist())]) != 0: error += 1print("error: {}".format(error))

error: 0

  这说明四个样本都被正确的存储。

2.5.3 检测其它样本

  其它样本就当做是带有噪声的样本，输入到DHNN，进行迭代之后，看是否能够与其对应的类别相同。

  编写dhnnPredict函数，对于输入的坐标进行验证。

ITER_STEP = 100
def dhnnPredict(x):xbits = xypoint2bits(x[0],x[1])in_x = array(xbits)*2-1newx = in_xfor i in range(ITER_STEP):in_x = newxnewx = array([1 if a > 0 else -1 for a in W.dot(in_x)])if all(newx==in_x): breakif not all(newx==in_x): return -1for id,n in enumerate(dhnn_bits):if all(n == newx):return idreturn -1for i in range(len(dhnn_dim)):print(dhnnPredict(dhnn_dim[i]))

  首先对于存储的样本进行验证，输出结果如下，可以看到它们与存储的序号是相同的。

0
1
2
3

  然后对于x中前100进行预测：

result = []
for i in range(len(x[:100])):result.append((dhnnPredict(x[i])))print("result: {}".format(result))

result: [0, 1, 1, 3, 2, -1, -1, 2, -1, -1, -1, -1, 0, -1, 1, -1, 2, 0, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, 2, -1, -1, -1, -1, -1, -1, -1, -1, 3, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, -1, 1, -1, -1, 1, -1, -1, -1, -1, -1, -1, -1, -1, 0, -1, -1, -1, -1, -1, 2, -1, -1, -1, -1, -1, 1, -1, -1, -1, 0, -1, -1, 2, -1, -1, 3, -1, 2, -1, -1, -1, -1, -1, -1]

  可以看到大部分都是错误的。这说明使用DHNN用于这类样本的存储识别是行不通的。

※ 作业总结 ※

  对于MATLAB中的SimpleClass数据集合，对比了BP,RBF,SVM,SOFM,DHNN 等方法分类结果，可以看到BP，RBF，SVM，SOFM都具有非常好的分类效果。DHNN对于这样的问题处理能力非常差。

■ 相关文献链接:

• 2021年人工神经网络第四次作业要求
• 应用在机器学习中的聚类数据集产生方法
• make_blobs
• GIthub Gist iris Dataset
• Iris Data Set
• iris.data
• iris.names
• The Iris Dataset?
• 机器学习——支持向量机SVM之python实现简单实例一（含数据预处理、交叉验证、参数优化等）

● 相关图表链接:

• 图1.2.1 SimpleClass_dataset
• 图1.2.4 利用sklearn_datasets产生数据
• IRIS Dataset
• 图1.2.4 Iris数据3D视图
• 图1.2.5 Sepal Length yu Sepal Width 分布
• 图4.1.1 测试数据分布
• 图4.1.2 Lr=0.05, Epochs=100训练精度和损失函数
• 图4.1.3 Lr=0.1, Epochs=100训练精度和损失函数
• 图2.1.5 网络分类界面
• 图2.1.5 一百次训练步骤对应的Loss和Accuracy变化
• 图2.1.6 训练过程中分类边界的变化
• 图2.1.7 一百次训练步骤对应的Loss和Accuracy变化
• 图2.1.8 训练过程中分类边界线的变化
• 图2.2.2 K均值聚类产生径向基函数中心节点
• 图2.2.2 RBF分类界限
• 图2.2.3 隐层的方差：0.01 对应的分界面
• 图2.2.4 隐层的方差：0.001 对应的分界面
• 图2.2.5 隐层的方差：1.0 对应的分界面
• 图2.2.6 隐层的方差：10.0 对应的分界面
• 图2.3.1 分类界面
• 图2.3.2 Gamma=0.1对应的分类界限
• 图2.3.3 Gamma=100 对应的分类界限
• 图2.4.1 SOFM训练过程
• 图2.4.2 训练半径：2，学习速率：0.05
• 图2.4.3 竞争层节点为50，学习速率为0.05
• 图2.4.4 分三个阶段训练
• 图2.5.1 取证函数传递曲线

2021年人工神经网络第四次作业要求：第七题相关推荐

1. 2021年人工神经网络第四次作业-第五题：危险品识别

   简 介: 通过对于物品X射线数据集合的整理,挑选出15类体积比较大的物品,训练LeNet网络进行识别. 关键词: X射线,危险品识别,LeNet,Paddle #mermaid-svg-wZUMACG ...

2. 2021年人工神经网络第四次作业-第一题：LeNet对于水果与动物进行分类

   简 介: 对于有五种动物和五中水果组成的FAMNIST数据集合的图像分类问题进行了测试.本文主要是集中在前期的数据库的准备和网络的构建方面.对于网络的详细测试参见在 对于FAMNIST中的十种动物和水 ...

3. 2021年人工神经网络第四次作业：基于MATLAB的求解

   简 介: 本文选取了2021年人工神经网络第四次作业学生提交的作业.供交流使用. 关键词: 人工神经网络 #mermaid-svg-ATqdYQemfmABj2Hj {font-family:&quo ...

4. 2021年人工神经网络第四次作业 - 第三题Cifar10

   简 介: 在Paddle下使用最基本的BP网络以及LeNet网络结构,测试了Cifar10数据集合.但实际运行在测试集合上的效果始终没有突破0.3,具体原因还需要进行查找. 后来经过测试,发现问题出现 ...

5. 2021年人工神经网络第四次作业 - 第二题MNIST手写体识别

   简 介: ※MNIST数据集合是深度学习基础训练数据集合.改数据集合可以使用稠密前馈神经网络训练,也可以使用CNN.本文采用了单隐层BP网络和LeNet网络对于MNIST数据集合进行测试.实验结果标明 ...

6. 2021年人工神经网络第四次作业-第四题：旋转的数字

   简 介: 本文对于作业中给定的机械数字字符识别问题进行了实验研究.通过对于采样1000样本的数据集合进行训练,经过增加DropOut的可以增加网络的泛化性能.对于网络规模的增加对训练精度没有明显的改进 ...

7. 2021年人工神经网络第三次作业-第二题：遗传算法与人工神经网络-参考答案

   简 介: 给出了对于BP网络求解异或问题过程中,利用遗传算法完成网络演变的过程.所使用的遗传算法是最基本的遗传算法.利用遗传算法对于网络的系数进行演变,可以对网络系数初始化过程进行优化.对于不同的遗传 ...

8. 2022年秋季学期人工神经网络第四次作业

   说明: 本次作业是针对这学期经典神经网络中的内容,主要涵盖竞争神经网络课程内容相关的算法. 完成作业可以使用你所熟悉的编程语言和平台,比如 C,C++.MATLAB.Python等. 作业要求链接: ...

9. 2022年秋季学期人工神经网络第五次作业

   说明: 本次作业是针对这学期经典神经网络中的内容,主要涵盖竞争神经网络课程内容相关的算法. 完成作业可以使用你所熟悉的编程语言和平台,比如 C,C++.MATLAB.Python等. 作业要求链接: ...

最新文章

1. 作业——08 爬虫综合大作业
2. 吉特仓库管理系统-- 后台管理开源啦,源码大放送
3. Spring事务之Propagation
4. 击败谷歌AI拿下“最强”称号？Facebook AI开源聊天机器人Blender
5. linux 新分区使用1%,linux下使用fdisk结合partprobe命令不重启系统添加一块新的磁盘分区...
6. Dalvik class加载的处理
7. 走近分形与混沌(part10)--用简单的规律来描述复杂的大自然
8. GD32如何替换STM32？
9. oracle的LAG和LEAD分析函数
10. NGINX下红黑树的删除(终章)附GIF
11. image加载图片 ui unity_【Unity游戏客户端框架搭建】四、资源管理之理论篇
12. git rebase和 merge的区别
13. 浅学一维傅里叶变换【下一章发布 ： 快速二维傅里叶变换FFT、快速二维傅里叶逆变换IFFT】
14. Git 团队协作中常用术语 WIP PTAL CC LGTM 等解释
15. 英语面试技巧以及准备工作
16. 服务器摆放需要预留U位么_客厅沙发怎么摆放？六种方法教你如何摆放！（实用荐读）...
17. Graphics2D进行后台绘图
18. 插槽+生命周期+过滤器
19. 《Long Short-Term Memory》翻译，Sepp Hochreiter， ¨urgen Schmidhuber．１９９７，９（８）：１７３５－１７８０
20. 09 数据存储Introduce

热门文章

1. 8.15 12.13-12.16
2. Microsoft Azure部署MYSQL-MMM(3)配置MYSQL-MMM
3. ViewPager 入门一
4. React-生命周期杂记
5. php文章付费阅读系统球料付费阅读系统
6. jenkins部署net core初探
7. GitLab首席执行官Sid Sijbrandij畅谈当前开发实践
8. Windows 下连接mysql工具NavicatForMysql
9. 为运维人员插上腾飞更远的翅膀！
10. centos pptp+l2tp+radius+mysql+tc限速,安装配置