【深度学习】图片分类CNN模板

最新推荐文章于 2024-05-23 11:08:36 发布
最新推荐文章于 2024-05-23 11:08:36 发布
阅读量421 收藏 2
点赞数 1
文章标签： 人工智能 tensorflow python 深度学习 sdl
原文链接：https://mp.weixin.qq.com/s?__biz=MzIwODI2NDkxNQ==&mid=2247500439&idx=3&sn=e51bdad234a3c0b55635788b9922ec3d&chksm=9707492ba070c03dbdd28880b53fe920df6df0a4e19dd25d7480b9572794b0dedc4386b0bff9&scene=126&&sessionid=0
版权

构建一个字母ABC的手写识别网络,

要求给出算法误差收敛曲线，所给程序要有图片导入接口。

c88fe64b1224639fcd44d94b808fbaa4.png其中A，B，C都代表label，三个文件夹存在具体的图片。只要是这样类型的，直接套下面模板。

02a6bf4dacc9ea36e5ad76ba172eceaa.png 
import os
import cv2
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
import tqdm

from tensorflow import keras
from keras import Input, Model, Sequential
from tensorflow.keras.regularizers import l2
from keras.layers import Dense, Flatten, InputLayer, Reshape, BatchNormalization, Dropout, Conv2D, MaxPooling2D
from tensorflow.keras.utils import plot_model

%matplotlib inline
data_dir = './data'
# Dict of labels
categories = {
'A': 0,
'B': 1,
'C': 2 
}
def load_images(images_folder, img_size = (128,128), scale=False):

    # Store paths to images
    image_path = []
    for dirname, _, filenames in os.walk(images_folder):
        for filename in filenames:
            image_path.append(os.path.join(dirname, filename))

    print("There are {} images in {}".format(len(image_path), images_folder))
    
    # Load images and associated labels
    images = []
    labels = []

    for path in tqdm.tqdm(image_path):

        img = cv2.imread(path)    
        img = cv2.resize(img, img_size) # Resize the images

        img = np.array(img)

        images.append(img)
        labels.append(categories[path.split('/')[-2]]) # last folder before the image name is the category

    images = np.array(images)  
    images = images.astype(np.int64)
    
    if scale:
        images = images/255 # scale
        
    return image_path, images, np.asarray(labels)
img_size = (128,128)
image_path, images, labels = load_images(data_dir, img_size=img_size)

# Resize
# images = np.array(images).reshape(-1,128,128,1)
images.shape
There are 600 images in ./data


100%|██████████| 600/600 [00:03<00:00, 183.15it/s]





