基于卷积神经网络的人脸识别的实现
 
利用opencv获取人脸，采集人脸数据，将收集到的人脸数据加载到内存，搭建属于自己的卷积神经网络，并用人脸数据训练自己的网络，将训练好的网络保存成模型，最后再用opencv获取实时人脸用先前训练好的模型来识别人脸。
 
1.前言
 
随着社会的不断进步以及各方面对于快速有效的自动身份验证的迫切要求，生物特征识别技术在近几十年得到了飞速的发展。作为人的一种内在属性，并且具有很强的自身稳定性及个体差异性，生物特征成为了自动身份验证的最理想依据。当前的生物特征识别技术主要包括有：指纹识别，视网膜识别，虹膜识别，步态识别，静脉识别，人脸识别等。与其他识别方法相比，人脸识别由于具有直接，友好，方便的特点，使用者无任何心理障碍，易于为用户所接受，从而得到了广泛的研究与应用。
 
2.系统设计
 
2.1 系统开发环境
 硬件：
 CUP: INTEL CORE I7-6500U
 GPU: NVIDIA GeForce 940M
 内存：8G
 硬盘：PCIE SSD 256G
 软件：
 Python 3.5
 
2.2 系统使用工具
 集成开发环境：
 IDLE（是安装好python之后，自动安装好的一个python自带的集成开发环境）
 插件：
 opencv3.4.3、numpy1.14.6、keras2.2.4、tensorflow cpu1.11.0和sklearn0.20.0。
 这些插件的具体安装步骤，网上都可以找到具体的教程，这里便不再赘述。
 
2.3 系统功能需求
 通过电脑本地的摄像头，拍摄实时人脸照片，与训练好的卷积神经网络模型中存放的人脸信息进行比对，同时在桌面上显示识别出的人脸标签值。
 
3.关键步骤
 3.1 人脸数据的获取
 利用opencv来调用摄像头，获取实时视频流，通过opencv自带的人脸分类器haar来识别并标注出人脸区域，将当前帧保存为图片存到指定的文件夹下面。
 代码如下：
 
#catchpicture.py
import cv2  
cap = cv2.VideoCapture(0)
num = 0    
while cap.isOpened():
    ret, frame = cap.read() #读取一帧数据
    gray = cv2.cvtColor(frame,cv2.COLOR_BGR2GRAY)#将图片转化成灰度
    face_cascade = cv2.CascadeClassifier("haarcascade_frontalface_alt2.xml")
    face_cascade.load('F:\python35\haarcascade_frontalface_alt2.xml')#一定要告诉编译器文件所在的具体位置
    '''此文件是opencv的haar人脸特征分类器'''
    faces = face_cascade.detectMultiScale(gray, 1.3, 5)
    if len(faces) > 0:
        for (x,y,w,h) in faces:
         #将当前帧保存为图片
         img_name = '%s/%d.jpg'%("F:\data\me", num)                
         image = frame[y - 10: y + h + 10, x - 10: x + w + 10]
         cv2.imwrite(img_name, image)                                                     
         num += 1                
         if num > 1000:   #如果超过指定最大保存数量退出循环
           break
         cv2.rectangle(frame,(x,y),(x+w,y+h),(0,0,255),2)
         #显示当前捕捉到了多少人脸图片
         font = cv2.FONT_HERSHEY_SIMPLEX
         cv2.putText(frame,'num:%d'%(num),(x + 30,y + 30),font,1,(255,0,255),4)
    #超过指定最大保存数量结束程序
    if num > 1000 :break             
    #显示图像并等待10毫秒按键输入，输入‘q’退出程序
    cv2.imshow("capture", frame)
    if cv2.waitKey(10) & 0xFF == ord('q'):
      break   
    #释放摄像头并销毁所有窗口
cap.release()
cv2.destroyAllWindows() 

 
3.2 图片预处理
 第一步获取到的人脸图片集中的每一张图片大小都不一样，为了后续操作的方便需要将，捕获到的人脸照片压缩为像素值为6464的并灰度化处理。所以图片预处理一共分为两部先是压缩成比例6464的，第一一步定义了一个resize_image()函数作用是先将图片补成正方形之后压缩成像素值为64*64，第二步利用opencv自带的cvtColor()函数将图片灰度化。
 代码如下：
 
#picturepraction.py
import os
import cv2
IMAGE_SIZE = 64
def resize_image(image, height=IMAGE_SIZE, width=IMAGE_SIZE):
    top, bottom, left, right = (0, 0, 0, 0)
    h, w, _ = image.shape
    longest_edge = max(h, w)
    if h < longest_edge:
        dh = longest_edge - h
        top = dh // 2
        bottom = dh - top
    elif w < longest_edge:
        dw = longest_edge - w
        left = dw // 2
        righ = dw - left
    else:
        pass
    BLACK = [0, 0, 0]
    constant = cv2.copyMakeBorder(image, top, bottom, left, right, cv2.BORDER_CONSTANT, value=BLACK)
    return cv2.resize(constant, (height, width))
