1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
def ANN():
    iterations = []
    accur_train = []
    accur_test = []
    losses = []
    #将训练集、测试集和情感标签转换为NumPy数组
    # 转换成numpy数组
    mydata = data()
    aligned_train_set = np.array(mydata.aligned_train_set)
    aligned_test_set = np.array(mydata.aligned_test_set)
    emotion_train = np.array(mydata.emotion_train)
    emotion_test = np.array(mydata.emotion_test)
    # 数值为1~6的情感标签转化成二进制
    emotion_train_b = LabelBinarizer().fit_transform(emotion_train)
    # 数据集参数
    feature_size = len(aligned_train_set[0]) #表示每个样本的特征维度（每个样本的特征数量）在本次中有多少词既有多少特征

    #开始训练模型
    perceptron = Perceptron(feature_size, num_classes)#输入大小为feature_size，输出大小为num_classes
    print('learning rate is ',learning_rate)
    for iteration in range(iterations_num):
        #计算输出Y = 𝑋𝑊
        Y = perceptron.forward(aligned_train_set)
        Y_test = perceptron.forward(aligned_test_set)

        #计算损失MS𝐸 = 1/𝑁(𝑋𝑊 − 𝑌)^2
        # L_MSE, d_L_MSE = MSE(aligned_train_set, Y, emotion_train_b) #iterations_num=3500 学习率0.7
        L_MSE, d_L_MSE = MSE_with_regularization(aligned_train_set, Y, emotion_train_b, perceptron.weights) #加入正则化
        # L_MSE, d_L_MSE = cross_entropy_error(aligned_train_set, Y, emotion_train_b)

        # #更新权重 𝑊 = 𝑊 − 𝜂 * 𝜕𝑀𝑆𝐸/𝜕W
        # perceptron.weights = perceptron.weights - learning_rate * d_L_MSE

        #更新正则化的权重 W = W - lr(dL_MSE/dW + lambda*W)
        perceptron.weights = perceptron.weights - learning_rate * (d_L_MSE + lamda * perceptron.weights)

        #为了画图取样
        if iteration % sample_rate == 0:
            #训练集
            pre_label = []
            for i in range(Y.shape[0]):#Y(train_size, num_class)的矩阵，所以Y.shape[0]即为train_size
                pre_label.append(np.argmax(Y[i]) + 1)#np.argmax()返回最大数的索引
            cur_accuracy = np.mean(np.equal(pre_label, emotion_train)) #即预测值与训练集情感标签相匹配的比例
            print('Train_Set: iteration [{}/{}], Loss: {:.4f}, Accuracy: {}'.format(iteration + 1, iterations_num, L_MSE,100 * cur_accuracy))
            accur_train.append(100 * cur_accuracy)
            #测试集
            pre_label = []
            for i in range(Y_test.shape[0]):
                pre_label.append(np.argmax(Y_test[i]) + 1)
            cur_accuracy = np.mean(np.equal(pre_label, emotion_test))
            print('Test_Set: iteration [{}/{}], Loss: {:.4f}, Accuracy: {}'.format(iteration + 1, iterations_num, L_MSE,100 * cur_accuracy))
            accur_test.append(100 * cur_accuracy)
            iterations.append(iteration)
            losses.append(L_MSE)

    # 创建一个 1x2 的子图，用于显示训练集和测试集准确率以及损失值
    fig, (ax1, ax2) = plt.subplots(1, 2, figsize=(12, 6))

    # 设置第一个子图的 x 轴和 y 轴标签及标题，并画出训练集和测试集准确率的折线图
    ax1.set_xlabel('iterations')
    ax1.set_ylabel('accuracy')
    ax1.set_title('Train/Test Set Accuracy')
    ax1.plot(iterations, accur_train, color = 'red')
    ax1.plot(iterations, accur_test, color='green')
    ax1.legend(['Train', 'test'])

    # 设置第二个子图的 x 轴和 y 轴标签及标题，并画出损失值的折线图
    ax2.set_xlabel('iterations')
    ax2.set_ylabel('losses')
    ax2.set_title('Losses')
    ax2.plot(range(len(losses)), losses, color='blue')

    # 在最后一行展示所有图形
    plt.show()

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
# 计算每个类别的先验概率
for c in classes:
	prior[c] = count(samples with class c) / total samples
# 计算每个特征在每个类别下的条件概率
for c in classes:
	for f in features:
		conditional_prob[c][f] = (count(samples with feature f and class c) + 1)
/ (count(samples with class c) + 2)
# 对于新样本x，计算其属于每个类别的后验概率
for c in classes:
	posterior[c] = log(prior[c])
	for f in features:
		if x has feature f:
            posterior[c] += log(conditional_prob[c][f])
		else:
			posterior[c] += log(1 - conditional_prob[c][f])
# 预测新样本所属类别
predicted_class = argmax(posterior)

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 给定训练数据train_data，词汇表vocabulary
# 返回条件概率p(word|label)
def train(self, train_data, vocabulary):
	# 计算每个特征在每个类别下的条件概率
	total_counts = {}
	for label in train_data.keys():
		total_counts[label] = sum(train_data[label].values())
	probabilities = {}
	# 这里要进行拉普拉斯平滑
	k = 4
	for label in train_data.keys():
	probabilities[label] = {}
	for word in vocabulary:
		if word in train_data[label].keys():
			count = train_data[label][word]
		else:
			count = 0
		probabilities[label][word] = (count + k) / (total_counts[label] + k * len(vocabulary))
	return probabilities

1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
# 给定测试数据，给回预测结果
def predict(self, test_data, probabilities, freq):
	labels = list(probabilities.keys())
	results = []
	label_sum = sum(freq.values())
	# 对每个句子进行预测
	for words in test_data:
		scores = {}
		# 对每个label进行打分
		for label in labels:
			score = freq[label] / label_sum
			for word in words:
				if word in probabilities[label].keys():
					score *= probabilities[label][word]
			scores[label] = score
		# 预测结果为最大分数的标签
		result = max(scores, key=scores.get)
		results.append(result)
	return results

1
self.vectorizer = TfidfVectorizer(use_idf=False)

1
self.vectorizer = TfidfVectorizer(use_idf=True)