Data-Mining-Experiment 1 der Hebei University of Technology, Datenvorverarbeitung

1. Experimenteller Zweck

(1) Seien Sie mit der vollständigen Konstruktion von Datenwürfeln sowie Online-Analyse- und Verarbeitungsalgorithmen vertraut.
(2) Durchsuchen Sie die zu verarbeitenden Daten, entdecken Sie mögliches Rauschen, fehlende Werte, Inkonsistenzen usw. in jedem Dimensionsattribut und formulieren Sie spezifische Algorithmen für die Datenbereinigung, Datentransformation und Datenintegration, um bestehende Probleme anzugehen.
(3) Schreiben Sie Programme, um Funktionen wie Datenbereinigung, Datentransformation und Datenintegration zu implementieren.
(4) Debuggen des gesamten Programms, um saubere, konsistente und integrierte Daten zu erhalten, und Auswahl geeigneter Parameter für die globale Optimierung.
(5) Schreiben Sie einen Experimentbericht.

2. Experimentelle Prinzipien

1. Datenvorverarbeitung

Datenbanken in der realen Welt sind äußerst anfällig für verrauschte Daten, fehlende Daten und inkonsistente Daten. Um die Datenqualität und damit die Qualität der Mining-Ergebnisse zu verbessern, wurde eine große Anzahl von Datenvorverarbeitungstechnologien entwickelt. Es gibt viele Methoden der Datenvorverarbeitung: Datenbereinigung, Datenintegration, Datentransformation, Datenreduktion usw. Diese Datenverarbeitungstechniken werden vor dem Data Mining eingesetzt, was die Qualität von Data Mining-Modellen erheblich verbessert und die für das eigentliche Mining erforderliche Zeit verkürzt.

2. Datenbereinigung

Datenbereinigungsroutinen „bereinigen“ die Daten, indem sie fehlende Werte ergänzen, verrauschte Daten glätten, Ausreißer identifizieren und entfernen und Inkonsistenzen beheben.

3. Datenintegration

Die Datenintegration kombiniert Daten aus mehreren Quellen in einem konsistenten Datenspeicher, beispielsweise einem Data Warehouse oder einem Datenwürfel.

4. Datentransformation

Konvertieren Sie Daten durch reibungslose Aggregation, Datengeneralisierung, Standardisierung usw. in eine für Data Mining geeignete Form.

5. Datenreduktion

Die Verwendung der Datenreduktion führt zu einer komprimierten Darstellung des Datensatzes, die viel kleiner ist, aber dieselben (oder nahezu dieselben) Analyseergebnisse liefert. Zu den häufig verwendeten Strategien zur Datenreduzierung gehören Datenaggregation, Dimensionsreduzierung, Datenkomprimierung und numerische Reduzierung usw.

3. Experimentelle Inhalte und Vorgehensweisen

1. Experimenteller Inhalt

1) Verwenden Sie Python-Programmiertools, um Programme zur Implementierung von Datenbereinigung, Datentransformation, Datenintegration und anderen Funktionen zu schreiben und die wichtigsten Vorverarbeitungsprozesse und -methoden zu schreiben, die im Versuchsbericht verwendet werden.
2) Erstellen Sie saubere, konsistente und integrierte Daten. .

2. Experimentelle Schritte

1) Studieren und überprüfen Sie die Daten sorgfältig, um Attribute oder Dimensionen zu identifizieren, die in Ihre Analyse einbezogen werden sollten, und entdecken Sie einige Fehler in den Daten, ungewöhnliche Werte und Inkonsistenzen in bestimmten Transaktionsdatensätzen.
2) Führen Sie eine Datenbereinigung durch, um fehlende Werte, verrauschte Daten und inkonsistente Daten zu beseitigen.
Zum Beispiel:
1. Fehlende Werte in Datumsangaben können anhand einheitlicher Seriennummern ermittelt werden.
2. Die gekaufte Menge darf nicht negativ sein.

