win10 x64搭建tensorflow-gpu开发环境

最新推荐文章于 2023-04-25 10:19:35 发布

外码斯迪

最新推荐文章于 2023-04-25 10:19:35 发布

阅读量466

点赞数 1

分类专栏： AI 文章标签：机器学习

本文链接：https://blog.csdn.net/zj850324/article/details/109902149

版权

AI 专栏收录该内容

25 篇文章 1 订阅

订阅专栏

我的显卡是两块丽台 RTX 4000，

准备软件资源如下：

pycharm-professional-2020.2.2
Anaconda3-5.3.1-Windows-x86_64
CUDA 10.1.243
cudnn 10.1
tensorflow-gpu 2.3.0

步骤：

1，安装Anaconda，建库，配Windows环境变量；

2，安装Pycharm 安装社区版或企业版，删除探测文件可无限使用
文件地址：C:\Users\jerry\AppData\Roaming\JetBrains\PyCharm2020.2\eval

3，配置pycharm的所需的tensorflow的环境
pycharm->file->settings->Project XXX ->Python Interpreter->Python Interpreter Add
选择anaconda创建的，如：C:\Users\jerry\AppData\Local\conda\conda\envs\py37\python.exe

4，安装cmake（有些python模块是编译安装的，需要cmake）

5，安装VS 2019 社区版，仅勾选C++基础库即可（有些python模块是编译安装的，需要C++编译器）

4，安装CUDA 10.1,在线安装（已有VS的话去掉VS选项）

5，下载cudnn 8.0.3.33，CUDA安装完成后解压到CUDA根目录

6，pip或conda安装tensorflow-gpu 2.3.0

7，pip或conda安装dlib（人脸识别库，可以不装）

8，pip或conda安装face_recognition（人脸识别库，可以不装）

试验：

案例1，猫狗大战（准备数据、先训练，再载入模型预测）

# -*- coding:utf-8 -*-
# @Time : 2020/10/11 15:41
# @Author: jerry
# @File : image_classification.py
import tensorflow as tf
import numpy as np
import pandas as pd
from keras.preprocessing.image import ImageDataGenerator, load_img
from sklearn.model_selection import train_test_split
from keras.models import Sequential
from keras.layers import Conv2D, MaxPooling2D, Dropout, Flatten, Dense, Activation, BatchNormalization
from matplotlib import pyplot as plt
from tensorflow.python.keras.callbacks import EarlyStopping, ReduceLROnPlateau
import os

def train_model_ex(train_input_dir,IMAGE_WIDTH,IMAGE_HEIGHT,IMAGE_CHANNELS,batch_size,saved_model_path,FAST_RUN = False):
    df,train_df, validate_df,total_train,total_validate = prepare_data_ex(train_input_dir,IMAGE_WIDTH, IMAGE_HEIGHT,batch_size)
    train_datagen, train_generator = traning_generator_ex(train_df, train_input_dir, IMAGE_WIDTH, IMAGE_HEIGHT,batch_size)
    validation_datagen, validation_generator = validation_generator_ex(validate_df,train_input_dir,IMAGE_WIDTH,IMAGE_HEIGHT,batch_size)

    model = build_model(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS)

    earlystop = EarlyStopping(patience=10)
    learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy',
                                                patience=2,
                                                verbose=1,
                                                factor=0.5,
                                                min_lr=0.00001)
    callbacks = [earlystop, learning_rate_reduction]

    # See how our generator work
    example_df = train_df.sample(n=1).reset_index(drop=True)
    example_generator = train_datagen.flow_from_dataframe(
        example_df,
        train_input_dir,
        x_col='filename',
        y_col='category',
        target_size=(IMAGE_WIDTH, IMAGE_HEIGHT),
        class_mode='categorical'
    )
    plt.figure(figsize=(12, 12))
    for i in range(0, 15):
        plt.subplot(5, 3, i + 1)
        for X_batch, Y_batch in example_generator:
            image = X_batch[0]
            plt.imshow(image)
            break
    plt.tight_layout()
    plt.show()

    fit_ex(model,FAST_RUN,train_generator,total_train,validation_generator,total_validate,batch_size,callbacks,saved_model_path)

