2015-05-27 16:57:57 zdy0_2004 阅读数 7049
  • Python数据分析机器学习)经典案例实战

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 使用Python数据分析流行的库Numpy,Pandas,Matplotlib, Scikit-learn结合真实数据集展开可视化特征分析与机器学习建模和评估。每次课程涉及一个完整的案例,基于案例讲解python库的使用以及如何建立机器学习模型,对涉及到的机器学习算法给出通俗易懂的解释,帮助大家掌握经典机器学习算法,并应用在实际的案例中。

    9042 人正在学习 去看看 唐宇迪

【原创】机器学习之PageRank算法应用与C#实现(2)球队排名应用与C#代码

  在上一篇文章:机器学习之PageRank算法应用与C#实现(1)算法介绍 中,对PageRank算法的原理和过程进行了详细的介绍,并通过一个很简单的例子对过程进行了讲解。从上一篇文章可以很快的了解PageRank的基础知识。相比其他一些文献的介绍,上一篇文章的介绍非常简洁明了。说明:本文的主要内容都是来自“赵国,宋建成.Google搜索引擎的数学模型及其应用,西南民族大学学报自然科学版.2010,vol(36),3”这篇学术论文。鉴于文献中本身提供了一个非常简单容易理解和入门的案例,所以本文就使用文章的案例和思路来说明PageRank的应用,文章中的文字也大部分是复制该篇论文,个人研究是对文章的理解,以及最后一篇的使用C#实现该算法的过程,可以让读者更好的理解如何用程序来解决问题。所以特意对作者表示感谢。如果有认为侵权,请及时联系我,将及时删除处理。

  论文中的案例其实是来源于1993年全国大学生数学建模竞赛的B题—足球队排名问题。

本文原文链接:【原创】机器学习之PageRank算法应用与C#实现(2)球队排名应用与C#代码

1.足球队排名问题

  1993年的全国大学生数学建模竞赛B题就出了这道题目,不过当时PageRank算法还没有问世,所以现在用PageRank来求解也只能算马后炮,不过可以借鉴一下思路,顺便可以加深对算法的理解,并可以观察算法实际的效果怎么样。顺便说一下,全国大学生数学建模竞赛的确非常有用,我在大学期间,连续参加过2004和2005年的比赛,虽然只拿了一个省二等奖,但是这个过程对我的影响非常大。包括我现在的编程,解决问题的思路都是从建模培训开始的。希望在校大学生珍惜这些机会,如果能入选校队,参加集训,努力学习,对以后的学习,工作都非常有帮助。下面看看这个题目的具体问题:

具体数据由于篇幅较大,已经上传为图片,需要看的,点击链接:数据链接

2.利用PageRank算法的思路

2.1 问题分析

  足球队排名次问题要求我们建立一个客观的评估方法,只依据过去一段时间(几个赛季或几年)内每个球队的战绩给出各个球队的名次,具有很强的实际背景.通过分析题中12支足球队在联赛中的成绩,不难发现表中的数据残缺不全,队与队之间的比赛场数相差很大,直接根据比赛成绩来排名次比较困难。

  下面我们利用PageRank算法的随机冲浪模型来求解.类比PageRank算法,我们可以综合考虑各队的比赛成绩为每支球队计算相应的等级分(Rank),然后根据各队的等级分高低来确定名次,直观上看,给定球队的等级分应该由它所战胜和战平的球队的数量以及被战胜或战平的球队的实力共同决定.具体来说,确定球队Z的等级分的依据应为:一是看它战胜和战平了多少支球队;二要看它所战胜或战平球队的等级分的高低.这两条就是我们确定排名的基本原理.在实际中,若出现等级分相同的情况,可以进一步根据净胜球的多少来确定排名.由于表中包含的数据量庞大,我们先在不计平局,只考虑获胜局的情形下计算出各队的等级分,以说明算法原理。然后我们综合考虑获胜局和平局,加权后得到各队的等级分,并据此进行排名。考虑到竞技比赛的结果的不确定性,我们最后建立了等级分的随机冲浪模型,分析表明等级分排名结果具有良好的参数稳定性。

2.2 获取转移概率矩阵

   首先利用有向赋权图的权重矩阵来表达出各队之间的胜负关系.用图的顶点表示相应球队,用连接两个顶点的有向边表示两队的比赛结果。同时给边赋权重,表明占胜的次数。所以,可以得到数据表中给出的12支球队所对应的权重矩阵,这是计算转义概率矩阵的必要步骤,这里直接对论文中的截图进行引用:

