登录/注册
qgyh
2158
占位
1
占位
0
浏览量
占位
粉丝
占位
关注
自我学习与理解：keras框架下的深度学习（二）二分类和多分类问题
qgyh
2021-12-31 11:47:40 2021-12-31
82
0

本文第一部分是对数据处理中one-hot编码的讲解，第二部分是对二分类模型的代码讲解，其模型的建立以及训练过程与上篇文章一样；在最后我们将训练好的模型保存下来，再用自己的数据放入保存下来的模型中进行分类（在后面的文章中会详细讨论如何使用自己的数据去训练模型，或者让保存下来的模型去处理自己的数据）。第三部分是多分类模型，多分类的过程和二分类很相似，只是在代码中有些地方需要做出调整。

第二部分是本文的重点。　

一：one-hot编码

通过第一篇文章我们知道，对于使用keras来进行深度学习网络的搭建，因为keras中已经把深度学习的步骤都打包成函数或者文件，我们只需要调用即可，所以我们需要在数据的处理（怎么把数据处理好放入框架里面）和参数的调整上用功夫。在本文中，我们讨论一种数据处理的方法：ong-hot编码，即根据一个矩阵生成一个只有0和1的矩阵，0表示之前的矩阵在这个索引处没有数值，1表示之前的矩阵在这个索引处有数值。比如说有一条数据是a=[1,8,4,2],使用one-hot编码生成一行10列的矩阵，那么将会是[0,1,1,0,1,0,0,0,1,0]，表示这个矩阵表示分别在索引1，2，3，8处有数值，而其他地方没有数值（one-hot矩阵的列数要大于a矩阵中数值的最大数）。

下面我们在pycharm中随机生成一个[3,10]，取值在0到20之间的矩阵，然后生成[3，20]的one-hot矩阵。

1.首先生成[3,10]的矩阵a：

import numpy as np
c1 = np.random.choice(20,10,replace=False)  #在0到20之间我们随机选择10不重复的数字，replace=False 表示选择的数字不能有重复
c2 = np.random.choice(20,10,replace=False)
c3 = np.random.choice(20,10,replace=False)
a = np.array([c1,c2,c3])                    #把前面三个[1,10]矩阵合成[3,10]矩阵

我们使用np.random.choice(20,10,replace=False)来生成10个在0到20之间不重复的数字，replace= False表示生成的数字不能有重复。

2.然后我们根据矩阵a生成one-hot矩阵b：

def one_hot(sample,dim=20):
    result = np.zeros((len(sample),dim))    
    for i,sample in enumerate(sample):      #enumerate会给i和sample自动编组   
        result[i,sample] = 1.  　　　　　　　 #索引在哪个位置有数值，就给赋值为1
    return result
b = ver(a)

（1）在第一行代码中，我们创建一个one-hot函数。

（2）第二行代码我们生成一个行是数据个数，列是20的全零矩阵result（列是矩阵a中数值最大的数）。

（3）第三行代码中的enumerate函数表示将一个可遍历的数据对象(如列表)组合为一个索引序列，同时列出数据和数据下标。比如说我们选择随机给定一个矩阵：

list_a = [[2,3,4,5],[4,6,2,4]]

然后打印矩阵list_a和使用enumerate函数后的矩阵：

print('list_a为：',list_a)
print('enumerate函数生成的矩阵为：',list(enumerate(list_a)))

输出结果如下：

list_a为： [[2, 3, 4, 5], [4, 6, 2, 4]]
enumerate函数生成的矩阵为： [(0, [2, 3, 4, 5]), (1, [4, 6, 2, 4])]

整个过程：

list_a = [[2,3,4,5],[4,6,2,4]]
print('list_a为：',list_a)
print('enumerate函数生成的矩阵为：',list(enumerate(list_a)))
输出结果：
list_a为： [[2, 3, 4, 5], [4, 6, 2, 4]]
enumerate函数生成的矩阵为： [(0, [2, 3, 4, 5]), (1, [4, 6, 2, 4])]

第四行代码表示在sample有数值的索引处赋值为1.

