class_brick
class_brick

标签传播算法

标签传播算法（Label Propagation）及Python实现

[email protected]

http://blog.csdn.net/zouxy09

 

       众所周知，机器学习可以大体分为三大类：监督学习、非监督学习和半监督学习。监督学习可以认为是我们有非常多的labeled标注数据来train一个模型，期待这个模型能学习到数据的分布，以期对未来没有见到的样本做预测。那这个性能的源头--训练数据，就显得非常感觉。你必须有足够的训练数据，以覆盖真正现实数据中的样本分布才可以，这样学习到的模型才有意义。那非监督学习就是没有任何的labeled数据，就是平时所说的聚类了，利用他们本身的数据分布，给他们划分类别。而半监督学习，顾名思义就是处于两者之间的，只有少量的labeled数据，我们试图从这少量的labeled数据和大量的unlabeled数据中学习到有用的信息。

一、半监督学习

       半监督学习（Semi-supervised learning）发挥作用的场合是：你的数据有一些有label，一些没有。而且一般是绝大部分都没有，只有少许几个有label。半监督学习算法会充分的利用unlabeled数据来捕捉我们整个数据的潜在分布。它基于三大假设：

       1）Smoothness平滑假设：相似的数据具有相同的label。

       2）Cluster聚类假设：处于同一个聚类下的数据具有相同label。

       3）Manifold流形假设：处于同一流形结构下的数据具有相同label。

       例如下图，只有两个labeled数据，如果直接用他们来训练一个分类器，例如LR或者SVM，那么学出来的分类面就是左图那样的。如果现实中，这个数据是右图那边分布的话，猪都看得出来，左图训练的这个分类器烂的一塌糊涂、惨不忍睹。因为我们的labeled训练数据太少了，都没办法覆盖我们未来可能遇到的情况。但是，如果右图那样，把大量的unlabeled数据（黑色的）都考虑进来，有个全局观念，牛逼的算法会发现，哎哟，原来是两个圈圈（分别处于两个圆形的流形之上）！那算法就很聪明，把大圈的数据都归类为红色类别，把内圈的数据都归类为蓝色类别。因为，实践中，labeled数据是昂贵，很难获得的，但unlabeled数据就不是了，写个脚本在网上爬就可以了，因此如果能充分利用大量的unlabeled数据来辅助提升我们的模型学习，这个价值就非常大。

       半监督学习算法有很多，下面我们介绍最简单的标签传播算法（label propagation），最喜欢简单了，哈哈。

二、标签传播算法

       标签传播算法（label propagation）的核心思想非常简单：相似的数据应该具有相同的label。LP算法包括两大步骤：1）构造相似矩阵；2）勇敢的传播吧。

2.1、相似矩阵构建

       LP算法是基于Graph的，因此我们需要先构建一个图。我们为所有的数据构建一个图，图的节点就是一个数据点，包含labeled和unlabeled的数据。节点i和节点j的边表示他们的相似度。这个图的构建方法有很多，这里我们假设这个图是全连接的，节点i和节点j的边权重为：

       这里，α是超参。

       还有个非常常用的图构建方法是knn图，也就是只保留每个节点的k近邻权重，其他的为0，也就是不存在边，因此是稀疏的相似矩阵。

2.2、LP算法

       标签传播算法非常简单：通过节点之间的边传播label。边的权重越大，表示两个节点越相似，那么label越容易传播过去。我们定义一个NxN的概率转移矩阵P：

       Pij表示从节点i转移到节点j的概率。假设有C个类和L个labeled样本，我们定义一个LxC的label矩阵YL，第i行表示第i个样本的标签指示向量，即如果第i个样本的类别是j，那么该行的第j个元素为1，其他为0。同样，我们也给U个unlabeled样本一个UxC的label矩阵YU。把他们合并，我们得到一个NxC的soft label矩阵F=[YL;YU]。soft label的意思是，我们保留样本i属于每个类别的概率，而不是互斥性的，这个样本以概率1只属于一个类。当然了，最后确定这个样本i的类别的时候，是取max也就是概率最大的那个类作为它的类别的。那F里面有个YU，它一开始是不知道的，那最开始的值是多少？无所谓，随便设置一个值就可以了。

       千呼万唤始出来，简单的LP算法如下：

       1）执行传播：F=PF

       2）重置F中labeled样本的标签：FL=YL

       3）重复步骤1）和2）直到F收敛。

       步骤1）就是将矩阵P和矩阵F相乘，这一步，每个节点都将自己的label以P确定的概率传播给其他节点。如果两个节点越相似（在欧式空间中距离越近），那么对方的label就越容易被自己的label赋予，就是更容易拉帮结派。步骤2）非常关键，因为labeled数据的label是事先确定的，它不能被带跑，所以每次传播完，它都得回归它本来的label。随着labeled数据不断的将自己的label传播出去，最后的类边界会穿越高密度区域，而停留在低密度的间隔中。相当于每个不同类别的labeled样本划分了势力范围。

2.3、变身的LP算法

       我们知道，我们每次迭代都是计算一个soft label矩阵F=[YL;YU]，但是YL是已知的，计算它没有什么用，在步骤2）的时候，还得把它弄回来。我们关心的只是YU，那我们能不能只计算YU呢？Yes。我们将矩阵P做以下划分：

       这时候，我们的算法就一个运算：

       迭代上面这个步骤直到收敛就ok了，是不是很cool。可以看到FU不但取决于labeled数据的标签及其转移概率，还取决了unlabeled数据的当前label和转移概率。因此LP算法能额外运用unlabeled数据的分布特点。

       这个算法的收敛性也非常容易证明，具体见参考文献[1]。实际上，它是可以收敛到一个凸解的：

       所以我们也可以直接这样求解，以获得最终的YU。但是在实际的应用过程中，由于矩阵求逆需要O(n3)的复杂度，所以如果unlabeled数据非常多，那么I – PUU矩阵的求逆将会非常耗时，因此这时候一般选择迭代算法来实现。

三、LP算法的Python实现

       Python环境的搭建就不啰嗦了，可以参考前面的博客。需要额外依赖的库是经典的numpy和matplotlib。代码中包含了两种图的构建方法：RBF和KNN指定。同时，自己生成了两个toy数据库：两条长形形状和两个圈圈的数据。第四部分我们用大点的数据库来做实验，先简单的可视化验证代码的正确性，再前线。

       算法代码：