2.3 关于加权等级分

  上述权重不够科学,在论文中,作者提出了加权等级分,就是考虑平局的影响,对2个矩阵进行加权得到权重矩阵,从而得到转移概率矩阵。这里由于篇幅比较大,但是思路比较简单,不再详细说明,如果需要详细了解,可以看论文。本文还是集中在C#的实现过程。

2.4 随机冲浪模型

  

3.C#编程实现过程

  下面我们将使用C#实现论文中的上述过程,注意,2.3和2.2的思想是类似的,只不过是多了一个加权的过程,对程序来说还是很简单的。下面还是按照步骤一个一个来,很多人看到问题写程序很难下手,其实习惯就好了,按照算法的步骤来,一个一个实现,总之要先动手,不要老是想,想来想去没有结果,浪费时间。只有实际行动起来,才能知道实际的问题,一个一个解决,持之以恒,思路会越来越清晰。

3.1 计算权重矩阵

  权重矩阵要根据测试数据,球队和每2个球队直接的比分来获取,所以我们使用一个字典来存储原始数据,将每个节点,2个队伍的比赛结果比分都写成数组的形式,来根据胜平负的场次计算积分,得到边的权重,看代码吧:

复制代码
 1 /// <summary>根据比赛成绩,直接根据积分来构造权重矩阵,根据i,对j比赛获取的分数</summary>
 2 /// <param name="data">key为2个对的边名称,value是比分列表,分别为主客进球数</param>
 3 /// <param name="teamInfo">球队的编号列表</param>
 4 /// <returns>权重矩阵</returns>
 5 public static double[,] CalcLevelTotalScore(Dictionary<String, Int32[][]> data, List<Int32> teamInfo)
 6 {
 7     Int32 N = teamInfo.Count;
 8     double[,] result = new double[N, N];
 9 
10     #region 利用对称性,只计算一半
11     for (int i = 1; i < N; i++)
12     {
13         for (int j = i + 1; j <= N; j++)
14         {
15             #region 循环计算
16             String key = String.Format("{0}-{1}", teamInfo[i - 1], teamInfo[j - 1]);
17             //不存在比赛成绩
18             if (!data.ContainsKey(key))
19             {
20                 result[i - 1, j - 1] = result[j - 1, i - 1] = 0;
21                 continue;
22             }
23             //计算i,j直接的互胜场次
24             var scores = data[key];//i,j直接的比分列表
25             var Si3 = scores.Where(n => n[0] > n[1]).ToList();//i胜场次
26             var S1 = scores.Where(n => n[0] == n[1]).ToList();//i平场次
27             var Si0 = scores.Where(n => n[0] < n[1]).ToList();//i负场次
28             result[i - 1, j - 1] = Si3.Count*3 + S1.Count ;
29             result[j - 1, i - 1] = Si0.Count *3 + S1.Count ;
30             #endregion
31         }
32     }
33     #endregion
34     //按照列向量进行归一化
35     return GetNormalizedByColumn(result);
36 }
复制代码

  上面最后返回调用了归一化的函数,比较简单,直接代码贴出来,折叠一下:

 View Code

3.2 计算最大特征值及特征向量

  计算特征值和特征向量是一个数学问题,我们采用了Math.NET数学计算组件,可以直接计算很方便。详细的使用可以参考下面代码,组件的其他信息可以参考本站导航栏上的专题目录,有大量的使用文章。看代码吧。

复制代码
 1 /// <summary>求最大特征值下的特征向量</summary>
 2 /// <param name="data"></param>
 3 /// <returns></returns>
 4 public static double[] GetEigenVectors(double[,] data)
 5 {
 6     var formatProvider = (CultureInfo)CultureInfo.InvariantCulture.Clone();
 7     formatProvider.TextInfo.ListSeparator = " ";
 8 
 9     int N = data.GetLength(0);
10     Matrix<double> A = DenseMatrix.OfArray(data);
11     var evd = A.Evd();
12     var vector = evd.EigenVectors;//特征向量
13     var ev = evd.EigenValues;//特征值,复数形式发
14 
15     if (ev[0].Imaginary > 0) throw new Exception("第一个特征值为复数");
16     //取 vector 第一列为最大特征向量
17     var result = new double[N];
18     for (int i = 0; i < N; i++)
19     {
20         result[i] =Math.Abs(vector[i, 0]);//第一列,取绝对值
21     }
22     return result;
23 }
复制代码

3.3 随机冲浪模型的实现

  随机冲浪模型主要是有一个比例,设置之后可以直接求解,也比较简单,函数如下:

