机器学习语言及朴素贝叶斯算法 -

三年计划

浏览: 43201 次
性别:
来自: 广州

最近访客更多访客>>

yangxue1201

whskl

ssydxa219

taoyongming

博主相关

博客

微博

相册

留言

关于我

文章分类

社区版块

存档分类

机器学习语言及朴素贝叶斯算法

博客分类：

大数据

最为广泛的两种分类模型是决策树模型(Decision Tree Model)和朴素贝叶斯模型（Naive Bayesian Model，NBM）。

朴素贝叶斯分类器基于一个简单的假定：给定目标值时属性之间相互条件独立。

通过以上定理和“朴素”的假定，我们知道：

P( Category | Document) = P ( Document | Category ) * P( Category) / P(Document)

概念定义可以参考百度百科：http://baike.baidu.com/link?url=wJ7TTJQLS6WN5K_6NxLpwQKHabkZQGa8hwCqdwnUmWHuQTfS5Wc7hWqkfkvhmeWRxMiI6ojo9wO4PArJeRkncmNBPD6h16ntgUJfcldsgqfbUA1kKqwy7yX6e9ItcEVGH83Twbc_pld97KWCGePhf_

我这里主要是讲解一个应用朴素贝叶斯算法实际项目案例：简历推荐

案例情景：各大上市公司成立以来肯定有很多面试的简历投递进来、也包括网上可以抓取到的简历，那么如何从海量简历中获取到hr对应需求度匹配度高的简历呢？据我所知目前还是人工查看简历阶段，就是招聘专员按照自己的需求通过各种渠道查看简历，这样做费时费力，那么有没有什么解决办法呢，下面就是我要说的方式：采用大数据进行简历存储、通过朴素贝叶斯算法进行机器分类学习、然后进行定点推送。

主要计算逻辑：1.将海量简历通过建模后存入到hbase库中 2.建立机器学习样本建立（这个肯定需要人工进行认定） 3.通过朴素贝叶斯算法对海量数据基于学习样本进行分类和计算匹配度 4.存储计算结果 5.推送给hr

首先我这里就贴出系统的图片，供大家理解这个过程：

1.样本分类（定义好样本的分类、比如java、。net等）

2.人工样本认定（供机器学习）
对于hr的需求进行分类样本进行人工认定

人工认定需求到分类下：

人工认定后，点击样本分类就可以看到分类下面的具体需求：

3.特殊逻辑处理

这个我就不便截图了，因为可能涉及到保密。主要用途就是定义好相关的情形，比如需要工作经验五年以上、本科毕业等要求，可以是或、与的逻辑等。

4.计算（朴素贝叶斯算法加机器自我学习和完善样本的过程）

此过程在此文后续我会贴出相关代码，这里就简单带过

5.结果存储和推送

通过以上的过程基本也说清楚了全部的逻辑了，下面我们重点来说说第4点的计算。这里我直接贴出部分相关代码，就不做过多讲解了，因为我这里是拿的一个实际项目来说的。因为我这里采用的scala和java混搭的写法，看的时候可能比较费劲。

计算入口，主要是定义了一个scala的main方法入口，进行测试用，实际调用代码这里不贴出来了

package main.scala

import java.text.SimpleDateFormat
import java.util
import java.util.Date

import main.java.BayesClassifier
import org.apache.hadoop.hbase.client.{Put, HTable}
import org.apache.hadoop.hbase.util.Bytes
import org.apache.spark.{SparkConf, SparkContext}

/**
 * Created by 峰 on 2016/11/9.
 */
