python深度学习---路透社多分类

import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import pylab
from pandas import DataFrame, Series

#路透社数据集
#多分类问题
from keras.datasets import reuters

(train_data, train_labels), (test_data, test_labels) = reuters.load_data( num_words=10000)#参数 num_words=10000 将数据限定为前 10 000 个最常出现的单词

print(train_data.shape,test_data.shape)
#与 IMDB 评论一样，每个样本都是一个整数列表（表示单词索引）

print(train_labels[10])#样本对应的标签是一个 0~45 范围内的整数，即话题索引编号

# #准备数据，与之前imdb数据集一样采用one-hot编码
# #将标签向量化有两种方法：你可以将标签列表转换为整数张量，或者使用 one-hot 编码。one-hot 编码是分类数据广泛使用的一种格式，也叫分类编码（categorical encoding）
#样本序列向量化
def one_hot(sequeces,demension):
    results=np.zeros((len(sequeces),demension))
    for i,sequece in enumerate(sequeces):
        results[i,sequece]=1
    return results

x_train=one_hot(train_data,10000)
x_test=one_hot(test_data,10000)

# x_train_label=one_hot(train_labels,46)
# x_test_label=one_hot(test_labels,46)
#，Keras 内置方法可以实现这个操作
from keras.utils.np_utils import to_categorical

x_train_labels=to_categorical(train_labels)
x_test_labels=to_categorical(test_labels)

#构建网络
#与二分类的约束条件的不同之处是：输出类别的数量从 2 个变为 46 个。输出空间的维度要大得多。

#对于前面用过的 Dense 层的堆叠，每层只能访问上一层输出的信息。如果某一层丢失了与 分类问题相关的一些信息，那么这些信息无法被后面的层找回，也就是说，每一层都可能成为信息瓶颈。出于这个原因，下面将使用维度更大的层，包含 64 个单元

#模型定义
from keras import models,layers
# 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'))
#
# '''
# 关于这个架构还应该注意另外两点。
# ? 网络的最后一层是大小为 46 的 Dense 层。这意味着，对于每个输入样本，网络都会输出一个 46 维向量。这个向量的每个元素（即每个维度）代表不同的输出类别。
# ? 最后一层使用了 softmax 激活。你在 MNIST 例子中见过这种用法。网络将输出在 46 个不同输出类别上的概率分布——对于每一个输入样本，网络都会输出一个 46 维向量， 其中 output[i] 是样本属于第 i 个类别的概率。46 个概率的总和为 1。
# 对于这个例子，最好的损失函数是 categorical_crossentropy（分类交叉熵）。它用于衡量两个概率分布之间的距离，这里两个概率分布分别是网络输出的概率分布和标签的真实分布。通过将这两个分布的距离最小化，训练网络可使输出结果尽可能接近真实标签  #，最大似然法求logistic回归模型的参数，取似然函数的负对数得到最小化错误分类率，该形式即为二分类交叉熵误差函数，使用softmax同理可得多分类交叉熵误差函数
# '''
#
# #编译模型
# model.compile(optimizer='rmsprop',
#                 loss='categorical_crossentropy',
#                 metrics=['accuracy'])
#
# #验证方法
# #这里在训练数据中留出1000个样本作为验证集
x_val = x_train[:1000]
partial_x_train = x_train[1000:]
y_val = x_train_labels[:1000]
partial_y_train = x_train_labels[1000:]

