Die Klassifizierung des CIFAR-10-Datensatzes und des UCI-Weindatensatzes basierend auf MLP wurde abgeschlossen, Sklearn und Tensorflow wurden verwendet und eine Datenvisualisierungsanzeige für die Bildklassifizierung wurde durchgeführt
Einführung in den Datensatz
UCI-Weindatensatz:
http://archive.ics.uci.edu/dataset/109/wine
Die Daten sind das Ergebnis einer chemischen Analyse von Wein, der in derselben Region Italiens angebaut wird, jedoch aus drei verschiedenen Sorten. Bei der Analyse wurden die Mengen von 13 Zutaten ermittelt, die in jedem der drei Weine enthalten waren.
CIFAR-10-Datensatz:
https://www.cs.toronto.edu/~kriz/cifar.html
Der CIFAR-10-Datensatz besteht aus 60.000 32x32-Farbbildern in 10 Kategorien mit 6.000 Bildern in jeder Kategorie. Es gibt 50.000 Trainingsbilder und 10.000 Testbilder.
Der Datensatz ist in 5 Trainingsstapel und 1 Teststapel unterteilt, jeder Stapel enthält 10.000 Bilder. Der Teststapel enthält genau 1000 zufällig ausgewählte Bilder aus jeder Klasse. Die Trainingsstapel enthalten die verbleibenden Bilder in zufälliger Reihenfolge, einige Trainingsstapel enthalten jedoch möglicherweise mehr Bilder aus einer Klasse als aus einer anderen. Insgesamt enthält der Trainingsstapel genau 5000 Bilder aus jeder Klasse
MLP-Algorithmus
MLP steht für Multilayer Perceptron und ist ein grundlegendes vorwärtsgerichtetes neuronales Netzwerkmodell. Es besteht aus einer Eingabeschicht, einer oder mehreren verborgenen Schichten und einer Ausgabeschicht, wobei jede Schicht mehrere Neuronen (oder Knoten) enthält. MLP ist ein leistungsstarkes Modell, das häufig zur Lösung von Klassifizierungs- und Regressionsproblemen verwendet wird.
Die Grundkomponenten eines MLP sind wie folgt:
-
Eingabeschicht: Die Eingabeschicht, die die Originaldaten empfängt. Jeder Eingabeknoten entspricht dem Eingabemerkmal.
-
Verborgene Schicht:
Eine oder mehrere Schichten von Neuronen, die sich zwischen der Eingabeschicht und der Ausgabeschicht befinden. Jedes Neuron ist über Gewichte mit allen Knoten der vorherigen Schicht verbunden und durchläuft durch Aktivierungsfunktionen eine nichtlineare Transformation. Das Vorhandensein verborgener Schichten ermöglicht es dem Netzwerk, komplexe Merkmale der Eingabedaten zu erlernen. -
Ausgabeschicht: Stellt die endgültige Netzwerkausgabe bereit. Bei unterschiedlichen Problemen kann die Aktivierungsfunktion der Ausgabeschicht unterschiedlich sein. Beispielsweise können Sie für binäre Klassifizierungsprobleme
die Sigmoid-Aktivierungsfunktion verwenden; für Mehrfachklassifizierungsprobleme können Sie die Softmax-Aktivierungsfunktion verwenden.
Modellbau
UCI-Wein:
Wir laden load_wine als Trainingsdaten in sklearn.datasets, teilen es in einen Datensatz und einen Testsatz auf und führen Standardisierungsoperationen durch
Rufen Sie dann MLPClassifier(hidden_layer_sizes=(100,), max_iter=1000, random_state=42) auf, um das Modell zu erstellen
Führen Sie nach dem Training eine Vorhersage anhand des Testsatzes durch und bewerten Sie schließlich das Modell
from sklearn.neural_network import MLPClassifier
from sklearn.datasets import load_iris
from sklearn.datasets import load_wine
from sklearn.model_selection import train_test_split
from sklearn.metrics import accuracy_score, classification_report, confusion_matrix
from sklearn.preprocessing import StandardScaler
# 加载Iris数据集
# iris = load_iris()
# X = iris.data
# y = iris.target
wine = load_wine()
X = wine.data
y = wine.target
# 划分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)
# 数据标准化
scaler = StandardScaler()
X_train_scaled = scaler.fit_transform(X_train)
X_test_scaled = scaler.transform(X_test)
# 构建MLP模型
mlp = MLPClassifier(hidden_layer_sizes=(100,), max_iter=1000, random_state=42)
# 训练模型
mlp.fit(X_train_scaled, y_train)
# 在测试集上进行预测
y_pred = mlp.predict(X_test_scaled)
# 评估模型性能
accuracy = accuracy_score(y_test, y_pred)
conf_matrix = confusion_matrix(y_test, y_pred)
class_report = classification_report(y_test, y_pred)
# 打印结果
print("Accuracy:", accuracy)
print("\nConfusion Matrix:\n", conf_matrix)
print("\nClassification Report:\n", class_report)
CIFAR-10:
Wir verwenden die mit tf.keras.datasets.cifar10 gelieferten Daten für das Training
Verwenden Sie die Funktion tf.keras.Sequential(), um ein Modell zu erstellen und ein vierschichtiges Netzwerk einzurichten
Trainieren Sie dann den Code stapelweise, werten Sie das Modell aus, behalten Sie es bei und visualisieren Sie die Ergebnisse.
########cifar10数据集##########
###########保存模型############
########卷积神经网络##########
#train_x:(50000, 32, 32, 3), train_y:(50000, 1), test_x:(10000, 32, 32, 3), test_y:(10000, 1)
#60000条训练数据和10000条测试数据，32x32像素的RGB图像
#第一层两个卷积层16个3*3卷积核，一个池化层：最大池化法2*2卷积核，激活函数：ReLU
#第二层两个卷积层32个3*3卷积核，一个池化层：最大池化法2*2卷积核，激活函数：ReLU
#隐含层激活函数：ReLU函数
#输出层激活函数：softmax函数（实现多分类）
#损失函数：稀疏交叉熵损失函数
#隐含层有128个神经元，输出层有10个节点
import tensorflow as tf
import matplotlib.pyplot as plt
import numpy as np
import time
print('--------------')
nowtime = time.strftime('%Y-%m-%d %H:%M:%S')
print(nowtime)
#指定GPU
#import os
#os.environ["CUDA_VISIBLE_DEVICES"] = "0"
# gpus = tf.config.experimental.list_physical_devices('GPU')
# tf.config.experimental.set_memory_growth(gpus[0],True)
#初始化
plt.rcParams['font.sans-serif'] = ['SimHei']
#加载数据
cifar10 = tf.keras.datasets.cifar10
(train_x,train_y),(test_x,test_y) = cifar10.load_data()
print('\n train_x:%s, train_y:%s, test_x:%s, test_y:%s'%(train_x.shape,train_y.shape,test_x.shape,test_y.shape))
#数据预处理
X_train,X_test = tf.cast(train_x/255.0,tf.float32),tf.cast(test_x/255.0,tf.float32) #归一化
y_train,y_test = tf.cast(train_y,tf.int16),tf.cast(test_y,tf.int16)
#建立模型
model = tf.keras.Sequential()
##特征提取阶段
#第一层
model.add(tf.keras.layers.Conv2D(16,kernel_size=(3,3),padding='same',activation=tf.nn.relu,data_format='channels_last',input_shape=X_train.shape[1:])) #卷积层，16个卷积核，大小（3，3），保持原图像大小，relu激活函数，输入形状（28，28，1）
model.add(tf.keras.layers.Conv2D(16,kernel_size=(3,3),padding='same',activation=tf.nn.relu))
model.add(tf.keras.layers.MaxPool2D(pool_size=(2,2))) #池化层，最大值池化，卷积核（2，2）
#第二层
model.add(tf.keras.layers.Conv2D(32,kernel_size=(3,3),padding='same',activation=tf.nn.relu))
model.add(tf.keras.layers.Conv2D(32,kernel_size=(3,3),padding='same',activation=tf.nn.relu))
model.add(tf.keras.layers.MaxPool2D(pool_size=(2,2)))
##分类识别阶段
#第三层
model.add(tf.keras.layers.Flatten()) #改变输入形状
#第四层
model.add(tf.keras.layers.Dense(128,activation='relu')) #全连接网络层，128个神经元，relu激活函数
model.add(tf.keras.layers.Dense(10,activation='softmax')) #输出层，10个节点
print(model.summary()) #查看网络结构和参数信息
#配置模型训练方法
#adam算法参数采用keras默认的公开参数，损失函数采用稀疏交叉熵损失函数，准确率采用稀疏分类准确率函数
model.compile(optimizer='adam',loss='sparse_categorical_crossentropy',metrics=['sparse_categorical_accuracy'])
#训练模型
#批量训练大小为64，迭代5次，测试集比例0.2（48000条训练集数据，12000条测试集数据）
print('--------------')
nowtime = time.strftime('%Y-%m-%d %H:%M:%S')
print('训练前时刻：'+str(nowtime))
history = model.fit(X_train,y_train,batch_size=64,epochs=5,validation_split=0.2)
print('--------------')
nowtime = time.strftime('%Y-%m-%d %H:%M:%S')
print('训练后时刻：'+str(nowtime))
#评估模型
model.evaluate(X_test,y_test,verbose=2) #每次迭代输出一条记录，来评价该模型是否有比较好的泛化能力
#保存整个模型
model.save('CIFAR10_CNN_weights.h5')
#结果可视化
print(history.history)
loss = history.history['loss'] #训练集损失
val_loss = history.history['val_loss'] #测试集损失
acc = history.history['sparse_categorical_accuracy'] #训练集准确率
val_acc = history.history['val_sparse_categorical_accuracy'] #测试集准确率
plt.figure(figsize=(10,3))
plt.subplot(121)
plt.plot(loss,color='b',label='train')
plt.plot(val_loss,color='r',label='test')
plt.ylabel('loss')
plt.legend()
plt.subplot(122)
plt.plot(acc,color='b',label='train')
plt.plot(val_acc,color='r',label='test')
plt.ylabel('Accuracy')
plt.legend()
#暂停5秒关闭画布，否则画布一直打开的同时，会持续占用GPU内存
#根据需要自行选择
#plt.ion() #打开交互式操作模式
#plt.show()
#plt.pause(5)
#plt.close()
#使用模型
plt.figure()
for i in range(10):
num = np.random.randint(1,10000)
plt.subplot(2,5,i+1)
plt.axis('off')
plt.imshow(test_x[num],cmap='gray')
demo = tf.reshape(X_test[num],(1,32,32,3))
y_pred = np.argmax(model.predict(demo))
plt.title('标签值：'+str(test_y[num])+'\n预测值：'+str(y_pred))
#y_pred = np.argmax(model.predict(X_test[0:5]),axis=1)
#print('X_test[0:5]: %s'%(X_test[0:5].shape))
#print('y_pred: %s'%(y_pred))
#plt.ion() #打开交互式操作模式
plt.show()
#plt.pause(5)
#plt.close()
Projektadresse
https://gitee.com/yishangyishang/homeword.git