def prepare_data_ex(train_input_dir,IMAGE_WIDTH, IMAGE_HEIGHT,batch_size):
    # Prepare Traning Data
    filenames = os.listdir(train_input_dir)
    categories = []
    for filename in filenames:
        category = filename.split('.')[0]
        if category == 'dog':
            categories.append(1)
        else:
            categories.append(0)

    df = pd.DataFrame({
        'filename': filenames,
        'category': categories
    })
    df.head()
    df.tail()

    # Prepare data
    df["category"] = df["category"].replace({0: 'cat', 1: 'dog'})
    train_df, validate_df = train_test_split(df, test_size=0.20, random_state=42)
    train_df = train_df.reset_index(drop=True)
    validate_df = validate_df.reset_index(drop=True)
    train_df['category'].value_counts().plot.bar()
    validate_df['category'].value_counts().plot.bar()
    total_train = train_df.shape[0]
    total_validate = validate_df.shape[0]

    return df,train_df, validate_df,total_train,total_validate

def traning_generator_ex(train_df,train_input_dir,IMAGE_WIDTH,IMAGE_HEIGHT,batch_size):
    # Traning Generator
    train_datagen = ImageDataGenerator(
        rotation_range=15,
        rescale=1. / 255,
        shear_range=0.1,
        zoom_range=0.2,
        horizontal_flip=True,
        width_shift_range=0.1,
        height_shift_range=0.1
    )

    train_generator = train_datagen.flow_from_dataframe(
        train_df,
        train_input_dir,
        x_col='filename',
        y_col='category',
        target_size=(IMAGE_WIDTH, IMAGE_HEIGHT),
        class_mode='categorical',
        batch_size=batch_size
    )

    return train_datagen,train_generator

def validation_generator_ex(validate_df,validate_input_dir,IMAGE_WIDTH,IMAGE_HEIGHT,batch_size):
    # Validation Generator
    validation_datagen = ImageDataGenerator(rescale=1. / 255)
    validation_generator = validation_datagen.flow_from_dataframe(
        validate_df,
        validate_input_dir,
        x_col='filename',
        y_col='category',
        target_size=(IMAGE_WIDTH, IMAGE_HEIGHT),
        class_mode='categorical',
        batch_size=batch_size
    )

    return validation_datagen,validation_generator

def build_model(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS):
    # Build Model
    model = Sequential()
    model.add(Conv2D(32, (3, 3), activation='relu', input_shape=(IMAGE_WIDTH, IMAGE_HEIGHT, IMAGE_CHANNELS)))
    model.add(BatchNormalization())
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.25))
    model.add(Conv2D(64, (3, 3), activation='relu'))
    model.add(BatchNormalization())
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.25))
    model.add(Conv2D(128, (3, 3), activation='relu'))
    model.add(BatchNormalization())
    model.add(MaxPooling2D(pool_size=(2, 2)))
    model.add(Dropout(0.25))
    model.add(Flatten())
    model.add(Dense(512, activation='relu'))
    model.add(BatchNormalization())
    model.add(Dropout(0.5))
    model.add(Dense(2, activation='softmax'))  # 2 because we have cat and dog classes
    model.compile(loss='categorical_crossentropy', optimizer='rmsprop', metrics=['accuracy'])
    model.summary()
    return model

def fit_ex(model,FAST_RUN,train_generator,total_train,validation_generator,total_validate,batch_size,callbacks,saved_model_path):
    # Fit Model
    epochs = 1 if FAST_RUN else 100
    history = model.fit_generator(
        train_generator,
        epochs=epochs,
        validation_data=validation_generator,
        validation_steps=total_validate // batch_size,
        steps_per_epoch=total_train // batch_size,
        callbacks=callbacks
    )
    #model.save_weights(saved_model_path)
    model.save(saved_model_path)
    virtualize_training(history,epochs)

