keras图像分类详解

最新推荐文章于 2024-07-06 22:37:37 发布

w_xjlxm

最新推荐文章于 2024-07-06 22:37:37 发布

阅读量395

点赞数

分类专栏：深度学习文章标签：深度学习神经网络 python

本文链接：https://blog.csdn.net/w_xjlxm/article/details/103886416

版权

深度学习专栏收录该内容

0 篇文章 0 订阅

订阅专栏

基于keras深度学习搭建的图像分类

本项目搭建了一个经典深度学习图像分类，本项目是借鉴于https://www.cnblogs.com/skyfsm/p/8051705.html
该项目总的分为3个程序，分别为lenet.py，train.py，predict.py。用vscode和anaconda进行开发，anaconda用于搭建开发虚拟环境，具体怎么搭建可以参考我的另外一个csdn文章https://blog.csdn.net/w_xjlxm/article/details/103844533，该文章详细介绍了如何搭建和指定python版本

1.卷积神经网络lenet

# import the necessary packages
from keras.models import Sequential
from keras.layers.convolutional import Conv2D
from keras.layers.convolutional import MaxPooling2D
from keras.layers.core import Activation
from keras.layers.core import Flatten
from keras.layers.core import Dense
from keras import backend as K
 
class LeNet:
    @staticmethod
    def build(width, height, depth, classes):
        # initialize the model
        model = Sequential()
        inputShape = (height, width, depth)
        # if we are using "channels last", update the input shape
        if K.image_data_format() == "channels_first":   #for tensorflow
            inputShape = (depth, height, width)
        # first set of CONV => RELU => POOL layers
        model.add(Conv2D(20, (5, 5),padding="same",input_shape=inputShape))
        model.add(Activation("relu"))
        model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
        #second set of CONV => RELU => POOL layers
        model.add(Conv2D(50, (5, 5), padding="same"))
        model.add(Activation("relu"))
        model.add(MaxPooling2D(pool_size=(2, 2), strides=(2, 2)))
        # first (and only) set of FC => RELU layers
        model.add(Flatten())
        model.add(Dense(500))
        model.add(Activation("relu"))

        # softmax classifier
        model.add(Dense(classes))
        model.add(Activation("softmax"))
        

        # return the constructed network architecture
        return model

if __name__ == '__mian__':
    print('22222222222222')
    app = LeNet()
    a = app.build(32,32,3,62)

下面为train程序

# set the matplotlib backend so figures can be saved in the background
import matplotlib
matplotlib.use("Agg")
 
# import the necessary packages
from keras.preprocessing.image import ImageDataGenerator
from keras.optimizers import Adam
from sklearn.model_selection import train_test_split
from keras.preprocessing.image import img_to_array
from keras.utils import to_categorical
from imutils import paths
import matplotlib.pyplot as plt
import numpy as np
import argparse
import random
import cv2
import os
import sys
from lenet import LeNet


def load_data(path,CLASS_NUM,norm_size):
    print("[INFO] loading images...")
    data = []
    labels = []
    # grab the image paths and randomly shuffle them
    imagePaths = sorted(list(paths.list_images(path)))
    random.seed(42)
    random.shuffle(imagePaths)
    # loop over the input images
    for imagePath in imagePaths:
        # load the image, pre-process it, and store it in the data list
        image = cv2.imread(imagePath)
        image = cv2.resize(image, (norm_size, norm_size))
        image = img_to_array(image)
        data.append(image)

        # extract the class label from the image path and update the
        # labels list
        label = int(imagePath.split(os.path.sep)[-2])       
        labels.append(label)
    
    # scale the raw pixel intensities to the range [0, 1]
    data = np.array(data, dtype="float") / 255.0
    labels = np.array(labels)

    # convert the labels from integers to vectors
    labels = to_categorical(labels, num_classes=CLASS_NUM)                         
    return data,labels