if __name__ == '__main__':
    path_name = "F:\data\me"
    i = 0
    for dir_item in os.listdir(path_name):
        full_path = os.path.abspath(os.path.join(path_name, dir_item))
        i += 1
        image = cv2.imread(full_path)       #读取出照片
        image = resize_image(image)         #将图片大小转为64*64
        image = cv2.cvtColor(image, cv2.COLOR_RGB2GRAY)     #将图片转为灰度图
        cv2.imwrite(full_path,image)
 
3.3 图片加载到内存
 将图片预处理之后的图片集，以多维数组的形式，加载到内存，并且要为每一类样本数据标注标签值。
 代码如下：
 
#loaddata.py
import os
import sys
import numpy as np
import cv2
#读取图片数据并与标签绑定
def read_path(images, labels, path_name, label):
    for dir_item in os.listdir(path_name):

        full_path = os.path.abspath(os.path.join(path_name, dir_item))
        image = cv2.imread(full_path)
        images.append(image)
        labels.append(label)
def loaddata(parent_dir):
    images = []
    labels = []
    read_path(images, labels, parent_dir+"me", 0)
    read_path(images, labels, parent_dir+"chen", 1)
    read_path(images, labels, parent_dir+"jia", 2)
    read_path(images, labels, parent_dir+"other", 3)
    images = np.array(images)
    labels = np.array(labels)
    return images,labels
if __name__ == '__main__':
        images, labels = loaddata("F:/example/")
 
3.4 搭建卷积神经网络
 搭建卷积神经网络前，需要先完成六个步骤：第一步需要先把数据加载到内存即将图片预处理之后的图片集，以多维数组的形式，加载到内存，并且要为每一类样本数据标注标签值；第二步划分数据集即按照交叉验证的原则划分数据集、验证集、训练集。交叉验证是机器学习中的一种常用来精度测试的方法，要先拿出大部分数据用来模型训练，少部分数据用来模型验证，验证结果与真实值计算出差平方和，以上工作重复进行，直至差平方和为0，模型训练完毕，可以交付使用。而在我自己的模型中，导入了sklearn库的交叉验证模块，利用函数train_test_split()函数来划分训练集、验证集和测试集。train_test_split()函数中的test_size参数用来指定划分的比例，另一个参数random_state是用来指定一个随机数种子，从全部数据中随机选取数据建立自己的数据集、验证集和训练集；第三步要改变图片的维度即我们小组用到了keras库，这个库是建立在tensorflow或者theano基础上的，所以keras库的后端系统可以是tensorflow也可以是theano。但是tensorflow和theano定义的图像数据输入到CNN网络的维度顺序是不一样的，tensorflow的维度顺序为行数(rows)、列数(cols)、通道数(颜色通道，channels)；theano则是通道数、行数、列数。所以需要调用函数image_dim_ordering()来确定后端系统的类型（我们用‘th’来代表theano用‘tf’来代表tensorflow），最后用numpy库提供的reshape()函数来调整维度；第四步采用one-hot编码即因为我的卷积神经网络采用了categorical_crossentropy作为我们的损失函数，而这个函数要求标签集必须采用one-hot编码。所谓的one-hot编码，我理解就是状态位编码，one-hot采用状态寄存器编码，每一个状态值对应一个寄存器，且任意时刻，只有一位是有效的。假设，我们类别有两种分别为0和1,0代表我，1代表others，如果标签为0，编码为[1 0]表示的是第一位有效，如果标签为1，编码为[0 1]表示的是第二位有效。这样做的原因是为了方便CNN操作；第五步归一化图像数据即数据集先让它浮点化之后又归一化的目的是提升网络收敛速度，减少模型的训练实践，同时适应值域在（0,1）之间的激活函数，增大区分度。归一化有一个特别重要的原因是确保特征值权重一致；第六步确定优化器即最开始使用的是SGD优化器，SGD优化器随机梯度下降算法参数更新针对每一个样本集x(i) 和y(i) 。批量梯度下降算法在大数据量时会产生大量的冗余计算，比如：每次针对相似样本都会重新计算。这种情况时，SGD算法每次则只更新一次。因此SGD算法通过更快，并且适合online。但是SGD以高方差进行快速更新，这会导致目标函数出现严重抖动的情况。一方面，正是因为计算的抖动可以让梯度计算跳出局部最优，最终到达一个更好的最优点；另一方面，SGD算法也会因此产生过调。之后改进使用了Adam，Adam算法是另一种自适应参数更新算法。和Adadelta、RMSProp算法一样，对历史平方梯度v(t)乘上一个衰减因子，adam算法还存储了一个历史梯度m(t)。mt和vt分别是梯度一阶矩（均值）和二阶矩（方差）。当mt和vt初始化为0向量时，adam的作者发现他们都偏向于0，尤其是在初始化的时候和衰减率很小的时候（例如，beta1和beta2趋近于1时）。通过计算偏差校正的一阶矩和二阶矩估计来抵消偏差。
 之后我构建了一个卷积神经网络，这个卷积神经网络一共16层：3层卷积层、2层池化层、3层Dropout层、1层flatten层、2层全连接层和1层分类层。结构如下图：
 代码如下：
 