def virtualize_training(history,epochs):
    # Virtualize Training
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 12))
    ax1.plot(history.history['loss'], color='b', label="Training loss")
    ax1.plot(history.history['val_loss'], color='r', label="validation loss")
    ax1.set_xticks(np.arange(1, epochs, 1))
    ax1.set_yticks(np.arange(0, 1, 0.1))

    ax2.plot(history.history['accuracy'], color='b', label="Training accuracy")
    ax2.plot(history.history['val_accuracy'], color='r', label="Validation accuracy")
    ax2.set_xticks(np.arange(1, epochs, 1))

    legend = plt.legend(loc='best', shadow=True)
    plt.tight_layout()
    plt.show()

def testing_ex(test_input_dir,IMAGE_WIDTH,IMAGE_HEIGHT,batch_size):
    # Prepare Testing Data
    test_filenames = os.listdir(test_input_dir)
    test_df = pd.DataFrame({
        'filename': test_filenames
    })
    nb_samples = test_df.shape[0]

    # Create Testing Generator
    test_gen = ImageDataGenerator(rescale=1. / 255)
    test_generator = test_gen.flow_from_dataframe(
        test_df,
        test_input_dir,
        x_col='filename',
        y_col=None,
        class_mode=None,
        target_size=(IMAGE_WIDTH, IMAGE_HEIGHT),
        batch_size=batch_size,
        shuffle=False
    )
    return test_df,nb_samples,test_generator

def predict_ex(model_path, predict_input_dir, output_dir, IMAGE_WIDTH, IMAGE_HEIGHT, batch_size):
    test_df, nb_samples, test_generator = testing_ex(predict_input_dir, IMAGE_WIDTH, IMAGE_HEIGHT, batch_size)

    model = tf.keras.models.load_model(model_path)
    # 检查其架构
    model.summary()
    # Predict
    predict = model.predict_generator(test_generator, steps=np.ceil(nb_samples / batch_size))
    test_df['category'] = np.argmax(predict, axis=-1)

    # Submission
    submission_df = test_df.copy()
    submission_df['id'] = submission_df['filename'].str.split('.').str[0]
    submission_df['label'] = submission_df['category']
    submission_df.drop(['filename', 'category'], axis=1, inplace=True)
    submission_df.to_csv(output_dir + 'submission.csv', index=False)

def test(model_path,predict_image_path, IMAGE_WIDTH, IMAGE_HEIGHT):
    model = tf.keras.models.load_model(model_path)
    # Predict
    img = tf.keras.preprocessing.image.load_img(
        predict_image_path, target_size=(IMAGE_HEIGHT, IMAGE_WIDTH)
    )
    img_array = tf.keras.preprocessing.image.img_to_array(img)
    img_array = tf.expand_dims(img_array, 0)  # Create a batch

    predictions = model.predict(img_array)
    score = tf.nn.softmax(predictions[0])
    print(
        "This image most likely belongs to {} with a {:.2f} percent confidence."
            .format(np.argmax(score), 100 * np.max(score))
    )

def evaluate_ex(model_path, input_dir, IMAGE_HEIGHT, IMAGE_WIDTH, batch_size):
    model = tf.keras.models.load_model(model_path)
    model.summary()

    df, train_df, validate_df, total_train, total_validate = prepare_data_ex(input_dir, IMAGE_WIDTH, IMAGE_HEIGHT,
                                                                             batch_size)
    train_datagen, train_generator = traning_generator_ex(train_df, input_dir, IMAGE_WIDTH, IMAGE_HEIGHT,
                                                          batch_size)
    validation_datagen, validation_generator = validation_generator_ex(validate_df, input_dir, IMAGE_WIDTH,
                                                                       IMAGE_HEIGHT, batch_size)

    test_loss, test_acc = model.evaluate(validate_df, verbose=2)
    print('\nTest accuracy:', test_acc)

