精华内容
下载资源
问答
  • 2020-10-11 11:23:48

    摘要:本文旨在对情感分类任务的工作流程做一个简单的梳理,总结了大体框架,及一些需要注意的细节问题,作为总结。

    目录

    标题1.文本预处理

    标题2.词带模型做文本表征

    标题3.word2vec做词表征

    标题4.用处理好的表征训练模型进行分类


    标题1.文本预处理

    无论用哪种模型进行文本表征或分类,第一步肯定是对数据进行预处理,做特征工程。

    对影评数据做预处理,大概有以下环节:

    1.用pandas读入数据,理解数据(可视化分析/统计信息)

    对数据的理解是任何AI工作的第一步,需要充分对手上的数据有个更直观的理解。
    
    统计一下在qlist 总共出现了多少个单词? 总共出现了多少个不同的单词?
    
    统计一下qlist中每个单词出现的频率,并把这些频率排一下序,然后画成plot. 

    2.去掉html标签

    from bs4 import BeautifulSoup
    # BeautifulSoup是一个专门处理网页爬下来的文本的库,可将里边的各种字符去掉。
    example = BeautifulSoup(raw_example, 'html.parser').get_text()

    3.移除标点

    # 一般需要正则
    example_letters = re.sub(r'[^a-zA-Z]', ' ', example)

    4. 切分成词/token

    words = example_letters.lower().split()

    5. 去掉停用词

    # 停用词可以用本地的也可用nltk等库里的,根据情况自己定
    #words_nostop = [w for w in words if w not in stopwords.words('english')]
    stopwords = {}.fromkeys([ line.rstrip() for line in open('../stopwords.txt')])
    words_nostop = [w for w in words if w not in stopwords]

    6. 重组为新的句子

    #eng_stopwords = set(stopwords.words('english'))
    eng_stopwords = set(stopwords)
    
    def clean_text(text):
        text = BeautifulSoup(text, 'html.parser').get_text()
        text = re.sub(r'[^a-zA-Z]', ' ', text)
        words = text.lower().split()
        words = [w for w in words if w not in eng_stopwords]
        return ' '.join(words)

    7. 另外还可以做stemming,lemenazitong(英文),去掉低频词,正则处理一些表情符号,邮箱等。这里需注意:Word2vec是需要上下文关系的,这里的停用词有时候不去掉效果可能会更好。

    标题2.词带模型做文本表征

    word2vec出现之前通常用词带模型进行表征,即每个词作为一个特征(通常取整个语料的前5000个词),词频作为特征值,进行文本表示。需用到sklearn中的countevectorizer方法。

    from sklearn.feature_extraction.text import CountVectorizer
    
    vectorizer = CountVectorizer(max_features = 5000) 
    train_data_features = vectorizer.fit_transform(df.clean_review).toarray()

     

    标题3.word2vec做词表征

    1.首先,第一步也是做预处理(如标题1)

    tokenizer = nltk.data.load('tokenizers/punkt/english.pickle')
    
    raw_sentences = tokenizer.tokenize(review.strip())
    sentences = [clean_text(s) for s in raw_sentences if s]
    
    # nltk.data.load('tokenizers/punkt/english.pickle')加载英文的划分句子的模型
    
    #tokenizers/punkt/ 这里面有好多训练好的模型,只能划分成句子,不能划分成单词

     2.用gensim训练处理好的文本

    model = Word2Vec(sentences, workers=num_workers, \
                size=num_features, min_count = min_word_count, \
                window = context, sample = downsampling)
    
    # If you don't plan to train the model any further, calling 
    # init_sims will make the model much more memory-efficient.
    model.init_sims(replace=True)
    
    # It can be helpful to create a meaningful model name and 
    # save the model for later use. You can load it later using Word2Vec.load()
    model.save(os.path.join('..', 'models', model_name))

    3.保存加载模型方法:

    # 保存模型
    # 第一种方法保存的文件不能利用文本编辑器查看,但是保存了训练的全部信息,可以在读取后追加训练
    # 后一种方法保存为word2vec文本格式,但是保存时丢失了词汇树等部分信息,不能追加训练
    
    model.save(os.path.join('..', 'models', model_name))
    
    model.wv.save_word2vec_format(os.path.join('..','models','word2vec_txt.txt'),binary = False)
    # 加载模型,根据保存时的格式不同,有两种加载方式
    
    model = models.Word2Vec.load(os.path.join('..', 'models', model_name))
    model_txt = models.KeyedVectors.load_word2vec_format(os.path.join('..','models','word2vec_txt.txt'),binary = False)
    
    # 可以同时取出一个句子中单词的词向量
    model.wv[['man','woman','guy']]

     

    标题4.用处理好的表征训练模型进行分类

     

    1.根据word2vec的结果去对影评文本进行编码,编码方式有一点粗暴,简单说来就是把这句话中的词的词向量做平均

    def to_review_vector(review):
        words = clean_text(review, remove_stopwords=True)
        array = np.array([model[w] for w in words if w in model])
        return pd.Series(array.mean(axis=0))

    2. 用随机森林分类器进行训练:

    forest = RandomForestClassifier(n_estimators = 100, random_state=42)
    forest = forest.fit(train_data_features, df.sentiment) 
    
    

     

     

    参考:

    https://www.cnblogs.com/Luv-GEM/p/10890010.html

    https://blog.csdn.net/YoungshellZzz/article/details/88385801

    https://blog.csdn.net/pit3369/article/details/95594728讲解了word2vec结合k-means聚类进行关键词提取的方法

    更多相关内容
  • word2vec情感分析实例

    2017-08-01 08:40:52
    python平台情感分析实例,使用gensim中的doc2vec实现,可用于新版gensim。
  • python实现了情感分析的完整项目,包含训练样本,训练好的模型,完整代码。python实现了情感分析的完整项目,包含训练样本,训练好的模型,完整代码。python实现了情感分析的完整项目,包含训练样本,训练好的模型,...
  • python实现情感分析Word2Vec) ** 前几天跟着老师做了几个项目,老师写的时候劈里啪啦一顿敲,写了个啥咱也布吉岛,线下自己就瞎琢磨,终于实现了一个最简单的项目。输入文本,然后分析情感,判断出是好感还是反感...
  • Word2Vec实现情感分析(bug修正)

    千次阅读 2022-01-17 21:06:18
    python实现情感分析Word2Vec) ** 前几天跟着老师做了几个项目,老师写的时候劈里啪啦一顿敲,写了个啥咱也布吉岛,线下自己就瞎琢磨,终于实现了一个最简单的项目。输入文本,然后分析情感,判断出是好感还是...

    python实现情感分析(Word2Vec

    ** 前几天跟着老师做了几个项目,老师写的时候劈里啪啦一顿敲,写了个啥咱也布吉岛,线下自己就瞎琢磨,终于实现了一个最简单的项目。输入文本,然后分析情感,判断出是好感还是反感。看最终结果:↓↓↓↓↓↓

    在这里插入图片描述

    在这里插入图片描述

    •加载数据,预处理

    数据就是正反两类,保存在neg.xls和pos.xls文件中,

    在这里插入图片描述

    数据内容类似购物网站的评论,分别有一万多个好评和一万多个差评,通过对它们的处理,变成我们用来训练模型的特征和标记。
    首先导入几个python常见的库,train_test_split用来对特征向量的划分,numpy和pands是处理数据常见的库,jieba库用来分词,joblib用来保存训练好的模型,sklearn.svm是机器学习训练模型常用的库,我觉得核心的就是Word2Vec这个库了,作用就是将自然语言中的字词转为计算机可以理解的稠密向量。

    from sklearn.model_selection import train_test_split
    import numpy as np
    import pandas as pd
    import jieba as jb
    from sklearn.externals import joblib
    from sklearn.svm import SVC
    from gensim.models.word2vec import Word2Vec
    

     加载数据,将数据分词,将正反样本拼接,然后创建全是0和全是1的向量拼接起来作为标签

    neg =pd.read_excel("data/neg.xls",header=None)
    pos =pd.read_excel("data/pos.xls",header=None)
    # 这是两类数据都是x值
    pos['words'] = pos[0].apply(lambda x:list(jb.cut(x)))
    neg['words'] = neg[0].apply(lambda x:list(jb.cut(x)))
    #需要y值  0 代表neg 1代表是pos
    y = np.concatenate((np.ones(len(pos)),np.zeros(len(neg))))
    X = np.concatenate((pos['words'],neg['words']))
    

    •词向量计算
    网上搜到的专业解释是这样说的:使用一层神经网络将one-hot(独热编码)形式的词向量映射到分布式形式的词向量。使用了Hierarchical softmax, negative sampling等技巧进行训练速度上的优化。作用:我们日常生活中使用的自然语言不能够直接被计算机所理解,当我们需要对这些自然语言进行处理时,就需要使用特定的手段对其进行分析或预处理。使用one-hot编码形式对文字进行处理可以得到词向量,但是,由于对文字进行唯一编号进行分析的方式存在数据稀疏的问题,Word2Vec能够解决这一问题,实现word embedding
    专业解释的话我还是一脸懵,后来看了一个栗子,大概是这样:
    word2vec也叫word embeddings,中文名“词向量”,作用就是将自然语言中的字词转为计算机可以理解的稠密向量(Dense Vector)。在word2vec出现之前,自然语言处理经常把字词转为离散的单独的符号,也就是One-Hot Encoder。

    X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=3)
    #保存数据
    np.save("data/y_train.npy",y_train)
    np.save("data/y_test.npy",y_test)
    

    •词向量计算
    网上搜到的专业解释是这样说的:使用一层神经网络将one-hot(独热编码)形式的词向量映射到分布式形式的词向量。使用了Hierarchical softmax, negative sampling等技巧进行训练速度上的优化。作用:我们日常生活中使用的自然语言不能够直接被计算机所理解,当我们需要对这些自然语言进行处理时,就需要使用特定的手段对其进行分析或预处理。使用one-hot编码形式对文字进行处理可以得到词向量,但是,由于对文字进行唯一编号进行分析的方式存在数据稀疏的问题,Word2Vec能够解决这一问题,实现word embedding
    专业解释的话我还是一脸懵,后来看了一个栗子,大概是这样:
    word2vec也叫word embeddings,中文名“词向量”,作用就是将自然语言中的字词转为计算机可以理解的稠密向量(Dense Vector)。在word2vec出现之前,自然语言处理经常把字词转为离散的单独的符号,也就是One-Hot Encoder。
    在这图片描述

    在语料库中,杭州、上海、宁波、北京各对应一个向量,向量中只有一个值为1,其余都为0。但是使用One-Hot Encoder有以下问题。一方面,城市编码是随机的,向量之间相互独立,看不出城市之间可能存在的关联关系。其次,向量维度的大小取决于语料库中字词的多少。如果将世界所有城市名称对应的向量合为一个矩阵的话,那这个矩阵过于稀疏,并且会造成维度灾难。
    使用Vector Representations可以有效解决这个问题。Word2Vec可以将One-Hot Encoder转化为低维度的连续值,也就是稠密向量,并且其中意思相近的词将被映射到向量空间中相近的位置。
    如果将embed后的城市向量通过PCA降维后可视化展示出来,那就是这个样子。
    在这里插入图片描述

    •计算词向量 

    def get_train_vecs(x_train,x_test):
        #初始化模型和词表
        twitter_w2v = Word2Vec(vector_size=300,min_count=10)
        twitter_w2v.build_vocab(x_train)
    
        # 训练并建模
        twitter_w2v.train(x_train,total_examples=1, epochs=1)
        #获取train_vecs
        train_vecs = np.concatenate([ build_vector(z,300,twitter_w2v.wv) for z in x_train])
        #保存处理后的词向量
        np.save('data/train_vecs.npy',train_vecs)
        #保存模型
        twitter_w2v.save("data/model3.pkl")
    
        twitter_w2v.train(x_test,total_examples=1, epochs=1)
        test_vecs = np.concatenate([build_vector(z,300,twitter_w2v.wv) for z in x_test])
        np.save('data/test_vecs.npy',test_vecs)

     •对句子中的所有词向量取均值,来生成一个句子的vec

    def build_vector(text,size,wv):
        #创建一个指定大小的数据空间
        vec = np.zeros(size).reshape((1,size))
        #count是统计有多少词向量
        count = 0
        #循环所有的词向量进行求和
        for w in text:
            try:
                vec +=  wv[w].reshape((1,size))
                count +=1
            except:
                continue
            
        #循环完成后求均值
        if count!=0:
            vec/=count
        return vec
    

     以上是比较难的代码讲解,如若跑完整项目代码只需要以下两部

    1.运行train.py训练模型

    2.运行predict.py预测

    代码和数据集已上传git仓库,链接放在本文最末尾

    train.py代码

    from sklearn.model_selection import train_test_split
    import numpy as np
    import pandas as pd
    import jieba as jb
    import joblib
    from sklearn.svm import SVC
    from gensim.models.word2vec import Word2Vec
    
    
    def load_file_and_preprocessing():
        neg =pd.read_excel("data/neg.xls",header=None)
        pos =pd.read_excel("data/pos.xls",header=None)
        # 这是两类数据都是x值
        pos['words'] = pos[0].apply(lambda x:list(jb.cut(x)))
        neg['words'] = neg[0].apply(lambda x:list(jb.cut(x)))
        #需要y值  0 代表neg 1代表是pos
        y = np.concatenate((np.ones(len(pos)),np.zeros(len(neg))))
        X = np.concatenate((pos['words'],neg['words']))
        # 切分训练集和测试集
        X_train,X_test,y_train,y_test = train_test_split(X,y,test_size=0.2,random_state=3)
        #保存数据
        np.save("data/y_train.npy",y_train)
        np.save("data/y_test.npy",y_test)
    
        return X_train,X_test
    
    def build_vector(text,size,wv):
        #创建一个指定大小的数据空间
        vec = np.zeros(size).reshape((1,size))
        #count是统计有多少词向量
        count = 0
        #循环所有的词向量进行求和
        for w in text:
            try:
                vec +=  wv[w].reshape((1,size))
                count +=1
            except:
                continue
    
        #循环完成后求均值
        if count!=0:
            vec/=count
        return vec
    
    def get_train_vecs(x_train,x_test):
        #初始化模型和词表
        twitter_w2v = Word2Vec(vector_size=300,min_count=10)
        twitter_w2v.build_vocab(x_train)
    
        # 训练并建模
        twitter_w2v.train(x_train,total_examples=1, epochs=1)
        #获取train_vecs
        train_vecs = np.concatenate([ build_vector(z,300,twitter_w2v.wv) for z in x_train])
        #保存处理后的词向量
        np.save('data/train_vecs.npy',train_vecs)
        #保存模型
        twitter_w2v.save("data/model3.pkl")
    
        twitter_w2v.train(x_test,total_examples=1, epochs=1)
        test_vecs = np.concatenate([build_vector(z,300,twitter_w2v.wv) for z in x_test])
        np.save('data/test_vecs.npy',test_vecs)
    
    def get_data():
        train_vecs = np.load("data/train_vecs.npy")
        y_train = np.load("data/y_train.npy")
        test_vecs = np.load("data/test_vecs.npy")
        y_test = np.load("data/y_test.npy")
        return train_vecs,y_train,test_vecs,y_test
    
    def suc_train(train_vecs,y_train,test_vecs,y_test):
        #创建SVC模型
        cls = SVC(kernel="rbf",verbose=True)
        #训练模型
        cls.fit(train_vecs,y_train)
        #保存模型
        joblib.dump(cls,"data/svcmodel.pkl")
        #输出评分
        print(cls.score(test_vecs,y_test))
    
    def get_predict_vecs(words):
        # 加载模型
        wv = Word2Vec.load("data/model3.pkl")
        #将新的词转换为向量
        train_vecs = build_vector(words,300,wv)
        return train_vecs
    
    def svm_predict(string):
        # 对语句进行分词
        words = jb.cut(string)
        # 将分词结果转换为词向量
        word_vecs = get_predict_vecs(words)
        #加载模型
        cls = joblib.load("data/svcmodel.pkl")
        #预测得到结果
        result = cls.predict(word_vecs)
        #输出结果
        if result[0]==1:
            print("pos")
        else:
            print("neg")
    
    def train():
        x_train,x_test = load_file_and_preprocessing()
        get_train_vecs(x_train,x_test)
        train_vecs,y_train,test_vecs,y_test = get_data()
        suc_train(train_vecs,y_train,test_vecs,y_test)
    
    train()
    
    string = "这本书非常好,我喜欢"
    
    svm_predict(string)
    
    

    predict.py代码

    from tkinter import *
    import numpy as np
    import jieba as jb
    import joblib
    from gensim.models.word2vec import Word2Vec
    
    import sys
    from os import path
    sys.path.append( path.dirname( path.dirname( path.abspath(__file__) ) ) )
    
    
    class core():
        def __init__(self,str):
            self.string=str
    
        def build_vector(self,text,size,wv):
            #创建一个指定大小的数据空间
            vec = np.zeros(size).reshape((1,size))
            #count是统计有多少词向量
            count = 0
            #循环所有的词向量进行求和
            for w in text:
                try:
                    vec +=  wv[w].reshape((1,size))
                    count +=1
                except:
                    continue
            #循环完成后求均值
            if count!=0:
                vec/=count
            return vec
        def get_predict_vecs(self,words):
            # 加载模型
            twitter_w2v = Word2Vec.load("data/model3.pkl")
            #将新的词转换为向量
            train_vecs = self.build_vector(words,300,twitter_w2v.wv)
            return train_vecs
        def svm_predict(self,string):
            # 对语句进行分词
            words = jb.cut(string)
            # 将分词结果转换为词向量
            word_vecs = self.get_predict_vecs(words)
            #加载模型
            cls = joblib.load("data/svcmodel.pkl")
            #预测得到结果
            result = cls.predict(word_vecs)
            #输出结果
            if result[0]==1:
                return "好感"
            else:
                return "反感"
        def main(self):
            s=self.svm_predict(self.string)
            return s
    
    root=Tk()
    root.title("情感分析")
    sw = root.winfo_screenwidth()
    #得到屏幕宽度
    sh = root.winfo_screenheight()
    #得到屏幕高度
    ww = 500
    wh = 300
    x = (sw-ww) / 2
    y = (sh-wh) / 2-50
    root.geometry("%dx%d+%d+%d" %(ww,wh,x,y))
    # root.iconbitmap('tb.ico')
    
    lb2=Label(root,text="输入内容,按回车键分析")
    lb2.place(relx=0, rely=0.05)
    
    txt = Text(root,font=("宋体",20))
    txt.place(rely=0.7, relheight=0.3,relwidth=1)
    
    inp1 = Text(root, height=15, width=65,font=("宋体",18))
    inp1.place(relx=0, rely=0.2, relwidth=1, relheight=0.4)
    
    def run1():
        txt.delete("0.0",END)
        a = inp1.get('0.0',(END))
        p=core(a)
        s=p.main()
        print(s)
        txt.insert(END, s)   # 追加显示运算结果
    
    def button1(event):
        btn1 = Button(root, text='分析', font=("",12),command=run1) #鼠标响应
        btn1.place(relx=0.35, rely=0.6, relwidth=0.15, relheight=0.1)
        # inp1.bind("<Return>",run2) #键盘响应
    
    button1(1)
    root.mainloop()

     

      

    github链接:GitHub - fengjun321/Language

    展开全文
  • word2vec,svm情感分析代码
  • 里面包含三个文件,text8.dev.txt、text8.test.txt、text8.train.txt。
  • 情感分析--word2vec

    2019-12-10 15:11:45
    from gensim.models.word2vec import Word2Vec model = Word2Vec(size=400,min_count=5) model.build_vocab(x_train) model.build_vocab(x_train) model.wv.most_similar("好",topn=100) model.wv.most...
    分词–list of list格式

    (df2的来源请看上一篇博客https://blog.csdn.net/dongzixian/article/details/103474094

    import jieba
    df2['cut'] = df2[0].apply(jieba.lcut)
    df2.head()
    

    在这里插入图片描述

    from sklearn.model_selection import train_test_split
    x_train,x_test,y_train,y_test = train_test_split(df2['cut'],df2['class'],test_size=0.3)
    x_train
    

    在这里插入图片描述

    from gensim.models.word2vec import Word2Vec
    model = Word2Vec(size=400,min_count=5)
    model.build_vocab(x_train)
    
    model.build_vocab(x_train)
    

    在这里插入图片描述

    model.wv.most_similar("好",topn=100)
    

    在这里插入图片描述

    model.wv.most_similar("不好",topn=100)
    

    在这里插入图片描述

    model.wv["不好"]
    

    在这里插入图片描述

    生成句向量
    print(df2.cut[0])#(第一条)
    print("第一条评论分词后词个数为:",len(df2.cut[0]))
    

    在这里插入图片描述

    将第一条评论转成word2vec矩阵
    pd.DataFrame([model.wv[i] for i in df2.cut[0] if i in model.wv])
    

    在这里插入图片描述

    将第一条评论转成向量
    vec1 = pd.DataFrame([model.wv[i] for i in df2.cut[0] if i in model.wv]).mean()
    print(vec1)
    

    在这里插入图片描述
    在这里插入图片描述

    生成word2vec句向量

    def sen2vec(words):
        return  pd.DataFrame([model.wv[i] for i in df2.cut[0] if i in model.wv]).mean()
    train_vec =  pd.DataFrame([sen2vec(s) for s in x_train])
    train_vec
    

    分类模型–支持向量机

    from sklearn.svm import SVC
    clf2 = SVC()
    clf2.fit(train_vec,y_train)
    

    在这里插入图片描述

    clf2.score(train_vec,y_train)
    

    在这里插入图片描述

    SVM

    from sklearn.metrics import classification_report
    print(classification_report(y_train,clf2.predict(train_vec)))
    

    在这里插入图片描述

    生成测试集word2vec句向量

    def sen2vec(words):
        return  pd.DataFrame([model.wv[i] for i in words if i in model.wv]).mean()
    test_vec =  pd.DataFrame([sen2vec(s) for s in x_test])
    test_vec
    
    clf2.score(test_vec,y_test)
    

    在这里插入图片描述

    from sklearn.metrics import classification_report
    print(classification_report(y_test,clf2.predict(test_vec)))
    

    在这里插入图片描述

    预测新评论

    s = """...新评论..."""
    
    s_seg1 = jieba.lcut(s)
    s_word2vec = pd.DataFrame([model.wv[i] for i in s_seg1 if i in model.wv])
    s_word2vec 
    
    s_vec = s_word2vec.mean()
    s_vec
    
    import numpy as np
    s_vec = np.array(s_vec)
    s_vec = s_vec.reshape(1,-1)
    result_svm = clf2.predict(s_vec)
    result_sum
    
    展开全文
  • LSTM+word2vec电影情感分析 import numpy as np import matplotlib.pyplot as plt import pandas as pd from sklearn.preprocessing import LabelEncoder from sklearn.model_selection import train_test_split ...

    LSTM+word2vec电影情感分析

    import numpy as np
    import matplotlib.pyplot as plt
    import pandas as pd
    from sklearn.preprocessing import LabelEncoder
    from sklearn.model_selection import train_test_split
    from sklearn.utils import shuffle
    from nltk.corpus import stopwords
    from plot_result import plot_history
    from tensorflow import keras
    from tensorflow.keras.preprocessing.text import Tokenizer
    
    data = pd.read_csv('dataset/labeledTrainData.tsv', sep='\t', usecols=['sentiment', 'review'])
    data.head()
    
    sentimentreview
    01With all this stuff going down at the moment w...
    11\The Classic War of the Worlds\" by Timothy Hi...
    20The film starts with a manager (Nicholas Bell)...
    30It must be assumed that those who praised this...
    41Superbly trashy and wondrously unpretentious 8...
    # 定义函数进行简单的文本处理
    def detail_text(w):
        import re
        # text = re.sub(r"([?,.!])", r" \1", w)
        # text = re.sub(r'[" "]+', " ", text)
        # text = re.sub(r'[^a-zA-Z?,!.]+', " ", text)
        token = re.compile('[A-Za-z]+|[!?,.()]')
        text = token.findall(w)
        new_text = [word.lower() for word in text if word not in stopwords.words('english') and len(word) > 2]
        return new_text
    
    data['review'] = data.review.apply(detail_text)
    data['review'][0]
    
    ['with',
     'stuff',
     'going',
     'moment',
     'started',
     ························
     ························
     'stupid',
     'guy',
     'one',
     'sickest',
     'liars',
     'hope',
     'latter']
    
    # 构建x y
    sentences = data.review.values
    y = data.sentiment.values
    
    sentences_train, sentences_test, y_train, y_test = train_test_split(sentences, y, test_size=0.25, random_state=1000)
    
    max_words = 20000
    # 创建Tokenizer对象
    tokenizer = Tokenizer(num_words=max_words)
    tokenizer.fit_on_texts(sentences_train)
    tokenizer.fit_on_texts(sentences_test)
    # 将text转成序列
    X_train = tokenizer.texts_to_sequences(sentences_train)
    X_test = tokenizer.texts_to_sequences(sentences_test)
    print(X_train[0])
    
    [271, 286, 13, 17, 3, 834, 6, 552, 14, 565, 437, 7, 4, 107, 17, 3, 2362, 244, 5130, 133, 311, 1100, 2669, 540, 942, 5130, 1283, 3025, 581, 750, 943, 944, 6665, 5131, 6666, 5132, 46, 51, 26, 386, 3026, 6667, 6665, 5131, 3497, 6668, 1654, 6669, 5133, 945, 942, 366, 387, 1655, 1284, 62, 290, 9578, 438, 1041, 6670, 245, 472, 134, 122, 515, 2363, 9579, 863, 12, 105, 116, 138, 344, 3498, 348, 18, 327, 3499, 9580, 41, 1799, 6671, 2142, 607, 22, 2670, 93, 17, 1154, 1042, 3, 3500, 117, 3500, 1800, 1043, 140, 277, 1100, 5134, 4231, 300, 66, 1801, 301, 96, 1101, 1101, 516, 5130, 141, 291, 2671, 6672, 311, 70, 133, 9581, 751, 49, 192, 337, 73, 66, 2143, 6673, 35, 123, 946, 2144, 699, 9582, 24, 903, 161, 439, 9583, 947, 2672, 2, 1363, 1102, 52, 327, 194, 9584, 1364, 226, 234, 566, 150, 499, 388, 2145, 6674, 6675, 2146, 1365, 176, 185, 656, 1366, 1367, 9585, 353, 52, 236, 1560, 9586, 5135, 344, 43, 54, 328, 806, 292, 2, 29, 9587, 1155, 948, 141, 277, 2364, 140, 4232, 1214, 9588, 2365, 176, 135, 71, 608, 18, 197, 2366, 23, 2, 24, 5, 499, 1368, 3, 108, 1368, 3027, 5134, 5136, 105, 2367, 440, 11, 1965, 235, 4, 680]
    
    # 进行pad_sequences
    maxlen = 150
    X_train = keras.preprocessing.sequence.pad_sequences(X_train, padding='post', maxlen=maxlen)
    X_test = keras.preprocessing.sequence.pad_sequences(X_test, padding='post', maxlen=maxlen)
    vocab_size = len(tokenizer.word_index) + 1
    print("vocab_size", vocab_size)
    
    vocab_size 17909
    
    # 使用训练好的word2vec语料库glove.6B.50d.txt   构建词向量  过滤无关词语
    def create_embedding_matrix(filepath, word_index, embedding_dim):
        """
        将自己的词对应的向量在 被人训练好的文本向量模型中找到  对应起来
        """
        vocab_size = len(word_index) + 1  # keras文档中指定需要+1
        embedding_matrix = np.zeros((vocab_size, embedding_dim))
    
        with open(filepath, encoding='utf-8') as f:
            for line in f:
                word, *vector = line.split()
                if word in word_index:
                    idx = word_index[word]
                    embedding_matrix[idx] = np.array(vector, dtype=np.float32)[:embedding_dim]
    
        return embedding_matrix
    
    
    # 构建模型
    embedding_dim = 50
    embedding_matrix = create_embedding_matrix('dataset/glove.6B.50d.txt', tokenizer.word_index, embedding_dim)
    
    model = keras.Sequential()
    model.add(keras.layers.Embedding(vocab_size, embedding_dim,
                               weights=[embedding_matrix],  # 权重不再是随机指定的向量 而是word2vec词向量
                               # input_length=max_len,
                               trainable=True))  # 词嵌入层继续训练
    model.add(keras.layers.LSTM(64, return_sequences=True))  # 输出64维
    model.add(keras.layers.LSTM(64, return_sequences=True))
    model.add(keras.layers.LSTM(128, return_sequences=False))
    model.add(keras.layers.Dense(10, activation='relu'))
    model.add(keras.layers.Dense(1, activation='sigmoid'))
    
    
    opt = keras.optimizers.Adam(lr=0.001)
    model.compile(optimizer=opt, loss='binary_crossentropy', metrics=['acc'])
    model.summary()
    history = model.fit(X_train, y_train,
                         epochs=50,
                         verbose=1,
                         # callbacks=[keras.callbacks.EarlyStopping(patience=2, monitor='val_loss')],
                         validation_data=(X_test, y_test),
                         batch_size=64)
    loss_train5, accuracy = model.evaluate(X_train, y_train, verbose=False)  # verbose=False  不打印训练结果
    print("Training Accuracy: {:.4f}".format(accuracy))
    loss_test5, accuracy = model.evaluate(X_test, y_test, verbose=False)
    print("Testing Accuracy:  {:.4f}".format(accuracy))
    plot_history(history, name='base_Embedding Layer')
    
    Model: "sequential"
    _________________________________________________________________
    Layer (type)                 Output Shape              Param #   
    =================================================================
    embedding (Embedding)        (None, None, 50)          895450    
    _________________________________________________________________
    lstm (LSTM)                  (None, None, 64)          29440     
    _________________________________________________________________
    lstm_1 (LSTM)                (None, None, 64)          33024     
    _________________________________________________________________
    lstm_2 (LSTM)                (None, 128)               98816     
    _________________________________________________________________
    dense (Dense)                (None, 10)                1290      
    _________________________________________________________________
    dense_1 (Dense)              (None, 1)                 11        
    =================================================================
    Total params: 1,058,031
    Trainable params: 1,058,031
    Non-trainable params: 0
    _________________________________________________________________
    Epoch 1/50
    12/12 [==============================] - 7s 361ms/step - loss: 0.6918 - acc: 0.4593 - val_loss: 0.6883 - val_acc: 0.6000
    Epoch 2/50
    12/12 [==============================] - 3s 265ms/step - loss: 0.6914 - acc: 0.5462 - val_loss: 0.6868 - val_acc: 0.5760
    Epoch 3/50
    12/12 [==============================] - 3s 263ms/step - loss: 0.6801 - acc: 0.5928 - val_loss: 0.6753 - val_acc: 0.6280
    Epoch 4/50
    12/12 [==============================] - 3s 267ms/step - loss: 0.6393 - acc: 0.5929 - val_loss: 0.6576 - val_acc: 0.5960
    Epoch 5/50
    12/12 [==============================] - 3s 296ms/step - loss: 0.5889 - acc: 0.6644 - val_loss: 0.6133 - val_acc: 0.6840
    Epoch 6/50
    12/12 [==============================] - 4s 339ms/step - loss: 0.5103 - acc: 0.7634 - val_loss: 0.6980 - val_acc: 0.6440
    Epoch 7/50
    12/12 [==============================] - 4s 336ms/step - loss: 0.5457 - acc: 0.7641 - val_loss: 0.7750 - val_acc: 0.5800
    Epoch 8/50
    12/12 [==============================] - 4s 361ms/step - loss: 0.6201 - acc: 0.6423 - val_loss: 0.6544 - val_acc: 0.5800
    Epoch 9/50
    12/12 [==============================] - 4s 327ms/step - loss: 0.5474 - acc: 0.6986 - val_loss: 0.6293 - val_acc: 0.7120
    Epoch 10/50
    12/12 [==============================] - 4s 359ms/step - loss: 0.4952 - acc: 0.7804 - val_loss: 0.7398 - val_acc: 0.5320
    Epoch 11/50
    12/12 [==============================] - 4s 337ms/step - loss: 0.5603 - acc: 0.6619 - val_loss: 0.7509 - val_acc: 0.5840
    Epoch 12/50
    12/12 [==============================] - 4s 327ms/step - loss: 0.4849 - acc: 0.7315 - val_loss: 0.6508 - val_acc: 0.7200
    Epoch 13/50
    12/12 [==============================] - 4s 334ms/step - loss: 0.4055 - acc: 0.8081 - val_loss: 0.6827 - val_acc: 0.7120
    Epoch 14/50
    12/12 [==============================] - 4s 353ms/step - loss: 0.3476 - acc: 0.8556 - val_loss: 0.7940 - val_acc: 0.6400
    Epoch 15/50
    12/12 [==============================] - 4s 324ms/step - loss: 0.4679 - acc: 0.7623 - val_loss: 0.6620 - val_acc: 0.7280
    Epoch 16/50
    12/12 [==============================] - 4s 369ms/step - loss: 0.3791 - acc: 0.8254 - val_loss: 0.7203 - val_acc: 0.6760
    Epoch 17/50
    12/12 [==============================] - 4s 376ms/step - loss: 0.3724 - acc: 0.8902 - val_loss: 0.6440 - val_acc: 0.6720
    Epoch 18/50
    12/12 [==============================] - 4s 336ms/step - loss: 0.3935 - acc: 0.8351 - val_loss: 0.6178 - val_acc: 0.7480
    Epoch 19/50
    12/12 [==============================] - 4s 334ms/step - loss: 0.2949 - acc: 0.9042 - val_loss: 0.7082 - val_acc: 0.7400
    Epoch 20/50
    12/12 [==============================] - 4s 336ms/step - loss: 0.2276 - acc: 0.9234 - val_loss: 0.7059 - val_acc: 0.7440
    Epoch 21/50
    12/12 [==============================] - 4s 325ms/step - loss: 0.2561 - acc: 0.8967 - val_loss: 0.9920 - val_acc: 0.6080
    Epoch 22/50
    12/12 [==============================] - 4s 324ms/step - loss: 0.3445 - acc: 0.8129 - val_loss: 0.7695 - val_acc: 0.7280
    Epoch 23/50
    12/12 [==============================] - 4s 322ms/step - loss: 0.3999 - acc: 0.7718 - val_loss: 0.6474 - val_acc: 0.6000
    Epoch 24/50
    12/12 [==============================] - 4s 330ms/step - loss: 0.3869 - acc: 0.7256 - val_loss: 1.0462 - val_acc: 0.5400
    Epoch 25/50
    12/12 [==============================] - 4s 348ms/step - loss: 0.5651 - acc: 0.6890 - val_loss: 0.7888 - val_acc: 0.7440
    Epoch 26/50
    12/12 [==============================] - 4s 366ms/step - loss: 0.4958 - acc: 0.8671 - val_loss: 0.5955 - val_acc: 0.7360
    Epoch 27/50
    12/12 [==============================] - 4s 354ms/step - loss: 0.3138 - acc: 0.9130 - val_loss: 0.7231 - val_acc: 0.7160
    Epoch 28/50
    12/12 [==============================] - 4s 330ms/step - loss: 0.2183 - acc: 0.9386 - val_loss: 0.7489 - val_acc: 0.7360
    Epoch 29/50
    12/12 [==============================] - 4s 321ms/step - loss: 0.2112 - acc: 0.9353 - val_loss: 0.8334 - val_acc: 0.7360
    Epoch 30/50
    12/12 [==============================] - 4s 320ms/step - loss: 0.2336 - acc: 0.9256 - val_loss: 0.8929 - val_acc: 0.6800
    Epoch 31/50
    12/12 [==============================] - 4s 325ms/step - loss: 0.2843 - acc: 0.8972 - val_loss: 0.8821 - val_acc: 0.7280
    Epoch 32/50
    12/12 [==============================] - 4s 324ms/step - loss: 0.2211 - acc: 0.9382 - val_loss: 0.8275 - val_acc: 0.6640
    Training Accuracy: 0.5387
    Testing Accuracy:  0.5200
    

    在这里插入图片描述

    总结

    上面LSTM模型结果不理想 最主要的原因是数据太少
    下面是优化代码
    在这里插入图片描述

    # 使用CNN
    model = keras.Sequential()
    # Embedding  输入一般都是语料库大小 (None, 30, 50)  每行文本输入不限制 每次输入30个词  每个词50个维度
    # model.add(keras.layers.Embedding(input_dim=max_words, output_dim=embedding_dim, input_length=maxlen))
    model.add(keras.layers.Embedding(input_dim=vocab_size, output_dim=embedding_dim, input_length=maxlen))
    model.add(keras.layers.Conv1D(64, 11, activation='relu', padding='same'))
    model.add(keras.layers.MaxPooling1D())
    model.add(keras.layers.Dropout(0.5))
    model.add(keras.layers.Conv1D(128, 11, activation='relu', padding='same'))
    model.add(keras.layers.MaxPooling1D())
    model.add(keras.layers.Dropout(0.5))
    model.add(keras.layers.Conv1D(256, 11, activation='relu', padding='same'))
    model.add(keras.layers.MaxPooling1D())
    model.add(keras.layers.Dropout(0.5))
    model.add(keras.layers.GlobalMaxPool1D())  # 全局池化 变成二维的
    model.add(keras.layers.Dense(10, activation='relu'))
    model.add(keras.layers.Dense(1, activation='sigmoid'))
    model.compile(optimizer='adam',
                  loss='binary_crossentropy',
                  metrics=['acc'])
    model.summary()
    # keras.utils.plot_model(model, to_file='model1.png')
    
    # 训练过程中降低学习速率 理解: 连续3个epoch学习速率没下降 lr*0.5  最后不超过最低值
    # callbacks = keras.callbacks.ReduceLROnPlateau(monitor='val_loss', patience=3, factor=0.5, min_lr=0.00001)
    history = model.fit(X_train, y_train, epochs=100, batch_size=128, validation_data=(X_test, y_test))
    loss_train1, accuracy = model.evaluate(X_train, y_train, verbose=False)  # verbose=False  不打印训练结果
    print("Training Accuracy: {:.4f}".format(accuracy))
    loss_test1, accuracy = model.evaluate(X_test, y_test, verbose=False)
    print("Testing Accuracy:  {:.4f}".format(accuracy))
    # 可视化
    plot_history(history, name='base_Embedding Layer')
    
    # 接着上次训练的步骤训练
    callbacks1 = keras.callbacks.EarlyStopping(patience=2, monitor='val_loss')
    
    # 设置保存最优参数
    checkpoint = keras.callbacks.ModelCheckpoint(
        filepath='./model1.h5',
        monitor="val_loss",
        verbose=1,
        save_best_only=True,
        mode="min",
    )
    callbacks = [callbacks1, checkpoint]
    
    history = model.fit(X_train, y_train, epochs=100, batch_size=128, callbacks=callbacks, validation_data=(X_test, y_test))
    
    

    总结:
    用全部数据跑, 训练集和验证集acc能到95%.

    展开全文
  • 基于word2vec扩展情感词典和SVM的情感分析方法,顾卓航,张笑燕,随着互联网的快速发展,用户的评论信息已经成为各个商家用于优化产品、服务的重要信息源,如何对这些评论信息进行情感分类已成为
  • 基于机器学习的情感分析方法 用带标签数据训练一个机器学习模型,将情感分析看作一个二元分类问题。模型训练完成后,将待测试数据输入到训练好的模型中,模型会根据训练好的参数给出待测试数据的标签。 二元分类又...
  • 基于python的svm与word2vec文本情感分析设计与实现
  • 俄语中的推文情感分析:使用带有Word2Vec嵌入的卷积神经网络(CNN),对俄语中的推文进行情感分析
  • Word2vec情感语义分析实战(part1)

    万次阅读 多人点赞 2017-12-07 17:20:54
    引言前面我分享了三篇文章,其中一篇:Word2vec使用手册主要专注于工具包...而接下来的这篇文章,我将系统地讲解如何在IMDB电影评论数据集上应用word2vec进行情感分析。代码与数据集:传送门NLPNLP(Natural Langua
  • Word2vec进行中文情感分析

    千次阅读 2018-11-02 01:29:59
    ''' Chinese sentiment analysis ''' from sklearn.cross_validation import train_test_...from gensim.models.word2vec import Word2Vec import numpy as np import pandas as pd import jieba from sklearn.e...
  • 基于长短时神经网络(LSTM)+word2vec情感分析

    千次阅读 多人点赞 2020-01-19 16:51:18
    本项目我们使用word2vec(据说效果很好)进行词向量的提取,word2vec是使用深度学习的方式将词映射为一个多维向量。 首先顶级模型结构 并进行训练及保存 from gensim . models . word2vec import Word2Vec ...
  • 本文结合Word2Vec与LSTM神经网络构建了一种三分类的情感分类模型:首先用Word2Vec词向量模型训练出情感词典,然后利用情感词典为当前训练集数据构建出词向量,之后用影响LSTM神经网络模型精度的主要参数来进行训练....
  • 博客链接:https://blog.csdn.net/qq_44186838/article/details/118054911 主要功能:数据清洗、文本特征提取、建立模型,评估模型,情感分类
  • 主要功能:数据清洗、文本特征提取(word2vec / fastText)、建立模型(BiLSTM、TextCNN、CNN+BiLSTM、BiLSTM+Attention) 注:资源内包含所有第三方模块的对应版本,百分百可运行,诚信。 博客链接:...
  • 使用脚本PreprocessingData的数据结果运行源情感分析(此操作用于创建基文件情感正和负) 运行源代码TrainingModelPositif(使用Positive.txt)并运行源代码TrainingModelNegative(使用Negative.txt)以获取模型...
  • 这篇博客中的资源《自然语言学习——使用word2vec对文本进行情感分析》,其中包含代码,训练集,测试集、停止词。
  • 对文本处理的方法是word2vec,然后用随机森林的方法构建模型,最后训练模型进行预测。前面一、二部分主要是讲述如何处理文档,有点啰嗦可以快速阅读,主要方法从第三部分开始。 一、读取文档 在进行文本情感分析...
  • 基于word2vec或doc2vec情感分析

    万次阅读 2016-05-05 11:32:04
     情感分析是一种常见的自然语言处理(NLP)方法的应用,特别是在以提取文本的情感内容为目标的分类方法中。通过这种方式,情感分析可以被视为利用一些情感得分指标来量化定性数据的方法。尽管情绪在很大程度上是...
  • word2vec.rar

    2020-03-11 22:41:49
    Word2vec,是一群用来产生词向量的相关模型。这些模型为浅而双层的神经网络,用来训练以重新建构语言学之词文本。网络以词表现,并且需猜测相邻位置的输入词,在word2vec中词袋模型假设下,词的顺序是不重要的。训练...
  • 基于情感分析Word2Vec的图书推荐方法.pdf
  • Pytorch+Text-CNN+Word2vec+电影评论情感分析实战

    千次阅读 热门讨论 2021-07-07 21:27:18
    很多人喜欢使用IMDB数据集来做电影评论情感分析示范,但这却是我极其不建议的,因为其一般被很多官方的库都收录,所以有很多接口用于处理这个数据集,这让我们无法体验到真实场景,一旦碰到真正的数据集,我们将手都...
  • 情感分析(1)—— Word2vec词向量

    千次阅读 2020-01-31 21:03:02
    情感分析(1)—— Word2vec词向量 一、Word2vec需要做什么? 1、NLP模型 对于任何模型,都可以视为一种映射 f(x) -> y 其中,如果在 NLP 中,x 可以为词语,y 可以为词语 x 的上下文词语,而映射 f 是一种判别...
  • 情感分析的描述、基于词袋模型和word2vec模型的情感分析实现 以购物评论为例: # 读入原始数据集 import pandas as pd dfpos = pd.read_excel('../data/购物评论.xlsx', sheet_name='正向', ...
  • 但是在我们这次情感分析任务中,标点”!!!”、”: (“很有可能承载着情感信息的,因此这些标点应该特殊被当作单词。在本次实战中,我们为了简化问题就直接去除表点了,但是如果你有兴趣,想进一步优化解决方案,可以...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 4,938
精华内容 1,975
关键字:

word2vec情感分析