object SparkTest {
  def main(args: Array[String]) {
    val sparkConf = new SparkConf().setMaster("local").setAppName("HBaseTest").set("spark.serializer", "org.apache.spark.serializer.KryoSerializer");
val sc = new SparkContext(sparkConf)
    val sim_time=new SimpleDateFormat("yyyy-MM-dd hh:mm");
val sim_date=new SimpleDateFormat("yyyy/MM/dd");
var hbasecommon=new HBaseCommon
    //将ty_hr_job_info数据插入到
var hbase4java=new Hbase4Java
    hbase4java.insertTy_hr_job_info(hbasecommon.getConfiguration())
    //开始计算
var infolist=hbasecommon.getTableInfo("ty_hr_job_info",sc)
    val classifier: BayesClassifier = new BayesClassifier
    classifier.saveResult(sim_time.format(new Date())+"_jeffTest",infolist)
  }
}

初始化一些配置和数据读取

package main.scala

import java.io.IOException
import java.util
import scala.collection.mutable.{ListBuffer, LinkedHashMap}
import org.apache.hadoop.hbase.util.Bytes
import org.apache.hadoop.hbase.{HColumnDescriptor, HTableDescriptor, KeyValue, HBaseConfiguration}
import org.apache.hadoop.mapreduce.Job
import org.apache.spark.SparkContext
import org.apache.hadoop.conf.Configuration
import org.apache.hadoop.hbase.client._
import org.apache.hadoop.hbase.io.ImmutableBytesWritable
import org.apache.hadoop.hbase.mapreduce.{TableInputFormat, TableOutputFormat}

class HBaseCommon {
  /**
   * 获取初始化配置
   */
def getConfiguration(): Configuration = {
    val map: LinkedHashMap[String, String] = new LinkedHashMap[String, String]();
val HBASE_CONFIG = new Configuration();
HBASE_CONFIG.set("hbase.zookeeper.quorum", map.getOrElse("zookeeper_quorum", "host1,host2,host3"));
HBASE_CONFIG.set("hbase.zookeeper.property.clientPort", map.getOrElse("zookeeper_port", "2181"));
val configuration = HBaseConfiguration.create(HBASE_CONFIG);
configuration;
}

  /**
   * 获取作业信息
   */
def getJob(tableName: String): Job = {
    val configuration = this.getConfiguration();
configuration.set(TableOutputFormat.OUTPUT_TABLE, tableName);
var job = new Job(configuration)
    job.setOutputKeyClass(classOf[ImmutableBytesWritable])
    job.setOutputValueClass(classOf[Result])
    job.setOutputFormatClass(classOf[TableOutputFormat[ImmutableBytesWritable]])
    job;
}


  /**
   * 读取hbase某个表中的全部内容
   */
def getTableInfo(tableName: String, sc: SparkContext): util.ArrayList[String] = {
    val configuration = this.getConfiguration()
    configuration.set(TableInputFormat.INPUT_TABLE, tableName)

    val hBaseRDD = sc.newAPIHadoopRDD(configuration, classOf[TableInputFormat],
classOf[org.apache.hadoop.hbase.io.ImmutableBytesWritable],
classOf[org.apache.hadoop.hbase.client.Result])

    var strinfo = ""
val count = hBaseRDD.count()
    println("HBase RDD Count:" + count)
    hBaseRDD.cache()

    val table = new HTable(configuration, tableName);
val g = new Get("row1".getBytes)
    val result = table.get(g)
    val value = Bytes.toString(result.getValue("basic".getBytes, "name".getBytes))

    hBaseRDD.cache()
    println("------------------------scan----------")
    val res = hBaseRDD.take(count.toInt)
    val reslist = new util.ArrayList[String]()
    for (j <- 1 until count.toInt) {
      var rs = res(j - 1)._2
      var kvs = rs.raw
      for (kv <- kvs) {
        reslist.add(new String(kv.getRow())+new String(kv.getValue()))
      }
    }
    reslist
  }
}

下面是hbase数据库的相关操作，有写、查等逻辑

package main.scala;
import main.java.jdbc.Jdbc;
import org.apache.hadoop.conf.Configuration;
import org.apache.hadoop.hbase.*;
import org.apache.hadoop.hbase.client.*;
import org.apache.hadoop.hbase.util.Bytes;
import java.io.IOException;
import java.sql.ResultSet;
import java.util.ArrayList;
import java.util.List;
/**
 * Created by 峰 on 2015/9/1.
 */
