（1-3）sklearn库的模型----无监督学习

声明：本文章涉及到的思想已被分解为文档一

1.无监督学习中的聚类算法之 k-means聚类算法–

from sklearn.cluster import KMeansKMeans(n_clusters=8, init='k-means++', n_init=10, max_iter=300, tol=0.0001, precompute_distances='auto', verbose=0, random_state=None, copy_x=True, n_jobs=1, algorithm='auto')

n_clusters: 指定聚类中心的个数
最大迭代次数，设置最大迭代次数可以控制时间，否则程序运行时间会非常长；

数据请见（电脑F盘）或（腾讯微云文件“Redhur的进阶“）的{python数据—test2}

北京,2959.19,730.79,749.41,513.34,467.87,1141.82,478.42,457.64
天津,2459.77,495.47,697.33,302.87,284.19,735.97,570.84,305.08
河北,1495.63,515.90,362.37,285.32,272.95,540.58,364.91,188.63
山西,1406.33,477.77,290.15,208.57,201.50,414.72,281.84,212.10
…

import numpy as np
from sklearn.cluster import KMeansdef loadData(filePath):fr = open(filePath,'r+',encoding='utf-8')lines = fr.readlines()retData = []retCityName = []for line in lines:items = line.strip().split(",")retCityName.append(items[0])retData.append([float(items[i]) for i in range(1,len(items))])return retData,retCityName'''
retData大致的模样是：
[[2959.19, 730.79, 749.41, 513.34, 467.87, 1141.82, 478.42, 457.64],
[2459.77, 495.47, 697.33, 302.87, 284.19, 735.97, 570.84, 305.08]...] K-Means聚类算法默认用的是欧氏距离
'''if __name__=='__main__':filepath = r'E:\快乐的程序猿\city.txt'data,cityName=loadData(filepath)  km=KMeans(n_clusters=4)          #n_cluster用于指定聚类中心的个数label=km.fit_predict(data)       #fit_predict()：计算簇中心以及为簇分配序号；#label：聚类后各数据所属的标签，大致是[2 0 3 3 3 1 3 3 2 0 0 1 0 3 1 3 1 1 2 1 1 0 1 1 0 0 3 3 3 3 3]的样子print(km.cluster_centers_) ##每个簇的每种消费的mean值print("--------------------------------------------------------------------")expenses=np.sum(km.cluster_centers_,axis=1)  #每个簇的平均总消费（）print(expenses)print("--------------------------------------------------------------------")CityCluster=[[],[],[],[]]      #将城市 按label分成设定的簇，将每个簇的城市输出for i in range(len(cityName)):CityCluster[label[i]].append(cityName[i])for i in range(len(CityCluster)):print("Expenses:{}.2f" .format(expenses[i]))print(CityCluster[i])

字典和列表的输出

cityName=[‘北京’,‘上海’,…]是一个包含31个省份名字的列表
label=[2 0 3 3 3 1 …]含有31个数字代表相应省份所在的蔟。
label是根据省份消费水平划分的蔟，label里面的0代表第0个蔟，一共有0、1、2、3四个蔟

现在想要把每个蔟里面的省份输出来

CityCluster=[[],[],[],[]]   #四个蔟
for i in range(len(cityName)):CityCluster[label[i]].append(cityName[i])
for i in range(len(CityCluster)):print(CityCluster[i])

2.无监督学习中的聚类算法之 Dbscan聚类算法–

数据请见（电脑F盘）或（腾讯微云文件“Redhur的进阶“）的{python数据—test1}

1.根据上网的时间（几点上的网）进行聚类

