【云计算】python数据分析之聚类模型与半监督学习笔记-职坐标

【云计算】python数据分析之聚类模型与半监督学习笔记

小标 2019-02-20 来源：阅读 1941 评论 0

摘要：本文主要向大家介绍了【云计算】python数据分析之聚类模型与半监督学习笔记，通过具体的内容向大家展现，希望对大家学习云计算有所帮助。

本文主要向大家介绍了【云计算】python数据分析之聚类模型与半监督学习笔记，通过具体的内容向大家展现，希望对大家学习云计算有所帮助。

【云计算】python数据分析之聚类模型与半监督学习笔记

1.聚类模型

–*1.1基于切割的—K-means算法

–*1.2基于密度的—DBSCAN算法

–*1.3基于层次的聚类算法

–*1.4基于图裂法的—-Split算法

2.关联，序列模型

–*2.1关联规则—Apriori算法

–*2.2序列规则

3.半监督学习

–*3.1标签传播算法

1.聚类模型

导入模块

import numpy as np
import matplotlib.pyplot as plt
#生成点数据
from sklearn.datasets import make_circles,make_blobs,make_moons
#Kmeans算法,基于密度的DBSCAN算法,AgglomerativeClustering层次聚类
from sklearn.cluster import KMeans,DBSCAN,AgglomerativeClustering

导入数据

#生成数据
#生成1000个点
n_samples=1000
#factor参数，指的是小圆与大圆之间的差距
circles=make_circles(n_samples=n_samples,factor=0.5,noise=0.05)
moons=make_moons(n_samples=n_samples,noise=0.05)
#8个随机位置 center_box，中心在（-1,1）之间cluster_std标准差
blobs=make_blobs(n_samples=n_samples,random_state=8,center_box=(-1,1),cluster_std=0.1)
#2维的
random_data=np.random.rand(n_samples,2),None
#设置颜色
colors="bgrcmyk"
#组织数据有4个数据集
data=[circles,moons,blobs,random_data]

1.1基于切割的K-means算法

算法流程：

1>从n个样本中随机选取k个作为初始化的质心；

2>对每个样本测量其到每个质心的距离，并把他们归到最近的质心的类；

3>重新计算已经得到的各个类的质心；

4>迭代2-3步直至新的质心与原质心相等或小于指定的阈值，算法结束

from sklearn.cluster import KMeans
models.append("Kmeans",KMeans(n_clusters=3))

1.2基于密度的DBSCAN算法