def main_ex():
    FAST_RUN = False
    train_input_dir = "./dataset/cat_and_dog/input/train/"
    model_path = "./dataset/cat_and_dog/models/saved_model/model.h5"
    test_input_dir = "./dataset/cat_and_dog/input/test1/"
    output_dir = "./dataset/cat_and_dog/output/"
    predict_image_path = "./dataset/cat_and_dog/input/test1/10.jpg"

    IMAGE_WIDTH = 128
    IMAGE_HEIGHT = 128
    IMAGE_CHANNELS = 3
    batch_size = 16

    #train_model_ex(train_input_dir,IMAGE_WIDTH,IMAGE_HEIGHT,IMAGE_CHANNELS,batch_size,model_path,FAST_RUN)

    #evaluate_ex(model_path, train_input_dir, IMAGE_HEIGHT, IMAGE_WIDTH, batch_size)

    predict_ex(model_path, test_input_dir, output_dir, IMAGE_WIDTH, IMAGE_HEIGHT, batch_size)

    #test(model_path,predict_image_path,IMAGE_WIDTH, IMAGE_HEIGHT)

main_ex()

案例2，鲜花分类（准备数据、先训练，再载入模型预测）

import matplotlib.pyplot as plt
import numpy as np
import os
import PIL
import tensorflow as tf
import pathlib
from tensorflow import keras
from tensorflow.keras import layers
from tensorflow.keras.models import Sequential
import matplotlib.pyplot as plt
from tensorflow.python.keras.callbacks import EarlyStopping, ReduceLROnPlateau


def train_model_ex(model_path, input_dir, img_height, img_width, batch_size,FAST_RUN):
    train_ds,val_ds,data_augmentation = prepare_data_ex(input_dir, img_height, img_width, batch_size)
    model = bulid_model(data_augmentation,img_height, img_width)
    history,epochs = fit_ex(model,model_path,train_ds,val_ds,FAST_RUN)
    virtualize_training(history, epochs)

def prepare_data_ex(input_dir, img_height, img_width, batch_size):
    input_dir = pathlib.Path(input_dir)
    image_count = len(list(input_dir.glob('*/*.jpg')))
    print(image_count)

    train_ds = tf.keras.preprocessing.image_dataset_from_directory(
        input_dir,
        validation_split=0.2,
        subset="training",
        seed=123,
        image_size=(img_height, img_width),
        batch_size=batch_size)

    val_ds = tf.keras.preprocessing.image_dataset_from_directory(
        input_dir,
        validation_split=0.2,
        subset="validation",
        seed=123,
        image_size=(img_height, img_width),
        batch_size=batch_size)

    class_names = train_ds.class_names
    print(class_names)

    # 可视化数据
    # plt.figure(figsize=(10, 10))
    # for images, labels in train_ds.take(1):
    #     for i in range(9):
    #         ax = plt.subplot(3, 3, i + 1)
    #         plt.imshow(images[i].numpy().astype("uint8"))
    #         plt.title(class_names[labels[i]])
    #         plt.axis("off")
    # plt.show()

    for image_batch, labels_batch in train_ds:
        print(image_batch.shape)
        print(labels_batch.shape)
        break

    # 配置数据集以提高性能
    AUTOTUNE = tf.data.experimental.AUTOTUNE
    train_ds = train_ds.cache().shuffle(1000).prefetch(buffer_size=AUTOTUNE)
    val_ds = val_ds.cache().prefetch(buffer_size=AUTOTUNE)

    # 标准化数据
    normalization_layer = layers.experimental.preprocessing.Rescaling(1. / 255)
    normalized_ds = train_ds.map(lambda x, y: (normalization_layer(x), y))
    image_batch, labels_batch = next(iter(normalized_ds))
    first_image = image_batch[0]
    # Notice the pixels values are now in `[0,1]`.
    print(np.min(first_image), np.max(first_image))

    data_augmentation = keras.Sequential(
        [
            layers.experimental.preprocessing.RandomFlip("horizontal",
                                                         input_shape=(img_height,
                                                                      img_width,
                                                                      3)),
            layers.experimental.preprocessing.RandomRotation(0.1),
            layers.experimental.preprocessing.RandomZoom(0.1),
        ]
    )
    plt.figure(figsize=(10, 10))
    for images, _ in train_ds.take(1):
        for i in range(9):
            augmented_images = data_augmentation(images)
            ax = plt.subplot(3, 3, i + 1)
            plt.imshow(augmented_images[0].numpy().astype("uint8"))
            plt.axis("off")
    plt.show()

    return train_ds,val_ds,data_augmentation

