机器学习—— 垃圾分类

垃圾分类

一、选题背景

现在随着人口数量的增多，产生了越来越多的垃圾。为了保护好我们居住的环境，我们应该学会垃圾分类，尽到垃圾分类的义务，做一名合格的公民。垃圾分类可以减少对环境的污染，还可以减少垃圾的占地面积，同时可以将回收的垃圾进行二次利用。减少垃圾产量之后不仅可以美化城市环境，而且还能对某些有价值的垃圾进行回收，能够减少资源的浪费，还可以减少二氧化碳的排放量。

二、机器学习案例设计方案

1. 本次项目所用的数据集是从kaggo平台下载的，在dataset文件下有四个类别文件，是四个大类的垃圾分类的名称

数据集分为：训练图像集、训练标签集、测试图像集、测试标签集、

 　　2.本次采用的深度学习的框架是 Tensorflow

 

Tensorflow的简介：TensorFlow™是一个基于数据流编程（dataflow programming）的符号数学系统，被广泛应用于各类机器学习（machine learning）算法的编程实现，其前身是谷歌的神经网络算法库DistBelief [1]  。

Tensorflow拥有多层级结构，可部署于各类服务器、PC终端和网页并支持GPU和TPU高性能数值计算，被广泛应用于谷歌内部的产品开发和各领域的科学研究 [1-2]  。

TensorFlow由谷歌人工智能团队谷歌大脑（Google Brain）开发和维护，拥有包括TensorFlow Hub、TensorFlow Lite、TensorFlow Research Cloud在内的多个项目以及各类应用程序接口（Application Programming Interface, API） [2]  。自2015年11月9日起，TensorFlow依据阿帕奇授权协议（Apache 2.0 open source license）开放源代码 [2]  。

Keras是基于TensorFlow和Theano（由加拿大蒙特利尔大学开发的机器学习框架）的深度学习库，是由纯python编写而成的高层神经网络API，也仅支持python开发。它是为了支持快速实践而对tensorflow或者Theano的再次封装，让我们可以不用关注过多的底层细节，能够把想法快速转换为结果。它也很灵活，且比较容易学。Keras默认的后端为tensorflow，如果想要使用theano可以自行更改。tensorflow和theano都可以使用GPU进行硬件加速，往往可以比CPU运算快很多倍。因此如果你的显卡支持cuda的话，建议尽可能利用cuda加速模型训练。（当机器上有可用的GPU时，代码会自动调用GPU 进行并行计算。）

Keras已经被TensorFlow收录，添加到TensorFlow 中，成为其默认的框架，成为TensorFlow官方的高级API。

 

　　　  3.本次涉及图像的处理，卷积神经网络的建造

 

三、深度学习的实现步骤

1. 本次的目的是：实现电脑对垃圾进行分类
2. 数据切分成四份

 

 

 

 

 

 

　　  3.因为深度学习的卷积比较适合做图像类的处理，所以本次选用卷积神经网络模型下面对一些必要的参数进行解释

 

 

 

　　  4.开始搭建卷积神经网络模型

 

 

 

 

　　　　5.开始训练模型

 

 

 

 

　　　　6.测试

　　　　　　模型的准确率可以达到98%

 

 

四、总结

1. 通过本次的学习，让我初步了解深度学习的强大之处，电脑的算力远远超过人的大脑，在接下来的社会发展中肯定是人工智能越来越发达，计算机以后会越来越帮助人们的生活
2. 在本次的设计中我明白了，一个好的模型是要通过好就的训练，不断的调整参数来进行训练，训练的数据也会对模型的准确率有影响，我想到的改进方法就是用算力更高的计算机，用更多的数据集以及参数来训练

 

 

五、程序代码

import cv2

import os

from keras.utils import np_utils

import numpy as np

#随机生成10个数

np.random.seed(10)

import random

import sys

 

# train_images表示训练图像数据;  train_labels代表是训练图像对应的标签;  test_images代表是测试图像数据;   test_labels代表测试图像对应的标签

 

 

# 将其中90%的图像数据做训练集和测试集,将四个类别的数据随机打乱,让每一个类别的数据都可以做成训练集数据

def makeTrainTestData(images, labels, trainRatio=0.9):

 

    c = list(zip(images, labels))

 

    random.shuffle(c)

 

    images, labels = zip(*c)

 

    train_num = int(trainRatio * len(images))

 

    train_images, train_labels = images[:train_num], labels[:train_num]

 

    test_images, test_labels = images[train_num:], labels[train_num:]

 

    return (np.array(train_images), np.array(train_labels)), (np.array(test_images), np.array(test_labels))

 

# 读取图像集,将图像集做成训练集和测试集

 

def readData(path=r"./dataset7/", trainRatio=0.9):

 

    images = []

 

    labels = []

 

    subdirs = os.listdir(path)

 

    subdirs.sort()

 

    print(subdirs)

 

    classes = len(subdirs)

 