3) Führen Sie Datenintegration, Datentransformation und Datenreduktion durch, um Daten aus mehreren Datenquellen zu integrieren und Datenredundanz oder Inkonsistenz in den resultierenden Daten zu reduzieren oder zu vermeiden. und konvertieren Sie die Daten in eine für das Mining geeignete Form.
Beispiel:
1. Nach der Datenbereinigung wird festgestellt, dass die Kaufmenge, der Verkaufspreis und der Gesamtbetrag miteinander verbundene Elemente sind, und der Gesamtbetrag kann entfernt werden.
2. Die Datumsformate der drei Zeitpläne sind unterschiedlich und sollten im gleichen Datumsformat vereinheitlicht werden.
3. Die Türnummer ist die gleiche wie die Nummer des Kassenautomaten, eine kann entfernt werden.
4. Zusätzlich: Die Produktseriennummern im selben Warenkorb sollten fortlaufend aufsteigend sein.

3. Programmblockdiagramm

4. Experimentelle Proben

Drei Datensätze: 1019.txt, 1020.txt und 1021.txt

5. Experimenteller Code

#!/usr/bin/env python 　
# -*- coding: utf-8 -*-
#
# Copyright (C) 2021 #
# @Time    : 2022/5/30 21:27
# @Author  : Yang Haoyuan
# @Email   : [email protected]
# @File    : Exp1.py
# @Software: PyCharm
import argparse
import numpy as np
from sklearn.cluster import KMeans
import matplotlib.pyplot as plt
import pandas as pd
from sklearn.preprocessing import StandardScaler

parser = argparse.ArgumentParser(description='Exp1')
parser.add_argument('-files', nargs='+')

parser.set_defaults(augment=True)
args = parser.parse_args()
print(args)


# 从txt文件中读取数据，并做初步处理，数据以numpy array的格式返回
def load_data():
    files = args.files

    data = []
    sales = []
    count = 0

    for filename in files:
        with open(filename, 'r') as file_to_read:
            while True:
                lines = file_to_read.readline()  # 整行读取数据
                if not lines:
                    break
                new_p_tmp = []
                p_tmp = [str(i) for i in lines.split(sep="\t")]  # 将整行数据分割处理
                # p_tmp 为每一条记录的list，其中数据类型均为str

                p_tmp[3] = p_tmp[3].replace('/', '', 2).replace('年', '', 1).replace('月', '', 1).replace('日', '', 1)
                # p_tmp[3]为日期，对于日期空缺，根据流水单号将其填补
                # 变换日期格式，为200304xx格式
                # 空缺日期从流水号中补齐
                if p_tmp[3] == "###":
                    p_tmp[3] = p_tmp[0][:8]
                else:
                    p_tmp[3] = p_tmp[3][0:4] + '0' + p_tmp[3][4:len(p_tmp[3])]

                # 去除最后的换行符
                p_tmp[len(p_tmp) - 1] = p_tmp[len(p_tmp) - 1].strip("\n")

                # 去掉'-'，是其能够转化为浮点型参与分析运算
                # 为每一条记录加一个序号，与其索引一致，方便后期运算
                p_tmp[0] = p_tmp[0].replace('-', '')
                p_tmp.insert(0, count)
                p_tmp[0] = count
                count = count + 1
                # 将所有数据转换为浮点型，以便后期运算
                for i in p_tmp:
                    i = float(i)
                    new_p_tmp.append(i)
                # 将小于零的购买记录和总价转正
                if new_p_tmp[7] < 0:
                    new_p_tmp[7] = -new_p_tmp[7]
                    new_p_tmp[9] = -new_p_tmp[9]

                # 向sales中添加数据
                sales.append([new_p_tmp[0], new_p_tmp[6], new_p_tmp[7]])
                data.append(new_p_tmp)  # 添加新读取的数据
                # 首条数据商品序号为1
                if len(data) == 1:
                    data[0][5] = 1
                # 流水号与之前的不同的商品序号为1
                if data[len(data) - 1][1] != data[len(data) - 2][1]:
                    data[len(data) - 1][5] = 1
                # 每一个购物篮商品序号从1逐次递增
                if (data[len(data) - 1][5] - data[len(data) - 2][5]) > 1 and (
                        data[len(data) - 1][1] == data[len(data) - 2][1]):
                    d = data[len(data) - 1][5]
                    d = d - 1
                    data[len(data) - 1][5] = d
        print(len(data))

    return np.array(data), np.array(sales)