import numpy as np
import sklearn.cluster as skc
from sklearn import metrics
import matplotlib.pyplot as pltmac2id = dict()
"""
在mac2id这个字典里：
键key是MAC地址
值value是字典里面对应的序号
"""
onlinetimes = []
f = open("F:/python数据/test1.txt",encoding='utf8')
for line in f:data = line.split(',')mac = data[2] #读取Mac地址onlinetime = int(data[6])   #读取上网时长starttime =  int(data[4].split(' ')[1].split(':')[0])  #读取开始时间（我们只要年月日时分秒里的“时”）mac2id[mac] = len(onlinetimes)  #len(onlinetimes)就是此时对应的onlinetimes里面的元素个数，mac2id的内容见下面onlinetimes.append((starttime,onlinetime))#onlinetimes里面的内容见下面#onlinetimes里面的内容是[(22, 1558), (12, 40261), (22, 1721), (23, 351), (16, 23564),,,]
#mac2id这个字典里面是{'A417314EEA7B': 0, 'F0DEF1C78366': 1, '88539523E88D': 2,,,,'3CDFBD175878': 287, '002427FE3712': 288}real_X = np.array(onlinetimes).reshape((-1,2)) #参数-1可以自动确定行数X = real_X[:,0:1] # 截取第一列（也就是“上网时间”），我们是要根据上网的时间进行蔟类'''
real_X为：
[[    22   1558][    12  40261][    22   1721][    23    351][    16  23564][    23   1162][    22   3540]...]X为：
[[22][12][22][23][16][23][22]...]
'''db = skc.DBSCAN(eps=0.01,min_samples=20,metric = 'euclidean').fit(X) #调用Dbscan的的方法进行训练
# eps:两个样本被看作邻居节点的最大距离
# min_sample:簇的样本数
# metrics:距离计算方式（默认欧几里得距离）labels = db.labels_
print("Labels")
print(labels)
ratio = len(labels[labels[:]==-1]) / len(labels) # 判定噪声数据（label被打上-1）数据所占的比例
print("Noise ratio:{:.2f}".format(ratio)) #输出噪声数据所占的比例n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)  #减去噪声数据-1占的位置
print("Estimate number of clusters:%d"%n_clusters_)#输出蔟的个数print("Silhouette Coefficient: %0.3f"% metrics.silhouette_score(X, labels))#输出蔟类效果评价指标（轮廓系数）
#轮廓系数（Silhouette Coefficient）的值是介于 [-1,1] ，越趋近于1代表内聚度和分离度都相对较优for i in range(n_clusters_):print("Cluster",i,":")print(list(X[labels==i].flatten()))# flatten()方法:将numpy对象（如array、mat）折叠成一维数组返回plt.hist(X,24)
plt.show()

相同思想的例题：

import numpy as np
city=['太原','北京','上海','成都','西安','南京','广州','西宁']
rank=[  2,    0,      0,     1,     1,    1,    0,      2  ] #城市对应的排名
ranks=np.array(rank)
citys=np.array(city)print(ranks[:]==2)  #[False False False  True  True  True False False]
print('----------------------------------------------------')num=len( ranks[ranks[:]==2] )   #ranks里面元素等于2的元素的数量（也就是排名第二的城市的数量）
print(num)
print('----------------------------------------------------')print( citys[ranks[:]==2]  )  #输出排名第二的城市
print('----------------------------------------------------')print( set(ranks) )
print('----------------------------------------------------')for i in range( len(set(ranks)) ):print('排名第',i,'的城市是：')print( citys[ranks[:]==i] )
print('----------------------------------------------------')

2.根据上网的总时长进行聚类

import numpy as np
import sklearn.cluster as skc
from sklearn import metricsmac2id = dict()
"""
key是MAC地址
value是开始上网时间和上网时长
"""
onlinetimes = []
f = open("F:/python数据/test1.txt",encoding='utf8')
for line in f:data = line.split(',')mac = data[2] #读取Mac地址onlinetime = int(data[6])   #读取上网时间starttime =  int(data[4].split(' ')[1].split(':')[0])  #读取开始时间（我们只要年月日时分秒里的“时”）mac2id[mac] = len(onlinetimes)  #len(onlinetimes)就是此时对应的onlinetimes里面的元素个数，mac2id的内容见下面onlinetimes.append((starttime,onlinetime))#onlinetimes里面的内容见下面#onlinetimes里面的内容是[(22, 1558), (12, 40261), (22, 1721), (23, 351), (16, 23564),,,]
#mac2id这个字典里面是{'A417314EEA7B': 0, 'F0DEF1C78366': 1, '88539523E88D': 2,,,,'3CDFBD175878': 287, '002427FE3712': 288}#-----------------------------------------以下内容进行了改动-------------------------------------------------------------real_X = np.array(onlinetimes).reshape((-1,2)) #参数-1可以自动确定行数X = real_X[:,1:] # 截取第二列（也就是“上网的总时长”）我们这次根据上网的总时长进行蔟类X=np.log(1+real_X[:,1:])#上网的总时长太大了，都是几千，我们要进行对数化处理db = skc.DBSCAN(eps=0.14,min_samples=10).fit(X) #调用Dbscan的的方法进行训练
# eps:两个样本被看作邻居节点的最大距离
# min_sample:簇的样本数
# metrics:距离计算方式（默认欧几里得距离）labels = db.labels_
print("Labels")
print(labels)
ratio = len(labels[labels[:]==-1]) / len(labels[:]) # 判定噪声数据（label被打上-1）数据所占的比例
print("Noise ratio:{:.2f}".format(ratio)) #输出噪声数据所占的比例
n_clusters_ = len(set(labels)) - (1 if -1 in labels else 0)
print("Estimate number of clusters:%d"%n_clusters_)#输出蔟的个数
print("Silhouette Coefficient: %0.3f"% metrics.silhouette_score(X, labels))#输出蔟类效果评价指标（轮廓系数）
#轮廓系数（Silhouette Coefficient）的值是介于 [-1,1] ，越趋近于1代表内聚度和分离度都相对较优for i in range(n_clusters_):print("Cluster",i,":")count=len(X[labels==i])mean=np.mean(real_X[labels==i][:,1])std=np.std(real_X[labels==i][:,1])print('\t number of sample:',count)print('\t mean of sample:',format(mean,'.1f'))print('\t std of sample:',format(std,'.1f'))

3.无监督学习中的降维算法之 PCA降维算法–

1.直接用numpy进行PCA（不需要看懂）

import numpy as np
n = 2                                         # 取对应特征值最大的n个特征向量
data = np.random.rand(10, 5)                  # （10行5列数据）生成10个样本，每个样本5个特征
mean = np.mean(data, axis=0)                  # 计算原始数据中每一列的均值，axis=0按列取均值
zeroCentred_data = data - mean                # 数据中心化，使每个feature的均值为0
covMat = np.cov(zeroCentred_data, rowvar=False)  # 计算协方差矩阵，rowvar=False表示数据的每一列代表一个feature
featValue, featVec = np.linalg.eig(covMat)    # 计算协方差矩阵的特征值和特征向量
index = np.argsort(featValue)                 # 将特征值按从小到大排序，index是对应原featValue中的下标
n_index = index[-n:]                          # 取最大的n个特征值在原featValue中的下标
n_featVec = featVec[:, n_index]               # 取最大的两维特征值对应的特征向量组成映射矩阵
low_dim_data = np.dot(zeroCentred_data, n_featVec)     # 降维后的数据

2.调用sklearn实现PCA

import numpy as np
from sklearn.decomposition import PCA
data = np.random.rand(10, 5)            # （生成10行5列数据）生成10个样本，每个样本5个特征
pca = PCA(n_components=2)
low_dim_data = pca.fit_transform(data)  # 每个样本降为2维

3.PCA的参数

sklearn.decomposition.PCA(n_components=None, copy=True, whiten=False)

n_components: PCA算法中所要保留的主成分个数，也即保留下来的特征个数，如果 n_components = 1，将把原始数据降到一维；
copy：True 或False，默认为True，即是否需要将原始训练数据复制。
whiten：True 或False，默认为False，即是否白化，使得每个特征具有相同的方差。

4.PCA对象的属性

explained_variance_ratio_：返回所保留各个特征的方差百分比，如果n_components没有赋值，则所有特征都会返回一个数值且解释方差之和等于1。
n_components_：返回所保留的特征个数。

5.PCA常用的方法

fit(X): 用数据X来训练PCA模型。
fit_transform(X)：用X来训练PCA模型，同时返回降维后的数据。
inverse_transform(newData) ：将降维后的数据转换成原始数据，但可能不会完全一样，会有些许差别。
transform(X)：将数据X转换成降维后的数据，当模型训练好后，对于新输入的数据，也可以用transform方法来降维。

简单的栗子：

import numpy as np
from sklearn.decomposition import PCA
X = np.array([[-1, -1], [-2, -1], [-3, -2], [1, 1], [2, 1], [3, 2]])
pca = PCA(n_components=2)
newX = pca.fit_transform(X)print(X)
Out[365]:
[[-1 -1][-2 -1][-3 -2][ 1  1][ 2  1][ 3  2]]print(newX)
Out[366]:
array([[ 1.38340578,  0.2935787 ],[ 2.22189802, -0.25133484],[ 3.6053038 ,  0.04224385],[-1.38340578, -0.2935787 ],[-2.22189802,  0.25133484],[-3.6053038 , -0.04224385]])print(pca.explained_variance_ratio_)
[ 0.99244289  0.00755711]

可以发现第一个特征可以99.24%表达整个数据集，因此我们可以降到1维：

pca = PCA(n_components=1)
newX = pca.fit_transform(X)
print(pca.explained_variance_ratio_)
[ 0.99244289]

实例–PCA鸢尾花数据集降维

import matplotlib.pyplot as plt
from sklearn.decomposition import PCA
from sklearn.datasets import load_irisdata = load_iris()                 # 以字典形式加载鸢尾花数据集
y = data.target                    # 使用y表示数据集中的标签
X = data.data                      # 使用X表示数据集中的属性数据
pca = PCA(n_components=2)          # 加载PCA算法，设置降维后主成分数目为2
reduced_X = pca.fit_transform(X)   # 对原始数据进行降维，保存在reduced_X中'''
print(reduced_X)得到：
[[-2.68412563  0.31939725][-2.71414169 -0.17700123][-2.88899057 -0.14494943][-2.74534286 -0.31829898][-2.72871654  0.32675451]...............[ 1.90094161  0.11662796][ 1.39018886 -0.28266094]]
'''red_x, red_y = [], []              # 第一类数据点
blue_x, blue_y = [], []            # 第二类数据点
green_x, green_y = [], []          # 第三类数据点for i in range(len(reduced_X)):    # 按照鸢尾花的类别将降维后的数据点保存在不同的列表中。if y[i] == 0:red_x.append(reduced_X[i][0])red_y.append(reduced_X[i][1])elif y[i] == 1:blue_x.append(reduced_X[i][0])blue_y.append(reduced_X[i][1])else:green_x.append(reduced_X[i][0])green_y.append(reduced_X[i][1])plt.scatter(red_x, red_y, c='r', marker='x')
plt.scatter(blue_x, blue_y, c='b', marker='D')
plt.scatter(green_x, green_y, c='g', marker='.')
plt.show()
#可以看出降维后的数据集仍能够分成三类，并没有改变数据的质量

本实例提取的思想

已知降到2维后的鸢尾花数据集为reduced_X=
[[-2.68412563  0.31939725][-2.71414169 -0.17700123][-2.88899057 -0.14494943][-2.74534286 -0.31829898][-2.72871654  0.32675451]...............[ 1.90094161  0.11662796][ 1.39018886 -0.28266094]]对应的标签为y=
[0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 0 00 0 0 0 0 0 0 0 0 0 0 0 0 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 11 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 1 2 2 2 2 2 2 2 2 2 2 22 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 2 22 2]我们要根据标签y里面的数字将reduced_X分开存储到六个列表里red_x, red_y = [], []              # 第一类数据点
blue_x, blue_y = [], []            # 第二类数据点
green_x, green_y = [], []          # 第三类数据点for i in range(len(reduced_X)):    if y[i] == 0:red_x.append(reduced_X[i][0])red_y.append(reduced_X[i][1])elif y[i] == 1:blue_x.append(reduced_X[i][0])blue_y.append(reduced_X[i][1])else:green_x.append(reduced_X[i][0])green_y.append(reduced_X[i][1])

以下例题是未搞明白的

4.无监督学习中的降维算法之 NMF降维算法–

实例

（以下代码只做了解）

import matplotlib.pyplot as plt
from sklearn import decomposition
#加载PCA算法包
from  sklearn.datasets import fetch_olivetti_faces
#加载人脸数据集
from numpy.random import RandomState
#加载RandomState用于创建随机种子
n_row,n_col = 2,3
#设置图像展示时的排列情况，2行三列
n_components = n_row * n_col
#设置提取的特征的数目
image_shape = (64,64)
#设置人脸数据图片的大小
dataset = fetch_olivetti_faces(shuffle=True,random_state=RandomState(0))
faces = dataset.data#加载数据，并打乱顺序
def plot_gallery(title,images,n_col=n_col,n_row=n_row):plt.figure(figsize=(2. * n_col,2.26 * n_row))#创建图片，并指定大小plt.suptitle(title,size=16)#设置标题及字号大小for i,comp in enumerate(images):plt.subplot(n_row,n_col,i+1)#选择画制的子图vmax = max(comp.max(),-comp.min())plt.imshow(comp.reshape(image_shape),cmap=plt.cm.gray,interpolation='nearest',vmin=-vmax,vmax=vmax)#对数值归一化，并以灰度图形式显示plt.xticks(())plt.yticks(())#去除子图的坐标轴标签plt.subplots_adjust(0.01,0.05,0.99,0.93,0.04,0.)
estimators=[('Eigenfaces - PCA using randomized SVD',decomposition.PCA(n_components=6,whiten=True)),('Non-negative components - NMF',decomposition.NMF(n_components=6,init='nndsvda',tol=5e-3))]
#NMF和PCA实例，将它们放在一个列表中
for name,estimators in estimators:#分别调用PCA和NMFestimators.fit(faces)#调用PCA或NMF提取特征components_=estimators.components_#获取提取特征plot_gallery(name,components_[:n_components])#按照固定格式进行排列
plt.show()#可视化

5.基于聚类的"图像分割"实例编写
（未搞明白，未摘抄）

import numpy as np
import PIL.Image as Image #加载PIL包，用于加载创建图片
from sklearn.cluster import  KMeans #加载Kmeans算法def loadData(filePath):data= []img=Image.open(filePath)m,n =img.size     #获得图片大小（width, height）for i in range(m):for j in range(n):x,y,z =img.getpixel((i,j))   #im.getpixel(x,y)返回给定位置的像素值。data.append([x/256.0,y/256.0,z/256.0])#将每个像素点RGB颜色处理到0-1范围内,将颜色值存入data内return np.mat(data),m,n #以矩阵的形式返回data，以及图片大小imgData,row,col =loadData('bull.png') #调用函数，获取数据
km=KMeans(n_clusters=3) #聚类获得每个像素所属的类别
label =km.fit_predict(imgData)
label=label.reshape([row,col])pic_new = Image.new("L",(row,col))#创建一张新的灰度图以保存聚类后的结果for i in range(row):for j in range(col):pic_new.putpixel((i,j),int(256/(label[i][j]+1))) #im.putpixel((x,y),(r,g,b)) 在指定位置(x,y)处画一像素pic_new.save("result-bull-4.jpg","JPEG") #以JPEG格式保存图像

（1-3）sklearn库的模型----无监督学习相关推荐

ID3决策树 Python实现 + sklearn库决策树模型的应用
本文介绍机器学习中决策树算法的python实现过程共介绍两类方法: (1)亲手实习Python ID3决策树经典算法 (2)利用sklearn库实现决策树算法关于决策树的原理,指路:机器学习第四 ...
利用sklearn库决策树模型对iris数据多分类并进行评估
1.导入所需要的库 from sklearn.tree import DecisionTreeClassifier from sklearn.datasets import load_iris 2.加 ...
（1-4）sklearn库的----模型评估
5,模型评估与选择务必记住那些指标适合分类,那些适合回归. 一,分类问题常见的分类模型包括:逻辑回归.决策树.朴素贝叶斯.SVM.神经网络等, 分类的模型评估指标包括以下几种: 1.TPR.FPR ...
Py之scikit-learn：机器学习sklearn库的简介、六大基本功能介绍(数据预处理/数据降维/模型选择/分类/回归/聚类)、安装、使用方法(实际问题中如何选择最合适的机器学习算法)之详细攻略
Py之scikit-learn:机器学习sklearn库的简介(组件/版本迭代).六大基本功能介绍(数据预处理/数据降维/模型选择/分类/回归/聚类).安装.使用方法(实际问题中如何选择最合适的机器学 ...
无监督学习 | GMM 高斯混合聚类原理及Sklearn实现
文章目录 1. 高斯混合聚类 1.1 高斯混合分布 1.2 参数求解 1.3 EM 算法 2. Sklearn 实现参考文献相关文章: 机器学习 | 目录机器学习 | 聚类评估指标机器学习 | ...
数据分析4——挖掘建模（监督学习中的分类、回归模型，无监督学习）
文章目录挖掘建模 1.机器学习与建模 2.训练集.测试集.验证集 3.监督学习中的分类模型 (1)KNN (2)朴素贝叶斯--适合离散数据 (3)生成模型与判别模型 (4)决策树安装Graphvi ...
隐马尔科夫模型(HMM)的无监督学习算法java实现（baum-welch迭代求解），包括串行以及并行实现
HMM的原理就不说了,这里主要说算法的实现. 实际实现起来并不是很困难,前提是你仔细看过hmm的原理,然后很多实现就照着公式写出对应的代码,比如前向算法,后向算法,参数更新都是有明确的公式的,只需要对 ...
无监督学习 | KMeans之Sklearn实现：电影评分聚类
文章目录 1. KMeans in Sklearn 2. Sklearn 实例:电影评分的 k 均值聚类 2.1 数据集概述 2.2 二维 KMeans 聚类 3. 肘部法选取最优 K 值 4. 多维 ...
无监督学习：从基本概念到四种实现模型
http://www.sohu.com/a/117638113_465975 这是今年 6 月份普渡大学副教授 Eugenio Culurciello 写的一篇关于无监督学习的概述性文章.除了基本概念 ...
深度 | 一篇文章带你进入无监督学习：从基本概念到四种实现模型（附论文）
作者:Eugenio Culurciello 机器之心编译参与:李亚洲.武竞微信公众号:(almosthuman2014)授权转载,禁止二次转载,点此为原文链接这是今年 6 月份普渡大学副教授 ...

（1-3）sklearn库的模型----无监督学习

以下例题是未搞明白的

（1-3）sklearn库的模型----无监督学习相关推荐

最新文章

热门文章