从item-base到svd再到rbm多种协同过滤算法从原理到实现

一.引入

一直想写一篇关于推荐系统的文章总结下,这次借着完善DML写一下,权当是总结了。不过真正的推荐系统当然不会这么简单,往往是很多算法交错在一起,本文只是入门水平的总结罢了。 (本文所用测试数据是movielens100k)

本文采用的评测标准是RMSE,数值越小算法越好,在movielens100k 的 u1数据上对每个要求预测的评分输出训练集总的平均分,其RMSE是:

二.Item Based and User Based

1.原理

Item-based和User-Based是CF算法中最基础的两个了,其算法思想很intuitive:

User-based就是把与你有相同爱好的用户所喜欢的物品(并且你还没有评过分)推荐给你

Item-based则与之相反,把和你之前喜欢的物品近似的物品推荐给你:

更一般的,我们此次使用的数据集是要求你预测某个用户对某个item的评分,以Item-based为例,使用上面提到的算法思想就是检测该用户评过的所有物品和待预测物品的相似度,而两个物品的相似度我们可以找出所有同时对两个物品进行评价的评分,然后计算其皮尔逊相似度,按照相似度计算加权平均值即可,具体过程可以看下面的实现(和《集体智慧编程》中的类似)

2.实现

[python] view plaincopy

  1. from __future__ import division
  2. import numpy as np
  3. import scipy as sp
  4. class Item_based_C:
  5. def __init__(self,X):
  6. self.X=np.array(X)
  7. print "the input data size is ",self.X.shape
  8. self.movie_user={}
  9. self.user_movie={}
  10. self.ave=np.mean(self.X[:,2])
  11. for i in range(self.X.shape[0]):
  12. uid=self.X[i][0]
  13. mid=self.X[i][1]
  14. rat=self.X[i][2]
  15. self.movie_user.setdefault(mid,{})
  16. self.user_movie.setdefault(uid,{})
  17. self.movie_user[mid][uid]=rat
  18. self.user_movie[uid][mid]=rat
  19. self.similarity={}
  20. pass
  21. def sim_cal(self,m1,m2):
  22. self.similarity.setdefault(m1,{})
  23. self.similarity.setdefault(m2,{})
  24. self.movie_user.setdefault(m1,{})
  25. self.movie_user.setdefault(m2,{})
  26. self.similarity[m1].setdefault(m2,-1)
  27. self.similarity[m2].setdefault(m1,-1)
  28. if self.similarity[m1][m2]!=-1:
  29. return self.similarity[m1][m2]
  30. si={}
  31. for user in self.movie_user[m1]:
  32. if user in self.movie_user[m2]:
  33. si[user]=1
  34. n=len(si)
  35. if (n==0):
  36. self.similarity[m1][m2]=1
  37. self.similarity[m2][m1]=1
  38. return 1
  39. s1=np.array([self.movie_user[m1][u] for u in si])
  40. s2=np.array([self.movie_user[m2][u] for u in si])
  41. sum1=np.sum(s1)
  42. sum2=np.sum(s2)
  43. sum1Sq=np.sum(s1**2)
  44. sum2Sq=np.sum(s2**2)
  45. pSum=np.sum(s1*s2)
  46. num=pSum-(sum1*sum2/n)
  47. den=np.sqrt((sum1Sq-sum1**2/n)*(sum2Sq-sum2**2/n))
  48. if den==0:
  49. self.similarity[m1][m2]=0
  50. self.similarity[m2][m1]=0
  51. return 0
  52. self.similarity[m1][m2]=num/den
  53. self.similarity[m2][m1]=num/den
  54. return num/den
  55. def pred(self,uid,mid):
  56. sim_accumulate=0.0
  57. rat_acc=0.0
  58. for item in self.user_movie[uid]:
  59. sim=self.sim_cal(item,mid)
  60. if sim<0:continue
  61. #print sim,self.user_movie[uid][item],sim*self.user_movie[uid][item]
  62. rat_acc+=sim*self.user_movie[uid][item]
  63. sim_accumulate+=sim
  64. #print rat_acc,sim_accumulate
  65. if sim_accumulate==0: #no same user rated,return average rates of the data
  66. return self.ave
  67. return rat_acc/sim_accumulate
  68. def test(self,test_X):
  69. test_X=np.array(test_X)
  70. output=[]
  71. sums=0
  72. print "the test data size is ",test_X.shape
  73. for i in range(test_X.shape[0]):
  74. pre=self.pred(test_X[i][0],test_X[i][1])
  75. output.append(pre)
  76. #print pre,test_X[i][2]
  77. sums+=(pre-test_X[i][2])**2
  78. rmse=np.sqrt(sums/test_X.shape[0])
  79. print "the rmse on test data is ",rmse
  80. return output

