livingbody

PaddlePaddle飞桨《高层API助你快速上手深度学习》『深度学习7日打卡营』第三节课后作业--人脸关键点检测

『深度学习7日打卡营』人脸关键点检测

一、问题定义

人脸关键点检测，是输入一张人脸图片，模型会返回人脸关键点的一系列坐标，从而定位到人脸的关键信息。

# 环境导入
import os
import numpy as np
import pandas as pd
import matplotlib.pyplot as plt
import matplotlib.image as mpimg

import cv2
import paddle

paddle.set_device('gpu') # 设置为GPU

import warnings 
warnings.filterwarnings('ignore') # 忽略 warning

二、数据准备

2.1 下载数据集

本次实验所采用的数据集来源为github的开源项目

目前该数据集已上传到 AI Studio 人脸关键点识别，加载后可以直接使用下面的命令解压。

# !unzip data/data69065/data.zip

解压后的数据集结构为

data/
|—— test
|   |—— Abdel_Aziz_Al-Hakim_00.jpg
    ... ...
|—— test_frames_keypoints.csv
|—— training
|   |—— Abdullah_Gul_10.jpg
    ... ...
|—— training_frames_keypoints.csv

其中，training 和 test 文件夹分别存放训练集和测试集。training_frames_keypoints.csv 和 test_frames_keypoints.csv 存放着训练集和测试集的标签。接下来，我们先来观察一下 training_frames_keypoints.csv 文件，看一下训练集的标签是如何定义的。

key_pts_frame = pd.read_csv('data/training_frames_keypoints.csv') # 读取数据集
print('Number of images: ', key_pts_frame.shape[0]) # 输出数据集大小
key_pts_frame.head(5) # 看前五条数据

Number of images:  3462

	Unnamed: 0	0	1	2	3	4	5	6	7	8	...	126	127	128	129	130	131	132	133	134	135
0	Luis_Fonsi_21.jpg	45.0	98.0	47.0	106.0	49.0	110.0	53.0	119.0	56.0	...	83.0	119.0	90.0	117.0	83.0	119.0	81.0	122.0	77.0	122.0
1	Lincoln_Chafee_52.jpg	41.0	83.0	43.0	91.0	45.0	100.0	47.0	108.0	51.0	...	85.0	122.0	94.0	120.0	85.0	122.0	83.0	122.0	79.0	122.0
2	Valerie_Harper_30.jpg	56.0	69.0	56.0	77.0	56.0	86.0	56.0	94.0	58.0	...	79.0	105.0	86.0	108.0	77.0	105.0	75.0	105.0	73.0	105.0
3	Angelo_Reyes_22.jpg	61.0	80.0	58.0	95.0	58.0	108.0	58.0	120.0	58.0	...	98.0	136.0	107.0	139.0	95.0	139.0	91.0	139.0	85.0	136.0
4	Kristen_Breitweiser_11.jpg	58.0	94.0	58.0	104.0	60.0	113.0	62.0	121.0	67.0	...	92.0	117.0	103.0	118.0	92.0	120.0	88.0	122.0	84.0	122.0

5 rows × 137 columns

上表中每一行都代表一条数据，其中，第一列是图片的文件名，之后从第0列到第135列，就是该图的关键点信息。因为每个关键点可以用两个坐标表示，所以 136/2 = 68，就可以看出这个数据集为68点人脸关键点数据集。

Tips1: 目前常用的人脸关键点标注，有如下点数的标注

5点
21点
68点
98点

Tips2：本次所采用的68标注，标注顺序如下：

# 计算标签的均值和标准差，用于标签的归一化
key_pts_values = key_pts_frame.values[:,1:] # 取出标签信息
data_mean = key_pts_values.mean() # 计算均值
data_std = key_pts_values.std()   # 计算标准差
print('标签的均值为:', data_mean)
print('标签的标准差为:', data_std)

标签的均值为: 104.4724870017331
标签的标准差为: 43.17302271754281

2.2 查看图像

def show_keypoints(image, key_pts):
    """
    Args:
        image: 图像信息
        key_pts: 关键点信息，
    展示图片和关键点信息
    """
    plt.imshow(image.astype('uint8'))  # 展示图片信息
    for i in range(len(key_pts)//2,):
        plt.scatter(key_pts[i*2], key_pts[i*2+1], s=20, marker='.', c='b') # 展示关键点信息

# 展示单条数据

n = 14 # n为数据在表格中的索引 
image_name = key_pts_frame.iloc[n, 0] # 获取图像名称
key_pts = key_pts_frame.iloc[n, 1:].as_matrix() # 将图像label格式转为numpy.array的格式
key_pts = key_pts.astype('float').reshape(-1) # 获取图像关键点信息
print(key_pts.shape)
plt.figure(figsize=(5, 5)) # 展示的图像大小
show_keypoints(mpimg.imread(os.path.join('data/training/', image_name)), key_pts) # 展示图像与关键点信息
plt.show() # 展示图像

(136,)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-XXO3m7qg-1612608269248)(output_12_1.png)]

2.3 数据集定义

使用飞桨框架高层API的 paddle.io.Dataset 自定义数据集类，具体可以参考官网文档自定义数据集。

作业1：自定义 Dataset，完成人脸关键点数据集定义

按照 __init__ 中的定义，实现 __getitem__ 和 __len__.

# 按照Dataset的使用规范，构建人脸关键点数据集

from paddle.io import Dataset

class FacialKeypointsDataset(Dataset):
    # 人脸关键点数据集
    """
    步骤一：继承paddle.io.Dataset类
    """
    def __init__(self, csv_file, root_dir, transform=None):
        """
        步骤二：实现构造函数，定义数据集大小
        Args:
            csv_file (string): 带标注的csv文件路径
            root_dir (string): 图片存储的文件夹路径
            transform (callable, optional): 应用于图像上的数据处理方法
        """
        self.key_pts_frame = pd.read_csv(csv_file) # 读取csv文件
        self.root_dir = root_dir # 获取图片文件夹路径
        self.transform = transform # 获取 transform 方法

    def __getitem__(self, idx):
        """
        步骤三：实现__getitem__方法，定义指定index时如何获取数据，并返回单条数据（训练数据，对应的标签）
        """

        # 实现 __getitem__
        image_name=os.path.join(self.root_dir, self.key_pts_frame.iloc[idx,0])
        image=mpimg.imread(image_name)

        if(image.shape[2]==4):
            image=image[:,:,0:3]
        
        # 获取关键点信息
        key_pts = self.key_pts_frame.iloc[idx, 1:].as_matrix()
        key_pts = key_pts.astype('float').reshape(-1) # [136, 1]

        # 如果定义了 transform 方法，使用 transform方法
        if self.transform:
            image, key_pts = self.transform([image, key_pts])
        
        # 转为 numpy 的数据格式
        image = np.array(image, dtype='float32')
        key_pts = np.array(key_pts, dtype='float32')

        return image, key_pts

    def __len__(self):
        """
        步骤四：实现__len__方法，返回数据集总数目
        """
        
        # 实现 __len__
        return len(self.key_pts_frame)

2.4 训练集可视化

实例化数据集并显示一些图像。

# 构建一个数据集类
face_dataset = FacialKeypointsDataset(csv_file='data/training_frames_keypoints.csv',
                                      root_dir='data/training/')

# 输出数据集大小
print('数据集大小为: ', len(face_dataset))
# 根据 face_dataset 可视化数据集
num_to_display = 3

for i in range(num_to_display):
    
    # 定义图片大小
    fig = plt.figure(figsize=(20,10))
    
    # 随机选择图片
    rand_i = np.random.randint(0, len(face_dataset))
    sample = face_dataset[rand_i]

    # 输出图片大小和关键点的数量
    print(i, sample[0].shape, sample[1].shape)

    # 设置图片打印信息
    ax = plt.subplot(1, num_to_display, i + 1)
    ax.set_title('Sample #{}'.format(i))
    
    # 输出图片
    show_keypoints(sample[0], sample[1])

数据集大小为:  3462
0 (131, 115, 3) (136,)
1 (293, 229, 3) (136,)
2 (148, 121, 3) (136,)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-cLZuxcfn-1612608269249)(output_18_1.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-WQQ5LV0V-1612608269251)(output_18_2.png)]

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-HlF5zw2Y-1612608269251)(output_18_3.png)]

上述代码虽然完成了数据集的定义，但是还有一些问题，如：

每张图像的大小不一样，图像大小需要统一以适配网络输入要求
图像格式需要适配模型的格式输入要求
数据量比较小，没有进行数据增强