#face_CNN_keras.py
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
#ADAM优化器
from keras.optimizers import Adam

from loaddata import loaddata
from picturepraction import resize_image, IMAGE_SIZE

class Dataset:
    def __int__(self):

        # 训练数据
        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.input_shape = None

    # 加载数据并预处理
    def load(self, img_rows=IMAGE_SIZE, img_cols=IMAGE_SIZE, img_channels=3, nb_classes=4):
        images, labels = loaddata("F:/example/")

        # 随机划分训练集、验证集(利用交叉验证原则)
        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))

        # 判断后端系统类型来调整数组维度
        if (K.image_dim_ordering() == 'th'):#如果后端系统是theano，维度顺序为通道数、行、列
            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:                              #如果后端系统是tensorflow，维度顺序为行、列、通道数
            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作为损失函数
        #因此需要根据图像集数量将图像集标签进行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')
        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




class Model:
    def __init__(self):
        self.model = None

    def build_model(self, dataset, nb_classes=4):
        self.model = Sequential()

        #第一层卷积
        #保留边界像素
        self.model.add(Convolution2D(32, 3, 3, border_mode='same', input_shape=dataset.input_shape, activation='relu'))#卷积层和激活函数
        ##输出(32, 64, 64)

        self.model.add(MaxPooling2D(pool_size=(2, 2)))                                                       #池化层
        #输出(32, 32, 32)

        self.model.add(Dropout(0.5))

        #第二层卷积
        #保留边界像素
        self.model.add(Convolution2D(32, 3, 3, border_mode='same', activation='relu'))#卷积层和激活函数
        ##输出(32, 32, 32)

      
        self.model.add(Dropout(0.5))

        
        #第三层卷积
        self.model.add(Convolution2D(64, 3, 3, border_mode='same', activation='relu'))
        #输出(64, 32, 32)

        self.model.add(MaxPooling2D(pool_size=(2, 2)))
        #输出(64, 16, 16)

        self.model.add(Dropout(0.5))

        self.model.add(Flatten())   #数据从二维转为一维
        #输出64*16*16 =  16384

        #二层全连接神经网络 512*人的个数
        self.model.add(Dense(512))
        self.model.add(Activation('relu'))
        self.model.add(Dropout(0.5))
        self.model.add(Dense(nb_classes))

        self.model.add(Activation('softmax'))
        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)
        
        #self.model.compile(loss='categorical_crossentropy', optimizer=sgd, metrics=['accuracy'])
        #Adam优化器
        adam = Adam(lr=0.001,beta_1=0.9,beta_2=0.999,epsilon=1e-8)
        self.model.compile(loss='categorical_crossentropy',optimizer=adam,metrics=['accuracy'])
        
        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)

    MODEL_PATH = 'F:/example/number3.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_dim_ordering() == 'th' and image.shape != (1, 3, IMAGE_SIZE, IMAGE_SIZE):
            image = resize_image(image)
            image = image.reshape((1, 3, IMAGE_SIZE, IMAGE_SIZE))
        elif K.image_dim_ordering() == 'tf' 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

        result = self.model.predict_proba(image)

        result = self.model.predict_classes(image)

        return result[0]

if __name__ == '__main__':
    dataset = Dataset()
    dataset.load()
    model = Model()
    model.build_model(dataset)
    model.train(dataset)
    model.save_model(file_path="F:/example/number3.h5")
 
3.5 识别人脸
 利用opencv获取实时人脸数据，调用训练好的卷积神经网络模型，来识别人脸。
 代码如下：
 