sim_cal()为相似度计算,pred(uid,mid)预测uid号用户对mid号电影评分,然后我们在test()中计算RMSE,来看看结果:

可以看到与全部输出平均值比较有一定的提升,但是效果似乎并不好,因为这个算法确实有些简单,但是这个算法的思想对CF算法都很有指导意义。

三.matrix factorization model 和 Baseline Predictors

这里没有实现是因为下面的SVD其实就是matrix factorization model和Baseline Predictor的结合,所以为了方便我们先在这里介绍这两个东西.

1.matrix factorization model

把我们的用户评分想象成一个表:

每一行代表一个用户,每一列代表一个物品,这其实就是一个矩形,只是我们拥有的这个矩形可能是非常稀疏的,也就是我们知道的评分占总量很少,,但现在我们知道它是一个矩形,一个矩形自然可以表示为另两个矩形的乘积:

这也就是matrix factorization model的原理了,我们需要做的就是通过已有数据来学习右边的两个矩形,更intuitive的你可以把总的矩形里的每个评分看成是该用户的特征向量与物品特征向量的内积:(这里符号变得有些多,你理解了意思就成)

2.Baseline Predictors

Baseline Predictors就简单多了,我们设定μ是平均值,然后分别用bi和bu来代表具体用户和物品的“偏好”,也就是

这两个参数我们当然可以当成一个优化任务来计算,比如最小二乘:

也可以用比较快的方法来,因为实际上这就是经验似然:

四.SVD and ++ and so on

1.SVD及其衍生算法的原理

SVD算法其实就是上面介绍的matrix factorization的一种,加上baseline predictor算是一种优化而已,最简单的SVD是优化下面的Loss function:

采用随机梯度下降进行优化:

虽然看起来比较简单,但实际上对预测的效果已经超出Item-based很多了,而从SVD衍生出很多其它的算法,利用了更多的信息,我们在这里只予以介绍而不加实践。

SVD++

可以看到,SVD中并没有利用好一个用户评价了哪些电影这种信息,这代表无论评分高低,在看电影之前这些电影对他来说是有吸引力的,更一般的,如果你有用户查看过电影介绍的数据,同样也可以加以利用,SVD++就是加入了这些信息:

R(u)表示用户rate过的电影,这样加入参数后使模型更加复杂了,但其效果也就更好了,具体的优化过程就不贴了,反正还是那样,对Loss function求导而已。

timeSVD++

无论是netflix还是movielens的数据,它的最后一列是用户作出该评价的时间,timeSVD++就是将时间这个信息加以了利用,比较直观的理解就是影片的受欢迎程度可能是随着时间的变化而变化的,某些电影可能还具有周期性,如何加入这个信息呢?:

是pu成为一个随着时间变化而变化的参数:

2.SVD的实现

说了那么多高大上的衍生算法,我们还是来实现一下最基础的SVD吧:

[python] view

