300字范文 > 大数据笔记--Spark机器学习（第二篇）

大数据笔记--Spark机器学习（第二篇）

时间：2020-11-27 15:15:10

一、梯度下降法

1、什么是梯度？

2、梯度下降法与梯度上升法

3、梯度下降法的直观解释

4、梯度下降法的相关概念

5、梯度下降法原理

6、梯度下降法的算法参数

7、梯度下降法-家族（BGD，SGD，MBGD）

8、总结

9、举例

二、推荐系统模型

1、什么是协同过滤

2、基于用户的推荐

3、基于物品的推荐

4、实现推荐算法

三、ALS算法与显示矩阵分解

1、概述

2、ALS算法原理

Ⅰ、过拟合的概念

四、案例-用户和电影推荐

1、小案例：

2、用户和电影推荐

五、推荐系统补充

1、推荐系统的冷启动问题

六、Jee-bigdata整体架构图

一、梯度下降法

1、什么是梯度？

在微积分里面，对多元函数的参数求∂偏导数，把求得的各个参数的偏导数以向量的形式写出来，就是梯度。

比如函数f(x,y)，分别对x,y求偏导数，求得的梯度向量就是(∂f/∂x, ∂f/∂y)T,简称grad f(x,y)或者▽f(x,y)。

对于在点(x0,y0)的具体梯度向量就是(∂f/∂x0,∂f/∂y0)T.或者▽f(x0,y0)，如果是3个参数的向量梯度，就是(∂f/∂x,∂f/∂y，∂f/∂z)T,以此类推。

那么这个梯度向量求出来有什么意义呢？

他的意义从几何意义上讲，就是函数变化最快的地方。具体来说，对于函数f(x,y),在点(x0,y0)，沿着梯度向量的方向就是(∂f/∂x0,∂f/∂y0)T的方向是f(x,y)增加最快的地方。或者说，沿着梯度向量的方向，更加容易找到函数的最大值。反过来说，沿着梯度向量相反的方向，也就是-(∂f/∂x0,∂f/∂y0)T的方向，梯度减少最快，也就是更加容易找到函数的最小值。

2、梯度下降法与梯度上升法

在机器学习算法中，在求最小化损失函数时，可以通过梯度下降法来一步步的迭代求解，得到最小化的损失函数，和模型参数值。

反过来，如果我们需要求解损失函数的最大值，这时就需要用梯度上升法来迭代了。

3、梯度下降法的直观解释

比如我们在一座大山上的某处位置，由于我们不知道怎么下山，于是决定走一步算一步，也就是在每走到一个位置的时候，求解当前位置的梯度，沿着梯度的负方向，也就是当前最陡峭的位置向下走一步，然后继续求解当前位置梯度，向这一步所在位置沿着最陡峭最易下山的位置走一步。这样一步步向谷底走下去。

从上面的解释可以看出，梯度下降不一定能够找到全局的最优解，有可能是一个局部最优解。当然，如果损失函数是凸函数，梯度下降法得到的解就一定是全局最优解。

4、梯度下降法的相关概念

①、步长：步长决定了在梯度下降迭代的过程中，每一步沿梯度负方向前进的长度。用上面下山的例子，步长就是在当前这一步所在位置沿着最陡峭最易下山的位置走的那一步的长度。

一般步长的选择：0.1~0.05。步长过小，迭代次数可能过多，收敛速度慢。步长过大，可能会错过最优解，围绕最优解震荡而不收敛。

②、特征：指的是样本中输入部分，比如样本（x0,y0），（x1,y1），则样本特征为x，样本输出为y。

③、假设函数：在监督学习中，为了拟合输入样本，而使用的假设函数，比如一个线性函数：

④、损失函数：为了评估模型拟合的好坏，通常用损失函数来度量拟合的程度。损失函数极小化，意味着拟合程度最好，对应的模型参数即为最优参数。在线性回归中，损失函数通常为样本输出和假设函数的差取平方

为了后续的求导运算方便，一般会乘以1/2

5、梯度下降法原理

①、先决条件：确认优化模型的假设函数和损失函数；

②、算法相关参数初始化：主要是初始化参数，算法终止距离以及步长。在没有任何先验知识的时候，可以将所有的参数初始化为0，将步长初始化为1，在调优时再优化；

③、算法过程