def bulid_model(data_augmentation,img_height, img_width):
    # 创建模型
    num_classes = 5

    model = Sequential([
        data_augmentation,
        layers.experimental.preprocessing.Rescaling(1. / 255),
        layers.Conv2D(16, 3, padding='same', activation='relu'),
        layers.MaxPooling2D(),
        layers.Conv2D(32, 3, padding='same', activation='relu'),
        layers.MaxPooling2D(),
        layers.Conv2D(64, 3, padding='same', activation='relu'),
        layers.MaxPooling2D(),
        layers.Dropout(0.2),
        layers.Flatten(),
        layers.Dense(128, activation='relu'),
        layers.Dense(num_classes)
    ])

    # 编译模型
    model.compile(optimizer='adam',
                  loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
                  metrics=['accuracy'])

    # 查看模型信息
    model.summary()
    return model

def fit_ex(model,model_path,train_ds,val_ds,FAST_RUN):
    earlystop = EarlyStopping(patience=10)
    learning_rate_reduction = ReduceLROnPlateau(monitor='val_accuracy',
                                                patience=2,
                                                verbose=2,
                                                factor=0.5,
                                                min_lr=0.00001)
    callbacks = [earlystop, learning_rate_reduction]

    # 训练模型
    # Fit Model
    epochs = 1 if FAST_RUN else 100
    history = model.fit_generator(
        train_ds,
        validation_data=val_ds,
        epochs=epochs,
        callbacks=callbacks
    )

    model.save(model_path)

    return history,epochs

def virtualize_training(history,epochs):
    # 可视化培训结果
    fig, (ax1, ax2) = plt.subplots(2, 1, figsize=(12, 12))
    ax1.plot(history.history['loss'], color='b', label="Training loss")
    ax1.plot(history.history['val_loss'], color='r', label="validation loss")
    ax1.set_xticks(np.arange(1, epochs, 1))
    ax1.set_yticks(np.arange(0, 1, 0.1))

    ax2.plot(history.history['accuracy'], color='b', label="Training accuracy")
    ax2.plot(history.history['val_accuracy'], color='r', label="Validation accuracy")
    ax2.set_xticks(np.arange(1, epochs, 1))

    legend = plt.legend(loc='best', shadow=True)
    plt.tight_layout()
    plt.show()
    print(legend)

def predict_ex(model_path, predict_image_path, img_width, img_height):
    model = tf.keras.models.load_model(model_path)
    model.summary()

    img = keras.preprocessing.image.load_img(
        predict_image_path, target_size=(img_height, img_width)
    )
    img_array = keras.preprocessing.image.img_to_array(img)
    img_array = tf.expand_dims(img_array, 0)  # Create a batch

    predictions = model.predict(img_array)
    score = tf.nn.softmax(predictions[0])

    print(
        "This image most likely belongs to {} with a {:.2f} percent confidence."
            .format(np.argmax(score), 100 * np.max(score))
    )

