我的余弦相似性，基于TFIDF结果

package com.winhong.datadig

import java.io.{File, PrintWriter}

import org.apache.log4j.{Level, Logger}

import org.apache.spark.mllib.feature.{IDF, HashingTF}

import org.apache.spark.mllib.linalg

import org.apache.spark.mllib.stat.Statistics

import org.apache.spark.rdd.RDD

import org.apache.spark.{SparkContext, SparkConf}

import breeze.numerics.{sqrt, pow}

import scala.math._

object CosineSimilarity {

   val keywordMap = scala.collection.mutable.Map(1 -> "name")

   def nonNegativeMod(x: Int, mod: Int): Int = {

      val rawMod = x % mod

      rawMod + (if (rawMod < 0) mod else 0)

   }

   def getRDDSecondStrs(nearCsWords:RDD[(String,Double)]):String = {

      var totalString = ""

      for(str <- nearCsWords.collect){

         totalString += str._2 +","

      }

      totalString

   }

   def main(args: Array[String]) {

      Logger.getLogger("org.apache.spark").setLevel(Level.WARN)

      Logger.getLogger("org.eclipse.jetty.server").setLevel(Level.OFF)

      val conf = new SparkConf

//      conf.setAppName("App").setMaster("local[5]")

      conf.setAppName("App").setMaster("local[5]")

      val sc = new SparkContext(conf)

      //      val hadoopRdd = sc.textFile("hdfs://localhost:9000/spark-in/1.txt")

      val hadoopRdd = sc.textFile("hdfs://localhost:9000/spark-in/aaa")

      // Load documents (one per line).

      val documents: RDD[Seq[String]] = hadoopRdd.map(_.split(" ").toSeq)

      documents.foreach(w => {

         for (v <- w) {

            keywordMap += (nonNegativeMod(v.##, 1 << 20) -> v)

            //            keywordMap.foreach(println)

         }

      })

      val hashingTF = new HashingTF()

      val tf: RDD[linalg.Vector] = hashingTF.transform(documents)

      tf.cache()

      val tfMapFromRdd = tf.map(line => (line.toSparse.indices -> line.toSparse.values))

      val tfMapRDD = tfMapFromRdd.map(

         line => {

            val changeToName = (x: Int) => keywordMap.getOrElse(x, "0")

            val kList:Array[String] = line._1.map(changeToName)

            val nameMap = kList.toList.zip(line._2.toList)

            nameMap

         }

      )

      tfMapFromRdd.foreach(println)

      println("tfMapFromRdd----------------")

      val idf = new IDF().fit(tf)

      val tfidf: RDD[linalg.Vector] = idf.transform(tf)

      val tfidfOfName = tfidf.partitions

      val mapFromRdd = tfidf.map(line => (line.toSparse.indices -> line.toSparse.values))

      //      mapFromRdd.foreach(

      //          n => println(n._1.toList +"\t" + n._2.toList)

      //      )

      val customerMapRDD = mapFromRdd.map(

         line => {

            val changeToName = (x: Int) => keywordMap.getOrElse(x, "0")

            val kList:Array[String] = line._1.map(changeToName)

            val nameMap = kList.toList.zip(line._2.toList)

            nameMap

         }

      )

      tfMapRDD.foreach(println)

      println("tfMapRDD-----------------")

      customerMapRDD.collect.foreach(println)

      println("customerMapRDD-----------------")

      //      customerMapRDD.saveAsTextFile("/root/abc")

      val joinRdd = tfMapRDD.zip(customerMapRDD)

      joinRdd.foreach(println)

      println("rdd zip-------------------")

    

      val resRdd = joinRdd.map(x => x._1++x._2)

      //resRdd.foreach(s => print(s + " "))

      resRdd.foreach{

         m => println(m)

      }

//      sc.parallelize(List((1,2),(3,4),(3,6))).foreach(println(_))

      println("resRdd-------------------")

      resRdd.map(x => {

         x

      })

      println("-------------------")

    

      val writer = new PrintWriter(new File("/root/test.txt" ))

//      for(c <-   resRdd.map(x => {x}).toArray()){

//         val v = sc.parallelize(c).reduceByKey((a,b) => {

//            val count = sqrt(pow(a,2)+pow(b,2)).toString

//            println("count:"+count)

//            var result = 1.0

//            println("count.length:"+count.length)

//            if(count.length > 3 )result=count.toDouble

//            else result=0.0

//            result

//         })

      for(c <-   resRdd.map(x => {x}).toArray()){

         val wordCs = sc.parallelize(c).reduceByKey((a,b) => sqrt(pow(a,2)+pow(b,2)))      //wordCs = word CosineSimilarity

         wordCs.foreach(print)

         val wordCsScore = wordCs.reduce((a, b) =>{                                                 //wordCsScore = word total score

            (a._1+" "+b._1,(a._2+b._2))

         })

         print(wordCsScore)

         val scoredWordCs = wordCs.filter(_._2.toString.length > 3)                                 //scoredWordCs = scored word CosineSimilarity

         val scoredWordCount = scoredWordCs.count()                                                                           //wordCount = count the words

         print("count: "+scoredWordCount)

         val wordCsTotalScore = scoredWordCs.reduce((a, b) =>{                                                 //wordCsTotalScore = scored word Total score

            (a._1+","+b._1,(a._2+b._2))

         })

         val wordCsTotal = wordCs.reduce((a, b) =>{                                                 //wordCsTotal

            (a._1+","+b._1,(a._2+b._2))

         })

         val lineCs = Tuple1(wordCsTotal._1 -> wordCsTotalScore._2/scoredWordCount)               //lineCs = line CosineSimilarity

         print(wordCsTotalScore)

         print(lineCs)

         val nearCsWords = scoredWordCs.map(a => {                                                                  //nearCsWords = words near line CosineSimilarity

            ((if (a._2-lineCs._1._2 < 0.05 && a._2-lineCs._1._2 > (-0.05)) a._2 else 0),a._1)

         }).sortByKey(false).map(b => (b._2,b._1))

        // totalNearCsWordsStr = ""

       

//         println("----------nearCsWordsStr--HAHAHA: "+getRDDSecondStrs(nearCsWords))

//         nearCsWords.foreach(print)

//         println()

         println()

         print(wordCsScore._1+"|"+lineCs._1._2+"|"+getRDDSecondStrs(nearCsWords))

         println()

         println()

//         val resultString = lineCs+nearCsWords.toArray().foreach()

//         println(resultString)

//         val m = v.filter(_._2.toString.length > 3)

//         m.map(_ => writer.writer(_))

         writer.write(wordCsScore._1+"|"+lineCs._1._2+"|"+getRDDSecondStrs(nearCsWords)+"\n\n")

//         m.toArray().foreach(println)

      }

      writer.close()

//      resuRdd.foreach(println)

      println("resuRdd-------------------")

//      val doubleRDD = resRdd.flatMap(identity)

//      doubleRDD.foreach{

//         m => println(m)

//      }

//      println("doubleRDD-------------------")

//      resRdd.saveAsTextFile("/root/result/resRdd")

//      val tryRDD = resRdd.map(

//         line => {

//            val kList = line.reduceBy

//            val nameMap = kList.toList.zip(line._2.toList)

//            nameMap

//         }

//

//      )

//      val aaaRdd = resRdd.map(x =>{

//         x.map(y => y._1+":"+y._2)

//      })

//      aaaRdd.foreach(println)

//      println("aaaRdd-------------------")

//      val resuRdd = aaaRdd.map(x => {

//         x.toString().substring(5,x.toString().length-1)

//      })

//      val resuRdd = resRdd.map(x => {

//         x.toString().substring(5,x.toString().length-1)

//      })

//      resuRdd.foreach(println)

//      println("resuRdd-------------------")

//      val tryRdd = resuRdd.map(x => x:List[(String,Double)])

//      tryRdd.foreach(println)

//      println("tryRdd-------------------")

//      val resultRdd = resRdd.map(x => x.toList)

//      resultRdd.foreach(println)

//      println(resultRdd.take(1))

//      val newOne = resultRdd.reduce((x,y) => x++y)

//      newOne.foreach(println)

    

//      println("resultRdd-------------------")

//

//      def consine(x: Double, y: Double): Double = {

//         val res = sqrt(pow(x,2)+pow(y,2))

//         res

//      }

//    val consineRdd = resRdd.reduceByKey((x:Double,y:Double) => consine(x,y))

      sc.stop()

   }

}