# 引入层次聚类函数, 树状图函数
from scipy.cluster.hierarchy import linkage, dendrogram
import matplotlib.pyplot as plt
# 引入坐标轴显示控制库
from matplotlib.ticker import MultipleLocator
import pandas as pd
 
%matplotlib inline

seeds_df = pd.read_csv("seeds-less-rows.csv")
seeds_df.head()

seeds_df.grain_variety.value_counts()

varieties = list(seeds_df.pop('grain_variety'))  # 去除类别
samples = seeds_df.values  # 去除 columns
samples

# 进行层次聚类
mergings = linkage(samples, method='complete')
 
# 绘制树状图
plt.figure(figsize=(10,6),dpi=80)
ax = plt.subplot(111)
dendrogram(mergings,
           labels=varieties,
           leaf_rotation=90,
           leaf_font_size=10,)
yminorLocator = MultipleLocator(0.2) 
ax.yaxis.set_minor_locator(yminorLocator)
plt.show()

# 得到某一层次上的分类结果
from scipy.cluster.hierarchy import fcluster
 
# 获取最大分类距离为 6 的层次聚类结果
labels = fcluster(mergings, 6, criterion='distance')
 
df = pd.DataFrame({'labels': labels, 'varieties': varieties})
# 统计每个簇中不同类别的个数
ct = pd.crosstab(df['labels'], df['varieties'])
ct

import pandas as pd
 
scores_df = pd.read_csv('eurovision-2016-televoting.csv', index_col=0)
country_names = list(scores_df.index)
scores_df.head()

# 填充 Nan 数据
scores_df = scores_df.fillna(12)
 
from sklearn.preprocessing import normalize
 
# 数据归一化处理
samples = normalize(scores_df.values)
samples

plt.figure(figsize=(10,12),dpi=80)
plt.subplots_adjust(hspace=0.5)
 
# single method distance clustering 最短距离
mergings = linkage(samples, method='single')
p1 = plt.subplot(211)
yminorLocator = MultipleLocator(0.05) 
p1.yaxis.set_minor_locator(yminorLocator)
dendrogram(mergings,
           labels=country_names,
           leaf_rotation=90,
           leaf_font_size=10,
)
p1.set_title("single-min distance",fontsize=18)
 
# complete method distance clustering 最长距离
mergings = linkage(samples, method='complete')
p2 = plt.subplot(212)
yminorLocator = MultipleLocator(0.05) 
p2.yaxis.set_minor_locator(yminorLocator)
dendrogram(mergings,
           labels=country_names,
           leaf_rotation=90,
           leaf_font_size=10,
)
p2.set_title("complete-max distance",fontsize=18)
 
plt.show()

import matplotlib.pyplot as plt
from sklearn.cluster import KMeans
import pandas as pd
 
df = pd.read_csv("ch1ex1.csv")
points = df.values
df.head()

plt.figure(figsize=(10, 6), dpi=80)
 
xs = points[:, 0]
ys = points[:, 1]
 
plt.scatter(xs, ys)
plt.show()

model = KMeans(n_clusters=3)
model.fit(points)
labels = model.predict(points)
print(labels)

# 聚类中心
centroids = model.cluster_centers_
centroids_x = centroids[:, 0]  # 重心 x 坐标
centroids_y = centroids[:, 1]  # 重心 y 坐标
 
# 原始数据点
xs = points[:, 0]
ys = points[:, 1]
 
# 创建标记和颜色 list
mk0 = ['o', ',', 'v']  # 符号形状
cs0 = ['r', 'g', 'b']  # 颜色
mk1 = []  # 各个点的符号形状
cs1 = []  # 各个点的颜色
for e in labels:
    mk1.append(mk0[e])
    cs1.append(cs0[e])
    
plt.figure(figsize=(10, 6), dpi=120)
plt.subplot(111)
for x, y, cr, m in zip(xs, ys, cs1, mk1):
    plt.scatter(x, y, edgecolors=cr, facecolors='none', marker=m)
plt.scatter(centroids_x, centroids_y, marker='X', s=200, c='k')  # 绘制重心
plt.show()

import pandas as pd
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
 
seeds_df = pd.read_csv('seeds-less-rows.csv')
varieties = list(seeds_df['grain_variety'])
del seeds_df['grain_variety']
samples = seeds_df.values
ks = range(1, 6)
inertias = []
 
for k in ks:
    # Create a KMeans instance with k clusters: model
    model = KMeans(n_clusters=k)
    # Fit model to samples
    model.fit(samples)
    # Append the inertia to the list of inertias
    inertias.append(model.inertia_)
    
plt.figure(figsize=(10,6),dpi=80)
plt.subplot(111)
# Plot ks vs inertias
plt.plot(ks, inertias, '-o')
plt.xlabel('number of clusters, k')
plt.ylabel('inertia')
plt.xticks(ks)
plt.show()

import pandas as pd
 
df = pd.read_csv('fish.csv')
species = list(df['species'])
del df['species']
df.head()

from sklearn.pipeline import make_pipeline
from sklearn.preprocessing import StandardScaler
from sklearn.cluster import KMeans
 
samples = df.values
scaler = StandardScaler()
kmeans = KMeans(n_clusters=4)
 
pipeline = make_pipeline(scaler, kmeans)
pipeline.fit(samples)
 
labels = pipeline.predict(samples)
df = pd.DataFrame({'labels': labels, 'species': species})
ct = pd.crosstab(df['labels'], df['species'])
ct

#16-10.py
 
import numpy as np
import matplotlib.pyplot as plt
from sklearn import datasets
from sklearn.cluster import DBSCAN
from collections import  Counter
%matplotlib inline
 
plt.figure(figsize=(12,8),dpi=100)
 