def evaluate_ex(model_path, input_dir, img_height, img_width, batch_size):
    model = tf.keras.models.load_model(model_path)
    model.summary()
    train_ds, val_ds, data_augmentation = prepare_data_ex(input_dir, img_height, img_width, batch_size)
    test_loss, test_acc = model.evaluate(train_ds, verbose=2)
    print('\nTest accuracy:', test_acc)

def main_ex():
    FAST_RUN = False
    batch_size = 15
    img_height = 180
    img_width = 180

    model_path = "./dataset/flower_photos/models/saved_model/model.h5"
    input_dir = "./dataset/flower_photos/input/"
    predict_image_path = "./dataset/flower_photos/input/roses/319298955_0c72bd36bf.jpg"
    # train_model_ex(model_path, input_dir, img_height, img_width, batch_size, FAST_RUN)

    evaluate_ex(model_path, input_dir, img_height, img_width, batch_size)

    # 0 daisy 雏菊、1 dandelion 蒲公英、2 roses 玫瑰、3 sunflowers 向日葵、4 tulips 郁金香
    # predict_ex(model_path, predict_image_path, img_width, img_height)

main_ex()

案例3，dlib人脸识别

#coding=utf-8
#图片检测 - Dlib版本
import cv2
import dlib

path = "img/tly0.jpg"
img = cv2.imread(path)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

#人脸分类器
detector = dlib.get_frontal_face_detector()
# 获取人脸检测器
predictor = dlib.shape_predictor(
    "data/shape_predictor_68_face_landmarks.dat"
)

dets = detector(gray, 1)
for face in dets:
    # 在图片中标注人脸，并显示
    # left = face.left()
    # top = face.top()
    # right = face.right()
    # bottom = face.bottom()
    # cv2.rectangle(img, (left, top), (right, bottom), (0, 255, 0), 2)
    # cv2.imshow("image", img)

    shape = predictor(img, face)  # 寻找人脸的68个标定点
    # 遍历所有点，打印出其坐标，并圈出来
    for pt in shape.parts():
        pt_pos = (pt.x, pt.y)
        cv2.circle(img, pt_pos, 1, (0, 255, 0), 2)
    cv2.imshow("image", img)

cv2.waitKey(0)
cv2.destroyAllWindows()

案例4，opencv人脸识别

#coding=utf-8
#图片检测 - OpenCV版本
import cv2
import datetime
import time

filepath = "img/duoren.jpg"
# OpenCV人脸识别分类器
classifier = cv2.CascadeClassifier(
    "data\haarcascades\haarcascade_frontalface_default.xml"
)

# 程序开始时间
startTime = datetime.datetime.now()

img = cv2.imread(filepath)  # 读取图片
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)  # 转换灰色
color = (0, 255, 0)  # 定义绘制颜色
# 调用识别人脸
faceRects = classifier.detectMultiScale(
    gray, scaleFactor=1.2, minNeighbors=3, minSize=(32, 32))
if len(faceRects):  # 大于0则检测到人脸
    for faceRect in faceRects:  # 单独框出每一张人脸
        x, y, w, h = faceRect
        # 框出人脸
        cv2.rectangle(img, (x, y), (x + h, y + w), color, 1)
        # 左眼 (不对
        # cv2.circle(img, (x + w // 4, y + h // 4 + 30), min(w // 8, h // 8),color)
        #右眼 (不对)
        # cv2.circle(img, (x + 3 * w // 4, y + h // 4 + 30), min(w // 8, h // 8), color)
        #嘴巴 (不对
        # cv2.rectangle(img, (x + 3 * w // 8, y + 3 * h // 4),(x + 5 * w // 8, y + 7 * h // 8), color)

# 程序结束时间
endTime = datetime.datetime.now()
print((endTime - startTime))
cv2.imshow("image", img)  # 显示图像
cv2.waitKey(0)
cv2.destroyAllWindows()

案例5，opecv面部表情识别

#coding=utf-8
#表情识别

