网页文本倾向性分析

最新推荐文章于 2022-10-24 16:30:45 发布
最新推荐文章于 2022-10-24 16:30:45 发布
阅读量974 收藏 1
点赞数 
import java.io.BufferedReader;  
import java.io.FileNotFoundException;  
import java.io.FileReader;  
import java.io.IOException;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
 
import org.springframework.stereotype.Component;  
 
import com.yidatec.vis.psms.commons.PSMSConstants;  
 
/**  
 * 加载词汇  
 * @author William Xu  
 */ 
 
@Component 
public class TrendencyWordsLoader {  
      
    private Map<String, Integer> negWordMap;  
    private Map<String, Integer> posWordMap;  
    private List<String> refWordList;     
      
    public TrendencyWordsLoader(){  
        loadWords();  
    }  
      
    private void loadWords(){  
          
        negWordMap = new HashMap<String, Integer>();  
        posWordMap = new HashMap<String, Integer>();  
        refWordList = new ArrayList<String>();  
          
        try {  
              
            FileReader fr = new FileReader(this.getClass().getClassLoader().getResource(PSMSConstants.NEG_WORDS_PATH).getFile());             
            BufferedReader br = new BufferedReader(fr);   
              
            String line = null;  
              
            while((line = br.readLine()) != null){  
                  
                String[] words = line.split("-");                 
                negWordMap.put(words[0], Integer.parseInt(words[1]));  
            }  
              
            fr = new FileReader(this.getClass().getClassLoader().getResource(PSMSConstants.POS_WORDS_PATH).getFile());            
            br = new BufferedReader(fr);              
            line = null;  
              
            while((line = br.readLine()) != null){  
                  
                String[] words = line.split("-");                 
                posWordMap.put(words[0], Integer.parseInt(words[1]));  
            }  
              
            fr = new FileReader(this.getClass().getClassLoader().getResource(PSMSConstants.REL_WORDS_PATH).getFile());            
            br = new BufferedReader(fr);              
            line = null;  
              
            while((line = br.readLine()) != null){                
                refWordList.add(line);  
            }  
              
            br.close();  
            fr.close();  
              
        } catch (FileNotFoundException e) {  
            e.printStackTrace();  
        } catch (NumberFormatException e) {  
            e.printStackTrace();  
        } catch (IOException e) {  
            e.printStackTrace();  
        }   
    }  
      
    public Map<String, Integer> getNegWordMap() {  
        return negWordMap;  
    }  
 
    public Map<String, Integer> getPosWordMap() {  
        return posWordMap;  
    }  
      
    public List<String> getRefWordList() {  
        return refWordList;  
    }  
}  
加载词汇表后，就可以使用mmSeg4j对网页文本进行分词，并进行分析了，代码如下：
 
import java.io.IOException;  
import java.io.Reader;  
import java.io.StringReader;  
import java.util.ArrayList;  
import java.util.HashMap;  
import java.util.List;  
import java.util.Map;  
import java.util.Set;  
 
import org.springframework.beans.factory.annotation.Autowired;  
import org.springframework.stereotype.Component;  
 
import com.chenlb.mmseg4j.ComplexSeg;  
import com.chenlb.mmseg4j.Dictionary;  
import com.chenlb.mmseg4j.MMSeg;  
import com.chenlb.mmseg4j.Word;  
import com.yidatec.vis.psms.entity.SolrQueryResult;  
 
@Component 
public class TrendencyAnalyser {  
 
    @Autowired 
    TrendencyWordsLoader wordLoader;  
 
    protected static final Dictionary dic = Dictionary.getInstance();  
    protected static final ComplexSeg seg = new ComplexSeg(dic);  
 
    /**  
     * 正序阈值  
     */ 
    private final int PS_THRESHOLD = 50;  
 
    /**  
     * 逆序阈值  
     */ 
    private final int NS_THRESHOLD = 30;  
 
    /**  
     * 整片文章分词Map  
     */ 
    private Map<String, List<Word>> segments = null;  
    private List<Word> negs = null;  
    private List<Word> poses = null;  
    private List<Word> rels = null;  
 