[python]  view plain  copy
  1. #***************************************************************************  
  2. #*   
  3. #* Description: label propagation  
  4. #* Author: Zou Xiaoyi ([email protected])  
  5. #* Date:   2015-10-15  
  6. #* HomePage: http://blog.csdn.net/zouxy09  
  7. #*   
  8. #**************************************************************************  
  9.   
  10. import time  
  11. import numpy as np  
  12.   
  13. # return k neighbors index  
  14. def navie_knn(dataSet, query, k):  
  15.     numSamples = dataSet.shape[0]  
  16.   
  17.     ## step 1: calculate Euclidean distance  
  18.     diff = np.tile(query, (numSamples, 1)) - dataSet  
  19.     squaredDiff = diff ** 2  
  20.     squaredDist = np.sum(squaredDiff, axis = 1) # sum is performed by row  
  21.   
  22.     ## step 2: sort the distance  
  23.     sortedDistIndices = np.argsort(squaredDist)  
  24.     if k > len(sortedDistIndices):  
  25.         k = len(sortedDistIndices)  
  26.   
  27.     return sortedDistIndices[0:k]  
  28.   
  29.   
  30. # build a big graph (normalized weight matrix)  
  31. def buildGraph(MatX, kernel_type, rbf_sigma = None, knn_num_neighbors = None):  
  32.     num_samples = MatX.shape[0]  
  33.     affinity_matrix = np.zeros((num_samples, num_samples), np.float32)  
  34.     if kernel_type == 'rbf':  
  35.         if rbf_sigma == None:  
  36.             raise ValueError('You should input a sigma of rbf kernel!')  
  37.         for i in xrange(num_samples):  
  38.             row_sum = 0.0  
  39.             for j in xrange(num_samples):  
  40.                 diff = MatX[i, :] - MatX[j, :]  
  41.                 affinity_matrix[i][j] = np.exp(sum(diff**2) / (-2.0 * rbf_sigma**2))  
  42.                 row_sum += affinity_matrix[i][j]  
  43.             affinity_matrix[i][:] /= row_sum  
  44.     elif kernel_type == 'knn':  
  45.         if knn_num_neighbors == None:  
  46.             raise ValueError('You should input a k of knn kernel!')  
  47.         for i in xrange(num_samples):  
  48.             k_neighbors = navie_knn(MatX, MatX[i, :], knn_num_neighbors)  
  49.             affinity_matrix[i][k_neighbors] = 1.0 / knn_num_neighbors  
  50.     else:  
  51.         raise NameError('Not support kernel type! You can use knn or rbf!')  
  52.       
  53.     return affinity_matrix  
  54.   
  55.   
  56. # label propagation  
  57. def labelPropagation(Mat_Label, Mat_Unlabel, labels, kernel_type = 'rbf', rbf_sigma = 1.5, \  
  58.                     knn_num_neighbors = 10, max_iter = 500, tol = 1e-3):  
  59.     # initialize  
  60.     num_label_samples = Mat_Label.shape[0]  
  61.     num_unlabel_samples = Mat_Unlabel.shape[0]  
  62.     num_samples = num_label_samples + num_unlabel_samples  
  63.     labels_list = np.unique(labels)  
  64.     num_classes = len(labels_list)  
  65.       
  66.     MatX = np.vstack((Mat_Label, Mat_Unlabel))  
  67.     clamp_data_label = np.zeros((num_label_samples, num_classes), np.float32)  
  68.     for i in xrange(num_label_samples):  
  69.         clamp_data_label[i][labels[i]] = 1.0  
  70.       
  71.     label_function = np.zeros((num_samples, num_classes), np.float32)  
  72.     label_function[0 : num_label_samples] = clamp_data_label  
  73.     label_function[num_label_samples : num_samples] = -1  
  74.       
  75.     # graph construction  
  76.     affinity_matrix = buildGraph(MatX, kernel_type, rbf_sigma, knn_num_neighbors)  
  77.       
  78.     # start to propagation  
  79.     iter = 0; pre_label_function = np.zeros((num_samples, num_classes), np.float32)  
  80.     changed = np.abs(pre_label_function - label_function).sum()  
  81.     while iter < max_iter and changed > tol:  
  82.         if iter % 1 == 0:  
  83.             print "---> Iteration %d/%d, changed: %f" % (iter, max_iter, changed)  
  84.         pre_label_function = label_function  
  85.         iter += 1  
  86.           
  87.         # propagation  
  88.         label_function = np.dot(affinity_matrix, label_function)  
  89.           
  90.         # clamp  
  91.         label_function[0 : num_label_samples] = clamp_data_label  
  92.           
  93.         # check converge  
  94.         changed = np.abs(pre_label_function - label_function).sum()  
  95.       
  96.     # get terminate label of unlabeled data  
  97.     unlabel_data_labels = np.zeros(num_unlabel_samples)  
  98.     for i in xrange(num_unlabel_samples):  
  99.         unlabel_data_labels[i] = np.argmax(label_function[i+num_label_samples])  
  100.       
  101.     return unlabel_data_labels  

       测试代码：

[python]  view plain  copy
  1. #***************************************************************************  
  2. #*   
  3. #* Description: label propagation  
  4. #* Author: Zou Xiaoyi ([email protected])  
  5. #* Date:   2015-10-15  
  6. #* HomePage: http://blog.csdn.net/zouxy09  
  7. #*   
  8. #**************************************************************************  
  9.   
  10. import time  
  11. import math  
  12. import numpy as np  
  13. from label_propagation import labelPropagation  
  14.   
  15. # show  
  16. def show(Mat_Label, labels, Mat_Unlabel, unlabel_data_labels):   
  17.     import matplotlib.pyplot as plt   
  18.       
  19.     for i in range(Mat_Label.shape[0]):  
  20.         if int(labels[i]) == 0:    
  21.             plt.plot(Mat_Label[i, 0], Mat_Label[i, 1], 'Dr')    
  22.         elif int(labels[i]) == 1:    
  23.             plt.plot(Mat_Label[i, 0], Mat_Label[i, 1], 'Db')  
  24.         else:  
  25.             plt.plot(Mat_Label[i, 0], Mat_Label[i, 1], 'Dy')  
  26.       
  27.     for i in range(Mat_Unlabel.shape[0]):  
  28.         if int(unlabel_data_labels[i]) == 0:    
  29.             plt.plot(Mat_Unlabel[i, 0], Mat_Unlabel[i, 1], 'or')    
  30.         elif int(unlabel_data_labels[i]) == 1:    
  31.             plt.plot(Mat_Unlabel[i, 0], Mat_Unlabel[i, 1], 'ob')  
  32.         else:  
  33.             plt.plot(Mat_Unlabel[i, 0], Mat_Unlabel[i, 1], 'oy')  
  34.       
  35.     plt.xlabel('X1'); plt.ylabel('X2')   
  36.     plt.xlim(0.0, 12.)  
  37.     plt.ylim(0.0, 12.)  
  38.     plt.show()    
  39.   
  40.   
  41. def loadCircleData(num_data):  
  42.     center = np.array([5.0, 5.0])  
  43.     radiu_inner = 2  
  44.     radiu_outer = 4  
  45.     num_inner = num_data / 3  
  46.     num_outer = num_data - num_inner  
  47.       
  48.     data = []  
  49.     theta = 0.0  
  50.     for i in range(num_inner):  
  51.         pho = (theta % 360) * math.pi / 180  
  52.         tmp = np.zeros(2, np.float32)  
  53.         tmp[0] = radiu_inner * math.cos(pho) + np.random.rand(1) + center[0]  
  54.         tmp[1] = radiu_inner * math.sin(pho) + np.random.rand(1) + center[1]  
  55.         data.append(tmp)  
  56.         theta += 2  
  57.       
  58.     theta = 0.0  
  59.     for i in range(num_outer):  
  60.         pho = (theta % 360) * math.pi / 180  
  61.         tmp = np.zeros(2, np.float32)  
  62.         tmp[0] = radiu_outer * math.cos(pho) + np.random.rand(1) + center[0]  
  63.         tmp[1] = radiu_outer * math.sin(pho) + np.random.rand(1) + center[1]  
  64.         data.append(tmp)  
  65.         theta += 1  
  66.       
  67.     Mat_Label = np.zeros((2, 2), np.float32)  
  68.     Mat_Label[0] = center + np.array([-radiu_inner + 0.5, 0])  
  69.     Mat_Label[1] = center + np.array([-radiu_outer + 0.5, 0])  
  70.     labels = [0, 1]  
  71.     Mat_Unlabel = np.vstack(data)  
  72.     return Mat_Label, labels, Mat_Unlabel  
  73.   
  74.   
  75. def loadBandData(num_unlabel_samples):  
  76.     #Mat_Label = np.array([[5.0, 2.], [5.0, 8.0]])  
  77.     #labels = [0, 1]  
  78.     #Mat_Unlabel = np.array([[5.1, 2.], [5.0, 8.1]])  
  79.       
  80.     Mat_Label = np.array([[5.0, 2.], [5.0, 8.0]])  
  81.     labels = [0, 1]  
  82.     num_dim = Mat_Label.shape[1]  
  83.     Mat_Unlabel = np.zeros((num_unlabel_samples, num_dim), np.float32)  
  84.     Mat_Unlabel[:num_unlabel_samples/2, :] = (np.random.rand(num_unlabel_samples/2, num_dim) - 0.5) * np.array([3, 1]) + Mat_Label[0]  
  85.     Mat_Unlabel[num_unlabel_samples/2 : num_unlabel_samples, :] = (np.random.rand(num_unlabel_samples/2, num_dim) - 0.5) * np.array([3, 1]) + Mat_Label[1]  
  86.     return Mat_Label, labels, Mat_Unlabel  
  87.   
  88.   
  89. # main function  
  90. if __name__ == "__main__":  
  91.     num_unlabel_samples = 800  
  92.     #Mat_Label, labels, Mat_Unlabel = loadBandData(num_unlabel_samples)  
  93.     Mat_Label, labels, Mat_Unlabel = loadCircleData(num_unlabel_samples)  
  94.       
  95.     ## Notice: when use 'rbf' as our kernel, the choice of hyper parameter 'sigma' is very import! It should be  
  96.     ## chose according to your dataset, specific the distance of two data points. I think it should ensure that  
  97.     ## each point has about 10 knn or w_i,j is large enough. It also influence the speed of converge. So, may be  
  98.     ## 'knn' kernel is better!  
  99.     #unlabel_data_labels = labelPropagation(Mat_Label, Mat_Unlabel, labels, kernel_type = 'rbf', rbf_sigma = 0.2)  
  100.     unlabel_data_labels = labelPropagation(Mat_Label, Mat_Unlabel, labels, kernel_type = 'knn', knn_num_neighbors = 10, max_iter = 400)  
  101.     show(Mat_Label, labels, Mat_Unlabel, unlabel_data_labels)  
  102.       

       该注释的，代码都注释的，有看不明白的，欢迎交流。不同迭代次数时候的结果如下：

       是不是很漂亮的传播过程？！在数值上也是可以看到随着迭代的进行逐渐收敛的，迭代的数值变化过程如下：

