python数据分析之聚类模型与半监督学习-第八次笔记

╰+攻爆jí腚メ 2022-05-17 11:43 349阅读 0赞

## 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部分的边的数量。**

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

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

#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()

![这里写图片描述][70 1]

## 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<thd:
                        continue
                    freq_items.append((self.apr_layers[layer].d[node].s,self.apr_layers[layer].d[node].num))
            freq_items.sort(key=lambda x:x[1],reverse = True)
            return freq_items[:hd]
    
        def getConf(self,low=True, h_thd=10, l_thd=1, hd=1):
            confidence = []
            for layer in self.apr_layers:
                for node in self.apr_layers[layer].d:
                    if self.apr_layers[layer].d[node].num < h_thd:
                        continue
                    for lnk_node in node.lnk_nodes:
                        if lnk_node.num < l_thd:
                            continue
                        conf = float(lnk_node.num) / float(node.num)
                        confidence.append([node.s, node.num, lnk_node.s, lnk_node.num, conf])
    
            confidence.sort(key=lambda x: x[4])
            if low:
                return confidence[:hd]
            else:
                return confidence[-hd::-1]
    
    class AssctAnaClass():
        #建立一个AprBlk
        def fit(self,data):
            self.apr_blk=AprBlk(data)
            return self
        #定义阈值
        def get_freq(self,thd=1,hd=1):
            return self.apr_blk.getFreqItems(thd=thd,hd=hd)
        def get_conf_high(self,thd,h_thd=10):
            return self.apr_blk.getConf(low=False, h_thd=h_thd, l_thd=thd)
        def get_conf_low(self,thd,hd,l_thd=1):
            return self.apr_blk.getConf(h_thd=thd,l_thd=l_thd,hd=hd)
    
    
    def main():
        data=[
            ["牛奶","啤酒","尿布"],
            ["牛奶","啤酒","咖啡","尿布"],
            ["香肠","牛奶","饼干"],
            ["尿布","果汁","啤酒"],
            ["钉子","啤酒"],
            ["尿布","毛巾","香肠"],
            ["啤酒","毛巾","尿布","饼干"]
        ]
        #输出频繁项集  参数thd=3指的 是数量,hd=10
        print("Freq",AssctAnaClass().fit(data).get_freq(thd=3,hd=10))
        #置信度
        print("Conf",AssctAnaClass().fit(data).get_conf_high(thd=3,h_thd=3))
    if __name__=="__main__":
        main()

## 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"))

[70]: /images/20220517/24aad615a7ac4115b5fc641a66537c8c.png
[70 1]: /images/20220517/c802b2763e5941668dda58ac9b04a9f6.png