def train(aug,trainX,trainY,testX,testY,EPOCHS,INIT_LR,BS,CLASS_NUM,norm_size,model):
    # initialize the model
    print("[INFO] compiling model...")
    model = LeNet.build(width=norm_size, height=norm_size, depth=3, classes=CLASS_NUM)
    opt = Adam(lr=INIT_LR, decay=INIT_LR / EPOCHS)
    model.compile(loss="categorical_crossentropy", optimizer=opt,
        metrics=["accuracy"])

    # train the network
    print("[INFO] training network...")
    H = model.fit_generator(aug.flow(trainX, trainY, batch_size=BS),
        validation_data=(testX, testY), steps_per_epoch=len(trainX) // BS,
        epochs=EPOCHS, verbose=1)

    # save the model to disk
    print("[INFO] serializing network...")
    model.save(model)
    
    # plot the training loss and accuracy
    plt.style.use("ggplot")
    plt.figure()
    N = EPOCHS
    plt.plot(np.arange(0, N), H.history["loss"], label="train_loss")
    plt.plot(np.arange(0, N), H.history["val_loss"], label="val_loss")
    plt.plot(np.arange(0, N), H.history["acc"], label="train_acc")
    plt.plot(np.arange(0, N), H.history["val_acc"], label="val_acc")
    plt.title("Training Loss and Accuracy on traffic-sign classifier")
    plt.xlabel("Epoch #")
    plt.ylabel("Loss/Accuracy")
    plt.legend(loc="lower left")
    plt.savefig("plot.png")

if __name__=='__main__':
    # initialize the number of epochs to train for, initial learning rate,
    # and batch size
    global EPOCHS 
    EPOCHS = 68
    INIT_LR = 1e-3
    BS = 32
    CLASS_NUM = 3
    norm_size = 64
    train_file_path = './cutlenet/pic/train/'
    test_file_path = './cutlenet/pic/train//test/'
    model = "cut.model"
    trainX,trainY = load_data(train_file_path,CLASS_NUM,norm_size)
    testX,testY = load_data(test_file_path,CLASS_NUM,norm_size)
    # construct the image generator for data augmentation
    aug = ImageDataGenerator(rotation_range=30, width_shift_range=0.1,
        height_shift_range=0.1, shear_range=0.2, zoom_range=0.2,
        horizontal_flip=True, fill_mode="nearest")
    train(aug,trainX,trainY,testX,testY,EPOCHS,INIT_LR,BS,CLASS_NUM,norm_size,model)

下面为predict程序

# import the necessary packages
from keras.preprocessing.image import img_to_array
from keras.models import load_model
import numpy as np
import argparse
import imutils
import cv2
import os

norm_size = 64

def predict(model,image):
    # load the trained convolutional neural network
    print("[INFO] loading network...")
    model = load_model(model)
    
    #load the image
    image = cv2.imread(image)
    orig = image.copy()
     
    # pre-process the image for classification
    image = cv2.resize(image, (norm_size, norm_size))
    image = image.astype("float") / 255.0
    image = img_to_array(image)
    image = np.expand_dims(image, axis=0)
     
    # classify the input image
    result = model.predict(image)[0]
    #print (result.shape)
    proba = np.max(result)
    label = str(np.where(result==proba)[0])
    label = "{}: {:.2f}%".format(label, proba * 100)
    print(label)
    
    if True:   
        # draw the label on the image
        output = imutils.resize(orig, width=400)
        cv2.putText(output, label, (10, 25),cv2.FONT_HERSHEY_SIMPLEX,
            0.7, (0, 255, 0), 2)       
        # show the output image
        cv2.imshow("Output", output)
        cv2.waitKey(0)

if __name__ == '__main__':

    model = './cut.model'
    # image = './2.png'    filelist = os.listdir('./testpic/')
    for file in filelist:
        image = os.path.join('./testpic/',file)
        print(image)
        predict(model,str(image))