最后返回result矩阵，并且根据数据a生成one-hot矩阵b。

（4）打印矩阵a和b，显示结果：

print(b)
结果：
a= [[ 6 15 14  9 19 13  4  1  2  3]
 [ 9 11 14 17 13 12  2 10  4 18]
 [18  2 11  8  5 14 13 12 19 16]]
b= [[0. 1. 1. 1. 1. 0. 1. 0. 0. 1. 0. 0. 0. 1. 1. 1. 0. 0. 0. 1.]
 [0. 0. 1. 0. 1. 0. 0. 0. 0. 1. 1. 1. 1. 1. 1. 0. 0. 1. 1. 0.]
 [0. 0. 1. 0. 0. 1. 0. 0. 1. 0. 0. 1. 1. 1. 1. 0. 1. 0. 1. 1.]]

3.总代码：

import numpy as np
c1 = np.random.choice(20,10,replace=False)  #在0到20之间我们随机选择10不重复的数字，replace=False 表示选择的数字不能有重复
c2 = np.random.choice(20,10,replace=False)
c3 = np.random.choice(20,10,replace=False)
a = np.array([c1,c2,c3])                    #把前面三个[1,10]矩阵合成[3,10]矩阵
def ver(sample,dim=20):
    result = np.zeros((len(sample),dim))    
    for i,sample in enumerate(sample):      #enumerate会给i和sample自动编组
        result[i,sample] = 1.    #索引在哪个位置有数值，就给赋值为1
    return result
b = ver(a)
print('a=',a)
print('b=',b)

 　　以上就是对数据处理的one-hot方法，下面我们详细讲解keras框架下的二分类问题。

 

二：二分类问题

对于二分类问题，我们这里采用的数据集是IMDB，它包含50000条严重两极分化的评论，数据集分为用于训练的25000跳评论和用于测试的25000条评论，两者都包含50%的证明评论和50%的负面评论。

1， 对于数据的预处理

首先我们使用keras导入imdb数据集：

from keras.datasets import imdb
(train_data,train_label),(test_data,test_label)=imdb.load_data(num_words=10000)

其过程和手写体的导入过程一样，不过多了一个参数的导入：num_woeds表示只保留训练数据集前10000个最常出现的单词，低频率的单词会被舍去（比如说人名）

       在train_data内的数据是1到10000的数字，表示每个数字出现的频率；而train_label是0或1的单个数字，0表示负面评论，1表示正面评论。比如说我们打印第一个数据以及它的标签（打印过程代码不算入最后的总代码，只是查看数据）：

print(train_data[0]) 
print(train_label[0])
[1, 14, 22, 16, …19, 178, 32]
1

       第一个数据一共包含218个单词，而它的标签是1。

       这里，你很可能会有问题，为什么要把单词变成数字？这样深度学习的框架是怎么学习到评论的好坏的？我的理解是比如说给我们人类一些数字，当给你的是单数的时候就给你糖，当是偶数的时候就给你一个惩罚，次数多了之后我们就知道了单数表示这有糖，是好的。类似于这个，负面评论中可能有很多负面的单词，因为它们是编号码的，所以负面的单词不太可能出现在正面评论中，又或者出现的次数很少。所以我们把单词变成纯数字，交给深度学习去处理，从而得到一个正面或者负面评价的结果（让单纯的数值赋予其不同的意义）。

       言归正传，在导入数据后，我们需要对数据进行处理，在把数据给到深度学习的时候，我们需要把数据变成张量，把数据向量化（简化数据）所以我们采用one-hot编码的方法，把train_data和test_data中的数据变成元素只有0和1的矩阵，至于train_label和test_label，因为只有单独的一个数据，我们用numpy把它进行one-hot编码，具体代码如下：

def one_hot(sample,dim=10000):
    result = np.zeros((len(sample),dim))
    for i,sample in enumerate(sample):
        result[i,sample] = 1
    return result