# 展示聚类后的情况
def show(label_pred, X, count):
    x0 = []
    x1 = []
    x2 = []
    x3 = []
    for i in range(len(label_pred)):
        if label_pred[i] == 0:
            x0.append(X[i])
        if label_pred[i] == 1:
            x1.append(X[i])
        if label_pred[i] == 2:
            x2.append(X[i])
        if label_pred[i] == 3:
            x3.append(X[i])
    # print(count[0])
    plt.scatter(np.ones((count[0], 1)), np.array(x0), color='blue', label='label0')
    plt.scatter(np.ones((count[1], 1)), np.array(x1), color='red', label='label1')
    plt.scatter(np.ones((count[2], 1)), np.array(x2), color='yellow', label='label2')
    plt.scatter(np.ones((count[3], 1)), np.array(x3), color='black', label='label3')

    plt.xlim(0, 2)
    plt.ylim(-100, 1200)
    plt.legend(loc=2)
    plt.savefig("fig_1.png")
    plt.clf()


# 进行K-Means聚类，发现单次购买数量的异常点
def K_Means(sale_data, data_raw, data):
    sale_data.reshape(len(sale_data), -1)

    estimator = KMeans(n_clusters=4)  # 构造聚类器，聚4类
    estimator.fit(sale_data)  # 聚类
    labels = estimator.labels_  # 获取聚类标签
    sale_class = [[], [], [], []]
    count = [0, 0, 0, 0]
    # 统计每一类的个数
    for i in range(len(sales)):
        if labels[i] == 0:
            sale_class[0].append(sales[i])
            count[0] = count[0] + 1
        if labels[i] == 1:
            sale_class[1].append(sales[i])
            count[1] = count[1] + 1
        if labels[i] == 2:
            sale_class[2].append(sales[i])
            count[2] = count[2] + 1
        if labels[i] == 3:
            sale_class[3].append(sales[i])
            count[3] = count[3] + 1
    # 获取数量最少的两个类，视为异常类
    count_np = np.array(count)
    idx = np.argpartition(count_np, 2)
    count_index = idx[0]
    count_index_2 = idx[1]

    # 每个异常类的数量变为该商品的平均销售数量
    for sale in sale_class[count_index]:
        filter = np.asarray([sale[1]])
        _class = data_raw[np.in1d(data_raw[:, 6], filter)]
        data[int(sale[0])][7] = np.array(_class[:, 7]).mean()
        # 总价相应变化
        data[int(sale[0])][9] = data[int(sale[0])][7] * data[int(sale[0])][8]

    for sale in sale_class[count_index_2]:
        filter = np.asarray([sale[1]])
        _class = data_raw[np.in1d(data_raw[:, 6], filter)]
        data[int(sale[0])][7] = np.array(_class[:, 7]).mean()
        # 总价相应变化
        data[int(sale[0])][9] = data[int(sale[0])][7] * data[int(sale[0])][8]

    # 展示聚类结果
    show(labels, sale_data, count)
    # 更新的数据返回
    return data


# 主成分分析
def PCA_(X):
    # 标准化
    X_std = StandardScaler().fit(X).transform(X)
    # 构建协方差矩阵
    cov_mat = np.cov(X_std.T)
    # 特征值和特征向量
    eigen_vals, eigen_vecs = np.linalg.eig(cov_mat)
    # 求出特征值的和
    tot = sum(eigen_vals)
    # 求出每个特征值占的比例
    var_exp = [(i / tot) for i in eigen_vals]

    cum_var_exp = np.cumsum(var_exp)
    # 绘图，展示各个属性贡献量
    plt.bar(range(len(eigen_vals)), var_exp, width=1.0, bottom=0.0, alpha=0.5, label='individual explained variance')
    plt.step(range(len(eigen_vals)), cum_var_exp, where='post', label='cumulative explained variance')
    plt.ylabel('Explained variance ratio')
    plt.xlabel('Principal components')
    plt.legend(loc='best')
    plt.savefig("fig_2.png")
    # 返回贡献量最小的属性的索引
    return np.argmin(var_exp)


