flink安装

自从微软在 windows 10 内集成了 wsl ，对于开发人员来说简直不要太方便了，尤其是听说下个版本的 wsl2 还支持 Docker。大数据环境基本对 windows 的支持很差，但是有了 wsl 就完全不一样了。

如何开启和安装 wsl 就不多介绍了，可以 百度/Google 一下。我安装的是 ubuntu 16.04 LTS 。

flink 的安装还是比较简单的，环境基本安装好 jdk 即可。

JDK 安装

我这里安装的是 Open JDK ,只需要一行命令即可。

sudo apt-get install openjdk-8-jdk

如果安装出错，先更新一下

sudo apt-get update

下载安装完成后，通过 java 和 javac 看看是否安装成功。

flink 安装

flink的安装就更加简单了，到 **flink 官方/中文网 ** 找到下载页面，选择你要的版本（我选择的是 Apache Flink 1.7.2 with Hadoop® 2.8 for Scala 2.12），点击下载之后官方会帮你选择一个镜像链接。然后下载即可。

通过 wget 命令下载

wget http://mirrors.tuna.tsinghua.edu.cn/apache/flink/flink-1.7.2/flink-1.7.2-bin-hadoop28-scala_2.12.tgz

等待下载完成即可。

下载完成之后，解压压缩包，完成项目。

tar -zxf flink-1.7.2-bin-hadoop28-scala_2.12.tgz

打开解压后的文件，我们在 bin 目录下找到 start-cluster.sh ， 启动该脚本即可运行。

./start-cluster.sh

运行该脚本，启动 flink 。

如图，启动成功。

此时在 windows 上打开浏览器 http://localhost:8081 可以看到 flink 控制台。

此时的 flink 项目已经启动成功。已经完成了安装工作。

编写flink代码

通过idea创建 maven/gradle 项目，导入必要的包，下面为 maven 依赖

  <dependencies>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-scala_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>
        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-streaming-scala_${scala.binary.version}</artifactId>
            <version>${flink.version}</version>
            <scope>provided</scope>
        </dependency>

        <dependency>
            <groupId>org.scala-lang</groupId>
            <artifactId>scala-library</artifactId>
            <version>${scala.version}</version>
        </dependency>


        <dependency>
            <groupId>org.apache.flink</groupId>
            <artifactId>flink-connector-kafka-0.11_2.11</artifactId>
            <version>${flink.version}</version>
            <exclusions>
                <exclusion>
                    <groupId>log4j</groupId>
                    <artifactId>*</artifactId>
                </exclusion>
                <exclusion>
                    <groupId>org.slf4j</groupId>
                    <artifactId>slf4j-log4j12</artifactId>
                </exclusion>
            </exclusions>
        </dependency>

        <dependency>
            <groupId>org.slf4j</groupId>
            <artifactId>slf4j-log4j12</artifactId>
            <version>1.7.7</version>
            <scope>runtime</scope>
        </dependency>
        <dependency>
            <groupId>log4j</groupId>
            <artifactId>log4j</artifactId>
            <version>1.2.17</version>
            <scope>runtime</scope>
        </dependency>
</dependencies>

注意部分依赖使用的范围 scope 是 provided，该属性为在项目打包是不会打包，但是本地运行项目时候需要，所以在本地调试的时候要将该属性注释掉，否者或报错。

下面是 Scala 版本的 wordCount

package top.young.wordcount

import org.apache.flink.api.scala.{ExecutionEnvironment, _}

object WordCount {
  def main(args: Array[String]): Unit = {
    val env = ExecutionEnvironment.getExecutionEnvironment
    val data = List("hi", "how are you", "hi")
    val ds = env.fromCollection(data)
    val counts = ds.flatMap(
      _.toLowerCase.split("\\W+").filter(_.nonEmpty)).map {
      (_, 1)
    }.groupBy(0).sum(1)
    counts.print()
  }
}

运行会有执行结果

(are,1)
(you,1)
(hi,2)
(how,1)

确认项目可以正确运行后可以进行打包。执行maven的 package 命令，会在target目录中找到我们打包好的jar

运行 Flink 代码

打开我们的控制台 http://localhost:8081 ,选择 submit new job ,点击 Add New 将我们的jar包上传上去，并且填写相关信息，在Entry Class 地方填写主类的名称 top.young.wordcount.WordCount

项目会启动运行。

下文所有内容基本总结于 《数据挖掘概念与技术 第三版》机械工业出版社

最近复习数据挖掘课程，就把复习的几个算法记录一下。

什么是Apriori算法

Apriori算法是 Agrawal 和 R.Srikant 与1994 提出的，为布尔关联规则挖掘频繁项集的原创性算法。Apriori算法使用一宗称为逐层搜索的迭代方法，其中 k 项集用于探索 (k+1) 项。

基本为扫描数据库，累计每个项的计数，并且收集满足最小支持度的项，找出频繁1项集的集合。该集合记为L1。然后，使用L1找出频繁2项集的集合L2，如此一直找下去，知道不能再找到频繁k项集，找出每个Lk需要一次数据库的完整扫描。

