`

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

 
阅读更多

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

朴素贝叶斯分类器基于一个简单的假定:给定目标值时属性之间相互条件独立。
通过以上定理和“朴素”的假定,我们知道:
P( Category | Document) = P ( Document | Category ) * P( Category) / P(Document)
我这里主要是讲解一个应用朴素贝叶斯算法实际项目案例:简历推荐
案例情景:各大上市公司成立以来肯定有很多面试的简历投递进来、也包括网上可以抓取到的简历,那么如何从海量简历中获取到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)+"毫秒");
}
}
说明:我这里只贴出了部分代码,只是用于交流用,直说问题解决的方式。
  • 大小: 55.1 KB
  • 大小: 67.3 KB
  • 大小: 67.8 KB
  • 大小: 68.9 KB
  • 大小: 61.6 KB
分享到:
评论

相关推荐

    基于朴素贝叶斯算法的垃圾邮件分类方法研究

    朴素贝叶斯算法是机器学习领域中的一种常用算法,近年来在垃圾邮件分类领域中的应用也逐渐增加。本研究论文详细介绍了基于朴素贝叶斯的垃圾邮件分类过程,并使用五折交叉验证法对分类结果进行了评估。 朴素贝叶斯...

    朴素贝叶斯算法学习笔记2

    朴素贝叶斯算法是一种经典的机器学习算法,它的应用范围非常广泛,涵盖了自然语言处理、信息检索、数据挖掘等多个领域。朴素贝叶斯算法的优点是简单、易于实现、计算效率高,且对数据的要求不高,但它也存在一些缺陷...

    使用决策树和朴素贝叶斯算法对Adult数据集分类的源码

    总之,理解和掌握决策树和朴素贝叶斯算法对于初学者和经验丰富的数据科学家都是至关重要的。它们不仅提供了对复杂数据的洞察力,也是许多更高级机器学习技术的基础。通过实际操作和应用,我们可以更好地理解和运用...

    《机器学习》算法实例-朴素贝叶斯算法-屏蔽社区留言板的侮辱言论

    《机器学习》算法实例-朴素贝叶斯算法-屏蔽社区留言板的侮辱言论 构建一个快速过滤器来屏蔽在线社区留言板上的侮辱性言论。如果某条留言使用了负面或者侮辱性的语言,那么就将该留言标识为内容不当。对此问题建立两...

    bayes09_机器学习_机器学习的算法_朴素贝叶斯_

    在机器学习领域,朴素贝叶斯算法是一种广泛应用的分类方法,尤其在文本分类、垃圾邮件过滤和推荐系统中表现出色。这个压缩包“bayes09_机器学习_机器学习的算法_朴素贝叶斯_”可能包含了关于朴素贝叶斯算法的详细...

    基于朴素贝叶斯算法的文本分类程序_Python

    朴素贝叶斯算法是一种在机器学习领域广泛应用的概率型分类方法,尤其在文本分类中表现出色。这个程序是用Python语言实现的,它利用朴素贝叶斯理论对文本数据进行分类。下面将详细介绍朴素贝叶斯算法及其在Python中的...

    深度学习-情感分析系统(朴素贝叶斯算法的应用)

    在这个项目中,我们将讨论如何利用朴素贝叶斯算法来实现这一功能,尽管朴素贝叶斯在深度学习领域可能不那么常见,但它在文本分类任务上仍然表现出色。 朴素贝叶斯算法基于贝叶斯定理,是一种统计分类方法。它的...

    机器学习-朴素贝叶斯代码

    在本项目中,我们重点探讨如何使用Python编程语言来实现朴素贝叶斯算法,包括在文本分类任务如垃圾邮件过滤以及从个人广告中分析区域倾向的应用。 首先,我们要理解**贝叶斯定理**的基本概念。贝叶斯定理描述了在...

    朴素贝叶斯伪代码

    1. **朴素贝叶斯算法的基本思想**:基于贝叶斯定理及特征条件独立性假设进行分类。 2. **训练过程**:通过统计训练集中各类别出现的频率以及特征在不同类别中的条件概率,完成模型训练。 3. **后验概率计算**:利用...

    scala实现朴素贝叶斯算法

    朴素贝叶斯算法是一种基于概率论的分类方法,它的理论基础是贝叶斯定理,因此得名“贝叶斯”。在机器学习领域,朴素贝叶斯被广泛应用于文本分类、垃圾邮件过滤、情感分析等多个场景。Scala是一种强大的、静态类型的...

    人工智能-项目实践-朴素贝叶斯分类器-朴素贝叶斯文本分类器

    人工智能_项目实践_朴素贝叶斯分类器_朴素贝叶斯文本分类器 **数据:**搜狗文本分类语料库 **分类器:**朴素贝叶斯分类器 NBC(Naive Bayesian Classifier) **编程语言:**Python+jieba分词库+nltk+sklearn

    基于C#的朴素贝叶斯算法

    朴素贝叶斯算法是一种基于概率理论的分类方法,在机器学习领域广泛应用。它是通过计算每个类别的先验概率和特征条件概率来预测数据属于哪个类别。C#作为.NET框架下的主要编程语言,拥有丰富的数学和统计库,使得实现...

    Python机器学习机器学习十大算法英文文档朴素贝叶斯

    根据提供的文件信息,我们将重点介绍Python在机器学习领域的应用,以及朴素贝叶斯算法的相关知识。 首先,机器学习是人工智能的一个分支,它使计算机系统能够从数据中学习并改进性能,而无需通过明确的编程指令来...

    树型朴素贝叶斯算法java数据挖掘算法源码

    朴素贝叶斯算法,作为统计学和机器学习领域中的一种基础分类方法,因其简单高效而被广泛应用。树型朴素贝叶斯算法是朴素贝叶斯算法的一种变体,它以决策树的形式组织类别概率,从而更好地处理多类别的问题。在Java...

    17 机器学习案例——基于朴素贝叶斯算法的文本分类(垃圾邮件过滤)的数据集

    在本案例中,我们将深入探讨一个机器学习领域的经典应用——基于朴素贝叶斯算法的文本分类,特别是垃圾邮件过滤。这个数据集包含了两类文件:`noSpam` 和 `spam`,分别代表非垃圾邮件(正常邮件)和垃圾邮件。通过...

    朴素贝叶斯_朴素贝叶斯分类_

    总的来说,朴素贝叶斯分类是一种简单而有效的机器学习方法,尽管它基于简化的假设,但在许多实际问题中,尤其是在文本处理和自然语言处理领域,它表现出色。通过学习和理解朴素贝叶斯,我们可以更好地理解和应用这一...

    机器学习-上海大学-朴素贝叶斯

    通过本实验掌握朴素贝叶斯算法原理,熟悉朴素贝叶斯算法的简单应用。 【言论过滤器】 实验步骤:【言论过滤器】- 概述 以在线社区留言为例。为了不影响社区的发展,我们要屏蔽侮辱性的言论,所以要构建一个快速过滤...

    基于Paddlepaddle机器学习OCR和朴素贝叶斯分类算法的生鲜管理工具。.zip

    【标题】中的“基于Paddlepaddle机器学习OCR和朴素贝叶斯分类算法的生鲜管理工具”揭示了这个项目的核心技术及其应用场景。Paddlepaddle是中国百度公司开发的一个开源深度学习平台,它提供了丰富的机器学习模型和...

    朴素贝叶斯代码学习代码

    朴素贝叶斯算法是一种基于概率论的分类方法,它在机器学习领域被广泛应用于文本分类、垃圾邮件过滤等场景。这个代码示例是用于学习和理解朴素贝叶斯算法的实现过程,尤其对于初学者来说,是理解理论与实践之间关联的...

    机器学习算法合集(贝叶斯算法等等)

    在文本分类、垃圾邮件过滤等领域,朴素贝叶斯算法表现出色。 其次,神经网络算法是受生物神经元结构启发的一种模型,它是深度学习的基础。神经网络由大量的节点(神经元)和连接它们的边(权重)组成,通过学习输入...

Global site tag (gtag.js) - Google Analytics