复制代码
 1 /// <summary>获取随机冲浪模型的 转移矩阵:
 2 /// 作用很明显,结果有明显的改善
 3 /// </summary>
 4 /// <returns></returns>
 5 public static double[,] GetRandomModeVector(double[,] data ,double d = 0.35)
 6 {
 7     int N = data.GetLength(0);
 8     double k = (1.0 - d) / (double)N;
 9     double[,] result = new double[N, N];
10     for (int i = 0; i < N; i++)
11     {
12         for (int j = 0; j < N; j++) result[i, j] = data[i, j] * d + k;
13     }
14     return result;
15 }
复制代码

3.4 其他

  其他问题就是数据组合的过程,这里太多,不详细讲解。主要是构建测试数据以及排序后结果的处理,很简单。贴一个球队排序的函数,根据特征向量:

复制代码
 1 /// <summary>排序,输出球队编号</summary>
 2 /// <param name="w"></param>
 3 /// <param name="teamInfo"></param>
 4 /// <returns></returns>
 5 public static Int32[] TeamOrder(double[] w, List<Int32> teamInfo)
 6 {
 7     Dictionary<int, double> dic = new Dictionary<int, double>();
 8     for (int i = 1; i <= w.Length; i++) dic.Add(i , w[i-1]);
 9     return dic.OrderByDescending(n => n.Value).Select(n => n.Key).ToArray();
10 }
复制代码

4.算法测试

  我们使用问题1中的数据,进行测试,首先构建测试集合,代码如下,太长,折叠一下,主要是问题1的原始数据:

 View Code

测试的主要方法是:

复制代码
1 var team = new List<Int32>(){1,2,3,4,5,6,7,8,9,10,11,12};
2 var data = GetTestData();
3 var k3 = CalcLevelScore3(data,team);
4 var w3 = GetEigenVectors(k3);
5 
6 var teamOrder = TeamOrder(w3,team);
7 Console.WriteLine(teamOrder.ArrayToString());
复制代码

排序结果如下:

7,3,1,9,8,2,10,4,6,5,12,11

结果和论文差不多,差别在前面2个,队伍7和3的位置有点问题。具体应该是计算精度的关系如果前面的计算有一些精度损失的话,对后面的计算有一点点影响。

  PageRank的一个基本应用今天就到此为止,接下来如果大家感兴趣,我将继续介绍PageRank在球队排名和比赛预测结果中的应用情况。看时间安排,大概思路和本文类似,只不过在细节上要处理一下。



如果您觉得阅读本文对您有帮助,请点一下“推荐”按钮,您的“推荐”将是我最大的写作动力!欢迎各位转载,但是未经作者本人同意,转载文章之后必须在文章页面明显位置给出作者和原文连接,否则保留追究法律责任的权利。

.NET技术爱好者,彩票分析预测

本文原始作者博客http://www.cnblogs.com/asxinyu

E-mail:1287263703@qq.com

2018-09-29 10:47:00 weixin_34166472 阅读数 212
  • Python数据分析机器学习)经典案例实战

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 使用Python数据分析流行的库Numpy,Pandas,Matplotlib, Scikit-learn结合真实数据集展开可视化特征分析与机器学习建模和评估。每次课程涉及一个完整的案例,基于案例讲解python库的使用以及如何建立机器学习模型,对涉及到的机器学习算法给出通俗易懂的解释,帮助大家掌握经典机器学习算法,并应用在实际的案例中。

    9042 人正在学习 去看看 唐宇迪

零起点PYTHON足彩大数据与机器学习实盘分析

第1章 足彩与数据分析 1

1.1 “阿尔法狗”与足彩 1

1.2 案例1-1:可怕的英国足球 3

1.3 关于足彩的几个误区 7

1.4 足彩·大事件 8

1.5 大数据图灵(足彩)原则 10

1.6 主要在线彩票资源 11

1.7 主要在线足彩数据源 15

1.8 足彩基础知识 17

1.9 学习路线图 18

 

第2章 开发环境 19

2.1 数据分析首选Python 19

==================================

==================================

下载地址:https://pan.baidu.com/s/1to1Ct6soEjixWuDT8k98EA

关注微信公众号获取提取码:

  输入:py22  获取提取码  

转载于:https://www.cnblogs.com/kuoAT/p/9722459.html

2019-04-03 23:46:24 weixin_42341153 阅读数 35
  • Python数据分析机器学习)经典案例实战

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 使用Python数据分析流行的库Numpy,Pandas,Matplotlib, Scikit-learn结合真实数据集展开可视化特征分析与机器学习建模和评估。每次课程涉及一个完整的案例,基于案例讲解python库的使用以及如何建立机器学习模型,对涉及到的机器学习算法给出通俗易懂的解释,帮助大家掌握经典机器学习算法,并应用在实际的案例中。

    9042 人正在学习 去看看 唐宇迪