public class Hbase4Java {

    /**
     * 将ty_hr_job_info表的数据插入到Hbase库中
     */
public void insertTy_hr_job_info(Configuration configuration){
        try {
            HBaseAdmin admin = new HBaseAdmin(configuration);
String sql="select * from ty_hr_job_info where  Status in(6,7,8) and ProjectExperience!='' and WorkExperience!=''  and  DateOfSubmission> DATE_SUB(CURDATE(), INTERVAL 6 MONTH )";
System.out.println("语句为：" + sql);
System.out.println("判断hbase库中是否已经存在 ty_hr_job_info 表");
            if (admin.tableExists("ty_hr_job_info")) {
                System.out.println("表已经存在");
admin.disableTable("ty_hr_job_info");
admin.deleteTable("ty_hr_job_info");
}
            System.out.println("创建 ty_hr_job_info 表");
HTableDescriptor tableDescriptor = new HTableDescriptor("ty_hr_job_info");
tableDescriptor.addFamily(new HColumnDescriptor("cf"));
admin.createTable(tableDescriptor);
System.out.println("查询关系型数据库表 ty_hr_job_info 的数据");
Jdbc jdbc = new Jdbc();
ResultSet resultSet = jdbc.executeQuery(sql);
System.out.println("插入数据到hbase库的ty_hr_job_info表中");
StringBuffer rowkey = new StringBuffer();
StringBuffer rowvalue = new StringBuffer();
HTable table = new HTable(configuration, "ty_hr_job_info");
Long starttime = System.currentTimeMillis();
            int count = 0;
            while (resultSet.next()) {
                //指定rowkey
rowkey.append(resultSet.getString("id") == null ? "" : resultSet.getString("id"))
                        .append("_").append(resultSet.getString("fullname") == null ? "" : resultSet.getString("fullname")).append("_");
rowkey.append(resultSet.getString("WorkingLlife") == null ? "" : resultSet.getString("WorkingLlife"))
                        .append("_").append(resultSet.getString("DateOfSubmission") == null ? "" : resultSet.getString("DateOfSubmission"));
//指定rowvalue
rowvalue.append(resultSet.getString("currentResidence") == null ? "" : resultSet.getString("currentResidence")).
                        append(resultSet.getString("ITSkill") == null ? "" : resultSet.getString("ITSkill")).
                        append(resultSet.getString("projectexperience") == null ? "" : resultSet.getString("projectexperience"));
//开始保存
Put put = new Put(rowkey.toString().getBytes());
put.add(Bytes.toBytes("cf"), Bytes.toBytes("content"), rowvalue.toString().getBytes());
table.put(put);
//清空
rowkey.setLength(0);
rowvalue.setLength(0);
//计数
count++;
}
            System.out.println("数据插入完成，此次共插入" + count + "条记录，耗时" + (System.currentTimeMillis() - starttime) + "毫秒");
}catch(Exception e){
            e.printStackTrace();
}
    }

    /**
     * 创建表操作
     *
     * @throws java.io.IOException
     */
public void createTable(String tablename, String[] cfs, Configuration configuration) throws IOException {
        HBaseAdmin admin = new HBaseAdmin(configuration);
        if (admin.tableExists(tablename)) {
            System.out.println("表已经存在！");
} else {
            HTableDescriptor tableDesc = new HTableDescriptor(tablename);
            for (int i = 0; i < cfs.length; i++) {
                tableDesc.addFamily(new HColumnDescriptor(cfs[i]));
}
            admin.createTable(tableDesc);
System.out.println(" 表创建成功！");
}
    }