from sklearn.cluster import DBSCAN
models.append("DBSCAN",DBSCAN(min_samples=3,eps=0.2)

1.3基于层次的聚类算法

from sklearn.cluster import AgglomerativeClustering
models.append("Agglomerative",AgglomerativeClustering(n_clusters=3,linkage="ward"))

1.4基于图裂法的Split算法

在这里定义了2个概念，承受系数*t和分裂阈值landa*。承受因为t就是要分裂的2部分中的较轻的一端的重量/连接2部分的边数，意思就是平均每条边所要承受的点的个数。公式如下：

t=min{W1,W2}/n，W1,W2为分割后的2部分的点的个数，n为2连接2部分的边的数量。

理解了这个，就很好分裂阈值了，分裂阈值就是当前针对全部的连通图，每条边的承受状况指数，你可以理解为就是总坐标点数/总边数。但是我们在这里采用更科学的方式进行计算，大意还是如上面描述的那样：

我们就能得出一个比较条件了，就是当根据某条边进行分割的时候，如果此时计算出来的承受系数大于等于分裂阈值的时候，就表明此边是可以被分割掉的，也就是说，此时的连通图可以继续被拆分掉。

完整程序：

#encoding utf-8
# time: 2018/08/09
# name: py粉
import numpy as np
import matplotlib.pyplot as plt
#生成点数据
from sklearn.datasets import make_circles,make_blobs,make_moons
#Kmeans算法,基于密度的DBSCAN算法,AgglomerativeClustering层次聚类
from sklearn.cluster import KMeans,DBSCAN,AgglomerativeClustering

#生成数据
#生成1000个点
n_samples=1000
#factor参数，指的是小圆与大圆之间的差距
circles=make_circles(n_samples=n_samples,factor=0.5,noise=0.05)
moons=make_moons(n_samples=n_samples,noise=0.05)
#8个随机位置 center_box，中心在（-1,1）之间cluster_std标准差
blobs=make_blobs(n_samples=n_samples,random_state=8,center_box=(-1,1),cluster_std=0.1)
#2维的
random_data=np.random.rand(n_samples,2),None
#设置颜色
colors="bgrcmyk"
#组织数据有4个数据集
data=[circles,moons,blobs,random_data]

#models模型集  min_samples最小点数,E邻域
models=[("None",None),("Kmeans",KMeans(n_clusters=3)),
        ("DBSCAN",DBSCAN(min_samples=3,eps=0.2)),
        ("Agglomerative",AgglomerativeClustering(n_clusters=3,linkage="ward"))]
from sklearn.metrics import silhouette_score

#绘图
f=plt.figure()
#inx,下标，clt代表的就是模型指的是("None",None)
for inx,clt in enumerate(models):
    #指定模型的名字和实体
    clt_name,clt_entity=clt
    for i,dataset in enumerate(data):
        #数组，x表示第一部分，Y是第二部分标注
        X,Y=dataset
        #实体是空的，赋0
        if not clt_entity:
            clt_res=[0 for item in range(len(X))]
        else:
            clt_entity.fit(X)
            clt_res=clt_entity.labels_.astype(np.int)
        #加子图：len(models)行号,len(data)列号,inx*len(data)+i+1子图画的位置
        f.add_subplot(len(models),len(data),inx*len(data)+i+1)
        #标题头
        plt.title(clt_name)
        try:
            print(clt_name,i,silhouette_score(X,clt_res))
        except:
            pass

        #绘制plt.scatter散点图
        [plt.scatter(X[p,0],X[p,1],color=colors[clt_res[p]]) for p in range(len(X))]
plt.show()

2.关联，序列模型

2.1关联规则

反映了一个事物与其他事物之间的相互依存性和关联性

用途：

在实际生活中，一般用于，交易市场，比如著名的“尿布”和“啤酒”现象

2.2序列规则

序列规则将时间因素考虑进来，剔除关联规则中时间点靠后的项对时间点靠前的项的支持

关联，序列模型的源码，改main()函数的数据就可以调用了。

#encoding utf-8
# time: 2018/08/09
# name: py粉
from itertools import combinations
def comb(lst):
    ret=[]
    #i 是项集的个数  combinations提取项集
    for i in range(1,len(lst)+1):
        ret+=list(combinations(lst,i))
    return ret
class AprLayer(object):
    d=dict()
    def __init__(self):
        self.d=dict()
class AprNode(object):
    def __init__(self,node):
        self.s=set(node)
        self.size=len(self.s)
        self.lnk_nodes=dict()
        self.num=0
    def __hash__(self):
        return hash("__".join(sorted([str(itm) for itm in list(self.s)])))
    def __eq__(self, other):
        if "__".join(sorted([str(itm) for itm in list(self.s)]))=="__".join(sorted([str(itm) for itm in list(other.s)])):
            return True
        return False
    def isSubnode(self,node):
        return self.s.issubset(node.s)
    def incNum(self,num=1):
        self.num+=num
    def addLnk(self,node):
        self.lnk_nodes[node]=node.s

class AprBlk():
    def __init__(self,data):
        cnt=0
        self.apr_layers = dict()
        self.data_num=len(data)
        for datum in data:
            cnt+=1
            datum=comb(datum)
            #da是项集的组合
            nodes=[AprNode(da) for da in datum]
            for node in nodes:
                if not node.size in self.apr_layers:
                    self.apr_layers[node.size]=AprLayer()
                if not node in self.apr_layers[node.size].d:
                    self.apr_layers[node.size].d[node]=node
                self.apr_layers[node.size].d[node].incNum()
            for node in nodes:
                if node.size==1:
                    continue
                for sn in node.s:
                    sub_n=AprNode(node.s-set([sn]))
                    self.apr_layers[node.size-1].d[sub_n].addLnk(node)

    def getFreqItems(self,thd=1,hd=1):
        freq_items=[]
        for layer in self.apr_layers:
            for node in self.apr_layers[layer].d:
                if self.apr_layers[layer].d[node].num

3.半监督学习

半监督学习就是：一部分数据没有标签，我们要研究其数据的结果。一般是利用标签传播算法。

导入模块

import numpy as np
from sklearn import datasets
from sklearn.semi_supervised import LabelPropagation

导入数据

from sklearn import datasets
iris=datasets.load_iris()
#print(iris)
#标签
labels=np.copy(iris.target)
#print(labels)
#随机选一些，标签设置为（0-1之间）
random_unlabels_points=np.random.rand(len(iris.target))
#print(random_unlabels_points)
#小于0.3的为True即为1，大于0.3的数为False
random_unlabels_points=random_unlabels_points<0.3
#print(random_unlabels_points)
#把True（为1）随机抽取的的标签的值换为-1
Y=labels[random_unlabels_points]
#print(Y)
labels[random_unlabels_points]=-1
#print(iris.target)
#print(labels)
print("Unlabels Number",list(labels).count(-1))

3.1标签传播算法

标签传播算法是：把没有标签的数据，以最近的已知数据分类标注为标注赋值。然后分类。

from sklearn.semi_supervised import LabelPropagation
label_prop_model=LabelPropagation()
label_prop_model.fit(iris.data,labels)
Y_pred=label_prop_model.predict(iris.data)
Y_pred=Y_pred[random_unlabels_points]

完整程序：

#encoding utf-8
# time: 2018/08/09
# name: py粉
import numpy as np
from sklearn import datasets
iris=datasets.load_iris()
#print(iris)
#标签
labels=np.copy(iris.target)
#print(labels)
#随机选一些，标签设置为（0-1之间）
random_unlabels_points=np.random.rand(len(iris.target))
#print(random_unlabels_points)
#小于0.3的为True即为1，大于0.3的数为False
random_unlabels_points=random_unlabels_points<0.3
#print(random_unlabels_points)
#把True（为1）随机抽取的的标签的值换为-1
Y=labels[random_unlabels_points]
#print(Y)
labels[random_unlabels_points]=-1
#print(iris.target)
#print(labels)
print("Unlabels Number",list(labels).count(-1))

from sklearn.semi_supervised import LabelPropagation
label_prop_model=LabelPropagation()
label_prop_model.fit(iris.data,labels)
Y_pred=label_prop_model.predict(iris.data)
Y_pred=Y_pred[random_unlabels_points]
from sklearn.metrics import accuracy_score,recall_score,f1_score

print("ACC",accuracy_score(Y,Y_pred))
print("REC",recall_score(Y,Y_pred,average="micro"))
print("F-score",f1_score(Y,Y_pred,average="micro"))