#faceclassify.py
import cv2
import sys
import gc
from face_CNN_keras import Model
import tensorflow as tf
if __name__ == '__main__':
    model = Model()#加载模型
    model.load_model(file_path = 'F:/example/number1.h5')             
    color = (0, 255, 255)#框住人脸的矩形边框颜色 
    cap = cv2.VideoCapture(0)#捕获指定摄像头的实时视频流
    cascade_path = "F:\python35\haarcascade_frontalface_alt2.xml"#人脸识别分类器本地存储路径    
    #循环检测识别人脸
    while cap.isOpened():
        ret, frame = cap.read()   #读取一帧视频
        gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)#图像灰化，降低计算复杂度
        cascade = cv2.CascadeClassifier(cascade_path)#使用人脸识别分类器，读入分类器                
        faceRects = cascade.detectMultiScale(gray, scaleFactor = 1.2, minNeighbors = 3, minSize = (16, 16))#利用分类器识别出哪个区域为人脸        
        if len(faceRects) > 0:                 
            for faceRect in faceRects: 
                x, y, w, h = faceRect
                #截取脸部图像提交给模型识别这是谁
                image = frame[y - 10: y + h + 10, x - 10: x + w + 10]
                cv2.rectangle(frame, (x - 10, y - 10), (x + w + 10, y + h + 10), color, thickness = 2)
                faceID = model.face_predict(image)   
                #如果是“我”
                if faceID == 0:                                                        
                    cv2.putText(frame, "zhuang", (x+30, y+30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 255), 2)#在显示界面输出
                    print("zhuang")#在控制台输出
                elif faceID == 1:
                    cv2.putText(frame, "chen", (x+30, y+30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 255), 2)#在显示界面输出
                    print("chen")#在控制台输出
                elif faceID == 2:
                    cv2.putText(frame, "jia", (x+30, y+30), cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 255), 2)#在显示界面输出
                    print("jia")#在控制台输出
                else:
                    cv2.putText(frame, "unknown",(x+30, y+30),cv2.FONT_HERSHEY_SIMPLEX, 1, (255, 0, 255), 2)#在显示界面输出
                    print("unknown")#在控制台输出                           
        cv2.imshow("classify me", frame)
        k = cv2.waitKey(10)#等待10毫秒看是否有按键输入
        if k & 0xFF == ord('q'):#按q退出
            break
    #释放摄像头并销毁所有窗口
    cap.release()
    cv2.destroyAllWindows()
 
完成上述步骤就可以实现对人脸的识别，完整代码见如下链接：
 https://download.csdn.net/download/weixin_43545546/10867729

关注微信公众号：嵌入式基地
 后台回复：车牌识别 获取资料
 获取更多资源，请关注微信公众号：嵌入式基地
 
 
视频演示地址
 
系统介绍
 
   使用STM32F103RCT6作为主控，摄像头使用OV7670（带FIFO）。STM32进行了16倍频。识别过程分别为：图像采集，二值化，识别车牌区域，字符分割，字符匹配。
 
识别过程分析
 
1.图像采集：
 
   通过OV7670摄像头进行图像采集，采集的图像大小为320*240像素，像素格式为RGB565。每个像素由两字节组成，第一字节的高五位是Red，第一字节的低三位和第二字节的高三位组成Green，第二字节的低五位是Blue。
 
2.二值化：
 
   二值化就是让图像的像素点矩阵中的每个像素点的灰度值为0（黑色）或者255（白色），让整个图片呈现出只有黑色和白色的效果。二值化后的图像中灰度值范围是0或者255。
    怎样让像素点的灰度值转为0或者255？假如灰度值为220的一个像素点，二值化后应该为0还是255？这时候需要设定一个阈值来对像素点进行设置。
    常用二值化方法：
    1、取中值
       设置阈值为127，灰度值小于127的为0，大于127的为255。这样设置计算量小，计算快。缺点也严重：在不同的图像中，颜色分布差别大，处理效果也不会很好。
    程序开始之前设置R,G，B的阈值，通过阈值判断将像素设置为全黑（0x0000）或者全白（0xFFFF）.同时根据色彩的变化记录每一行的颜色跳变点，由此识别出车牌区域。
    2、取平均值
       像素点平均值 = （像素点1灰度值 + 像素点2灰度值 + …… + 像素点n灰度值） / n
    3、双峰法
       此方法适用于具有明显双峰直方图的图像，不适合直方图中双峰差别很大或双峰间的谷比较宽广而平坦的图像。该方法认为图像由前景和背景组成，在灰度直方图上，前景和背景会形成高峰，在双峰之间的最低谷处就是阈值。
 
3.识别车牌区域：
 
   根据上一步的二值化，由于车牌区域跳变点多，由此可以得出车牌区域。分别记录车牌区域的上下高度。然后通过RGB-HSV颜色转换，识别出车牌区域的左右边界。
 
