Skip to content

P
PaddleHub

PaddlePaddle / PaddleHub
大约 2 年 前同步成功

通知 285
Star 12117
Fork 2091
P
PaddleHub
未验证 提交 2fd801c3 编写于 作者: W wuzewu 提交者： GitHub
浏览文件
操作

Update image classification module docs (#1614)

上级 b0d82b3d
展开全部 显示空白变更内容
内联 并排
Showing with 3770 addition and 4089 deletion
modules/image/classification/ghostnet_x0_5_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # ghostnet_x0_5_imagenet
$ hub install ghostnet_x0_5_imagenet==1.0.0
```
## 命令行预测 |模型名称|ghostnet_x0_5_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|GhostNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|15MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run ghostnet_x0_5_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - GhostNet是华为在2020年提出的全新轻量级网络结构，通过引入ghost模块，大大缓解了传统深度网络中特征的冗余计算问题，大大减少了网络参数和计算量。
model = hub.Module(name='ghostnet_x0_5_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install ghostnet_x0_5_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run ghostnet_x0_5_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='ghostnet_x0_5_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='ghostnet_x0_5_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x0_5_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="ghostnet_x0_5_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='ghostnet_x0_5_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='ghostnet_x0_5_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m ghostnet_x0_5_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m ghostnet_x0_5_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/ghostnet_x0_5_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/ghostnet_x0_5_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/ghostnet_x1_0_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # ghostnet_x1_0_imagenet
$ hub install ghostnet_x1_0_imagenet==1.0.0
```
## 命令行预测 |模型名称|ghostnet_x1_0_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|GhostNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|30MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run ghostnet_x1_0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - GhostNet是华为在2020年提出的全新轻量级网络结构，通过引入ghost模块，大大缓解了传统深度网络中特征的冗余计算问题，大大减少了网络参数和计算量。
model = hub.Module(name='ghostnet_x1_0_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install ghostnet_x1_0_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run ghostnet_x1_0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='ghostnet_x1_0_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='ghostnet_x1_0_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x1_0_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="ghostnet_x1_0_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='ghostnet_x1_0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='ghostnet_x1_0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m ghostnet_x1_0_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m ghostnet_x1_0_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/ghostnet_x1_0_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/ghostnet_x1_0_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/ghostnet_x1_3_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # ghostnet_x1_3_imagenet
$ hub install ghostnet_x1_3_imagenet==1.0.0
```
## 命令行预测 |模型名称|ghostnet_x1_3_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|GhostNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|43MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run ghostnet_x1_3_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - GhostNet是华为在2020年提出的全新轻量级网络结构，通过引入ghost模块，大大缓解了传统深度网络中特征的冗余计算问题，大大减少了网络参数和计算量。
model = hub.Module(name='ghostnet_x1_3_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install ghostnet_x1_3_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run ghostnet_x1_3_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='ghostnet_x1_3_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='ghostnet_x1_3_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x1_3_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="ghostnet_x1_3_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='ghostnet_x1_3_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='ghostnet_x1_3_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m ghostnet_x1_3_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m ghostnet_x1_3_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/ghostnet_x1_3_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/ghostnet_x1_3_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/ghostnet_x1_3_imagenet_ssld/README.md
浏览文件 @ 2fd801c3
```shell # ghostnet_x1_3_imagenet_ssld
$ hub install ghostnet_x1_3_imagenet_ssld==1.0.0
```
## 命令行预测 |模型名称|ghostnet_x1_3_imagenet_ssld|
| :--- | :---: |
|类别|图像-图像分类|
|网络|GhostNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|43MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run ghostnet_x1_3_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - GhostNet是华为在2020年提出的全新轻量级网络结构，通过引入ghost模块，大大缓解了传统深度网络中特征的冗余计算问题，大大减少了网络参数和计算量。
model = hub.Module(name='ghostnet_x1_3_imagenet_ssld',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install ghostnet_x1_3_imagenet_ssld
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run ghostnet_x1_3_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='ghostnet_x1_3_imagenet_ssld')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='ghostnet_x1_3_imagenet_ssld', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x1_3_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="ghostnet_x1_3_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='ghostnet_x1_3_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='ghostnet_x1_3_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m ghostnet_x1_3_imagenet_ssld
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m ghostnet_x1_3_imagenet_ssld
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/ghostnet_x1_3_imagenet_ssld"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/ghostnet_x1_3_imagenet_ssld" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/hrnet18_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # hrnet18_imagenet
$ hub install hrnet18_imagenet==1.0.0
```
## 命令行预测 |模型名称|hrnet18_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|HRNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|124MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run hrnet18_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
model = hub.Module(name='hrnet18_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install hrnet18_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run hrnet18_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='hrnet18_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='hrnet18_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet18_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="hrnet18_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='hrnet18_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='hrnet18_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m hrnet18_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m hrnet18_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/hrnet18_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/hrnet18_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/hrnet18_imagenet_ssld/README.md
浏览文件 @ 2fd801c3
```shell # hrnet18_imagenet_ssld
$ hub install hrnet18_imagenet_ssld==1.0.0
```
## 命令行预测 |模型名称|hrnet18_imagenet_ssld|
| :--- | :---: |
|类别|图像-图像分类|
|网络|HRNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|124MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run hrnet18_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
model = hub.Module(name='hrnet18_imagenet_ssld',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install hrnet18_imagenet_ssld
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run hrnet18_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='hrnet18_imagenet_ssld')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='hrnet18_imagenet_ssld', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet18_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="hrnet18_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='hrnet18_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='hrnet18_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m hrnet18_imagenet_ssld
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m hrnet18_imagenet_ssld
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/hrnet18_imagenet_ssld"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/hrnet18_imagenet_ssld" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/hrnet30_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # hrnet30_imagenet
$ hub install hrnet30_imagenet==1.0.0
```
## 命令行预测 |模型名称|hrnet30_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|HRNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|218MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run hrnet30_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
model = hub.Module(name='hrnet30_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install hrnet30_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run hrnet30_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='hrnet30_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='hrnet30_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet30_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="hrnet30_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='hrnet30_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='hrnet30_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m hrnet30_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m hrnet30_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/hrnet30_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/hrnet30_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/hrnet32_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # hrnet32_imagenet
$ hub install hrnet32_imagenet==1.0.0
```
## 命令行预测 |模型名称|hrnet32_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|HRNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|238MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run hrnet32_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
model = hub.Module(name='hrnet32_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install hrnet32_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run hrnet32_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='hrnet32_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='hrnet32_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet32_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="hrnet32_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='hrnet32_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='hrnet32_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m hrnet32_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m hrnet32_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/hrnet32_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/hrnet32_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/hrnet40_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # hrnet40_imagenet
$ hub install hrnet40_imagenet==1.0.0
```
## 命令行预测 |模型名称|hrnet40_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|HRNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|333MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run hrnet40_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
model = hub.Module(name='hrnet40_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install hrnet40_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run hrnet40_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='hrnet40_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='hrnet40_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet40_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="hrnet40_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='hrnet40_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='hrnet40_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m hrnet40_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m hrnet40_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/hrnet40_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/hrnet40_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/hrnet44_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # hrnet44_imagenet
$ hub install hrnet44_imagenet==1.0.0
```
## 命令行预测 |模型名称|hrnet44_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|HRNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|388MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run hrnet44_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
model = hub.Module(name='hrnet44_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install hrnet44_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run hrnet44_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='hrnet44_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='hrnet44_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet44_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="hrnet44_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='hrnet44_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='hrnet44_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m hrnet44_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m hrnet44_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/hrnet44_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/hrnet44_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/hrnet48_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # hrnet48_imagenet
$ hub install hrnet48_imagenet==1.0.0
```
## 命令行预测 |模型名称|hrnet48_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|HRNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|448MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run hrnet48_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
model = hub.Module(name='hrnet48_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install hrnet48_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run hrnet48_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='hrnet48_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='hrnet48_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet48_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="hrnet48_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='hrnet48_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='hrnet48_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m hrnet48_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m hrnet48_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/hrnet48_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/hrnet48_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/hrnet48_imagenet_ssld/README.md
浏览文件 @ 2fd801c3
```shell # hrnet48_imagenet_ssld
$ hub install hrnet48_imagenet_ssld==1.0.0
```
## 命令行预测 |模型名称|hrnet48_imagenet_ssld|
| :--- | :---: |
|类别|图像-图像分类|
|网络|HRNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|446MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run hrnet48_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
model = hub.Module(name='hrnet48_imagenet_ssld',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install hrnet48_imagenet_ssld
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run hrnet48_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='hrnet48_imagenet_ssld')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='hrnet48_imagenet_ssld', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet48_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="hrnet48_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='hrnet48_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='hrnet48_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m hrnet48_imagenet_ssld
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m hrnet48_imagenet_ssld
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/hrnet48_imagenet_ssld"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/hrnet48_imagenet_ssld" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/hrnet64_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # hrnet64_imagenet
$ hub install hrnet64_imagenet==1.0.0
```
## 命令行预测 |模型名称|hrnet64_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|HRNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|740MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run hrnet64_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - HRNet是微软亚洲研究院在2019年提出的全新神经网络。与之前的卷积神经网络不同，这个网络在网络的深层依然可以保持高分辨率，所以预测的关键点的热图更加准确，而且在空间上也更加准确。此外，该网络在其他对分辨率敏感的视觉任务中表现特别好，例如检测和分割。
model = hub.Module(name='hrnet64_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install hrnet64_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run hrnet64_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='hrnet64_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='hrnet64_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet64_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="hrnet64_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='hrnet64_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='hrnet64_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m hrnet64_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m hrnet64_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/hrnet64_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/hrnet64_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/repvgg_a0_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # repvgg_a0_imagenet
$ hub install repvgg_a0_imagenet==1.0.0
```
## 命令行预测 |模型名称|repvgg_a0_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|RepVGG|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|53MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run repvgg_a0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - RepVGG（Making VGG-style ConvNets Great Again）系列模型是清华大学（丁桂光团队）、旷视科技（孙建等）、香港科技大学和阿伯里斯特威斯大学于2021年提出的一种简单但功能强大的卷积神经网络架构。有一个类似于 VGG 的推理时间代理。主体由3x3卷积和relu stack组成，而训练时间模型具有多分支拓扑。训练时间和推理时间的解耦是通过重新参数化技术实现的，因此该模型被称为repvgg。
model = hub.Module(name='repvgg_a0_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install repvgg_a0_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run repvgg_a0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='repvgg_a0_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='repvgg_a0_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_a0_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="repvgg_a0_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='repvgg_a0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='repvgg_a0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m repvgg_a0_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m repvgg_a0_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/repvgg_a0_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/repvgg_a0_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
modules/image/classification/repvgg_a1_imagenet/README.md
浏览文件 @ 2fd801c3
```shell # repvgg_a1_imagenet
$ hub install repvgg_a1_imagenet==1.0.0
```
## 命令行预测 |模型名称|repvgg_a1_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|RepVGG|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|是|
|模型大小|82MB|
|指标|-|
|最新更新日期|2021-09-14|
```shell
$ hub run repvgg_a1_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
## 脚本预测 ## 一、模型基本信息
```python - ### 模型介绍
import paddle
import paddlehub as hub
if __name__ == '__main__': - RepVGG（Making VGG-style ConvNets Great Again）系列模型是清华大学（丁桂光团队）、旷视科技（孙建等）、香港科技大学和阿伯里斯特威斯大学于2021年提出的一种简单但功能强大的卷积神经网络架构。有一个类似于 VGG 的推理时间代理。主体由3x3卷积和relu stack组成，而训练时间模型具有多分支拓扑。训练时间和推理时间的解耦是通过重新参数化技术实现的，因此该模型被称为repvgg。
model = hub.Module(name='repvgg_a1_imagenet',)
result = model.predict([PATH/TO/IMAGE])
```
## Fine-tune代码步骤 ## 二、安装
使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 - ### 1、环境依赖
### Step1: 定义数据预处理方式 - paddlepaddle >= 2.0.0
```python
import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)), - paddlehub >= 2.0.0
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 - ### 2、安装
- ```shell
$ hub install repvgg_a1_imagenet
```
### Step2: 下载数据集并使用 - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
```python | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
from paddlehub.datasets import Flowers
flowers = Flowers(transforms) ## 三、模型API预测
flowers_validate = Flowers(transforms, mode='val')
```
* transforms(Callable): 数据预处理方式。
* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。
'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 - ### 1.命令行预测
```shell
$ hub run repvgg_a1_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5
```
- ### 2.预测代码示例
### Step3: 加载预训练模型 ```python
import paddle
```python import paddlehub as hub
import paddlehub as hub if __name__ == '__main__':
model = hub.Module(name='repvgg_a1_imagenet')
result = model.predict(['flower.jpg'])
```
- ### 3.如何开始Fine-tune
model = hub.Module(name='repvgg_a1_imagenet', - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_a1_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。
label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"],
load_checkpoint=None)
```
* name(str): 选择预训练模型的名字。
* label_list(list): 设置标签对应分类类别, 默认为Imagenet2012类别。
* load _checkpoint(str): 模型参数地址。
PaddleHub提供许多图像分类预训练模型，如xception、mobilenet、efficientnet等，详细信息参见[图像分类模型](https://www.paddlepaddle.org.cn/hub?filter=en_category&value=ImageClassification)。 - 代码步骤
如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. - Step1: 定义数据预处理方式
```python - ```python
import paddlehub as hub import paddlehub.vision.transforms as T
transforms = T.Compose([T.Resize((256, 256)),
T.CenterCrop(224),
T.Normalize(mean=[0.485, 0.456, 0.406], std = [0.229, 0.224, 0.225])],
to_rgb=True)
```
# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。
module = hub.Module(name="efficientnetb7_imagenet")
```
**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。
### Step4: 选择优化策略和运行配置 - Step2: 下载数据集并使用
- ```python
from paddlehub.datasets import Flowers
flowers = Flowers(transforms)
flowers_validate = Flowers(transforms, mode='val')
```
```python * `transforms`: 数据预处理方式。
import paddle * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。
from paddlehub.finetune.trainer import Trainer
optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters()) * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 优化策略 - Step3: 加载预训练模型
Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 - ```python
model = hub.Module(name="repvgg_a1_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"])
```
* `name`: 选择预训练模型的名字。
* `label_list`: 设置输出分类类别，默认为Imagenet2012类别。
其中'Adam': - Step4: 选择优化策略和运行配置
* learning_rate: 全局学习率。默认为1e-3； ```python
* parameters: 待优化模型参数。 optimizer = paddle.optimizer.Adam(learning_rate=0.001, parameters=model.parameters())
trainer = Trainer(model, optimizer, checkpoint_dir='img_classification_ckpt')
trainer.train(flowers, epochs=100, batch_size=32, eval_dataset=flowers_validate, save_interval=1)
```
#### 运行配置
'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数:
* model: 被优化模型； - 运行配置
* optimizer: 优化器选择；
* use_vdl: 是否使用vdl可视化训练过程；
* checkpoint_dir: 保存模型参数的地址；
* compare_metrics: 保存最优模型的衡量指标；
'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数:
* train_dataset: 训练时所用的数据集； * `model`: 被优化模型；
* epochs: 训练轮数； * `optimizer`: 优化器选择；
* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； * `use_vdl`: 是否使用vdl可视化训练过程；
* num_workers: works的数量，默认为0； * `checkpoint_dir`: 保存模型参数的地址；
* eval_dataset: 验证集； * `compare_metrics`: 保存最优模型的衡量指标；
* log_interval: 打印日志的间隔， 单位为执行批训练的次数。
* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。
## 模型预测 - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数：
当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 * `train_dataset`: 训练时所用的数据集；
我们使用该模型来进行预测。predict.py脚本如下： * `epochs`: 训练轮数；
* `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size；
* `num_workers`: works的数量，默认为0；
* `eval_dataset`: 验证集；
* `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。
* `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。
```python - 模型预测
import paddle
import paddlehub as hub
if __name__ == '__main__': - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下：
- ```python
import paddle
import paddlehub as hub
if __name__ == '__main__':
model = hub.Module(name='repvgg_a1_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') model = hub.Module(name='repvgg_a1_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT')
result = model.predict(['flower.jpg']) result = model.predict(['flower.jpg'])
``` ```
参数配置正确后，请执行脚本'python predict.py'， 加载模型具体可参见[加载](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/framework/io/load_cn.html#load)。
**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## 服务部署
PaddleHub Serving可以部署一个在线分类任务服务 - **NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。
## Step1: 启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个在线分类任务服务。
```shell - ### 第一步：启动PaddleHub Serving
$ hub serving start -m repvgg_a1_imagenet
```
这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 - 运行启动命令：
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 - ```shell
$ hub serving start -m repvgg_a1_imagenet
```
## Step2: 发送预测请求 - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
import numpy as np - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python
def cv2_to_base64(image): import requests
import json
import cv2
import base64
import numpy as np
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
def base64_to_cv2(b64str):
def base64_to_cv2(b64str):
data = base64.b64decode(b64str.encode('utf8')) data = base64.b64decode(b64str.encode('utf8'))
data = np.fromstring(data, np.uint8) data = np.fromstring(data, np.uint8)
data = cv2.imdecode(data, cv2.IMREAD_COLOR) data = cv2.imdecode(data, cv2.IMREAD_COLOR)
return data return data
# 发送HTTP请求
# 发送HTTP请求 org_im = cv2.imread('/PATH/TO/IMAGE')
org_im = cv2.imread('/PATH/TO/IMAGE') data = {'images':[cv2_to_base64(org_im)], 'top_k':2}
headers = {"Content-type": "application/json"}
data = {'images':[cv2_to_base64(org_im)], 'top_k':2} url = "http://127.0.0.1:8866/predict/repvgg_a1_imagenet"
headers = {"Content-type": "application/json"} r = requests.post(url=url, headers=headers, data=json.dumps(data))
url = "http://127.0.0.1:8866/predict/repvgg_a1_imagenet" data =r.json()["results"]['data']
r = requests.post(url=url, headers=headers, data=json.dumps(data)) ```
data =r.json()["results"]['data'] ## 五、更新历史
```
* 1.0.0
### 查看代码
初始发布
[PaddleClas](https://github.com/PaddlePaddle/PaddleClas)
### 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或