机器学习其实只有三个步骤。第一个步骤就是找一个function，第二个步骤是让machine可以衡量一个function是好是坏，第三个步骤是让machine有一个自动的方法，挑出最好的function。
###机器学习相关的技术
监督学习
Int -> Color //Color 取值为 Red, Yellow, Blue
\a = [Red,Yellow,Blue] !! (abs a % 3)
机器学习其实只有三个步骤。第一个步骤就是找一个function，第二个步骤是让machine可以衡量一个function是好是坏，第三个步骤是让machine有一个自动的方法，挑出最好的function。
Int -> Color //Color 取值为 Red, Yellow, Blue
\a = [Red,Yellow,Blue] !! (abs a % 3)
按照之前的讨论方向，除了之前的数据之外还需要增加以下几个内容：
在统计第一个数据时，即每种类型的调用次数时发现调用次数为0的声明太多了：
这个太不符合常理，一般除了接口外不会有人声明函数不调用，于是我就简单的查看一些没有被我程序检查出来的调用，发现：
-代表导入一个包里面的所有类，类似java里面的*, 有些函数调用在一个文件中只出现了一次而且前面也没有类修饰，只是像getFile(fileName) 这样就不容易分析这个函数调用到底属于谁。以上几个问题都是在在统计中发现的，其他的一些情况像嵌套函数暂时还没有列出来。
介于上面的问题，我决定尝试使用语义数据库来尝试一下，之前跟玄老师介绍过，这个是Scalameta开源组织另一个工具，但是我在几个大项目中(spark,scala..,)中尝试了编译中断，无法通过编译。这周我将这个工具尝试用在其他的项目上，经过两三天的配置项目，最终得到了11个项目的语法数据库。
语法数据库的内容：
根据语法数据库的内容，我们可以在Symbol中找到函数的声明，在Occurrences中查找函数的调用。通过语法数据库我们可以得到：
但是语法数据库我们无法得到：
针对后两个我们无法得到的东西我们可以通过其具体的位置，然后通过语法分析，字符串匹配来得出。
| 语法分析高阶函数声明 | 语法分析调用 | 语义分析声明 | 语义分析调用 | |
|---|---|---|---|---|
| bfg | 7 | 3 | 27 | 11 |
| fpinscala | 464 | 416 | 700 | 910 |
| framework | 176 | 151 | 468 | 328 |
| gitbucket | 62 | 256 | 138 | 624 |
| gatling | 101 | 110 | 315 | 379 |
| sbt | 512 | 622 | 710 | 1202 |
| shapeless | 97 | 36 | 502 | 102 |
| lila | 258 | 391 | 453 | 699 |
在查找如何使用配置semanticdb的时候，偶然发现了scalameta作者收集到的一些数据（所用到的工具版本不一致），作者一共统计了91个项目的数据，其中有几个是我们20个项目中的，我认为可以作为后面实验的补充数据，至少可以确定能够配置成功。
GitHub 网址： https://github.com/olafurpg/scala-experiments
91个项目列表： https://docs.google.com/spreadsheets/d/1btkCiF30Wb9MJti6LDc9og788XqXBKgwEhIdKb9aloc/edit#gid=1799045603
lambda expression，提出了concurrent applications与lambda expression可能存在一定联系，并通过一系列实验和实验数据的分析验证了自己的观点。
lambda expressions有很优越性，它允许声明匿名函数，能够更容易将行为转化为程序组件。在一些纯(purity)表达式中，能够保证代码没有副作用等等，这些好处推动了程序员更加广泛的使用lambda expressions。
Järvi and Freeman 2010; Gyori et al. 2013 等人在自己的论文中声明了lambda expressions的几个优点或者影响即：
本文主要针对第二点做了更深入的研究。
针对第一个RQ,本文主要做了以下实验：
度,利用Kruskal-Wallis test和Dunn’s test来探索三种语言项目的相关性。
结论：
针对第二个RQ,本文主要做了以下实验：
capturing lambda 和non-capturing lambda的数量
Kruskal-Wallis test和Dunn’s test来探索三种语言项目的相关性
结论：
针对第三个RQ,本文主要做了以下实验：
结论：
相关工作里面对我们有用的只有这个感觉，对是否采用lambda表达式进行分析
Mazinanian et al. (2017)等最近对Java中的lambda表达式进行了一项研究。特别是，他们分析了来自GitHub的241个开源项目的历史数据，以找到开发人员最近添加了lambda表达式的项目。然后他们采访了有意义的开发人员，以发现他们插入具体lambda表达式的原因。他们的主要见解是lambda表达式的采用正在增加，并且大多数lambda都是手动插入的。此外，分析表明，由于几个原因，例如缺少异常处理，开发人员不使用标准库提供的许多功能接口。此外，在他们的定性研究中确定了采用lambda表达式的几个关键原因。这些包括减少代码大小，避免类实现，包装行为，迁移到Java 8或强制使用lambda表达式的库。除了这些抽象的原因，他们还确定了lambda表达式的一些特定用例，例如，实现了监听器和回调，简化了测试，以及多线程和异常处理。与我们的研究相反，他们只调查了一种编程语言中的lambda表达式的使用，即Java。此外，我们还进行了跨语言分析，可以更深入地了解编程语言之间的差异。这可以帮助语言设计者通过学习其他语言的实现来改进他们当前的lambda表达式设计
Uesbeck et al. (2016)等对58名不同经验水平的参与者进行了用户实验。在本实验中，他们被要求通过使用迭代器接口或lambda表达式来解决C++中的编程任务。他们的研究结果表明，有经验的用户更有可能正确应用lambda表达式。 这表明我们必须仔细选择我们分析中使用的项目，因为大量新手开发人员正在处理的项目可能具有更高的错误使用的lambda表达式。
Tsantalis et al. (2017)等开发了一个Java重构工具，旨在通过插入lambda表达式来减少代码克隆。 他们表明，他们的工具可以在开源项目中正确地重构57-60％的类型-2（除了标识符名称语法相同）和类型-3（添加或删除语句）克隆。 特别是，他们指出，与生产代码中的克隆相比，驻留在测试代码中的克隆比例更高，可以成功重构（71％对51％）。这些发现揭示了lambda表达式的潜在用例，即克隆代码减少和自动测试。
上周主要做了三个工作：
按照之前讨论的思路，首先遍历项目，提取所有的函数声明的信息，并保存函数的类名，方法名，参数的数量和函数参数的位置，然后再遍历一遍项目，提取每一个函数调用，并根据之前提取的信息进行匹配函数的声明，通过一次又一次的修改测试，整出来一个尚可的版本。
提取函数调用并保存到数据库，便于快速查询。
但是，提取调用关系仍然存在以下问题(每跑一个项目都会发现相应的问题，修改完以后还要重新跑一遍之前的项目，心累)。
new关键字，因为在匹配函数调用时，我需要知道这个调用具体属于哪个对象，属于哪个类，我将一个文件中的所有new出来的对象存在一个symbol表中，但是没有关键字new不容易识别：
除了上面的问题，提取的函数调用基本没有什么问题，还有就是在函数调用类型判断的时候，类型一的数量实际上会比实际上多，因为里面会包含那种从上层函数直接继承来的函数。因为在判断类型的时候，类型一是处于逻辑上的else语句上。
上周解决了提取git log困难的信息，采用了将其存入数据库的方法，现在派上了用场了，我的思路是根据函数所在文件的路径以及函数的第一行来进行匹配。
但是其中也存在一些问题，95%以上的作者都能找到，另有一些函数没有找到作者，最后通过发现，函数第一行都能匹配到，但是路径总是不对，最后通过观察发现，有些文件或者变换了路径或者修改了文件名称导致在log文件中没有找到，最后只能通过手动将剩余没有找的信息补充完整。
详细的信息(每个函数声明和调用的信息)sql文件已上传，最终的简略表格统计在这里列出。
上周主要按照之前的实验设计统计数据。统计的数据主要有：
git log -p> **.txt的命令首先将所有的commit的信息生成文件，然后对文件中的字符串进行切割，预处理，搜索，查找我们制定的作者，但是有时候这个文件又特别大，很占内存，读的时候很慢，实验也就卡在这里了，我也尝试了其他读取文件的方法，效果不是很好，另外，java提供了jGit这个工具，可以允许你用java代码调用git接口，但是我找到了git.log()这个api,但是得到的东西很少，没有包含每次提交添加了什么代码，也就是没有命令行里面-p的选项。针对上面的问题，继续寻找解决方法，增加项目数量，继续统计数据。
]]>上次实验我主要统计了所有的scala项目的高阶函数声明的数量，并没有对其调用进行统计，而且后来才发现我只统计了那些函数行数大于10行的函数，所以这次实验要重新进行统计。
这次实验选取的项目为跑playframework:
playframework是一个full-stack（全栈的） Web的应用框架，包括一个简单的无状态MVC模型，具有Hibernate的对象持续，一个基于Groovy的模板引擎，以及建立一个现代Web应用所需的所有东西。而且playframework是star最多的一个scala项目。
实验步骤：
apply,map这样的函数，在高阶函数里面就有很多，在所有函数里面搜索关键字就有几百条。
前面我们统计了一个项目中的高阶函数的分布，发现大多数函数声明和调用都发生在同一个文件中，所以我就打算统计一下那些没有在同一个文件中的高阶函数的声明和调用是不是同一个作者。
所有的作者信息：
最先创建文件作者信息：
只有三对的初始化作者是相同的，其余作者都不相同。
Higher order functions take other functions as parameters or return a function as a result. This is possible because functions are first-class values in Scala. The terminology can get a bit confusing at this point, and we use the phrase “higher order function” for both methods and functions that take functions as parameters or that return a function.
也就是之前我们说的高阶函数的定义，没有说明为什么要用高阶函数。
但在另一个scala-exercise网站上举了一个例子：https://www.scala-exercises.org/scala_tutorial/higher_order_functions
总结：使用高阶函数可以减少代码，尤其是在比较复杂的流程中，这类似于Strategy模式，将核心算法整体替换，整个架构不变，比如一个有不同水平的棋类游戏，高阶函数的让这个实现更简单。
调用函数的类型：
经过我粗略的统计，发现上面四中使用方法中，第一种使用的最少，使用最多的是第三种和第四种，函数参数就在函数调用中编写的情况处于两者之间，但是比第一种多很多。
之前所说的高阶函数的主要目的就是简化代码，然后抽象化。在项目统计高阶函数数据时，我发现很多高阶函数在参数面前都有一个[T],这根我们之前c++中的template
而且在所统计的数据中，模板高阶函数还占有很大的比重，在我提取的166个高阶函数中，有97个加了模板[T]。
]]>这一步就是在之前构造AST的代码上做进一步进行修改。之前博客中提到高阶函数的定义：
满足以下条件之一：
就是高阶函数：
但是由于scala 函数默认最后一句话为返回值，且利用工具scala-mate查看不出最后一句话的类型，所以我只能从传入的是个函数这个判断条件来进行提取数据。
高阶函数示例：
def sum(f:Int=>Int):(Int,Int)=>Int={
def sumF(a:Int,b:Int):Int=
if(a>b) 0
else f(a)+sumF(a+1,b)
sumF
}
构造的AST树：
所以只要判断函数的参数里面有函数的类型即Type.Function即可，所以修改后的代码如下：
20个项目选取的网址：
https://github.com/search?l=Scala&o=desc&p=1&q=scala&s=stars&type=Repositories
接下来就是git clone 20个项目，跑实验，统计每个项目中高阶函数的个数，统计结果如下：
通过观察实验结果可以发现，高阶函数占比并不是很高，除了fpinscala,scalaz,sbt 三个项目占比较高外，其他项目都低于10%。说明高阶函数的普及型并不是很高。
通过github api 获取文件的commit信息，很简单，就直接写了一个python 函数，统计了每个项目每个高阶函数所在文件的commit的历史作者和最早提交的作者。
提取函数的代码链接：https://gitee.com/iss2015302580249/scalaCommitInfo
在提取commit的信息的时候遇到了一个问题，就是提取账户名的时候，会有不存在的现象，也就是 login字段为空，我感觉应该是账户已经注销了，所以我提取的是commit里面的author字段的信息，也就是用户姓名的信息。
最终的统计结果：
通过实验结果我们可以看出，高阶函数所在文件创始者总数占比也很低，但是我们不能确定，文件的创始者就是高阶函数的创始者，这一点有待讨论和解决：
实验最终数据链接：https://gitee.com/iss2015302580249/scala_data
通过之前的实验我们可以发现，程序运行的时间主要发生在autoencoder上面，即将词向量转换成句向量的过程。对此我想根据网上的一些方法对这部分代码进行优化，其优化的方法主要有以下几个过程。
在上次开会的时候我们就已经说了，代码已经使用openmpi允许我们多进程并行计算，于是我就简单的测试了多个进程和单个进程执行的时间差异。
2个进程，CPU
我是在李老师提供的GPU服务器上跑的实验，该实验并没有调用GPU进行加速。
启动
开启的两个进程
未调用GPU
结果： 跑了80分钟，没跑完，我强行结束了
10个进程，CPU
同样是在相同的服务器上进行的实验，该实验并没有调用GPU进行加速
启动
开启10个进程
未调用GPU
结果： 1991s
20个进程，CPU
启动
开启20个进程
未调用GPU
结果： 1847s
通过实验可以看出来之后简单的增加的运行的进程已经对速度的提升不太明显，所以之后祭出神器GPU来对我们的代码进行加速。
通过阅读代码发现，该autoencoder使用的是Numpy,Scipy来进行的系列的矩阵操作，并没有使用什么TensorFlow类似的神经网络框架，所以并没有现成的GPU版本的框架直接替代，到目前为止有两个方法，一个是将Scipy转为用TensorFlow类似神经网络的框架，但是没有任何实践经验，无从下手，所以我决定在代码内部做点改变，使其支持GPU。具体尝试的方法有以下几种：
所以最终决定使用cupy替代Numpy,实现GPU支持，当然其中需要修改很多代码，虽然官网说是完全替代，其实并不是。最终经过两天半的不断修改，GPU版本可以运行了，我们看下结果。
4 个进程 GPU
还是使用李老师给的GPU服务器
启动
调用GPU
结果： 1578s
这里我们只是用了服务器里面的一块GPU，并没有全部使用，结果看来虽然加速了，但是效果并不是很好啊，就提高了300s,当时我怀疑是服务器配置的问题，以为我开启四个进程，GPU就100%了，所以我决定在贾老师的电脑里试一试。于是又花了一天的时间配置服务器的环境，进行了实验。实验结果如下。
10个进程 GPU
使用的是贾老师实验室的服务器
启动
调用GPU
结果 ： 909s
这次实验也只用电脑里面的一块GPU，速度提升可以看到，一半左右，但是也没有达到10倍一百倍那种地步，后期还需要探索问一下相关老师。
Note: GPU 版本相关代码已经发布到 GitLab上面去了: http://125.220.157.228/clone_detection/clone_detection_tools_gpu ，老师可以进行相关测试。
]]>命令”机器”如何去做事情，这样不管你想要的是什么，他都会按照你的命令实现。
告诉”机器”你想要什么，让机器想出如何去做
Integer[] nums = new Integer[]{1, 2, 3, 4};
int i=0;
for (Integer n : nums) {
n*=2;
nums[i++]=n;
}
遍历整个数组，取出每个元素，乘以二，然后把翻倍后的值放回数组，每次都要操作这个数组，直到计算完所有元素。
val nums = Array(1,2,3,4)
val doubleNums = nums.map(_*2)
利用Array的map函数，将所有元素2，并生成了一个新的双倍数组。map函数所做的事情是把遍历整个数组的过程，归纳并抽离出来，让我们专注于描述我们想要的是什么”_2”。我们传入map的是一个纯函数；它不具有任何副作用(不会改变外部状态)，它只是接收一个数字，返回乘以二后的值。PS： ‘_’ 字符是scala中的入参缩写形式。
def max(x: Int, y: Int): Int = {
if (x > y) x else y
}
def 是声明函数的关键字，小括号中的x:Int,y:int是函数的入参，紧跟着的:Int是函数返回值类型，花括号中的是函数体。
val increment = (x: Int) => x + 1
increment(2)
// output 3
匿名函数是指一类无需定义标识符的函数，定义匿名函数的语法很简单，=>箭头左边是参数列表，右边是函数体。可以把命名函数赋值给一个变量使用。
另一种方式
val increment =new Function1[Int, Int] {
def apply(x: Int): Int = x + 1
}
val sayHello = () => { System.out.print("Hello World!") }
sayHello()
//output: Hello World!
满足以下条件之一：
在数学领域他们也叫做算子或泛函。微积分中的导数就是常见的例子，它映射一个函数到另一个函数。
val convert2String=(x:Int)=>"==[" + x.toString() + "]=="
def apply(f: Int => String, v: Int) = f(v)
apply(convert2String,36)
//output: ==[36]==
在Scala中可以在函数体中再定义一个函数。
def filter(xs: List[Int], threshold: Int) = {
def process(ys: List[Int]): List[Int] =
if (ys.isEmpty) ys
else if (ys.head < threshold) ys.head :: process(ys.tail)
else process(ys.tail)
process(xs)
}
在计算机科学中，柯里化是指把接受多个参数的函数变换成接受一个单一参数的函数，并且返回其余的参数和结果的函数。
def curriedSum(x: Int)(y: Int)(z: Int) = x + y + z
val sum = curriedSum(1)(2)(3)
//output: 6
//the calling procedure of currying function
def first(x: Int) = (y: Int) => (z: Int) => x + y + z
def second = first(5)
//output: Int => (Int => Int) = 5 + y + z
def third = second(6)
//output: Int => Int = 5 + 6 + z
val fourth = third(7)
//output: 18
first(5)(6)(7)
//output: 18
代码范例中，curriedSum是一个currying函数的Scala写法，而first、second、third、fourth展示了currying函数调用过程。通过代码注释可看到second、third返回的都是函数，直到fourth才返回求和值。而这种特性也正是惰性求值的秘密所在。
def sum(x: Int, y: Int, z: Int) = {
x + y + z
}
val sum2 = sum(10, _: Int, 15)
sum2(2)
//output: 27
从输入集合X到可能的输出集合Y的函数f(记作f(X)=>Y)是X与Y的关系，满足如下条件：
X与Y的关系f满足条件1，则为多值函数。X与Y的关系f满足条件2，则为偏函数。
val pf: PartialFunction[Int, String] = {
case 1 => "One"
case 2 => "Two"
case 3 => "Three"
case 9 => "Nine"
case _=> "Nothing"
}
pf(1) // output: One
pf(2) // output: Two
pf(5) // output: Nothing
pf(9) // output: Nine
示例代码中，我们定义了一个Scala的偏函数，那么只有1、2、3、9有对应的输出值，而输入其它值只会打印 Nothing。
val L1 = List(1, 2, 3, "A", 4, "B", 5)
val L2 = L1 map {
case x: Int => x * x
case x: String => s"$x*$x"
}
//L2: List[Any] = List(1, 4, 9, A*A, 16, B*B, 25)
又称函数闭包，是引用了自由变量的函数。这个被引用的自由变量将和这个函数一同存在，换句话说，闭包是由函数和与其相关的引用环境组合成的。
另外一种解释，对象是带有函数的数据，闭包是带有数据的函数。
val more = 2
val addMore = (x: Int) => x + more
addMore(1)
将未计算的参数表达式直接应用到函数内部即为传名调用。
def assert(predicate: => Boolean) =
if (!predicate)
throw new AssertionError
assert(1 > 3)
def compare(x: Int, y: Int): Boolean = {
if (x > y) true else false
}
assert(compare(1, 3))
def echo(args:String*)={
for(arg <- args) println(arg)
}
echo("Hello","World","!")
//output: Hello World!
def even(x:Array[Int]):Array[Int]={
x.filter(_%2==0)
}
def square(x:Array[Int]):Array[Int]={
x.map(e=>e*e)
}
def total(x:Array[Int]):Int={
x.reduce(_+_)
}
val nums = Array(1,2,3,4,5,6,7,8,9,10)
val pipeline = total(square(even(nums)))
//output: 220
def fun(i:Int):Unit=
{
if (i < 10 && i >= 0)
{
println(s"i:$i");
fun(i + 1);
}
}
fun(1)
Scala编译器优化了尾递归调用，递归调用和执行一个while循环没有性能上区别。
在Scala中函数如果是某个对象的成员，那么称这种函数为方法。
class Sample{
def sayHello():Unit={
print("Hello")
}
}
之前我们一直根据spark开源项目来开展我们的研究，没有跑其他的项目，这就造成了程序的不兼容性。果然通过英国那边的老师的反馈确实程序的健壮性出现了问题。于是又跑了几遍程序，修改出现的问题。
在修复的过程中，我们主要以scala语言的开源代码作为目标代码： https://github.com/scala/scala ，因为我觉得这个项目应该包含了scala语言的所有特性。 最终发现了两个问题：
新添加的方法
然后跑了一下scala语言的代码，统计了一下结果
其中可以进行分批次优化的关键步骤就是在词向量转化为句向量的过程中，目前可以采用的方法就是多个电脑并行运行这一步骤，然后将结果汇总统计距离，也可以启用多进程或者线程。
]]>