INT104-lab11 [聚类] [iris数据集] [K-means Algorithm]

[K-means Algorithm][3D子图]

由于K-means Algorithm是基于随机点选取的，

所以可能结果较差，甚至RE ! ! !

import numpy as np
import random
import matplotlib.pyplot as plt
from sklearn.manifold import TSNE


def read(path: str) -> list:
    with open(path, "r") as f:
        text = f.readlines()
        D = []
        for row in text:
            features = str.split(row, ",")
            X = []
            for feature in features:
                X.append(feature)
            if len(X) == 5:
                D.append(X)
    return D


def init(D) -> tuple:
    n, m = len(D), len(D[0]) - 1
    X, Y = [], []
    for i in range(n):
        x = []
        for j in range(m):
            x.append(float(D[i][j]))
        X.append(x)
        Y.append(str.split(D[i][m], "\n")[0])
    return X, Y, n, m


def randomDataset(seed: int, D) -> list:
    # set the random seed then the order is fixed and random
    # random.seed(seed)
    random.shuffle(D)
    return D


def setPoints(K: int, X: list, n: int, m: int) -> tuple:
    minValues, maxValues = [], []
    for j in range(m):
        maxValue, minValue = -10000.0, 10000.0
        for i in range(n):
            maxValue = max(maxValue, X[i][j])
            minValue = min(minValue, X[i][j])
        maxValues.append(maxValue)
        minValues.append(minValue)
    P = []
    for i in range(K):
        X = []
        for j in range(m):
            X.append(random.uniform(minValues[j], maxValues[j]))
        P.append(X)
    return minValues, maxValues, P


def getType(a, b, c):
    if a < b and a < b:
        return 1
    if b < a and b < c:
        return 2
    return 3


eps = 1e-3


def compare(P, newP, K, m):
    for i in range(K):
        for j in range(m):
            if abs(P[i][j] - newP[i][j]) > eps:
                return False
    return True


def G(A, m):
    n = len(A)
    sumA = [0 for _ in range(m)]
    for i in range(n):
        for j in range(m):
            sumA[j] += A[i][j]
    return [(x / n) for x in sumA]


def getNewP(X, dis, n, m):
    A, B, C = [], [], []
    for i in range(n):
        if dis[i][0] == 1:
            A.append(X[i])
        elif dis[i][0] == 2:
            B.append(X[i])
        else:
            C.append(X[i])
    return [G(A, m), G(B, m), G(C, m)]


def K_means_algorithm(K: int, X: list, Y: list, n: int, m: int):
    minValues, maxValues, P = setPoints(K, X, n, m)
    K_distances = []

    print(minValues)
    print(maxValues)
    print(np.array(P))

    while True:

        for i in range(n):
            dis1 = euclideanDistance(P[0], X[i], m)
            dis2 = euclideanDistance(P[1], X[i], m)
            dis3 = euclideanDistance(P[2], X[i], m)
            Type = getType(dis1, dis2, dis3)
            K_distances.append([Type, dis1, dis2, dis3])

        newP = getNewP(X, K_distances, n, m)

        if compare(P, newP, K, m):
            break
        P = newP
        print(np.array(newP))
        print("Yes")
    return P, K_distances


def similarity(A, B, m) -> float:
    Sigma_AixBi = 0
    Sigma_Ai_Square = 0
    Sigma_Bi_Square = 0
    for i in range(m):
        Sigma_AixBi += A[i] * B[i]
        Sigma_Ai_Square += A[i] * A[i]
        Sigma_Bi_Square += B[i] * B[i]
    return Sigma_AixBi / (np.sqrt(Sigma_Ai_Square) * np.sqrt(Sigma_Bi_Square))


def euclideanDistance(A, B, m) -> float:
    Sigma_Xi_Yi_square = 0
    for i in range(m):
        Sigma_Xi_Yi_square += (A[i] - B[i]) * (A[i] - B[i])
    return np.sqrt(Sigma_Xi_Yi_square)


def answer(X, Y, dis, n):
    x = np.array(X)
    tsne = TSNE(n_components=3)
    tsne.fit_transform(x)
    one_x, one_y, one_z = [], [], []
    two_x, two_y, two_z = [], [], []
    three_x, three_y, three_z = [], [], []
    _one_x, _one_y, _one_z = [], [], []
    _two_x, _two_y, _two_z = [], [], []
    _three_x, _three_y, _three_z = [], [], []
    for i in range(n):
        _x = tsne.embedding_[i][0]
        _y = tsne.embedding_[i][1]
        _z = tsne.embedding_[i][2]
        if dis[i][0] == 1:
            one_x.append(_x)
            one_y.append(_y)
            one_z.append(_z)
        elif dis[i][0] == 2:
            two_x.append(_x)
            two_y.append(_y)
            two_z.append(_z)
        else:
            three_x.append(_x)
            three_y.append(_y)
            three_z.append(_z)
        if Y[i] == "Iris-setosa":
            _one_x.append(_x)
            _one_y.append(_y)
            _one_z.append(_z)
        elif Y[i] == "Iris-versicolor":
            _two_x.append(_x)
            _two_y.append(_y)
            _two_z.append(_z)
        else:
            _three_x.append(_x)
            _three_y.append(_y)
            _three_z.append(_z)
    # answer
    fig = plt.figure(figsize=(12, 6), facecolor='w')
    ax1 = fig.add_subplot(121, projection='3d')
    plt.title('answer')
    ax1.scatter(one_x, one_y, one_z)
    ax1.scatter(two_x, two_y, two_z)
    ax1.scatter(three_x, three_y, three_z)
    # data
    ax2 = fig.add_subplot(122, projection='3d')
    plt.title('data')
    ax2.scatter(_one_x, _one_y, _one_z)
    ax2.scatter(_two_x, _two_y, _two_z)
    ax2.scatter(_three_x, _three_y, _three_z)
    plt.show()
    print("Showing done")


if __name__ == '__main__':
    dataset = read("iris.data")
    dataset = randomDataset(17, dataset)
    X, Y, n, m = init(dataset)
    P, dis = K_means_algorithm(3, X, Y, n, m)

    print("Done!")
    print(np.array(P))

    answer(X, Y, dis, n)
    plt.show()