4.字符分割：
 
   我国常见车牌以及排列顺序大部分都是按照如下设计的：汉字、英文字母、点、英文字母、阿拉伯数字、阿拉伯数字、阿拉伯数字、阿拉伯数字。基于这个规律，以及图像采集高度一致，设计了如下的分割方法：
    1、在内存中开辟七个长为车牌长的七分之一和宽为车牌宽的区域
    2、从车牌图像长边的巾问向下开始扫描车牌图像，并把扫描到的所有的点灰度值复制到0区域的第四个区域对应位置上。然后再从上向下扫描刚扫描过这一努的左边或右边，直到所扫描的这一峰上的所有点的灰度都是0时为止,并把这一竖认为是字符的分离处。
    3、切割第五到第七个字符。方法就是，切割完了第四个字符之后，再依次扫描剩下的空间，直到所扫描的这一竖上的所有点的灰度值不全为0时，认为是字符的开始并依次扫描直到所扫描的这一竖上的所有点的灰度值全为0时认为是字符的结束。
    4、切割第三到第四个字符。这两个字符的切割方式与第五到第七个字符一样。
    5、切割第一到第二个字符。当第三个字符切割完之后，我们将遇到一个点，我们也把它看作一个字符，只不过这个点扫描之后就不要了。扫描完这个点之后，我们来切割第二个字符，它的切割方式与前面一样。切割完了第二个字符之后，再向左扫描，直到所扫描的这一竖上的所有点的灰度值不全为0时，认为是字符的开始，并依次扫描直到所扫描所有剩下的，并填到相应的位置，直到剩下的空间填满。经过粗分割后，可以得到一些单个字符区域和多余的空间。下一步我们将把这些多余的空间去掉。这将更有利于下一步字符的识别。
    去除图像上多余空间：
    车牌上的字符经过了粗切割所得到的是一些单的字符，但在分配空间时是按照车牌的宽和长的七分之一来分配的；所以这个空间可能大于字符应该占的空问。所以，要将多余空间去除。对于第一个字符从第一行开始向下扫描，把那些一行中所有的点的灰度值全为0的点去掉，直到扫描到有一行不全为0时为止。然后再从第一列开始向右扫描把那些一列中所有的点的灰度值全为0的点去掉，直到扫描到有一列不全为0时为止。接下来从最后一行开始向上扫描，把那些一行中所有的点的灰度值全为0的点去掉，直到扫描到有一行不全为0时为止。最后从最后一列开始向左扫描把那些一列中所有的点的灰度值全为0的点去掉，直到扫描到有一列不全为0时为止。重复上面的步骤完成剩下字符的切割
    根据二值化的结果，以及记录的跳变点位置，对字符进行分割，同时记录字符的左右边界。
 
5.字符匹配：
 
   对分割出来的字符进行归一化处理，这里用到图片的扩大算法，扩大之后逐一的去进行字符匹配。字符模板事前通过字模软件转换成二进制数据保存在数组中。最后根据匹配结果相似度最大的做为输出结果。
    归一化图像就是要把原来各不相同的字符统一到同一尺寸。因为扫描进来的图像中字符大小存在较大的差异，而相对来说，统一尺寸的字符识别的标准性更强，准确率自然也更高。具体算法如下：先得到原来字符的高度和宽度，与系统已存字模的数据作比较，得出要变换的系数，然后根据得到的系数按照插值的方法映射到原图像中。
 
实物图
 

 
更多优秀费开源软件推荐，可前往github：
 
https://github.com/MemorialCheng/shareware
 


 
目录
 
一、eDiary记笔记软件
1.1 下载方式
1.2 软件展示
  
二、OCR截图识别文字软件
2.1 下载方式
2.2 软件展示
 

 
一、eDiary记笔记软件
 
eDiary是一款Windows记笔记软件，绿色免费、简约大方、无需安装、占用内存仅需5M左右，非常实用，不带一点花里胡哨。
 
1.1 下载方式
 
方式一：推荐 首页GitHub直接获取，同时还有更多福利软件分享。
 
https://github.com/MemorialCheng/shareware
 
方式二：eDiary官网入口
 
方式三：若官网不好下载可百度网盘下：链接：https://pan.baidu.com/s/1QpW7Fau4XBFgFPedcYZj9g
 提取码：u4ho
 
1.2 软件展示
 
（一）按日期来记流水账
 
 （二）按文档分类来记笔记
 
 还可以按日历来记录备忘录，还有很多实用功能，感觉去体验吧。
 
二、OCR截图识别文字软件
 
无论你是学生党、工作党，都是需要阅读文献、获取一些不能复制的文字内容。网上也有很多OCR软件，但很多都是收费的。
 
以下是我收集到的免费的OCR软件，无需安装，当然有经济条件的还是应该支持一下正版，毕竟开发不易。
 
2.1 下载方式
 
方式一：首页Github中获取
 
https://github.com/MemorialCheng/shareware
 
方式二：百度网盘下载
 链接：https://pan.baidu.com/s/1w4lKeuD5Rfwz8it3JP8fig
 提取码：65k8
 
2.2 软件展示
 
 
如文章对您有帮助，感谢您的点赞+关注(^ _ ^)

又到了金九银十跳槽求职旺季。准备好一场面试不仅需要在简历上多下功夫，还需要为面试问答做好充足的准备，简历书写请参考：https://blog.csdn.net/leboxy/article/details/100658701。
 
以下是“大佬”本人从乐搏学院VIP学员面试经验中收集的，然后分门别类整理了这套面试题，很具备参考性，毕竟都是企业真实面试题目。
 接下来，针对以下知识类型列出具体的面试点(其中包括笔试题和问答题)，大家看完后一定要查缺补漏，找到欠缺的知识点，然后抓紧时间复习、参加面试，如果时间紧张，来找我, 我来帮你解决~~你也可以添加软件测试交流群+Q群952573395
 
 
 