import cv2
from keras.models import load_model
import numpy as np
import chineseText
import datetime

startTime = datetime.datetime.now()
emotion_classifier = load_model(
    'classifier/emotion_models/simple_CNN.530-0.65.hdf5')
endTime = datetime.datetime.now()
print(endTime - startTime)

emotion_labels = {
    0: '生气',
    1: '厌恶',
    2: '恐惧',
    3: '开心',
    4: '难过',
    5: '惊喜',
    6: '平静'
}

img = cv2.imread("img/duoren.jpg")
face_classifier = cv2.CascadeClassifier(
    "data\haarcascades\haarcascade_frontalface_default.xml"
)
gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
faces = face_classifier.detectMultiScale(
    gray, scaleFactor=1.2, minNeighbors=3, minSize=(40, 40))
color = (255, 0, 0)

for (x, y, w, h) in faces:
    gray_face = gray[(y):(y + h), (x):(x + w)]
    gray_face = cv2.resize(gray_face, (48, 48))
    gray_face = gray_face / 255.0
    gray_face = np.expand_dims(gray_face, 0)
    gray_face = np.expand_dims(gray_face, -1)
    emotion_label_arg = np.argmax(emotion_classifier.predict(gray_face))
    emotion = emotion_labels[emotion_label_arg]
    cv2.rectangle(img, (x + 10, y + 10), (x + h - 10, y + w - 10),
                  (255, 255, 255), 2)
    img = chineseText.cv2ImgAddText(img, emotion, x + h * 0.3, y, color, 20)

cv2.imshow("Image", img)
cv2.waitKey(0)
cv2.destroyAllWindows()

案例6，face_recognition 自动化妆

#coding=utf-8
#数字化妆类
import face_recognition
from PIL import Image, ImageDraw

#加载图片到numpy array
image = face_recognition.load_image_file("img/tly0.jpg")

#标识脸部特征
face_landmarks_list = face_recognition.face_landmarks(image)

for face_landmarks in face_landmarks_list:
    pil_image = Image.fromarray(image)
    d = ImageDraw.Draw(pil_image, 'RGBA')

    # 绘制眉毛
    d.polygon(face_landmarks['left_eyebrow'], fill=(68, 54, 39, 128))
    d.polygon(face_landmarks['right_eyebrow'], fill=(68, 54, 39, 128))
    d.line(face_landmarks['left_eyebrow'], fill=(68, 54, 39, 150), width=2)
    d.line(face_landmarks['right_eyebrow'], fill=(68, 54, 39, 150), width=2)

    # 绘制嘴唇
    d.polygon(face_landmarks['top_lip'], fill=(120, 0, 0, 128))
    d.polygon(face_landmarks['bottom_lip'], fill=(120, 0, 0, 128))
    d.line(face_landmarks['top_lip'], fill=(120, 0, 0, 64), width=2)
    d.line(face_landmarks['bottom_lip'], fill=(120, 0, 0, 64), width=2)

    # 绘制眼睛
    d.polygon(face_landmarks['left_eye'], fill=(255, 255, 255, 30))
    d.polygon(face_landmarks['right_eye'], fill=(255, 255, 255, 30))

    # 绘制眼线
    d.line(
        face_landmarks['left_eye'] + [face_landmarks['left_eye'][0]],
        fill=(0, 0, 0, 110),
        width=6)
    d.line(
        face_landmarks['right_eye'] + [face_landmarks['right_eye'][0]],
        fill=(0, 0, 0, 110),
        width=6)

    pil_image.show()

案例7，face_recognition人脸识别（用opencv拿摄像头数据，要有摄像头）

#coding=utf-8
#人脸识别类 - 使用face_recognition模块
import cv2
import face_recognition
import os