在极大似然估计和矩估计中,我们都将待估参数θ\theta视为参数空间Θ\Theta的一个未知常数(或常向量),我们坚信这些参数的信息只是由样本携带,于是通过对样本“毫无偏见”的加工,得到参数估计,而后按照判别好坏的标准对估计量进行分析,但事实上,参数θ\theta本身就是一个随机变量。
既然我们将参数θΘ\theta\in\Theta视为一个取值于Θ\Theta的随机变量,如果是连续型随机变量,则便有一个随机密度,记为h(θ)h(\theta),称为参数θ\theta先验分布
设样本X1,X2,...,XnX_1,X_2,...,X_n出自总体XX,并设F(x;θ)F(x;\theta)XX的分布函数,样本的联合分布F(x1,x2,...,xn;θ)=i=1nF(xi;θ)F(x_1,x_2,...,x_n;\theta)=\prod_{i=1}^nF(x_i;\theta)
在贝叶斯估计中,已知θ\theta的条件下,上述样本联合分布函数实际是条件分布,即它的相应形式为F(x1,x2,...,xnθ)=i=1nF(xi;θ)F(x_1,x_2,...,x_n|\theta)=\prod_{i=1}^nF(x_i;\theta)
同理对于样本密度也是条件密度,可有类似的记法,即f(x1,x2,...,xnθ)=i=1nF(xi;θ)f(x_1,x_2,...,x_n|\theta)=\prod_{i=1}^nF(x_i;\theta)
对于离散型的总体,其联合概率也是条件概率 P(x1,x2,...,xnθ)=i=1nF(xi;θ)P(x_1,x_2,...,x_n|\theta)=\prod_{i=1}^nF(x_i;\theta)

θ^θ\hat\theta是\theta的估计量,由于θ^θ\hat\theta与\theta或多或少会有一些距离,我们可以定义一个非负的二元函数L(θ^,θ)L(\hat\theta,\theta),称为在用θ^θ\hat\theta估计\theta时的损失函数。通常最常用的是所谓二次损失函数:L(θ^,θ)=(θ^θ)2L(\hat\theta,\theta)=(\hat\theta-\theta)^2
显然L(θ^,θ)L(\hat\theta,\theta)越小,表明我们的估计越好,但是这里θ^θ\hat\theta与\theta都是随机变量,因此我们所希望的“小”,只能从概率的意义上来说,也就是“平均损失”要小。考虑样本和参数的联合分布g(x1,x2,...xn;θ)=g(x1,x2,...,xnθ)h(θ)g(x_1,x_2,...x_n;\theta)=g(x_1,x_2,...,x_n|\theta)h(\theta)
于是我们有贝叶斯估计的定义如下:

对于θ\theta的一个估计θ^=θ^(X1,X2,...,Xn)\hat\theta=\hat\theta(X_1,X_2,...,X_n),记R(θ^)=Rn×θL(θ,θ^(x1,x2,...,xn))g(x1,x2,...,xnθ)h(θ)dx1dx2dxndθR(\hat\theta)=\int\int_{R^n\times\theta}L(\theta,\hat\theta(x_1,x_2,...,x_n))\bullet{g(x_1,x_2,...,x_n|\theta)h(\theta)}dx_1dx_2\cdot\cdot\cdot{dx_n}d\theta,称R(θ^)θ^R(\hat\theta)是估计量\hat\theta的贝叶斯风险,并称使得贝叶斯风险最小的估计θ^0\hat\theta_0R(θ^0)=minR(θ^)R(\hat\theta_0)=minR(\hat\theta)θ\theta的贝叶斯估计。