软件测试理论基础
 软件测试工具篇
 性能测试篇
 自动化篇
 数据库篇
 Linux操作系统篇
 综合题(思维，综合知识体系)
 
 
一、软件测试理论基础**
 
1. 软件测试策略有哪些？**
 
答案：黑盒测试、白盒测试、灰盒测试
 
拓展：很多童鞋分不清软件的测试策略、测试类型、测试方法等这类问题，在这里详细回答下。毕竟这些都是理论知识高概率面试题目。需要思维导图原图的可以去qun文件下载：636859964，暗号“CSDN”，或者在我文末网盘连接中下载。
 
 2. 什么是静态测试、动态测试、黑盒测试、白盒测试、α测试 β测试
 
静态测试是不运行程序本身而寻找程序代码中可能存在的错误或评估程序代码的过程。
 动态测试是实际运行被测程序，输入相应的测试实例，检查运行结果与预期结果的差异，判定执行结果是否符合要求，从而检验程序的正确性、可靠性和有效性，并分析系统运行效率和健壮性等性能。
 黑盒测试一般用来确认软件功能的正确性和可操作性,目的是检测软件的各个功能是否能得以实现,把被测试的程序当作一个黑盒,不考虑其内部结构,在知道该程序的输入和输出之间的关系或程序功能的情况下,依靠软件规格说明书来确定测试用例和推断测试结果的正确性。
 白盒测试根据软件内部的逻辑结构分析来进行测试,是基于代码的测试，测试人员通过阅读程序代码或者通过使用开发工具中的单步调试来判断软件的质量，一般黑盒测试由项目经理在程序员开发中来实现。
 α测试是由一个用户在开发环境下进行的测试，也可以是公司内部的用户在模拟实际操作环境下进行的受控测试，Alpha测试不能由程序员或测试员完成。
 β测试是软件的多个用户在一个或多个用户的实际使用环境下进行的测试。开发者通常不在测试现场，Beta测试不能由程序员或测试员完成。
 
3. 按开发阶段划分，软件测试划分为哪几个阶段？
 
答案：按开发阶段划分，软件测试划分为单元测试、集成测试、确认测试、系统测试、验收测试。
 拓展：
 
 4. 一条软件缺陷（或者叫Bug）记录都包含了哪些内容？
 
答案：
 
 
 
bug编号；
 bug严重级别，优先级；
 bug产生的模块；
 bug摘要，阐述bug大体的内容；
 bug对应的版本；
 bug详细现象描述、测试场景，包括一些截图等；
 bug出现时的测试环境，产生的条件即对应操作步骤；
 
 
5. 简述BUG管理工具的工作过程。
 
 6. 试着画软件测试模型W、V、H模型。
 
 
 
 7. 接口请求的时候，有哪几种方法？
 
 8. 什么是回归测试?
 
答案：回归测试: (regression testing): 回归测试有两类：用例回归和错误回归；用例回归是过一段时间以后再回头对以前使用过的用例在重新进行测试，看看会重新发现问题。错误回归，就是在新版本中，对以前版本中出现并修复的缺陷进行再次验证，并以缺陷为核心，对相关修改的部分进行测试的方法。
 
9. 完整的测试流程应该由哪些阶段组成？需要原思维导图的可以加qun: 952573395
 
 二、性能测试篇
 
1. Loadrunner分哪三个部分？
 
 
 
Virtual User Generator：用于录制脚步
 Mercury LoadRunnerController：用于创建、运行和监控场景
 Mercury LoadRunner Analysis：用于分析测试结果
 
 
2. QTP中的Action有哪些，分别作用是什么？
 
 
 
可复用Action
 不可复用Action
 外部Action
 
 
3. Jmeter架包如何引用？
 
方法一：测试计划 通过 Add directory or jar to classpath 浏览导入jar
 方法二：直接将需要引用的jar包放置到JMeter的lib目录，或者ext目录下
 方法三：设置插件依赖路径，此时需要在jmeter.properties中添加依赖的路径，在jmeter 下新建对应的文件夹，将需要的jar包放入即可
 4. 概述一下性能测试流程？
 
l 分析性能需求。挑选用户使用最频繁的场景来测试。确定性能指标，比如：事务通过率为100%，TOP99%是5秒，最大并发用户为1000人，CPU和内存的使用率在70%以下
 l 制定性能测试计划，明确测试时间(通常在功能稳定后，如第一轮测试后进行)和测试环境和测试工具
 l 编写测试用例
 l 搭建测试环境，准备好测试数据
 l 编写性能测试脚本
 l 性能测试脚本调优。设置检查点、参数化、关联、集合点、事务，调整思考时间，删除冗余脚本
 l 设计测试场景，运行测试脚本，监控服务器
 l 分析测试结果，收集相关的日志提单给开发
 l 回归性能测试
 l 编写测试报告
 
