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<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"))
扫一扫
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