解法,简记x=(x1,x2,...,xn),dx=dx1dx2...dxnx=(x_1,x_2,...,x_n),dx=dx_1dx_2...dx_n对风险两遍关于θ^\hat\theta求导得,有R(θ^)θ^=2ΘX(θθ^(x))g(xθ)h(θ)dxdθ\frac{\partial{R(\hat\theta)}}{\partial{\hat\theta}}=2\int\int_{\Theta\cap{X}}(\theta-\hat\theta(x))g(x|\theta)h(\theta)dxd\theta
令右式等0,且积分可变换顺序,得ΘXθg(xθ)h(θ)dθdx=ΘXθ^(x)g(xθ)h(θ)dθdx=Rnθ^(x)dxΘg(x,θ)dθ\int\int_{\Theta\cap{X}}\theta{g(x|\theta)}h(\theta)d\theta{dx}=\int\int_{\Theta\cap{X}}\hat\theta(x)g(x|\theta)h(\theta)d\theta{dx}=\int_{R^n}\hat\theta(x)dx\int_{\Theta}g(x,\theta)d\theta
显然若令θ^=Θθh(θx)dθ\hat\theta=\int_{\Theta}\theta{h}(\theta|x)d\theta,其中h(θx)=h(θx1,x2,...,xn)=g(xθ)h(θ)Θg(xθ)h(θ)dθh(\theta|x)=h(\theta|x_1,x_2,...,x_n)=\frac{g(x|\theta)h(\theta)}{\int_{\Theta}g(x|\theta)h(\theta)d{\theta}}
将上面结果带入到上上式子中,即知θ^0\hat\theta_0是它的解,亦即θ^0θ\hat\theta_0是\theta贝叶斯估计。而θ^o=Θθh(θx)dθ\hat\theta_o=\int_{\Theta}\theta{h}(\theta|x)d\theta正是随机变量θ\theta的条件期望,以此作为估计值就是贝叶斯估计的方法
于是我们知,在二次损失函数下,θ\theta的贝叶斯估计θ^0\hat\theta_0,即为θ\theta的后验期望值,是在条件密度下求得的期望,即为条件期望E(θX1,X2,...,Xn)E(\theta|X_1,X_2,...,X_n),简记估计量θ^0=E(θX)θ^0=E(θx)\hat\theta_0=E(\theta|X)或估计值\hat\theta_0=E(\theta|x)。所以有

θ^=E(θX1,X2,...,Xn)θ称条件期望\hat\theta=E(\theta|X_1,X_2,...,X_n)为\theta的**贝叶斯估计量**

2015-05-07 22:15:38 zdy0_2004 阅读数 739
  • Python数据分析机器学习)经典案例实战

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 使用Python数据分析流行的库Numpy,Pandas,Matplotlib, Scikit-learn结合真实数据集展开可视化特征分析与机器学习建模和评估。每次课程涉及一个完整的案例,基于案例讲解python库的使用以及如何建立机器学习模型,对涉及到的机器学习算法给出通俗易懂的解释,帮助大家掌握经典机器学习算法,并应用在实际的案例中。

    9042 人正在学习 去看看 唐宇迪

考虑到知识的复杂性,连续性,将本算法及应用分为3篇文章,请关注,将在本月逐步发表。

1.机器学习之PageRank算法应用与C#实现(1)算法介绍

2.机器学习之PageRank算法应用与C#实现(2)球队排名应用与C#代码

3.机器学习之PageRank算法应用与C#实现(3)球队实力排名应用与C#代码 

  Pagerank是Google排名运算法则(排名公式)的一部分,是Google用于用来标识网页的等级/重要性的一种方法,是Google用来衡量一个网站的好坏的唯一标准。在揉合了诸如Title标识和Keywords标识等所有其它因素之后,Google通过PageRank来调整结果,使那些更具“等级/重要性”的网页在搜索结果中令网站排名获得提升,从而提高搜索结果的相关性和质量。鉴于Google的巨大成功和PageRank的巨大作用,已经入学了机器学习的十大算法之一。今天就带大家走近PageRank,简述其原理以及应用的C#实现。由于个人是专业做足球赛事预测,所以应用就拿足球胜平负的预测作为例子了。原理和过程都差不多,看大家如何分析问题了。

  鉴于PageRank算法的资料很多,也很成熟,所以相关的介绍和原理部分就直接引用了相关著作上面的话,在应用部分是个人的代码和思路,引用原始出处已经标明。

本文原文地址:http://www.cnblogs.com/asxinyu/p/4452979.html 

1.PageRank算法介绍

  PageRank,简称为PR值,又称网页级别、Google左侧排名或佩奇排名。Pagerank取自Google的创始人LarryPage,它是Google排名运算法则的一部分,Pagerank是Google对网页重要性的评估,是Google用来衡量一个网站的好坏的唯一标准。Google通过PageRank来调整结果,使那些更具“重要性”的网页在搜索结果中另网站排名获得提升,从而提高搜索结果的相关性和质量。PR值的级别从1到10级,10级为满分。PR值越高说明该网页越受欢迎。

  PageRank这个概念引自学术中一篇论文的被引述的频度——即被别人引述的次数越多,一般判断这篇论文的权威性就越高。Google有一套自动化方法来计算这些投票。Google的PageRank分值从0到10;PageRank为10表示最佳,但非常少见,类似里氏震级(Richterscale),PageRank级别也不是线性的,而是按照一种指数刻度。这是一种奇特的数学术语,意思是PageRank4不是比PageRank3好一级——而可能会好6到7倍。因此,一个PageRank5的网页和PageRank8的网页之间的差距会比你可能认为的要大的多。PageRank较高的页面的排名往往要比PageRank较低的页面高,而这导致了人们对链接的着魔。在整个SEO社区,人们忙于争夺、交换甚至销售链接,它是过去几年来人们关注的焦点,以至于Google修改了他的系统,并开始放弃某些类型的链接。比如,被人们广泛接受的一条规定,来自缺乏内容的“linkfarm”(链接工厂)网站的链接将不会提供页面的PageRank,从PageRank较高的页面得到链接但是内容不相关(比如说某个流行的漫画书网站链接到一个叉车规范页面),也不会提供页面的PageRank。Google选择降低了PageRank对更新频率,以便不鼓励人们不断的对其进行监测。