# #训练模型，20轮次
# history = model.fit(partial_x_train,
#                     partial_y_train,
#                     epochs=20,
#                     batch_size=512,
#                     validation_data=(x_val, y_val))
#
# history_dict=history.history
# #绘制损失曲线和精度曲线
# fig=plt.figure()
# ax1=fig.add_subplot(2,1,1)
# x=[i for i in range(1,21)]
# loss=history_dict['loss']
# val_loss=history_dict['val_loss']
#
# ax1.plot(x,loss,'bo',label='Training loss')
# ax1.plot(x,val_loss,'b',label='validation loss')
# ax1.set_title('Training and validation loss')
# ax1.set_xlabel('Epochs')
# ax1.set_ylabel('Loss')
# ax1.legend()
#
# ax2=fig.add_subplot(2,1,2)
# acc=history_dict['acc']
# val_acc = history_dict['val_acc']
# ax2.plot(x, acc, 'bo', label='Training acc')
# ax2.plot(x, val_acc, 'b', label='Validation acc')
# ax2.set_title('Training and validation accuracy')
# ax2.set_xlabel('Epochs')
# ax2.set_ylabel('Accuracy')
# ax2.legend()
# plt.tight_layout()
# plt.show()

#发现大约第7-9轮开始出现过拟合，因此将轮次调为9，重新训练模型

#代码清单 3-21 从头开始重新训练一个模型
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'))
model.compile(optimizer='rmsprop',
              loss='categorical_crossentropy',
              metrics=['accuracy'])
model.fit(partial_x_train,
          partial_y_train,
          epochs=9,
          batch_size=512,
          validation_data=(x_val, y_val))
results = model.evaluate(x_test, x_test_labels)
print(results)#返回一个loss值和metric值，【loss值会大于1？】

import copy
test_labels_copy=copy.copy(test_labels)
np.random.shuffle(test_labels_copy)#置乱
hits_array=np.array(test_labels)==np.array(test_labels_copy)
r=np.sum(hits_array)/len(test_labels)#完全随机分类率
print(r)

#模型预测（在新数据集上生成预测结果）
predictions=model.predict(x_test)#返回每条数据对应的46个分类概率
print(predictions[0].shape)
print(np.sum(predictions[0]))
class_belong=np.argmax(predictions[0])#返回最大元素，即概率最大的类别

#处理标签和损失的另一种方法
    #将其转换为整数张量
y_train=np.array(train_labels)
y_test=np.array(test_labels)
#对于这种编码方法，唯一需要改变的是损失函数的选择
#对于整数标签，应当使用 sparse_categorical_crossentropy
#它与前面的多分类交叉熵损失函数在数学上完全相同，只是接口不同
model.compile(optimizer='rmsprop',
              loss='sparse_categorical_crossentropy',
              metrics=['acc'])
#中间层维度足够大的重要性
#，如果中间层的维度远远小于 46（比如 4 维），造成了信息瓶颈，那么会发生什么？
model = models.Sequential()
model.add(layers.Dense(64, activation='relu', input_shape=(10000,)))
model.add(layers.Dense(4, activation='relu'))
model.add(layers.Dense(46, activation='softmax'))

model.compile(optimizer='rmsprop',
loss='categorical_crossentropy', metrics=['accuracy'])

model.fit(partial_x_train, partial_y_train, epochs=20,
batch_size=128, validation_data=(x_val, y_val))
#导致这一下降的主要原因在于，你试图将大量信息（这些信息足够恢复46个类别的分割超平面）压缩到维度很小的中间空间。网络能够将大部分必要信息塞入这个四维表示中，但并不是全部信息

'''
? 如果要对N个类别的数据点进行分类，网络的最后一层应该是大小为N的 Dense 层。 
? 对于单标签、多分类问题，网络的最后一层应该使用 softmax 激活，这样可以输出在N 个输出类别上的概率分布。
? 这种问题的损失函数几乎总是应该使用分类交叉熵。它将网络输出的概率分布与目标的 真实分布之间的距离最小化。
? 处理多分类问题的标签有两种方法。 
? 通过分类编码（也叫 one-hot 编码）对标签进行编码，然后使用 categorical_ crossentropy 作为损失函数。
? 将标签编码为整数，然后使用 sparse_categorical_crossentropy 损失函数。
? 如果你需要将数据划分到许多类别中，应该避免使用太小的中间层，以免在网络中造成信息瓶颈
'''