5. 性能测试中，有哪些关键指标，分别指的是什么？
 
 资源指标：
 
CPU使用率：指用户进程与系统进程消耗的CPU时间百分比，长时间情况下，一般可接受上限不超过85%。
 内存利用率：内存利用率=（1-空闲内存/总内存大小）*100%，一般至少有10%可用内存，内存使用率可接受上限为85%。
 磁盘I/O: 磁盘主要用于存取数据，因此当说到IO操作的时候，就会存在两种相对应的操作：存数据的时候对应的是写IO操作，取数据的时候对应的是是读IO操作，一般使用% Disk Time（磁盘用于读写操作所占用的时间百分比）度量磁盘读写性能。
 网络带宽：一般使用计数器Bytes Total/sec来度量，Bytes Total/sec表示为发送和接收字节的速率，包括帧字符在内。判断网络连接速度是否是瓶颈，可以用该计数器的值和目前网络的带宽比较。
 
系统指标：
 
并发用户数：某一物理时刻同时向系统提交请求的用户数。
 在线用户数：某段时间内访问系统的用户数，这些用户并不一定同时向系统提交请求。
 平均响应时间：系统处理事务的响应时间的平均值。事务的响应时间是从客户端提交访问请求到客户端接收到服务器响应所消耗的时间。对于系统快速响应类页面，一般响应时间为3秒左右。
 事务成功率：性能测试中，定义事务用于度量一个或者多个业务流程的性能指标。单位时间内系统可以成功完成多少个定义的事务，在一定程度上反应了系统的处理能力，一般以事务成功率来度量。
 超时错误率：主要指事务由于超时或系统内部其它错误导致失败占总事务的比率。
 
6. 什么情况下要做关联，关联是怎么做的？
 
当脚本的上下文有联系，就用关联。比如登录的token关联，增删改查主键id关联等。
 
7. 有验证码的功能，怎么做性能测试？
 
l 将验证码暂时屏蔽，完成性能测试后，再恢复
 l 使用万能的验证码
 l 使用代码脚本解析(不推荐)
 
8. 如何脚本增强？
 
l 做参数化
 l 做关联
 l 添加事务
 l 添加断言
 l 添加集合点
 l 添加思考时间
 
9. 你们系统哪些地方(哪些功能)做了性能测试？
 
选用了用户使用最频繁的功能来做测试，比如：登陆，搜索，提交订单等。
 
10. 怎么分析性能测试结果？
 
首先查看事物通过率，然后分析其他性能指标，比如，确认响应时间，事务通过率，CPU等指标是否满足需求；如果测试结果不可信，要分析异常的原因，修改后重新测试。
 
在确定性能测试结果可信后，如果发现以下问题，按下面的思路来定位问题.
 
三、自动化篇
 
1. Python序列中的元组、列表、字典有什么区别？
 
列表：列表是可变的，即可修改其内容。另外，列表有很多特有的方法。
 元组：不可修改的序列，包括字符串，创建方法也很简单，用逗号隔开或小括号即可创建一个元组。
 字典：字典可通过名称来访问其各个值的数据结构，这种数据结构称为映射，字典是python中唯一的内置映射类型，其中的值不按顺序排列，而是存储在键下，键可能是数字、字符串或元组。
 
2. 自动化测试模型？
 
 3. 什么是持续集成？
 
持续集成源于极限编程(XP)，是一种软件实践，软件开发过程中集成步骤是一个漫长并且无法预测的过程。集成过程中可能会爆发大量的问题，因此集成过程需要尽可能小而多，实际上持续集成讲的是不断的去做软件的集成工作。持续集成，最简单的形式是包括一个监控版本控制（SVN等等）变化的工具。当变化被发觉时，这个工具可以自动的编译并测试你的应用。
 
4. 你的自动化用例的执行策略是什么？
 
自动化测试用例的执行策略是要看自动化测试的目的，通常有如下几种策略：
 
(1) 自动化测试用例是用来监控的，在此目的下，我们就把自动化测试用例设置成定时执行的，如果每五分钟或是一个小时执行一次，在jenkins上创建一个定时任务即可。
 
(2) 必须回归的用例。有些儿测试用例，如BVT测试用例，我们在公司产品任何变动上线之前都需要回归执行。那我们就把测试用例设置成触发式执行，在jenkins上将我们的自动化测试任务绑定到开发的build任务上。当开发人员在仿真环境上部代码的时候，我们的自动化测试用例就会被触发执行。
 
(3) 不需要经常执行的测试用例。像全量测试用例，我们没有必要一直回归执行，毕竟还是有时间消耗的，有些非主要业务线也不需要时时回归。这类测试用例我们就采用人工执行，在jenkins创建一个任务，需要执行的时候人工去构建即可。
 
5. 自动化测试最大的缺陷是什么？
 (1) 一旦项目发生变化，测试用例就需要改进，工作量大。
 