from __future__ import division

  1. import numpy as np
  2. import scipy as sp
  3. from numpy.random import random
  4. class SVD_C:
  5. def __init__(self,X,k=20):
  6. '''''
  7. k is the length of vector
  8. '''
  9. self.X=np.array(X)
  10. self.k=k
  11. self.ave=np.mean(self.X[:,2])
  12. print "the input data size is ",self.X.shape
  13. self.bi={}
  14. self.bu={}
  15. self.qi={}
  16. self.pu={}
  17. self.movie_user={}
  18. self.user_movie={}
  19. for i in range(self.X.shape[0]):
  20. uid=self.X[i][0]
  21. mid=self.X[i][1]
  22. rat=self.X[i][2]
  23. self.movie_user.setdefault(mid,{})
  24. self.user_movie.setdefault(uid,{})
  25. self.movie_user[mid][uid]=rat
  26. self.user_movie[uid][mid]=rat
  27. self.bi.setdefault(mid,0)
  28. self.bu.setdefault(uid,0)
  29. self.qi.setdefault(mid,random((self.k,1))/10*(np.sqrt(self.k)))
  30. self.pu.setdefault(uid,random((self.k,1))/10*(np.sqrt(self.k)))
  31. def pred(self,uid,mid):
  32. self.bi.setdefault(mid,0)
  33. self.bu.setdefault(uid,0)
  34. self.qi.setdefault(mid,np.zeros((self.k,1)))
  35. self.pu.setdefault(uid,np.zeros((self.k,1)))
  36. if (self.qi[mid]==None):
  37. self.qi[mid]=np.zeros((self.k,1))
  38. if (self.pu[uid]==None):
  39. self.pu[uid]=np.zeros((self.k,1))
  40. ans=self.ave+self.bi[mid]+self.bu[uid]+np.sum(self.qi[mid]*self.pu[uid])
  41. if ans>5:
  42. return 5
  43. elif ans<1:
  44. return 1
  45. return ans
  46. def train(self,steps=20,gamma=0.04,Lambda=0.15):
  47. for step in range(steps):
  48. print 'the ',step,'-th step is running'
  49. rmse_sum=0.0
  50. kk=np.random.permutation(self.X.shape[0])
  51. for j in range(self.X.shape[0]):
  52. i=kk[j]
  53. uid=self.X[i][0]
  54. mid=self.X[i][1]
  55. rat=self.X[i][2]
  56. eui=rat-self.pred(uid,mid)
  57. rmse_sum+=eui**2
  58. self.bu[uid]+=gamma*(eui-Lambda*self.bu[uid])
  59. self.bi[mid]+=gamma*(eui-Lambda*self.bi[mid])
  60. temp=self.qi[mid]
  61. self.qi[mid]+=gamma*(eui*self.pu[uid]-Lambda*self.qi[mid])
  62. self.pu[uid]+=gamma*(eui*temp-Lambda*self.pu[uid])
  63. gamma=gamma*0.93
  64. print "the rmse of this step on train data is ",np.sqrt(rmse_sum/self.X.shape[0])
  65. #self.test(test_data)
  66. def test(self,test_X):
  67. output=[]
  68. sums=0
  69. test_X=np.array(test_X)
  70. #print "the test data size is ",test_X.shape
  71. for i in range(test_X.shape[0]):
  72. pre=self.pred(test_X[i][0],test_X[i][1])
  73. output.append(pre)
  74. #print pre,test_X[i][2]
  75. sums+=(pre-test_X[i][2])**2
  76. rmse=np.sqrt(sums/test_X.shape[0])
  77. print "the rmse on test data is ",rmse
  78. return output

行数各种少有木有,我们测试一下:在向量长度k=30,执行轮数steps=25,参数gamma=0.04,Lambda=0.15

[python]

  1. a=SVD_C(train_X,30)
  2. a.train()
  3. a.test(test_X)

结果:

可以达到0.927左右,比之前的提高已经很多了,事实上如果你对参数进一步优化,并且增加向量大小和迭代步数,在movielens1M的数据上可以到到0.87左右的rmse,这就是最烦人的调参了,我就不在这里详述这种痛苦的经历了.......

五.CF with RBM

又到了相当的蛋疼RBM了,RBM的CF,单模型效果和SVD相似,只是error在不同的地方,所以结合起来可以提升效果,总觉得RBM不够intuitive,这次实现也遇到很多困难,所以这一节的质量不高,见谅

1.原理

首先……你得了解一下RBM……一个能量模型,Hinton的招牌作品,DeepLearning就是由这个火起来的(DBN)

这里我就不细讲RBM了,有兴趣大家找下面的ref看,直接看看CF FOR RBM这个模型吧:

严格来说这是condional RBM,基本思路是把V用softmax的形式表示成一个向量,然后去掉改用户没有评价的部分,作为RBM的V层,共用一个Hidden层,主要参数有:Vik,Wikj,Dij,vb(bias of visual layer), hb(bias of hidden)。

这是主要的学习过程:

看着是有点烦,但如果你看懂了这个结构,还是很简单明了的,与普通的RBM比较,只是在visible层的sample和update有一定的变化,主要体现在:a)sample一个v[item]的时候按随机值向上累计v[item][1...5],超过随机值的那个值设置为1,其它为0;b)update的时候按照softmax的格式来处理每一组v[item]。

2.实现