(600, 128, 128, 3)
# 查看图片
plt.figure(figsize=(10,10))
random_inds = np.random.choice(len(image_path),36)
for i in range(36):
    plt.subplot(6,6,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    image_ind = random_inds[i]
    plt.imshow(np.squeeze(images[image_ind]), cmap=plt.cm.binary)
    
    label = list(categories.keys())[list(categories.values()).index(labels[image_ind])]
    plt.title(label)
9c1b338d5e4378a4a9a6149d03411f7f.png 
labels_df = pd.DataFrame(labels) 
labels_df.value_counts()
2    201
0    201
1    198
dtype: int64
dataset=[]
dataname=[]
count=0
for name in tqdm(os.listdir(data_dir)):
    path=os.path.join(data_dir,name)
    for im in os.listdir(path):
        image=cv2.imread(os.path.join(path,im))
        image2=np.resize(image,(50,50,3))
        dataset+=[image2]
        dataname+=[count]
    count=count+1
100%|██████████| 3/3 [00:03<00:00,  1.06s/it]
data=np.array(dataset)
dataname=np.array(dataname)
data[0].shape
(50, 50, 3)
print(pd.Series(dataname).value_counts())
1    202
2    201
0    198
dtype: int64
len(categories)
3
from tensorflow.keras.layers import Dense, Conv2D, Flatten, Dropout, MaxPooling2D, BatchNormalization

def build_cnn_model():
    cnn_model=tf.keras.Sequential([
      Conv2D(filters=32,kernel_size=(3,3),activation='relu',input_shape=images.shape[1:]),
      MaxPooling2D(2,2),
      BatchNormalization(),
      Dropout(0.4),

      Conv2D(filters=64,kernel_size=(3,3),activation='relu', padding='same'),
      Conv2D(filters=64,kernel_size=(3,3),activation='relu', padding='same'),
      MaxPooling2D((2,2)),
      BatchNormalization(),
      Dropout(0.4),

      Conv2D(filters=128,kernel_size=(3,3),activation='relu', padding='same'),
      Conv2D(filters=128,kernel_size=(3,3),activation='relu', padding='same'),
      MaxPooling2D(2,2),
      BatchNormalization(),
      Dropout(0.4),
        
      Conv2D(filters=256,kernel_size=(3,3),activation='relu', padding='same'),
      Conv2D(filters=256,kernel_size=(3,3),activation='relu', padding='same'),
      MaxPooling2D(2,2),
      BatchNormalization(),
      Dropout(0.4),
        

      Conv2D(filters=128,kernel_size=(3,3),activation='relu', padding='same'),
      Conv2D(filters=128,kernel_size=(3,3),activation='relu', padding='same'),
      MaxPooling2D(2,2),
      BatchNormalization(),
      Dropout(0.4),
        
      Conv2D(filters=64,kernel_size=(3,3),activation='relu', padding='same'),
      Conv2D(filters=64,kernel_size=(3,3),activation='relu', padding='same'),
      MaxPooling2D((2,2)),
      BatchNormalization(),
      Dropout(0.4),

      Flatten(),

      Dense(units=len(categories),activation='softmax')
    ])

    return cnn_model
  
model = build_cnn_model()
# Initialize the model by passing some data through
model.predict(images[[0]])
# Print the summary of the layers in the model.
print(model.summary())
Model: "sequential_3"
_________________________________________________________________
 Layer (type)                Output Shape              Param #   
=================================================================
 conv2d_6 (Conv2D)           (None, 126, 126, 32)      896       
                                                                 
 max_pooling2d_6 (MaxPooling  (None, 63, 63, 32)       0         
 2D)                                                             
                                                                 
 batch_normalization (BatchN  (None, 63, 63, 32)       128       
 ormalization)                                                   
                                                                 
 dropout (Dropout)           (None, 63, 63, 32)        0         
                                                                 
 conv2d_7 (Conv2D)           (None, 63, 63, 64)        18496     
                                                                 
 conv2d_8 (Conv2D)           (None, 63, 63, 64)        36928     
                                                                 
 max_pooling2d_7 (MaxPooling  (None, 31, 31, 64)       0         
 2D)                                                             
                                                                 
 batch_normalization_1 (Batc  (None, 31, 31, 64)       256       
 hNormalization)                                                 
                                                                 
 dropout_1 (Dropout)         (None, 31, 31, 64)        0         
                                                                 
 conv2d_9 (Conv2D)           (None, 31, 31, 128)       73856     
                                                                 
 conv2d_10 (Conv2D)          (None, 31, 31, 128)       147584    
                                                                 
 max_pooling2d_8 (MaxPooling  (None, 15, 15, 128)      0         
 2D)                                                             
                                                                 
 batch_normalization_2 (Batc  (None, 15, 15, 128)      512       
 hNormalization)                                                 
                                                                 
 dropout_2 (Dropout)         (None, 15, 15, 128)       0         
                                                                 
 conv2d_11 (Conv2D)          (None, 15, 15, 256)       295168    
                                                                 
 conv2d_12 (Conv2D)          (None, 15, 15, 256)       590080    
                                                                 
 max_pooling2d_9 (MaxPooling  (None, 7, 7, 256)        0         
 2D)                                                             
                                                                 
 batch_normalization_3 (Batc  (None, 7, 7, 256)        1024      
 hNormalization)                                                 
                                                                 
 dropout_3 (Dropout)         (None, 7, 7, 256)         0         
                                                                 
 conv2d_13 (Conv2D)          (None, 7, 7, 128)         295040    
                                                                 
 conv2d_14 (Conv2D)          (None, 7, 7, 128)         147584    
                                                                 
 max_pooling2d_10 (MaxPoolin  (None, 3, 3, 128)        0         
 g2D)                                                            
                                                                 
 batch_normalization_4 (Batc  (None, 3, 3, 128)        512       
 hNormalization)                                                 
                                                                 
 dropout_4 (Dropout)         (None, 3, 3, 128)         0         
                                                                 
 conv2d_15 (Conv2D)          (None, 3, 3, 64)          73792     
                                                                 
 conv2d_16 (Conv2D)          (None, 3, 3, 64)          36928     
                                                                 
 max_pooling2d_11 (MaxPoolin  (None, 1, 1, 64)         0         
 g2D)                                                            
                                                                 
 batch_normalization_5 (Batc  (None, 1, 1, 64)         256       
 hNormalization)                                                 
                                                                 
 dropout_5 (Dropout)         (None, 1, 1, 64)          0         
                                                                 
 flatten_1 (Flatten)         (None, 64)                0         
                                                                 
 dense_6 (Dense)             (None, 3)                 195       
                                                                 
=================================================================
Total params: 1,719,235
Trainable params: 1,717,891
Non-trainable params: 1,344
_________________________________________________________________
None
tf.keras.utils.plot_model(model, show_shapes=True)
223d82bb6cb31ecdb531725a0b4d18cb.png 
from tensorflow.keras.utils import to_categorical
from sklearn.preprocessing import LabelEncoder
from sklearn.utils import shuffle
le = LabelEncoder()
labels = le.fit_transform(labels)
labels = to_categorical(labels)
labels[:10]
array([[0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.],
       [0., 1., 0.]], dtype=float32)
model.compile(optimizer = "adam", loss = "binary_crossentropy", metrics = ["accuracy"])
checkpoint_filepath = '/checkpoint.hdf5'
model_checkpoint_callback = tf.keras.callbacks.ModelCheckpoint(
    filepath=checkpoint_filepath,
    save_weights_only=True,
    monitor='val_accuracy',
    mode='max',
    save_best_only=True,
    save_freq=500)
from tensorflow.keras.callbacks import EarlyStopping
early_stopping = EarlyStopping(
    monitor='val_accuracy', 
    patience=10, 
    min_delta=0.001, 
    mode='max',
    restore_best_weights=True
)
datagen = ImageDataGenerator(horizontal_flip=True,vertical_flip=True,rotation_range=20,zoom_range=0.2,
                        width_shift_range=0.2,height_shift_range=0.2,shear_range=0.1,fill_mode="nearest")
from tensorflow.keras.callbacks import ReduceLROnPlateau
reducelr = ReduceLROnPlateau(monitor = "val_accuracy",factor = 0.3, patience = 3,
                            min_delta = 0.001,mode = 'auto',verbose=1)
from sklearn.model_selection import train_test_split
# Train, validation and test split

X_train, X_test, y_train, y_test = train_test_split(images, labels, test_size=0.10, random_state=7)

X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.20, random_state=1)
print("*-*-*-*-*-*")
print("Train")
print(X_train.shape)
print(y_train.shape)