[python]  view plain  copy
  1. ---> Iteration 0/400, changed: 1602.000000  
  2. ---> Iteration 1/400, changed: 6.300182  
  3. ---> Iteration 2/400, changed: 5.129996  
  4. ---> Iteration 3/400, changed: 4.301994  
  5. ---> Iteration 4/400, changed: 3.819295  
  6. ---> Iteration 5/400, changed: 3.501743  
  7. ---> Iteration 6/400, changed: 3.277122  
  8. ---> Iteration 7/400, changed: 3.105952  
  9. ---> Iteration 8/400, changed: 2.967030  
  10. ---> Iteration 9/400, changed: 2.848606  
  11. ---> Iteration 10/400, changed: 2.743997  
  12. ---> Iteration 11/400, changed: 2.649270  
  13. ---> Iteration 12/400, changed: 2.562057  
  14. ---> Iteration 13/400, changed: 2.480885  
  15. ---> Iteration 14/400, changed: 2.404774  
  16. ---> Iteration 15/400, changed: 2.333075  
  17. ---> Iteration 16/400, changed: 2.265301  
  18. ---> Iteration 17/400, changed: 2.201107  
  19. ---> Iteration 18/400, changed: 2.140209  
  20. ---> Iteration 19/400, changed: 2.082354  
  21. ---> Iteration 20/400, changed: 2.027376  
  22. ---> Iteration 21/400, changed: 1.975071  
  23. ---> Iteration 22/400, changed: 1.925286  
  24. ---> Iteration 23/400, changed: 1.877894  
  25. ---> Iteration 24/400, changed: 1.832743  
  26. ---> Iteration 25/400, changed: 1.789721  
  27. ---> Iteration 26/400, changed: 1.748706  
  28. ---> Iteration 27/400, changed: 1.709593  
  29. ---> Iteration 28/400, changed: 1.672284  
  30. ---> Iteration 29/400, changed: 1.636668  
  31. ---> Iteration 30/400, changed: 1.602668  
  32. ---> Iteration 31/400, changed: 1.570200  
  33. ---> Iteration 32/400, changed: 1.539179  
  34. ---> Iteration 33/400, changed: 1.509530  
  35. ---> Iteration 34/400, changed: 1.481182  
  36. ---> Iteration 35/400, changed: 1.454066  
  37. ---> Iteration 36/400, changed: 1.428120  
  38. ---> Iteration 37/400, changed: 1.403283  
  39. ---> Iteration 38/400, changed: 1.379502  
  40. ---> Iteration 39/400, changed: 1.356734  
  41. ---> Iteration 40/400, changed: 1.334906  
  42. ---> Iteration 41/400, changed: 1.313983  
  43. ---> Iteration 42/400, changed: 1.293921  
  44. ---> Iteration 43/400, changed: 1.274681  
  45. ---> Iteration 44/400, changed: 1.256214  
  46. ---> Iteration 45/400, changed: 1.238491  
  47. ---> Iteration 46/400, changed: 1.221474  
  48. ---> Iteration 47/400, changed: 1.205126  
  49. ---> Iteration 48/400, changed: 1.189417  
  50. ---> Iteration 49/400, changed: 1.174316  
  51. ---> Iteration 50/400, changed: 1.159804  
  52. ---> Iteration 51/400, changed: 1.145844  
  53. ---> Iteration 52/400, changed: 1.132414  
  54. ---> Iteration 53/400, changed: 1.119490  
  55. ---> Iteration 54/400, changed: 1.107032  
  56. ---> Iteration 55/400, changed: 1.095054  
  57. ---> Iteration 56/400, changed: 1.083513  
  58. ---> Iteration 57/400, changed: 1.072397  
  59. ---> Iteration 58/400, changed: 1.061671  
  60. ---> Iteration 59/400, changed: 1.051324  
  61. ---> Iteration 60/400, changed: 1.041363  
  62. ---> Iteration 61/400, changed: 1.031742  
  63. ---> Iteration 62/400, changed: 1.022459  
  64. ---> Iteration 63/400, changed: 1.013494  
  65. ---> Iteration 64/400, changed: 1.004836  
  66. ---> Iteration 65/400, changed: 0.996484  
  67. ---> Iteration 66/400, changed: 0.988407  
  68. ---> Iteration 67/400, changed: 0.980592  
  69. ---> Iteration 68/400, changed: 0.973045  
  70. ---> Iteration 69/400, changed: 0.965744  
  71. ---> Iteration 70/400, changed: 0.958682  
  72. ---> Iteration 71/400, changed: 0.951848  
  73. ---> Iteration 72/400, changed: 0.945227  
  74. ---> Iteration 73/400, changed: 0.938820  
  75. ---> Iteration 74/400, changed: 0.932608  
  76. ---> Iteration 75/400, changed: 0.926590  
  77. ---> Iteration 76/400, changed: 0.920765  
  78. ---> Iteration 77/400, changed: 0.915107  
  79. ---> Iteration 78/400, changed: 0.909628  
  80. ---> Iteration 79/400, changed: 0.904309  
  81. ---> Iteration 80/400, changed: 0.899143  
  82. ---> Iteration 81/400, changed: 0.894122  
  83. ---> Iteration 82/400, changed: 0.889259  
  84. ---> Iteration 83/400, changed: 0.884530  
  85. ---> Iteration 84/400, changed: 0.879933  
  86. ---> Iteration 85/400, changed: 0.875464  
  87. ---> Iteration 86/400, changed: 0.871121  
  88. ---> Iteration 87/400, changed: 0.866888  
  89. ---> Iteration 88/400, changed: 0.862773  
  90. ---> Iteration 89/400, changed: 0.858783  
  91. ---> Iteration 90/400, changed: 0.854879  
  92. ---> Iteration 91/400, changed: 0.851084  
  93. ---> Iteration 92/400, changed: 0.847382  
  94. ---> Iteration 93/400, changed: 0.843779  
  95. ---> Iteration 94/400, changed: 0.840274  
  96. ---> Iteration 95/400, changed: 0.836842  
  97. ---> Iteration 96/400, changed: 0.833501  
  98. ---> Iteration 97/400, changed: 0.830240  
  99. ---> Iteration 98/400, changed: 0.827051  
  100. ---> Iteration 99/400, changed: 0.823950  
  101. ---> Iteration 100/400, changed: 0.820906  
  102. ---> Iteration 101/400, changed: 0.817946  
  103. ---> Iteration 102/400, changed: 0.815053  
  104. ---> Iteration 103/400, changed: 0.812217  
  105. ---> Iteration 104/400, changed: 0.809437  
  106. ---> Iteration 105/400, changed: 0.806724  
  107. ---> Iteration 106/400, changed: 0.804076  
  108. ---> Iteration 107/400, changed: 0.801480  
  109. ---> Iteration 108/400, changed: 0.798937  
  110. ---> Iteration 109/400, changed: 0.796448  
  111. ---> Iteration 110/400, changed: 0.794008  
  112. ---> Iteration 111/400, changed: 0.791612  
  113. ---> Iteration 112/400, changed: 0.789282  
  114. ---> Iteration 113/400, changed: 0.786984  
  115. ---> Iteration 114/400, changed: 0.784728  
  116. ---> Iteration 115/400, changed: 0.782516  
  117. ---> Iteration 116/400, changed: 0.780355  
  118. ---> Iteration 117/400, changed: 0.778216  
  119. ---> Iteration 118/400, changed: 0.776139  
  120. ---> Iteration 119/400, changed: 0.774087  
  121. ---> Iteration 120/400, changed: 0.772072  
  122. ---> Iteration 121/400, changed: 0.770085  
  123. ---> Iteration 122/400, changed: 0.768146  
  124. ---> Iteration 123/400, changed: 0.766232  
  125. ---> Iteration 124/400, changed: 0.764356  
  126. ---> Iteration 125/400, changed: 0.762504  
  127. ---> Iteration 126/400, changed: 0.760685  
  128. ---> Iteration 127/400, changed: 0.758889  
  129. ---> Iteration 128/400, changed: 0.757135  
  130. ---> Iteration 129/400, changed: 0.755406  