这个实现写了两三天了,而且目前效果不好,RMSE只能到0.98,不知道哪里出了问题,我已经排查过好几次了,不过还是发到这里希望大家能够帮我找出问题,代码可读性也不是很好,因为为了向量化使用了大量的切片操作,堪称丑陋,绝对没有一些C++版本的代码可读性好,但还是发在这里吧,希望有人能加以指正,万分感谢。sigh……

[python] view placopy

  1. from __future__ import division
  2. import numpy as np
  3. import scipy as sp
  4. from numpy.random import normal,random,uniform
  5. '''''
  6. this code still have some problem,I can only get 0.98 rmse on movielens data
  7. If you can figure it out,PLEASE!!! tell me .
  8. '''
  9. class TEMP:
  10. def __init__(self):
  11. self.AccVH=None
  12. self.CountVH=None
  13. self.AccV=None
  14. self.temp.CountV=None
  15. self.temp.AccH=None
  16. class CF_RMB_C:
  17. def __init__(self,X,UserNum=943,HiddenNum=30,ItemNum=1682,Rate=5):
  18. self.X=np.array(X)
  19. self.HiddenNum=HiddenNum
  20. self.ItemNum=ItemNum
  21. self.UserNum=UserNum
  22. self.Rate=Rate
  23. self.movie_user={}
  24. self.user_movie={}
  25. self.bik=np.zeros((self.ItemNum,self.Rate))
  26. self.Momentum={}
  27. self.Momentum['bik']=np.zeros((self.ItemNum,self.Rate))
  28. self.UMatrix=np.zeros((self.UserNum,self.ItemNum))
  29. self.V=np.zeros((self.ItemNum,self.Rate))
  30. for i in range(self.X.shape[0]):
  31. uid=self.X[i][0]-1
  32. mid=self.X[i][1]-1
  33. rat=self.X[i][2]-1
  34. self.UMatrix[uid][mid]=1
  35. self.bik[mid][rat]+=1
  36. self.movie_user.setdefault(mid,{})
  37. self.user_movie.setdefault(uid,{})
  38. self.movie_user[mid][uid]=rat
  39. self.user_movie[uid][mid]=rat
  40. pass
  41. self.W=normal(0,0.01,(self.ItemNum,self.Rate,HiddenNum))
  42. self.Momentum['W']=np.zeros(self.W.shape)
  43. self.initialize_bik()
  44. self.bj=np.zeros((HiddenNum,1)).flatten(1)
  45. self.Momentum['bj']=np.zeros(self.bj.shape)
  46. self.Dij=np.zeros((self.ItemNum,self.HiddenNum))
  47. self.Momentum['Dij']=np.zeros((self.ItemNum,self.HiddenNum))
  48. def initialize_bik(self):
  49. for i in range(self.ItemNum):
  50. total=np.sum(self.bik[i])
  51. if total>0:
  52. for k in range(self.Rate):
  53. if self.bik[i][k]==0:
  54. self.bik[i][k]=-10
  55. else:
  56. self.bik[i][k]=np.log(self.bik[i][k]/total)
  57. def test(self,test_X):
  58. output=[]
  59. sums=0
  60. test_X=np.array(test_X)
  61. #print "the test data size is ",test_X.shape
  62. for i in range(test_X.shape[0]):
  63. pre=self.pred(test_X[i][0]-1,test_X[i][1]-1)
  64. #print test_X[i][2],pre
  65. output.append(pre)
  66. #print pre,test_X[i][2]
  67. sums+=(pre-test_X[i][2])**2
  68. rmse=np.sqrt(sums/test_X.shape[0])
  69. print "the rmse on test data is ",rmse
  70. return output
  71. def pred(self,uid,mid):
  72. V=self.clamp_user(uid)
  73. pj=self.update_hidden(V,uid)
  74. vp=self.update_visible(pj,uid,mid)
  75. ans=0
  76. for i in range(self.Rate):
  77. ans+=vp[i]*(i+1)
  78. return ans
  79. def clamp_user(self,uid):
  80. V=np.zeros(self.V.shape)
  81. for i in self.user_movie[uid]:
  82. V[i][self.user_movie[uid][i]]=1
  83. return V
  84. def train(self,para,test_X,cd_steps=3,batch_size=30,numEpoch=100,Err=0.00001):
  85. for epo in range(numEpoch):
  86. print 'the ',epo,'-th epoch is running'
  87. kk=np.random.permutation(range(self.UserNum))
  88. bt_count=0
  89. while bt_count<=self.UserNum:
  90. btend=min(self.UserNum,bt_count+batch_size)
  91. users=kk[bt_count:btend]
  92. temp=TEMP
  93. temp.AccVH=np.zeros(self.W.shape)
  94. temp.CountVH=np.zeros(self.W.shape)
  95. temp.AccV=np.zeros(self.V.shape)
  96. temp.CountV=np.zeros(self.V.shape)
  97. temp.AccH=np.zeros(self.bj.shape)
  98. watched=np.zeros(self.UMatrix[0].shape)
  99. for user in users:
  100. watched[self.UMatrix[user]==1]=1
  101. sv=self.clamp_user(user)
  102. pj=self.update_hidden(sv,user)
  103. temp=self.accum_temp(sv,pj,temp,user)
  104. #AccVH+=pj*
  105. for step in range(cd_steps):
  106. sh=self.sample_hidden(pj)
  107. vp=self.update_visible(sh,user)
  108. sv=self.sample_visible(vp,user)
  109. pj=self.update_hidden(sv,user)
  110. deaccum_temp=self.deaccum_temp(sv,pj,temp,user)
  111. self.updateall(temp,batch_size,para,watched)
  112. #updateall============================================
  113. bt_count+=batch_size
  114. self.test(test_X)
  115. def accum_temp(self,V,pj,temp,uid):
  116. for i in self.user_movie[uid]:
  117. temp.AccVH[i]+=np.dot(V[i].reshape(-1,1),pj.reshape(1,-1))
  118. temp.CountVH[i]+=1
  119. temp.AccV[i]+=V[i]
  120. temp.CountV[i]+=1
  121. temp.AccH+=pj
  122. return temp
  123. def deaccum_temp(self,V,pj,temp,uid):
  124. for i in self.user_movie[uid]:
  125. temp.AccVH[i]-=np.dot(V[i].reshape(-1,1),pj.reshape(1,-1))
  126. temp.AccV[i]-=V[i]
  127. temp.AccH-=pj
  128. return temp
  129. def updateall(self,temp,batch_size,para,watched):
  130. delatW=np.zeros(temp.CountVH.shape)
  131. delatBik=np.zeros(temp.CountV.shape)
  132. delatW[temp.CountVH!=0]=temp.AccVH[temp.CountVH!=0]/temp.CountVH[temp.CountVH!=0]
  133. delatBik[temp.CountV!=0]=temp.AccV[temp.CountV!=0]/temp.CountV[temp.CountV!=0]
  134. delataBj=temp.AccH/batch_size
  135. self.Momentum['W'][temp.CountVH!=0]=self.Momentum['W'][temp.CountVH!=0]*para['Momentum']
  136. self.Momentum['W'][temp.CountVH!=0]+=para['W']*(delatW[temp.CountVH!=0]-para['weight_cost']*self.W[temp.CountVH!=0])
  137. self.W[temp.CountVH!=0]+=self.Momentum['W'][temp.CountVH!=0]
  138. self.Momentum['bik'][temp.CountV!=0]=self.Momentum['bik'][temp.CountV!=0]*para['Momentum']
  139. self.Momentum['bik'][temp.CountV!=0]+=para['bik']*delatBik[temp.CountV!=0]
  140. self.bik[temp.CountV!=0]+=self.Momentum['bik'][temp.CountV!=0]
  141. self.Momentum['bj']=self.Momentum['bj']*para['Momentum']
  142. self.Momentum['bj']+=para['bj']*delataBj
  143. self.bj+=self.Momentum['bj']
  144. for i in range(self.ItemNum):
  145. if watched[i]==1:
  146. self.Momentum['Dij'][i]=self.Momentum['Dij'][i]*para['Momentum']
  147. self.Momentum['Dij'][i]+=para['D']*temp.AccH/batch_size
  148. self.Dij[i]+=self.Momentum['Dij'][i]
  149. np.seterr(all='raise')
  150. def update_hidden(self,V,uid):
  151. r=self.UMatrix[uid]
  152. hp=None
  153. for i in self.user_movie[uid]:
  154. if hp==None:
  155. hp=np.dot(V[i],self.W[i]).flatten(1)
  156. else:
  157. hp+=np.dot(V[i],self.W[i]).flatten(1)
  158. pj=1/(1+np.exp(-self.bj-hp+np.dot(r,self.Dij).flatten(1)))
  159. #pj=1/(1+np.exp(-self.bj-hp))
  160. return pj
  161. def sample_hidden(self,pj):
  162. sh=uniform(size=pj.shape)
  163. for i in range(sh.shape[0]):
  164. if sh[i]<pj[i]:
  165. sh[i]=1.0
  166. else:
  167. sh[i]=0.0
  168. return sh
  169. def update_visible(self,sh,uid,mid=None):
  170. if mid==None:
  171. vp=np.zeros(self.V.shape)
  172. for i in self.user_movie[uid]:
  173. vp[i]=np.exp(self.bik[i]+np.dot(self.W[i],sh))
  174. vp[i]=vp[i]/np.sum(vp[i])
  175. return vp
  176. vp=np.exp(self.bik[mid]+np.dot(self.W[mid],sh))
  177. vp=vp/np.sum(vp)
  178. return vp
  179. def sample_visible(self,vp,uid):
  180. sv=np.zeros(self.V.shape)
  181. for i in self.user_movie[uid]:
  182. r=uniform()
  183. k=0
  184. for k in range(self.Rate):
  185. r-=vp[i][k]
  186. if r<=0:break
  187. sv[i][k]=1
  188. return sv