print("*-*-*-*-*-*")
print("Validation")
print(X_val.shape)
print(y_val.shape)

print("*-*-*-*-*-*")
print("Test")
print(X_test.shape)
print(y_test.shape)
*-*-*-*-*-*
Train
(432, 128, 128, 3)
(432, 3)
*-*-*-*-*-*
Validation
(108, 128, 128, 3)
(108, 3)
*-*-*-*-*-*
Test
(60, 128, 128, 3)
(60, 3)
history = model.fit(X_train, y_train, 
                    batch_size = 32, 
                    epochs = 100, 
                    verbose = 1, 
                    validation_data = (X_val, y_val),
                    callbacks=[model_checkpoint_callback, early_stopping, reducelr])
Epoch 1/1000
14/14 [==============================] - 8s 238ms/step - loss: 0.8036 - accuracy: 0.3588 - val_loss: 6.2921 - val_accuracy: 0.2963 - lr: 0.0010
Epoch 2/1000
14/14 [==============================] - 1s 95ms/step - loss: 0.8162 - accuracy: 0.3796 - val_loss: 5.2361 - val_accuracy: 0.2963 - lr: 0.0010
Epoch 3/1000
14/14 [==============================] - 1s 97ms/step - loss: 0.7190 - accuracy: 0.4537 - val_loss: 1.3893 - val_accuracy: 0.3333 - lr: 0.0010
Epoch 4/1000
14/14 [==============================] - 1s 97ms/step - loss: 0.6875 - accuracy: 0.4792 - val_loss: 0.7386 - val_accuracy: 0.3519 - lr: 0.0010
Epoch 5/1000
14/14 [==============================] - 1s 100ms/step - loss: 0.6144 - accuracy: 0.5949 - val_loss: 0.7014 - val_accuracy: 0.4259 - lr: 0.0010
Epoch 6/1000
14/14 [==============================] - 1s 97ms/step - loss: 0.5156 - accuracy: 0.7060 - val_loss: 0.7592 - val_accuracy: 0.4537 - lr: 0.0010
Epoch 7/1000
14/14 [==============================] - 1s 96ms/step - loss: 0.4904 - accuracy: 0.7384 - val_loss: 0.7034 - val_accuracy: 0.5370 - lr: 0.0010
Epoch 8/1000
14/14 [==============================] - 1s 97ms/step - loss: 0.3854 - accuracy: 0.7940 - val_loss: 0.6092 - val_accuracy: 0.5556 - lr: 0.0010
Epoch 9/1000
14/14 [==============================] - 1s 97ms/step - loss: 0.3313 - accuracy: 0.8241 - val_loss: 0.5192 - val_accuracy: 0.6389 - lr: 0.0010
Epoch 10/1000
14/14 [==============================] - 1s 93ms/step - loss: 0.2873 - accuracy: 0.8519 - val_loss: 0.5089 - val_accuracy: 0.6111 - lr: 0.0010
Epoch 11/1000
14/14 [==============================] - 1s 96ms/step - loss: 0.2346 - accuracy: 0.8981 - val_loss: 0.4359 - val_accuracy: 0.6852 - lr: 0.0010
Epoch 12/1000
14/14 [==============================] - 1s 94ms/step - loss: 0.2238 - accuracy: 0.8819 - val_loss: 0.4404 - val_accuracy: 0.6481 - lr: 0.0010
Epoch 13/1000
14/14 [==============================] - 1s 97ms/step - loss: 0.1954 - accuracy: 0.8912 - val_loss: 0.4215 - val_accuracy: 0.7500 - lr: 0.0010
Epoch 14/1000
14/14 [==============================] - 1s 100ms/step - loss: 0.1792 - accuracy: 0.9051 - val_loss: 0.1971 - val_accuracy: 0.9074 - lr: 0.0010
Epoch 15/1000
14/14 [==============================] - 1s 96ms/step - loss: 0.1608 - accuracy: 0.9144 - val_loss: 0.2836 - val_accuracy: 0.8056 - lr: 0.0010
Epoch 16/1000
14/14 [==============================] - 1s 95ms/step - loss: 0.1447 - accuracy: 0.9398 - val_loss: 0.2867 - val_accuracy: 0.7500 - lr: 0.0010
Epoch 17/1000
14/14 [==============================] - ETA: 0s - loss: 0.1215 - accuracy: 0.9375
Epoch 00017: ReduceLROnPlateau reducing learning rate to 0.0003000000142492354.
14/14 [==============================] - 1s 95ms/step - loss: 0.1215 - accuracy: 0.9375 - val_loss: 0.1474 - val_accuracy: 0.9074 - lr: 0.0010
Epoch 18/1000
14/14 [==============================] - 1s 97ms/step - loss: 0.1023 - accuracy: 0.9537 - val_loss: 0.1186 - val_accuracy: 0.9352 - lr: 3.0000e-04
Epoch 19/1000
14/14 [==============================] - 1s 101ms/step - loss: 0.0992 - accuracy: 0.9606 - val_loss: 0.1074 - val_accuracy: 0.9444 - lr: 3.0000e-04
Epoch 20/1000
14/14 [==============================] - 1s 94ms/step - loss: 0.0837 - accuracy: 0.9676 - val_loss: 0.0917 - val_accuracy: 0.9444 - lr: 3.0000e-04
Epoch 21/1000
14/14 [==============================] - 1s 98ms/step - loss: 0.0788 - accuracy: 0.9699 - val_loss: 0.0877 - val_accuracy: 0.9444 - lr: 3.0000e-04
Epoch 22/1000
14/14 [==============================] - ETA: 0s - loss: 0.0809 - accuracy: 0.9722
Epoch 00022: ReduceLROnPlateau reducing learning rate to 9.000000427477062e-05.
14/14 [==============================] - 1s 95ms/step - loss: 0.0809 - accuracy: 0.9722 - val_loss: 0.0897 - val_accuracy: 0.9444 - lr: 3.0000e-04
Epoch 23/1000
14/14 [==============================] - 1s 95ms/step - loss: 0.0677 - accuracy: 0.9792 - val_loss: 0.0834 - val_accuracy: 0.9537 - lr: 9.0000e-05
Epoch 24/1000
14/14 [==============================] - 1s 93ms/step - loss: 0.0741 - accuracy: 0.9722 - val_loss: 0.0771 - val_accuracy: 0.9537 - lr: 9.0000e-05
Epoch 25/1000
14/14 [==============================] - 1s 94ms/step - loss: 0.0672 - accuracy: 0.9815 - val_loss: 0.0733 - val_accuracy: 0.9537 - lr: 9.0000e-05
Epoch 26/1000
14/14 [==============================] - ETA: 0s - loss: 0.0595 - accuracy: 0.9838
Epoch 00026: ReduceLROnPlateau reducing learning rate to 2.700000040931627e-05.
14/14 [==============================] - 1s 95ms/step - loss: 0.0595 - accuracy: 0.9838 - val_loss: 0.0694 - val_accuracy: 0.9537 - lr: 9.0000e-05
Epoch 27/1000
14/14 [==============================] - 1s 94ms/step - loss: 0.0631 - accuracy: 0.9838 - val_loss: 0.0699 - val_accuracy: 0.9537 - lr: 2.7000e-05
Epoch 28/1000
14/14 [==============================] - 1s 97ms/step - loss: 0.0591 - accuracy: 0.9861 - val_loss: 0.0705 - val_accuracy: 0.9537 - lr: 2.7000e-05
Epoch 29/1000
14/14 [==============================] - ETA: 0s - loss: 0.0635 - accuracy: 0.9838
Epoch 00029: ReduceLROnPlateau reducing learning rate to 8.100000013655517e-06.
14/14 [==============================] - 1s 95ms/step - loss: 0.0635 - accuracy: 0.9838 - val_loss: 0.0697 - val_accuracy: 0.9444 - lr: 2.7000e-05
Epoch 30/1000
14/14 [==============================] - 1s 95ms/step - loss: 0.0643 - accuracy: 0.9792 - val_loss: 0.0687 - val_accuracy: 0.9444 - lr: 8.1000e-06
Epoch 31/1000
14/14 [==============================] - 1s 100ms/step - loss: 0.0768 - accuracy: 0.9745 - val_loss: 0.0665 - val_accuracy: 0.9537 - lr: 8.1000e-06
Epoch 32/1000
14/14 [==============================] - ETA: 0s - loss: 0.0645 - accuracy: 0.9861
Epoch 00032: ReduceLROnPlateau reducing learning rate to 2.429999949526973e-06.
14/14 [==============================] - 1s 95ms/step - loss: 0.0645 - accuracy: 0.9861 - val_loss: 0.0656 - val_accuracy: 0.9537 - lr: 8.1000e-06
Epoch 33/1000
14/14 [==============================] - 1s 97ms/step - loss: 0.0635 - accuracy: 0.9792 - val_loss: 0.0645 - val_accuracy: 0.9630 - lr: 2.4300e-06
Epoch 34/1000
14/14 [==============================] - 1s 95ms/step - loss: 0.0606 - accuracy: 0.9838 - val_loss: 0.0636 - val_accuracy: 0.9630 - lr: 2.4300e-06
Epoch 35/1000
14/14 [==============================] - 1s 95ms/step - loss: 0.0620 - accuracy: 0.9907 - val_loss: 0.0628 - val_accuracy: 0.9630 - lr: 2.4300e-06
Epoch 36/1000
 9/14 [==================>...........] - ETA: 0s - loss: 0.0729 - accuracy: 0.9826WARNING:tensorflow:Can save best model only with val_accuracy available, skipping.