# 读取每一个类别的数据,具体到每一个照片

 

    for subdir in range(classes):

 

        for index in os.listdir(os.path.join(path, subdirs[subdir])):

 

            indexDir = os.path.join(path, subdirs[subdir], index)

 

            sys.stdout.flush()

 

            print("label --> dir : {} --> {}".format(subdirs[subdir], indexDir))

 

            for indexdir in os.listdir(indexDir):

 

                image_path = os.path.join(indexDir, indexdir)

 

                img = cv2.imread(image_path)

 

                img = cv2.resize(img, dsize=(32, 32), interpolation=cv2.INTER_AREA)

 

                images.append(img)

 

                labels.append(subdir)

 

    (train_images, train_labels), (test_images, test_labels) = makeTrainTestData(images, labels)

 

    np.save("train_images.npy", train_images)

 

    np.save("test_images.npy", test_images)

 

    np.save("train_labels.npy", train_labels)

 

    np.save("test_labels.npy", test_labels)

 

    return (train_images, train_labels), (test_images, test_labels)

 

# 保存的形式为npy文件

try:

    train_images = np.load("train_images.npy")

 

    test_images = np.load("test_images.npy")

 

    train_labels = np.load("train_labels.npy")

 

    test_labels = np.load("test_labels.npy")

except:

    (train_images, train_labels), (test_images, test_labels) = readData()

 

print(train_images.shape)                                                                    #打印训练集数据的形状

 

print(test_images.shape)                                                                     #打印测试集数据的形状

 

print(train_labels.shape)

 

print(test_labels.shape)

 

# 将训练集数据和测试集数据进行归一化处理

train_image_norm=train_images.astype('float32')/255

test_image_norm=test_images.astype('float32')/255

 

# 将训练集和测试集进行oneho编码

train_labels_ohe=np_utils.to_categorical(train_labels)

test_labels_ohe=np_utils.to_categorical(test_labels)

 

print(train_labels[:10])

print(test_labels_ohe[:10])

 

 

import matplotlib.pyplot as plt

 

def plot_image(image):

    fig=plt.gcf()

    fig.set_size_inches(2,2)

    plt.imshow(image)

    plt.show()

 

for i in range(0,10):

    b,g,r = cv2.split(train_images[i])

    img_rgb=cv2.merge([r,g,b])

    plot_image(img_rgb)

    print(train_labels[i])

 

 

 

from keras.models import Sequential

from keras.layers import Conv2D,MaxPooling2D,ZeroPadding2D,Dropout

from keras.layers import Flatten,Dense

import tensorflow as tf

import keras.backend as K

from keras.callbacks import LearningRateScheduler

 

 

# 这个就是建模形          这个是采用卷积神经网络(CNN)

model=Sequential()

model.add(Conv2D(filters=48,

                 kernel_size=(3,3),

                 input_shape=(32,32,3),

                 activation='relu',

                 padding='same'))

 

model.add(Dropout(0.25))

 

model.add(MaxPooling2D(pool_size=(2,2)))

 

model.add(Conv2D(filters=64,

                 kernel_size=(3,3),

                 activation='relu',

                 padding='same'))

 

model.add(Dropout(0.25))

 

model.add(MaxPooling2D(pool_size=(2,2)))

 

model.add(Flatten())

model.add(Dropout(0.2))

 

model.add(Dense(units=1000,activation='relu'))

 

model.add(Dropout(0.2))

 

model.add(Dense(units=4,activation='softmax'))

 

model.summary()

 

 

try:

    model.load_weights("CNNModel.h5")

    print('be ready')

except:

    print("not prepare well")

 

 

def scheduler(epoch):

 

    if epoch % 100 == 0 and epoch != 0:

 

        lr = K.get_value(model.optimizer.lr)

 

        K.set_value(model.optimizer.lr, lr * 0.01)

 

        print("lr changed to {}".format(lr * 0.01))

 

    return K.get_value(model.optimizer.lr)

 

reduce_lr = LearningRateScheduler(scheduler)

 

while True:

 

    model.compile(tf.keras.optimizers.Adam(lr=0.001),

 

                  loss="categorical_crossentropy",

                  metrics=['acc'])

    train_history = model.fit(x=train_image_norm,

                              y=train_labels_ohe,

                              validation_split=0.1,


                              epochs=10,

                              batch_size=64,

                              verbose=1,

                             callbacks=[reduce_lr])

    results = model.evaluate(test_image_norm, test_labels_ohe)

    print('accuracy=', results[1])

    if results[1] >= 0.97:

        model.save_weights("CNNModel.h5")

        print("Save the newly trained model")

        break

 

# 验证这个模型的准确率是多少,用上面10%的数据作为验证数据来检验

model.compile(loss="categorical_crossentropy",optimizer='adam',

metrics=['accuracy'])


results=model.evaluate(test_image_norm,test_labels_ohe)

print('accuracy=',results[1])

 

print(str(reduce_lr))