四、LP算法MPI并行实现

       这里，我们测试的是LP的变身版本。从公式，我们可以看到，第二项PULYL迭代过程并没有发生变化，所以这部分实际上从迭代开始就可以计算好，从而避免重复计算。不过，不管怎样，LP算法都要计算一个UxU的矩阵PUU和一个UxC矩阵FU的乘积。当我们的unlabeled数据非常多，而且类别也很多的时候，计算是很慢的，同时占用的内存量也非常大。另外，构造Graph需要计算两两的相似度，也是O(n2)的复杂度，当我们数据的特征维度很大的时候，这个计算量也是非常客观的。所以我们就得考虑并行处理了。而且最好是能放到集群上并行。那如何并行呢？

       对算法的并行化，一般分为两种：数据并行和模型并行。

       数据并行很好理解，就是将数据划分，每个节点只处理一部分数据，例如我们构造图的时候，计算每个数据的k近邻。例如我们有1000个样本和20个CPU节点，那么就平均分发，让每个CPU节点计算50个样本的k近邻，然后最后再合并大家的结果。可见这个加速比也是非常可观的。

       模型并行一般发生在模型很大，无法放到单机的内存里面的时候。例如庞大的深度神经网络训练的时候，就需要把这个网络切开，然后分别求解梯度，最后有个leader的节点来收集大家的梯度，再反馈给大家去更新。当然了，其中存在更细致和高效的工程处理方法。在我们的LP算法中，也是可以做模型并行的。假如我们的类别数C很大，把类别数切开，让不同的CPU节点处理，实际上就相当于模型并行了。

       那为啥不切大矩阵PUU，而是切小点的矩阵FU，因为大矩阵PUU没法独立分块，并行的一个原则是处理必须是独立的。 矩阵FU依赖的是所有的U，而把PUU切开分发到其他节点的时候，每次FU的更新都需要和其他的节点通信，这个通信的代价是很大的（实际上，很多并行系统没法达到线性的加速度的瓶颈是通信！线性加速比是，我增加了n台机器，速度就提升了n倍）。但是对类别C也就是矩阵FU切分，就不会有这个问题，因为他们的计算是独立的。只是决定样本的最终类别的时候，将所有的FU收集回来求max就可以了。

       所以，在下面的代码中，是同时包含了数据并行和模型并行的雏形的。另外，还值得一提的是，我们是迭代算法，那决定什么时候迭代算法停止？除了判断收敛外，我们还可以让每迭代几步，就用测试label测试一次结果，看模型的整体训练性能如何。特别是判断训练是否过拟合的时候非常有效。因此，代码中包含了这部分内容。

       好了，代码终于来了。大家可以搞点大数据库来测试，如果有MPI集群条件的话就更好了。

       下面的代码依赖numpy、scipy（用其稀疏矩阵加速计算）和mpi4py。其中mpi4py需要依赖openmpi和Cpython，可以参考我之前的博客进行安装。

[python]  view plain  copy
  1. #***************************************************************************  
  2. #*   
  3. #* Description: label propagation  
  4. #* Author: Zou Xiaoyi ([email protected])  
  5. #* Date:   2015-10-15  
  6. #* HomePage: http://blog.csdn.net/zouxy09  
  7. #*   
  8. #**************************************************************************  
  9.   
  10. import os, sys, time  
  11. import numpy as np  
  12. from scipy.sparse import csr_matrix, lil_matrix, eye  
  13. import operator  
  14. import cPickle as pickle  
  15. import mpi4py.MPI as MPI  
  16.   
  17. #  
  18. #   Global variables for MPI  
  19. #  
  20.   
  21. # instance for invoking MPI related functions  
  22. comm = MPI.COMM_WORLD  
  23. # the node rank in the whole community  
  24. comm_rank = comm.Get_rank()  
  25. # the size of the whole community, i.e., the total number of working nodes in the MPI cluster  
  26. comm_size = comm.Get_size()  
  27.   
  28. # load mnist dataset  
  29. def load_MNIST():  
  30.     import gzip  
  31.     f = gzip.open("mnist.pkl.gz", "rb")  
  32.     train, val, test = pickle.load(f)  
  33.     f.close()  
  34.       
  35.     Mat_Label = train[0]  
  36.     labels = train[1]  
  37.     Mat_Unlabel = test[0]  
  38.     groundtruth = test[1]  
  39.     labels_id = [0, 1, 2, 3, 4, 5, 6, 7, 8, 9]  
  40.   
  41.     return Mat_Label, labels, labels_id, Mat_Unlabel, groundtruth  
  42.   
  43. # return k neighbors index  
  44. def navie_knn(dataSet, query, k):  
  45.     numSamples = dataSet.shape[0]  
  46.   
  47.     ## step 1: calculate Euclidean distance  
  48.     diff = np.tile(query, (numSamples, 1)) - dataSet  
  49.     squaredDiff = diff ** 2  
  50.     squaredDist = np.sum(squaredDiff, axis = 1) # sum is performed by row  
  51.   
  52.     ## step 2: sort the distance  
  53.     sortedDistIndices = np.argsort(squaredDist)  
  54.     if k > len(sortedDistIndices):  
  55.         k = len(sortedDistIndices)  
  56.     return sortedDistIndices[0:k]  
  57.   
  58.   
  59. # build a big graph (normalized weight matrix)  
  60. # sparse U x (U + L) matrix  
  61. def buildSubGraph(Mat_Label, Mat_Unlabel, knn_num_neighbors):  
  62.     num_unlabel_samples = Mat_Unlabel.shape[0]  
  63.     data = []; indices = []; indptr = [0]  
  64.     Mat_all = np.vstack((Mat_Label, Mat_Unlabel))  
  65.     values = np.ones(knn_num_neighbors, np.float32) / knn_num_neighbors  
  66.     for i in xrange(num_unlabel_samples):  
  67.         k_neighbors = navie_knn(Mat_all, Mat_Unlabel[i, :], knn_num_neighbors)  
  68.         indptr.append(np.int32(indptr[-1]) + knn_num_neighbors)  
  69.         indices.extend(k_neighbors)  
  70.         data.append(values)   
  71.     return csr_matrix((np.hstack(data), indices, indptr))  
  72.   
  73.   
  74. # build a big graph (normalized weight matrix)  
  75. # sparse U x (U + L) matrix  
  76. def buildSubGraph_MPI(Mat_Label, Mat_Unlabel, knn_num_neighbors):  
  77.     num_unlabel_samples = Mat_Unlabel.shape[0]  
  78.     local_data = []; local_indices = []; local_indptr = [0]  
  79.     Mat_all = np.vstack((Mat_Label, Mat_Unlabel))  
  80.     values = np.ones(knn_num_neighbors, np.float32) / knn_num_neighbors  
  81.     sample_offset = np.linspace(0, num_unlabel_samples, comm_size + 1).astype('int')  
  82.     for i in range(sample_offset[comm_rank], sample_offset[comm_rank+1]):  
  83.         k_neighbors = navie_knn(Mat_all, Mat_Unlabel[i, :], knn_num_neighbors)  
  84.         local_indptr.append(np.int32(local_indptr[-1]) + knn_num_neighbors)  
  85.         local_indices.extend(k_neighbors)  
  86.         local_data.append(values)  
  87.     data = np.hstack(comm.allgather(local_data))  
  88.     indices = np.hstack(comm.allgather(local_indices))  
  89.     indptr_tmp = comm.allgather(local_indptr)  
  90.     indptr = []  
  91.     for i in range(len(indptr_tmp)):  
  92.         if i == 0:  
  93.             indptr.extend(indptr_tmp[i])  
  94.         else:  
  95.             last_indptr = indptr[-1]  
  96.             del(indptr[-1])  
  97.             indptr.extend(indptr_tmp[i] + last_indptr)  
  98.     return csr_matrix((np.hstack(data), indices, indptr), dtype = np.float32)  
  99.   
  100.   
  101. # label propagation  
  102. def run_label_propagation_sparse(knn_num_neighbors = 20, max_iter = 100, tol = 1e-4, test_per_iter = 1):  
  103.     # load data and graph  
  104.     print "Processor %d/%d loading graph file..." % (comm_rank, comm_size)  
  105.     #Mat_Label, labels, Mat_Unlabel, groundtruth = loadFourBandData()  
  106.     Mat_Label, labels, labels_id, Mat_Unlabel, unlabel_data_id = load_MNIST()  
  107.     if comm_size > len(labels_id):  
  108.         raise ValueError("Sorry, the processors must be less than the number of classes")  
  109.     #affinity_matrix = buildSubGraph(Mat_Label, Mat_Unlabel, knn_num_neighbors)  
  110.     affinity_matrix = buildSubGraph_MPI(Mat_Label, Mat_Unlabel, knn_num_neighbors)  
  111.       
  112.     # get some parameters  
  113.     num_classes = len(labels_id)  
  114.     num_label_samples = len(labels)  
  115.     num_unlabel_samples = Mat_Unlabel.shape[0]  
  116.   
  117.     affinity_matrix_UL = affinity_matrix[:, 0:num_label_samples]  
  118.     affinity_matrix_UU = affinity_matrix[:, num_label_samples:num_label_samples+num_unlabel_samples]  
  119.   
  120.     if comm_rank == 0:  
  121.         print "Have %d labeled images, %d unlabeled images and %d classes" % (num_label_samples, num_unlabel_samples, num_classes)  
  122.       
  123.     # divide label_function_U and label_function_L to all processors  
  124.     class_offset = np.linspace(0, num_classes, comm_size + 1).astype('int')  
  125.       
  126.     # initialize local label_function_U  
  127.     local_start_class = class_offset[comm_rank]  
  128.     local_num_classes = class_offset[comm_rank+1] - local_start_class  
  129.     local_label_function_U = eye(num_unlabel_samples, local_num_classes, 0, np.float32, format='csr')  
  130.       
  131.     # initialize local label_function_L  
  132.     local_label_function_L = lil_matrix((num_label_samples, local_num_classes), dtype = np.float32)  
  133.     for i in xrange(num_label_samples):  
  134.         class_off = int(labels[i]) - local_start_class  
  135.         if class_off >= 0 and class_off < local_num_classes:  
  136.             local_label_function_L[i, class_off] = 1.0  
  137.     local_label_function_L = local_label_function_L.tocsr()  
  138.     local_label_info = affinity_matrix_UL.dot(local_label_function_L)  
  139.     print "Processor %d/%d has to process %d classes..." % (comm_rank, comm_size, local_label_function_L.shape[1])  
  140.       
  141.     # start to propagation  
  142.     iter = 1; changed = 100.0;  
  143.     evaluation(num_unlabel_samples, local_start_class, local_label_function_U, unlabel_data_id, labels_id)  
  144.     while True:  
  145.         pre_label_function = local_label_function_U.copy()  
  146.           
  147.         # propagation  
  148.         local_label_function_U = affinity_matrix_UU.dot(local_label_function_U) + local_label_info  
  149.           
  150.         # check converge  
  151.         local_changed = abs(pre_label_function - local_label_function_U).sum()  
  152.         changed = comm.reduce(local_changed, root = 0, op = MPI.SUM)  
  153.         status = 'RUN'  
  154.         test = False  
  155.         if comm_rank == 0:  
  156.             if iter % 1 == 0:  
  157.                 norm_changed = changed / (num_unlabel_samples * num_classes)  
  158.                 print "---> Iteration %d/%d, changed: %f" % (iter, max_iter, norm_changed)  
  159.             if iter >= max_iter or changed < tol:  
  160.                 status = 'STOP'  
  161.                 print "************** Iteration over! ****************"  
  162.             if iter % test_per_iter == 0:  
  163.                 test = True  
  164.             iter += 1  
  165.         test = comm.bcast(test if comm_rank == 0 else None, root = 0)  
  166.         status = comm.bcast(status if comm_rank == 0 else None, root = 0)  
  167.         if status == 'STOP':  
  168.             break  
  169.         if test == True:  
  170.             evaluation(num_unlabel_samples, local_start_class, local_label_function_U, unlabel_data_id, labels_id)  
  171.     evaluation(num_unlabel_samples, local_start_class, local_label_function_U, unlabel_data_id, labels_id)  
  172.   
  173.   
  174. def evaluation(num_unlabel_samples, local_start_class, local_label_function_U, unlabel_data_id, labels_id):  
  175.     # get local label with max score  
  176.     if comm_rank == 0:  
  177.         print "Start to combine local result..."  
  178.     local_max_score = np.zeros((num_unlabel_samples, 1), np.float32)   
  179.     local_max_label = np.zeros((num_unlabel_samples, 1), np.int32)  
  180.     for i in xrange(num_unlabel_samples):  
  181.         local_max_label[i, 0] = np.argmax(local_label_function_U.getrow(i).todense())  
  182.         local_max_score[i, 0] = local_label_function_U[i, local_max_label[i, 0]]  
  183.         local_max_label[i, 0] += local_start_class  
  184.           
  185.     # gather the results from all the processors  
  186.     if comm_rank == 0:  
  187.         print "Start to gather results from all processors"  
  188.     all_max_label = np.hstack(comm.allgather(local_max_label))  
  189.     all_max_score = np.hstack(comm.allgather(local_max_score))  
  190.       
  191.     # get terminate label of unlabeled data  
  192.     if comm_rank == 0:  
  193.         print "Start to analysis the results..."  
  194.         right_predict_count = 0  
  195.         for i in xrange(num_unlabel_samples):  
  196.             if i % 1000 == 0:  
  197.                 print "***", all_max_score[i]  
  198.             max_idx = np.argmax(all_max_score[i])  
  199.             max_label = all_max_label[i, max_idx]  
  200.             if int(unlabel_data_id[i]) == int(labels_id[max_label]):  
  201.                 right_predict_count += 1  
  202.         accuracy = float(right_predict_count) * 100.0 / num_unlabel_samples  
  203.         print "Have %d samples, accuracy: %.3f%%!" % (num_unlabel_samples, accuracy)  
  204.   
  205.   
  206. if __name__ == '__main__':  
  207.     run_label_propagation_sparse(knn_num_neighbors = 20, max_iter = 30)  