    /**
     * 删除表操作
     *
     * @param tablename
* @throws java.io.IOException
     */
public void deleteTable(String tablename, Configuration configuration) throws IOException {
        try {
            HBaseAdmin admin = new HBaseAdmin(configuration);
            if (!admin.tableExists(tablename)) {
                System.out.println("表不存在, 无需进行删除操作！");
} else {
                admin.disableTable(tablename);
admin.deleteTable(tablename);
System.out.println(" 表删除成功！");
}
        } catch (MasterNotRunningException e) {
            e.printStackTrace();
} catch (ZooKeeperConnectionException e) {
            e.printStackTrace();
}
    }

    public void insertRow(Configuration configuration) throws Exception {
        HTable table = new HTable(configuration, "test");
Put put = new Put(Bytes.toBytes("row3"));
put.add(Bytes.toBytes("cf"), Bytes.toBytes("444"), Bytes.toBytes("value444"));
table.put(put);
}

    /**
     * 插入一行记录
     *
     * @param tablename
* @param cfs
*/
public void writeRow(String tablename, String[] cfs, Configuration configuration) {
        try {
            HTable table = new HTable(configuration, tablename);
Put put = new Put(Bytes.toBytes("rows3"));
            for (int j = 0; j < cfs.length; j++) {
                put.add(Bytes.toBytes(cfs[j]),
Bytes.toBytes(cfs[j] + String.valueOf(1)),
Bytes.toBytes(cfs[j] + "value"));
table.put(put);
}
            System.out.println("写入成功！");
} catch (IOException e) {
            e.printStackTrace();
}
    }

    //写多条记录
public void writeMultRow(String tablename, String[][] cfs, Configuration configuration) {
        try {
            HTable table = new HTable(configuration, tablename);
List<Put> lists = new ArrayList<Put>();
            for (int i = 0; i < cfs.length; i++) {
                Put put = new Put(Bytes.toBytes(cfs[i][0]));
put.add(Bytes.toBytes(cfs[i][1]),
Bytes.toBytes(cfs[i][2]),
Bytes.toBytes(cfs[i][3]));
lists.add(put);
}
            table.put(lists);
System.out.println("写入成功！");
} catch (IOException e) {
            e.printStackTrace();
}
    }

    /**
     * 删除一行记录
     *
     * @param tablename
* @param rowkey
* @throws java.io.IOException
     */
public void deleteRow(String tablename, String rowkey, Configuration configuration) throws IOException {
        HTable table = new HTable(configuration, tablename);
List<Delete> list = new ArrayList<Delete>();
Delete d1 = new Delete(rowkey.getBytes());
list.add(d1);
table.delete(list);
System.out.println("删除行成功！");
}

    /**
     * 查找一行记录
     *
     * @param tablename
* @param rowKey
*/
public static void selectRow(String tablename, String rowKey, Configuration configuration)
            throws IOException {
        HTable table = new HTable(configuration, tablename);
Get g = new Get(rowKey.getBytes());
Result rs = table.get(g);
        for (KeyValue kv : rs.raw()) {
            System.out.print(new String(kv.getRow()) + "  ");
System.out.print(new String(kv.getFamily()) + ":");
System.out.print(new String(kv.getQualifier()) + "  ");
System.out.print(kv.getTimestamp() + "  ");
System.out.println(new String(kv.getValue()));
}
    }

    /**
     * 查询表中所有行
     *
     * @param tablename
*/
public void scaner(String tablename, Configuration configuration) {
        try {
            HTable table = new HTable(configuration, tablename);
Scan s = new Scan();
ResultScanner rs = table.getScanner(s);
            for (Result r : rs) {
                KeyValue[] kv = r.raw();
                for (int i = 0; i < kv.length; i++) {
                    System.out.print(new String(kv[i].getRow()) + "  ");
System.out.print(new String(kv[i].getFamily()) + ":");
System.out.print(new String(kv[i].getQualifier()) + "  ");
System.out.print(kv[i].getTimestamp() + "  ");
System.out.println(new String(kv[i].getValue()));
}
            }
        } catch (IOException e) {
            e.printStackTrace();
}
    }
}