寻找频繁项集

先验性质

为了提高频繁项集逐层产生的效率，一种称为先验性质的重要性质用于压缩搜索空间。

先验性质：频繁项集的所有非空子集也一定是频繁的。

该表是一个事务数据库D。该数据库有9个事务，即|D|=9。假设最小支持度为2

1. 在算法第一次迭代的时候，每个项都是候选1项集的集合C1的成员。算法扫描，统计出每个项出现的次数。

2. 可以确定频繁1项集的集合L1，它由满足最小支持段的候选1项集组成。

3. 为发现频繁2项集的集合L2，算法使用L1 🔗 L1产生候选2项集的集合C2。注意剪枝，没有候选的C2中删除，因为这些候选的每个子集也是频繁的。

4. 扫描D中的事务，累计C2中的每个候选项集的支持技术。

5. 然后确定频繁2项集的集合L2，它由C2中满足最小支持度的候选2项集组成。

6. …………

重复以上步骤，直到Cn = ∅，此算法终止，找出所有的频繁项集。

由频繁项集产生关联规则

一旦由数据库D中的事务找出频繁项集，就可以直接由它们产生强关联规则。对于置信度，可以用下面的公式计算。

confidence(A ＝>B) = P（A | B）= support_count(A ∪ B) / support_count(A)

继续使用上面的案例，该数据包含频繁项集 x = {I1,I2,I5},可有X产生哪些关联规则，并且计算{I1,I2},{I1,I5},{I1}置信度

产生的关联规则

{I1,I2},{I1,I5},{I2,I5},{I1},{I2},{I5}

{I1,I2} => I5, confidence = 2 / 4 = 50%

{I1,I5} => I2, confidence = 2 / 2 = 100%

在推荐系统中有很多算法，其中一种就是协同过滤算法。

分类

在协同过滤算法中，分为两类，基于用户的协同过滤(UserCF)和基于物品的协同过滤(ItemCF)。每个类型的适用情况不同。

在上述的两种类型中，基于用户的协同过滤算法是不太常用的，原因如下

• 用户的数量是远远大于物品的数量，计算用户之间的相似度计算量会很大。
• 对于一个新用户很难找到相似度

所以一般是不会使用基于用户的协同过滤，但是并不表示不用，一般用于新闻推送等。

相似度计算

离散图表示

目前有五个用户对商品1和商品2的喜爱程度，分析用户之间的关系。

寻找他们的相似度

通过离散图来进行表示

可以看出 用户1 用户3 用户4 之间是存在关系的。

# coding = utf8
import matplotlib.pyplot as plt
import numpy as np

# 散点图分析五个用户之间的相关程度
# x轴为对于商品 1 的喜欢程度
# y轴是对于商品 2 的喜欢程度
# 数据如下
# 商品1 [3.3, 5.8, 3.6, 3.4, 5.2]
# 商品2 [6.5, 2.6, 6.3, 5.8, 3.1]

shop1 = [3.3, 5.8, 3.6, 3.4, 5.2]
shop2 = [6.5, 2.6, 6.3, 5.8, 3.1]
color = ['r', 'b', 'c', 'g', 'y', 'k', 'm', '0xff0012']
for i in range(0, len(shop1)):
    plt.scatter(shop1[i], shop2[i], c=color[i])
plt.xlim(0, 10)
plt.ylim(0, 10)
plt.ylabel("shopping 2")
plt.xlabel("shopping 1")
plt.legend('12345')
plt.show()

欧几里得距离

欧几里得距离是最常用的距离公式,用于计算两点之间的距离。公式如下：

通过计算两点之间的距离来表示他们之间的相关程度。

我们通过 python 计算 欧几里得距离。

# coding = utf8

#        1    2     3   4   5
shop1 = [3.3, 5.8, 3.6, 3.4, 5.2]
shop2 = [6.5, 2.6, 6.3, 5.8, 3.1]
for i in range(0, len(shop1) - 1):
    for j in range(i + 1, len(shop2)):
        distance = (shop1[i] - shop1[j]) ** 2 + (shop2[i] - shop2[j]) ** 2
        correlation = 1 / (1 + distance) # 将范围缩小至0 ~ 1 之间
        if correlation > 0.60:  # 根据需求更换相关系数
            print("第 {} and {}  distance is {}".format(i + 1, j + 1, correlation))

计算结果

第 1 和 2 相关系数是 0.04452359750667854

第 1 和 3 相关系数是 0.8849557522123891

第 1 和 4 相关系数是 0.6666666666666665

第 1 和 5 相关系数是 0.061842918985776124

第 2 和 3 相关系数是 0.051203277009728626

第 2 和 4 相关系数是 0.058823529411764705

第 2 和 5 相关系数是 0.6211180124223604

第 3 和 4 相关系数是 0.7751937984496123

第 3 和 5 相关系数是 0.07246376811594203

第 4 和 5 相关系数是 0.08673026886383348

得出结论，基本和离散图相似。

这样就可以根据需求来判断用户之间的相似度。

皮尔逊相关系数