这些问题都会影响模型最终的性能，所以需要对数据进行预处理。

2.5 Transforms

对图像进行预处理，包括灰度化、归一化、重新设置尺寸、随机裁剪，修改通道格式等等，以满足数据要求；每一类的功能如下：

灰度化：丢弃颜色信息，保留图像边缘信息；识别算法对于颜色的依赖性不强，加上颜色后鲁棒性会下降，而且灰度化图像维度下降（3->1），保留梯度的同时会加快计算。
归一化：加快收敛
重新设置尺寸：数据增强
随机裁剪：数据增强
修改通道格式：改为模型需要的结构

作业2：实现自定义ToCHW

实现数据预处理方法 ToCHW

# 标准化自定义 transform 方法

# class TransformAPI(object):
#     """
#     步骤一：继承 object 类
#     """
#     def __call__(self, data):

#         """
#         步骤二：在 __call__ 中定义数据处理方法
#         """
        
#         processed_data = data
#         return  processed_data

import paddle.vision.transforms.functional as F

class GrayNormalize(object):
    # 将图片变为灰度图，并将其值放缩到[0, 1]
    # 将 label 放缩到 [-1, 1] 之间

    def __call__(self, data):
        image = data[0]   # 获取图片
        key_pts = data[1] # 获取标签
        
        image_copy = np.copy(image)
        key_pts_copy = np.copy(key_pts)

        # 灰度化图片
        gray_scale = paddle.vision.transforms.Grayscale(num_output_channels=3)
        image_copy = gray_scale(image_copy)
        
        # 将图片值放缩到 [0, 1]
        image_copy = image_copy / 255.0
        
        # 将坐标点放缩到 [-1, 1]
        mean = data_mean # 获取标签均值
        std = data_std   # 获取标签标准差
        key_pts_copy = (key_pts_copy - mean)/std

        return image_copy, key_pts_copy

class Resize(object):
    # 将输入图像调整为指定大小

    def __init__(self, output_size):
        assert isinstance(output_size, (int, tuple))
        self.output_size = output_size

    def __call__(self, data):

        image = data[0]    # 获取图片
        key_pts = data[1]  # 获取标签

        image_copy = np.copy(image)      
        key_pts_copy = np.copy(key_pts)

        h, w = image_copy.shape[:2]
        if isinstance(self.output_size, int):
            if h > w:
                new_h, new_w = self.output_size * h / w, self.output_size
            else:
                new_h, new_w = self.output_size, self.output_size * w / h
        else:
            new_h, new_w = self.output_size

        new_h, new_w = int(new_h), int(new_w)

        img = F.resize(image_copy, (new_h, new_w))
        
        # scale the pts, too
        key_pts_copy[::2] = key_pts_copy[::2] * new_w / w
        key_pts_copy[1::2] = key_pts_copy[1::2] * new_h / h

        return img, key_pts_copy


class RandomCrop(object):
    # 随机位置裁剪输入的图像

    def __init__(self, output_size):
        assert isinstance(output_size, (int, tuple))
        if isinstance(output_size, int):
            self.output_size = (output_size, output_size)
        else:
            assert len(output_size) == 2
            self.output_size = output_size

    def __call__(self, data):
        image = data[0]
        key_pts = data[1]

        image_copy = np.copy(image)
        key_pts_copy = np.copy(key_pts)

        h, w = image_copy.shape[:2]
        new_h, new_w = self.output_size

        top = np.random.randint(0, h - new_h)
        left = np.random.randint(0, w - new_w)

        image_copy = image_copy[top: top + new_h,
                      left: left + new_w]

        key_pts_copy[::2] = key_pts_copy[::2] - left
        key_pts_copy[1::2] = key_pts_copy[1::2] - top

        return image_copy, key_pts_copy

class ToCHW(object):
    # 将图像的格式由HWC改为CHW
    def __call__(self, data):

        # 实现ToCHW，可以使用 paddle.vision.transforms.Transpose 实现
        image = data[0]
        key_pts = data[1]

        transpose = T.Transpose() # 改为CHW
        image = transpose(image)
        return image, key_pts

看一下每种图像预处理方法的的效果。

import paddle.vision.transforms as T

# 测试 Resize
resize = Resize(256)

# 测试 RandomCrop
random_crop = RandomCrop(128)

# 测试 GrayNormalize
norm = GrayNormalize()

# 测试 Resize + RandomCrop，图像大小变到250*250， 然后截取出224*224的图像块
composed = paddle.vision.transforms.Compose([Resize(250), RandomCrop(224)])

test_num = 800 # 测试的数据下标
data = face_dataset[test_num]

transforms = {'None': None, 
              'norm': norm,
              'random_crop': random_crop,
              'resize': resize ,
              'composed': composed}
for i, func_name in enumerate(['None', 'norm', 'random_crop', 'resize', 'composed']):
    
    # 定义图片大小
    fig = plt.figure(figsize=(20,10))
    
    # 处理图片
    if transforms[func_name] != None:
        transformed_sample = transforms[func_name](data)
    else:
        transformed_sample = data

    # 设置图片打印信息
    ax = plt.subplot(1, 5, i + 1)
    ax.set_title(' Transform is #{}'.format(func_name))
    
    # 输出图片
    show_keypoints(transformed_sample[0], transformed_sample[1])

2.6 使用数据预处理的方式完成数据定义

让我们将 Resize、RandomCrop、GrayNormalize、ToCHW 应用于新的数据集

from paddle.vision.transforms import Compose

data_transform = Compose([Resize(256), RandomCrop(224), GrayNormalize(), ToCHW()])

# create the transformed dataset
train_dataset = FacialKeypointsDataset(csv_file='data/training_frames_keypoints.csv',
                                       root_dir='data/training/',
                                       transform=data_transform)
print('Number of train dataset images: ', len(train_dataset))

for i in range(4):
    sample = train_dataset[i]
    print(i, sample[0].shape, sample[1].shape)

test_dataset = FacialKeypointsDataset(csv_file='data/test_frames_keypoints.csv',
                                             root_dir='data/test/',
                                             transform=data_transform)

print('Number of test dataset images: ', len(test_dataset))

Number of train dataset images:  3462
0 (3, 224, 224) (136,)
1 (3, 224, 224) (136,)
2 (3, 224, 224) (136,)
3 (3, 224, 224) (136,)
Number of test dataset images:  770

3、模型组建

3.1 组网可以很简单

根据前文的分析可知，人脸关键点检测和分类，可以使用同样的网络结构，如LeNet、Resnet50等完成特征的提取，只是在原来的基础上，需要修改模型的最后部分，将输出调整为人脸关键点的数量*2，即每个人脸关键点的横坐标与纵坐标，就可以完成人脸关键点检测任务了，具体可以见下面的代码，也可以参考官网案例:人脸关键点检测

网络结构如下：

作业3：根据上图，实现网络结构

import paddle.nn as nn
from paddle.vision.models import resnet50
class SimpleNet(nn.Layer):
    
    def __init__(self, key_pts):

        super(SimpleNet, self).__init__()

        # 实现 __init__
        self.backbone = paddle.vision.models.resnet101(pretrained=True)
        # 添加第一个线性变换层
        self.linear1 = nn.Linear(in_features=1000, out_features=512)

        # 使用 ReLU 激活函数
        self.act1 = nn.ReLU()

        # 添加第二个线性变换层作为输出，输出元素的个数为 key_pts*2，代表每个关键点的坐标
        self.linear2 = nn.Linear(in_features=512, out_features=key_pts*2)

    def forward(self, x):

        # 实现 forward
        x = self.backbone(x)
        x = self.linear1(x)
        x = self.act1(x)
        x = self.linear2(x)
        return x

3.2 网络结构可视化

使用model.summary可视化网络结构。

model = paddle.Model(SimpleNet(key_pts=68))
model.summary((-1, 3, 224, 224))

-------------------------------------------------------------------------------
   Layer (type)         Input Shape          Output Shape         Param #    