1）随机选择一个θ（θ1，θ2，……）的初始位置，
2）用步长乘以损失函数的梯度，得到当前位置下降的距离，并更新下降后的θ
3）多次迭代第二步，直至收敛于损失函数的极值
4）得到极值点对应的θ解

④、损失函数梯度的推导：

⑤、θi的更新表达式：

上述θi的更新表达式是在只有一个样本的情况下，我们接下来推广到更一般的情况，比如有n个样本：

即当前点的梯度方向是由所有的样本决定的。

6、梯度下降法的算法参数

①、算法的步长选择。

在前面的算法描述中，提到取步长为1，但是实际上取值取决于数据样本，可以多取一些值，从大到小，分别运行算法，看看迭代效果，如果损失函数在变小，说明取值有效。
步长太大，会导致迭代过快，甚至有可能错过最优解。步长太小，迭代速度太慢，很长时间算法都不能结束。所以算法的步长需要多次运行后才能得到一个较为优的值。

②、算法参数的初始值选择。

初始值不同，获得的最小值也有可能不同，因此梯度下降求得的只是局部最小值；当然如果损失函数是凸函数则一定是最优解。由于有局部最优解的风险，需要多次用不同初始值运行算法，关键损失函数的最小值，选择损失函数最小化的初值。

③、归一化。

由于样本不同特征的取值范围不一样，可能导致迭代很慢，为了减少特征取值的影响，可以对特征数据归一化。

7、梯度下降法-家族（BGD，SGD，MBGD）

①、批量梯度下降法（BatchGradientDescent）

批量梯度下降法，是梯度下降法最常用的形式，具体做法也就是在更新参数时使用所有的样本来进行更新。

②、随机梯度下降法（StochasticGradientDescent）

随机梯度下降法，和批量梯度下降法原理类似，区别在与求梯度时没有用所有的n个样本的数据，而是仅仅选取一个样本j来求梯度。
批量梯度下降法和随机梯度下降法是两个极端，一个采用所有数据来梯度下降，一个用一个样本来梯度下降。自然各自的优缺点都非常突出。
批量梯度下降法由于采用所有样本计算，所以收敛速度很快，即迭代很少次数就能够收敛到局部或全局最优解。而随机梯度是每次选取一个样本计算，所以收敛速度相比于批量来说就慢很多。
举个例子：比如批量法10次迭代后收敛，随机法则可能需要100次迭代。
但在海量数据下，使用批量法就不适合了
举个例子：因为数据量巨大，批量法可能迭代1次就需要20分钟，而随机法迭代一次只需要1ms
所以总的耗时：批量法=10*20*60*1000ms 随机法=100*1ms
对于训练速度来说，随机梯度下降法由于每次仅仅采用一个样本来迭代，训练速度很快，而批量梯度下降法在样本量很大的时候，训练速度不能让人满意。对于准确度来说，随机梯度下降法由于仅仅用一个样本决定梯度方向，导致解很有可能不是最优。对于收敛速度来说，由于随机梯度下降法一次迭代一个样本，导致迭代方向变化很大，不能很快的收敛到局部最优解。

③、MBGD小批量梯度下降法

结合了以上两种算法，应用没有随机梯度用的多
对于迭代类型的算法，除了梯度下降法以外，还有牛顿法

8、总结

梯度可以理解函数值变化最快的方向，即沿着梯度方向，可以更快的找到函数的极大值。沿着梯度的负方向，可以更快的找到函数的极小值。

有梯度上升法和梯度下降法。一般用的都是梯度下降法；因为通过梯度下降法，可以求解损失函数极小值点对应的系数解

举个例子来理解：

下图可以理解为某个目标方程对应的损失函数，最终目的时通过梯度下降法得到最小值对应的系数解。

算法过程：

1、随机选择一个Θ的初始位置
2、用步长（建模时程序员自己定的）*损坏函数的梯度，然后更新下降后的位置
3、多次迭代第二步，直到收敛于损失函数的极小值
4、获取极小值点对应的θ解

注意事项：

