finish the final example of model 3

Author: FanFanFantazy

.vscode/chapter3.md

@@ -159,6 +159,37 @@ waitKey()与waitKey(0)代表窗口无线等待，直到有按键按下。waitKey
 
 我们在看openCV 的材料时会经常看到```cv2.waitKey(1) & 0xFF == ord('q')```这样的写法来获取用户按键操作的。其意思为：**0xff** 是一个16进制的数，转换成二进制就 **1111 1111** 占八个位，这样和waitKey()进行与运算后，就将其八位之前的所有数都变成了0。**ord('q')**是q转换成ASCII码值，和刚刚算出来的后八位进行比较。因此我们可以获得用户的按键信息从而控制。
 
+#### 1.3 视频人脸检测性别
+
+除了使用openCv已有的模型进行人脸的识别，我们可以引入一些训练好的数据模型来扩展我们的功能。这个案例中，我们可以体验一下检测视频中出现人的性别。
+
+1. 首先我们需要安装**TensorFlow** 的包。在terminal中输入```pip install tensorflow``` 点击回车就可以安装python下的TensorFlow了。
+
+**TensorFlow** 
+
+
+#### 1.4 训练一个模型
+##### 1.4.1 Keras  
+Keras 是一个用 Python 编写的高级神经网络 API，它能够以 TensorFlow, CNTK, 或者 Theano 作为后端运行。Keras 的开发重点是支持快速的实验。能够以最小的时延把你的想法转换为实验结果，是做好研究的关键。[来自官方文档](https://keras.io/zh/)
+
+Keras 的适用范围： 
++ 允许简单而快速的原型设计（由于用户友好，高度模块化，可扩展性）。
++ 同时支持卷积神经网络和循环神经网络，以及两者的组合。
++ 在 CPU 和 GPU 上无缝运行。
+
+Keras 的模块结构图：
+<img src= "../mdSrc/kerasModelStruct.png" width="800"></img>
+
+
+Keras 神经网络结构图：
+<img src = "../mdSrc/kerasNeuralNetworkModel.png">
+
+**以上两图均来自于网络**
+
+
+
+
+
 ---
 
 ```

__pycache__/catch_face.cpython-37.pyc

@@ -0,0 +1,51 @@
+import cv2
+
+
+def CatchFace(window_name, catch_pic_num, path_name):
+    cv2.namedWindow(window_name)
+    cap = cv2.VideoCapture(0)
+    classfier = cv2.CascadeClassifier(
+        r"./openCv/opencv/data/haarcascades/haarcascade_frontalface_alt2.xml"
+    )
+    color = (115, 233, 86)
+    num = 1
+    while cap.isOpened():
+        try:
+            ok, frame = cap.read()
+            grey = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
+            faceRects = classfier.detectMultiScale(
+                grey, scaleFactor=1.2, minNeighbors=3, minSize=(80, 80)
+            )
+            if len(faceRects) > 0:
+                for (x, y, w, h) in faceRects:
+                    img_name = '%s/%d.jpg' % (path_name, num)  # 定义图片存储路径+图片名称
+                    image = frame[y - 10: y + h + 10, x - 10: x + w + 10]
+                    cv2.imwrite(img_name, image)  # 将当前帧保存为图片
+                    num += 1
+                    if num > (catch_pic_num):   # 成功捕捉超过1000次突出循环
+                        break
+                    cv2.rectangle(
+                        frame, (x - 10, y - 10), (
+                            x + w + 10, y + h + 10
+                        ), color, 2
+                    )  # 画矩形
+                    cv2.putText(
+                        frame, 'num:%d' % (num), (
+                            x + 30, y + 30
+                        ), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 255), 4
+                    )  # 显示当前捕捉人脸图片是第几个
+            # 超过指定最大保存数量结束程序
+            if num > (catch_pic_num):
+                break
+            cv2.imshow(window_name, frame)
+            c = cv2.waitKey(10)
+            if c & 0xFF == ord('q'):
+                break
+        except BaseException:
+            continue
+    cap.release()
+    cv2.destroyAllWindows()
+
+
+if __name__ == '__main__':
+    CatchFace("CatchFace", 1000, './faceData/posFaceData')

__pycache__/clear_folder.cpython-37.pyc

@@ -0,0 +1,18 @@
+import os
+
+
+def clearFolder(folderPath):
+    for i in os.listdir(folderPath):
+        path_file = os.path.join(folderPath, i)
+        if os.path.isfile(path_file):
+            os.remove(path_file)
+        else:
+            for f in os.listdir(path_file):
+                path_file2 = os.path.join(path_file, f)
+                if os.path.isfile(path_file2):
+                    os.remove(path_file2)
+    print("Folder has been cleared")
+
+
+if __name__ == '__main__':
+    clearFolder('./faceData/posFaceData')

__pycache__/face_train.cpython-37.pyc

@@ -0,0 +1,244 @@
+import random
+# import numpy as np
+from sklearn.model_selection import train_test_split
+from keras.preprocessing.image import ImageDataGenerator
+from keras.models import Sequential
+from keras.layers import Dense, Dropout, Activation, Flatten
+from keras.layers import Convolution2D, MaxPooling2D
+from keras.optimizers import SGD
+from keras.utils import np_utils
+from keras.models import load_model
+from keras import backend as K
+from load_data import load_dataset, resize_image, IMAGE_SIZE
+
+
+class Dataset:
+    def __init__(self, path_name):
+        # 训练集
+        self.train_images = None
+        self.train_labels = None
+        # 验证集
+        self.valid_images = None
+        self.valid_labels = None
+        # 测试集
+        self.test_images = None
+        self.test_labels = None
+        # 数据集加载路径
+        self.path_name = path_name
+        # 当前库采用的维度顺序
+        self.input_shape = None
+
+    # 加载数据集并按照交叉验证的原则划分数据集并进行相关预处理工作
+    def load(self, img_rows=IMAGE_SIZE, img_cols=IMAGE_SIZE,
+             img_channels=3, nb_classes=2):
+        # 加载数据集到内存
+        images, labels = load_dataset(self.path_name)
+        train_images, valid_images, train_labels, valid_labels = train_test_split(images, labels, test_size=0.3, random_state=random.randint(0, 100))
+        _, test_images, _, test_labels = train_test_split(
+            images, labels, test_size=0.5, random_state=random.randint(0, 100)
+        )
+        # 当前的维度顺序如果为'channels_first'，则输入图片数据时的顺序为：channels,rows,cols，否则:rows,cols,channels
+        # 这部分代码就是根据keras库要求的维度顺序重组训练数据集
+        if K.image_data_format() == 'channels_first':
+            train_images = train_images.reshape(
+                train_images.shape[0], img_channels, img_rows, img_cols
+            )
+            valid_images = valid_images.reshape(
+                valid_images.shape[0], img_channels, img_rows, img_cols
+            )
+            test_images = test_images.reshape(
+                test_images.shape[0], img_channels, img_rows, img_cols
+            )
+            self.input_shape = (img_channels, img_rows, img_cols)            
+        else:
+            train_images = train_images.reshape(
+                train_images.shape[0], img_rows, img_cols, img_channels
+            )
+            valid_images = valid_images.reshape(
+                valid_images.shape[0], img_rows, img_cols, img_channels
+            )
+            test_images = test_images.reshape(
+                test_images.shape[0], img_rows, img_cols, img_channels
+            )
+            self.input_shape = (img_rows, img_cols, img_channels)            
+            # 输出训练集、验证集、测试集的数量
+            print(train_images.shape[0], 'train samples')
+            print(valid_images.shape[0], 'valid samples')
+            print(test_images.shape[0], 'test samples')
+            # 我们的模型使用categorical_crossentropy作为损失函数，因此需要根据类别数量nb_classes将
+            # 类别标签进行one-hot编码使其向量化，在这里我们的类别只有两种，经过转化后标签数据变为二维
+            train_labels = np_utils.to_categorical(train_labels, nb_classes)                        
+            valid_labels = np_utils.to_categorical(valid_labels, nb_classes)            
+            test_labels = np_utils.to_categorical(test_labels, nb_classes)                        
+            # 像素数据浮点化以便归一化
+            train_images = train_images.astype('float32')            
+            valid_images = valid_images.astype('float32')
+            test_images = test_images.astype('float32')
+            # 将其归一化,图像的各像素值归一化到0~1区间
+            train_images /= 255
+            valid_images /= 255
+            test_images /= 255
+            self.train_images = train_images
+            self.valid_images = valid_images
+            self.test_images = test_images
+            self.train_labels = train_labels
+            self.valid_labels = valid_labels
+            self.test_labels = test_labels
+
+
+# CNN网络模型类
+class Model:
+    def __init__(self):
+        self.model = None
+
+    # 建立模型
+    def build_model(self, dataset, nb_classes=2):
+        # 构建一个空的网络模型，它是一个线性堆叠模型，各神经网络层会被顺序添加，专业名称为序贯模型或线性堆叠模型
+        self.model = Sequential()
+        # 以下代码将顺序添加CNN网络需要的各层，一个add就是一个网络层
+        self.model.add(Convolution2D(
+            32, 3, 3, border_mode='same', input_shape=dataset.input_shape
+        ))    # 1 2维卷积层
+        self.model.add(Activation('relu'))  # 2 激活函数层
+        self.model.add(Convolution2D(32, 3, 3))  # 3 2维卷积层
+        self.model.add(Activation('relu'))  # 4 激活函数层
+        self.model.add(MaxPooling2D(pool_size=(2, 2)))  # 5 池化层
+        self.model.add(Dropout(0.25))  # 6 Dropout层
+        self.model.add(Convolution2D(64, 3, 3, border_mode='same'))  # 7  2维卷积层
+        self.model.add(Activation('relu'))  # 8  激活函数层
+        self.model.add(Convolution2D(64, 3, 3))  # 9  2维卷积层
+        self.model.add(Activation('relu'))  # 10 激活函数层
+        self.model.add(MaxPooling2D(pool_size=(2, 2)))  # 11 池化层
+        self.model.add(Dropout(0.25))  # 12 Dropout层
+        self.model.add(Flatten())  # 13 Flatten层
+        self.model.add(Dense(512))  # 14 Dense层,又被称作全连接层
+        self.model.add(Activation('relu'))  # 15 激活函数层
+        self.model.add(Dropout(0.5))  # 16 Dropout层
+        self.model.add(Dense(nb_classes))  # 17 Dense层
+        self.model.add(Activation('softmax'))  # 18 分类层，输出最终结果
+        # 输出模型概况
+        self.model.summary()
+
+    # 训练模型
+    def train(
+        self, dataset, batch_size=20, nb_epoch=10, data_augmentation=True
+    ):
+        sgd = SGD(lr=0.01, decay=1e-6,
+                  momentum=0.9, nesterov=True)
+        # 采用SGD+momentum的优化器进行训练，首先生成一个优化器对象
+        self.model.compile(loss='categorical_crossentropy',
+                           optimizer=sgd,
+                           metrics=['accuracy'])   # 完成实际的模型配置工作
+        # 不使用数据提升，所谓的提升就是从我们提供的训练数据中利用旋转、翻转、加噪声等方法创造新的
+        # 训练数据，有意识的提升训练数据规模，增加模型训练量
+        if not data_augmentation:
+            self.model.fit(dataset.train_images,
+                           dataset.train_labels,
+                           batch_size=batch_size,
+                           nb_epoch=nb_epoch,
+                           validation_data=(
+                               dataset.valid_images, dataset.valid_labels
+                            ),
+                           shuffle=True)
+        # 使用实时数据提升
+        else:
+            # 定义数据生成器用于数据提升，其返回一个生成器对象datagen，datagen每被调用一
+            # 次其生成一组数据（顺序生成），节省内存，其实就是python的数据生成器
+            datagen = ImageDataGenerator(
+                featurewise_center=False,  # 是否使输入数据去中心化（均值为0），
+                samplewise_center=False,  # 是否使输入数据的每个样本均值为0
+                featurewise_std_normalization=False,  # 是否数据标准化（输入数据除以数据集的标准差）
+                samplewise_std_normalization=False,  # 是否将每个样本数据除以自身的标准差
+                zca_whitening=False,  # 是否对输入数据施以ZCA白化
+                rotation_range=20,  # 数据提升时图片随机转动的角度(范围为0～180)
+                width_shift_range=0.2,  # 数据提升时图片水平偏移的幅度（单位为图片宽度的占比，0~1之间的浮点数）
+                height_shift_range=0.2,  # 同上，只不过这里是垂直
+                horizontal_flip=True,  # 是否进行随机水平翻转
+                vertical_flip=False)  # 是否进行随机垂直翻转
+            # 计算整个训练样本集的数量以用于特征值归一化、ZCA白化等处理
+            datagen.fit(dataset.train_images)
+            # 利用生成器开始训练模型
+            self.model.fit_generator(datagen.flow(
+                dataset.train_images, dataset.train_labels,
+                batch_size=batch_size
+            ),
+                samples_per_epoch=dataset.train_images.shape[0],
+                nb_epoch=nb_epoch, validation_data=(
+                    dataset.valid_images, dataset.valid_labels
+                )
+            )
+    MODEL_PATH = './my.face.model.h5'
+
+    def save_model(self, file_path=MODEL_PATH):
+        self.model.save(file_path)
+
+    def load_model(self, file_path=MODEL_PATH):
+        self.model = load_model(file_path)
+
+    def evaluate(self, dataset):
+        score = self.model.evaluate(
+            dataset.test_images, dataset.test_labels, verbose=1
+        )
+        print("%s: %.2f%%" % (self.model.metrics_names[1], score[1] * 100))
+
+    # 识别人脸
+    def face_predict(self, image):
+        # 依然是根据后端系统确定维度顺序
+        if K.image_data_format() == 'channels_first' and image.shape != (
+            1, 3, IMAGE_SIZE, IMAGE_SIZE
+        ):
+            image = resize_image(image)
+            # 尺寸必须与训练集一致都应该是IMAGE_SIZE x IMAGE_SIZE
+            image = image.reshape((1, 3, IMAGE_SIZE, IMAGE_SIZE))
+            # 与模型训练不同，这次只是针对1张图片进行预测
+        elif K.image_data_format() == 'channels_last' and image.shape != (
+            1, IMAGE_SIZE, IMAGE_SIZE, 3
+        ):
+            image = resize_image(image)
+            image = image.reshape((1, IMAGE_SIZE, IMAGE_SIZE, 3))
+
+        # 浮点并归一化
+        image = image.astype('float32')
+        image /= 255
+        # 给出输入属于各个类别的概率，我们是二值类别，则该函数会给出输入图像属于0和1的概率各为多少
+        result = self.model.predict_proba(image)
+        # 给出类别预测：0或者1
+        result = self.model.predict_classes(image)
+        # 返回类别预测结果
+        return result[0]
+
+
+def faceTrainMain(myName):
+    dataset = Dataset('./faceData/')
+    dataset.load()
+    model = Model()
+    model.build_model(dataset)
+    model.train(dataset)
+    model.save_model(file_path='./faceData/' + myName + '.face.model.h5')
+    model.evaluate(dataset)
+
+
+if __name__ == '__main__':
+    dataset = Dataset('./faceData/')
+    dataset.load()
+    model = Model()
+    model.build_model(dataset)
+    # 先前添加的测试build_model()函数的代码
+    model.build_model(dataset)
+    # 测试训练函数的代码
+    model.train(dataset)
+if __name__ == '__main__':
+    dataset = Dataset('./faceData/')
+    dataset.load()
+    model = Model()
+    model.build_model(dataset)
+    model.train(dataset)
+    model.save_model(file_path='./faceData/my.face.model.h5')
+
+if __name__ == '__main__':
+    dataset = Dataset('./faceData/')
+    dataset.load()
+    # 评估模型
+    model = Model()
+    model.load_model(file_path='./faceData/my.face.model.h5')
+    model.evaluate(dataset)