train_data = one_hot(train_data)
test_data = one_hot(test_data)
train_label = np.asarray(train_label).astype('float32')
test_label = np.asarray(test_label).astype('float32')

       one-hot的方法在上面已经详细讲述过了，所以这里不详细讲解；在这里我们定义一个one_hot函数，然后把train_data和test_data的数据放进去处理。我们打印train_data[0]和train_lable[0]看看数据是什么样的：

print(train_data[0])
print(test_label[0])
[0. 1. 1. ... 0. 0. 0.]
0.0

2.搭建网络框架

       在这里我们采用三层全连接层，其中前两层是16个隐藏层，采用的函数时relu激活函数；最后是一层输出一个标量，表示评论的情感，采用sigmid激活函数。代码如下所示：

from keras import models
from keras import layers
model = models.Sequential()
model.add(layers.Dense(16,activation='relu',input_shape=(10000,)))
model.add(layers.Dense(16,activation='relu'))
model.add(layers.Dense(1,activation='sigmoid'))

对于全连接层（Dense）来说，16个隐藏单元，表示将输入的数据投影到16维表示空间中。Relu函数是一个非线性的激活函数，其函数为：。假设输入的数据是X（单列矩阵），那么假设经过16个隐藏单元的全连接层后的输出为Z，则可以得到：Z=Relu(dot(W,X)+b)。其中W表示权重矩阵，其形状是(X,16)，b是偏执向量，含有16个数值。当隐藏单元个数越大时，网络越能学到复杂的表示，但是其计算代价也会更高。

3.编译

model.compile(
    optimizer='rmsprop', #可以导入包，自己定义
    loss='binary_crossentropy',
    metrics=['accuracy']
)

       在编译中，我们可以自定义损失函数loss，通过导入keras中的优化器，对其参数进行修改，从而使模型得到更好的效果。下面是导入损失函数的代码（替换上面的代码）：

from keras import optimizers
model.copile(
optimizer= optimizers.RMSprop(lr=0.001), #可以导入包，自己定义
    loss='binary_crossentropy',
    metrics=['accuracy']
)

     为了更好的理解优化器的内容，我们可以在keras的文件里面找到optimizers.py文件，里面包含着很多个类，每个类都是一种优化器的具体过程。我们找到RMSprop优化函数：

    然后查看lr，如图所示：

4.循环训练

训练开始前，我们需要说明一点，就是在训练阶段（先不去管测试集），我们需要在训练集中分出一部分数据来进行检测，检测我们的模型泛化能力，也就是检测模型遇到新数据时的表现（有时候虽然准确率高，其实是模型把数据和对应的标签背了下来，对新数据的处理会十分差劲）所以，在我们开始循环时，我们在训练集中抽一部分做验证集，具体代码如下：

train_data_val = train_data[:10000] 
train_data = train_data[10000:]
train_label_val = trian_label[:10000]
train_label = trian_label[10000:]

    其中在train_data和train_label中抽出10000个数据和标签作为验证集（validation），剩下的作为训练集。注：[:10000]表示取0到9999索引的数据（也就是取10000个数据，但是不要10000）

    下面我们把数据丢入网络中进行训练以及验证：

history=model.fit(train_data,train_label,epochs=100,batch_size=512,validation_data=(train_data_val,train_lable_val ))

    其中，我们把模型训练以及验证得到的结果赋值给history（model.fit()中得到的结果是以字典的形式返回）这样方便我们后面画图查看模型训练以及验证的情况；上述函数fit中的参数于上文一致，不过多了一个验证的过程，即：validation_data=(train_data_val,train_lable_val )

    下面我们引用history中的参数，画图查看训练以及验证的情况，代码如下：

history_dict=history.history
loss_values = history_dict['loss']
val_loss_values=history_dict['val_loss']
epochs=range(1,len(loss_values)+1)
plt.plot(epochs,loss_values,'bo',label='training loss')
plt.plot(epochs,val_loss_values,'b',label='validation loss')
plt.title('training and validation')
plt.xlabel('epochs')
plt.ylabel('loss')
plt.legend()
plt.show()

    第一行代码表示，我们使用history函数调用history中的参数赋值给history_dict，第二行第三行表示取出训练损失值和验证损失值（在这里，若是不知道history中有什么值，可以在运行时查看页面，history会有四个key以及他们返回的value，其中key分别是：loss,val_loss,acc,val_acc;分别表示损失值，验证损失值，准确率，验证准确率）

    第四行表示画图的横坐标.