原文发布于微信公众号 - 大数据挖掘DT数据分析(datadw)

原文发表时间:2015-09-10

本文参与腾讯云自媒体分享计划,欢迎正在阅读的你也加入,一起分享。

发表于

我来说两句

0 条评论
登录 后参与评论

相关文章

来自专栏机器学习人工学weekly

机器学习人工学weekly-2018/4/29

链接:https://machinelearning.apple.com/2018/04/16/personalized-hey-siri.html?utm_c...

752
来自专栏专知

【专知荟萃14】机器翻译 Machine Translation知识资料全集(入门/进阶/综述/视频/代码/专家,附PDF下载)

【导读】主题荟萃知识是专知的核心功能之一,为用户提供AI领域系统性的知识学习服务。主题荟萃为用户提供全网关于该主题的精华(Awesome)知识资料收录整理,使得...

3556
来自专栏CVer

TensorFlow从入门到精通 | 预告篇

[TensorFlow从入门到精通]系列课程既包含TensorFlow的基础知识点(如Graph),还有卷积神经网络、模型的保存和恢复、迁移学习、Fine-Tu...

994
来自专栏欧阳大哥的轮子

地图开发知识之-投影坐标

由于地球是一个赤道略宽两极略扁的不规则的梨形球体,表面是一个不可展平的曲面,而地图通常是二维平面,因此在地图制图时首先要考虑把曲面转化成平面。然而,从几何意义上...