(2) 验证的范围有限，操作更加复杂，比如说简单的一个验证验证码，如果是人工识别很快就可以输入，但是自动化测试中会增添很多困难。那么这个时候速度也不如人工。
 
(3) 不稳定。
 
(4) 可靠性不强。
 
(5) 成本与收益。
 
6. 自动化测试的时候是不是需要连接数据库做数据校验？
 
(1) UI自动化不需要
 
(2) 接口测试会需要
 
7. 公司内一直在使用的测试系统（B/S架构）突然不能访问了，需要你进行排查并恢复，说出你的检查方法？
 
(1) 测试FTP是否正常可以登录，不能登录的直接问空间商那是空间商的问题直接联系他们。
 
(2) 空间赠送的三级域名是否能够访问网站打开网站（空间都赠送三级域名），如果也不能访问应该是空间问题。
 
(3) 在电脑的开始菜单运行中输入cmd，在弹出的黑框中输入：ping 你的域名；然后回车，如果看不到IP或IP地址与你的主机地址不符，则说明域名解析有误,是域名的问题得重新解析域名。
 
8. 什么是分层测试？
 
行业里面提的一般是金字塔的分层模型，UI测试；集成/接口测试；单元测试。
 
四、数据库篇
 
1. 数据库中的增删改查分别使用什么关键字？
 
Select update delete insert
 
2. MySQL中查询的2到5行怎么查询?
 
Select * from table where 字段 limit 2,3;
 
3. 数据库的聚合函数有哪些？
 
Avg()平均值，count()求个数，sum()求和，
 
4. 多表关联笔试题，内容过多，大家自行网盘下载。或者去群文件下载：554058482
 
链接：https://pan.baidu.com/s/19BxOW5D4mEK46OaJ6HAvFQ
 提取码：3zt9
 
 六、Linux操作系统篇
 
1. Linux常用的命令有哪些？请说出5~10个
 
ls、cd、ll、mkidr、touch、cat、tar、vi、find、awk、grep、ps
 
2. 如何修改Linux时间？如果需要将时间改为2015-01-01，如何修改，请写出命令？
 
date -s
 
3. 在/var目录下会定义系统的启动日志相关信息，请查找对应的boot.log文件，并把它备份一份到/var/log下命名为testroad-boot.log.
 
dump
 
4. 在当前路径下，日志文件为log.log,如何实时查看日志文件打印的内容？请写出命令。
 
tail -10 filename
 
5. 系统/etc/sysctl.conf文件会定义系统内核的一些配置，查找和net有关的信息，并值打印前面5行信息。
 
grep ‘net’ file | sed ‘1,5p’
 
cat /etc/sysctl.conf | grep ‘net’|head -5
 
6. Shell脚本网盘
 
链接：https://pan.baidu.com/s/1k4ydELFQf7VpezsA_aoj9Q
 
提取码：bzhq
 
七、综合题(思维，综合知识体系)
 
1. 测试中发现一个Bug, 但是开发经理认为这不是一个bug，你应该怎么解决？
 
先将问题提交到缺陷管理库里面进行备案。然后获取判断的依据和标准：
 
l 根据需求说明书、产品说明、设计文档等，确认实际结果是否与计划有不一致的地方，提供缺陷是否确认的直接依据；
 l 如果没有文档依据，可以根据类似软件的一般特性来说明是否存在不一致的地方，来确认是否是缺陷；
 l 根据用户的一般使用习惯，来确认是否是缺陷；
 l 与设计人员、开发人员和客户代表等相关人员探讨，确认是否是缺陷；
 合理的论述，向测试经理说明自己的判断的理由，注意客观、严谨，不参杂个人情绪。等待测试经理做出最终决定，如果仍然存在争议，可以通过公司政策所提供的渠道，向上级反映，并有上级做出决定。
 
2. 给你一个电商网站，你如何测试？
 
 3. 如何测试一个纸杯？
 
答案：万变不离其踪，不管是一个水杯，一把椅子，一个电梯，测试的要点都可以基于以下要素。
 
l 功能度：用水杯装水看漏不漏；水能不能被喝到
 l 安全性：杯子有没有毒或细菌
 l 可靠性：杯子从不同高度落下的损坏程度
 l 可移植性：杯子在不同的地方、温度等环境下是否都可以正常使用
 l 兼容性：杯子是否能够容纳果汁、白水、酒精、汽油等
 l 易用性：杯子是否烫手、是否有防滑措施、是否方便饮用
 l 用户文档：使用手册是否对杯子的用法、限制、使用条件等有详细描述
 l 疲劳测试：将杯子盛上水（案例一）放24小时检查泄漏时间和情况；盛上汽油（案例二）放24小时检查泄漏时间和情况等
 l 压力测试：用根针并在针上面不断加重量，看压强多大时会穿透
 
今天先分享到这里，更多软件测试面试资料 + Q群：952573395， 暗号 “CSDN”