1、如果求解的损失函数说非凸的，则得到的可能是局部最优解，而不是全局最优解。解决方案是：做多次训练，找出损失值最小的那一次
2、如果求解的损失函数是凸函数，则得到的一定是全局最优解
3、收敛的概念，比如：
第1次迭代 RSS=80
第2次迭代 RSS=65
.........
第99次迭代 RSS=11
第100次迭代 RSS=10.9998
第101次迭代 RSS=10.9997
可以认为此时算法收敛了，然后获取RSS最小值对应的一组系数解
4、梯度下降法有三种，分别是：
①、批量梯度下降法（BGD）BatchGradientDescent
上式表达的含义式：每次更新系数时，是所有的样本（n个样本）都参与计算
优点：需要很少的迭代次数就可以收敛
缺点：不适用于大数据场景，因为每更新一次，计算代价极大且耗时很大
所以这种批量梯度下降法在生产环境下时不用的
②、随机梯度下降法（SGD）StochasticGradientDescent
每次更新系数时，随即从n个样本中选取一个参与计算。
优点：每次更新计算代价极小且时间极短，适用于大数据的场景
缺点：缺点更多次的迭代次数才能收敛
所以，SGD用于生产环境
③、小批量梯度下降法（MBGD）
相当于整合上述两种方法，每次更新系数时，选取一小批数据参与更新

9、举例

testSGD数据：

1,0 1
2,0 2
3,0 3
5,1 4
7,6 1
9,4 5
6,3 3

代码：

