keras-多标签分类

r囧r小猫 2021-11-17 07:32 369阅读 0赞

import numpy as np
    import matplotlib.pyplot as plt
    import pandas as pd
    from keras.layers.core import Dense,Activation,Dropout,Flatten
    from keras.layers.advanced_activations import PReLU
    from keras.layers.convolutional import Convolution2D,MaxPooling2D
    from keras.optimizers import SGD,Adadelta,Adagrad
    from keras.utils import np_utils,generic_utils
    import random
    np.random.seed(1024)
    from PIL import Image
    from keras.models import Sequential
    import time
    from keras.layers import LSTM
    import math
    from sklearn.preprocessing import MinMaxScaler
    from sklearn.metrics import mean_squared_error
    from keras import optimizers
    import os
    from keras.preprocessing.image import ImageDataGenerator
    from keras import backend as K
    from keras.models import Sequential
    from keras.layers.normalization import BatchNormalization
    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 Dropout
    from keras.layers.core import Dense
    from keras import backend as K
    
    class SmallerVGGNet:
        @staticmethod
        def build(width,height,depth,classes,finalAct="softmax"):
            #initialize the model along with the input shape to be channels last and the channels dimension itself
            model = Sequential()
            inputShape = (height,width,depth)
            chanDim = -1
            #if we are using "channel first",update the input shape and channels dimension
            if K.image_data_format()=='channels_first':
                inputShape = (depth,height,width)
                chanDim = 1
                # CONV => RELU => POOL
                model.add(Conv2D(32, (3, 3), padding="same",
                                 input_shape=inputShape))
                model.add(Activation("relu"))
                model.add(BatchNormalization(axis=chanDim))
                model.add(MaxPooling2D(pool_size=(3, 3)))
                model.add(Dropout(0.25))
                # (CONV => RELU) * 2 => POOL
                model.add(Conv2D(64, (3, 3), padding="same"))
                model.add(Activation("relu"))
                model.add(BatchNormalization(axis=chanDim))
                model.add(Conv2D(64, (3, 3), padding="same"))
                model.add(Activation("relu"))
                model.add(BatchNormalization(axis=chanDim))
                model.add(MaxPooling2D(pool_size=(2, 2)))
                model.add(Dropout(0.25))
    
                # (CONV => RELU) * 2 => POOL
                model.add(Conv2D(128, (3, 3), padding="same"))
                model.add(Activation("relu"))
                model.add(BatchNormalization(axis=chanDim))
                model.add(Conv2D(128, (3, 3), padding="same"))
                model.add(Activation("relu"))
                model.add(BatchNormalization(axis=chanDim))
                model.add(MaxPooling2D(pool_size=(2, 2)))
                model.add(Dropout(0.25))
                # first (and only) set of FC => RELU layers
                model.add(Flatten())
                model.add(Dense(1024))
                model.add(Activation("relu"))
                model.add(BatchNormalization())
                model.add(Dropout(0.5))
    
                # use a *softmax* activation for single-label classification
                # and *sigmoid* activation for multi-label classification
                model.add(Dense(classes))
                model.add(Activation(finalAct))
    
                # return the constructed network architecture
                return model
    
    
    
    
    from keras.preprocessing.image import ImageDataGenerator
    from keras.optimizers import Adam
    from keras.preprocessing.image import img_to_array
    from sklearn.preprocessing import MultiLabelBinarizer
    from sklearn.model_selection import train_test_split
    import matplotlib.pyplot as plt
    from imutils import paths
    import numpy as np
    import argparse
    import random
    import pickle
    import cv2
    import os
    
    
    # construct the argument parse and parse the arguments
    ap = argparse.ArgumentParser()
    ap.add_argument("-d", "--dataset", required=True,
    	help="path to input dataset (i.e., directory of images)")
    ap.add_argument("-m", "--model", required=True,
    	help="path to output model")
    ap.add_argument("-l", "--labelbin", required=True,
    	help="path to output label binarizer")
    ap.add_argument("-p", "--plot", type=str, default="plot.png",
    	help="path to output accuracy/loss plot")
    args = vars(ap.parse_args())
    
    
    '''
    --dataset : The path to our dataset.
    --model : The path to our output #serialized Keras model.
    --labelbin : The path to our output multi-label binarizer object.
    --plot : The path to our output plot of training loss and accuracy.
    '''
    
    #intialize the number of epochs to train for,intial learning rate,batch size and image dimensions
    epochs = 75
    init_lr = 1e-3
    bs = 32
    image_dims = (96,96,3)
    
    #grab the image pths and randomly shuffle them
    print("[Info] loading images...")
    imagePaths = sorted(list(paths.list_images(args["dataset"])))
    random.seed(42)
    random.shuffle(imagePaths)
    
    #initizlize the data and labels
    data = []
    labels = []
    
    #loop over the input images
    for imagePath in imagePaths:
        #load the image ,pre-proces it and store it in the data list
        image = cv2.imread(imagePath)
        image = cv2.resize(image,(image_dims[1],image_dims[0]))
        image = img_to_array(image)
        data.append(image)
    
    #scale the raw pixel intensities to the range[0,1
    
    data = np.array(data,dtype="float")/255.0
    labels = np.array(labels)
    print("[Info] data matrix:{} images(:.2f)MB".format(len(imagePaths),data.nbytes/(1024*1000.0)))
    
    #二值化标签
    print("[Info] class labels:")
    mlb = MultiLabelBinarizer()
    labels = mlb.fit_transform(labels)
    
    #loop over each of the possible class labels and show them
    for (i,label) in enumerate(mlb.classes_):
        print("{}.{}".format(i+1,label))
    
    
    (trainX, testX, trainY, testY) = train_test_split(data,
    	labels, test_size=0.2, random_state=42)
    
    #图像增强
    aug = ImageDataGenerator(rotation_range=25,width_shift_range=0.1,height_shift_range=0.1,shear_range=0.2,zoom_range=0.2,horizontal_flip=True,fill_mode="nearest")
    
    #接下来就是建立模型了
    #initialize the model using a sigmoid activation as the final layer in the network so we can perform multi-label classification
    print("[Info] compilig model...")
    model = SmallerVGGNet.build(width=image_dims[1],height=image_dims[0],depth=image_dims[2],classes=len(mlb.classes_),finalAct="sigmoid")
    
    #初始化优化器
    opt = Adam(lr=init_lr,decay=init_lr/epochs)
    
    
    # compile the model using binary cross-entropy rather than
    # categorical cross-entropy -- this may seem counterintuitive for
    # multi-label classification, but keep in mind that the goal here
    # is to treat each output label as an independent Bernoulli
    # distribution
    model.compile(loss="binary_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))
    
    #保存模型
    print("[Info] serializing network...")
    
    model.save(args["model"])
    
    # save the multi-label binarizer to disk
    print("[INFO] serializing label binarizer...")
    f = open(args["labelbin"], "wb")
    f.write(pickle.dumps(mlb))
    f.close()
    
    # 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")
    plt.xlabel("Epoch #")
    plt.ylabel("Loss/Accuracy")
    plt.legend(loc="upper left")
    plt.savefig(args["plot"])
    
    
    
    '''
    python GenderTrain.py --dataset dataset --model fashion.model --labelbin mlb.pickle
    '''

# -*- coding: utf-8 -*-
    """
    Created on 2019/5/25 17:00
    @Author: Johnson
    @Email:593956670@qq.com
    @File: 3-classify.py
    """
    from keras.preprocessing.image import img_to_array
    from keras.models import load_model
    import numpy as np
    import argparse
    import imutils
    import pickle
    import cv2
    import os
    
    
    #constuct the argument parse and parse the arguments
    
    ap = argparse.ArgumentParser()
    ap.add_argument("-m","--model",required=True,help="path to trained model model")
    ap.add_argument("-l","--labelbin",required=True,help="path to label binarizer")
    ap.add_argument("-i","--image",required=True,help="path to input image")
    
    args = vars(ap.parse_args())
    
    #load the image
    image = cv2.imread(args["image"])
    output = imutils.resize(image,width=400)
    
    #pre-process the image for classification
    image = cv2.resize(image,(96,96))
    image = image.astype("float")/255.0
    image = img_to_array(image)
    image = np.expand_dims(image,axis=0)
    
    #load the trained network and the multi-label
    print("[Info] loading network...")
    model = load_model(args["model"])
    mlb = pickle.load(open(args["labelbin"],"rb").read())
    
    #classify the input image then find the indexex of the two class
    proba = model.predict(image)[0]
    idxs = np.argsort(proba)[::-1][:2]
    
    #loop over the indexes of the high confidence class labels
    for (i,j) in enumerate(idxs):
        #build the lable and draw the label on the image
        label = "{}:{:.2f}%".format(mlb.class_[j],proba[j]*100)
        cv2.putText(output,label,(10,(0*30)+25),cv2.FONT_HERSHEY_SIMPLEX,0.7,(0,255,0),2)
    
    # show the probabilities for each of the individual labels
    for (label, p) in zip(mlb.classes_, proba):
        print("{}: {:.2f}%".format(label, p * 100))
    
    # show the output image
    cv2.imshow("Output", output)
    cv2.waitKey(0)
    
    
    '''
    python classify.py --model fashion.model --labelbin mlb.pickle \
    	--image examples/example_01.jpg
    '''