http://baike.haosou.com/doc/5496980-5734893.html

2.PageRank算法原理

  PageRank算法是Google搜索引擎对检索结果的一种排序算法.它的基本思想主要是来自传统文献计量学中的文献引文分析,即一篇文献的质量和重要性可以通过其它文献对其引用的数量和引文质量来衡量,也就是说,一篇文献被其它文献引用越多,并且引用它的文献的质量越高,则该文献本身就越重要.Google在给出页面排序时也有两条标准:一是看有多少超级链接指向它;二是要看超级链接指向它的那个页面重要不重要.这两条直观的想法就是PageRank算法的数学基础,也是Google搜索引擎最基本的工作原理.PageRank算法利用了互联网独特的超链接结构.在庞大的超链接资源中,Google提取出上亿个超级链接页面进行分析,制作出一个巨大的网络地图.具体的讲,就是把所有的网页看作图里面相应的顶点,如果网页A有—个指向网页B的链接,则认为一条从顶点A到顶点B的有向边.这样就可以利用图论来研究网络的拓扑结构.PageRank算法正是利用网络的拓扑结构来判断网页的重要性.具体来说,假如网页A有—个指向网页B的超链接,Google就认为网页A投了网页B一票,说明网页A认为网页B有链接价值,因而B可能是—个重要的网页.Google根据指向网页B的超链接数及其重要性来判断页面B的重要性,并赋予相应的页面等级值(PageRank).网页A的页面等级值被平均分画己给网页A所链接指向的网页,从而当网页A的页面等级值比较高时,则网页B可从网页A到它的超链接分得一定的重要性.根据这样的分析,得到了高评价的重要页面会被赋予较高的网页等级,在检索结果内的排名也会较高.页面等级值(PageRank)是Google表示网页重要性的综合性指标,而且不会受到不同搜索引擎的影响.当然,重要性高的页面如果和检索关键词无关同样也没有任何意义.为此,Google使用了完善的超文本匹配分析技术,使得能够检索出重要而且正确的网页.

[1].上述引用“赵国,宋建成.Google搜索引擎的数学模型及其应用,西南民族大学学报自然科学版.2010,vol(36),3”

3.PageRank算法基本过程

  这一节我们还是采用赵国那篇论文的简单例子,介绍PageRank的简单过程以及对应的随机冲浪模型,可以让你加深对算法的理解,同时这也是编写代码的重要依据。

PageRank算法的具体实现可以利用网页所对应的图的邻接矩阵来表达超链接关系。因此要先写出所对应图的邻接矩阵 A ,为了能将网页的页面等级值平均分配给该网页所链接指向的网页,需要对各个行向量进行归一化处理,得到矩阵A1。PageRank算法的矩阵是将归一化矩阵A1转置所得矩阵W,称之为 转移概率矩阵(是不是和马尔可夫链有点像,的确是与马尔可夫链过程有着密切的关系),其特征是各个列列向量之和为全概率1,各个行矢量表示状态之间的转移概率,转置的原因是PageRank算法重视的某个页面被多少个页面链接,而不是链接到多少个页面。各个网页的页面等级制就是求这个转义概率矩阵W的最大特征值所属的特征向量。因此可以看出,PageRank的应用也主要是对某些过程对象进行重要等级排名。

  例如,先假设有下面的图邻接矩阵:

为了能将网页的页面等级值平均分配给该网页所链接指向的网页,对各个行向量进行归一化处理,得:

将归一化所得的矩阵转置,所得到的转移概率矩阵W:

 根据上述公式和转移概率矩阵,可以求得其最大特征值为:

对应的非负特征向量为:

因此可以确定网页的排序为C,A,B,而A,C的排序并没有很显著的差别,但是由于指向C的链接多一些,所以可以考虑排在前面。至于其中的特征值计算和非负特征向量,是一个比较简单的线性代数问题,如果不懂的可以去查下资料,本博客也有相应的Math.NET数学组件可以借鉴,可以很容易的解决这些基础的问题,链接看菜单导航。