第五到十一行是画图，运行以上代码，将会得到的图形如图所示：

图中训练集的损失值是不断下降，逼近于零，但是当模型运行验证集的时候，也就是遇见新的数据时，在大概第4个epoch的地方，其验证集的损失值直线上升，出现过拟合现象。对于过拟合的处理有很多方法，会在以后的文章中阐述，这里我们让epochs为4，总共运行4论就结束，让其处于在验证集最佳的位置。（这里只画了损失值的图像，对于准确率（acc）的图像可以自行编写代码查看）我们最后更改把histor=model.fit（）这句代码更改成如下代码：

history=model.fit(train_data,train_label,epochs=4,batch_size=512,validation_data=(train_data_val,train_lable_val ))

5.测试训练的网络模型

result = model.evaluate(test_data,test_label)
print(result)

最后使用evaluate函数进行模型的最后测试，并且把数值打印出来，查看测试的结果。结果：[0.32555921449184416, 0.8685600161552429]，准确率可到达86%。

7.总代码：

from keras.datasets import imdb
from keras import models
from keras import layers
(train_data,train_label),(test_data,test_label)=imdb.load_data(num_words=10000)
def one_hot(sample,dim=10000):
    result = np.zeros((len(sample),dim))
    for i,sample in enumerate(sample):
        result[i,sample] = 1
    return result
train_data = one_hot(train_data)
test_data = one_hot(test_data)
train_label = np.asarray(train_label).astype('float32')
test_label = np.asarray(test_label).astype('float32')
model = models.Sequential()
model.add(layers.Dense(16,activation='relu',input_shape=(10000,)))
model.add(layers.Dense(16,activation='relu'))
model.add(layers.Dense(1,activation='sigmoid'))
model.compile(
    optimizer='rmsprop', #可以导入包，自己定义
    loss='binary_crossentropy',
    metrics=['accuracy']
)
train_data_val = train_data[:10000] #[:10000] 
train_data = train_data[10000:]
train_label_val = trian_label[:10000]
train_label = trian_label[10000:]
history=model.fit(train_data,train_label,epochs=4,batch_size=512,validation_data=(train_data_val,train_lable_val ))
history_dict=history.history
loss_values = history_dict['loss']
val_loss_values=history_dict['val_loss']
epochs=range(1,len(loss_values)+1)
plt.plot(epochs,loss_values,'bo',label='training loss')
plt.plot(epochs,val_loss_values,'b',label='validation loss')
plt.title('training and validation')
plt.xlabel('epochs')
plt.ylabel('loss')
plt.legend()
plt.show()
result = model.evaluate(test_data,test_label)
print(result)

8.用训练好的模型处理自己的数据

在我们使用自己的数据识别的时候，我们先把自己的模型保存下来，在代码的最后我们加上下面的代码保存模型：

model.save('tow_classes.h5')

（类似的，我们可以在网上下载别人训练好的模型然后进行自己数据的识别）我们会在旁边文件目录里面看到保存的该模型：

 

 

然后我们在保存的模型下文件的同目录下，重新创建一个.py文件，进行自己数据的处理。

首先我们使用keras导入自己的模型文件：

from keras import models
model=models.load_model('tow_classes.h5')

然后我们随机制造一组数据放入模型中进行预测（可以套用到之前手写体数字识别的模板中，不过得对图片进行处理）

随机生成数据a（这里只做示范，数据没有包含任何信息）：

a0 = np.random.choice(2000,200,replace=False)
a1 = np.random.choice(2000,200,replace=False)
a2 = np.random.choice(2000,200,replace=False)
a3 = np.random.choice(2000,200,replace=False)
a4 = np.random.choice(2000,200,replace=False)
a = np.array([[a1],[a2],[a3],[a4]])

    随机生成4组数据，组成a矩阵

    然后把矩阵a用one-hot编码：