五、参考资料

[1]Semi-SupervisedLearning with Graphs.pdf

你可能感兴趣的:(机器学习,机器学习,半监督学习)

  • 机器学习与深度学习间关系与区别 ℒℴѵℯ心·动ꦿ໊ོ꫞ 人工智能学习深度学习python
    一、机器学习概述定义机器学习（MachineLearning,ML）是一种通过数据驱动的方法，利用统计学和计算算法来训练模型，使计算机能够从数据中学习并自动进行预测或决策。机器学习通过分析大量数据样本，识别其中的模式和规律，从而对新的数据进行判断。其核心在于通过训练过程，让模型不断优化和提升其预测准确性。主要类型1.监督学习（SupervisedLearning）监督学习是指在训练数据集中包含输入
  • 数字里的世界17期：2021年全球10大顶级数据中心，中国移动榜首 张三叨
    你知道吗？2016年，全球的数据中心共计用电4160亿千瓦时，比整个英国的发电量还多40％！前言每天，我们都会创造超过250万TB的数据。并且随着物联网（IOT）的不断普及，这一数据将持续增长。如此庞大的数据被存储在被称为“数据中心”的专用设施中。虽然最早的数据中心建于20世纪40年代，但直到1997-2000年的互联网泡沫期间才逐渐成为主流。当前人类的技术，比如人工智能和机器学习，已经将我们推向
  • nosql数据库技术与应用知识点 皆过客，揽星河 NoSQLnosql数据库大数据数据分析数据结构非关系型数据库
    Nosql知识回顾大数据处理流程数据采集(flume、爬虫、传感器)数据存储(本门课程NoSQL所处的阶段)Hdfs、MongoDB、HBase等数据清洗(入仓)Hive等数据处理、分析(Spark、Flink等)数据可视化数据挖掘、机器学习应用(Python、SparkMLlib等)大数据时代存储的挑战(三高)高并发(同一时间很多人访问)高扩展(要求随时根据需求扩展存储)高效率(要求读写速度快)
  • Python开发常用的三方模块如下： 换个网名有点难 python开发语言
    Python是一门功能强大的编程语言，拥有丰富的第三方库，这些库为开发者提供了极大的便利。以下是100个常用的Python库，涵盖了多个领域：1、NumPy，用于科学计算的基础库。2、Pandas，提供数据结构和数据分析工具。3、Matplotlib，一个绘图库。4、Scikit-learn，机器学习库。5、SciPy，用于数学、科学和工程的库。6、TensorFlow，由Google开发的开源机
  • Python实现简单的机器学习算法 master_chenchengg pythonpython办公效率python开发IT
    Python实现简单的机器学习算法开篇：初探机器学习的奇妙之旅搭建环境：一切从安装开始必备工具箱第一步：安装Anaconda和JupyterNotebook小贴士：如何配置Python环境变量算法初体验：从零开始的Python机器学习线性回归：让数据说话数据准备：从哪里找数据编码实战：Python实现线性回归模型评估：如何判断模型好坏逻辑回归：从分类开始理论入门：什么是逻辑回归代码实现：使用skl
  • 遥感影像的切片处理 sand&wich 计算机视觉python图像处理
    在遥感影像分析中，经常需要将大尺寸的影像切分成小片段，以便于进行详细的分析和处理。这种方法特别适用于机器学习和图像处理任务，如对象检测、图像分类等。以下是如何使用Python和OpenCV库来实现这一过程，同时确保每个影像片段保留正确的地理信息。准备环境首先，确保安装了必要的Python库，包括numpy、opencv-python和xml.etree.ElementTree。这些库将用于图像处理
  • ai绘画工具midjourney怎么下载？附作品管理教程 设计师早上好
    Midjourney是一款功能强大的AI绘画工具，它使用机器学习技术和深度神经网络等算法，可以生成各种艺术风格的绘画作品。在创意设计、广告宣传等方面有着广泛的应用前景。那么，ai绘画工具midjourney怎么下载？本文将为您介绍Midjourney的下载以及作品的相关管理。一、Midjourney下载Midjourney的下载非常简单，只需打开Midjourney官网（点击“GetMidjour
  • [实践应用] 深度学习之模型性能评估指标 YuanDaima2048 深度学习工具使用深度学习人工智能损失函数性能评估pytorchpython机器学习
    文章总览：YuanDaiMa2048博客文章总览深度学习之模型性能评估指标分类任务回归任务排序任务聚类任务生成任务其他介绍在机器学习和深度学习领域，评估模型性能是一项至关重要的任务。不同的学习任务需要不同的性能指标来衡量模型的有效性。以下是对一些常见任务及其相应的性能评估指标的详细解释和总结。分类任务分类任务是指模型需要将输入数据分配到预定义的类别或标签中。以下是分类任务中常用的性能指标：准确率(
  • 机器学习-聚类算法 不良人龍木木 机器学习机器学习算法聚类
    机器学习-聚类算法1.AHC2.K-means3.SC4.MCL仅个人笔记，感谢点赞关注！1.AHC2.K-means3.SC传统谱聚类：个人对谱聚类算法的理解以及改进4.MCL目前仅专注于NLP的技术学习和分享感谢大家的关注与支持！
  • 未来软件市场是怎么样的？做开发的生存空间如何？ cesske 软件需求
    目录前言一、未来软件市场的发展趋势二、软件开发人员的生存空间前言未来软件市场是怎么样的？做开发的生存空间如何？一、未来软件市场的发展趋势技术趋势：人工智能与机器学习：随着技术的不断成熟，人工智能将在更多领域得到应用，如智能客服、自动驾驶、智能制造等，这将极大地推动软件市场的增长。云计算与大数据：云计算服务将继续普及，大数据技术的应用也将更加广泛。企业将更加依赖云计算和大数据来优化运营、提升效率，并
  • python中zeros用法_Python中的numpy.zeros()用法 江平舟 python中zeros用法
    numpy.zeros()函数是最重要的函数之一,广泛用于机器学习程序中。此函数用于生成包含零的数组。numpy.zeros()函数提供给定形状和类型的新数组,并用零填充。句法numpy.zeros(shape,dtype=float,order='C'参数形状：整数或整数元组此参数用于定义数组的尺寸。此参数用于我们要在其中创建数组的形状,例如(3,2)或2。dtype：数据类型(可选)此参数用于
  • 【NumPy】深入解析numpy.zeros()函数 二七830 numpy
    欢迎莅临我的个人主页这里是我深耕Python编程、机器学习和自然语言处理（NLP）领域，并乐于分享知识与经验的小天地！博主简介：我是二七830，一名对技术充满热情的探索者。多年的Python编程和机器学习实践，使我深入理解了这些技术的核心原理，并能够在实际项目中灵活应用。尤其是在NLP领域，我积累了丰富的经验，能够处理各种复杂的自然语言任务。技术专长：我熟练掌握Python编程语言，并深入研究了机
  • 【中国国际航空-注册_登录安全分析报告】 风控牛 验证码接口安全评测系列安全行为验证极验网易易盾智能手机
    前言由于网站注册入口容易被黑客攻击，存在如下安全问题：1.暴力破解密码，造成用户信息泄露2.短信盗刷的安全问题，影响业务及导致用户投诉3.带来经济损失，尤其是后付费客户，风险巨大，造成亏损无底洞所以大部分网站及App都采取图形验证码或滑动验证码等交互解决方案，但在机器学习能力提高的当下，连百度这样的大厂都遭受攻击导致点名批评，图形验证及交互验证方式的安全性到底如何？请看具体分析一、中国国际航空PC
  • 机器学习 流形数据降维：UMAP 降维算法 小嗷犬 Python机器学习#数据分析及可视化机器学习算法人工智能
    ✅作者简介：人工智能专业本科在读，喜欢计算机与编程，写博客记录自己的学习历程。个人主页：小嗷犬的个人主页个人网站：小嗷犬的技术小站个人信条：为天地立心，为生民立命，为往圣继绝学，为万世开太平。本文目录UMAP简介理论基础特点与优势应用场景在Python中使用UMAP安装umap-learn库使用UMAP可视化手写数字数据集UMAP简介UMAP（UniformManifoldApproximatio
  • 七.正则化 愿风去了
    吴恩达机器学习之正则化（Regularization）http://www.cnblogs.com/jianxinzhou/p/4083921.html从数学公式上理解L1和L2https://blog.csdn.net/b876144622/article/details/81276818虽然在线性回归中加入基函数会使模型更加灵活，但是很容易引起数据的过拟合。例如将数据投影到30维的基函数上，模
  • 机器学习-------数据标准化 罔闻_spider 数据分析算法机器学习人工智能
    什么是归一化，它与标准化的区别是什么？一作用在做训练时，需要先将特征值与标签标准化，可以防止梯度防炸和过拟合；将标签标准化后，网络预测出的数据是符合标准正态分布的—StandarScaler()，与真实值有很大差别。因为StandarScaler()对数据的处理是（真实值-平均值）/标准差。同时在做预测时需要将输出数据逆标准化提升模型精度：标准化/归一化使不同维度的特征在数值上更具比较性，提高分类
  • 分享一个基于python的电子书数据采集与可视化分析 hadoop电子书数据分析与推荐系统 spark大数据毕设项目（源码、调试、LW、开题、PPT) 计算机源码社 Python项目大数据大数据pythonhadoop计算机毕业设计选题计算机毕业设计源码数据分析spark毕设
    作者：计算机源码社个人简介：本人八年开发经验，擅长Java、Python、PHP、.NET、Node.js、Android、微信小程序、爬虫、大数据、机器学习等，大家有这一块的问题可以一起交流！学习资料、程序开发、技术解答、文档报告如需要源码，可以扫取文章下方二维码联系咨询Java项目微信小程序项目Android项目Python项目PHP项目ASP.NET项目Node.js项目选题推荐项目实战|p
  • 两种方法判断Python的位数是32位还是64位 sanqima Python编程电脑python开发语言
      Python从1991年发布以来，凭借其简洁、清晰、易读的语法、丰富的标准库和第三方工具，在Web开发、自动化测试、人工智能、图形识别、机器学习等领域发展迅猛。  Python是一种胶水语言，通过Cython库与C/C++语言进行链接，通过Jython库与Java语言进行链接。  Python是跨平台的，可运行在多种操作系统上，包括但不限于Windows、Linux和macOS。这意味着用Py
  • 使用最大边际相关性(MMR)选择示例：提高AI模型的多样性和相关性 aehrutktrjk 人工智能easyui前端python
    使用最大边际相关性(MMR)选择示例：提高AI模型的多样性和相关性引言在机器学习和自然语言处理领域，选择合适的训练示例对模型性能至关重要。最大边际相关性(MaximalMarginalRelevance,MMR)是一种优秀的示例选择方法，它不仅考虑了示例与输入的相关性，还注重保持所选示例之间的多样性。本文将深入探讨如何使用MMR来选择示例，以提高AI模型的性能和泛化能力。什么是最大边际相关性(MM
  • LangChain集成指南:如何利用多样化的AI提供商 aehrutktrjk 人工智能langchainpython
    LangChain集成指南:如何利用多样化的AI提供商引言在人工智能和机器学习领域,LangChain已成为一个强大而灵活的框架,允许开发者轻松集成各种AI服务提供商。本文将深入探讨LangChain的集成能力,介绍如何利用不同的AI提供商来增强你的应用程序,并提供实用的代码示例。LangChain集成概览LangChain支持多种AI提供商的集成,这些集成可以分为两类:独立包集成:这些提供商有独
  • 机器学习VS深度学习 nfgo 机器学习
    机器学习（MachineLearning,ML）和深度学习（DeepLearning,DL）是人工智能（AI）的两个子领域，它们有许多相似之处，但在技术实现和应用范围上也有显著区别。下面从几个方面对两者进行区分：1.概念层面机器学习：是让计算机通过算法从数据中自动学习和改进的技术。它依赖于手动设计的特征和数学模型来进行学习，常用的模型有决策树、支持向量机、线性回归等。深度学习：是机器学习的一个子领
  • 大数据毕业设计hadoop+spark+hive知识图谱租房数据分析可视化大屏 租房推荐系统 58同城租房爬虫 房源推荐系统 房价预测系统 计算机毕业设计 机器学习 深度学习 人工智能 2401_84572577 程序员大数据hadoop人工智能
    做了那么多年开发，自学了很多门编程语言，我很明白学习资源对于学一门新语言的重要性，这些年也收藏了不少的Python干货，对我来说这些东西确实已经用不到了，但对于准备自学Python的人来说，或许它就是一个宝藏，可以给你省去很多的时间和精力。别在网上瞎学了，我最近也做了一些资源的更新，只要你是我的粉丝，这期福利你都可拿走。我先来介绍一下这些东西怎么用，文末抱走。（1）Python所有方向的学习路线（
  • 【机器学习与R语言】1-机器学习简介 苹果酱0567 面试题汇总与解析java中间件开发语言springboot后端
    1.基本概念机器学习：发明算法将数据转化为智能行为数据挖掘VS机器学习：前者侧重寻找有价值的信息，后者侧重执行已知的任务。后者是前者的先期准备过程：数据——>抽象化——>一般化。或者：收集数据——推理数据——归纳数据——发现规律抽象化：训练：用一个特定模型来拟合数据集的过程用方程来拟合观测的数据：观测现象——数据呈现——模型建立。通过不同的格式来把信息概念化一般化：一般化：将抽象化的知识转换成可用
  • Python前沿技术：机器学习与人工智能 4.0啊 Python人工智能python机器学习
    Python前沿技术：机器学习与人工智能一、引言随着科技的飞速发展，机器学习和人工智能（AI）已经成为了计算机科学领域的热门话题。Python作为一门易学易用且功能强大的编程语言，已经成为了这两个领域的首选语言之一。本文将深入探讨Python在机器学习和人工智能领域的应用，以及一些前沿技术和工具。二、Python机器学习基础2.1机器学习概述机器学习是人工智能（AI）的一个关键子集，它的核心在于让
  • chatgpt赋能python：如何在Python中计算平均值 tulingtest ChatGptpythonchatgptnumpy计算机
    如何在Python中计算平均值计算平均值是数据分析、统计和机器学习等许多领域中的常见任务。Python作为一门功能强大且易于学习的编程语言，为计算平均值提供了多种方法。在本文中，我们将介绍如何在Python中计算平均值。什么是平均值简单来说，平均值是一组数字的总和除以数字的数量。例如，对于数字序列1，3，5，7，9，平均值是(1+3+5+7+9)/5=5。平均值在数据分析中非常有用，因为它可以提供
  • Python 初学者入门必知： Anaconda是什么？有什么作用？怎么使用？ 懒大王爱吃狼 Python基础python开发语言python基础python学习anacondaanaconda安装python教程
    初学者在学习Python时，经常看到的一个名字是Anaconda。究竟什么是Anaconda，为什么它如此受欢迎？在这篇文章中，我们将探讨Anaconda，了解Anaconda的从安装到使用的。Anaconda是一个免费开源的Python和R编程发行版，包含上千个适用于数据科学和机器学习的包。同时，配备了Spyder和Jupyternotebook等工具，初学者可以使用它们来学习Python，使用
  • 每天五分钟玩转深度学习PyTorch：模型参数优化器torch.optim 幻风_huanfeng 深度学习框架pytorch深度学习pytorch人工智能神经网络机器学习优化算法
    本文重点在机器学习或者深度学习中，我们需要通过修改参数使得损失函数最小化(或最大化)，优化算法就是一种调整模型参数更新的策略。在pytorch中定义了优化器optim，我们可以使用它调用封装好的优化算法，然后传递给它神经网络模型参数，就可以对模型进行优化。本文是学习第6步(优化器)，参考链接pytorch的学习路线随机梯度下降算法在深度学习和机器学习中，梯度下降算法是最常用的参数更新方法，它的公式
  • 一切皆是映射：AI的去中心化：区块链技术的融合 AI大模型应用之禅 计算科学神经计算深度学习神经网络大数据人工智能大型语言模型AIAGILLMJavaPython架构设计AgentRPA
    一切皆是映射：AI的去中心化：区块链技术的融合作者：禅与计算机程序设计艺术/ZenandtheArtofComputerProgramming关键词：AI，区块链，去中心化，智能合约，共识机制，数据安全，隐私保护，分布式账本技术，机器学习，数据隐私1.背景介绍1.1问题的由来随着人工智能（AI）技术的快速发展，其在各个领域的应用越来越广泛，从自动驾驶、智能医疗到金融服务，AI正在改变着我们的生活。
  • 第五届核磁机器学习班（训练营：2023.6.5~6.17） 茗创科技
    茗创科技专注于脑科学数据处理，涵盖（EEG/ERP,fMRI,结构像,DTI,ASL,FNIRS）等，欢迎留言讨论及转发推荐，也欢迎了解茗创科技的脑电课程，数据处理服务及脑科学工作站销售业务，可添加我们的工程师（微信号MCKJ-zhouyi或17373158786）咨询。★课程简介★基于血氧水平依赖的功能磁共振成像(fMRI)技术,利用其数据构建的功能性脑网络后,发现脑并不是一个单纯对外界刺激进行
  • 如何有效的学习AI大模型？ Python程序员罗宾 学习人工智能语言模型自然语言处理架构
    学习AI大模型是一个系统性的过程，涉及到多个学科的知识。以下是一些建议，帮助你更有效地学习AI大模型：基础知识储备：数学基础：学习线性代数、概率论、统计学和微积分等，这些是理解机器学习算法的数学基础。编程技能：掌握至少一种编程语言，如Python，因为大多数AI模型都是用Python实现的。理论学习：机器学习基础：了解监督学习、非监督学习、强化学习等基本概念。深度学习：学习神经网络的基本结构，如卷
  • 安装数据库首次应用 Array_06 javaoraclesql
    可是为什么再一次失败之后就变成直接跳过那个要求 enter full pathname of java.exe的界面 这个java.exe是你的Oracle 11g安装目录中例如：【F:\app\chen\product\11.2.0\dbhome_1\jdk\jre\bin】下的java.exe 。不是你的电脑安装的java jdk下的java.exe！ 注意第一次，使用SQL D
  • Weblogic Server Console密码修改和遗忘解决方法 bijian1013 Welogic
            在工作中一同事将Weblogic的console的密码忘记了，通过网上查询资料解决，实践整理了一下。 一.修改Console密码         打开weblogic控制台，安全领域 --> myrealm -->&n
  • IllegalStateException: Cannot forward a response that is already committed Cwind javaServlets
    对于初学者来说，一个常见的误解是：当调用 forward() 或者 sendRedirect() 时控制流将会自动跳出原函数。标题所示错误通常是基于此误解而引起的。 示例代码： protected void doPost() { if (someCondition) { sendRedirect(); } forward(); // Thi
  • 基于流的装饰设计模式 木zi_鸣 设计模式
    当想要对已有类的对象进行功能增强时，可以定义一个类，将已有对象传入，基于已有的功能，并提供加强功能。 自定义的类成为装饰类 模仿BufferedReader，对Reader进行包装，体现装饰设计模式 装饰类通常会通过构造方法接受被装饰的对象，并基于被装饰的对象功能，提供更强的功能。 装饰模式比继承灵活，避免继承臃肿，降低了类与类之间的关系 装饰类因为增强已有对象，具备的功能该
  • Linux中的uniq命令 被触发 linux
    Linux命令uniq的作用是过滤重复部分显示文件内容，这个命令读取输入文件，并比较相邻的行。在正常情 况下，第二个及以后更多个重复行将被删去，行比较是根据所用字符集的排序序列进行的。该命令加工后的结果写到输出文件中。输入文件和输出文件必须不同。如 果输入文件用“- ”表示，则从标准输入读取。 AD： uniq [选项] 文件 说明：这个命令读取输入文件，并比较相邻的行。在正常情况下，第二个
  • 正则表达式Pattern 肆无忌惮_ Pattern
    正则表达式是符合一定规则的表达式，用来专门操作字符串，对字符创进行匹配，切割，替换，获取。   例如，我们需要对QQ号码格式进行检验 规则是长度6~12位  不能0开头  只能是数字，我们可以一位一位进行比较，利用parseLong进行判断，或者是用正则表达式来匹配[1-9][0-9]{4,14} 或者 [1-9]\d{4,14} &nbs
  • Oracle高级查询之OVER (PARTITION BY ..) 知了ing oraclesql
    一、rank()/dense_rank() over(partition by ...order by ...) 现在客户有这样一个需求，查询每个部门工资最高的雇员的信息，相信有一定oracle应用知识的同学都能写出下面的SQL语句： select e.ename, e.job, e.sal, e.deptno from scott.emp e, (se
  • Python调试 矮蛋蛋 pythonpdb
    原文地址： http://blog.csdn.net/xuyuefei1988/article/details/19399137 1、下面网上收罗的资料初学者应该够用了，但对比IBM的Python 代码调试技巧： IBM：包括 pdb 模块、利用 PyDev 和 Eclipse 集成进行调试、PyCharm 以及 Debug 日志进行调试： http://www.ibm.com/d
  • webservice传递自定义对象时函数为空，以及boolean不对应的问题 alleni123 webservice
    今天在客户端调用方法 NodeStatus status=iservice.getNodeStatus(). 结果NodeStatus的属性都是null。 进行debug之后，发现服务器端返回的确实是有值的对象。 后来发现原来是因为在客户端，NodeStatus的setter全部被我删除了。 本来是因为逻辑上不需要在客户端使用setter， 结果改了之后竟然不能获取带属性值的
  • java如何干掉指针，又如何巧妙的通过引用来操作指针————>说的就是java指针 百合不是茶
    C语言的强大在于可以直接操作指针的地址，通过改变指针的地址指向来达到更改地址的目的,又是由于c语言的指针过于强大，初学者很难掌握， java的出现解决了c，c++中指针的问题 java将指针封装在底层，开发人员是不能够去操作指针的地址，但是可以通过引用来间接的操作：   定义一个指针p来指向a的地址（&是地址符号）：        
  • Eclipse打不开，提示“An error has occurred.See the log file ***/.log” bijian1013 eclipse
    打开eclipse工作目录的\.metadata\.log文件，发现如下错误： !ENTRY org.eclipse.osgi 4 0 2012-09-10 09:28:57.139 !MESSAGE Application error !STACK 1 java.lang.NoClassDefFoundError: org/eclipse/core/resources/IContai
  • spring aop实例annotation方法实现 bijian1013 javaspringAOPannotation
            在spring aop实例中我们通过配置xml文件来实现AOP，这里学习使用annotation来实现，使用annotation其实就是指明具体的aspect,pointcut和advice。1.申明一个切面(用一个类来实现)在这个切面里,包括了advice和pointcut AdviceMethods.jav
  • [Velocity一]Velocity语法基础入门 bit1129 velocity
    用户和开发人员参考文档 http://velocity.apache.org/engine/releases/velocity-1.7/developer-guide.html   注释 1.行级注释## 2.多行注释#*  *#   变量定义 使用$开头的字符串是变量定义，例如$var1, $var2,   赋值 使用#set为变量赋值，例
  • 【Kafka十一】关于Kafka的副本管理 bit1129 kafka
    1. 关于request.required.acks   request.required.acks控制者Producer写请求的什么时候可以确认写成功，默认是0， 0表示即不进行确认即返回。 1表示Leader写成功即返回，此时还没有进行写数据同步到其它Follower Partition中 -1表示根据指定的最少Partition确认后才返回，这个在   Th
  • lua统计nginx内部变量数据 ronin47 lua nginx　 统计
    server { listen 80; server_name photo.domain.com; location /{set $str $uri; content_by_lua ' local url = ngx.var.uri local res = ngx.location.capture(
  • java-11.二叉树中节点的最大距离 bylijinnan java
    import java.util.ArrayList; import java.util.List; public class MaxLenInBinTree { /* a. 1 / \ 2 3 / \ / \ 4 5 6 7 max=4 pass "root"
  • Netty源码学习-ReadTimeoutHandler bylijinnan javanetty
    ReadTimeoutHandler的实现思路： 开启一个定时任务，如果在指定时间内没有接收到消息，则抛出ReadTimeoutException 这个异常的捕获，在开发中，交给跟在ReadTimeoutHandler后面的ChannelHandler，例如 private final ChannelHandler timeoutHandler = new ReadTim
  • jquery验证上传文件样式及大小(好用) cngolon 文件上传jquery验证
    <!DOCTYPE html> <html> <head> <meta http-equiv="Content-Type" content="text/html; charset=utf-8" /> <script src="jquery1.8/jquery-1.8.0.
  • 浏览器兼容【转】 cuishikuan css浏览器IE
    浏览器兼容问题一：不同浏览器的标签默认的外补丁和内补丁不同 问题症状：随便写几个标签，不加样式控制的情况下，各自的margin 和padding差异较大。 碰到频率:100% 解决方案：CSS里    *{margin:0;padding:0;} 备注：这个是最常见的也是最易解决的一个浏览器兼容性问题，几乎所有的CSS文件开头都会用通配符*来设
  • Shell特殊变量：Shell $0, $#, $*, $@, $?, $$和命令行参数 daizj shell$#$?特殊变量
    前面已经讲到，变量名只能包含数字、字母和下划线，因为某些包含其他字符的变量有特殊含义，这样的变量被称为特殊变量。例如，$ 表示当前Shell进程的ID，即pid，看下面的代码： $echo $$ 运行结果 29949   特殊变量列表 变量 含义 $0 当前脚本的文件名 $n 传递给脚本或函数的参数。n 是一个数字，表示第几个参数。例如，第一个
  • 程序设计KISS 原则-------KEEP IT SIMPLE, STUPID! dcj3sjt126com unix
    翻到一本书，讲到编程一般原则是kiss：Keep It Simple, Stupid.对这个原则深有体会，其实不仅编程如此，而且系统架构也是如此。 KEEP IT SIMPLE, STUPID! 编写只做一件事情，并且要做好的程序；编写可以在一起工作的程序，编写处理文本流的程序，因为这是通用的接口。这就是UNIX哲学.所有的哲学真 正的浓缩为一个铁一样的定律，高明的工程师的神圣的“KISS 原
  • android Activity间List传值 dcj3sjt126com Activity
    第一个Activity： import java.util.ArrayList;import java.util.HashMap;import java.util.List;import java.util.Map;import android.app.Activity;import android.content.Intent;import android.os.Bundle;import a
  • tomcat 设置java虚拟机内存 eksliang tomcat 内存设置
    转载请出自出处：http://eksliang.iteye.com/blog/2117772 http://eksliang.iteye.com/ 常见的内存溢出有以下两种: java.lang.OutOfMemoryError: PermGen space java.lang.OutOfMemoryError: Java heap space   ------------
  • Android 数据库事务处理 gqdy365 android
    使用SQLiteDatabase的beginTransaction()方法可以开启一个事务，程序执行到endTransaction() 方法时会检查事务的标志是否为成功，如果程序执行到endTransaction()之前调用了setTransactionSuccessful() 方法设置事务的标志为成功则提交事务，如果没有调用setTransactionSuccessful() 方法则回滚事务。事
  • Java 打开浏览器 hw1287789687 打开网址open浏览器open browser打开url打开浏览器
    使用java 语言如何打开浏览器呢? 我们先研究下在cmd窗口中,如何打开网址 使用IE 打开 D:\software\bin>cmd /c start iexplore http://hw1287789687.iteye.com/blog/2153709 使用火狐打开 D:\software\bin>cmd /c start firefox http://hw1287789
  • ReplaceGoogleCDN：将 Google CDN 替换为国内的 Chrome 插件 justjavac chromeGooglegoogle apichrome插件
    Chrome Web Store 安装地址： https://chrome.google.com/webstore/detail/replace-google-cdn/kpampjmfiopfpkkepbllemkibefkiice 由于众所周知的原因，只需替换一个域名就可以继续使用Google提供的前端公共库了。 同样，通过script标记引用这些资源，让网站访问速度瞬间提速吧
  • 进程VS.线程 m635674608 线程
    资料来源： http://www.liaoxuefeng.com/wiki/001374738125095c955c1e6d8bb493182103fac9270762a000/001397567993007df355a3394da48f0bf14960f0c78753f000 1、Apache最早就是采用多进程模式 2、IIS服务器默认采用多线程模式 3、多进程优缺点 优点： 多进程模式最大
  • Linux下安装MemCached 字符串 memcached
    前提准备：1. MemCached目前最新版本为：1.4.22，可以从官网下载到。2. MemCached依赖libevent，因此在安装MemCached之前需要先安装libevent。2.1 运行下面命令，查看系统是否已安装libevent。[root@SecurityCheck ~]# rpm -qa|grep libevent libevent-headers-1.4.13-4.el6.n
  • java设计模式之--jdk动态代理（实现aop编程） Supanccy2013 javaDAO设计模式AOP
        与静态代理类对照的是动态代理类，动态代理类的字节码在程序运行时由Java反射机制动态生成，无需程序员手工编写它的源代码。动态代理类不仅简化了编程工作，而且提高了软件系统的可扩展性，因为Java 反射机制可以生成任意类型的动态代理类。java.lang.reflect 包中的Proxy类和InvocationHandler 接口提供了生成动态代理类的能力。 &
  • Spring 4.2新特性-对java8默认方法(default method)定义Bean的支持 wiselyman spring 4
    2.1 默认方法(default method) java8引入了一个default medthod; 用来扩展已有的接口,在对已有接口的使用不产生任何影响的情况下,添加扩展 使用default关键字 Spring 4.2支持加载在默认方法里声明的bean 2.2 将要被声明成bean的类 public class DemoService {
按字母分类： ABCDEFGHIJKLMNOPQRSTUVWXYZ其他