14/14 [==============================] - ETA: 0s - loss: 0.0682 - accuracy: 0.9861
Epoch 00036: ReduceLROnPlateau reducing learning rate to 7.289999985005124e-07.
14/14 [==============================] - 1s 95ms/step - loss: 0.0682 - accuracy: 0.9861 - val_loss: 0.0622 - val_accuracy: 0.9630 - lr: 2.4300e-06
Epoch 37/1000
14/14 [==============================] - 1s 96ms/step - loss: 0.0573 - accuracy: 0.9907 - val_loss: 0.0613 - val_accuracy: 0.9630 - lr: 7.2900e-07
Epoch 38/1000
14/14 [==============================] - 1s 97ms/step - loss: 0.0575 - accuracy: 0.9931 - val_loss: 0.0607 - val_accuracy: 0.9722 - lr: 7.2900e-07
Epoch 39/1000
14/14 [==============================] - 1s 94ms/step - loss: 0.0622 - accuracy: 0.9769 - val_loss: 0.0600 - val_accuracy: 0.9722 - lr: 7.2900e-07
Epoch 40/1000
14/14 [==============================] - 1s 96ms/step - loss: 0.0660 - accuracy: 0.9838 - val_loss: 0.0594 - val_accuracy: 0.9722 - lr: 7.2900e-07
Epoch 41/1000
14/14 [==============================] - ETA: 0s - loss: 0.0614 - accuracy: 0.9884
Epoch 00041: ReduceLROnPlateau reducing learning rate to 2.1870000637136398e-07.
14/14 [==============================] - 1s 95ms/step - loss: 0.0614 - accuracy: 0.9884 - val_loss: 0.0591 - val_accuracy: 0.9722 - lr: 7.2900e-07
Epoch 42/1000
14/14 [==============================] - 1s 94ms/step - loss: 0.0605 - accuracy: 0.9792 - val_loss: 0.0583 - val_accuracy: 0.9722 - lr: 2.1870e-07
Epoch 43/1000
14/14 [==============================] - 1s 99ms/step - loss: 0.0529 - accuracy: 0.9954 - val_loss: 0.0582 - val_accuracy: 0.9722 - lr: 2.1870e-07
Epoch 44/1000
14/14 [==============================] - ETA: 0s - loss: 0.0500 - accuracy: 0.9884
Epoch 00044: ReduceLROnPlateau reducing learning rate to 6.561000276406048e-08.
14/14 [==============================] - 1s 95ms/step - loss: 0.0500 - accuracy: 0.9884 - val_loss: 0.0580 - val_accuracy: 0.9722 - lr: 2.1870e-07
Epoch 45/1000
14/14 [==============================] - 1s 94ms/step - loss: 0.0613 - accuracy: 0.9861 - val_loss: 0.0581 - val_accuracy: 0.9722 - lr: 6.5610e-08
Epoch 46/1000
14/14 [==============================] - 1s 94ms/step - loss: 0.0672 - accuracy: 0.9861 - val_loss: 0.0572 - val_accuracy: 0.9722 - lr: 6.5610e-08
Epoch 47/1000
14/14 [==============================] - ETA: 0s - loss: 0.0511 - accuracy: 0.9931
Epoch 00047: ReduceLROnPlateau reducing learning rate to 1.9683000829218145e-08.
14/14 [==============================] - 1s 96ms/step - loss: 0.0511 - accuracy: 0.9931 - val_loss: 0.0574 - val_accuracy: 0.9722 - lr: 6.5610e-08
Epoch 48/1000
14/14 [==============================] - 1s 99ms/step - loss: 0.0622 - accuracy: 0.9861 - val_loss: 0.0570 - val_accuracy: 0.9722 - lr: 1.9683e-08
plt.plot(history.history["accuracy"])
plt.plot(history.history["val_accuracy"])
plt.title("Model accuracy")
plt.ylabel("Accuracy")
plt.xlabel("Epoch")
plt.legend(["Train", "Test"], loc = "upper left")
plt.show()
d0d2fcfe72cdf3586fd30984c1e6402a.png 
plt.plot(history.history["loss"])
plt.plot(history.history["val_loss"])
plt.title("Model loss")
plt.ylabel("Loss")
plt.xlabel("Epoch")
plt.legend(["Train", "Test"], loc = "upper left")
plt.show()
822d7938b36fd4674199da8bfea9fd36.png 
def predict_class(img):
    # Resize
    img = img.reshape(1,128,128,3)
    # Predict
    predictions = model.predict(img)
    true_prediction = [tf.argmax(pred) for pred in predictions]
    true_prediction = np.array(true_prediction)
    
    # Return label corresponding to predicted index
    return list(categories.keys())[list(categories.values()).index(true_prediction)]