if __name__ == "__main__":
    # 装载数据
    data_raw, sales = load_data()
    print(data_raw.shape)
    # 对商品购买情况进行聚类，并消除异常何人噪声
    data = K_Means(data_raw=data_raw, data=data_raw, sale_data=sales[:, 2:])
    # 进行主成分分析
    min_col_index = PCA_(data[:, 2:])
    # 根据主成分分析结果去掉多于属性（门店号或者PSNO）
    # 去掉总价格这一冗余属性
    data = np.hstack((data[:, 1:min_col_index + 1], data[:, min_col_index + 2:9]))
    # 保存在CVS文件中
    pd.DataFrame(data, columns=["SerNo", "PSNo", "Data", "GoodNo", "GoodID", "Num", "Price"]).to_csv("data.csv",index=False)

4. Experimentelle Ergebnisse

Ein schematisches Diagramm der Ergebnisse der Clusteranalyse basierend auf der Kaufmenge. Aus den Clusterergebnissen wird abgeleitet, dass es sich bei label1 und label3 um abnormale Daten handelt. Ein schematisches

Diagramm der Ergebnisse der Hauptkomponentenanalyse von der Filialnummer bis zur Gesamtmenge. It Aus den Analyseergebnissen wird abgeleitet, dass es sich bei Attribut 1 möglicherweise um redundante Attributdaten handelt

. Verarbeitete CSV-Datei

5. Experimentelle Analyse

Dieses Experiment konzentriert sich hauptsächlich auf die Vorverarbeitung der gegebenen Daten.
Das erste im Experiment aufgetretene Problem ist der Unterschied zwischen Datentyp und -format. Dazu muss die Inkonsistenz zwischen Datentyp und -format gelöst werden. Ich habe alle Daten in numerische Gleitkommatypen vereinheitlicht, um später verschiedene Analysevorgänge zu erleichtern, aber tatsächlich macht es Sinn einige Daten wie Preis und Menge in Gleitkommazahlen umzuwandeln, andere wie Datum und Seriennummer sind jedoch nominale Attribute und es ist nicht angebracht, sie in numerische Attribute umzuwandeln.
Bei fehlenden Daten in den Daten kann die Vervollständigung direkt aus der Seriennummer ermittelt werden. Für die tatsächlichen Datensätze im Warenkorb, wie z. B. das in der Abbildung unten gezeigte Produkt Nr. 5, können wir jedoch keine Informationen direkt aus anderen Attributen erhalten.

Eine zuverlässigere Methode besteht darin, die am meisten verkauften Artikel im Geschäft an diesem Datum zu zählen und diesen Artikel dann als Kaufdatensatz einzugeben. Da der Rechenaufwand für 27.000 Daten jedoch zu groß ist, habe ich einfach die Datensätze benachbarter Produkte verwendet, um ihn direkt zu ergänzen.
Es gibt einige offensichtliche Anomalien und Störungen in den Daten, wie z. B. negative Einkaufsmengen und Gesamtpreise, die beim Lesen der Daten direkt verarbeitet werden können. Für andere Ausreißer habe ich die K-Means-Clustering-Methode verwendet, um sie zu entdecken. Durch Anpassen der Superparameter ist bei der Gruppierung in 4 Kategorien die Anzahl der beiden Kategorien zu gering und kann als abnormale Kategorie angesehen werden.
Für diese abnormalen Daten habe ich die Kaufmenge zur Glättung auf die durchschnittliche Kaufmenge des Produkts gesetzt.
Für die redundanten Attribute in den Daten habe ich zunächst versucht, die Hauptkomponentenanalyse (PCA) zur Analyse zu verwenden, um die Attribute mit kleinen Beiträgen zu finden. Ich konstruiere eine Kovarianzmatrix in den Dimensionen von der Filialnummer bis zum Gesamtpreis und berechne den Eigenwertanteil jedes Attributs. Die Ergebnisse zeigen, dass der „Beitragsbetrag“ des Attributs „PSNO“ nahe bei 0 liegt, was ein redundantes Attribut ist und daher reduziert werden kann. Allerdings macht ein weiteres redundantes Attribut „Gesamtpreis“ immer noch einen erheblichen Anteil aus.
In diesem Zusammenhang besteht meine Analyse darin, dass die PCA-Methode analysiert, welche Attribute die Hauptattribute eines Datenobjekts sind, dh welche Attribute am meisten zur Beschreibung des Datenobjekts beitragen. Hier ist in jedem Datensatz der Gesamtpreis noch gewissermaßen beschreibend.