快学scala第一章习题答案_百度文库
两大类热门资源免费畅读
续费一年阅读会员，立省24元！
快学scala第一章习题答案
总评分4.3|
浏览量8072
用知识赚钱
阅读已结束，下载文档到电脑
想免费下载本文？
定制HR最喜欢的简历
你可能喜欢以下scala代码中的问号代表什么意思？ - 知乎2被浏览385分享邀请回答@ implicit class ?????(val x: Int) extends AnyVal {
def ?? (y: Int) = x + y
defined class ?????
@ val ? = 1
?: Int = 1
@ val ??? = 2
???: Int = 2
@ val ???? = 3
????: Int = 3
@ ? ?? ??? ?? ????
res4: Int = 6
1添加评论分享收藏感谢收起关键字抽取算法 TextRank 之 Scala 实现 - 为程序员服务
关键字抽取算法 TextRank 之 Scala 实现
关键字提取的方法有很多，本文会介绍一种 Graph-based 关键字抽取算法，并给出 Scala 实现。
事实上， 的基本思想源自 。为了对网页进行排序，Google 提出了 PageRank 这种基于图的算法。按照 Google 的思想，互联网可以抽象为图这种数据结构。若干网页构成图上的结点，网页之间的链接则构成边。每个网页的排名（rank）可以通过多次迭代计算得到。在一次迭代过程中，每个网页对其邻居（neighbour）贡献（contributes） r/n 。其中 r 为该网页 rank，n 为该网页邻居数。之后再根据每个网页得到的贡献（contributions），更新其 rank。更新方法如下：
$$r_{i}=\frac{\alpha}{N} + (1-\alpha)\sum_{i=1}^{n}{c_i} \qquad (\alpha \in [0,1)) $$
经过若干次迭代之后，每个网页会得到一个 rank，之后便可根据这个 rank 来对网页排序。
在 PageRank 的基础上，TextRank 做了一些修改，但基本方法是一致的。让我们来看看 TextRank 的形式化描述：
给定 G = (V, E) 为有向图，其中 V 是顶点集（单词集合），E 是边集。每次迭代更新各个单词 rank 公式如下：
$$WS_{V_{i}}=(1-d) + d\sum_{V_{j}\in{In(V_{i})}}^{n}\frac{w_{ji}}{\sum_{V_{k}\in{Out(V_{j})}}w_{jk}}WS_{V_{j}} \qquad (d \in [0,1))$$
Scala 实现
因为 TextRank 是基于图的算法，第一步需要做的便是将整篇文档中的单词构造成一个 TextGraph。考虑到关键词一般为名词或命名实体，我们除了使用 ansj 做词性标注抽取名词，还使用 stanford 的 NER 库抽取命名实体。根据同现信息构造 TextGraph。
import java.io.StringReader
import java.text.BreakIterator
import java.util.Locale
import akka.event.slf4j.SLF4JLogging
import edu.stanford.nlp.process.{CoreLabelTokenFactory, PTBTokenizer}
import edu.stanford.nlp.tagger.maxent.MaxentTagger
import org.ansj.domain.Term
import org.ansj.splitWord.analysis.ToAnalysis
import org.ansj.util.recognition.NatureRecognition
import org.graphstream.graph.Node
import org.graphstream.graph.implementations.SingleGraph
import scala.collection.mutable
import scala.io.Source
* Created by yangchaozhong on 12/30/14.
class TextGraph(val graphName: String,
val doc: String) extends SLF4JLogging {
import TextGraph._
val graph = new SingleGraph(graphName)
constructTextGraph
private def constructTextGraph = {
val bi = BreakIterator.getSentenceInstance(Locale.CHINESE)
bi.setText(doc)
var lastIndex = bi.first()
while (lastIndex != BreakIterator.DONE) {
val firstIndex = lastIndex
lastIndex = bi.next()
if (lastIndex != BreakIterator.DONE &&
Character.isLetterOrDigit(doc.charAt(firstIndex))) {
val sentence = doc.substring(firstIndex, lastIndex)
var wordSet: mutable.HashSet[String] = mutable.HashSet.empty
if (containsChinese(sentence)) {
wordSet = chinesWordSet(sentence)
wordSet = englishWordSet(sentence)
val wordList = wordSet.toList
wordList foreach {
word =& if (graph.getNode(word) == null) graph.addNode(word)
binations(2).toList foreach {
if (graph.getEdge(s"${words(0)}-${words(1)}") == null &&
graph.getEdge(s"${words(1)}-${words(0)}") == null) {
graph.addEdge(s"${words(0)}-${words(1)}", words(0), words(1))
graph.getNodeSet.toArray.map(_.asInstanceOf[Node]).foreach {
(s"${node.getId}:${node.getDegree}")
private def chinesWordSet(sentence: String) = {
val terms = ToAnalysis.paser(sentence)
new NatureRecognition(terms).recogntion()
val wordSet = new mutable.HashSet[String]()
terms.toArray.foreach {
val word = term.asInstanceOf[Term].getName
val nature = term.asInstanceOf[Term].getNatrue.natureStr
if (!(nature == "null") && word.length &= 2) {
val reg = "^[ne]".r
if (reg.findFirstMatchIn(nature).isDefined && !stopwords.contains(word))
wordSet.add(word.toLowerCase)
private def englishWordSet(sentence: String) = {
val ptbt = new PTBTokenizer(new StringReader(sentence), new CoreLabelTokenFactory, "")
val wordSet = new mutable.HashSet[String]()
while (ptbt.hasNext) {
val label = ptbt.next()
val tagged = tagger.tagString(label.word())
val start = tagged.lastIndexOf("_") + 1
val reg = "^[N]".r
if (reg.findFirstMatchIn(tagged.substring(start)).isDefined &&
!stopwords.contains(label.word().toLowerCase()) &&
label.word().toLowerCase.length &= 3)
wordSet.add(label.word().toLowerCase)
private def containsChinese(doc: String) = {
doc.count {
val ub = Character.UnicodeBlock.of(word)
if (ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS ||
ub == Character.UnicodeBlock.CJK_COMPATIBILITY_IDEOGRAPHS ||
ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_A ||
ub == Character.UnicodeBlock.CJK_UNIFIED_IDEOGRAPHS_EXTENSION_B ||
ub == Character.UnicodeBlock.CJK_SYMBOLS_AND_PUNCTUATION ||
ub == Character.UnicodeBlock.HALFWIDTH_AND_FULLWIDTH_FORMS ||
ub == Character.UnicodeBlock.GENERAL_PUNCTUATION) {
} else false
object TextGraph {
val tagger = new MaxentTagger("taggers/left3words-wsj-0-18.tagger")
val stopwords = Source.fromURL(getClass.getResource("/stopwords/stopwords-en.txt")).
getLines().toSet
有了 TextGraph，采用 TextRank 算法多次迭代即可抽取文档关键词。这里的实现将公式中的 d 设置为了 0.85, 每条边的权值统一设为 1.0。
import org.graphstream.graph.{Edge, Node}
import scala.collection.mutable
* Created by yangchaozhong on 12/30/14.
object KeywordExtractor {
def extractKeywords(doc: String) = {
val graph = new TextGraph("keywords", doc).graph
val nodes = graph.getNodeSet.toArray.map(_.asInstanceOf[Node])
val scoreMap = new mutable.HashMap[String, Float]()
// Initialization
nodes.foreach(node =& scoreMap.put(node.getId, 1.0f))
// Iteration
(1 to 500).foreach {
nodes.foreach {
val edges = node.getEdgeSet.toArray.map(_.asInstanceOf[Edge])
var score = 1.0f - 0.85f
edges.foreach {
val node0 = edge.getNode0.asInstanceOf[Node]
val node1 = edge.getNode1.asInstanceOf[Node]
val tempNode = if (node0.getId.equals(node.getId)) node1 else node0
score += 0.85f * (1.0f * scoreMap(tempNode.getId) / tempNode.getDegree)
scoreMap.put(node.getId, score)
scoreMap.toList.sortWith(_._2 & _._2).slice(0, 20).map(_._1)
项目地址：
关键字提取的方法有很多，本文会介绍一种 Graph-based 关键字抽取算法，并给出 Scala 实现。
事实上， 的基本思想源自 。为了对网页进行排序，Google 提出了 PageRank 这种基于图的算法。按照 Google 的思想，互联网可以抽象为图这种数据结构。若干网页构成图上的结点，网页之间的链接则构成边。每个网页的排名（rank）可以通过多次迭代计算得到。在一次迭代过程中，每个网页对其邻居（neighbour）贡献（contributes） r/n 。其中 r 为该网页 rank，n 为该网页邻居数。之后再根据每个网页得到的贡献（contributions），更新其 rank。更新方法如下：
$$r_{i}=\frac{\alpha}{N} + (1-\alpha)\sum_{i=1}^{n}{c_i} \qquad (\alpha \in [0,1)) $$
经过若干次迭代之后，每个网页会得到一个 rank，之后便可根据这个 rank 来对网页排序。
在 PageRank 的基础上，TextRank 做了一些修改，但基本方法是一致的。让我们来看看 TextRank 的形式化描述：
给定 G = (V, E) 为有向图，其中 V 是顶点集（单词集合），E 是边集。每次迭代更新各个单词 rank 公式如下：
$$WS_{V_{i}}=(1-d) + d\sum_{V_{j}\in{In(V_{i})}}^{n}\frac{w_{ji}}{\sum_{V_{k}\in{Out(V_{j})}}w_{jk}}WS_{V_{j}} \qquad (d \in [0,1))$$
原文地址：, 感谢原作者分享。
您可能感兴趣的代码博客分类：
var 可变，可重新赋值，赋值为"_"表示缺省值(0, false, null)，例如：
var d:Double = _ // d = 0.0
var i:Int = _ // i = 0
var s:String = _ // s = null
val (x,y) = (10, "hello")
def 实时返回结果变量，可作为方法返回结果，方便使用
def t = System. currentTimeMillis // 每次不一样
类型转化：
var i = 10.asInstanceOf[Double] //类型强制
println(i)
println(List('A','B','C').map { x =& (x+32).asInstanceOf[Char] })
在强转换Array[Object]到Array[String]则会报错，建议arr.map{x=&x.toString//加上的处理什么的}
2.implicit隐式转化
implicit def typeConvertor(input:Int):String = input.toString
implicit def typeConvertor(input:Boolean):String = if(input) "true" else "false"
display("1212")
display(12)
display(true)
3.表示Array转为普通序列
val options = parse(args2:_*)
def parse(x:Int*) = {
for(i &- x)
println(i)
集合map方法：
//transation的map方法，seq，list，map...
var arr1 = Seq(1,2,3,4,5)
var maparr = arr1.map(p=&{
1.List是不可变的，Tuple可以包含不同元素
var arr2 = List(1,2,3,4,5,1)
println(arr2.map { case(a) =& a+1})
var maptest = Map(1-&2,3-&4,5-&6,1-&5)
println(maptest.map{case(k,v)=&k})
//map 1是key，2是value
println(maptest.map(_._1))
println(maptest.map(_._2))
3.Seq 去重集合
println(arr2(0))
println(arr1(0))
println((1,2,3)._1)
var ttt = Set(1,2,3)
4.Array定长集合，可变内容，不变长度，和java交互式，一般集合转为此类
var pathList = new Array[String](list.size())
for(i &- 0 to list.size()-1){
pathList(i)=list.get(i)
pathList = pathList.map { x =& path+pathSeperate+x }
5.ArrayBuffer 变长变内容的集合
private var cis=ArrayBuffer[(String,Option[ZkDTState],Option[String],Option[Array[String]])]();
for(po &- list){
var stat = readContent(zkclient,po._1+pathSeperate+pathContent,po._2)
var nodes = readchildNodesInfo(zkclient, po._1+pathSeperate+pathNodes)
var active = readChildActiveNodeInfo(zkclient, po._1+pathSeperate+pathActive)
cis.+=((po._1,stat,active,nodes))
6.集合的filter，groupBy方法：
println("相同的arr2元素分到一个组,并过滤大于1"+arr2.groupBy(groupm).filter{case(a,b) =& (a&1)}.keys)
groupBy方法按照函数参数groupm分组
def groupm[A](x:A):A=x;
将相同的元素分到一个组里，返回map[Int,List[Int]]
filter方法，（a,b）,a是groupBy返回的值Int，b是集合arr2中相同的元素集合List[Int]
最终过滤值大于1的，获得map的key
这一行的作用是去重
blackproof
浏览: 835039 次
来自: 北京
很清楚，有帮助。
Good job !!
为啥EPHEMERAL_SEQUENTIAL类型的节点并没有自 ...
写道新手讨厌不贴整个工程代码的大侠需要 ...