精华内容
下载资源
问答
  • 评论观点抽取

    2018-01-08 18:52:00
    评论观点抽取自动抽取和分析评论观点,帮助您实现舆情分析、用户理解,支持产品优化和营销决策 功能介绍自动分析评论关注点和评论观点,并输出评论观点标签及评论观点极性。目前支持13类产品用户评论观点抽取,...

     

    评论观点抽取
    自动抽取和分析评论观点,帮助您实现舆情分析、用户理解,支持产品优化和营销决策

     

    功能介绍
    自动分析评论关注点和评论观点,并输出评论观点标签及评论观点极性。目前支持13类产品用户评论的观点抽取,包括美食、酒店、汽车、景点等,可帮助商家进行产品分析,辅助用户进行消费决策

    https://ai.baidu.com/tech/nlp/comment_tag

     

    接口说明

    语音识别

    接口描述

    向远程服务上传整段语音进行识别

    请求说明

    举例:

    public void synthesis(AipSpeech client)
    {
    	// 对本地语音文件进行识别
        String path = "D:\\code\\java-sdk\\speech_sdk\\src\\test\\resources\\16k_test.pcm"; JSONObject asrRes = client.asr(path, "pcm", 16000, null); System.out.println(asrRes); // 对语音二进制数据进行识别 byte[] data = Util.readFileByBytes(path); //readFileByBytes仅为获取二进制数据示例 JSONObject asrRes2 = client.asr(data, "pcm", 16000, null); System.out.println(asrRes); // 对网络上音频进行识别 String url = "http://somehost/res/16k_test.pcm"; String callback = "http://callbackhost/aip/dump"; JSONObject res = client.asr(url, callback, "pcm", 16000, null); System.out.println(res); } 

    接口函数说明:

    // 语音识别
    JSONObject asr(String path, String format, int rate, HashMap<String, Object> options); JSONObject asr(byte[] data, String format, int rate, HashMap<String, Object> options); JSONObject asr(String url, String callback, String format, int rate, HashMap<String, Object> options); 
    参数类型描述是否必须
    path/dataString/byte[]语音文件所在路径或二进制数据, 语音文件的格式,pcm 或者 wav 或者 amr。不区分大小写
    urlString语音下载地址
    callbackString识别结果回调地址
    formatString包括pcm(不压缩)、wav、opus、speex、amr
    rateint采样率,支持 8000 或者 16000
    cuidString用户唯一标识,用来区分用户,填写机器 MAC 地址或 IMEI 码,长度为60以内
    lanString语种选择,中文=zh、粤语=ct、英文=en,不区分大小写,默认中文
    ptcint协议号,下行识别结果选择,默认 nbest 结果

    语音识别 返回数据参数详情

    参数类型是否一定输出描述
    err_noint错误码
    err_msgint错误码描述
    snint语音数据唯一标识,系统内部产生,用于 debug
    resultint识别结果数组,提供1-5 个候选结果,string 类型为识别的字符串, utf-8 编码

    返回样例:

    // 成功返回
    {
    	"err_no": 0,
    	"err_msg": "success.", "corpus_no": "15984125203285346378", "sn": "481D633F-73BA-726F-49EF-8659ACCC2F3D", "result": ["北京天气"] } // 失败返回 { "err_no": 2000, "err_msg": "data empty.", "sn": null } 

    错误信息

    错误返回格式

    若请求错误,服务器将返回的JSON文本包含以下参数:

    • error_code:错误码。
    • error_msg:错误描述信息,帮助理解和解决发生的错误。

     http://ai.baidu.com/docs#/ASR-Online-Java-SDK/top

     

    转载于:https://www.cnblogs.com/softidea/p/8244270.html

    展开全文
  • 基于深度学习和CRFs的产品评论观点抽取方法.pdf
  • 用户评论观点抽取

    千次阅读 2019-01-03 17:11:20
    其实评论挖掘的主要有两个部分,观点抽取和情感判断,主要的作用还是间接或直接引导用户购买意向,像淘宝,京东类似的智能展示。而评论的主语都是商家,但如果平台即是商家的话,展示评论观点就会显得比较鸡肋,因为...

    1.目的:从用户的订单评论里,抽取观点,进行标签化,此标签可以用来作一些辅助决策或者填充到用户画像体系里。

    其实评论挖掘的主要有两个部分,观点抽取和情感判断,主要的作用还是间接或直接引导用户购买意向,像淘宝,京东类似的智能展示。而评论的主语都是商家,但如果平台即是商家的话,展示评论观点就会显得比较鸡肋,因为不可能展示对自身不好的评论。因此在这种情况下,评论挖掘的意义更在于知道用户对商家的反馈,建模统计用户对商家的关注点是什么,例如是对商家的服务、价格还是app应用的反馈问题,知道这些,可以更好的对产品进行更好的决策和更改。

    参考书籍:https://pan.baidu.com/s/1aHP7q8ktJWSVhTBRiziECw,美团机器学习实践。

    2.例子:

                 输入:车子价格优惠,车况良好,服务态度很好,很周到。

                 输出:价格优惠、车况不错、服务好

    3.方案:

    a.刚开时我做的时候,是先调用了百度AI平台的观点抽取,发现不怎么好用,可能是我所在行业所导致的,有很多大量的专有词汇。

    b.评论标签化,可以看成noun+adj,也就是名词和描述性词汇的结合。有一个大众的做法,就是通过依存句法分析来进行匹配,然后word2vec向量化+dbscan聚类,就可以做到类似淘宝那种评论观点显示,例子:

    输入:服务很到位   

    依存句法分析输出后:主谓关系:服务,状中结构:很,核心关系:到位

    可以看出最终的结合是主谓关系+核心关系,就可以将评论观点抽取出来。不过这种方法问题还是很大,实际运用时,不能单单只靠依存句法分析来处理,会出现很多问题的。

    c.首先得建立独有的词表(跟自己行业有关),比如名词词表,像我的行业里,独有的有车况,取车,还车,手续之类独有的,描述性词表同理(这个手动去挑选比较好,如果词典比较大,再用代码去挑选)。注意:有些词汇出现的频率非常高,但是其不是名词,也不是形容词的话,这种情况要单独挑选出来处理,以免纰漏。

    两个词表建立完以后,可以通过word2vec去将相似的词汇进行聚类统一(实际运用时还不如直接人工简单粗暴的好用)。这两个词表在去结合依存句法分析来进行提取,就会比较准确。

    d.评论最后都抽取完以后,就可以进行统计分析了,或者出于业务角度来进行应用。

              

    展开全文
  • 目前已经可以返回值,但是只有对第一条数据进行评论观点抽取的结果。 总共list里酒店数据有1W多条,但是只返回了第一条数据的处理结果 {'log_id': 8924813165379044540, 'items': [{'sentiment': 2, 'abstract':...
  • 观点抽取 “语言云” 以哈工大社会计算与信息检索研究中心研发的 “语言技术平台(LTP)” 为基础,为用户提供高效精准的中文自然语言处理云服务。 pyltp 是 LTP 的 Python 封装,提供了分词,词性标注,命名实体...

    无监督信息抽取较多都是使用哈工大的ltp作为底层框架。那么基于ltp其实有了非常多的小伙伴进行了尝试,笔者私自将其归纳为:

    • 事件抽取(三元组)
    • 观点抽取

    “语言云” 以哈工大社会计算与信息检索研究中心研发的 “语言技术平台(LTP)” 为基础,为用户提供高效精准的中文自然语言处理云服务。
    pyltp 是 LTP 的 Python 封装,提供了分词,词性标注,命名实体识别,依存句法分析,语义角色标注的功能。

    • 技术文档:http://pyltp.readthedocs.io/zh_CN/latest/api.html#id15
    • 介绍文档:https://www.ltp-cloud.com/intro/#introduction
    • 介绍文档:http://ltp.readthedocs.io/zh_CN/latest/appendix.html#id5

    需要先载入他们训练好的模型,下载地址

    初始化pyltp的时候一定要留意内存问题,初始化任何子模块(Postagger() /NamedEntityRecognizer()等等)都是需要占用内存,如果不及时释放会爆内存。
    之前比较好的尝试是由该小伙伴已经做的小项目:liuhuanyong/EventTriplesExtraction

    展开全文
  • 使用HOWNet知识资源建立极性词库,吸取语义块和依存关系的思想,提出了极性...通过测试,将自动抽取观点与手工标注结果进行比较,得出召回率和准确率,并和其它算法结果数据比较,证明了极性收缩传递算法的有效性。
  • 下面代码也许有助你使用...baidu API有10多个接口,下面仅仅演示评论观点抽取,其他方法一样,只是参数不一样。 工具类: package com.baidu.ai.aip.utils; /** * Base64 工具类 */ public class Base64Util {

    下面代码也许有助你使用百度自然语言处理API功能,自己理解吧,哦,说一下,工具类非本人原创,仅仅供示例代码使用。

    baidu API有10多个接口,下面仅仅演示评论观点抽取,其他方法一样,只是参数不一样。

    工具类:


    package com.baidu.ai.aip.utils;
    
    /**
     * Base64 工具类
     */
    public class Base64Util {
        private static final char last2byte = (char) Integer.parseInt("00000011", 2);
        private static final char last4byte = (char) Integer.parseInt("00001111", 2);
        private static final char last6byte = (char) Integer.parseInt("00111111", 2);
        private static final char lead6byte = (char) Integer.parseInt("11111100", 2);
        private static final char lead4byte = (char) Integer.parseInt("11110000", 2);
        private static final char lead2byte = (char) Integer.parseInt("11000000", 2);
        private static final char[] encodeTable = new char[]{'A', 'B', 'C', 'D', 'E', 'F', 'G', 'H', 'I', 'J', 'K', 'L', 'M', 'N', 'O', 'P', 'Q', 'R', 'S', 'T', 'U', 'V', 'W', 'X', 'Y', 'Z', 'a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'k', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u', 'v', 'w', 'x', 'y', 'z', '0', '1', '2', '3', '4', '5', '6', '7', '8', '9', '+', '/'};
    
        public Base64Util() {
        }
    
        public static String encode(byte[] from) {
            StringBuilder to = new StringBuilder((int) ((double) from.length * 1.34D) + 3);
            int num = 0;
            char currentByte = 0;
    
            int i;
            for (i = 0; i < from.length; ++i) {
                for (num %= 8; num < 8; num += 6) {
                    switch (num) {
                        case 0:
                            currentByte = (char) (from[i] & lead6byte);
                            currentByte = (char) (currentByte >>> 2);
                        case 1:
                        case 3:
                        case 5:
                        default:
                            break;
                        case 2:
                            currentByte = (char) (from[i] & last6byte);
                            break;
                        case 4:
                            currentByte = (char) (from[i] & last4byte);
                            currentByte = (char) (currentByte << 2);
                            if (i + 1 < from.length) {
                                currentByte = (char) (currentByte | (from[i + 1] & lead2byte) >>> 6);
                            }
                            break;
                        case 6:
                            currentByte = (char) (from[i] & last2byte);
                            currentByte = (char) (currentByte << 4);
                            if (i + 1 < from.length) {
                                currentByte = (char) (currentByte | (from[i + 1] & lead4byte) >>> 4);
                            }
                    }
    
                    to.append(encodeTable[currentByte]);
                }
            }
    
            if (to.length() % 4 != 0) {
                for (i = 4 - to.length() % 4; i > 0; --i) {
                    to.append("=");
                }
            }
    
            return to.toString();
        }
    }
    

    package com.baidu.ai.aip.utils;
    
    import java.io.*;
    
    /**
     * 文件读取工具类
     */
    public class FileUtil {
    
        /**
         * 读取文件内容,作为字符串返回
         */
        public static String readFileAsString(String filePath) throws IOException {
            File file = new File(filePath);
            if (!file.exists()) {
                throw new FileNotFoundException(filePath);
            } 
    
            if (file.length() > 1024 * 1024 * 1024) {
                throw new IOException("File is too large");
            } 
    
            StringBuilder sb = new StringBuilder((int) (file.length()));
            // 创建字节输入流  
            FileInputStream fis = new FileInputStream(filePath);  
            // 创建一个长度为10240的Buffer
            byte[] bbuf = new byte[10240];  
            // 用于保存实际读取的字节数  
            int hasRead = 0;  
            while ( (hasRead = fis.read(bbuf)) > 0 ) {  
                sb.append(new String(bbuf, 0, hasRead));  
            }  
            fis.close();  
            return sb.toString();
        }
    
        /**
         * 根据文件路径读取byte[] 数组
         */
        public static byte[] readFileByBytes(String filePath) throws IOException {
            File file = new File(filePath);
            if (!file.exists()) {
                throw new FileNotFoundException(filePath);
            } else {
                ByteArrayOutputStream bos = new ByteArrayOutputStream((int) file.length());
                BufferedInputStream in = null;
    
                try {
                    in = new BufferedInputStream(new FileInputStream(file));
                    short bufSize = 1024;
                    byte[] buffer = new byte[bufSize];
                    int len1;
                    while (-1 != (len1 = in.read(buffer, 0, bufSize))) {
                        bos.write(buffer, 0, len1);
                    }
    
                    byte[] var7 = bos.toByteArray();
                    return var7;
                } finally {
                    try {
                        if (in != null) {
                            in.close();
                        }
                    } catch (IOException var14) {
                        var14.printStackTrace();
                    }
    
                    bos.close();
                }
            }
        }
    }
    

    /*
     * Copyright (C) 2017 Baidu, Inc. All Rights Reserved.
     */
    package com.baidu.ai.aip.utils;
    
    import com.google.gson.Gson;
    import com.google.gson.GsonBuilder;
    import com.google.gson.JsonParseException;
    
    import java.lang.reflect.Type;
    
    /**
     * Json工具类.
     */
    public class GsonUtils {
        private static Gson gson = new GsonBuilder().create();
    
        public static String toJson(Object value) {
            return gson.toJson(value);
        }
    
        public static <T> T fromJson(String json, Class<T> classOfT) throws JsonParseException {
            return gson.fromJson(json, classOfT);
        }
    
        public static <T> T fromJson(String json, Type typeOfT) throws JsonParseException {
            return (T) gson.fromJson(json, typeOfT);
        }
    }
    

    package com.baidu.ai.aip.utils;
    
    import java.io.BufferedReader;
    import java.io.DataOutputStream;
    import java.io.InputStreamReader;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.util.List;
    import java.util.Map;
    
    /**
     * http 工具类
     */
    public class HttpUtil {
    
        public static String post(String requestUrl, String accessToken, String params)
                throws Exception {
            String contentType = "application/x-www-form-urlencoded";
            return HttpUtil.post(requestUrl, accessToken, contentType, params);
        }
    
        public static String post(String requestUrl, String accessToken, String contentType, String params)
                throws Exception {
            String encoding = "UTF-8";
            if (requestUrl.contains("nlp")) {
                encoding = "GBK";
            }
            return HttpUtil.post(requestUrl, accessToken, contentType, params, encoding);
        }
    
        public static String post(String requestUrl, String accessToken, String contentType, String params, String encoding)
                throws Exception {
            String url = requestUrl + "?access_token=" + accessToken;
            return HttpUtil.postGeneralUrl(url, contentType, params, encoding);
        }
    
        public static String postGeneralUrl(String generalUrl, String contentType, String params, String encoding)
                throws Exception {
            URL url = new URL(generalUrl);
            // 打开和URL之间的连接
            HttpURLConnection connection = (HttpURLConnection) url.openConnection();
            connection.setRequestMethod("POST");
            // 设置通用的请求属性
            connection.setRequestProperty("Content-Type", contentType);
            connection.setRequestProperty("Connection", "Keep-Alive");
            connection.setUseCaches(false);
            connection.setDoOutput(true);
            connection.setDoInput(true);
    
            // 得到请求的输出流对象
            DataOutputStream out = new DataOutputStream(connection.getOutputStream());
            out.write(params.getBytes(encoding));
            out.flush();
            out.close();
    
            // 建立实际的连接
            connection.connect();
            // 获取所有响应头字段
            Map<String, List<String>> headers = connection.getHeaderFields();
            // 遍历所有的响应头字段
            for (String key : headers.keySet()) {
                System.err.println(key + "--->" + headers.get(key));
            }
            // 定义 BufferedReader输入流来读取URL的响应
            BufferedReader in = null;
            in = new BufferedReader(
                    new InputStreamReader(connection.getInputStream(), encoding));
            String result = "";
            String getLine;
            while ((getLine = in.readLine()) != null) {
                result += getLine;
            }
            in.close();
            System.err.println("result:" + result);
            return result;
        }
    }
    

    package test;
    
    import java.io.BufferedReader;  
    import java.io.IOException;
    import java.io.InputStream;  
    import java.io.InputStreamReader;  
    import java.io.OutputStreamWriter;
    import java.io.UnsupportedEncodingException;  
    import java.net.HttpURLConnection;  
    import java.net.InetSocketAddress;
    import java.net.Proxy;
    import java.net.URL; 
    import java.net.URLConnection;
    import java.util.List;
    import java.util.Map;
    
    /** 
     * Http请求工具类 
     * @author snowfigure 
     * @since 2014-8-24 13:30:56 
     * @version v1.0.1 
     */ 
    public class HttpRequestUtil {
        static boolean proxySet = false;
        static String proxyHost = "127.0.0.1";
        static int proxyPort = 8087;
        /** 
         * 编码 
         * @param source 
         * @return 
         */  
        public static String urlEncode(String source,String encode) {  
            String result = source;  
            try {  
                result = java.net.URLEncoder.encode(source,encode);  
            } catch (UnsupportedEncodingException e) {  
                e.printStackTrace();  
                return "0";  
            }  
            return result;  
        }
        public static String urlEncodeGBK(String source) {  
            String result = source;  
            try {  
                result = java.net.URLEncoder.encode(source,"GBK");  
            } catch (UnsupportedEncodingException e) {  
                e.printStackTrace();  
                return "0";  
            }  
            return result;  
        }
        /** 
         * 发起http请求获取返回结果 
         * @param req_url 请求地址 
         * @return 
         */  
        public static String httpRequest(String req_url) {
            StringBuffer buffer = new StringBuffer();  
            try {  
                URL url = new URL(req_url);  
                HttpURLConnection httpUrlConn = (HttpURLConnection) url.openConnection();  
    
                httpUrlConn.setDoOutput(false);  
                httpUrlConn.setDoInput(true);  
                httpUrlConn.setUseCaches(false);  
    
                httpUrlConn.setRequestMethod("GET");  
                httpUrlConn.connect();  
    
                // 将返回的输入流转换成字符串  
                InputStream inputStream = httpUrlConn.getInputStream();  
                InputStreamReader inputStreamReader = new InputStreamReader(inputStream, "utf-8");  
                BufferedReader bufferedReader = new BufferedReader(inputStreamReader);  
    
                String str = null;  
                while ((str = bufferedReader.readLine()) != null) {  
                    buffer.append(str);  
                }  
                bufferedReader.close();  
                inputStreamReader.close();  
                // 释放资源  
                inputStream.close();  
                inputStream = null;  
                httpUrlConn.disconnect();  
    
            } catch (Exception e) {  
                System.out.println(e.getStackTrace());  
            }  
            return buffer.toString();  
        }  
    
        /** 
         * 发送http请求取得返回的输入流 
         * @param requestUrl 请求地址 
         * @return InputStream 
         */  
        public static InputStream httpRequestIO(String requestUrl) {  
            InputStream inputStream = null;  
            try {  
                URL url = new URL(requestUrl);  
                HttpURLConnection httpUrlConn = (HttpURLConnection) url.openConnection();  
                httpUrlConn.setDoInput(true);  
                httpUrlConn.setRequestMethod("GET");  
                httpUrlConn.connect();  
                // 获得返回的输入流  
                inputStream = httpUrlConn.getInputStream();  
            } catch (Exception e) {  
                e.printStackTrace();  
            }  
            return inputStream;  
        }
    
    
        /**
         * 向指定URL发送GET方法的请求
         * 
         * @param url
         *            发送请求的URL
         * @param param
         *            请求参数,请求参数应该是 name1=value1&name2=value2 的形式。
         * @return URL 所代表远程资源的响应结果
         */
        public static String sendGet(String url, String param) {
            String result = "";
            BufferedReader in = null;
            try {
                String urlNameString = url + "?" + param;
                URL realUrl = new URL(urlNameString);
                // 打开和URL之间的连接
                URLConnection connection = realUrl.openConnection();
                // 设置通用的请求属性
                connection.setRequestProperty("accept", "*/*");
                connection.setRequestProperty("connection", "Keep-Alive");
                connection.setRequestProperty("user-agent",
                        "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
                // 建立实际的连接
                connection.connect();
                // 获取所有响应头字段
                Map<String, List<String>> map = connection.getHeaderFields();
                // 遍历所有的响应头字段
                for (String key : map.keySet()) {
                    System.out.println(key + "--->" + map.get(key));
                }
                // 定义 BufferedReader输入流来读取URL的响应
                in = new BufferedReader(new InputStreamReader(
                        connection.getInputStream()));
                String line;
                while ((line = in.readLine()) != null) {
                    result += line;
                }
            } catch (Exception e) {
                System.out.println("发送GET请求出现异常!" + e);
                e.printStackTrace();
            }
            // 使用finally块来关闭输入流
            finally {
                try {
                    if (in != null) {
                        in.close();
                    }
                } catch (Exception e2) {
                    e2.printStackTrace();
                }
            }
            return result;
        }
    
        /**
         * 向指定 URL 发送POST方法的请求
         * 
         * @param url
         *            发送请求的 URL
         * @param param
         *            请求参数,请求参数应该是 name1=value1&name2=value2 的形式。
         * @param isproxy
         *               是否使用代理模式
         * @return 所代表远程资源的响应结果
         */
        public static String sendPost(String url, String param,boolean isproxy) {
            OutputStreamWriter out = null;
            BufferedReader in = null;
            String result = "";
            try {
                URL realUrl = new URL(url);
                HttpURLConnection conn = null;
                if(isproxy){//使用代理模式
                    @SuppressWarnings("static-access")
                    Proxy proxy = new Proxy(Proxy.Type.DIRECT.HTTP, new InetSocketAddress(proxyHost, proxyPort));
                    conn = (HttpURLConnection) realUrl.openConnection(proxy);
                }else{
                    conn = (HttpURLConnection) realUrl.openConnection();
                }
                // 打开和URL之间的连接
    
                // 发送POST请求必须设置如下两行
                conn.setDoOutput(true);
                conn.setDoInput(true);
                conn.setRequestMethod("POST");    // POST方法
    
    
                // 设置通用的请求属性
    
                conn.setRequestProperty("accept", "*/*");
                conn.setRequestProperty("connection", "Keep-Alive");
                conn.setRequestProperty("user-agent",
                        "Mozilla/4.0 (compatible; MSIE 6.0; Windows NT 5.1;SV1)");
                conn.setRequestProperty("Content-Type", "application/x-www-form-urlencoded");
    
                conn.connect();
    
                // 获取URLConnection对象对应的输出流
                out = new OutputStreamWriter(conn.getOutputStream(), "UTF-8");
                // 发送请求参数
                out.write(param);
                // flush输出流的缓冲
                out.flush();
                // 定义BufferedReader输入流来读取URL的响应
                in = new BufferedReader(
                        new InputStreamReader(conn.getInputStream()));
                String line;
                while ((line = in.readLine()) != null) {
                    result += line;
                }
            } catch (Exception e) {
                System.out.println("发送 POST 请求出现异常!"+e);
                e.printStackTrace();
            }
            //使用finally块来关闭输出流、输入流
            finally{
                try{
                    if(out!=null){
                        out.close();
                    }
                    if(in!=null){
                        in.close();
                    }
                }
                catch(IOException ex){
                    ex.printStackTrace();
                }
            }
            return result;
        }    
    
        public static void main(String[] args) {
            //demo:代理访问
            String url = "http://api.adf.ly/api.php";
            String para = "key=youkeyid&youuid=uid&advert_type=int&domain=adf.ly&url=http://somewebsite.com";
    
            String sr=HttpRequestUtil.sendPost(url,para,true);
            System.out.println(sr);
        }
    
    }



    package test;
    
    
    
    import org.json.JSONObject;
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.util.List;
    import java.util.Map;
    
    
    
    /**
     * 获取token类
     */
    public class AuthService {
    
        /**
         * 获取权限token
         * @return 返回示例:
         * {
         * "access_token": "luozhuang",
         * "expires_in": 2592000
         * }
         */
        public static String getAuth() {
        	//java.security.Security.setProperty("ssl.SocketFactory.provider", "sun.security.ssl.SSLSocketFactoryImpl");
        	//java.security.Security.setProperty("ssl.ServerSocketFactory.provider", "sun.security.ssl.SSLSocketFactoryImpl");
            // 官网获取的 API Key 更新为你注册的
            String clientId = "luozhuang";
            // 官网获取的 Secret Key 更新为你注册的
            String clientSecret = "luozhuang";
            return getAuth(clientId, clientSecret);
        }
    
        /**
         * 获取API访问token
         * 该token有一定的有效期,需要自行管理,当失效时需重新获取.
         * @param ak - 百度云官网获取的 API Key
         * @param sk - 百度云官网获取的 Securet Key
         * @return assess_token 示例:
         * "luozhuang"
         */
        public static String getAuth(String ak, String sk) {
            // 获取token地址
        	 String access_token = null;
            String authHost = "https://aip.baidubce.com/oauth/2.0/token?";
            String getAccessTokenUrl = authHost
                    // 1. grant_type为固定参数
                    + "grant_type=client_credentials"
                    // 2. 官网获取的 API Key
                    + "&client_id=" + ak
                    // 3. 官网获取的 Secret Key
                    + "&client_secret=" + sk;
            try {
                URL realUrl = new URL(getAccessTokenUrl);
                // 打开和URL之间的连接
                HttpURLConnection connection = (HttpURLConnection) realUrl.openConnection();
                connection.setRequestMethod("GET");
                connection.connect();
                // 获取所有响应头字段
                Map<String, List<String>> map = connection.getHeaderFields();
                // 遍历所有的响应头字段
                for (String key : map.keySet()) {
                    System.err.println(key + "--->" + map.get(key));
                }
                // 定义 BufferedReader输入流来读取URL的响应
                BufferedReader in = new BufferedReader(new InputStreamReader(connection.getInputStream()));
                String result = "";
                String line;
                while ((line = in.readLine()) != null) {
                    result += line;
                }
                /**
                 * 返回结果示例
                 */
                System.err.println("result:" + result);
                JSONObject jsonObject = new JSONObject(result);
                 access_token = jsonObject.getString("access_token");
                return access_token;
            } catch (Exception e) {
                System.err.printf("获取token失败!");
                e.printStackTrace(System.err);
            }
            return access_token;
        }
    
            public static void main(String args[]) { 
            	AuthService temp=new AuthService();
            	temp.getAuth();
            } 
       
    }
    package test;
    
    import java.io.BufferedReader;
    import java.io.InputStreamReader;
    import java.io.UnsupportedEncodingException;
    import java.net.HttpURLConnection;
    import java.net.URL;
    import java.net.URLDecoder;
    import java.net.URLEncoder;
    import java.util.HashMap;
    import java.util.List;
    import java.util.Map;
    
    import org.json.JSONArray;
    import org.json.JSONObject;
    
    import com.alibaba.fastjson.JSON;
    import com.baidu.ai.aip.utils.GsonUtils;
    import com.baidu.ai.aip.utils.HttpUtil;
    
    public class recComment_TagClss {
    	// #####调用鉴权接口获取的token#####
    	public String access_token = "luozhuang";
    	int getaccesstokentime;
    	String comment_tag_Url = "https://aip.baidubce.com/rpc/2.0/nlp/v2/comment_tag";
    
    	public String getaccess_token() {
    		AuthService temp = new AuthService();
    		access_token = temp.getAuth();
    		return access_token;
    	}
    
    	public String comment_tag(String accessToken, String comment) {
    		try {
    			comment = URLDecoder.decode(comment, "utf-8");
    		} catch (UnsupportedEncodingException e1) {
    
    			e1.printStackTrace();
    		}
    		String result = null;
    		// 评论观点抽取url
    		if (comment == null) {
    			return result;
    		}
    
    		try {
    			Map<String, Object> map = new HashMap<String, Object>();
    			// comment = URLEncoder.encode(comment, "GBK");
    			map.put("text", comment); // 评论内容
    			map.put("type", 13); // 类别
    			String params = GsonUtils.toJson(map);
    
    			/**
    			 * 线上环境access_token有过期时间, 客户端可自行缓存,过期后重新获取。
    			 */
    
    			result = HttpUtil.post(comment_tag_Url, accessToken, params);
    
    			System.out.println(result);
    			JSONObject jsonObject = new JSONObject(result);
    			if (jsonObject.has("error_code") == true) {
    				int error=jsonObject.getInt("error_code");
    				if("282130".equals(String.valueOf(error)))
    				{ 
    				return "282130 没有识别到数据";
    				}
    				else
    				{
    				return "错误:" + jsonObject.getString("error_msg");
    				}
    			}
    			if (jsonObject.has("items") == true) {
    
    				JSONArray item = jsonObject.getJSONArray("items");
    				result = "";
    				if (item == null) {
    					return result;
    				}
    
    				for (int i = 0; i < item.length(); i++) {
    					jsonObject = item.getJSONObject(i);
    					result = result + ";" + jsonObject.getString("abstract");
    				}
    			}
    
    		} catch (Exception e) {
    			e.printStackTrace();
    		}
    		return result;
    	}
    
    	public static void main(String args[]) {
    		recComment_TagClss tempTagClss = new recComment_TagClss();
    		/*
    		 * AuthService temp=new AuthService(); String
    		 * access_token=temp.getAuth();
    		 */
    		String comment = "个人觉得luozhuang好,外观漂亮年轻,动力和操控性都不错";
    		tempTagClss.comment_tag(tempTagClss.getaccess_token(), comment);
    	}
    }


    
    
    展开全文
  • 评论内容观点抽取

    千次阅读 2017-05-27 14:56:37
    1)评论情感分析 可分为积极,中性,负面情绪。有两种方式:DNN分类,根据词向量搭建一个分类器即可;基于情感字典,可采用ROSTCM6的基于词典方法 2)基于语义网络的评论分析 可视化后看上去比较酷炫哈哈 ...
  • 短语分析-观点抽取

    千次阅读 2018-09-26 20:10:35
    一种是对评论进行观点抽取,得到一个短语,然后在对短语进行分类。 1.文章观点抽取 文章的观点抽取结果可以是一句话(类似标题),一段话(类似摘要),一个短语,一个关键词(打标签,其实是文本分类)。 2.评论...
  • 今天小编就为大家分享一篇对python借助百度云API对评论进行观点抽取的方法详解,具有很好的参考价值,希望对大家有所帮助。一起跟随小编过来看看吧
  • 通过百度云API接口抽取得到产品评论观点,也掠去了很多评论中无用的内容以及符号,为后续进行文本主题挖掘或者规则的提取提供基础。 工具 1、百度云账号,申请应用接口(自然语言处理) 2、python3.5 以下是...
  • 通过百度云API接口抽取得到产品评论观点,也掠去了很多评论中无用的内容以及符号,为后续进行文本主题挖掘或者规则的提取提供基础。 工具 1、百度云账号,申请应用接口(自然语言处理) 2、python3.5 以下是...
  • 该文首先利用依存语法对句子进行了依存分析,在此基础上研究了旅游评论文本中特征-观点对的抽取。利用词对间的依存关系,构建了获取含有特征和观点词语的组块规则,并设计了候选特征的识别算法和特征—观点对的抽取算法...
  • 通过百度云API接口抽取得到产品评论观点,也掠去了很多评论中无用的内容以及符号,为后续进行文本主题挖掘或者规则的提取提供基础。工具1、百度云账号,申请应用接口(自然语言处理)2、python3.5以下是百度接口...
  • 互联网上的海量信息中包含...从网上相关信息中抽取出人们的主观意向如消费者的购买倾向、政治观点等已成为了Web研究的热点。提出了几种适用于实时抽取网上舆论观点的算法,主要描述了各算法分析观点的原理及分类过程。
  • 基于情感分析的学生评教文本观点抽取与聚类.pdf
  • 汉语句子语义极性分析和观点抽取方法的研究_娄德成
  • 所谓的观点抽取就是从文本中获取关于某个特征词的观点词语。特征词在句子结构中通常为主语或者宾语,从词性上看一般为名词或者形容词,而观点词通常为带有情感色彩的形容词或者副词。观点词的抽取在用户对产品评价...
  • 电信设备-一种中文的观点、评价信息的属性-观点抽取方法.zip
  • 背景介绍 文本情感分析旨在自动地从非结构化的评论文本中抽取有用的观点信息 [1,2] 。早先的文本情感分析工作主要关注文档级别的情感分析和句子级别的情感分析,采用各种方法来分析评论文档或句子整体的情感极性...
  • 语法和语义的观点抽取混合域词典构造方法(已接受)
  • 从大量的产品评论中进行观点评价对象的自动抽取观点挖掘研究的重要课题,然而目前观点评价对象抽取结果只提供少量信息,因此提出一种基于上下文相关的双向自举方法同时获取产品名称和产品属性。该方法利用初始种子...
  • 近日项目要求基于爬取的影视评论信息,抽取影视的关键字信息。考虑到影视评论数据量较大,因此采用Spark处理框架。关键词提取的处理主要包含分词+算法抽取两部分。目前分词工具包较为主流的,包括哈工大的LTP以及...
  • 提出了一种评价对象特征抽取与聚类方法,其基本思想是:首先运用Apriori算法和剪枝方法从客户评论中抽取评论对象特征集;然后,以特征之间的基于Hownet的词语相似度和特征与观点共现的信息作为聚类依据,对特征进行...

空空如也

空空如也

1 2 3 4 5 ... 20
收藏数 15,729
精华内容 6,291
关键字:

评论观点抽取