import org.apache.spark.SparkConfimport org.apache.spark.SparkContextimport org.apache.spark.mllib.regression.LabeledPointimport org.apache.spark.mllib.linalg.Vectorsimport org.apache.spark.mllib.regression.LinearRegressionWithSGD/*** 处理 data/ml/testSGD.txt文件* 1,0 12,0 23,0 3* 第一列是Y,第二列和第三列分别为X1和X2。建立一个多元线性回归模型，* 方程表达式:Y=θ1X1+θ2X2+θ0* 底层使用梯度下降法来求解出θ系数*/object Driver {def main(args: Array[String]): Unit = {val conf=new SparkConf().setMaster("local").setAppName("sgd")val sc=new SparkContext(conf)val data=sc.textFile("D://data/ml/testSGD.txt")//第一步:RDD[line:String]->RDD[LabeledPoint]val r1=data.map { line =>val info=line.split(",")val Y=info(0).toDoubleval XArr=info(1).split(" ").map { num => num.toDouble }LabeledPoint(Y,Vectors.dense(XArr))}//第二步:建模//1参:数据集 2参:最大迭代次数 3参:步长val model=LinearRegressionWithSGD.train(r1,10,0.05)//获取模型的自变量系数//Y=0.529X1+0.543X2val coef=model.weights//第三步:通过模型回代原样本集预测,要求传入的数据结构:RDD[Vector(X1,X2,...)]val predictResult=model.predict(r1.map { x => x.features })predictResult.foreach{println} } }

二、推荐系统模型

我们可以基于一种协同过滤的算法思想来实现推荐系统。利用大量的已有的用户偏好数据，来推荐用户未接触过的商品。核心思想就是计算相似度

1、什么是协同过滤

协同过滤是一种借助众包智慧的途径。它利用大量已有的用户偏好来估计用户对其未接触过的物品的喜好程度。其内在思想是相似度的定义。

在基于用户的方法的中，如果两个用户表现出相似的偏好（即对相同物品的偏好大体相同），那就认为他们的兴趣类似。要对他们中的一个用户推荐一个未知物品，便可选取若干与其类似的用户并根据他们的喜好计算出对各个物品的综合得分，再以得分来推荐物品。其整体的逻辑是，如果其他用户也偏好某些物品，那这些物品很可能值得推荐。

同样也可以借助基于物品的方法来做推荐。这种方法通常根据现有用户对物品的偏好或是评级情况，来计算物品之间的某种相似度。这时，相似用户评级相同的那些物品会被认为更相近。一旦有了物品之间的相似度，便可用用户接触过的物品来表示这个用户，然后找出和这些已知物品相似的那些物品，并将这些物品推荐给用户。同样，与已有物品相似的物品被用来生成一个综合得分，而该得分用于评估未知物品的相似度。

2、基于用户的推荐

记住一个词“志趣相投”，举个生活中的例子：

小王：哥们，我想去看看这个电影，你不是看了吗，怎么样？
小张：不怎地，陪女朋友去看的，她看得津津有味，我看了一小半就玩手机去了。小王：那最近有什么好看的电影吗？
小张：你去看《雷霆XX》吧，我看了不错，估计你也喜欢。
小王：好的。
这是一段日常生活中经常发生的对话，也是基于用户的协同过滤算法的基础。

用户1和用户3在选择偏好上更加相似。那么完全有理由相信用户1和用户3都选择了相同的物品1和物品5，那么将物品3向用户3推荐也是完全合理的。

用特定的计算方法扫描和指定目标相同的已有用户，根据给定的相似度对用户进行相似度计算，选择最高得分的用户并根据其已有的信息作为推荐结果从而反馈给用户

上图也是基于用户的推荐场景，核心是计算出用户和用户之间的相似度，然后完成推荐

3、基于物品的推荐

再记住一个词“物以类聚”。

小张：马上情人节快到了，我想给我女朋友买个礼物，但是不知道买什么，上次买了个赛车模型的差点被她骂死。
小王：哦？那你真是的，也不买点她喜欢的东西。她平时喜欢什么啊？
小张：她平时比较喜欢看动画片，特别是《机器猫》，没事就看几集。
小王：那我建议你给她买套机器猫的模型套装，绝对能让她喜欢。
小张：好主意，我试试
对于不熟悉的用户，在缺少特定用户信息的情况下，根据用户已有的偏好数据去推荐一个未知物品是合理的。这就是基于物品的推荐算法。

上图的核心就是计算物品与物品之间的相似度，然后完成推荐。

4、实现推荐算法

实现推荐系统的最基本前提，需要收集到用户的偏好数据，如下：

基于用户-物品的偏好矩阵，计算相似度，从而完成推荐。

但是在生产环境下，遇到的问题可能较为复杂，因为偏好矩阵往往是稀疏的，如下：

不能简单的将空缺数据置为0，会导致结果不准确。所以需要通过某种手段将空缺的数据预测出来（这一步才是难点和重点）

我们可以通过矩阵分解法，对原始的偏好矩阵（稀疏的）进行处理，

1、找一个低阶k，k的数量是程序员建模时自己指定的，k的大小需要满足小于U（用户数）和I（物品数），比如上图中，U=5，I=4，则k可以取1，2，3

2、当把K定好之后，然后会拆出两个因子矩阵。

3、两个因子矩阵的乘积就是原始偏好矩阵的近似

三、ALS算法与显示矩阵分解

1、概述

ALS交替最小二乘法

我们在实现推荐系统时，当要处理的那些数据是由用户所提供的自身的偏好数据，这些数据被称作显式偏好数据，由显示偏好数据建立的矩阵称为显式矩阵。这类数据包括如物品评级、赞、喜欢等用户对物品的评价。

这些数据可以转换为以用户为行、物品为列的二维矩阵。矩阵的每一个数据表示某个用户对特定物品的偏好。大部分情况下单个用户只会和少部分物品接触，所以该矩阵只有少部分数据非零（即该矩阵很稀疏）。在生产环境下，偏好矩阵一般的是稀疏的。

2、ALS算法原理

如何算得因子矩阵里的因子数值是ALS算法要解决的问题，这需要一个明确的可量化目标，ALS用每个元素重构误差的平方和来进行量化。

因为在原评级矩阵中，大量未知元是我们想推断的，所以这个重构误差是包含未知数的。而ALS算法的解决方案很简单：只计算已知打分的重构误差。

ALS的实现原理是迭代式求解一系列最小二乘回归问题。在每一次迭代时，固定用户因子矩阵或是物品因子矩阵中的一个，然后用固定的这个矩阵以及评级数据来更新另一个矩阵。之后，被更新的矩阵被固定住，再更新另外一个矩阵。如此迭代，直到模型收敛（或是迭代了预设好的次数）。

第1次迭代：RSS=80
第2次迭代：RSS=65
.......
第99次迭代：RSS=11
第100次迭代：RSS=10.9995
第101次迭代：RSS=10.99949-----算法收敛，获取到对应的那一组最优的因子解
随机化思想在很多算法中都有应用，如果有随机化的部分，一定需要多次迭代再结合损失函数来实现。

所以在MLlib的ALS算法中，首先对U或者I矩阵随机化生成，在每一次迭代时，固定用户因子矩阵或是物品因子矩阵中的一个，然后用固定的这个矩阵以及评级数据来更新另一个矩阵，然后利用被求取的矩阵对象去求随机化矩阵。最后两个对象相互迭代计算，直到模型收敛。

Ⅰ、过拟合的概念

在训练模型时，目标是使得模型的误差最小，即误差越小，模型拟合得越好。但有些时候，拟合得太好，就会造成过拟合。过拟合的结果：模型在实验环境下很准，但是一放到生产环境下就不准了，这种情况就是过拟合。

如果模型方程对数据拟合的过好，就可能会出现拟合情况。危害是：在实验环境变现较好，但放到生产环境泛型性很大，甚至失去实际的使用价值

四、案例-用户和电影推荐

1、小案例：

处理本地文件，实现用户商品推荐：

als.txt
1 11 2
1 12 3
1 13 1
1 14 0
第一列是用户id，第二列是物品id，第三列是用户对物品的评分

package cn.yang.alsimport org.apache.spark.SparkConfimport org.apache.spark.SparkContextimport org.apache.spark.mllib.recommendation.Ratingimport org.apache.spark.mllib.recommendation.ALSobject Driver {def main(args: Array[String]): Unit = {val conf = new SparkConf().setMaster("local").setAppName("als")val sc = new SparkContext(conf)val data = sc.textFile("D:/data/ml/als/als.txt")//第一步：为了满足建模需要，RDD[line:String]->RDD[Rating(uid,itemId,score)]val ratings = data.map{line=>val info=line.split(" ")val userId=info(0).toIntval itemId=info(1).toIntval score=info(2).toDouble Rating(userId,itemId,score)}// ratings.foreach { println}//第二步：建立推荐系统模型，底层通过ALS算法来求解//参数：数据集，隐藏因子k的数量，最大迭代次数：生产环境建议多一些，使其充分收敛//最后可以加λ，正则化参数，防止模型过拟合val model=ALS.train(ratings,3, 10,0.01)//下面表示为用户3推荐2个商品val user3Result=model.recommendProducts(3,2)user3Result.foreach {println}//下面表示为11号商品，推荐2个用户val item11Result=model.recommendUsers(11, 2)item11Result.foreach {println}//下面表示3号用户对12号商品的评分val u3Item12Predict=model.predict(3, 12)println(u3Item12Predict)}}

2、用户和电影推荐

对u.data（十万条数据）数据建立推荐系统模型，然后为789号用户推荐10部电影。
说明:文件格式:用户id 电影id score
注意分隔符是制表符
建模时,k:10~50,迭代次数:5~15

代码：

package cn.yang.alsmovieimport org.apache.spark.SparkConfimport org.apache.spark.SparkContextimport org.apache.spark.mllib.recommendation.Ratingimport org.apache.spark.mllib.recommendation.ALSobject Driver {def main(args: Array[String]): Unit = {val conf=new SparkConf().setMaster("local").setAppName("als")val sc=new SparkContext(conf)val data=sc.textFile("D://data/ml/als/u.data")//第一步:数据格式转换val ratings=data.map { line =>val info=line.split("\t")val userId=info(0).toIntval movieId=info(1).toIntval score=info(2).toDoubleRating(userId,movieId,score)}//第二步:建立推荐系统模型//隐藏因子k的数量不宜过大,避免产生过大的计算代价val model=ALS.train(ratings,50,10,0.01)//第三步:为789号用户推荐10部电影val u789Result=model.recommendProducts(789,10)//u789Result.foreach {println}//第四步:根据推荐结果+u.item文件(包含了电影信息),获取到推荐的电影名//整体思路://①先通过spark读取u.item //②把文件数据变为一个Map(电影id,电影名) //③从推荐结果中,根据电影id获取电影名val movieData=sc.textFile("D://data/ml/als/u.item")//collectAsMap方法:可以将RDD[(key,value)]->Map(key,value)val movieMap=movieData.map { line =>val info=line.split("\\|")val movieId=info(0).toIntval movieName=info(1)(movieId,movieName)}.collectAsMap//println(movieMap(345))val u789ResultParse=u789Result.map { rat => //获取用户idval userId=rat.user//获取商品idval movieId=rat.productval movieName=movieMap(movieId)//获取评分val score=rat.rating(userId,movieName,score)}u789ResultParse.foreach{println}//第五步:检验模型推荐的效果,本例中采用直观检验法。//处理思路：//第1步:先获取789号用户看过的所有电影//第2步:再获取789号用户最喜欢的前10部电影//第2步:用推荐的10部和他最喜欢的10部电影比对,看是否有相似的电影//keyBy的作用:以指定的规则为key来进行查找,下面代码表示以用户id为key进行查找//lookup的作用:传入具体查找的key//keyBy和lookup一般是成对出现的val u789Movies=ratings.keyBy { x => x.user }.lookup(789)//完成第二步,最后返回的数据RDD[(userId,movieName,score)]val u789Top10=u789Movies.sortBy{x=> -x.rating}.take(10).map { x =>(x.user,movieMap(x.product),x.rating) }//第六步:模型的存储,为了避免每次推荐时都重新训练模型,使用时仅需加载模型使用即可model.save(sc, "hdfs://hadoop01:9000/rec-result-1909")}}

结果如下：

从指定的目录,加载推荐系统模型,完成推荐

package cn.yang.alsmovie/*** 从指定的目录,加载推荐系统模型,完成推荐*/import org.apache.spark.SparkConfimport org.apache.spark.SparkContextimport org.apache.spark.mllib.recommendation.MatrixFactorizationModelobject LoadDriver {def cosArray(a1:Array[Double],a2:Array[Double])={val a1a2=a1 zip a2val fenzi=a1a2.map{x=>x._1*x._2}.sumval a1Fenmu=Math.sqrt(a1.map{x=>x*x}.sum)val a2Fenmu=Math.sqrt(a2.map{x=>x*x}.sum)val a1a2Cos=fenzi/(a1Fenmu*a2Fenmu)//返回计算得到的余弦距离a1a2Cos}def main(args: Array[String]): Unit = {val conf = new SparkConf().setMaster("local").setAppName("load")val sc = new SparkContext(conf)//加载模型val model=MatrixFactorizationModel.load(sc,"hdfs://hadoop01:9000/rec-result-1909")//目前Spark MLlib提供的ALS只支持基于用户的推荐,但没提供基于物品的推荐方式(需要程序员自己来实现)//基于物品的推荐指的是:根据物品来推荐物品,//比如某个用户看了一部123号电影,然后系统会推荐和123号电影相关的一些电影//实现思路://第1步:获取物品因子矩阵//第2步:获取123号电影的因子值数组//第3步:计算其他所有电影和123号电影的相似度(使用余弦距离来衡量)//第4步:根据相似度降序排序,返回最相关的前10部电影,从而完成基于物品的推荐//val userFactors=model.userFeatures 获取用户因子矩阵//第一步:获取物品因子矩阵//RDD[(movieId,电影的因子数组)]val movieFactors=model.productFeatures//第二步:获取123号电影的因子值数组//下面表示以电影id为key来查找val movie123Factor=movieFactors.keyBy{x=>x._1}.lookup(123).head._2//第三步:计算其他所有电影和123号电影的相似度(使用余弦距离来衡量)val movie123Coss=movieFactors.map{case(movieId,factor)=>//用当前电影的因子数组和123号电影的因子数组计算相似度val cos=cosArray(movie123Factor, factor) (movieId,cos)}//第四步:根据相似度降序排序,返回最相关的前10部电影,从而完成基于物品的推荐val top10=movie123Coss.sortBy{x=> -x._2}.take(11).drop(1)top10.foreach{println} }}

五、推荐系统补充

1、推荐系统的冷启动问题

用户冷启动、物品冷启动、系统冷启动

用户冷启动：
指的是由于后台没有新用户相关的偏好数据，所以最初无法实现个性化推荐。
这种问题称为用户的冷启动，所以需要想办法解决
解决方案：
①、注册时让用户选择感兴趣的方向，便于下一步推荐
②、根据用户的注册信息完成推荐
③、根据热搜排行榜的内容完成推荐
物品冷启动：
对于新物品，由于后台没有相关的用户对它的偏好数据，无法完成推荐。这个问题称为物品的冷启动。
解决方案：
①、在商铺首页或平台显著位置推送此商品，目的时让更多的用户对它产生一定量偏好数据
②、最初认为这个商品打分（可以高一些），最开始的打分可能不客观，但是随着时间的推移以及使用客户的增多，打分会越来越趋近于客观水平
系统冷启动：
初建系统时，没有用户量（用户数据），甚至没有商品数据，所以无法建立推荐系统，，这个问题可以认为是系统冷启动，所以首要的就是要解决数据源以及用户源的问题
解决数据源的手段：
①、通过爬虫爬取数据（高效廉价）
②、搜寻相关专业的数据
③、购买数据
④、利用之前相关的从业资源来解决