# Generate the Data Source with sklearn
"""
make_moons 是函数用来生成数据集 
n_numbers:生成样本数量
shuffle:数据是否打乱
noise:默认是 false，数据集是否加入高斯噪声
random_state:生成随机种子，给定一个 int 型数据，能够保证每次生成数据相同。
"""
X1, _ = datasets.make_moons(n_samples=500, noise=.05)
X2, _ = datasets.make_blobs(n_samples=100, n_features=2, centers=[[1.2,1.2]], 
                           cluster_std=[[.1]],random_state=9)
X = np.concatenate((X1, X2))
 
# colors and markers for the scatter graph
# 前 6 个为分类标识, 最后一个为噪声点标识
colors = ['black','green','yellow','brown','blue','orange','red']
markers = ['o',',','v','^','<','>','x']
 
# Graph for the Data Source
p11 = plt.subplot(221)
p11.set_title('Data Source Graph')
plt.scatter(X[:, 0], X[:, 1],c=colors[0], marker=markers[0])
 
# Graph for the clustering with default params
p12 = plt.subplot(222)
p12.set_title('Clustering BY DB with Defaut params')
y_pred = DBSCAN().fit_predict(X)
for x,y,i in zip(X[:,0],X[:,1],y_pred):
    plt.scatter(x,y,c=colors[i],marker=markers[i])
 
# Graph for the clustering with specified params
p21 = plt.subplot(223)
p21.set_title('Clustering BY DB with Eps=0.1')
y_pred = DBSCAN(eps = 0.10, min_samples = 10).fit_predict(X)
for x,y,i in zip(X[:,0],X[:,1],y_pred):
    plt.scatter(x,y,c=colors[i],marker=markers[i])
    
# Graph for the clustering with specified params    
p22 = plt.subplot(224)
p22.set_title('Clustering BY DB with Eps=0.12')
y_pred = DBSCAN(eps = 0.12, min_samples = 10).fit_predict(X)
for x,y,i in zip(X[:,0],X[:,1],y_pred):
    plt.scatter(x,y,c=colors[i],marker=markers[i])
 
plt.show()

import pandas as pd
 
beer = pd.read_csv('data.txt', sep=' ')
beer

from sklearn.cluster import KMeans
 
X = beer[['calories', 'sodium', 'alcohol', 'cost']]
 
km2 = KMeans(n_clusters=2).fit(X)  # K = 2 时的聚类结果
km3 = KMeans(n_clusters=3).fit(X)  # K = 3 时的聚类结果
beer['cluster2'] = km2.labels_
beer['cluster3'] = km3.labels_
beer.sort_values('cluster2')

beer.groupby('cluster2').mean()

beer.groupby('cluster3').mean()

import matplotlib.pyplot as plt
import numpy as np
from pandas.plotting import scatter_matrix
 
plt.rcParams['font.size'] = 14
plt.rcParams['figure.figsize'] = (10, 6)
 
centers = beer.groupby('cluster3').mean().reset_index()
colors = np.array(['red', 'green', 'blue', 'yellow'])
markers = np.array(['o', ',', 'v', '^'])
for x, y, cr, mr in zip(beer['calories'], beer['alcohol'], colors[beer['cluster3']], markers[beer['cluster3']]):
    plt.scatter(x, y, c=cr, marker=mr)
plt.scatter(centers.calories, centers.alcohol, linewidths=3, marker='+', s=300, c='black')
plt.xlabel('Calories')
plt.ylabel('Alcohol')
plt.title('Clustering Result with K = 3')
 
# K = 2
scatter_matrix(beer[['calories', 'sodium', 'alcohol', 'cost']], s=100, alpha=1,
              c=colors[beer["cluster2"]], figsize=(10, 10))
plt.suptitle("With 2 centroids initialized", x=0.5, y=0.92)
 
# K = 3
scatter_matrix(beer[['calories', 'sodium', 'alcohol', 'cost']], s=100, alpha=1,
              c=colors[beer["cluster3"]], figsize=(10, 10))
plt.suptitle("With 3 centroids initialized", x=0.5, y=0.92)
 
plt.show()

from sklearn.preprocessing import StandardScaler
 
scaler = StandardScaler()
X_scaled = scaler.fit_transform(X)
X_scaled

# 对标准化后的数据重新进行 K-Means 聚类
km = KMeans(n_clusters=3).fit(X_scaled)
beer["scaled_cluster"] = km.labels_
beer.sort_values('scaled_cluster')

# 通过每一簇的平均值, 来观察聚类结果的特征
beer.groupby('scaled_cluster').mean()

scatter_matrix(X, c=colors[beer.scaled_cluster], alpha=1, figsize=(10, 10), s=100)

# 计算轮廓系数
from sklearn import metrics
score_scaled = metrics.silhouette_score(X, beer.scaled_cluster)
score = metrics.silhouette_score(X, beer.cluster3)
score_scaled, score

# 在 2~20 持续变化 K 值, 对同一数据进行 K-Means 聚类, 并计算轮廓系数
scores = []
for k in range(2, 20):
    labels = KMeans(n_clusters=k).fit(X).labels_
    score = metrics.silhouette_score(X, labels)
    scores.append(score)
scores

plt.plot(list(range(2, 20)), scores)
plt.xlabel('Number of Clusters Initialized')
plt.ylabel('Sihouette Score')

from sklearn.cluster import DBSCAN
 
db = DBSCAN(eps=10, min_samples=2).fit(X)
labels = db.labels_
beer['cluster_db'] = labels
beer.sort_values('cluster_db')

beer.groupby('cluster_db').mean()

scatter_matrix(X, c=colors[beer.cluster_db], alpha=1, figsize=(10, 10), s=100)