# Predict on test set
y_pred = model.predict(X_test)
# From categorical outputs to discrete values
y_pred_ = [np.argmax(y) for y in y_pred]
y_test_ = [np.argmax(y) for y in y_test]
from sklearn.metrics import classification_report
print(classification_report(y_test_, y_pred_))
precision    recall  f1-score   support

           0       1.00      0.96      0.98        25
           1       0.85      1.00      0.92        11
           2       1.00      0.96      0.98        24

    accuracy                           0.97        60
   macro avg       0.95      0.97      0.96        60
weighted avg       0.97      0.97      0.97        60
plt.figure(figsize=(10,10))
random_inds = np.random.choice(X_test.shape[0],36)
for i in range(36):
    plt.subplot(6,6,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    image_ind = random_inds[i]
    plt.imshow(np.squeeze(X_test[image_ind]), cmap=plt.cm.binary)
    
    # Predict and get label
    label = predict_class(X_test[image_ind])
    plt.xlabel(label)
dcae1190971ba4105a51843201fc8911.png 
model.save("model.h5")
# 识别接口
def predict(path,model_str,img_size = (128,128)):
  new_model = tf.keras.models.load_model(model_str)
  img = cv2.imread(path)
  img = cv2.resize(img, img_size) # Resize the images
  img = np.array(img)    
  # Resize
  img = img.reshape(1,128,128,3)
  # Predict
  predictions = new_model.predict(img)
  true_prediction = [tf.argmax(pred) for pred in predictions]
  true_prediction = np.array(true_prediction)
  
  # Return label corresponding to predicted index
  return list(categories.keys())[list(categories.values()).index(true_prediction)]
    
predict("./data/A/051.jpg","model.h5")
'A'
predict("./data/B/048.jpg","model.h5")
'B'
predict("./data/C/050.jpg","model.h5")
'C'

2cd9778da853684cb381d11f02809d67.png

e5079741d14b1af21b300214684d7a79.png

 
 
 
 
 
 
 
 
 
 
往期精彩回顾




适合初学者入门人工智能的路线及资料下载中国大学慕课《机器学习》（黄海广主讲）机器学习及深度学习笔记等资料打印机器学习在线手册深度学习笔记专辑《统计学习方法》的代码复现专辑
AI基础下载本站qq群955171419，加入微信群请扫码：
 
 
ebb1f7c0baa9cb0cd23b19fff6588581.png
 


                

        

        

    




    

      

        

            

              
                
                  风度78
                
              
            

            

                关注
              
            

        

        

          
    
            
  • 
              
                
                
                
                
                    1
                
              
              
    点赞
    
            
    • 
            
  • 
              
                
                
                
              
              
    踩
    
            
    • 
            
  • 
              
                
                
                
                
                    2
                
              
              
    
                
    
                  
                    收藏
                  
                
    
              
    
              
    
                
    
                  觉得还不错?
                  
                    一键收藏
                  
                 
                
    
              
    
            
    • 
          
  • 
            
    
              
              
            
    
              
              
              
                    0
              
            
            
    评论
    
          
    • 
          
  • 
          
    • 
          
  • 
            
              
            
              
    
            
              
                
            
    
          
    • 
        

      

      










                



	

		

			

				
					
图像处理8-CNN图像分类

				
			

			

				

					<Hunter>
				

				

					06-30
					
					4851
					
				

			

		

		

			
				
Pytorch 图像分类

			
		

	



                

              
                



	

		

			

				
					
CNN实现图片分类.zip

				
			

			

				

					04-10
				

			

		

		

			
				
数据预处理：将数据集按照类别进行分组处理，分别对应的目录为0-9，读取图片，保存数据集；
	将数据集和标签按照相同的种子进行打乱处理，然后按照标签的比例进行分割数据集，80%作为训练集（训练集中的10%作为验证集，查看是否过拟合），20%作为测试集。
	构建CNN模型，这里是基于TensorFlow2.0进行搭建的，具体代码如图所示：
其中包括输入层（32*32的图像，3通道），两个卷积层，1个池化层，重复一次，展平经过全连接层，最后输出层，除了输出层的激活函数是softmax，其他的都是relu。
	模型训练，将处理后数据经过模型训练
	模型预测，将处理后的测试集数据经过模型进行预测，分别输出模型对于测试集的召回率，精确率和F1测度。
	根据预测结果和实际结果构建混淆矩阵


			
		

	



                


  
              

                


	

		

			

				
					
卷积神经网络CNN经典模型整理Lenet，Alexnet，Googlenet，VGG，Deep Residual Learning,squeezenet

				
			

			

				

					ytusdc的博客
				

				

					09-25
					
					853
					
				

			

		

		

			
				
关于卷积神经网络CNN，网络和文献中有非常多的资料，我在工作/研究中也用了好一段时间各种常见的model了，就想着简单整理一下，以备查阅之需。如果读者是初接触CNN，建议可以先看一看“Deep Learning（深度学习）学习笔记整理系列”中关于CNN的介绍[1]，是介绍我们常说的Lenet为例，相信会对初学者有帮助。

Lenet，1986年Alexnet，2012年GoogleNet，20

			
		

	





	

		

			

				
					
机器学习网络模型绘图模板

				
			

			

				

					m0_72676510的博客
				

				

					10-11
					
					646
					
				

			

		

		

			
				
本期为读者推荐一款名为ML Visuals的机器学习画图PPT模板，ML Visuals专为解决神经网络画图问题设计，通过提供免费的专业的、科学的和充分的视觉和图形来帮助机器学习社区改善科学传播。目前，ML Visuals包含了超过100多个的自定义图形。

			
		

	



		

			
		



	

		

			

				
					
深度学习——图像分类（CNN）—训练模型

					
最新发布

				
			

			

				

					2301_76794217的博客
				

				

					05-23
					
					1320
					
				

			

		

		

			
				
导入必要的库，定义超参数，读取训练和测试标签CSV文件，确保标签是字符串类型，显示两个数据框的前几行以了解它们的结构，定义图像处理参数，创建图像数据生成器，设置目录路径，创建训练和验证数据生成器，构建模型，编译模型，训练模型并收集历史，绘制损失和准确率曲线，保存图表，保存模型到本地

			
		

	





	

		

			

				
					
CNN应用：图片分类

				
			

			

				

					leva的博客
				

				

					08-11
					
					1540
					
				

			

		

		

			
				
然后是两个卷积核级联，卷积核的个数是64，尺寸是3×3，激活函数是ReLU。然后，编码局部结构的简单方法是将相邻输入神经元的子矩阵连接成属于下一层的单隐藏层神经元。例如，可以从28×28输入神经元开始处理MNIST图像，然后（还是以5×5的步幅）在下一个隐藏层中得到每个大小为23×23的神经元的k个特征图。加载CIFAR-10数据，并将其分为X_train和Y_train，X_test用于测试，Y_test是测试集的标签。对X和Y进行混洗可能是有用的，因为这样能避免训练依赖于特定的数据配置。...

			
		

	





	

		

			

				
					
深度学习图片分类CNN模板

				
			

			

				

					微信号：RunsenLiu
				

				

					01-01
					
					1673
					
				

			

		

		

			
				
构建一个字母ABC的手写识别网络,
要求给出算法误差收敛曲线，所给程序要有图片导入接口。

其中A，B，C都代表label，三个文件夹存在具体的图片。只要是这样类型的，直接套下面模板。

import os
import cv2
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import tensorflow as tf
import tqdm

from tensorflow import keras
from

			
		

	





	

		

			

				
					
keras搭建CNN卷积神经网络模板

				
			

			

				

					Chauncy的博客
				

				

					11-25
					
					832
					
				

			

		

		

			
				
import keras
from keras.datasets import mnist
from keras import layers
from keras.utils import np_utils
from keras.optimizers import Adam
from keras.model import load_model
# 画出模型的结构

from keras.utils.vis_utils import plot_model
# 载入数据
(x_train, y_train), 

			
		

	





	

		

			

				
					
猫狗图片深度学习中使用

				
			

			

				

					08-17
				

			

		

		

			
				
通过实践猫狗图片分类项目，你可以深入理解深度学习的基本概念，掌握CNN的运作机制，并提升数据处理和模型调优的能力。同时，这也是一个很好的起点，为进一步探索计算机视觉、图像识别等领域打下基础。

			
		

	





	

		

			

				
					
图片CNN分类模板，换图片和文件夹名　直接使用

				
			

			

				

					01-01
				

			

		

		

			
				
标题中的“图片CNN分类模板，换图片和文件夹名　直接使用”指的是一个基于卷积神经网络（CNN）的图像分类项目，它提供了一个可直接应用的模板，用户只需要替换自己的图片数据集和相应的文件夹名称，即可进行图像分类...

			
		

	





	

		

			

				
					
深度学习-向日葵图片数据集

				
			

			

				

					01-15
				

			

		

		

			
				
总的来说，"深度学习-向日葵图片数据集"是深度学习和计算机视觉领域的一个实例，用于训练和评估图像分类模型，尤其是向日葵识别。通过这个数据集，我们可以学习如何构建、训练和优化深度学习模型，以及理解数据质量...

			
		

	





	

		

			

				
					
cnn的5*5模板实现

				
			

			

				

					05-06
				

			

		

		

			
				
5*5的cnn模板实现，可以作为研究神经网络的参考，在向高的层次扩展的同时的一个基础

			
		

	





	

		

			

				
					
建立的简单的CNN_model模型，是python类型的程序代码

				
			

			

				

					10-02
				

			

		

		

			
				
建立的简单的CNN模型，用于相互作用的计算。建立的模型较为简单，适合刚开始接触CNN模型的新手参考

			
		

	





	

		

			

				
					
深度学习-雏菊图片数据集

				
			

			

				

					01-15
				

			

		

		

			
				
在本案例中，“深度学习-雏菊图片数据集”是一个专门为训练和验证深度学习模型而设计的图像集合，主要用于花卉识别，特别是雏菊的识别。  这个数据集包含了633张不同的雏菊图片，每张照片都展示了雏菊的各种形态，如...

			
		

	





	

		

			

				
					
深度学习-郁金香图片数据集

				
			

			

				

					01-15
				

			

		

		

			
				
在这个特定的场景中，我们有一个名为"深度学习-郁金香图片数据集"的资源，它包含了799张郁金香的图片，这些图片展示了郁金香的各种形态，如花朵的不同阶段、不同颜色以及可能的品种差异。  首先，我们可以从这个数据...

			
		

	





	

		

			

				
					
经典的图像分类CNN网络总结

				
			

			

				

					qq_44540136的博客
				

				

					06-04
					
					342
					
				

			

		

		

			
				
经典的CNN网络模型总结，从Alexnet到VGG再到Googlenet、ResNet残差网络

			
		

	





	

		

			

				
					
Char_Level_CNN_Model 模型介绍

				
			

			

				

					Jason24_Zeng的博客
				

				

					10-23
					
					479
					
				

			

		

		

			
				
Char_Level_CNN_Model模型介绍模型参数总览逐层介绍Input LayerEmbedding LayerConvolution layers 1D逐层计算参数量：Flatten LayerFull Connected(FC) Layers and Output Layer参数数量预测：Build ModelTrain Model
模型介绍
模型参数总览
_________________________________________________________________
Laye

			
		

	





	

		

			

				
					
一个简单的CNN model，训练集MNIST

				
			

			

				

					一条有梦想的咸鱼
				

				

					04-09
					
					1381
					
				

			

		

		

			
				
欢迎使用Markdown编辑器写博客

本Markdown编辑器使用StackEdit修改而来，用它写博客，将会带来全新的体验哦：


Markdown和扩展Markdown简洁的语法
代码块高亮
图片链接和图片上传
LaTex数学公式
UML序列图和流程图
离线写博客
导入导出Markdown文件
丰富的快捷键






快捷键


加粗    Ctrl + B 
斜体    Ctrl + I

			
		

	





	

		

			

				
					
CNN架构

				
			

			

				

					云计算、数据库、大数据、容器、微服务、深度学习、NLP、Python
				

				

					03-18
					
					326
					
				

			

		

		

			
				
LeNet-5
特点：采用2个卷积，2个全连接层
采用sigmoid激活函数
10分类
AlexNet
5个卷积层 3个全连接层
参数6000千万
采用Relu激活函数
加入dropout
使用批标准化
100分类
VGG
获得2014年ImageNet的亚军
19层的卷积层
1.4亿个参数
采用更小的卷积核  11 33的
获得更小参数
inception
使用11 33 5*5 max_po...

			
		

	





	

		

			

				
					
如何利用 Flink 和深度学习模型实现垃圾图片分类（Apache Flink 极客挑战赛特别场.pdf

				
			

			

				

					03-21
				

			

		

		

			
				
"如何利用 Flink 和深度学习模型实现垃圾图片分类"  这篇文档主要探讨了如何结合Apache Flink大数据处理框架与深度学习技术来解决垃圾图片分类问题。Apache Flink作为一个实时流处理平台，能够有效地处理和分析大量...

			
		

	



              



  
“相关推荐”对你有帮助么？

  

      
    
          
  • 
              
    
                  
                  
              
    
              
    非常没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    没帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    一般
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    有帮助
    
          
    • 
          
  • 
              
    
                  
                  
              
    
              
    非常有帮助
    
          
    • 
      

      

      

          
          提交
      

      

  




          




        



    





    



      

      

        
      

      





	

		评论	
	

	
	




  

    

      添加红包
      
    

    

      

        
        

          
          
        

        
请填写红包祝福语或标题

      

      

        
        

          
          个
        

        
红包个数最小为10个

      

      

        
        

          
          元
        

        
红包金额最低5元

      

      

        
        

          当前余额3.43元
          前往充值 >
        

      

      

        

          需支付：10.00元
        

        
        
      

    

  





  

    
    
  

  

    
    
  








  

    

      

        

          

            
            
成就一亿技术人!

          

          

        

        

          

          

            领取后你会自动成为博主和红包主的粉丝
            规则
          

        

      

      

        

          

            
              
            
            

              
hope_wisdom
 发出的红包
            

          

        

        

          

          

          

        

      

    

    

  



      
      

      
实付元

      
使用余额支付

      

        

          

            
            点击重新获取
          

        

        
扫码支付

      

      

        
          
            
          
          
        
      

      

        
        钱包余额
          0
          

            
            

              

                
抵扣说明：

                
 1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
 2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

              

            

          

      

      余额充值