    public int analyzeTrendency(String title, String content) {  
 
        try {  
 
            boolean flag = isRelTitle(title);  
 
            if (flag) {  
 
                int titleTendency = getTitleTrendency();  
 
                if (titleTendency < 0) {  
                    return SolrQueryResult.NEGATIVE_NATURE;  
                } else if (titleTendency > 0) {  
                    return SolrQueryResult.POSITIVE_NATURE;  
                }  
            }  
 
            clearAll();  
 
            initSegmentsMap(new StringReader(title + " " + content));  
 
            parseNegWordsMap();  
 
            parsePosWordsMap();  
 
            int result = analyzeContentsTrendency();  
 
            if (flag) { // 标题相关，仅判断文本倾向性  
 
                if (result < 0) {  
 
                    return SolrQueryResult.NEGATIVE_NATURE;  
 
                } else if (result == 0) {  
 
                    return SolrQueryResult.NEUTRAL_NATURE;  
 
                } else {  
 
                    return SolrQueryResult.POSITIVE_NATURE;  
 
                }  
 
            } else { // 标题无关，需要复杂的矩阵算法  
 
                parseRelWordsMap();  
 
                if (result < 0) {  
 
                    if (analyzeTrendencyByMatrix()) {  
 
                        return SolrQueryResult.NEGATIVE_NATURE;  
 
                    } else {  
 
                        return SolrQueryResult.NEUTRAL_NATURE;  
 
                    }  
 
                } else if (result == 0) {  
 
                    return SolrQueryResult.NEUTRAL_NATURE;  
 
                } else {  
 
                    return SolrQueryResult.POSITIVE_NATURE;  
 
                }  
 
            }  
 
        } catch (IOException e) {  
            return SolrQueryResult.NEUTRAL_NATURE;  
        }  
    }  
 
    private void clearAll() {  
 
        if (segments != null) {  
            segments.clear();  
        }  
        if (negs != null) {  
            negs.clear();  
        }  
        if (poses != null) {  
            poses.clear();  
        }  
    }  
 
    /**  
     * 是否是倾向性相关标题  
     *   
     * @param title  
     * @return  
     */ 
    private boolean isRelTitle(String title) {  
 
        try {  
 
            initTitleSegmentsMap(new StringReader(title));  
 
            List<String> relWords = wordLoader.getRefWordList();  
 
            for (String word : relWords) {  
 
                if (segments.containsKey(word)) {  
                    return true;  
                }  
 
            }  
 
        } catch (IOException e) {  
            return false;  
        }  
 
        return false;  
 
    }  
 
    /**  
     * 获取标题倾向性  
     *   
     * @param title  
     * @return  
     */ 
    private int getTitleTrendency() {  
 
        parseNegWordsMap();  
        parsePosWordsMap();  
 
        return analyzeContentsTrendency();  
 
    }  
 
    /**  
     * 判断整篇文章的倾向性  
     *   
     * @param title  
     * @param content  
     * @return  
     */ 
    private int analyzeContentsTrendency() {  
 
        int negScore = 0;  
        int posScore = 0;  
 
        if (negs != null && negs.size() > 0) {  
 
            for (Word word : negs) {  
                negScore += wordLoader.getNegWordMap().get(word.getString());  
            }  
 
        }  
 
        if (poses != null && poses.size() > 0) {  
 
            for (Word word : poses) {  
                posScore += wordLoader.getPosWordMap().get(word.getString());  
            }  
        }  
 
        return posScore - negScore;  
    }  
 
    /**  
     * 交叉矩阵判断文本倾向性  
     *   
     * @return  
     */ 
    private boolean analyzeTrendencyByMatrix() {  
 
        if (rels == null || rels.size() == 0) {  
            return false;  
        }  
 
        if (negs == null || negs.size() == 0) {  
            return false;  
        }  
 
        for (int i = 0; i < rels.size(); i++) {  
 
            for (int j = 0; j < negs.size(); j++) {  
 
                Word relWord = rels.get(i);  
                Word negWord = negs.get(j);  
 
                if (relWord.getStartOffset() < negWord.getStartOffset()) {  
 
                    if (negWord.getStartOffset() - relWord.getStartOffset()  
                            - relWord.getLength() < PS_THRESHOLD) {  
 
                        return true;  
 
                    }  
 
                } else {  
                    if (relWord.getStartOffset() - negWord.getStartOffset()  
                            - negWord.getLength() < NS_THRESHOLD) {  
                        return true;  
                    }  
                }  
 
            }  
 
        }  
 
        return false;  
 
    }  
 
