解释以下代码含义:package com.highcom.spark import org.apache.lucene.analysis.TokenStream import…
- User
解释以下代码含义:package com.highcom.spark
import org.apache.lucene.analysis.TokenStream import org.apache.lucene.analysis.tokenattributes.CharTermAttribute import org.apache.spark.mllib.feature.{HashingTF, IDF, IDFModel} import org.apache.spark.{SparkConf, SparkContext} import org.wltea.analyzer.lucene.IKAnalyzer import org.apache.spark.mllib.clustering.KMeans import org.apache.spark.mllib.linalg.Vector import org.apache.spark.rdd.RDD import org.apache.spark.mllib.clustering.KMeansModel import java.sql.{Connection, DriverManager, PreparedStatement}
import scala.collection.mutable.{ArrayBuffer, ListBuffer} import scala.util.control.Breaks._
object avgSpark { //定义连接对象 var conn:Connection = null
//定义连接数据库的方法 def dbCon():Unit = { val url = "jdbc:mysql:///aolin?useUnicode=true&characterEncoding=UTF8&serverTimezone=UTC" val driver = "com.mysql.cj.jdbc.Driver" val username = "root" val password = "root" try{ Class.forName(driver) conn = DriverManager.getConnection(url,username,password) }catch { case e:Exception =>e.printStackTrace() } }
//定义处理完后的数据 进入插入功能 def avdb(uid:String,keywords:String,typeId:Int):Unit= {
val statement = conn.createStatement() val sql = "insert into avdata(userId,keywords,type) values (?,?,?)" val pstmt:PreparedStatement = conn.prepareStatement(sql) pstmt.setString(1,uid) pstmt.setString(2,keywords) pstmt.setInt(1,typeId) pstmt.execute() println("插入数据完成")} //主函数 def main(args: Array[String]): Unit = { //调用数据库连接函数 dbCon() //创建spark应用 val conf = new SparkConf().setAppName("Simple Application").setMaster("local") val sc = new SparkContext(conf) val rdd = sc.textFile("D:\ideaworkspace\sparkworkspace\mySparkProject\data\advdata1_small.txt") rdd.collect.foreach(println)
} }
- Assistant
该代码定义了一个名为avgSpark的Scala对象,该对象包含了连接数据库的方法dbCon()和将处理完的数据插入数据库的方法avdb(uid:String,keywords:String,typeId:Int),以及主函数main(args: Array[String])。
在主函数中,首先调用了dbCon()方法连接数据库,然后创建了一个SparkConf对象和一个SparkContext对象,使用sc.textFile()方法读取了一个名为"advdata1_small.txt"的文本文件,并将其转化为RDD对象。最后使用rdd.collect().foreach(println)方法将RDD对象中的所有元素逐个打印输出。
该代码还引入了一些Spark和Lucene等库。具体包括:
- org.apache.lucene.analysis:Lucene分词库,用于对文本数据进行分词处理。
- org.apache.spark.mllib.feature.HashingTF:在Spark中实现的HashingTF类,用于将文本数据转化为词频向量。
- org.apache.spark.mllib.feature.IDF:在Spark中实现的IDF类,用于计算逆文本频率,进一步转化文本数据。
- org.apache.spark.mllib.clustering:在Spark中实现的聚类库,用于对文本数据进行聚类分析。
- org.wltea.analyzer.lucene.IKAnalyzer:Lucene结巴中文分词器,提高了中文分词的准确度。
- java.sql:Java数据库连接库,用于连接和操作MySQL等数据库。
- User
解释以下代码含义:package com.highcom.spark
import org.apache.lucene.analysis.TokenStream import org.apache.lucene.analysis.tokenattributes.CharTermAttribute import org.apache.spark.mllib.feature.{HashingTF, IDF, IDFModel} import org.apache.spark.{SparkConf, SparkContext} import org.wltea.analyzer.lucene.IKAnalyzer import org.apache.spark.mllib.clustering.KMeans import org.apache.spark.mllib.linalg.Vector import org.apache.spark.rdd.RDD import org.apache.spark.mllib.clustering.KMeansModel import java.sql.{Connection, DriverManager, PreparedStatement}
import scala.collection.mutable.{ArrayBuffer, ListBuffer} import scala.util.control.Breaks._
object avgSpark { //定义连接对象 var conn:Connection = null
//定义连接数据库的方法 def dbCon():Unit = { val url = "jdbc:mysql:///aolin?useUnicode=true&characterEncoding=UTF8&serverTimezone=UTC" val driver = "com.mysql.cj.jdbc.Driver" val username = "root" val password = "root" try{ Class.forName(driver) conn = DriverManager.getConnection(url,username,password) }catch { case e:Exception =>e.printStackTrace() } }
//定义处理完后的数据 进入插入功能 def avdb(uid: String, keywords: String, typeId: Int): Unit = { val statement = conn.createStatement // 执行插入操作 t_avdata val sql1 = "insert into avdata(userid,keywords,type) values(?,?,?)" val ps1: PreparedStatement = conn.prepareStatement(sql1) ps1.setString(1, uid) ps1.setString(2, keywords) ps1.setInt(3, typeId) ps1.execute(); println("插入数据完成") } //主函数 def main(args: Array[String]): Unit = { //调用数据库连接函数 dbCon() //avdb("x1001","疫情",8) //创建spark应用 val conf = new SparkConf().setAppName("Simple Application").setMaster("local") val sc = new SparkContext(conf) val rdd = sc.textFile("D:\ideaworkspace\sparkworkspace\mySparkProject\data\advdata1_small.txt") //rdd.collect.foreach(println) val value = rdd.mapPartitions(iterator => { val list = new ListBuffer[(String, ArrayBuffer[String])] while (iterator.hasNext) { val line = iterator.next() val textArr = line.split("\t") breakable { if (textArr.length != 2) break val id = textArr(0) val text = textArr(1)
val analyzer = new IKAnalyzer(true) val ts: TokenStream = analyzer.tokenStream("", text) //得到相应词汇的内容 val term: CharTermAttribute = ts.getAttribute(classOf[CharTermAttribute]) //重置分词器,使得tokenstream可以重新返回各个分词 ts.reset() val arr = new ArrayBuffer[String] //遍历分词数据 while (ts.incrementToken()) { arr.+=(term.toString()) } list.append((id, arr)) analyzer.close() } } list.iterator }) var wordRDD = value wordRDD = wordRDD.cache()} }
- Assistant
该代码与前一个代码相似,定义了一个名为avgSpark的Scala对象,包含了连接数据库的方法dbCon()和将处理完的数据插入数据库的方法avdb(uid:String,keywords:String,typeId:Int),以及主函数main(args: Array[String])。
在主函数中,首先调用了dbCon()方法连接数据库,然后创建了一个SparkConf对象和一个SparkContext对象,使用sc.textFile()方法读取了一个名为"advdata1_small.txt"的文本文件,并将其转化为RDD对象。接着,使用rdd.mapPartitions()方法对RDD进行操作,这个方法将RDD中每个分区都映射成一个迭代器,对每个分区的数据进行处理。在这里,使用了Lucene的IKAnalyzer中文分词器对每个文本数据进行分词处理,并得到每个文本数据中的词组成的词汇表,以(id,词汇表)的形式保存到ListBuffer中。最后,将处理完的数据保存到wordRDD中,并使用wordRDD.cache()方法缓存RDD中的数据。
该代码还引入了一些Spark和Lucene等库。具体包括:
- org.apache.lucene.analysis:Lucene分词库,用于对文本数据进行分词处理。
- org.apache.spark.mllib.feature.HashingTF:在Spark中实现的HashingTF类,用于将文本数据转化为词频向量。
- org.apache.spark.mllib.feature.IDF:在Spark中实现的IDF类,用于计算逆文本频率,进一步转化文本数据。
- org.apache.spark.mllib.clustering:在Spark中实现的聚类库,用于对文本数据进行聚类分析。
- org.wltea.analyzer.lucene.IKAnalyzer:Lucene结巴中文分词器,提高了中文分词的准确度。
- java.sql:Java数据库连接库,用于连接和操作MySQL等数据库。
- User
解释以下代码含义:package com.highcom.spark
import org.apache.lucene.analysis.TokenStream import org.apache.lucene.analysis.tokenattributes.CharTermAttribute import org.apache.spark.mllib.feature.{HashingTF, IDF, IDFModel} import org.apache.spark.{SparkConf, SparkContext} import org.wltea.analyzer.lucene.IKAnalyzer import org.apache.spark.mllib.clustering.KMeans import org.apache.spark.mllib.linalg.Vector import org.apache.spark.rdd.RDD import org.apache.spark.mllib.clustering.KMeansModel import java.sql.{Connection, DriverManager, PreparedStatement}
import scala.collection.mutable.{ArrayBuffer, ListBuffer} import scala.util.control.Breaks._
object avSpark { //初始化数据连接 var connection: Connection =null def dbcon(): Unit ={ val url = "jdbc:mysql:///lindashixi?useUnicode=true&characterEncoding=UTF8&serverTimezone=UTC" //驱动名称 val driver = "com.mysql.cj.jdbc.Driver" //用户名 val username = "root" //密码 val password = "root"
try { //注册Driver Class.forName(driver) //得到连接 connection = DriverManager.getConnection(url, username, password) } catch { case e: Exception => e.printStackTrace }}
def avdb(uid: String, keywords: String, typeId: Int): Unit = { val statement = connection.createStatement // 执行插入操作 t_avdata val sql1 = "insert into t_avdata_copy(userid,keywords,type) values(?,?,?)" val ps1: PreparedStatement = connection.prepareStatement(sql1) ps1.setString(1, uid) ps1.setString(2, keywords) ps1.setInt(3, typeId) ps1.execute(); println("插入数据完成") }
def main(args: Array[String]): Unit = { dbcon() val conf = new SparkConf().setAppName("BlogKMeans").setMaster("local[*]") val sc = new SparkContext(conf) val rdd = sc.textFile("D:\ideaworkspace\sparkworkspace\sparkpro1\data\advdata1.txt") val value = rdd.mapPartitions(iterator => { val list = new ListBuffer[(String, ArrayBuffer[String])] while (iterator.hasNext) { val line = iterator.next() val textArr = line.split("\t") breakable { if (textArr.length != 2) break val id = textArr(0) val text = textArr(1)
val analyzer = new IKAnalyzer(true) val ts: TokenStream = analyzer.tokenStream("", text) //得到相应词汇的内容 val term: CharTermAttribute = ts.getAttribute(classOf[CharTermAttribute]) //重置分词器,使得tokenstream可以重新返回各个分词 ts.reset() val arr = new ArrayBuffer[String] //遍历分词数据 while (ts.incrementToken()) { arr.+=(term.toString()) } list.append((id, arr)) analyzer.close() } } list.iterator }) var wordRDD = value wordRDD = wordRDD.cache() // wordRDD.foreach(println) //TF-IDF val hashingTF: HashingTF = new HashingTF(1000) val tfRDD = wordRDD.map(x => { (x._1, hashingTF.transform(x._2)) }) // println("*********tfRDD***********************") //// tfRDD.foreach(println) val idf: IDFModel = new IDF().fit(tfRDD.map(_._2)) val tfIdfs: RDD[(String, Vector)] = tfRDD.mapValues(idf.transform(_)) // println("===========tfIdfs=================") // tfIdfs.foreach(x=>{ // println("tfIdfs = "+x) // }) wordRDD = wordRDD.mapValues(buffer => { buffer.distinct.sortBy(item => { hashingTF.indexOf(item) }) }) // println("===========wordRDD=================") // wordRDD.foreach(print) //设置聚类个数 val kcluster = 20 val kmeans = new KMeans() kmeans.setK(kcluster) //使用的是kemans++算法来训练模型 "random"|"k-means||" kmeans.setInitializationMode("k-means||") //设置最大迭代次数 kmeans.setMaxIterations(100) //训练模型 val kmeansModel: KMeansModel = kmeans.run(tfIdfs.map(_._2)) // kmeansModel.save(sc, "d:/model001") //打印模型的20个中心点 println("*****==============================") println(kmeansModel.clusterCenters) val modelBroadcast = sc.broadcast(kmeansModel) val predicetionRDD = tfIdfs.mapValues(vetor => { val model = modelBroadcast.value model.predict(vetor) }) val tfIdfs2wordsRDD = tfIdfs.join(wordRDD) val result: RDD[(String, (Int, (Vector, ArrayBuffer[String])))] = predicetionRDD.join(tfIdfs2wordsRDD) // println("=====*****==============================") // result.foreach(println) var j = 0; for (j <- 0 to 19) { var wordslist = result .filter(x => x._2._1 == j) //0-19 .flatMap(line => { val avid = line._1 val tfIdfV: Vector = line._2._2._1 val words: ArrayBuffer[String] = line._2._2._2 val list = new ListBuffer[(Double, String, String)] for (i <- 0 until words.length) { //hashingTF.indexOf(words(i)) 当前单词在1000个向量中的位置 list.append((tfIdfV(hashingTF.indexOf(words(i))), words(i), avid)) } list }) val words = wordslist.sortBy(x => x._1, false) .map(_._2).filter(_.length() > 1).distinct() // .take(30).foreach(println) .take(30) // println("===========================") // words.foreach(println) // println("====len==",wordslist.count()) val idandword = wordslist.filter(x => words.contains(x._2)) println("**************************") idandword.foreach(println) //调取数据库函数 idandword.foreach(x => { avdb(x._3, x._2, j) }) } sc.stop() connection.close}
}
- Assistant
该代码与前两个代码相似,定义了一个名为avSpark的Scala对象,包含了连接数据库的方法dbCon()和将处理完的数据插入数据库的方法avdb(uid:String,keywords:String,typeId:Int),以及主函数main(args: Array[String])。
在主函数中,首先调用了dbCon()方法连接数据库,然后创建了一个SparkConf对象和一个SparkContext对象,使用sc.textFile()方法读取了一个名为"advdata1.txt"的文本文件,并将其转化为RDD对象。接着,使用rdd.mapPartitions()方法对RDD进行操作,这个方法将RDD中每个分区都映射成一个迭代器,对每个分区的数据进行处理。在这里,使用了Lucene的IKAnalyzer中文分词器对每个文本数据进行分词处理,并得到每个文本数据中的词组成的词汇表,以(id,词汇表)的形式保存到ListBuffer中。最后,将处理完的数据保存到wordRDD中,并使用wordRDD.cache()方法缓存RDD中的数据。
接着,使用HashingTF和IDF对wordRDD进行TF-IDF的计算,得到tfIdfs。之后,将wordRDD中每个文本数据中的词按照词语出现的位置进行去重和排序,得到去重且排序后的文本词表。随后,使用KMeans聚类算法对tfIdfs进行聚类分析,得到聚类模型kmeansModel和聚类中心。将聚类模型广播给各个节点,对tfIdfs进行预测,得到predicetionRDD。将tfIdfs和wordRDD进行联合,得到tfIdfs2wordsRDD。使用联合后的数据和聚类模型对数据进行处理,得到结果result。从中提取出每个聚类中心对应的文本数据中的前30个