下面是计算逻辑核心代码的部分逻辑，以及保存结果信息代码。

package main.java;
import main.java.jdbc.Jdbc;
import main.java.pojo.Pattern_classific;
import java.sql.ResultSet;
import java.sql.SQLException;
import java.text.SimpleDateFormat;
import java.util.*;
/**
 * 朴素贝叶斯分类器
 */
public class BayesClassifier {
    private TrainingDataManager tdm;//训练集管理器
private static double zoomFactor = 10.0f;
    private static int fix=5;
    private SimpleDateFormat simpleDateFormat=new SimpleDateFormat("yyyy/MM/dd");
/**
     * 默认的构造器，初始化训练集
     */
public BayesClassifier() {
        tdm = new TrainingDataManager();
}

    /**
     * 计算给定的文本属性向量X在给定的分类Cj中的类条件概率
     * <code>ClassConditionalProbability</code>连乘值
     *
     * @param X  给定的文本属性向量
     * @param Cj 给定的类别
     * @return 分类条件概率连乘值，即<br>
     */
float calcProd(String[] X, String Cj) {
        float ret =0.0F;
// 类条件概率连乘
for (int i = 0; i < X.length; i++) {
            //因为结果过小，因此在连乘之前放大10倍，这对最终结果并无影响，因为我们只是比较概率大小而已
ret += ClassConditionalProbability.calculatePxc(X[i], Cj) * zoomFactor;
}
        // 再乘以先验概率，因为样本为一个样本为一个分类，所以没必要
//        ret *= PriorProbability.calculatePc(Cj);
return ret;
}

    int calcProdInt(String[] X, String Cj) {
        int ret =0;
// 类条件概率连乘
for (int i = 0; i < X.length; i++) {
            if (Cj.contains(X[i])) {
                ret++;
}
        }
        return ret;
}

    /**
     * 去掉停用词
     *
     * @param oldWords 给定的文本
     * @return 去停用词后结果
     */
public String[] DropStopWords(String[] oldWords) {
        Vector<String> v1 = new Vector<String>();
        for (int i = 0; i < oldWords.length; ++i) {
            if (StopWordsHandler.IsStopWord(oldWords[i]) == false) {//不是停用词
v1.add(oldWords[i]);
}
        }
        String[] newWords = new String[v1.size()];
v1.toArray(newWords);
        return newWords;
}

    /**
     * 对给定的文本进行分类
     *
     * @param text 给定的文本
     * @return 分类结果
     */
@SuppressWarnings("unchecked")
    public ClassifyResult classify(String text) {
        String[] terms = null;
terms = ChineseSpliter.split(text, " ").split(" ");//中文分词处理(分词后结果可能还包含有停用词）
terms = DropStopWords(terms);//去掉停用词，以免影响分类
float probility = 0.00f;
List<ClassifyResult> crs = new ArrayList<ClassifyResult>();//分类结果
for (Pattern_classific pattern_classifics:TrainingDataManager.pattern_classifics) {
            String Ci =(pattern_classifics.getGongzuodidian()+pattern_classifics.getLeisihangye()+pattern_classifics.getMianshiguanzhudian()+pattern_classifics.getGangweizhize()+pattern_classifics.getXiangmujingyan());//第i个分类
probility = calcProd(terms, Ci);//计算给定的文本属性向量terms在给定的分类Ci中的分类条件概率
            //保存分类结果
ClassifyResult cr = new ClassifyResult();
cr.classification = Ci;//分类
cr.pattern_classific=pattern_classifics;
cr.probility = probility;//关键字在分类的条件概率
crs.add(cr);
}
        //对最后概率结果进行排序
Collections.sort(crs, new Comparator() {
            public int compare(final Object o1, final Object o2) {
                final ClassifyResult m1 = (ClassifyResult) o1;
                final ClassifyResult m2 = (ClassifyResult) o2;
                final double ret = m1.probility - m2.probility;
                if (ret < 0) {
                    return 1;
} else if(ret>0) {
                    return -1;
}else{
                    return 0;
}
            }
        });
//如果某个需求匹配成都的简历很高，超过某个阈值后就不要在推荐简历给此需求了
ClassifyResult classifyResult=null;
        for(int i=0;i<crs.size();i++){
            if(TrainingDataManager.listMap.get(crs.get(i).pattern_classific.getId()).size()<fix){
                classifyResult=crs.get(i);
                break;
}
        }
        //返回概率最大的分类
return classifyResult;
}