    /**  
     * 先对标题进行分词  
     *   
     * @param reader  
     * @throws IOException  
     */ 
    private void initTitleSegmentsMap(Reader reader) throws IOException {  
 
        segments = new HashMap<String, List<Word>>();  
 
        MMSeg mmSeg = new MMSeg(reader, seg);  
 
        Word word = null;  
 
        while ((word = mmSeg.next()) != null) {  
 
            if (segments.containsKey(word.getString())) {  
 
                segments.get(word.getString()).add(word);  
            }  
 
            List<Word> words = new ArrayList<Word>();  
 
            words.add(word);  
 
            segments.put(word.getString(), words);  
 
        }  
    }  
 
    /**  
     * 对正文进行分词  
     *   
     * @param reader  
     * @throws IOException  
     */ 
    private void initSegmentsMap(Reader reader) throws IOException {  
 
        if (segments == null) {  
            segments = new HashMap<String, List<Word>>();  
        }  
 
        MMSeg mmSeg = new MMSeg(reader, seg);  
 
        Word word = null;  
 
        while ((word = mmSeg.next()) != null) {  
 
            if (segments.containsKey(word.getString())) {  
 
                segments.get(word.getString()).add(word);  
            }  
 
            List<Word> words = new ArrayList<Word>();  
 
            words.add(word);  
 
            segments.put(word.getString(), words);  
 
        }  
 
    }  
 
    /**  
     * 解析负面词汇  
     */ 
    private void parseNegWordsMap() {  
 
        Map<String, Integer> negMap = wordLoader.getNegWordMap();  
        Set<String> negKeys = negMap.keySet();  
 
        for (String negKey : negKeys) {  
 
            List<Word> negWords = segments.get(negKey);  
 
            if (negWords != null) {  
 
                if (negs == null) {  
                    negs = new ArrayList<Word>();  
                }  
 
                negs.addAll(negWords);  
 
            }  
 
        }  
 
    }  
 
    /**  
     * 解析正面词汇  
     */ 
    private void parsePosWordsMap() {  
 
        Map<String, Integer> posMap = wordLoader.getPosWordMap();  
        Set<String> posKeys = posMap.keySet();  
 
        for (String posKey : posKeys) {  
 
            List<Word> posWords = segments.get(posKey);  
 
            if (posWords != null) {  
 
                if (poses == null) {  
                    poses = new ArrayList<Word>();  
                }  
 
                poses.addAll(posWords);  
 
            }  
 
        }  
    }  
 
    /**  
     * 解析相关词汇  
     */ 
    private void parseRelWordsMap() {  
 
        List<String> refWords = wordLoader.getRefWordList();  
 
        for (String word : refWords) {  
 
            List<Word> relWords = segments.get(word);  
 
            if (relWords != null) {  
 
                if (rels == null) {  
                    rels = new ArrayList<Word>();  
                }  
 
                rels.addAll(relWords);  
 
            }  
        }  
 
    }  
 
}

这里面用了一些策略：

  1. 先分析标题，如果标题中出现相关词汇，仅需判断正文倾向性即可。
  2. 如果标题中出现相关词汇，并且标题存在倾向，以标题倾向为准。
  3. 如果上述都不成立，则合并标题与正文，一起进行分词与情感词汇识别。
  4. 对于通篇识别为负面情感的文章需要进一步判断相关性。
  5. 采用距离矩阵的方式判断相关性。
  6. 需要设定正向最大距离阈值与反向最大距离阈值。