path = "img/face_recognition"  # 模型数据图片目录
cap = cv2.VideoCapture(0)
total_image_name = []
total_face_encoding = []
for fn in os.listdir(path):  #fn 表示的是文件名q
    print(path + "/" + fn)
    total_face_encoding.append(
        face_recognition.face_encodings(
            face_recognition.load_image_file(path + "/" + fn))[0])
    fn = fn[:(len(fn) - 4)]  #截取图片名（这里应该把images文件中的图片名命名为为人物名）
    total_image_name.append(fn)  #图片名字列表
while (1):
    ret, frame = cap.read()
    # 发现在视频帧所有的脸和face_enqcodings
    face_locations = face_recognition.face_locations(frame)
    face_encodings = face_recognition.face_encodings(frame, face_locations)
    # 在这个视频帧中循环遍历每个人脸
    for (top, right, bottom, left), face_encoding in zip(
            face_locations, face_encodings):
        # 看看面部是否与已知人脸相匹配。
        for i, v in enumerate(total_face_encoding):
            match = face_recognition.compare_faces(
                [v], face_encoding, tolerance=0.5)
            name = "Unknown"
            if match[0]:
                name = total_image_name[i]
                break
        # 画出一个框，框住脸
        cv2.rectangle(frame, (left, top), (right, bottom), (0, 0, 255), 2)
        # 画出一个带名字的标签，放在框下
        cv2.rectangle(frame, (left, bottom - 35), (right, bottom), (0, 0, 255),
                      cv2.FILLED)
        font = cv2.FONT_HERSHEY_DUPLEX
        cv2.putText(frame, name, (left + 6, bottom - 6), font, 1.0,
                    (255, 255, 255), 1)
    # 显示结果图像
    cv2.imshow('Video', frame)
    if cv2.waitKey(1) & 0xFF == ord('q'):
        break

cap.release()
cv2.destroyAllWindows()

案例8，face_recognition勾画面部轮廓

#coding=utf-8
#绘制面部轮廓
import face_recognition
from PIL import Image, ImageDraw

# 将图片文件加载到numpy 数组中
image = face_recognition.load_image_file("img/tly0.jpg")

#查找图像中所有面部的所有面部特征
face_landmarks_list = face_recognition.face_landmarks(image)

for face_landmarks in face_landmarks_list:
    facial_features = [
        'chin',  # 下巴
        'left_eyebrow',  # 左眉毛
        'right_eyebrow',  # 右眉毛
        'nose_bridge',  # 鼻樑
        'nose_tip',  # 鼻尖
        'left_eye',  # 左眼
        'right_eye',  # 右眼
        'top_lip',  # 上嘴唇
        'bottom_lip'  # 下嘴唇
    ]
    pil_image = Image.fromarray(image)
    d = ImageDraw.Draw(pil_image)
    for facial_feature in facial_features:
        d.line(face_landmarks[facial_feature], fill=(0, 255, 0), width=2)
    pil_image.show()

案例9，OCR 文本识别（装个Tesseract-OCR，记得勾选中文支持，修改python pytesseract模块里的环境）

#coding=utf-8
#文字识别类
from PIL import Image
import pytesseract
import cv2

path = "img/text-img.png"

text = pytesseract.image_to_string(Image.open(path),lang='chi_sim')
print(text)

img = cv2.imread(path)
cv2.imshow("Image", img)

cv2.waitKey(0)
cv2.destroyAllWindows()

外码斯迪

关注

1
点赞
踩
4

收藏

觉得还不错? 一键收藏
打赏
3
评论
win10 x64搭建tensorflow-gpu开发环境

我的显卡是两块丽台 RTX 4000，准备软件资源如下：pycharm-professional-2020.2.2Anaconda3-5.3.1-Windows-x86_64CUDA 10.1.243cudnn 10.1tensorflow-gpu 2.3.0步骤：1，安装Anaconda，建库，配Windows环境变量；2，安装Pycharm 安装社区版或企业版，删除探测文件可无限使用文件地址：C:\Users\jerry\AppData\Roaming\JetBrains.
复制链接

扫一扫