《python深度学习》笔记---3.4、电影评论分类：二分类问题
《python深度学习》笔记---3.4、电影评论分类：二分类问题
一、总结
一句话总结：
binary_crossentropy损失函数：对于二分类问题的 sigmoid 标量输出，你应该使用 binary_crossentropy 损失函数。
不是越训练越好：随着神经网络在训练数据上的表现越来越好，模型最终会过拟合，并在前所未见的数据 上得到越来越差的结果。一定要一直监控模型在训练集之外的数据上的性能
二分类问题最后一层用sigmoid：对于二分类问题（两个输出类别），网络的最后一层应该是只有一个单元并使用 sigmoid 激活的 Dense 层，网络输出应该是 0~1 范围内的标量，表示概率值
model = tf.keras.models.Sequential() model.add(tf.keras.layers.Dense(16, activation='relu', input_shape=(10000,))) model.add(tf.keras.layers.Dense(16, activation='relu')) model.add(tf.keras.layers.Dense(1, activation='sigmoid'))
1、准备数据常见两种方式？
Embedding层：列表->张量：填充列表，使其具有相同的长度，再将列表转换成形状为 (samples, word_indices) 的整数张量，然后网络第一层使用能处理这种整数张量的层（即 Embedding 层）。
one-hot编码：对列表进行 one-hot 编码，将其转换为 0 和 1 组成的向量。举个例子，序列 [3, 5] 将会 被转换为10 000 维向量，只有索引为3 和 5 的元素是1，其余元素都是0。然后网络第 一层可以用 Dense 层，它能够处理浮点数向量数据。
2、什么是激活函数？为什么要使用激活函数？
只有线性变换：如果没有 relu 等激活函数（也叫非线性）， Dense 层将只包含两个线性运算——点积 和加法：output = dot(W, input) + b这样 Dense 层就只能学习输入数据的线性变换（仿射变换）
线性变换集合非常有限：该层的假设空间是从输 入数据到16 位空间所有可能的线性变换集合。这种假设空间非常有限，无法利用多个表示 层的优势，因为多个线性层堆叠实现的仍是线性运算，添加层数并不会扩展假设空间。
为了更丰富的假设空间：为了得到更丰富的假设空间，从而充分利用多层表示的优势，你需要添加非线性或激 活函数。
3、概率模型，也就是分类问题，用什么损失函数？
概率值模型用交叉熵：但对于输出概率值的模型，交叉熵（crossentropy）往往是最好 的选择。
交叉熵用于衡量概率分布之间的距离：交叉熵是来自于信息论领域的概念，用于衡量概率分布之间的距离，在这个例子中就 是真实分布与预测值之间的距离。
4、调用 model.fit() 返回了一个 History 对象？
history是字典对象：这个对象有一个成员 history，它 是一个字典，包含训练过程中的所有数据。我们来看一下。
>>> history_dict = history.history
>>> history_dict.keys()
dict_keys(['val_acc', 'acc', 'val_loss', 'loss'])
5、keras读取数据集？
数据集后接load_data方法：(train_data, train_labels),(test_data, test_labels)= tf.keras.datasets.imdb.load_data(num_words=10000)
6、python字典键值颠倒？
【内嵌for.in循环，key和val颠倒】：reverse_word_index = dict([(value, key) for (key, value) in word_index.items()])
7、python字典get的默认值？
【没找到，默认就是'?'】：reverse_word_index.get(i - 3, '?')
8、numpy批量赋值：results1 = np.zeros((2, 10)) ？
results1[0,[1,3,5]]=1：也就是将(0,1)、(0,3)、(0,5)的位置置为1
二、电影评论分类：二分类问题
博客对应课程的视频位置：
import pandas as pd
import numpy as np
import tensorflow as tf
import matplotlib.pyplot as plt
步骤
1、读取数据集
2、拆分数据集（拆分成训练数据集和测试数据集）
3、构建模型
4、训练模型
5、检验模型
需求
1、读取数据集
In [2]:
(train_data, train_labels),(test_data, test_labels)= tf.keras.datasets.imdb.load_data(num_words=10000)
参数 num_words=10000 的意思是仅保留训练数据中前10 000 个最常出现的单词。低频单 词将被舍弃。
这样得到的向量数据不会太大，便于处理。
In [3]:
print(type(train_data))
print(type(train_labels))
In [4]:
print(train_data.shape)
print(train_labels.shape)
In [5]:
print(train_data[0:2])
print(train_labels[0:2])
由于限定为前 10 000 个最常见的单词，单词索引都不会超过 10 000。
In [6]:
max([max(sequence) for sequence in train_data])
Out[6]:
In [7]:
word_index = tf.keras.datasets.imdb.get_word_index()
# 键值颠倒，将整数 索引映射为单词
reverse_word_index = dict(
[(value, key) for (key, value) in word_index.items()])
# 将评论解码。注意，索引减去了3，因为0、1、2 是为
# “padding”（填充）、“ start of sequence”（序 列开始）、
# “unknown”（未知词）分别保留的索引
decoded_review = ' '.join(
[reverse_word_index.get(i - 3, '?') for i in train_data[0]])
In [8]:
print(decoded_review)
In [ ]:
print(type(word_index))
In [ ]:
for item in word_index.items():
if(item[1]<=20):
print(item,item[0],item[1])
2、拆分数据集（拆分成训练数据集和测试数据集）
因为评论文字都是用数字来表示，而这些数字没有大小的意义，所以选择one_hot编码
所以无论训练集，还是测试集，无论是data还是label，都one_hot编码一下就好
(train_data, train_labels),(test_data, test_labels)
In [ ]:
train_data=np.array(train_data)
In [ ]:
print(type(train_data))
print(train_data.shape)
In [ ]:
print(train_data[0])
print(type(train_data[0]))
In [ ]:
print(len(train_data[0]))
print(len(train_data[1]))
print(len(train_data[2]))
print(len(train_data[3]))
In [ ]:
max_review_len=200
In [ ]:
train_data = tf.keras.preprocessing.sequence.pad_sequences(train_data, maxlen=max_review_len)
In [ ]:
train_data = np.concatenate(train_data, axis=0)
print(train_data[0].shape)
print(train_data[1].shape)
print(train_data[2].shape)
print(train_data[3].shape)
In [ ]:
train_data=tf.one_hot(train_data,depth=10000)
test_data=tf.one_hot(test_data,depth=10000)
train_labels=tf.one_hot(train_labels,depth=2)
test_labels=tf.one_hot(test_labels,depth=2)
===============================================
In [9]:
def vectorize_sequences(sequences, dimension=10000):
results = np.zeros((len(sequences), dimension))
for i, sequence in enumerate(sequences):
results[i, sequence] = 1.
return results
In [10]:
# 将训练数据向量化
x_train = vectorize_sequences(train_data)
# 将测试数据向量化
x_test = vectorize_sequences(test_data)
In [11]:
print(x_train.shape)
print(x_test.shape)
In [12]:
print(x_train[0])
In [ ]:
print(type(x_train[0]))
In [ ]:
for i in x_train[0]:
#print(i)
pass
In [ ]:
# 感觉就是把出现这个单词的位置的编号这里的数置为1
# 没出现就置为0
# 所以如果一句话单词对应的数字为1、5、7，那么这个10000维向量1/5/7的位置为1，其它为0
x_train_0=[]
for item in enumerate(x_train[0]):
# print(item)
# print(item[0],item[1])
if(int(item[1])==1):
x_train_0.append(item[0])
#print(item[0])
print(x_train_0)
==============================================
测试方法
In [ ]:
t1_data=[[8,2,5],[3,5,1]]
t1_data=np.array(t1_data)
print(t1_data)
In [ ]:
print(type(t1_data[0]))
In [ ]:
results1 = np.zeros((len(t1_data), 10))
print(results1)
In [ ]:
# 批量赋值
results1[0,[1,3,5]]=1
print(results1)
In [ ]:
for i, sequence1 in enumerate(t1_data):
print(i,sequence1)
results1[i, sequence1] = 1.
print(results1)
========================================
标签向量化
也就是将整形化为浮点型
In [13]:
print(train_labels)
print(test_labels)
In [14]:
y_train = np.asarray(train_labels).astype('float32')
y_test = np.asarray(test_labels).astype('float32')
In [15]:
print(y_train)
print(y_test)
3、构建模型
In [16]:
model = tf.keras.models.Sequential()
model.add(tf.keras.layers.Dense(16, activation='relu', input_shape=(10000,)))
model.add(tf.keras.layers.Dense(16, activation='relu'))
model.add(tf.keras.layers.Dense(1, activation='sigmoid'))
In [17]:
model.summary()
神经网络结构：10000->16->16->1
所以参数为：160016（10000*16+16）->272（16*16+16）->17（16*1+1）
4、训练模型
In [20]:
x_val = x_train[:10000]
partial_x_train = x_train[10000:]
y_val = y_train[:10000]
partial_y_train = y_train[10000:]
In [21]:
model.compile(
optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])
In [22]:
history = model.fit(
partial_x_train,
partial_y_train,
epochs=20,
batch_size=512,
validation_data=(x_val, y_val))
In [28]:
history = model.fit(
x_test,
y_test,
epochs=20,
batch_size=512,
validation_data=(x_val, y_val))
5、检验模型
In [23]:
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 loss')
plt.xlabel('Epochs')
plt.ylabel('Loss')
plt.legend()
plt.show()
In [26]:
plt.clf()
acc = history_dict['accuracy']
val_acc = history_dict['val_accuracy']
plt.plot(epochs, acc, 'bo', label='Training acc')
plt.plot(epochs, val_acc, 'b', label='Validation acc')
plt.title('Training and validation accuracy')
plt.xlabel('Epochs')
plt.ylabel('Accuracy')
plt.legend()
plt.show()
In [27]:
model.predict(x_test)
Out[27]:
In [ ]:
版权申明：欢迎转载，但请注明出处
一些博文中有一些参考内容因时间久远找不到来源了没有注明，如果侵权请联系我删除。
在校每年国奖、每年专业第一，加拿大留学，先后工作于华东师范大学和香港教育大学。
2025-04-30：宅加太忙，特此在网上找女朋友，坐标上海，非诚勿扰，vx：fan404006308
AI交流资料群：753014672
浙公网安备 33010602011771号