「已注销」
关注
Web文本褒贬倾向性分类研究
05-17
【Web文本褒贬倾向性分类研究】是一篇深入探讨如何对网络文本进行情感倾向分析的学术文章。该研究主要关注Web文本中蕴含的作者观点和态度，旨在通过分类技术对文本进行褒贬分类，以便更好地理解和组织网络信息，提高...
文本倾向性分析
weixin_34347651的博客
03-29 205
package test; import java.sql.PreparedStatement; import java.sql.ResultSet; import java.sql.SQLException; import java.util.HashSet; import java.util.Iterator; import java.util.Set; import jav...
文本倾向性分析综述
xiakeyou的专栏
12-01 4401
2008/10/13 20:50最近看了两篇关于文本倾向性分析的硕士学位论文（金晓鸥 (2008). 互联网舆情信息获取与分析研究. 上海, 上海交通大学.；肖伟 (2007). 基于语义的BLOG社区文本倾向性分析. 上海, 上海交通大学.），总结了一下：1. 文本倾向性分析的定义和主要任务Peter等人指出，文本倾向性分析(SentimentClassificatio
基于深度学习的文本情感倾向分析（综述）
qq_43697382的博客
06-20 5175
基于深度学习的文本情感倾向分析（综述）
【文本网站的分析】
最新发布
m0_64750119的博客
10-24 192
文本网站的分析
利用HTMLParser解析网页中的文本
hotpot的博客
06-29 1348
这篇文章主要是使用HTMLParser来解析一个网页，获取想要的信息。具体python代码实现如下：#这个小程序可以用来获取html页面中的指定信息 #此例中是读取Python官网发布的会议时间、名称和地点 from html.parser import HTMLParser from html.entities import name2codepoint from urllib import ...
股票分析经纪公司网页模板
01-22
不过，由于其不兼容移动设备和安全性问题，现代网页设计倾向于避免使用Flash。 7. **股票分析**：模板可能包含集成的股票分析工具，如技术指标（如MACD、RSI）、图表（K线图、折线图）、历史数据查询等，帮助投资者...
利用mmSeg4j分词实现网页文本倾向性分析
小飞侠的博客
12-16 100
利用mmSeg4j分词实现网页文本倾向性分析 最近一直在做网页情感倾向性分析的工作，找了一些论文，发现基于机器学习的算法在项目中不太合适，于是自己鼓捣了一套基于中文分词和正负面词库的分析算法。 原理很简单： 文章倾向性 = ∑（出现的正面词汇 * 权重） —∑(出现的负面词汇 * 权重）。 在这个基础上对于负面新闻再加上相关性判断。 ...
使用Docx4j操作PPT指南系列（一）
weixin_33692284的博客
01-06 320
使用Docx4j操作PPT指南系列（一） —— pptx文档的生成与添加新页 写在最前 由于项目需要系统生成ppt文档，在开源技术中选定了docx4j。docx4j操作ppt的文档几乎没有（中文的就更加凤毛麟角了），所有的东西只能自己去摸索，...
基于LingPipe的文本倾向性分析--LingPipe学习笔记
gdp5211314的专栏
02-21 1859
文本倾向性分析 文本倾向性分析（情感分析 ）是将用户的观点分为“正面”和“负面”，有时候会多一个“中性”。文本倾向性分析一个比较直观的应用就是追踪用户对于一个事物的观点和偏好，比如分析豆瓣上一个电影的评论进行分析。正因为如此情感分析又被称为观点挖掘。 LingPipe lingpipe 是alias公司开发的一款自然语言处理软件包，包括主题分类、句题检测、字符语言建模等十余个模块
基于文本的网页分析算法
牛牛码特的博客
03-28 125
1）纯文本分类与聚类算法。 2）超文本分类和聚类算法。
利用情感种子词计算数据集中最具有正负情感的前50个词【社会计算大作业】
m0_52775920的博客
11-21 2264
说明 需要相关文件的，请访问我的 github仓库，指路。拜托顺手点个小 star 。 步骤 读取评论文件，按照正向和负向两个分类把评论分别写入两个新的文件（正向的评论和负向的评论）。读取前4000条写入正向的评论文件，后8000条写入负向的评论文件。 def separate_csv(file): """ 将评论按照正向或者负向分别写入两个文件 """ a = 1 with open(file, "r", encoding="utf-8") as f: reader
Python_001_旅游评论情感倾向性分析_000_分析(基于深度学习的微博评论情感倾向性分析_胡西祥)论文
生于忧患，死于安乐
09-26 779
Python_001_旅游评论情感倾向性分析_000_分析论文
Python训练文本情感分析模型
热门推荐
S_Masons的博客
08-22 2万+
最近闲来无事，看了 王树义老师 的一篇文章 《如何用Python和机器学习训练中文文本情感分类模型》，跟着步骤做了一个demo，此demo是爬取了美团用户的评论，对评论进行情感分析，收获很大，特此做下了笔记。 首先导入库 import pandas as pd import numpy as np from pandas import DataFrame, Series 读取评论数据，数据在 ...
实现python一个简单的文本情感分析
lemon_wsm的博客
05-06 2719
结果：
Python数据分析8-----网页文本处理
weixin_34413065的博客
07-17 186
1、去除网页的标签，如<br/> from bs4 import BeautifulrSoup preData=BeautifulSoup(data,'html.parser').get_text() 2、将标点符号等去掉，用正则表达式。 import re#表示将data中的除了大小写字母之外的符号换成空格 preData=re.sub(r'[^a-zA...
利用机器学习进行文本预测分析
"PredictiveMethodsforTextMining是关于利用机器学习和预测方法进行文本挖掘的讨论，旨在有效地利用丰富的电子文本资源，如电子邮件、网页、文档等，通过组织和分析文本来实现信息过滤、模式发现、知识库创建等功能...
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值