def one_hot(sample,dim=10000):
    result=np.zeros((len(sample),dim))
    for i,sample in enumerate(sample):
        result[i,sample] = 1
    return result
b=one_hot(a)

    最后把b矩阵丢入模型得到一个分类的概率值以及最后分类的结果：

predict = model.predict(b) 
predict_class = model.predict_classes(b)

    打印结果查看：

print(predict)
print(predict_class)
[[0.02564826]
 [0.46361473]
 [0.98723143]
 [0.07622854]]
[[0]
 [0]
 [1]
 [0]]

模型把第一、二、四组的数据分成第一类，把第三组数据分成第二类。

总代码：

from keras import models
import numpy as np
model=models.load_model('tow_classes.h5')
a0 = np.random.choice(2000,200,replace=False)
a1 = np.random.choice(2000,200,replace=False)
a2 = np.random.choice(2000,200,replace=False)
a3 = np.random.choice(2000,200,replace=False)
a4 = np.random.choice(2000,200,replace=False)
a = np.array([[a1],[a2],[a3],[a4]])
def one_hot(sample,dim=10000):
    result=np.zeros((len(sample),dim))
    for i in enumerate(sample):
        result[i] = 1
    return result
b=one_hot(a)
predict = model.predict(b)
predict_class = model.predict_classes(b)
print(predict)
print(predict_class)

 

三、多分类问题

    对于多分类问题，其模型框架与二分类十分类似，只是有几个个地方稍有不同，在多分类模型中，我们采用路透社数据集，它包含许多短新闻以及其对应的主题。一共包含46个不同的主题，每组至少有10组样本（数据集详情，参考reuters中的源代码）。

这里直接上总代码：

from keras.datasets import reuters
from keras import layers
from keras import models
from keras.utils import to_categorical
import numpy as np
#1对数据的处理
(train_data,train_labels),(test_data,test_labels) = reuters.load_data(num_words=10000)
def ver(sequence,dim=46):
    resules=np.zeros((len(sequence),dim)) 
    for i,sequence in enumerate(sequence): #编号  属于哪个新闻社
        resules[i,sequence]=1  #有数据的地方标1
    return resules
x_trian=ver(train_data)
x_test=ver(test_data)
one_hot_trian_labels = to_categorical(train_labels)
one_hot_test_labels = to_categorical(test_labels)
x_val=x_trian[:1000]
partial_x_train=x_trian[1000:]
y_val=one_hot_trian_labels[:1000]
partial_y_train=one_hot_trian_labels[1000:]
#2.搭建网络框架
model=models.Sequential()
model.add(layers.Dense(64,activation='relu',input_shape=(10000,)))
model.add(layers.Dense(64,activation='relu'))
model.add(layers.Dense(46,activation='softmax'))
#3.编译
model.compile(
    optimizer='rmsprop',
    loss='categorical_crossentropy',
    metrics=['accuracy']
)
#4.循环训练
history=model.fit(partial_x_train,partial_x_train,epochs=9,batch_size=512,validation_data=(x_val,y_val))
#5.测试训练的网络模型
result = model.evaluate(x_test,one_hot_test_labels)
print(result)

多分类的数据处理和二分类一样，但是有几点不同：1.我们把验证集的划分移到了前面（dim变成了46，表示有46个报社）。2.在搭建网络框架中，第一二层全连接层的隐藏元个数变成了64，最后输出变成了46，其激活函数变成了softmax激活函数。（注意：以上没有写出画图的代码，画图代码与二分类一样，最后得到结果是模型到了第九次左右的效果为最佳；在画图前，可以先让模型运行几十次，如，让epochs=30，最后得到图像后，根据图像获得合适的epochs）

在最后我们可以与二分类模型一样，保存训练好的模型，自己模拟一组数据放入模型中进行分类预测（在自己模拟数据放入模型预测之前，需要查看数据的格式，如查看训练集数据的第一个数据格式：print(trian_data[0].size)）。（在后续的文章中，我们会从零开始制作自己的数据集，然后利用深度学习模型来进行处理）

原文: https://www.cnblogs.com/openabox/p/15458638.html

暂无评论