    public ClassifyResult classifyNew(String text) {
        Levenshtein lt = new Levenshtein();
List<ClassifyResult> crs = new ArrayList<ClassifyResult>();//分类结果
StringBuffer stringBuffer=null;
        for (Pattern_classific pattern_classifics:TrainingDataManager.pattern_classifics) {
            stringBuffer=new StringBuffer();
stringBuffer.append(pattern_classifics.getGongsijieshao()).append(pattern_classifics.getLeisihangye()).append(pattern_classifics.getTuanduijieshao()).append(pattern_classifics.getMianshiguanzhudian()).append(pattern_classifics.getGangweizhize()).append(pattern_classifics.getXiangmujingyan());//第i个分类
            //保存分类结果
ClassifyResult cr = new ClassifyResult();
cr.classification = stringBuffer.toString();//分类
cr.pattern_classific=pattern_classifics;
cr.probility =lt.getSimilarityRatio(text, stringBuffer.toString());//计算给定的文本属性向量terms在给定的分类Ci中的分类条件概率
crs.add(cr);
}
        //对最后概率结果进行排序
Collections.sort(crs, new Comparator() {
            public int compare(final Object o1, final Object o2) {
                final ClassifyResult m1 = (ClassifyResult) o1;
                final ClassifyResult m2 = (ClassifyResult) o2;
                final double ret = m1.probility - m2.probility;
                if (ret < 0) {
                    return 1;
} else if(ret>0) {
                    return -1;
}else{
                    return 0;
}
            }
        });
//如果某个需求匹配成都的简历很高，超过某个阈值后就不要在推荐简历给此需求了
ClassifyResult classifyResult=null;
        for(int i=0;i<crs.size();i++){
            if(TrainingDataManager.listMap.get(crs.get(i).pattern_classific.getId()).size()<fix){
                classifyResult=crs.get(i);
                break;
}
        }
        //返回概率最大的分类
return classifyResult;
}


    //放回总数和各分类的匹配总数
public Map<Integer,List<String>> classifys(List<String> texts){
        System.out.println("开始运行推荐算法");
System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");
Long currenttime=System.currentTimeMillis();
        int count=texts.size();
        for(int i=0;i<count;i++){
            System.out.println("共有"+count+"条记录，已经计算到了第"+i+"条");
ClassifyResult rs=classify(texts.get(i));
//将分类下所有简历进行分类存放
if(rs!=null)TrainingDataManager.listMap.get(rs.pattern_classific.getId()).add(texts.get(i));
}
        System.out.println("计算完成，共用时"+(System.currentTimeMillis()-currenttime)+"毫秒");
        return TrainingDataManager.listMap;
}

