基于SVM+AdaBoost加强分类器的微博情感分析（Python）

电玩女神 2024-04-03 14:07 76阅读 0赞

目 录  
前 言 1  
第一章 概述 2  
1.1 研究背景和现状 2  
1.2 情感分析的概念 2  
1.3 本文的内容安排 4  
第二章 微博的获取与清理 6  
2.1 概述 6  
2.2 微博的反爬虫机制 6  
2.2.1 通过Headers反爬虫 6  
2.2.2 基于用户行为的爬虫 6  
2.2.3 动态页面的反爬虫 7  
2.2.4 微博的反爬虫 7  
2.3 微博的获取 7  
2.3.1 微博API的获取 7  
2.3.2 模拟登录 8  
2.3.3 微博抓取与存储 9  
2.4 微博的分词与降噪 9  
2.4.1 概念 9  
2.4.2 分词 9  
2.4.3 删除URL 10  
2.4.4 删除用户名 11  
2.4.5 去除停用词 11  
2.5 本章小结 11  
第三章 SVM初步分类 12  
3.1 概念 12  
3.1.1 线性分类 12  
3.2 SVC 13  
3.2.1 线性支持向量分类机 13  
3.2.2 算法描述 14  
3.3 实验 15  
3.3.1 选取特征 15  
3.3.2 降噪 15  
3.3.3 特征降维 15  
3.3.4 将文本样本变成特征显示 16  
3.3.5 将文本随机分成训练集、测试集 16  
3.3.6 进行训练和预测 16  
3.4 本章小结 17  
第四章 利用贝叶斯定理进行情感分析 18  
4.1 引言 18  
4.2 贝叶斯定理 18  
4.2.1 高斯朴素贝叶斯 20  
4.2.2 伯努利贝叶斯 20  
4.2.3 多项式朴素贝叶斯定理 21  
4.3 本文中的多项式朴素贝叶斯 21  
4.3.1 算法过程 21  
4.3.2 拉普拉斯平滑 22  
4.4 实验 22  
4.4.1 分词 22  
4.4.2 特征提取 23  
4.4.3 向量化 23  
4.4.4 朴素贝叶斯分类 24  
4.4.5 测试 24  
4.4.6 计算准确率 25  
4.5 本章小结 25  
第五章 利用AdaBoost加强分类器 26  
5.1 集成学习 26  
5.1.1 发展历史 26  
5.1.2 Bagging方法 26  
5.1.3 Boosting方法 26  
5.2 ADABOOST 27  
5.2.1 概念 27  
5.2.2 举例 27  
5.2.3 算法描述 29  
5.3 ADABOOST提升朴素贝叶斯文本分类 32  
5.4 多类问题 33  
5.4.1 AdaBoost.M1算法 33  
5.4.2 AdaBoost.SAMME 34  
5.4.3 AdaBoost.SAMME.R 34  
5.5 实验 35  
5.5.1 二分类 36  
5.5.2 多分类 37  
5.6 本章小结 39  
第六章 总结与展望 40  
6.1 本文主要内容总结 40  
6.2 存在问题及未来研究展望 40  
参考文献 42  
致 谢 44  
本文按照传统的文本分析方法，并根据微博的特点进行了情感分析。主要在以下方面展开了研究：  
（1）对微博的降噪清理。从微博短文本的的特点，分析了采用Hash方法的URL并将其过滤，并将跟情感分析无关的用户名等进行过滤。进一步的，论文对微博中表达的情感基本单元也有深入的研究，通过对文本中的广义表情符号、重复单词等现象。  
（2）对无关性的微博本文进行过滤。众所周知，微博已经为热点事件的传播平台，同时，也带来了大量无关的广告、重复字词（“分享图片”）等。本文利用了SVC对文本中无关性的微博进行了过滤。  
（3）使用了朴素贝叶斯对微博进行情感分类。基于贝叶斯定理和特征独立的朴素贝叶斯方法，在文本分类中有极其明显的优点。  
（4）使用AdaBoost算法对朴素贝叶斯进行加强。将朴素贝叶斯作为AdaBoost的弱分类器，然后对其进行加强。有效的提高了情感分类的准确性。  
3.3 实验  
3.3.1 选取特征  
选取特征就是选出分类对象中所展现的部分特点，用来实现分类的依据。举个例子：  
能拿奖品这种事一定要和大家说一说的，否则以后还怎么在一起愉快的玩耍\[酷\]我正在领取\#微博等级专享礼\#，这里的奖品太给力了，快去试试人品吧http://t.cn/RLAxtki。  
特征是从大量的文本中选举出来的高频词，假设样本中有许多类似这样的句子，那么由上面该句子我们可以知道，“奖品”、“微博等级”是该句子的高频词，也是影响其分类的主要特征。  
3.3.2 降噪  
在上面这个例子中，经过降噪处理后：  
\[‘拿’, ‘这种’, ‘否则’, ‘愉快’, ‘我’, ‘说’, ‘力’, ‘以后’, ‘大家’, ‘太’, ‘博’, ‘一起’, ‘\[酷\]’, ‘在’, ‘还’, ‘奖品’, ‘了’, ‘给’, ‘事’, ‘吧’, ‘礼’, ‘\#’, ‘这里’, ‘能’, ‘等级’, ‘专’, ‘要’, ‘人品’, ‘试试’, ‘怎么’, ‘正’, ‘微’, ‘享’, ‘的’, ‘领取’, ‘一’, ‘和’, ‘去’, ‘，’, ‘快’, ‘一定’, ‘玩耍’\]  
3.3.3 特征降维  
特征降维,即降低特征的维数，降低复杂度。在自然语言处理中，多余的特征有时候会影响或误导学习器，特征太多就需要调整更多的参数，过拟合的风险也就越大。本文中，主要是把无关或冗余的特征删掉，特征数量减少了之后不经能够可以加快算法计算的速度，还可以减少干扰，提高分类的准确率。在自然语言处理中，主要是通过一定的统计方法来找出信息量丰富的特征。其中，这些方法包括：信息熵、卡方统计、词频、文档频率、互信息等。  
本文中，使用的是词频统计，也就是选在语料库中出现频率高的词。比如我可以选择语料库中词频最高的n个词（降噪后）作为特征。之后，再将所有的原始文本转化为特征表示的形式。  
3.3.4 将文本样本变成特征显示  
所以，上诉文本经过选取特征之后如下：  
\[\{‘试试’: ‘True’, ‘正’: ‘True’, ‘礼’: ‘True’, ‘人品’: ‘True’, ‘专’: ‘True’, ‘力’: ‘True’, ‘事’: ‘True’, ‘玩耍’: ‘True’, ‘说’: ‘True’, ‘博’: ‘True’, ‘微’: ‘True’, ‘\[酷\]’: ‘True’, ‘享’: ‘True’, ‘奖品’: ‘True’, ‘领取’: ‘True’, ‘太’: ‘True’, ‘等级’: ‘True’, ‘愉快’: ‘True’\}, ‘adv’\]  
3.3.5 将文本随机分成训练集、测试集  
在机器学习分类中，必须要有一定的数据用来训练，一定的数据用来测试，这样才能获取该分类器的准确度，之后可以根据实际情况构建出一个高效的分类器。  
本文使用python中的random里的shuffle来将数据随机化，之后再将文本分为训练集和测试集。  
3.3.6 进行训练和预测  
我们使用python scikitlearn中的LinearSVC进行训练和预测，然后进行训练和预测，对实验中进行二十次迭代，得出结果绘制成图表如图3.3所示。  
![在这里插入图片描述][ff9828c937fe45e8b00658da91f5df34.png]

图3.3 实验结果

from __future__ import division, print_function
    import os
    import numpy as np
    import random as rnd
    filepath = os.path.dirname(os.path.abspath(__file__))
    
    class SVM():
        """
            使用SMO实现支持向量
        """
        def __init__(self, max_iter=10000, kernel_type='linear', C=1.0, epsilon=0.001):
            self.kernels = {
        
                'linear' : self.kernel_linear,
                'quadratic' : self.kernel_quadratic
            }
            self.max_iter = max_iter
            self.kernel_type = kernel_type
            self.C = C
            self.epsilon = epsilon
        def fit(self, X, y):
            # 初始化
            n, d = X.shape[0], X.shape[1]
            alpha = np.zeros((n))
            kernel = self.kernels[self.kernel_type]
            count = 0
            while True:
                count += 1
                alpha_prev = np.copy(alpha)
                for j in range(0, n):
                    i = self.get_rnd_int(0, n-1, j) # 随机 i~=j
                    x_i, x_j, y_i, y_j = X[i,:], X[j,:], y[i], y[j]
                    k_ij = kernel(x_i, x_i) + kernel(x_j, x_j) - 2 * kernel(x_i, x_j)
                    if k_ij == 0:
                        continue
                    alpha_prime_j, alpha_prime_i = alpha[j], alpha[i]
                    (L, H) = self.compute_L_H(self.C, alpha_prime_j, alpha_prime_i, y_j, y_i)
    
                    self.w = self.calc_w(alpha, y, X)
                    self.b = self.calc_b(X, y, self.w)
    
                    E_i = self.E(x_i, y_i, self.w, self.b)
                    E_j = self.E(x_j, y_j, self.w, self.b)
    
                    alpha[j] = alpha_prime_j + float(y_j * (E_i - E_j))/k_ij
                    alpha[j] = max(alpha[j], L)
                    alpha[j] = min(alpha[j], H)
    
                    alpha[i] = alpha_prime_i + y_i*y_j * (alpha_prime_j - alpha[j])
    
                # 检测
                diff = np.linalg.norm(alpha - alpha_prev)
                if diff < self.epsilon:
                    break
    
                if count >= self.max_iter:
                    print("Iteration number exceeded the max of %d iterations" % (self.max_iter))
                    return
            # 实现完整模型元素
            self.b = self.calc_b(X, y, self.w)
            if self.kernel_type == 'linear':
                self.w = self.calc_w(alpha, y, X)
            # 获得支持向量
            alpha_idx = np.where(alpha > 0)[0]
            support_vectors = X[alpha_idx, :]
            return support_vectors, count
        def predict(self, X):
            return self.h(X, self.w, self.b)
        def calc_b(self, X, y, w):
            b_tmp = y - np.dot(w.T, X.T)
            return np.mean(b_tmp)
        def calc_w(self, alpha, y, X):
            return np.dot(alpha * y, X)
        # 预测
        def h(self, X, w, b):
            return np.sign(np.dot(w.T, X.T) + b).astype(int)
        # 预测错误
        def E(self, x_k, y_k, w, b):
            return self.h(x_k, w, b) - y_k
        def compute_L_H(self, C, alpha_prime_j, alpha_prime_i, y_j, y_i):
            if(y_i != y_j):
                return (max(0, alpha_prime_j - alpha_prime_i), min(C, C - alpha_prime_i + alpha_prime_j))
            else:
                return (max(0, alpha_prime_i + alpha_prime_j - C), min(C, alpha_prime_i + alpha_prime_j))
        def get_rnd_int(self, a,b,z):
            i = z
            while i == z:
                i = rnd.randint(a,b)
            return i
        # Define kernels
        def kernel_linear(self, x1, x2):
            return np.dot(x1, x2.T)
        def kernel_quadratic(self, x1, x2):
            return (np.dot(x1, x2.T) ** 2)

![在这里插入图片描述][0bced471530b4fcd926e6dcb7b84ad47.png_pic_center]  
![在这里插入图片描述][1885760158d341f09524b1a20c78ff02.png_pic_center]  
![在这里插入图片描述][4dfae058f5c44df8899a6839d0134299.png_pic_center]  
![在这里插入图片描述][3937818bb23c42e8a389d1b751f2cbd7.png_pic_center]  
![在这里插入图片描述][4d41f56aa830451685d6515e78b2c7c0.png_pic_center]  
![在这里插入图片描述][dc7264d2533a48dda5de2ae6d4110b7b.png_pic_center]  
![在这里插入图片描述][44e4d939005544e4b63646977a0e5a79.png_pic_center]  
![在这里插入图片描述][7938391ff80d47c2b2ea044c319d5482.png_pic_center]  
![在这里插入图片描述][7ead5471270f4640bf5c56cb69c5fafb.png_pic_center]  
![在这里插入图片描述][10ceea4e26c8422aacc1aa490303d09f.png_pic_center]

[ff9828c937fe45e8b00658da91f5df34.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/e1f48836f86a4b0babd1ca21c86fde88.png
[0bced471530b4fcd926e6dcb7b84ad47.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/b2c45748d34d4792946473fb9005bece.png
[1885760158d341f09524b1a20c78ff02.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/3ccd4ee203ee42fea90ec836f4ceb62d.png
[4dfae058f5c44df8899a6839d0134299.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/3e4782092dd942cf92a951c12aff54df.png
[3937818bb23c42e8a389d1b751f2cbd7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/478929232bf54248a4a8949aaf33c0ab.png
[4d41f56aa830451685d6515e78b2c7c0.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/ac586ff788764a81bd2f8d45ae16f942.png
[dc7264d2533a48dda5de2ae6d4110b7b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/e90c8c489b184db4b50172990b50ae18.png
[44e4d939005544e4b63646977a0e5a79.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/bf7bb8dbce6c46eca35b162a0a8ef108.png
[7938391ff80d47c2b2ea044c319d5482.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/22eb9fbab14d4f23a94ae086b76bf052.png
[7ead5471270f4640bf5c56cb69c5fafb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/4902ed48a60f49268dd59adda1292a0c.png
[10ceea4e26c8422aacc1aa490303d09f.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/1c276fd89b404b3d8033efa7ec772eaa.png