4.随机冲浪模型

  随机冲浪模型(Random Surfer Model)是为了更加的符合实际情况而对上述PageRank基本模型进行的改进。PageRank算法原理中假设所有的网页形成一个闭合的链接图,除了这些文档以外没有其他任何链接的出入,并且每个网页能从其他网页通过超链接达到.但是在现实的网络中,并不完全是这样的情况.当一个页面没有出链的时候,它的PageRank值就不能被分配给其它的页面。同样道理,只有出链接而没有入链接的页面也是存在的。但PageRank并不考虑这样的页面.在现实中的页面,无论怎样顺着链接前进,仅仅顺着链接是绝对不能进入的页面群总归是存在的。所以为了解决这个问题,提出了用户的随机冲浪模型:用户虽然在大多数情况下都顺着当前页面中的链接前进,但也有少数情况会突然重新打开浏览器随机进入到完全无关的页面。这样就可以用公式表示相应的概率矩阵:

 

 

 

 

还是考虑第3节中的问题,我们取d=0.5,可以计算相应的概率转移矩阵为:

计算得到其最大特征值为1,相应的特征向量为:

所以排序的结果C,A,B合理一些,也更加符合实际情况。

接下来我们将通过上述论文中的一个例子来介绍PageRank的实际应用与C#实现过程,请关注博客。

下一篇文章地址:机器学习之PageRank算法应用与C#实现(2)在足球队排名中的应用



如果您觉得阅读本文对您有帮助,请点一下“推荐”按钮,您的“推荐”将是我最大的写作动力!欢迎各位转载,但是未经作者本人同意,转载文章之后必须在文章页面明显位置给出作者和原文连接,否则保留追究法律责任的权利。

.NET技术爱好者,彩票分析预测

本文原始作者博客http://www.cnblogs.com/asxinyu

E-mail:1287263703@qq.com

2018-10-07 17:25:00 m0_37591671 阅读数 2203
  • Python数据分析机器学习)经典案例实战

    购买课程后,可扫码进入学习群,获取唐宇迪老师答疑 使用Python数据分析流行的库Numpy,Pandas,Matplotlib, Scikit-learn结合真实数据集展开可视化特征分析与机器学习建模和评估。每次课程涉及一个完整的案例,基于案例讲解python库的使用以及如何建立机器学习模型,对涉及到的机器学习算法给出通俗易懂的解释,帮助大家掌握经典机器学习算法,并应用在实际的案例中。

    9042 人正在学习 去看看 唐宇迪

基于WPF实现双色球

1.实现思路:

分析:双色球由六个红色号码和一个蓝色号码组成;红色球号码从01–33中选择,而且不能重复;蓝色球号码从01–16中选择(可以跟红球重复)。
(1)点击开始按钮,开启七个线程,获取数据
(2)由于前六个的数据不一样,所以应当将获得的数据与除了当前Lable外的其他Lable内容进行比较,如果重复,则需要重新获取;否则,显示
(3)当点击停止按钮,等待所有线程执行完,显示结果

2.实现代码:

(1)点击后,开启线程执行:

        private bool IsGoon = true;
        private static object _Lock = new object();
        private void Image_MouseDown(object sender, MouseButtonEventArgs e)
        {

            try
            {
                Image image = (Image)sender;
                if (image.Source.ToString().Equals("pack://application:,,,/DoubleChromosphere;component/Images/click.png"))
                {
                    this.IsGoon = true;
                    image.Source = new BitmapImage(new Uri("Images/stop.jpg", UriKind.RelativeOrAbsolute));
                    //foreach (UIElement element in LayoutRoot.Children)
                    //{
                    //    if (element is Label)
                    //    {
                    //        ((Label)element).Content = "00";
                    //    }
                    //}
                    Thread.Sleep(500);
                    TaskFactory taskFactory = new TaskFactory();
                    List<Task> taskList = new List<Task>();
                    foreach (UIElement element in LayoutRoot.Children)
                    {
                        if (element is Label)
                        {
                            Label lbl = element as Label;
                            taskList.Add(taskFactory.StartNew(() =>
                            {
                                while (this.IsGoon)
                                {
                                    string text = "";
                                    if (this.Dispatcher.Invoke(() => { return lbl.Name.Contains("red"); }))

                                    {
                                        //1 解决冲突的最好办法,是没有冲突,上来就随机分6组,每个线程只取一个组的
                                        //2 线程安全的集合,出一个进一个
                                        //3 每次先找出6个不同的球,然后分配给线程
                                        //4 每次线程随意获取球,更新前检测下有没有冲突,有则重新随机,没有则更新
                                        text = this.GetRandomText();
                                        lock (_Lock)
                                        {
                                            List<string> redList = this.Dispatcher.Invoke(() => GetUsedRed(lbl));
                                            if (redList.Contains(text))
                                                continue;
                                            else
                                            {
                                                Thread.Sleep(50);//让停止的时候,线程可能在这里
                                                this.UpdateLable(lbl, text);
                                            }
                                        }
                                    }
                                    else
                                    {
                                        int index = RandomHelper.GetRandomNumber(0, 16);
                                        //Random random = new Random();//伪随机
                                        //string text = this.BlueNums[random.Next(0, 15)];
                                        //int index = RandomHelper.GetRandomNumber(0, 16);
                                        text = this.BlueNums[index];
                                        //lbl.Text = text;//不行
                                        this.UpdateLable(lbl, text);
                                    }

                                    //this.UpdateLable(lbl, text);
                                    Thread.Sleep(50);
                                }
                            }));
                        }
                    }
                    //所有线程执行完,展示结果
                    taskFactory.ContinueWhenAll(taskList.ToArray(), tList => this.ShowResult());

                    {

                    }
                }
                else
                {
                    image.Source = new BitmapImage(new Uri("Images/click.png", UriKind.Relative));
                    this.IsGoon = false;
                }



            }
            catch (Exception ex)
            {

                Console.WriteLine("双色球启动出现异常:{0}", ex.Message);
            }

        }