===============================================================================
     Conv2D-1        [[1, 3, 224, 224]]   [1, 64, 112, 112]        9,408     
   BatchNorm2D-1    [[1, 64, 112, 112]]   [1, 64, 112, 112]         256      
      ReLU-1        [[1, 64, 112, 112]]   [1, 64, 112, 112]          0       
    MaxPool2D-1     [[1, 64, 112, 112]]    [1, 64, 56, 56]           0       
     Conv2D-3        [[1, 64, 56, 56]]     [1, 64, 56, 56]         4,096     
   BatchNorm2D-3     [[1, 64, 56, 56]]     [1, 64, 56, 56]          256      
      ReLU-2         [[1, 256, 56, 56]]    [1, 256, 56, 56]          0       
     Conv2D-4        [[1, 64, 56, 56]]     [1, 64, 56, 56]        36,864     
   BatchNorm2D-4     [[1, 64, 56, 56]]     [1, 64, 56, 56]          256      
     Conv2D-5        [[1, 64, 56, 56]]     [1, 256, 56, 56]       16,384     
   BatchNorm2D-5     [[1, 256, 56, 56]]    [1, 256, 56, 56]        1,024     
     Conv2D-2        [[1, 64, 56, 56]]     [1, 256, 56, 56]       16,384     
   BatchNorm2D-2     [[1, 256, 56, 56]]    [1, 256, 56, 56]        1,024     
 BottleneckBlock-1   [[1, 64, 56, 56]]     [1, 256, 56, 56]          0       
     Conv2D-6        [[1, 256, 56, 56]]    [1, 64, 56, 56]        16,384     
   BatchNorm2D-6     [[1, 64, 56, 56]]     [1, 64, 56, 56]          256      
      ReLU-3         [[1, 256, 56, 56]]    [1, 256, 56, 56]          0       
     Conv2D-7        [[1, 64, 56, 56]]     [1, 64, 56, 56]        36,864     
   BatchNorm2D-7     [[1, 64, 56, 56]]     [1, 64, 56, 56]          256      
     Conv2D-8        [[1, 64, 56, 56]]     [1, 256, 56, 56]       16,384     
   BatchNorm2D-8     [[1, 256, 56, 56]]    [1, 256, 56, 56]        1,024     
 BottleneckBlock-2   [[1, 256, 56, 56]]    [1, 256, 56, 56]          0       
     Conv2D-9        [[1, 256, 56, 56]]    [1, 64, 56, 56]        16,384     
   BatchNorm2D-9     [[1, 64, 56, 56]]     [1, 64, 56, 56]          256      
      ReLU-4         [[1, 256, 56, 56]]    [1, 256, 56, 56]          0       
     Conv2D-10       [[1, 64, 56, 56]]     [1, 64, 56, 56]        36,864     
  BatchNorm2D-10     [[1, 64, 56, 56]]     [1, 64, 56, 56]          256      
     Conv2D-11       [[1, 64, 56, 56]]     [1, 256, 56, 56]       16,384     
  BatchNorm2D-11     [[1, 256, 56, 56]]    [1, 256, 56, 56]        1,024     
 BottleneckBlock-3   [[1, 256, 56, 56]]    [1, 256, 56, 56]          0       
     Conv2D-13       [[1, 256, 56, 56]]    [1, 128, 56, 56]       32,768     
  BatchNorm2D-13     [[1, 128, 56, 56]]    [1, 128, 56, 56]         512      
      ReLU-5         [[1, 512, 28, 28]]    [1, 512, 28, 28]          0       
     Conv2D-14       [[1, 128, 56, 56]]    [1, 128, 28, 28]       147,456    
  BatchNorm2D-14     [[1, 128, 28, 28]]    [1, 128, 28, 28]         512      
     Conv2D-15       [[1, 128, 28, 28]]    [1, 512, 28, 28]       65,536     
  BatchNorm2D-15     [[1, 512, 28, 28]]    [1, 512, 28, 28]        2,048     
     Conv2D-12       [[1, 256, 56, 56]]    [1, 512, 28, 28]       131,072    
  BatchNorm2D-12     [[1, 512, 28, 28]]    [1, 512, 28, 28]        2,048     
 BottleneckBlock-4   [[1, 256, 56, 56]]    [1, 512, 28, 28]          0       
     Conv2D-16       [[1, 512, 28, 28]]    [1, 128, 28, 28]       65,536     
  BatchNorm2D-16     [[1, 128, 28, 28]]    [1, 128, 28, 28]         512      
      ReLU-6         [[1, 512, 28, 28]]    [1, 512, 28, 28]          0       
     Conv2D-17       [[1, 128, 28, 28]]    [1, 128, 28, 28]       147,456    
  BatchNorm2D-17     [[1, 128, 28, 28]]    [1, 128, 28, 28]         512      
     Conv2D-18       [[1, 128, 28, 28]]    [1, 512, 28, 28]       65,536     
  BatchNorm2D-18     [[1, 512, 28, 28]]    [1, 512, 28, 28]        2,048     
 BottleneckBlock-5   [[1, 512, 28, 28]]    [1, 512, 28, 28]          0       
     Conv2D-19       [[1, 512, 28, 28]]    [1, 128, 28, 28]       65,536     
  BatchNorm2D-19     [[1, 128, 28, 28]]    [1, 128, 28, 28]         512      
      ReLU-7         [[1, 512, 28, 28]]    [1, 512, 28, 28]          0       
     Conv2D-20       [[1, 128, 28, 28]]    [1, 128, 28, 28]       147,456    
  BatchNorm2D-20     [[1, 128, 28, 28]]    [1, 128, 28, 28]         512      
     Conv2D-21       [[1, 128, 28, 28]]    [1, 512, 28, 28]       65,536     
  BatchNorm2D-21     [[1, 512, 28, 28]]    [1, 512, 28, 28]        2,048     
 BottleneckBlock-6   [[1, 512, 28, 28]]    [1, 512, 28, 28]          0       
     Conv2D-22       [[1, 512, 28, 28]]    [1, 128, 28, 28]       65,536     
  BatchNorm2D-22     [[1, 128, 28, 28]]    [1, 128, 28, 28]         512      
      ReLU-8         [[1, 512, 28, 28]]    [1, 512, 28, 28]          0       
     Conv2D-23       [[1, 128, 28, 28]]    [1, 128, 28, 28]       147,456    
  BatchNorm2D-23     [[1, 128, 28, 28]]    [1, 128, 28, 28]         512      
     Conv2D-24       [[1, 128, 28, 28]]    [1, 512, 28, 28]       65,536     
  BatchNorm2D-24     [[1, 512, 28, 28]]    [1, 512, 28, 28]        2,048     
 BottleneckBlock-7   [[1, 512, 28, 28]]    [1, 512, 28, 28]          0       
     Conv2D-26       [[1, 512, 28, 28]]    [1, 256, 28, 28]       131,072    
  BatchNorm2D-26     [[1, 256, 28, 28]]    [1, 256, 28, 28]        1,024     
      ReLU-9        [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-27       [[1, 256, 28, 28]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-27     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-28       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-28    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
     Conv2D-25       [[1, 512, 28, 28]]   [1, 1024, 14, 14]       524,288    
  BatchNorm2D-25    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
 BottleneckBlock-8   [[1, 512, 28, 28]]   [1, 1024, 14, 14]          0       
     Conv2D-29      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-29     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-10       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-30       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-30     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-31       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-31    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
 BottleneckBlock-9  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-32      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-32     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-11       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-33       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-33     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-34       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-34    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-10  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-35      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-35     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-12       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-36       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-36     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-37       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-37    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-11  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-38      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-38     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-13       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-39       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-39     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-40       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-40    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-12  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-41      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-41     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-14       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-42       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-42     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-43       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-43    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-13  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-44      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-44     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-15       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-45       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-45     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-46       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-46    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-14  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-47      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-47     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-16       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-48       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-48     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-49       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-49    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-15  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-50      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-50     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-17       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-51       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-51     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-52       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-52    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-16  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-53      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-53     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-18       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-54       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-54     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-55       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-55    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-17  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-56      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-56     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-19       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-57       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-57     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-58       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-58    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-18  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-59      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-59     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-20       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-60       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-60     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-61       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-61    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-19  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-62      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-62     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-21       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-63       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-63     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-64       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-64    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-20  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-65      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-65     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-22       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-66       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-66     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-67       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-67    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-21  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-68      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-68     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-23       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-69       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-69     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-70       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-70    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-22  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-71      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-71     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-24       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-72       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-72     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-73       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-73    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-23  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-74      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-74     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-25       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-75       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-75     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-76       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-76    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-24  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-77      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-77     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-26       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-78       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-78     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-79       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-79    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-25  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-80      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-80     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-27       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-81       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-81     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-82       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-82    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-26  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-83      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-83     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-28       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-84       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-84     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-85       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-85    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-27  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-86      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-86     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-29       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-87       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-87     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-88       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-88    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-28  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-89      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-89     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-30       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-90       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-90     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-91       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-91    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-29  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-92      [[1, 1024, 14, 14]]    [1, 256, 14, 14]       262,144    
  BatchNorm2D-92     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
      ReLU-31       [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-93       [[1, 256, 14, 14]]    [1, 256, 14, 14]       589,824    
  BatchNorm2D-93     [[1, 256, 14, 14]]    [1, 256, 14, 14]        1,024     
     Conv2D-94       [[1, 256, 14, 14]]   [1, 1024, 14, 14]       262,144    
  BatchNorm2D-94    [[1, 1024, 14, 14]]   [1, 1024, 14, 14]        4,096     
BottleneckBlock-30  [[1, 1024, 14, 14]]   [1, 1024, 14, 14]          0       
     Conv2D-96      [[1, 1024, 14, 14]]    [1, 512, 14, 14]       524,288    
  BatchNorm2D-96     [[1, 512, 14, 14]]    [1, 512, 14, 14]        2,048     
      ReLU-32        [[1, 2048, 7, 7]]     [1, 2048, 7, 7]           0       
     Conv2D-97       [[1, 512, 14, 14]]     [1, 512, 7, 7]       2,359,296   
  BatchNorm2D-97      [[1, 512, 7, 7]]      [1, 512, 7, 7]         2,048     
     Conv2D-98        [[1, 512, 7, 7]]     [1, 2048, 7, 7]       1,048,576   
  BatchNorm2D-98     [[1, 2048, 7, 7]]     [1, 2048, 7, 7]         8,192     
     Conv2D-95      [[1, 1024, 14, 14]]    [1, 2048, 7, 7]       2,097,152   
  BatchNorm2D-95     [[1, 2048, 7, 7]]     [1, 2048, 7, 7]         8,192     
BottleneckBlock-31  [[1, 1024, 14, 14]]    [1, 2048, 7, 7]           0       
     Conv2D-99       [[1, 2048, 7, 7]]      [1, 512, 7, 7]       1,048,576   
  BatchNorm2D-99      [[1, 512, 7, 7]]      [1, 512, 7, 7]         2,048     
      ReLU-33        [[1, 2048, 7, 7]]     [1, 2048, 7, 7]           0       
    Conv2D-100        [[1, 512, 7, 7]]      [1, 512, 7, 7]       2,359,296   
  BatchNorm2D-100     [[1, 512, 7, 7]]      [1, 512, 7, 7]         2,048     
    Conv2D-101        [[1, 512, 7, 7]]     [1, 2048, 7, 7]       1,048,576   
  BatchNorm2D-101    [[1, 2048, 7, 7]]     [1, 2048, 7, 7]         8,192     
BottleneckBlock-32   [[1, 2048, 7, 7]]     [1, 2048, 7, 7]           0       
    Conv2D-102       [[1, 2048, 7, 7]]      [1, 512, 7, 7]       1,048,576   
  BatchNorm2D-102     [[1, 512, 7, 7]]      [1, 512, 7, 7]         2,048     
      ReLU-34        [[1, 2048, 7, 7]]     [1, 2048, 7, 7]           0       
    Conv2D-103        [[1, 512, 7, 7]]      [1, 512, 7, 7]       2,359,296   
  BatchNorm2D-103     [[1, 512, 7, 7]]      [1, 512, 7, 7]         2,048     
    Conv2D-104        [[1, 512, 7, 7]]     [1, 2048, 7, 7]       1,048,576   
  BatchNorm2D-104    [[1, 2048, 7, 7]]     [1, 2048, 7, 7]         8,192     
BottleneckBlock-33   [[1, 2048, 7, 7]]     [1, 2048, 7, 7]           0       
AdaptiveAvgPool2D-1  [[1, 2048, 7, 7]]     [1, 2048, 1, 1]           0       
     Linear-1           [[1, 2048]]           [1, 1000]          2,049,000   
     ResNet-1        [[1, 3, 224, 224]]       [1, 1000]              0       
     Linear-2           [[1, 1000]]            [1, 512]           512,512    
      ReLU-35            [[1, 512]]            [1, 512]              0       
     Linear-3            [[1, 512]]            [1, 136]           69,768     
===============================================================================
Total params: 45,236,784
Trainable params: 45,026,096
Non-trainable params: 210,688
-------------------------------------------------------------------------------
Input size (MB): 0.57
Forward/backward pass size (MB): 391.66
Params size (MB): 172.56
Estimated Total Size (MB): 564.80
-------------------------------------------------------------------------------






{'total_params': 45236784, 'trainable_params': 45026096}

四、模型训练

4.1 模型配置

训练模型前，需要设置训练模型所需的优化器，损失函数和评估指标。

优化器：Adam优化器，快速收敛。
损失函数：SmoothL1Loss
评估指标：NME

4.2 自定义评估指标

特定任务的 Metric 计算方式在框架既有的 Metric接口中不存在，或算法不符合自己的需求，那么需要我们自己来进行Metric的自定义。这里介绍如何进行Metric的自定义操作，更多信息可以参考官网文档自定义Metric；首先来看下面的代码。


from paddle.metric import Metric

class NME(Metric):
    """
    1. 继承paddle.metric.Metric
    """
    def __init__(self, name='nme', *args, **kwargs):
        """
        2. 构造函数实现，自定义参数即可
        """
        super(NME, self).__init__(*args, **kwargs)
        self._name = name
        self.rmse = 0
        self.sample_num = 0
    
    def name(self):
        """
        3. 实现name方法，返回定义的评估指标名字
        """
        return self._name
    
    def update(self, preds, labels):
        """
        4. 实现update方法，用于单个batch训练时进行评估指标计算。
        - 当`compute`类函数未实现时，会将模型的计算输出和标签数据的展平作为`update`的参数传入。
        """
        N = preds.shape[0]

        preds = preds.reshape((N, -1, 2))
        labels = labels.reshape((N, -1, 2))

        self.rmse = 0
        
        for i in range(N):
            pts_pred, pts_gt = preds[i, ], labels[i, ]
            interocular = np.linalg.norm(pts_gt[36, ] - pts_gt[45, ])

            self.rmse += np.sum(np.linalg.norm(pts_pred - pts_gt, axis=1)) / (interocular * preds.shape[1])
            self.sample_num += 1

        return self.rmse / N
    
    def accumulate(self):
        """
        5. 实现accumulate方法，返回历史batch训练积累后计算得到的评价指标值。
        每次`update`调用时进行数据积累，`accumulate`计算时对积累的所有数据进行计算并返回。
        结算结果会在`fit`接口的训练日志中呈现。
        """
        return self.rmse / self.sample_num
    
    def reset(self):
        """
        6. 实现reset方法，每个Epoch结束后进行评估指标的重置，这样下个Epoch可以重新进行计算。
        """
        self.rmse = 0
        self.sample_num = 0

作业4：实现模型的配置和训练

# 使用 paddle.Model 封装模型
model = paddle.Model(SimpleNet(key_pts=68))

# 定义Adam优化器
optimizer = paddle.optimizer.Adam(learning_rate=0.001,
                                weight_decay=5e-4,
                                parameters=model.parameters())

# 定义SmoothL1Loss
loss = nn.SmoothL1Loss()

# 使用自定义metrics
metric = NME()

# 配置模型
model.prepare(optimizer=optimizer, loss=loss, metrics=metric)

# 模型训练
# model.fit(train_dataset, epochs=100, batch_size=128, verbose=1)

损失函数的选择：L1Loss、L2Loss、SmoothL1Loss的对比

L1Loss: 在训练后期，预测值与ground-truth差异较小时，损失对预测值的导数的绝对值仍然为1，此时如果学习率不变，损失函数将在稳定值附近波动，难以继续收敛达到更高精度。
L2Loss: 在训练初期，预测值与ground-truth差异较大时，损失函数对预测值的梯度十分大，导致训练不稳定。
SmoothL1Loss: 在x较小时，对x梯度也会变小，而在x很大时，对x的梯度的绝对值达到上限 1，也不会太大以至于破坏网络参数。

4.2 模型训练

 model.fit(train_dataset, epochs=100, batch_size=64, verbose=1)

4.3 模型保存

checkpoints_path = './checkpoints/models'
model.save(checkpoints_path)

五、模型预测

# 定义功能函数

def show_all_keypoints(image, predicted_key_pts):
    """
    展示图像，预测关键点
    Args：
        image：裁剪后的图像 [224, 224, 3]
        predicted_key_pts: 预测关键点的坐标
    """
    # 展示图像
    plt.imshow(image.astype('uint8'))

    # 展示关键点
    for i in range(0, len(predicted_key_pts), 2):
        plt.scatter(predicted_key_pts[i], predicted_key_pts[i+1], s=20, marker='.', c='m')

def visualize_output(test_images, test_outputs, batch_size=1, h=20, w=10):
    """
    展示图像，预测关键点
    Args：
        test_images：裁剪后的图像 [224, 224, 3]
        test_outputs: 模型的输出
        batch_size: 批大小
        h: 展示的图像高
        w: 展示的图像宽
    """

    if len(test_images.shape) == 3:
        test_images = np.array([test_images])

    for i in range(batch_size):

        plt.figure(figsize=(h, w))
        ax = plt.subplot(1, batch_size, i+1)

        # 随机裁剪后的图像
        image = test_images[i]

        # 模型的输出，未还原的预测关键点坐标值
        predicted_key_pts = test_outputs[i]

        # 还原后的真实的关键点坐标值
        predicted_key_pts = predicted_key_pts * data_std + data_mean
        
        # 展示图像和关键点
        show_all_keypoints(np.squeeze(image), predicted_key_pts)
            
        plt.axis('off')

    plt.show()

# 读取图像
img = mpimg.imread('1.jpg')

# 关键点占位符
kpt = np.ones((136, 1))

transform = Compose([Resize(256), RandomCrop(224)])

# 对图像先重新定义大小，并裁剪到 224*224的大小
rgb_img, kpt = transform([img, kpt])

norm = GrayNormalize()
to_chw = ToCHW()

# 对图像进行归一化和格式变换
img, kpt = norm([rgb_img, kpt])
img, kpt = to_chw([img, kpt])

img = np.array([img], dtype='float32')

# 加载保存好的模型进行预测
model = paddle.Model(SimpleNet(key_pts=68))
model.load(checkpoints_path)
model.prepare()

# 预测结果
out = model.predict_batch([img])
out = out[0].reshape((out[0].shape[0], 136, -1))

# 可视化
visualize_output(rgb_img, out, batch_size=1)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-9SjXIt7T-1612608269271)(output_46_0.png)]

# 读取图像
img = mpimg.imread('2.jpg')

# 关键点占位符
kpt = np.ones((136, 1))

transform = Compose([Resize(256), RandomCrop(224)])

# 对图像先重新定义大小，并裁剪到 224*224的大小
rgb_img, kpt = transform([img, kpt])

norm = GrayNormalize()
to_chw = ToCHW()

# 对图像进行归一化和格式变换
img, kpt = norm([rgb_img, kpt])
img, kpt = to_chw([img, kpt])

img = np.array([img], dtype='float32')

# 加载保存好的模型进行预测
model = paddle.Model(SimpleNet(key_pts=68))
model.load(checkpoints_path)
model.prepare()

# 预测结果
out = model.predict_batch([img])
out = out[0].reshape((out[0].shape[0], 136, -1))

# 可视化
visualize_output(rgb_img, out, batch_size=1)

[外链图片转存失败,源站可能有防盗链机制,建议将图片保存下来直接上传(img-Sh3S6sKl-1612608269272)(output_47_0.png)]

六、趣味应用

当我们得到关键点的信息后，就可以进行一些趣味的应用。

# 定义功能函数

def show_fu(image, predicted_key_pts):
    """
    展示加了贴纸的图像
    Args：
        image：裁剪后的图像 [224, 224, 3]
        predicted_key_pts: 预测关键点的坐标
    """
    # 计算坐标，15 和 34点的中间值
    x = (int(predicted_key_pts[28]) + int(predicted_key_pts[66]))//2
    y = (int(predicted_key_pts[29]) + int(predicted_key_pts[67]))//2

    # 打开 春节小图
    star_image = mpimg.imread('light.jpg')

    # 处理通道
    if(star_image.shape[2] == 4):
        star_image = star_image[:,:,1:4]
    
    # 将春节小图放到原图上
    image[y:y+len(star_image[0]), x:x+len(star_image[1]),:] = star_image
    
    # 展示处理后的图片
    plt.imshow(image.astype('uint8'))

    # 展示关键点信息
    for i in range(len(predicted_key_pts)//2,):
        plt.scatter(predicted_key_pts[i*2], predicted_key_pts[i*2+1], s=20, marker='.', c='m') # 展示关键点信息


def custom_output(test_images, test_outputs, batch_size=1, h=20, w=10):
    """
    展示图像，预测关键点
    Args：
        test_images：裁剪后的图像 [224, 224, 3]
        test_outputs: 模型的输出
        batch_size: 批大小
        h: 展示的图像高
        w: 展示的图像宽
    """

    if len(test_images.shape) == 3:
        test_images = np.array([test_images])

    for i in range(batch_size):

        plt.figure(figsize=(h, w))
        ax = plt.subplot(1, batch_size, i+1)

        # 随机裁剪后的图像
        image = test_images[i]

        # 模型的输出，未还原的预测关键点坐标值
        predicted_key_pts = test_outputs[i]

        # 还原后的真实的关键点坐标值
        predicted_key_pts = predicted_key_pts * data_std + data_mean
        
        # 展示图像和关键点
        show_fu(np.squeeze(image), predicted_key_pts)
            
        plt.axis('off')

    plt.show()

# 读取图像
img = mpimg.imread('xiaojiejie.jpg')

# 关键点占位符
kpt = np.ones((136, 1))

transform = Compose([Resize(256), RandomCrop(224)])

# 对图像先重新定义大小，并裁剪到 224*224的大小
rgb_img, kpt = transform([img, kpt])

norm = GrayNormalize()
to_chw = ToCHW()

# 对图像进行归一化和格式变换
img, kpt = norm([rgb_img, kpt])
img, kpt = to_chw([img, kpt])

img = np.array([img], dtype='float32')

# 加载保存好的模型进行预测
# model = paddle.Model(SimpleNet())
# model.load(checkpoints_path)
# model.prepare()

# 预测结果
out = model.predict_batch([img])
out = out[0].reshape((out[0].shape[0], 136, -1))

# 可视化
custom_output(rgb_img, out, batch_size=1)

你可能感兴趣的:(paddlepaddle)

NLP_jieba中文分词的常用模块 Hiweir · NLP_jieba的使用自然语言处理中文分词人工智能 nlp
1.jieba分词模式（1）精确模式:把句子最精确的切分开,比较适合文本分析.默认精确模式.（2）全模式:把句子中所有可能成词的词都扫描出来,cut_all=True,缺点:速度快,不能解决歧义（3）paddle:利用百度的paddlepaddle深度学习框架.简单来说就是使用百度提供的分词模型.use_paddle=True.（4）搜索引擎模式:在精确模式的基础上,对长词再进行切分,提高召回率,
【Python】已解决：ModuleNotFoundError: No module named ‘paddle‘ 屿小夏 python paddle 开发语言
文章目录一、分析问题背景二、可能出错的原因三、错误代码示例四、正确代码示例步骤1：安装PaddlePaddle库步骤2：验证安装五、注意事项已解决：ModuleNotFoundError:Nomodulenamed‘paddle‘一、分析问题背景在使用Python进行深度学习开发时，开发者可能会选择使用PaddlePaddle作为深度学习框架。然而，有时在导入PaddlePaddle库时，可能会遇
Python包的安装 weixin_38778542 Python 包 python anaconda
只是在包装paddlepaddle包的时候，使用官方推荐的命令使用安装失败。大概看了一下，是其他的一些支持的包安装失败，要么是找不到，要么是版本问题，要么是自己网速差……自己又看不明白，或者是静不下心来仔细去查找问题，所以开了这个帖子，希望来记录一下学习Python中，在关于一些包的安装使用上的问题。同时也欢迎大家参与讨论。现在正在安装paddlepaddle以及其支持的包，主要学习https:/
震惊！PaddlePaddle竟然支持Python 3.7了！高斯纯牛奶
震惊！****PaddlePaddle****竟然支持****Python3.7****了！image这个2018，如果你还不知道这件事情，你就真的OUT了！几天之前，一条PaddlePaddle版本发布的消息，让开发者QQ群里的成员又惊又喜：PaddlePaddle支持了Python3.7。在外人看来，PaddlePaddle就像一位用情专一的“钢铁直男“，长久以来一直钟情于Python2.7，
PaddleOCR超大分辨率文本检测代码教程 LEILEI18A Python 深度学习 paddle paddleocr ppocr 超大分辨率文本检测
PaddleOCR超大分辨率文本检测代码教程目录1.前提2.PaddleOCR部署（win10下）3.解决思路和代码1.前提这是我提的issue：https://github.com/PaddlePaddle/PaddleOCR/issues/11888很多问题可以看：https://github.com/PaddlePaddle/PaddleOCR/blob/release/2.7/doc/do
百度飞浆目标检测PPYOLOE模型在PC端、Jetson上的部署（python）代码能跑就可以百度目标检测 python 学习计算机视觉笔记
部署目标检测模型前，需要配置好paddlepaddle的环境：开始使用_飞桨-源于产业实践的开源深度学习平台(paddlepaddle.org.cn)PC端和Jetson板卡端的部署方法相同，如下（直接放置部署和测试代码）：importpaddle.inferenceimportcv2importnumpyasnpimporttimefrompaddle.inferenceimportConfig
百度飞桨教程（一）怎么这么多名字都被占了百度 paddlepaddle 人工智能
百度飞桨（paddle），是一个开源的深度学习平台百度飞桨的安装pipinstallpaddlepaddle-ihttps://mirror.baidu.com/pypi/simple手写数字识别案例我们来通过一个案例，大概了解paddle的使用importpaddleimportnumpyasnpfrompaddle.vision.transformsimportNormalizetransfo
Python，Nuitka，打包Paddle和Paddleocr，test.dist\\paddle\\fluid\\..\\libs‘；飞天小女警出击 python paddle 开发语言
Python版本3.9，Nuitka版本1.8.6，paddleocr版本2.6.1.3，paddlepaddle版本2.5.2Nuitka打包后提示报错File"C:\Users\Administrator\Desktop\XXX\XXX\test.dist\os.py",line1111,inadd_dll_directoryFileNotFoundError:[WinError2]系统找不到
ubuntu18.04+cuda11.4+nccl安装袁泽斌的学习记录 ubuntu
本文参考自，但更加详细的介绍了安装方法，避免走弯路ubuntu下安装nccl具体教程_ubuntu安装nccl-CSDN博客文章浏览阅读1w次，点赞5次，收藏12次。使用paddlepaddle框架进行多卡训练时报错：Traceback(mostrecentcalllast):File"train.py",line210,indo_train()File"train.py",line91,indo
飞桨科学计算套件PaddleScience skywalk8163 人工智能 paddlepaddle 人工智能飞桨
PaddleScience是一个基于深度学习框架PaddlePaddle开发的科学计算套件，利用深度神经网络的学习能力和PaddlePaddle框架的自动(高阶)微分机制，解决物理、化学、气象等领域的问题。支持物理机理驱动、数据驱动、数理融合三种求解方式，并提供了基础API和详尽文档供用户使用与二次开发。安装当然要先安装好飞桨PaddlePaddle，再安装PaddleSciencepipinst
TechDay公开课实录:PaddlePaddle车牌识别实战和心得 PaddleWeekly
车牌识别作为一种常见的图像识别的应用场景，已经是一个非常成熟的业务了，在传统的车牌识别中，可以使用字符分割+字符识别的方式来进行车牌识别，而深度学习兴起后，出现了很多端到端的车牌识别模型，不用分割字符，直接输入车牌图片即可识别出车牌字符。2019年1月5日百度深度学习线下技术公开课PaddlePaddleTechDay第一期演讲则邀请了百度认证布道师胡晓曼老师分享基于PaddlePaddle最新版
基于Python的paddleocr推理环境列表博观而约取,厚积而薄发 PaddlePaddle python 开发语言
基于Python的paddleocr推理环境列表，#Python==3.9.13，安装目录名不能太长#单独导入python-mpipinstallpaddlepaddle-gpu==2.6.0.post120-fhttps://www.paddlepaddle.org.cn/whl/windows/mkl/avx/stable.htmlopencv-pythonlmdbimgaugscikit-i
pip安装paddlepaddle报错ERROR: Could not install packages due to an OSError 博观而约取,厚积而薄发 PaddlePaddle pip
ERROR:CouldnotinstallpackagesduetoanOSError:[Errno2]Nosuchfileordirectory:'C:\\Users\\yang\\AppData\\Local\\Packages\\PythonSoftwareFoundation.Python.3.9_qbz5n2kfra8p0\\LocalCache\\local-packages\\Pyt
paddlepaddle 2.6版本在WSL2环境中如何使用NVIDIA显卡运行神经网络 kampoo paddlepaddle 神经网络人工智能
paddlepaddle2.6版本发布后，官网上可以使用NVIDIAcuda12.x进行机器学习了，训练神经网络的效率大为提升。因为是在wsl2环境中安装，不是纯正的linux环境，其中一些小问题需要注意。使用conda安装飞浆，wsl2中安装了cuda12.x，跟飞浆2.6兼容，按照官网指令即可：condacreate-npp2cudapython=3.11condaactivatepp2cud
概率论与数理统计实验附源码及实验报告可打包为exe 货又星概率论经验分享笔记 python 开源
Hi,I’m@货又星I’minterestedin…I’mcurrentlylearning…I’mlookingtocollaborateon…Howtoreachme…README目录（持续更新中）各种错误处理、爬虫实战及模板、百度智能云人脸识别、计算机视觉深度学习CNN图像识别与分类、PaddlePaddle自然语言处理知识图谱、GitHub、运维…WeChat：1297767084GitH
【新手必看】解决GitHub打不开问题，亲测有效货又星 github 笔记经验分享 python 开源开源软件
Hi,I’m@货又星I’minterestedin…I’mcurrentlylearning…I’mlookingtocollaborateon…Howtoreachme…README目录（持续更新中）各种错误处理、爬虫实战及模板、百度智能云人脸识别、计算机视觉深度学习CNN图像识别与分类、PaddlePaddle自然语言处理知识图谱、GitHub、运维…WeChat：1297767084GitH
使用ssh链接GitHub，附GitHub命令货又星 ssh github 运维笔记经验分享开源
Hi,I’m@货又星I’minterestedin…I’mcurrentlylearning…I’mlookingtocollaborateon…Howtoreachme…README目录（持续更新中）各种错误处理、爬虫实战及模板、百度智能云人脸识别、计算机视觉深度学习CNN图像识别与分类、PaddlePaddle自然语言处理知识图谱、GitHub、运维…WeChat：1297767084GitH
NSsimulation：使用python模拟Navier-Stokes equations（ns方程），附项目GitHub地址，亲测可用。（2023 apmcm、2024美赛）货又星 python github 开发语言笔记数学建模开源
Hi,I’m@货又星I’minterestedin…I’mcurrentlylearning…I’mlookingtocollaborateon…Howtoreachme…README目录（持续更新中）各种错误处理、爬虫实战及模板、百度智能云人脸识别、计算机视觉深度学习CNN图像识别与分类、PaddlePaddle自然语言处理知识图谱、GitHub、运维…WeChat：1297767084GitH
PaddleNLP 自然语言处理知识图谱 uie-x-base,uie-m-large,uie-m-base模型使用时，报错Out of memory error on GPU 0 gpu内存不够货又星自然语言处理语言模型人工智能运维知识图谱 nlp gpt-3
Hi,I’m@货又星I’minterestedin…I’mcurrentlylearning…️I’mlookingtocollaborateon…Howtoreachme…README目录（持续更新中）各种错误处理、爬虫实战及模板、百度智能云人脸识别、计算机视觉深度学习CNN图像识别与分类、PaddlePaddle自然语言处理知识图谱、GitHub、运维…WeChat：1297767084Git
基于PaddlePaddle2.0的蝴蝶图像识别分类 bianhuaHYQ 笔记 python 图像识别人工智能
基于PaddlePaddle2.0的蝴蝶图像识别分类——利用预训练残差网络ResNet101模型分类资源来源如下：https://aistudio.baidu.com/aistudio/education/group/info/119391.蝴蝶识别分类任务概述本项目将利用人工智能技术来对蝴蝶图像进行分类，需要能对蝴蝶的类别、属性进行细粒度的识别分类。相关研究工作者能够根据采集到的蝴蝶图片，快速识
TechDay公开课实录:PaddlePaddle车牌识别实战和心得 PaddlePaddle
车牌识别作为一种常见的图像识别的应用场景，已经是一个非常成熟的业务了，在传统的车牌识别中，可以使用字符分割+字符识别的方式来进行车牌识别，而深度学习兴起后，出现了很多端到端的车牌识别模型，不用分割字符，直接输入车牌图片即可识别出车牌字符。2019年1月5日百度深度学习线下技术公开课PaddlePaddleTechDay第一期演讲则邀请了百度认证布道师胡晓曼老师分享基于PaddlePaddle最新版
在训练过程中报显存不足该怎么办呢？- PaddlePaddle 飞桨 FAQ合集 - 训练问题5 GT_Zhang
PaddlePaddle飞桨FAQ合集-训练问题5Question：在训练过程中报显存不足该怎么办呢？Answer:训练中报显存不足是很正常的情况，你可以尝试调整BatchSize的大小，也可以更改网络模型，或者参考官方文档的显存优化部分。其实我们更推荐去使用AIStudio去训练，配备高端显卡，速度也是杠杠的。
Python OCR 之旅：PaddleOCR 与 pytesseract 比较及应用田猿笔记 python ocr 开发语言
简介：在Python技术栈中，光学字符识别（OCR）是一个非常实用的功能，它可以将图片中的文本内容提取出来。在这篇文章中，我们将比较两个常用的OCR库：PaddleOCR和pytesseract，了解它们的特点、功能以及应用场景。一、PaddleOCR介绍PaddleOCR是一个基于PaddlePaddle深度学习框架的OCR库，支持多种语言的文本识别。它的特点如下：-使用了基于深度学习的OCR模
训练版paddleOCR代码讲解修改枭玉龙 #python图像处理 python
paddleOCR下载：pipinstallpaddlepaddle-gpu==2.0.0rc0.post100-fhttps://paddlepaddle.org.cn/whl/stable.htmlLookinginlinks:https://paddlepaddle.org.cn/whl/stable.html训练det目标检测1：修改tools中的program中的要训练的参数：det和r
百度PaddleOCR字符识别推理部署（C++）枭玉龙百度 c++开发语言
1环境1.opencv（https://sourceforge.net/projects/opencvlibrary/）2.cmake（https://cmake.org/download/）3.vs2019（(https://github.com/PaddlePaddle/PaddleOCR/tree/release/2.1)4.paddleOCR项目-建议2.0(https://github.
orin nx 安装paddlespeech记录想努力的人算法语音合成人工智能
nx配置：模块版本说明CPU8核内存16GCuda版本11.4Opencv版本4.5.4Tensorrt版本5.1Cudnn版本8.6.0.166Deepstream版本6.2Python版本3.8算力100T安装paddlepaddle：去飞桨官网下载jetpack版本的：下载安装Linux推理库-PaddlePaddle深度学习平台当需要调用语速的接口时：需要安装soxbindings包，这个
飞桨自然语言处理框架 paddlenlp的 trainer 路人与大师 paddlepaddle 自然语言处理人工智能
飞桨（PaddlePaddle）的NLP库PaddleNLP中的Trainer类是一个用于训练和评估模型的简单但功能完整的循环。它被优化用于与PaddleNLP一起使用。Trainer类简化了训练过程，提供了自动的批处理、模型保存、日志记录等特性。以下是Trainer类的主要参数和功能：模型：model：可以是一个预训练的模型或一个自定义的paddle.nn.Layer。如果使用自定义模型，它需要
使用PaddleNLP识别垃圾邮件：用ELECTRA做英文邮件标题分类，英文邮件短标题的分类效果能达到92%以上以及如何使用PaddleNLP加载和微调ELECTRA模型？（附公开数据集）代码讲故事机器人智慧之心分类数据挖掘 ELECTRA PaddleNLP NLP 垃圾邮件邮件识别
使用PaddleNLP识别垃圾邮件：用ELECTRA做英文邮件标题分类，英文邮件短标题的分类效果能达到92%以上以及如何使用PaddleNLP加载和微调ELECTRA模型？（附公开数据集）要使用PaddleNLP和ELECTRA来识别垃圾邮件并做英文邮件标题分类，可以按照以下步骤进行操作：安装PaddlePaddle和PaddleNLP：首先，确保在你的环境中已经安装了PaddlePaddle和P
使用PaddleNLP识别垃圾邮件：用RoBERTa做中文邮件标题分类，模型在测试集上准确率达到98.3%以上（附公开数据集）代码讲故事机器人智慧之心分类数据挖掘 RoBERTa 垃圾邮件机器学习深度学习 PaddleNLP
使用PaddleNLP识别垃圾邮件：用RoBERTa做中文邮件标题分类，模型在测试集上准确率达到98.3%以上（附公开数据集）。要使用PaddleNLP和RoBERTa来识别垃圾邮件并做中文邮件标题分类，可以按照以下步骤进行操作：安装PaddlePaddle和PaddleNLP：首先，确保在你的环境中已经安装了PaddlePaddle和PaddleNLP。你可以根据PaddlePaddle和Pad
使用PaddleNLP识别垃圾邮件：用BERT做中文邮件内容分类，验证集准确率高达99.6%以上（附公开数据集）代码讲故事机器人智慧之心 bert 分类 PaddleNLP NLP 垃圾邮件邮件识别深度学习
使用PaddleNLP识别垃圾邮件：用BERT做中文邮件内容分类，验证集准确率高达99.6%以上（附公开数据集）。要使用PaddleNLP和BERT来识别垃圾邮件并做中文邮件内容分类，可以按照以下步骤进行操作：安装PaddlePaddle和PaddleNLP：首先，确保在你的环境中已经安装了PaddlePaddle和PaddleNLP。你可以根据PaddlePaddle和PaddleNLP的官方文
Maven Array_06 eclipse jdk maven
Maven Maven是基于项目对象模型(POM)，信息来管理项目的构建，报告和文档的软件项目管理工具。 Maven 除了以程序构建能力为特色之外，还提供高级项目管理工具。由于 Maven 的缺省构建规则有较高的可重用性，所以常常用两三行 Maven 构建脚本就可以构建简单的项目。由于 Maven 的面向项目的方法，许多 Apache Jakarta 项目发文时使用 Maven，而且公司
ibatis的queyrForList和queryForMap区别 bijian1013 java ibatis
一.说明 iBatis的返回值参数类型也有种：resultMap与resultClass，这两种类型的选择可以用两句话说明之： 1.当结果集列名和类的属性名完全相对应的时候，则可直接用resultClass直接指定查询结果类
LeetCode[位运算] - #191 计算汉明权重 Cwind java 位运算 LeetCode Algorithm 题解
原题链接：#191 Number of 1 Bits 要求：写一个函数，以一个无符号整数为参数，返回其汉明权重。例如，‘11’的二进制表示为'00000000000000000000000000001011', 故函数应当返回3。汉明权重：指一个字符串中非零字符的个数；对于二进制串，即其中‘1’的个数。难度：简单分析：将十进制参数转换为二进制，然后计算其中1的个数即可。 “
浅谈java类与对象 15700786134 java
java是一门面向对象的编程语言，类与对象是其最基本的概念。所谓对象，就是一个个具体的物体，一个人，一台电脑，都是对象。而类，就是对象的一种抽象，是多个对象具有的共性的一种集合，其中包含了属性与方法，就是属于该类的对象所具有的共性。当一个类创建了对象，这个对象就拥有了该类全部的属性，方法。相比于结构化的编程思路，面向对象更适用于人的思维
linux下双网卡同一个IP 被触发 linux
转自： http://q2482696735.blog.163.com/blog/static/250606077201569029441/ 由于需要一台机器有两个网卡，开始时设置在同一个网段的IP，发现数据总是从一个网卡发出，而另一个网卡上没有数据流动。网上找了下，发现相同的问题不少：一、关于双网卡设置同一网段IP然后连接交换机的时候出现的奇怪现象。当时没有怎么思考、以为是生成树
安卓按主页键隐藏程序之后无法再次打开肆无忌惮_ 安卓
遇到一个奇怪的问题，当SplashActivity跳转到MainActivity之后，按主页键，再去打开程序，程序没法再打开（闪一下），结束任务再开也是这样，只能卸载了再重装。而且每次在Log里都打印了这句话"进入主程序"。后来发现是必须跳转之后再finish掉SplashActivity 本来代码： // 销毁这个Activity fin
通过cookie保存并读取用户登录信息实例知了ing JavaScript html
通过cookie的getCookies()方法可获取所有cookie对象的集合；通过getName()方法可以获取指定的名称的cookie；通过getValue()方法获取到cookie对象的值。另外，将一个cookie对象发送到客户端，使用response对象的addCookie()方法。下面通过cookie保存并读取用户登录信息的例子加深一下理解。（1）创建index.jsp文件。在改
JAVA 对象池矮蛋蛋 java ObjectPool
原文地址： http://www.blogjava.net/baoyaer/articles/218460.html Jakarta对象池 ☆为什么使用对象池恰当地使用对象池化技术，可以有效地减少对象生成和初始化时的消耗，提高系统的运行效率。Jakarta Commons Pool组件提供了一整套用于实现对象池化
ArrayList根据条件+for循环批量删除的方法 alleni123 java
场景如下： ArrayList<Obj> list Obj-> createTime, sid. 现在要根据obj的createTime来进行定期清理。（释放内存） ------------------------- 首先想到的方法就是 for(Obj o:list){ if(o.createTime-currentT>xxx){
阿里巴巴“耕地宝”大战各种宝百合不是茶平台战略
“耕地保”平台是阿里巴巴和安徽农民共同推出的一个 “首个互联网定制私人农场”，“耕地宝”由阿里巴巴投入一亿，主要是用来进行农业方面，将农民手中的散地集中起来不仅加大农民集体在土地上面的话语权，还增加了土地的流通与利用率，提高了土地的产量，有利于大规模的产业化的高科技农业的发展，阿里在农业上的探索将会引起新一轮的产业调整，但是集体化之后农民的个体的话语权将更少，国家应出台相应的法律法规保护
Spring注入有继承关系的类（1） bijian1013 java spring
一个类一个类的注入 1.AClass类 package com.bijian.spring.test2; public class AClass { String a; String b; public String getA() { return a; } public void setA(Strin
30岁转型期你能否成为成功人士 bijian1013 成功
很多人由于年轻时走了弯路，到了30岁一事无成，这样的例子大有人在。但同样也有一些人，整个职业生涯都发展得很优秀，到了30岁已经成为职场的精英阶层。由于做猎头的原因，我们接触很多30岁左右的经理人，发现他们在职业发展道路上往往有很多致命的问题。在30岁之前，他们的职业生涯表现很优秀，但从30岁到40岁这一段，很多人
[Velocity三]基于Servlet+Velocity的web应用 bit1129 velocity
什么是VelocityViewServlet 使用org.apache.velocity.tools.view.VelocityViewServlet可以将Velocity集成到基于Servlet的web应用中，以Servlet+Velocity的方式实现web应用 Servlet + Velocity的一般步骤 1.自定义Servlet，实现VelocityViewServl
【Kafka十二】关于Kafka是一个Commit Log Service bit1129 service
Kafka is a distributed, partitioned, replicated commit log service.这里的commit log如何理解？ A message is considered "committed" when all in sync replicas for that partition have applied i
NGINX + LUA实现复杂的控制 ronin47 lua nginx 控制
安装lua_nginx_module 模块 lua_nginx_module 可以一步步的安装，也可以直接用淘宝的OpenResty Centos和debian的安装就简单了。。这里说下freebsd的安装： fetch http://www.lua.org/ftp/lua-5.1.4.tar.gz tar zxvf lua-5.1.4.tar.gz cd lua-5.1.4 ma
java-14.输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字 bylijinnan java
public class TwoElementEqualSum { /** * 第 14 题：题目：输入一个已经按升序排序过的数组和一个数字，在数组中查找两个数，使得它们的和正好是输入的那个数字。要求时间复杂度是 O(n) 。如果有多对数字的和等于输入的数字，输出任意一对即可。例如输入数组 1 、 2 、 4 、 7 、 11 、 15 和数字 15 。由于
Netty源码学习-HttpChunkAggregator-HttpRequestEncoder-HttpResponseDecoder bylijinnan java netty
今天看Netty如何实现一个Http Server org.jboss.netty.example.http.file.HttpStaticFileServerPipelineFactory： pipeline.addLast("decoder", new HttpRequestDecoder()); pipeline.addLast(&quo
java敏感词过虑-基于多叉树原理 cngolon 违禁词过虑替换违禁词敏感词过虑多叉树
基于多叉树的敏感词、关键词过滤的工具包，用于java中的敏感词过滤 1、工具包自带敏感词词库，第一次调用时读入词库，故第一次调用时间可能较长，在类加载后普通pc机上html过滤5000字在80毫秒左右，纯文本35毫秒左右。 2、如需自定义词库，将jar包考入WEB-INF工程的lib目录，在WEB-INF/classes目录下建一个 utf-8的words.dict文本文件，
多线程知识 cuishikuan 多线程
T1，T2，T3三个线程工作顺序，按照T1，T2，T3依次进行 public class T1 implements Runnable{ @Override
spring整合activemq dalan_123 java spring jms
整合spring和activemq需要搞清楚如下的东东1、ConnectionFactory分： a、spring管理连接到activemq服务器的管理ConnectionFactory也即是所谓产生到jms服务器的链接 b、真正产生到JMS服务器链接的ConnectionFactory还得
MySQL时间字段究竟使用INT还是DateTime？ dcj3sjt126com mysql
环境：Windows XPPHP Version 5.2.9MySQL Server 5.1 第一步、创建一个表date_test（非定长、int时间） CREATE TABLE `test`.`date_test` (`id` INT NOT NULL AUTO_INCREMENT ,`start_time` INT NOT NULL ,`some_content`
Parcel: unable to marshal value dcj3sjt126com marshal
在两个activity直接传递List<xxInfo>时，出现Parcel: unable to marshal value异常。在MainActivity页面（MainActivity页面向NextActivity页面传递一个List<xxInfo>）： Intent intent = new Intent(this, Next
linux进程的查看上（ps） eksliang linux ps linux ps -l linux ps aux
ps:将某个时间点的进程运行情况选取下来转载请出自出处：http://eksliang.iteye.com/admin/blogs/2119469 http://eksliang.iteye.com ps 这个命令的man page 不是很好查阅，因为很多不同的Unix都使用这儿ps来查阅进程的状态，为了要符合不同版本的需求，所以这个
为什么第三方应用能早于System的app启动 gqdy365 System
Android应用的启动顺序网上有一大堆资料可以查阅了，这里就不细述了，这里不阐述ROM启动还有bootloader，软件启动的大致流程应该是启动kernel -> 运行servicemanager 把一些native的服务用命令启动起来（包括wifi, power, rild, surfaceflinger, mediaserver等等）-> 启动Dalivk中的第一个进程Zygot
App Framework发送JSONP请求(3) hw1287789687 jsonp 跨域请求发送jsonp ajax请求越狱请求
App Framework 中如何发送JSONP请求呢? 使用jsonp,详情请参考:http://json-p.org/ 如何发送Ajax请求呢? (1)登录 /*** * 会员登录 * @param username * @param password */ var user_login=function(username,password){ // aler
发福利，整理了一份关于“资源汇总”的汇总 justjavac 资源
觉得有用的话，可以去github关注：https://github.com/justjavac/awesome-awesomeness-zh_CN 通用 free-programming-books-zh_CN 免费的计算机编程类中文书籍精彩博客集合 hacke2/hacke2.github.io#2 ResumeSample 程序员简历
用 Java 技术创建 RESTful Web 服务 macroli java 编程 Web REST
转载：http://www.ibm.com/developerworks/cn/web/wa-jaxrs/ JAX-RS (JSR-311) 【 Java API for RESTful Web Services 】是一种 Java™ API，可使 Java Restful 服务的开发变得迅速而轻松。这个 API 提供了一种基于注释的模型来描述分布式资源。注释被用来提供资源的位
CentOS6.5-x86_64位下oracle11g的安装详细步骤及注意事项超声波 oracle linux
前言：这两天项目要上线了，由我负责往服务器部署整个项目，因此首先要往服务器安装oracle，服务器本身是CentOS6.5的64位系统，安装的数据库版本是11g，在整个的安装过程中碰到很多的坑，不过最后还是通过各种途径解决并成功装上了。转别写篇博客来记录完整的安装过程以及在整个过程中的注意事项。希望对以后那些刚刚接触的菜鸟们能起到一定的帮助作用。安装过程中可能遇到的问题（注
HttpClient 4.3 设置keeplive 和 timeout 的方法 supben httpclient
ConnectionKeepAliveStrategy kaStrategy = new DefaultConnectionKeepAliveStrategy() { @Override public long getKeepAliveDuration(HttpResponse response, HttpContext context) { long keepAlive
Spring 4.2新特性-@Import注解的升级 wiselyman spring 4
3.1 @Import @Import注解在4.2之前只支持导入配置类在4.2,@Import注解支持导入普通的java类,并将其声明成一个bean 3.2 示例演示java类 package com.wisely.spring4_2.imp; public class DemoService { public void doSomethin