皮尔逊相关系数同样也是计算距离的一种方式

通过相关系数可以计算出他们的相关程度。

适用范围

皮尔逊相关系数是有一定的适用条件。

当两个变量的标准差都不为零时，相关系数才有定义，皮尔逊相关系数适用于： (1)、两个变量之间是线性关系，都是连续数据。 (2)、两个变量的总体是正态分布，或接近正态的单峰分布。 (3)、两个变量的观测值是成对的，每对观测值之间相互独立。

同样这个算法也是有缺陷的,但数据越少的时候,波动性越大。当数据很少的时候不建议使用。

皮尔逊相关系数公式有四个

公式一：

公式二：

公式三：

公式四：

相关系数

• 0.8-1.0 极强相关
• 0.6-0.8 强相关
• 0.4-0.6 中等程度相关
• 0.2-0.4 弱相关
• 0.0-0.2 极弱相关或无相关

我们通过第四个公式进行计算

简单案例

通过 python 计算出相关系数

# coding=utf8


# 皮尔孙相关系数计算
def PearsonCorrelationSimilarity(vec1, vec2):
    value = range(len(vec1))

    sum_vec1 = sum([vec1[i] for i in value])
    sum_vec2 = sum([vec2[i] for i in value])

    square_sum_vec1 = sum([pow(vec1[i], 2) for i in value])
    square_sum_vec2 = sum([pow(vec2[i], 2) for i in value])

    product = sum([vec1[i] * vec2[i] for i in value])

    numerator = product - (sum_vec1 * sum_vec2 / len(vec1))
    dominator = ((square_sum_vec1 - pow(sum_vec1, 2) / len(vec1)) * (
        square_sum_vec2 - pow(sum_vec2, 2) / len(vec2))) ** 0.5

    if dominator == 0:
        return 0
    result = numerator / (dominator * 1.0)

    return result


if __name__ == '__main__':
    # 五个用户对五个商品的评价
    user1 = [3.3, 5.8, 3.6, 3.4, 5.2]
    user2 = [6.5, 2.6, 6.3, 5.8, 3.1]
    user3 = [5.5, 3.2, 6.5, 4.7, 4.4]
    user4 = [4.4, 6.2, 2.3, 5.1, 3.3]
    user5 = [2.1, 5.2, 4.2, 2.2, 4.1]

    userlist = [user1, user2, user3, user4, user5]
    for i in range(0, len(userlist) - 1):
        for j in range(i + 1, len(userlist)):
            result = PearsonCorrelationSimilarity(userlist[i], userlist[j])
            print "user%d 和 user%d 的相关系数是%f" % (i + 1, j + 1, result)

user1 和 user2 的相关系数是0.999774

user1 和 user3 的相关系数是-0.847758

user1 和 user4 的相关系数是-0.841816

user1 和 user5 的相关系数是-0.915237

user2 和 user3 的相关系数是-0.841741

user2 和 user4 的相关系数是-0.835320

user2 和 user5 的相关系数是-0.909975

user3 和 user4 的相关系数是0.998987

user3 和 user5 的相关系数是0.976272

user4 和 user5 的相关系数是0.969782

通过计算出来的结果可以看出来等到的结果

余弦距离

余弦相似度用向量空间中两个向量夹角的余弦值作为衡量两个个体间差异的大小。余弦值越接近1，就表明夹角越接近0度，也就是两个向量越相似，这就叫"余弦相似性"。

公式

一般余弦定理这个公式运用与文本分析。

分别采用下列的文本进行

示例

A：这里距离北京有多远，火车多长时间

B:北京离这里有多远，坐火车多长时间

对A，B进行分词

A:这里/距离/北京/有/多远，火车/多长/时间

B:北京/离/这里/有/多远，坐/火车/多长/时间

列出所有的词

这里 距离 北京 有 多远 火车 多长 时间 离 坐

进行词频统计

A: 这里(1)距离(1)北京(1)有(1)多远(1)火车(1)多长(1)时间(1)离(0)坐(0)

B: 这里(1)距离(0)北京(1)有(1)多远(1)火车(1)多长(1)时间(1)离(1)坐(1)

计算句子的词频向量

A (1,1,1,1,1,1,1,1,0,0)

B (1,0,1,1,1,1,1,1,1,1)

通过余弦定理计算相似度

# coding=utf8

import math

# 余弦定理
def cos(v1, v2):
    l = 0.0
    for i in range(0, len(v1)):
        l += v1[i] * v2[i]
    v = 0.0
    w = 0.0
    for i in range(0, len(v1)):
        v += math.pow(v1[i], 2)
        w += math.pow(v2[i], 2)
    cos = l / (math.sqrt(v) * math.sqrt(w))
    return cos

if __name__ == '__main__':
    v1 = [1, 1, 1, 1, 1, 1, 1, 1, 0, 0]
    v2 = [1, 0, 1, 1, 1, 1, 1, 1, 1, 1]
    l = cos(v1, v2)
    print l

计算出的相似度为：

0.824957911384

说明这两句话基本相等

这是一些基本的相似度计算方法。