精华内容
下载资源
问答
  • 自然语言处理—文本情感分析

    千次阅读 多人点赞 2018-07-25 20:50:59
    自然语言处理(NLP)中的文本情感分析是一个重要的应用领域,多用于评价性的用户信息回馈,如电影影评和购物后的评价。而情感分析主要是通过用户的回答文本数据(中文),进行文本情感量化分析,现有的情感分析方法...

    自然语言处理(NLP)中的文本情感分析是一个重要的应用领域,多用于评价性的用户信息回馈,如电影影评和购物后的评价。而情感分析主要是通过用户的回答文本数据(中文),进行文本情感量化分析,现有的情感分析方法:1.情感词典分析方法。2.机器学习分析方法。

    情感词典分析方法

    一句话来总结,就是对文本进行切词,出除掉停用词,提取出关键词中的积极关键词和消极关键词,计算出情感得分。
    先是对文本数据进行切词,这里使用中文切词工具jieba,还有很多其他的切词工具,如snowNLP等,都有各自的优点,但是切词越准确得到的结果就越准确。其次就是关于字典的生成,这里主要是包含三个字典,停用词字典,积极情感字典,消极情感字典,来源于知网HowNet的字典。停用词字典包含的是“那么”,“怎么”这样的连接词还有一些标点符号等,不带有情感的词语,将这些词语去掉后,只剩下了带有情感的词语。词典包含的数据越多,情感预测的也就越准确。
    字典法流程图

    代码:

    # -*- coding: utf-8 -*-
    __author__ = 'JoeyYK'
    
    import jieba
    
    print('loading dictionary dataset...')
    
    #导入负面情绪字典
    negitive_dic = open('negitive_word.txt')
    negitive_arr= negitive_dic.readlines()
    negitive_word = []
    for arr in negitive_arr:
        arr = arr.replace("\n", "")
        negitive_word.append(arr)
    # print(negitive_word)
    
    #导入积极情绪词典
    posstive_dic = open('posstive_word.txt')
    posstive_arr = posstive_dic.readlines()
    posstive_word = []
    for arr in posstive_arr:
        arr = arr.replace("\n", "")
        posstive_word.append(arr)
    # print(posstive_word)
    
    #分词函数
    def segmentation(sentence):
        seg_list = jieba.cut(sentence)
        seg_result = []
        for w in seg_list:
            seg_result.append(w)
        return seg_result
    
    #去掉停用词
    def del_stopWord(seg_result):
        # 将txt的文件转化为一个list,不带、n的
        stop_dic = open('stop_word.txt')
        stopwords = stop_dic.readlines()
        arr = []
        for stopword in stopwords:
            stopword = stopword.replace("\n", "")
            arr.append(stopword)
        new_sent = []
        for word in seg_result:
            if word not in arr:
                new_sent.append(word)
        return new_sent
    
    def sentence_score(sentences):
        # sentence_score = []
        seg_result = segmentation(sentences)
        seg_result = del_stopWord(seg_result)
        print(seg_result)
        poscount = 0
        negcount = 0
    
        for word in seg_result:
            if word in negitive_word:
                negcount +=1
            elif word in posstive_word:
                poscount +=1
        final_score = poscount - negcount
    
        print('poscount:',poscount)
        print('negcount:',negcount)
        print('final_score:' ,final_score)
    
    if __name__ == '__main__':
        sentences = '以前你们很棒的,现在你们这个维修的进度也太慢了吧,我都等了几天了,真的是垃圾,太差劲了,我要投诉你们'
        print(sentences)
        print(segmentation(sentences))
        sentence_score(sentences)

    输出结果:

    /home/joey/anaconda3/bin/python /home/joey/PycharmProjects/workspace/emotion/emotion_test.py
    loading dictionary dataset...
    Building prefix dict from the default dictionary ...
    Loading model from cache /tmp/jieba.cache
    以前你们很棒的,现在你们这个维修的进度也太慢了吧,我都等了几天了,真的是垃圾,太差劲了,我要投诉你们
    ['以前', '你们', '很棒', '的', ',', '现在', '你们', '这个', '维修', '的', '进度', '也', '太慢', '了', '吧', ',', '我', '都', '等', '了', '几天', '了', ',', '真的', '是', '垃圾', ',', '太', '差劲', '了', ',', '我要', '投诉', '你们']
    ['很棒', '维修', '进度', '太慢', '几天', '真的', '垃圾', '太', '差劲', '我要', '投诉']
    Loading model cost 1.298 seconds.
    Prefix dict has been built succesfully.
    poscount: 1
    negcount: 3
    final_score: -2
    
    Process finished with exit code 0

    词典法存在很多缺点,词典法的精确度与词典的关系非常大,只有词典的规模足够大才能并且包含足够多的该领域的专业数据才能准确的预测情感情况,其次词典法只是简单的关键词匹配,数学化的计算出消极和积极词语的数量来判断情感是很局限的,例如“我开始觉得你们非常的差劲,进度慢,效率垃圾,但是我接触后才发现非常的好”这句话其实表达的是一种赞美的情感可以说是积极的,但是按照词典法就是不太好的结果。所以我们考虑第二种方法,也就是机器学习方法。

    机器学习法

    利用机器学习的方法,主要利用的是word2vec这个词向量模型,将词转化成数组,这样通过计算词间的数据距离,来衡量词之间的相似度,这样在模型有监督的学习了积极和消极词向量后,就可以得到结果了。这里使用的循环神经网络LSTM,LSTM的时延性能帮助到词向量的学习。这里使用的是tensorflow的深度学习框架。
    借用大神代码,代码地址:https://github.com/vortexJCH/-LSTM-

    代码:

    import warnings
    warnings.filterwarnings(action='ignore', category=UserWarning, module='gensim')
    import gensim
    from gensim.models import word2vec
    import jieba
    import tensorflow as tf
    import numpy as np
    import time
    from random import shuffle
    
    #----------------------------------
    #停用词获取
    def makeStopWord():
        with open('停用词.txt','r',encoding = 'utf-8') as f:
            lines = f.readlines()
        stopWord = []
        for line in lines:
            words = jieba.lcut(line,cut_all = False)
            for word in words:
                stopWord.append(word)
        return stopWord
    
    #将词转化为数组
    def words2Array(lineList):
        linesArray=[]
        wordsArray=[]
        steps = []
        for line in lineList:
            t = 0
            p = 0
            for i in range(MAX_SIZE):
                if i<len(line):
                    try:
                        wordsArray.append(model.wv.word_vec(line[i]))
                        p = p + 1
                    except KeyError:
                        t=t+1
                        continue
                else:
                   wordsArray.append(np.array([0.0]*dimsh))
            for i in range(t):
                wordsArray.append(np.array([0.0]*dimsh))
            steps.append(p)
            linesArray.append(wordsArray)
            wordsArray = []
        linesArray = np.array(linesArray)
        steps = np.array(steps)
        return linesArray, steps
    
    #将数据转化为数据
    def convert2Data(posArray, negArray, posStep, negStep):
        randIt = []
        data = []
        steps = []
        labels = []
        for i in range(len(posArray)):
            randIt.append([posArray[i], posStep[i], [1,0]])
        for i in range(len(negArray)):
            randIt.append([negArray[i], negStep[i], [0,1]])
        shuffle(randIt)
        for i in range(len(randIt)):
            data.append(randIt[i][0])
            steps.append(randIt[i][1])
            labels.append(randIt[i][2])
        data = np.array(data)
        steps = np.array(steps)
        return data, steps, labels
    
    #获得文件中的数据,并且分词,去除其中的停用词
    def getWords(file):
        wordList = []
        trans = []
        lineList = []
        with open(file,'r',encoding='utf-8') as f:
            lines = f.readlines()
        for line in lines:
            trans = jieba.lcut(line.replace('\n',''), cut_all = False)
            for word in trans:
                if word not in stopWord:
                    wordList.append(word)
            lineList.append(wordList)
            wordList = []
        return lineList
    
    #产生训练数据集和测试数据集
    def makeData(posPath,negPath):
        #获取词汇,返回类型为[[word1,word2...],[word1,word2...],...]
        pos = getWords(posPath)
        print("The positive data's length is :",len(pos))
        neg = getWords(negPath)
        print("The negative data's length is :",len(neg))
        #将评价数据转换为矩阵,返回类型为array
        posArray, posSteps = words2Array(pos)
        negArray, negSteps = words2Array(neg)
        #将积极数据和消极数据混合在一起打乱,制作数据集
        Data, Steps, Labels = convert2Data(posArray, negArray, posSteps, negSteps)
        return Data, Steps, Labels
    
    
    #----------------------------------------------
    # Word60.model   60维
    # word2vec.model        200维
    
    timeA=time.time()
    word2vec_path = 'word2vec/word2vec.model'
    model=gensim.models.Word2Vec.load(word2vec_path)
    dimsh=model.vector_size
    MAX_SIZE=25
    stopWord = makeStopWord()
    
    print("In train data:")
    trainData, trainSteps, trainLabels = makeData('data/A/Pos-train.txt',
                                                  'data/A/Neg-train.txt')
    print("In test data:")
    testData, testSteps, testLabels = makeData('data/A/Pos-test.txt',
                                               'data/A/Neg-test.txt')
    trainLabels = np.array(trainLabels)
    
    del model
    
    # print("-"*30)
    # print("The trainData's shape is:",trainData.shape)
    # print("The testData's shape is:",testData.shape)
    # print("The trainSteps's shape is:",trainSteps.shape)
    # print("The testSteps's shape is:",testSteps.shape)
    # print("The trainLabels's shape is:",trainLabels.shape)
    # print("The testLabels's shape is:",np.array(testLabels).shape)
    
    
    num_nodes = 128
    batch_size = 16
    output_size = 2
    
    #使用tensorflow来建立模型
    graph = tf.Graph() #定义一个计算图
    with graph.as_default(): #构建计算图
    
        tf_train_dataset = tf.placeholder(tf.float32,shape=(batch_size,MAX_SIZE,dimsh))
        tf_train_steps = tf.placeholder(tf.int32,shape=(batch_size))
        tf_train_labels = tf.placeholder(tf.float32,shape=(batch_size,output_size))
    
        tf_test_dataset = tf.constant(testData,tf.float32)
        tf_test_steps = tf.constant(testSteps,tf.int32)
    
        #使用LSTM的循环神经网络
        lstm_cell = tf.nn.rnn_cell.BasicLSTMCell(num_units = num_nodes,state_is_tuple=True)
    
        w1 = tf.Variable(tf.truncated_normal([num_nodes,num_nodes // 2], stddev=0.1))
        b1 = tf.Variable(tf.truncated_normal([num_nodes // 2], stddev=0.1))
    
        w2 = tf.Variable(tf.truncated_normal([num_nodes // 2, 2], stddev=0.1))
        b2 = tf.Variable(tf.truncated_normal([2], stddev=0.1))
    
        def model(dataset, steps):
            outputs, last_states = tf.nn.dynamic_rnn(cell = lstm_cell,
                                                     dtype = tf.float32,
                                                     sequence_length = steps,
                                                     inputs = dataset)
            hidden = last_states[-1]
    
            hidden = tf.matmul(hidden, w1) + b1
            logits = tf.matmul(hidden, w2) + b2
            return logits
        train_logits = model(tf_train_dataset, tf_train_steps)
        loss = tf.reduce_mean(
            tf.nn.softmax_cross_entropy_with_logits(labels=tf_train_labels,logits=train_logits))
        optimizer = tf.train.GradientDescentOptimizer(0.01).minimize(loss)
        #预测
        test_prediction = tf.nn.softmax(model(tf_test_dataset, tf_test_steps))
    
    num_steps = 20001
    summary_frequency = 500
    
    with tf.Session(graph = graph) as session:
        tf.global_variables_initializer().run()
        print('Initialized')
        mean_loss = 0
        for step in range(num_steps):
            offset = (step * batch_size) % (len(trainLabels)-batch_size)
            feed_dict={tf_train_dataset:trainData[offset:offset + batch_size],
                       tf_train_labels:trainLabels[offset:offset + batch_size],
                       tf_train_steps:trainSteps[offset:offset + batch_size]}
            _, l = session.run([optimizer,loss],
                               feed_dict = feed_dict)
            mean_loss += l
            if step >0 and step % summary_frequency == 0:
                mean_loss = mean_loss / summary_frequency
                print("The step is: %d"%(step))
                print("In train data,the loss is:%.4f"%(mean_loss))
                mean_loss = 0
                acrc = 0
                prediction = session.run(test_prediction)
                for i in range(len(prediction)):
                    if prediction[i][testLabels[i].index(1)] > 0.5:
                        acrc = acrc + 1
                print("In test data,the accuracy is:%.2f%%"%((acrc/len(testLabels))*100))
    #####################################
    timeB=time.time()
    print("time cost:",int(timeB-timeA))
    

    结果:
    经过20000次的迭代后得到结果

    ...
    The step is: 18000
    In train data,the loss is:0.0230
    In test data,the accuracy is:97.04%
    The step is: 18500
    In train data,the loss is:0.0210
    In test data,the accuracy is:96.94%
    The step is: 19000
    In train data,the loss is:0.0180
    In test data,the accuracy is:96.89%
    The step is: 19500
    In train data,the loss is:0.0157
    In test data,the accuracy is:97.49%
    The step is: 20000
    In train data,the loss is:0.0171
    In test data,the accuracy is:96.64%
    time cost: 809

    在语料足够的情况下,机器学习的方法效果更好一点。

    展开全文
  • 情感分析作为自然语言处理的基础技术之一,常被用于电商评论、舆情监控、微博评论情感分析、话题监督等领域,因此深入掌握情感分析技术,是作为自然语言处理从业者必备技能,本课程以案例驱动出发,结合多个项目实战...
  • LSTM实现自然语言处理中的情感分析,其中包含了分词,词序列化,词向量,LSTM建模
  • 本文为笔者学习阿里云大学的基于LSTM的文本情感分析教学视频总结。 一、何为文本情感分析 其实也就是,用户输入了一句话,我们需要靠机器来知道这句话的情感,本文会以开心和不开心为例,来进行情感分析,有点像二...

    本文为笔者学习阿里云大学的基于LSTM的文本情感分析教学视频总结。

    一、何为文本情感分析

    其实也就是,用户输入了一句话,我们需要靠机器来知道这句话的情感,本文会以开心和不开心为例,来进行情感分析,有点像二分类,但并不是。

    二、神经网络模型

    这里提出使用的是LSTM,也叫做长短时记忆网络,该网络其实是RNN的衍生,主要是为针对RNN的缺点设计出来的,一个神经单元有遗忘门、输入门、输出门,该网络除了结构有所改变,其训练方法和其它NN一样,也是主要采用反向传播、梯度的方法。下面贴出其单个神经单元的结构图:
    在这里插入图片描述
    该结构继承了RNN的记忆功能,也改善了RNN不能够排除掉很久以前的信息,在文本处理中,可能现阶段的文本与很久之前的文本没有一丁点关系了,但是RNN依然保留了很久之前的信息,不能排除。但LSTM由于有遗忘门,便可以“慢慢遗忘”之前无关的信息。具体是有公式证明,推荐去了解一下。

    三、机器如何处理文本?

    这个问题应该是自然处理领域最基本也是最重要的问题,众所周知,机器只能够处理数字,那我们便需要了解如何将文字转换成数字呢?
    一般,一句话是由很多个单词构成,或者简称词。如果我们知道了如何用数字来表示词,那是不是就可以知道怎么表示一段话了。
    当前自然语言处理研究都是先训练出自己所需要的词向量,也就是每一个词对应的向量。比如,“机器”这个词可以用[1,2,3,4,5,6,4,7,8,…],这样的多维向量来表示,那么机器也也就可以处理了,得到词向量也有一个专业名词——word2vec。有兴趣也可以去检索一下,这里就不赘述了。且本文使用的词向量使用的是别人已经训练好的,这样覆盖面也会更广。(等我拿到算力超好的计算机,我也试着训练一个。)

    四、机器识别文本情感的训练流程

    ①首先加载词向量的模型
    ②加载训练数据
    ③对吃进的数据进行预处理,装其使用词向量表示,此文由于使用tensorflow,比如“我”这个词,在此模型中找的是词的在词向量模型中的索引。所以假设一句话有20个词,如果一个词向量是50维的向量,那最后处理的是一个20 × 50的词矩阵。最后达到满足网络模型的输入要求。
    ④构建网络模型,设置网络需要的参数,训练。

    五、主要实现过程

    5.1 加载词向量模型:

    """
        首先需要获得词向量,词向量可以通过自己训练,也就是word2vec。
        这里使用别人已经使用好的词向量模型,英文的
    """
    wordsList = np.load('./training_data/wordsList.npy')
    print('Loaded the word list!')
    wordsList = wordsList.tolist() 
    wordsList = [word.decode('UTF-8') for word in wordsList] 
    wordVectors = np.load('./training_data/wordVectors.npy')
    print ('Loaded the word vectors!')
    

    5.2 读取数据
    由于获取的数据集是一个一个的txt文件,且分别存放于两个文件夹,首先把文件位置都读到放进一个列表,然后在for循环里依次读取各个文件的各行,并统计词数目。

    positiveFiles = ['./training_data/positiveReviews/' + f for f in listdir('./training_data/positiveReviews/') if isfile(join('./training_data/positiveReviews/', f))]
    negativeFiles = ['./training_data/negativeReviews/' + f for f in listdir('./training_data/negativeReviews/') if isfile(join('./training_data/negativeReviews/', f))]
    
    for pf in positiveFiles:
        with open(pf, "r", encoding='utf-8') as f:
            line=f.readline()
            counter = len(line.split())
            numWords.append(counter)
    print('Positive files finished')
    for nf in negativeFiles:
        with open(nf, "r", encoding='utf-8') as f:
            line=f.readline()
            counter = len(line.split())
            numWords.append(counter)
    print('Negative files finished')
    

    5.3 数据预处理
    先对数据进行处理:只要字母数字,其它都不要

    import re
    strip_special_chars = re.compile("[^A-Za-z0-9 ]+")
    
    def cleanSentences(string):
        string = string.lower().replace("<br />", " ")
        return re.sub(strip_special_chars, "", string.lower())
    

    接着基于此方法,找这句话所有词对应的词向量。我们通过前面对段话大概的单词做出估计,每段话250词左右,那输出的的便是一个250 * 50的词矩阵,因为这个词向量模型是50维度的。

    firstFile = np.zeros((maxSeqLength), dtype='int32')
    with open(fname) as f:
        indexCounter = 0
        line=f.readline()
        cleanedLine = cleanSentences(line)
        split = cleanedLine.split()
        for word in split:
            try:
                firstFile[indexCounter] = wordsList.index(word)
            except ValueError:
                firstFile[indexCounter] = 399999 #Vector for unknown words
            indexCounter = indexCounter + 1
    

    然后重复此方法便可以完成数据集的处理。

    ids = np.zeros((numFiles, maxSeqLength), dtype='int32')
    fileCounter = 0
    for pf in positiveFiles:
       with open(pf, "r") as f:
           indexCounter = 0
           line=f.readline()
           cleanedLine = cleanSentences(line)
           split = cleanedLine.split()
           for word in split:
               try:
                   ids[fileCounter][indexCounter] = wordsList.index(word)
               except ValueError:
                   ids[fileCounter][indexCounter] = 399999 #Vector for unkown words
               indexCounter = indexCounter + 1
               if indexCounter >= maxSeqLength:
                   break
           fileCounter = fileCounter + 1 
    
    for nf in negativeFiles:
       with open(nf, "r") as f:
           indexCounter = 0
           line=f.readline()
           cleanedLine = cleanSentences(line)
           split = cleanedLine.split()
           for word in split:
               try:
                   ids[fileCounter][indexCounter] = wordsList.index(word)
               except ValueError:
                   ids[fileCounter][indexCounter] = 399999 #Vector for unkown words
               indexCounter = indexCounter + 1
               if indexCounter >= maxSeqLength:
                   break
           fileCounter = fileCounter + 1 
    

    5.4 搭建模型,由于使用到了LSTM,则基于tensorflow搭建模型。

    """
        下面的几个参数为神经网络模型的基本参数
        batchsize:训练一次网络,给多少样本,这个值可以自己设置,但必须位于1到样本总数之间
        lstmUnits:LSTM神经单元个数
        numClasses:有多少个分类
        iterations:训练次数
    """
    batchSize = 24
    lstmUnits = 64
    numClasses = 2
    iterations = 50000
    

    未完待续。。。

    展开全文
  • 原标题:自然语言处理中的情感分析 情感分析是一种常见的自然语言处理(NLP)方法的应用,特别是在以提取文本的情感内容为目标的分类方法中。通过这种方式,情感分析可以被视为利用一些情感得分指标来量化定性数据的...

    原标题:自然语言处理中的情感分析

    8a1a834c8b9048f81c4f2e4f15a4ae5c.png

    情感分析是一种常见的自然语言处理(NLP)方法的应用,特别是在以提取文本的情感内容为目标的分类方法中。通过这种方式,情感分析可以被视为利用一些情感得分指标来量化定性数据的方法。尽管情绪在很大程度上是主观的,但是情感量化分析已经有很多有用的实践,比如企业分析消费者对产品的反馈信息,或者检测在线评论中的差评信息。

    有两种主流思想运用到情感分析,第一种为基于情感词典的情感分析,是指根据已构建的情感词典,计算该文本的情感倾向,即根据语义和依存关系来量化文本的情感色彩。最终分类效果取决于情感词库的完善性,另外需要很好的语言学基础,也就是说需要知道一个句子通常在什么情况为表现为积极或消极。第二种是基于机器学习,是指选取情感词作为特征词,将文本矩阵化,利用logistic Regression, 朴素贝叶斯(Naive Bayes),支持向量机(SVM)等方法进行分类。最终分类效果取决于训练文本的选择以及正确的情感标注。

    下文列举两种基于机器学习的情感分析主流算法。

    KNN分类算法:思路是为如果一个样本在特征空间中的k个最相似的样本中的大多数属于某一个类别,则该样本也属于这个类别。

    优点:

    (1)简单、易实现、易理解、无需参数估计及训练;

    (2)适用于对稀有时间进行分类;

    (3)特别适用于多分类问题(multi-modal,分类对象具有多个类别标签),比SVM表现要好。

    缺点:

    (1)输出的可解释性不强且类别的评分不是规则化的。

    (2)计算量较大。目前常用的改进方法,事先对已知样本点进行剪辑,去除对分类作用不大的样本。该改进算法比较适用于容量大的类域,而容量较小的类域容易产生误分。

    (3)当样本不平衡时,有可能导致当输入一个新样本时,该样本的K个邻居中大容量类的样本占多数。

    朴素贝叶斯:朴素贝叶斯法是基于贝叶斯定理与特征条件独立假设的分类方法

    优点:

    (1)朴素贝叶斯模型发源于古典数学理论,有稳定的分类效率。

    (2)对小规模的数据表现很好,能个处理多分类任务,适合增量式训练,尤其是数据量超出内存时,我们可以一批批的去增量训练。

    (3)对缺失数据不太敏感,算法也比较简单,常用于文本分类。

    缺点:

    (1) 理论上,朴素贝叶斯模型与其他分类方法相比具有最小的误差率。但是实际上并非总是如此,这是因为朴素贝叶斯模型假设属性之间相互独立,这个假设在实际应用中往往是不成立的,在属性个数比较多或者属性之间相关性较大时,分类效果不好。而在属性相关性较小时,朴素贝叶斯性能最为良好。对于这一点,有半朴素贝叶斯之类的算法通过考虑部分关联性适度改进。

    (2)需要知道先验概率,且先验概率很多时候取决于假设,假设的模型可以有很多种,因此在某些时候会由于假设的先验模型的原因导致预测效果不佳。

    (3)分类决策存在一定的错误率,且对输入数据的表达形式很敏感。

    文章来源:www.xixi.ai(息息人工智能)返回搜狐,查看更多

    责任编辑:

    展开全文
  • mark一下,感谢作者分享! 基于情感词典的中文自然语言处理情感分析(上): https://blog.csdn.net/valada/article/details/81024992 基于情感词典的中文自然语言处理情感分析(下): ...

    mark一下,感谢作者分享!
    基于情感词典的中文自然语言处理情感分析(上):
    https://blog.csdn.net/valada/article/details/81024992

    基于情感词典的中文自然语言处理情感分析(下):
    https://blog.csdn.net/valada/article/details/81025011

    展开全文
  • 总的来说,可以理解成:是对带有情感色彩的主观性文本进行数据挖掘与情感倾向分析的过程。 情感分析的用途: 分析文本情感可以帮助我们从海量的文本内容中提取需要的信息,可用于各个行业。比如,电商平台评论进行...
  • 自然语言处理6 -- 情感分析

    万次阅读 多人点赞 2018-09-09 15:30:17
    情感分析自然语言处理中常见的场景,比如淘宝商品评价,饿了么外卖评价等,对于指导产品更新迭代具有关键性作用。通过情感分析,可以挖掘产品在各个维度的优劣,从而明确如何改进产品。比如对外卖评价,可以分析菜...
  • 自然语言处理中,斯坦福大学做的不错,分析结果准确性较高,而且支持中文等多主流言语 传送门 1.斯坦福实体抽取传送门 2.斯坦福情感分析传送门 3.斯坦福自然语言处理 github 传送门 成果 支持语言:英文 概述:实体...
  • !!!!!!不要急着代码,搞清楚原理知识结构才下手,以后还指着它吃饭呢,又不是水一篇论文当混子!... 情感分析是从书面或口头语言中,对特定主题,理解观点的自动过程。 在世界上,我们每天生成2.5QB字...
  • task0:自然语言处理之PyTorch情感分析简介(1天) 环境: PyTorch1.8或以上、torchtext0.9或以上、python3.7(其他的安装很简单,就不赘述了) transformer: pip install -i ...
  • 目前情感分析在中文自然语言处理中...在《基于情感词典的中文自然语言处理情感分析(上)》的基础上,本场 Chat 你将学到: 股吧数据情感分类; 情感可视化之绘制情感树; 通过自定义情感词权重计算情感值; 实战...
  • 目前情感分析在中文自然语言处理中比较火热,很多场景下,我们都需要用到情感分析。比如,做金融产品量化交易的,需要根据爬取的舆论数据来分析政策和舆论对股市或者基金期货的态度;电商交易,根据买家的评论数据,...
  • 基于自然语言处理的顾客对于产品的情感分析(分类问题) 在这个项目中,我们来研究分类问题,并将它们应用于分析顾客对于物品的情绪。进一步,我们要理解分类产生的错误类型。 我们使用ipython notebook,借助...
  • 自然语言情感分析

    千次阅读 2018-11-04 01:48:43
    情感分析是基于自然语言处理的分类技术,主要解决的问题是判断一段话是正面的还是负面的。 例如网站上人们会发表评论,商家可以通过情感分析知道用户对产品的评价。还有不少基金公司会利用人们对某公司和行业的看法...
  • 自然语言处理(NLP)学习路线总结

    万次阅读 多人点赞 2019-03-20 21:01:53
    自然语言处理概述 自然语言处理入门基础 自然语言处理的主要技术范畴 自然语言处理基本点 特征处理 模型选择 NLP常用工具 NLP语言模型 快速入门NLP方法 自然语言处理...
  • 自然语言处理实战——LSTM情感分析

    千人学习 2018-06-22 16:26:12
    自然语言处理实战视频教程,自然语言处理中重要的算法,词向量模型。本课程从语言模型入手,详解词向量构造原理与求解算法。理论与实战结合, 基于深度学习主流框架Tensorflow实例演示如何用深度学习来进行文本分类...
  • 语音命令,语音和文本翻译,情感分析,文本摘要以及许多其他语言应用程序和分析背后的魔力,通过深度学习极大地改善了自然语言处理。 Python语言为包括NLP在内的各种机器学习提供了便捷的前端。 实际上,在Python...
  • 情感分析无处不在,它是一种基于自然语言处理的分类技术。其主要解决的问题是给定一段话,判断这段话是正面的还是负面的。例如在亚马逊网站或者推特网站中,人们会发表评论,谈论某个商品、事件或人物。商家可以利用...
  • 自然语言处理(NLP)之使用LSTM进行文本情感分析 情感分析简介 文本情感分析(Sentiment Analysis)是自然语言处理(NLP)方法中常见的应用,也是一个有趣的基本任务,尤其是以提炼文本情绪内容为目的的分类。它是对...
  • 自然语言处理情感分析
  • 首先先注册登录百度AI平台,自然...看到自然语言处理 点击进入 进入之后跳转到自然语言处理产品页 点击创建应用,应用创建后会有AppID、API Key、Secret Key这些参数。后续使用会利用到这些参数! 使用百...
  • 文本分类应用: 常见的有垃圾邮件识别,情感分析 文本分类方向: 主要有二分类,多分类,多标签分类 文本分类方法: 传统机器学习方法(贝叶斯,svm等),深度学习方法(fastText,TextCNN等) 文本分类的处理大致...
  • 面向智能客服系统的情感分析技术自然语言处理知识图谱语音图像数据采集30页.pdf
  • NLP之TEA:自然语言处理之文本情感分析的简介、算法、应用、实现流程、实现方法之详细攻略 目录 TEA的简介 TEA的应用 TEA的实现流程 TEA的实现方法 T1、词袋模型 TEA的案例应用 TEA的简介 文本...
  • 自然语言处理 典型场景分析

    千次阅读 2019-05-23 11:33:36
    是对带有情感色彩的主观性文本进行分析处理、归纳和推理的过程。 主要流程: 输入数据 -> tokenization -> stop word filtering -> NegationHanding -> stemming -> classification -> ...
  • 一种情感分析的方法使用用户设计的规则(有时称为启发式规则)来度量文本的情感。一个常用的基于规则的方法是在文本中寻找关键词,并将每个关键词映射到某部字典或者映射上的数值得分或权重,例如这部字典可以是 ...
  • 从零开始自然语言处理

    千人学习 2019-08-07 14:38:22
    例如LSTM,BiLSTM等,并结合京东电商评论分类、豆瓣电影摘要提取、今日头条舆情挖掘、饿了么情感分析等过个案例,帮助大家熟悉自然语言处理工程师在工作中会接触到的常见应用的实施的基本实施流程,从0-1入门变成...
  • 情感分析语料 实体分析语料 垃圾分类语料 个人开发在做很多NLP相关任务的时候,语料的寻找十分头疼。 有很多公开的语料,被他人收费,或要积分下载等等。 对平时开发造成诸多不便。 这边整理了一些自己收集到...
  • 文章目录论述自然语言处理的技术范畴(基本全貌) 一、前言...问答系统10、机器翻译11、文本情感分析12、自动摘要13、文字蕴涵三、自然语言处理的难点 论述自然语言处理的技术范畴(基本全貌) 一、前言 &amp;amp;...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 25,277
精华内容 10,110
关键字:

自然语言处理情感分析