(2)获取随机号码代码:

        private string GetRandomText()
        {
            int index = RandomHelper.GetRandomNumber(0, 33);
            return this.RedNums[index];
        }
    public class RandomHelper
    {
        /// <summary>
        /// 获取随机数
        /// </summary>
        /// <param name="min">能出现的最小值</param>
        /// <param name="max">不会出现</param>
        /// <returns></returns>
        public static int GetRandomNumber(int min, int max)
        {
            Guid guid = Guid.NewGuid();
            string sGuid = guid.ToString();
            int seed = DateTime.Now.Millisecond;
            for (int i = 0; i < sGuid.Length; i++)
            {
                switch (sGuid[i])
                {
                    case 'a':
                    case 'b':
                    case 'c':
                    case 'd':
                    case 'e':
                    case 'f':
                    case 'g':
                        seed = seed + 1;
                        break;
                    case 'h':
                    case 'i':
                    case 'j':
                    case 'k':
                    case 'l':
                    case 'm':
                    case 'n':
                        seed = seed + 2;
                        break;
                    case 'o':
                    case 'p':
                    case 'q':
                    case 'r':
                    case 's':
                    case 't':
                        seed = seed + 3;
                        break;
                    case 'u':
                    case 'v':
                    case 'w':
                    case 'x':
                    case 'y':
                    case 'z':
                        seed = seed + 3;
                        break;
                    default:
                        seed = seed + 4;
                        break;
                }
            }
            Random random = new Random(seed);
            return random.Next(min, max);
        }
    }

(3)获取已经存在的数据代码

 private List<string> GetUsedRed(Label lbl)
        {
            List<string> usedList = new List<string>();
            foreach (var labItem in LayoutRoot.Children)
            {
                if (labItem is Label && labItem != lbl)//当前的数字可以用
                {
                    usedList.Add(((Label)labItem).Content.ToString());
                }
            }
            return usedList;
        }

(4)更新Lable内容代码

 private void UpdateLable(Label lbl, string text)
        {
            this.Dispatcher.Invoke(new Action(() =>
            {
                lbl.Content = text;
            }));
        }

(5)展示结果代码:

 private void ShowResult()
        {
            this.Dispatcher.Invoke(() =>
            {
                MessageBox.Show(string.Format("本期双色球结果为:{0} {1} {2} {3} {4} {5}  蓝球{6}"
, this.labred1.Content
, this.labred2.Content
, this.labred3.Content
, this.labred4.Content
, this.labred5.Content
, this.labred6.Content
, this.lab7.Content));
                foreach (UIElement element in LayoutRoot.Children)
                {
                    if (element is Label)
                    {
                        ((Label)element).Content = "00";
                    }
                }
            }
            );
        }

(6)数据:

 #region Data
        /// <summary>
        /// 红球集合
        /// </summary>
        private string[] RedNums =
        {
            "01","02","03","04","05","06","07","08","09","10",
            "11","12","13","14","15","16","17","18","19","20",
            "21","22","23","24","25","26","27","28","29","30",
            "31","32","33"
        };

        /// <summary>
        /// 蓝球集合
        /// </summary>
        private string[] BlueNums =
        {
            "01","02","03","04","05","06","07","08","09","10",
            "11","12","13","14","15","16"
        };
#endregion

3.源代码

基于WPF实现双色球

没有更多推荐了,返回首页