    public Map<Integer,List<String>> classifysNew(List<String> texts){
        System.out.println("开始运行推荐算法");
System.setProperty("java.util.Arrays.useLegacyMergeSort", "true");
Long currenttime=System.currentTimeMillis();
//将需求作为比较样本
int index=0;
        for (Pattern_classific pattern_classifics:TrainingDataManager.pattern_classifics) {
            index++;
System.out.println("共有"+TrainingDataManager.pattern_classifics.size()+"条需求需要匹配简历，已经计算到了第"+index+"条");
List<ClassifyResult> crs = new ArrayList<ClassifyResult>();//分类结果
String Ci =(pattern_classifics.getGongzuodidian()+pattern_classifics.getLeisihangye()+pattern_classifics.getMianshiguanzhudian()+pattern_classifics.getGangweizhize()+pattern_classifics.getXiangmujingyan());//第i个分类
String[] terms = null;
terms = ChineseSpliter.split(Ci, " ").split(" ");//中文分词处理(分词后结果可能还包含有停用词）
terms = DropStopWords(terms);//去掉停用词，以免影响分类
int probility = 0;
            int count=texts.size();
            for(int i=0;i<count;i++){
                probility = calcProdInt(terms, texts.get(i));//计算给定的文本属性向量terms在给定的分类Ci中的分类条件概率
                //保存分类结果
ClassifyResult cr = new ClassifyResult();
cr.classification = texts.get(i);//分类
cr.probility = probility;//关键字在分类的条件概率
crs.add(cr);
}
            //对最后概率结果进行排序
Collections.sort(crs, new Comparator() {
                public int compare(final Object o1, final Object o2) {
                    final ClassifyResult m1 = (ClassifyResult) o1;
                    final ClassifyResult m2 = (ClassifyResult) o2;
                    final double ret = m1.probility - m2.probility;
                    if (ret < 0) {
                        return 1;
} else if(ret>0) {
                        return -1;
}else{
                        return 0;
}
                }
            });
            int matchnum=0;
//匹配需求的hr个数，并将匹配需求后的简历从推荐集合中移除
if(!"".equals(pattern_classifics.getZPZYUsername())&&pattern_classifics.getZPZYUsername()!=null){
                 matchnum=pattern_classifics.getZPZYUsername().split(",").length*3;
}else{
                matchnum=3;
}
            if(crs.size()<matchnum){
                matchnum=crs.size();
}
            for(int i=0;i<matchnum;i++){
                //将分类下所有简历进行分类存放
TrainingDataManager.listMap.get(pattern_classifics.getId()).add(crs.get(i).classification);
}
            //并将匹配需求后的简历从推荐集合中移除
//            if(texts.size()>matchnum){
//                texts=texts.subList(matchnum-1,texts.size());
//            }else{
//                System.out.println("所有简历匹配完毕");
//                break;
//            }
}
        System.out.println("计算完成，共用时"+(System.currentTimeMillis()-currenttime)+"毫秒");
        return TrainingDataManager.listMap;
}

    //保存结果到sqlserver中
public void saveResult(String flag,List<String> texts){
        Map<Integer,List<String>> result = classifys(texts);//进行分类
System.out.println("开始保存数据");
Long currenttime=System.currentTimeMillis();
Jdbc jdbc=new Jdbc();
String maxid_sql="select  MAX(id) maxid from cul_result_temp";
ResultSet rs = jdbc.executeQuery(maxid_sql);
Integer maxid=0;
        try {
            while (rs.next()) {
                maxid=rs.getInt("maxid");
}
        } catch (SQLException e) {
            e.printStackTrace();
}
        List<String> sqllist=new ArrayList<String>();
StringBuffer xqidsbf=new StringBuffer();
Date currentdate=new Date();
        for (Map.Entry<Integer, List<String>> entry :result.entrySet()) {
            maxid++;
            for(int i=0;i<entry.getValue().size();i++){
                if(i>=30)break;
xqidsbf.append(entry.getValue().get(i).split("_")[0]).append(",");
}
            sqllist.add("insert into cul_result_temp values("+maxid+","+entry.getKey()+",'"+xqidsbf.toString()+"','"+simpleDateFormat.format(currentdate)+"')");
xqidsbf=new StringBuffer();
}
        try {
            jdbc.batchUpdata(sqllist);
} catch (SQLException e) {
            e.printStackTrace();
}
        jdbc.close();
System.out.println("保存数据完成，共"+result.size()+"条数据被保存，用时"+(System.currentTimeMillis()-currenttime)+"毫秒");
}
}