653
来自专栏人工智能头条

Top 50机器学习项目实战总结

1202
来自专栏SeanCheney的专栏

三本关于机器学习和深度学习的书

这几本在Amazon上的排名都非常高,最近特别火的书。 第一本:《用Scikit-Learn和TensorFlow实践机器学习》(Hands-On Machi...

3446
来自专栏大数据智能实战

基于tensorflow实现图像风格的变换

      Leon A. Gatys, Alexander S. Ecker, 和 Matthias Bethge 等人的论文“A Neural Algor...

1868
来自专栏AI研习社

AI 玩微信跳一跳的正确姿势——跳一跳 Auto-Jump 算法详解

最近,微信小游戏跳一跳可以说是火遍了全国,从小孩子到大孩子仿佛每一个人都在刷跳一跳,作为无(zhi)所(hui)不(ban)能(zhuan)的 AI 程序员,我...

3548
来自专栏Python小屋

Python使用折线图、柱状图、热力图比较不同班级相同学号学生的成绩

问题描述:有些学校的学号最后两位是根据入学成绩顺序排的,那么入学之后同学们的学习状态是否会有变化呢,入学成绩较好的同学是否能够一直保持优势呢,会不会有同学是高考...

745
来自专栏一心无二用,本人只专注于基础图像算法的实现与优化。

图像偏色检测算法,速度快,效果好,共享给大家。      式中 ,M、 N分别为图像的宽和高,以像素为单位。在 a - b色度平面上,等效圆的中心坐标为 ( da , db ) ,半径为 M 。等效

     本文的算法并不是我自己提出的,而是一些论文中提出的,详见 :      1、基于图像分析的偏色检测及颜色校正方法 徐晓昭 , 蔡轶珩 , 刘长江 , ...

2098

扫描关注云+社区