diff --git a/modules/image/classification/ghostnet_x0_5_imagenet/README.md b/modules/image/classification/ghostnet_x0_5_imagenet/README.md index 40d83f30ccf0a11ddc149da0a92f32d0a78666ba..26762f0b0273794f7aa033586990e796be6be9c5 100644 --- a/modules/image/classification/ghostnet_x0_5_imagenet/README.md +++ b/modules/image/classification/ghostnet_x0_5_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install ghostnet_x0_5_imagenet==1.0.0 -``` +# ghostnet_x0_5_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install ghostnet_x0_5_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='ghostnet_x0_5_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x0_5_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='ghostnet_x0_5_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="ghostnet_x0_5_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - 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']) -``` -参数配置正确后，请执行脚本'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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m ghostnet_x0_5_imagenet + ``` -```shell -$ hub serving start -m ghostnet_x0_5_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/ghostnet_x0_5_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/ghostnet_x0_5_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/ghostnet_x1_0_imagenet/README.md b/modules/image/classification/ghostnet_x1_0_imagenet/README.md index 9e25c471b72cf96393766d3c46eeb161ea7489b2..1708020b63fcdfbdb445f1dd8a86fd312e9b61e5 100644 --- a/modules/image/classification/ghostnet_x1_0_imagenet/README.md +++ b/modules/image/classification/ghostnet_x1_0_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install ghostnet_x1_0_imagenet==1.0.0 -``` +# ghostnet_x1_0_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install ghostnet_x1_0_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='ghostnet_x1_0_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x1_0_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='ghostnet_x1_0_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="ghostnet_x1_0_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - 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']) -``` -参数配置正确后，请执行脚本'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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m ghostnet_x1_0_imagenet + ``` -```shell -$ hub serving start -m ghostnet_x1_0_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/ghostnet_x1_0_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/ghostnet_x1_0_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/ghostnet_x1_3_imagenet/README.md b/modules/image/classification/ghostnet_x1_3_imagenet/README.md index 72189fcd68cd3b61d7937c3de43853d380fbf0c1..a5f0a27a3e40ed57ce1345e70e1027875697077b 100644 --- a/modules/image/classification/ghostnet_x1_3_imagenet/README.md +++ b/modules/image/classification/ghostnet_x1_3_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install ghostnet_x1_3_imagenet==1.0.0 -``` +# ghostnet_x1_3_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install ghostnet_x1_3_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='ghostnet_x1_3_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x1_3_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='ghostnet_x1_3_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="ghostnet_x1_3_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - 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']) -``` -参数配置正确后，请执行脚本'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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m ghostnet_x1_3_imagenet + ``` -```shell -$ hub serving start -m ghostnet_x1_3_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/ghostnet_x1_3_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/ghostnet_x1_3_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/ghostnet_x1_3_imagenet_ssld/README.md b/modules/image/classification/ghostnet_x1_3_imagenet_ssld/README.md index ef310be9ec7f4112fc7d02cc962bd5734da8a92f..b3e87610246e2568ddc65006d9f83b46a14097a6 100644 --- a/modules/image/classification/ghostnet_x1_3_imagenet_ssld/README.md +++ b/modules/image/classification/ghostnet_x1_3_imagenet_ssld/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install ghostnet_x1_3_imagenet_ssld==1.0.0 -``` +# ghostnet_x1_3_imagenet_ssld -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install ghostnet_x1_3_imagenet_ssld + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='ghostnet_x1_3_imagenet_ssld') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用ghostnet_x1_3_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='ghostnet_x1_3_imagenet_ssld', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="ghostnet_x1_3_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - 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']) -``` -参数配置正确后，请执行脚本'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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m ghostnet_x1_3_imagenet_ssld + ``` -```shell -$ hub serving start -m ghostnet_x1_3_imagenet_ssld -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/ghostnet_x1_3_imagenet_ssld" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/ghostnet_x1_3_imagenet_ssld" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/hrnet18_imagenet/README.md b/modules/image/classification/hrnet18_imagenet/README.md index d1530c8902706896bd01aa7c93a039109c7f3b2f..9cd941f141df7799f60d08294969d247ecab064b 100644 --- a/modules/image/classification/hrnet18_imagenet/README.md +++ b/modules/image/classification/hrnet18_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install hrnet18_imagenet==1.0.0 -``` +# hrnet18_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install hrnet18_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='hrnet18_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet18_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='hrnet18_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="hrnet18_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='hrnet18_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m hrnet18_imagenet + ``` -```shell -$ hub serving start -m hrnet18_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/hrnet18_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/hrnet18_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/hrnet18_imagenet_ssld/README.md b/modules/image/classification/hrnet18_imagenet_ssld/README.md index 5a33c39fd31ff02b838716d374d0dcc85a7b548c..305ac09b28d3c1d2e895fa3968d0dc80aca40a90 100644 --- a/modules/image/classification/hrnet18_imagenet_ssld/README.md +++ b/modules/image/classification/hrnet18_imagenet_ssld/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install hrnet18_imagenet_ssld==1.0.0 -``` +# hrnet18_imagenet_ssld -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install hrnet18_imagenet_ssld + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='hrnet18_imagenet_ssld') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet18_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='hrnet18_imagenet_ssld', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="hrnet18_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='hrnet18_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m hrnet18_imagenet_ssld + ``` -```shell -$ hub serving start -m hrnet18_imagenet_ssld -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/hrnet18_imagenet_ssld" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/hrnet18_imagenet_ssld" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/hrnet30_imagenet/README.md b/modules/image/classification/hrnet30_imagenet/README.md index 4b447d1f3c4eacc623f5287af2ea8bdf71e111ed..c64a0075696dc6896f63fd43ed27922631c88d1f 100644 --- a/modules/image/classification/hrnet30_imagenet/README.md +++ b/modules/image/classification/hrnet30_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install hrnet30_imagenet==1.0.0 -``` +# hrnet30_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install hrnet30_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='hrnet30_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet30_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='hrnet30_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="hrnet30_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='hrnet30_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m hrnet30_imagenet + ``` -```shell -$ hub serving start -m hrnet30_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/hrnet30_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/hrnet30_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/hrnet32_imagenet/README.md b/modules/image/classification/hrnet32_imagenet/README.md index af97dc62a0c95cea46adad5db8ae987eefc29ff4..69b3c82d8f8eb38c988d045c30fa1e5139e8e7d0 100644 --- a/modules/image/classification/hrnet32_imagenet/README.md +++ b/modules/image/classification/hrnet32_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install hrnet32_imagenet==1.0.0 -``` +# hrnet32_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install hrnet32_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='hrnet32_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet32_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='hrnet32_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="hrnet32_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='hrnet32_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m hrnet32_imagenet + ``` -```shell -$ hub serving start -m hrnet32_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/hrnet32_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/hrnet32_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/hrnet40_imagenet/README.md b/modules/image/classification/hrnet40_imagenet/README.md index d09944004c371022fbc896710e16ee3d65a7db52..3c6efc2c6a61e6a48a092ea1b996e29d1335531c 100644 --- a/modules/image/classification/hrnet40_imagenet/README.md +++ b/modules/image/classification/hrnet40_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install hrnet40_imagenet==1.0.0 -``` +# hrnet40_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install hrnet40_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='hrnet40_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet40_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='hrnet40_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="hrnet40_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='hrnet40_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m hrnet40_imagenet + ``` -```shell -$ hub serving start -m hrnet40_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/hrnet40_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/hrnet40_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/hrnet44_imagenet/README.md b/modules/image/classification/hrnet44_imagenet/README.md index 78031d1cacce6b85e3dee97957fba8326b00b608..9c2c6ccbb85a43620ad2641a6e2a615f46ee86ea 100644 --- a/modules/image/classification/hrnet44_imagenet/README.md +++ b/modules/image/classification/hrnet44_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install hrnet44_imagenet==1.0.0 -``` +# hrnet44_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install hrnet44_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='hrnet44_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet44_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='hrnet44_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="hrnet44_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='hrnet44_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m hrnet44_imagenet + ``` -```shell -$ hub serving start -m hrnet44_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/hrnet44_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/hrnet44_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/hrnet48_imagenet/README.md b/modules/image/classification/hrnet48_imagenet/README.md index 1b82779201fb4ec941d9f31ed380e536a63c96a3..6c480ce1fc730b79b8ce890d7239032a839d84e6 100644 --- a/modules/image/classification/hrnet48_imagenet/README.md +++ b/modules/image/classification/hrnet48_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install hrnet48_imagenet==1.0.0 -``` +# hrnet48_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install hrnet48_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='hrnet48_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet48_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='hrnet48_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="hrnet48_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='hrnet48_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m hrnet48_imagenet + ``` -```shell -$ hub serving start -m hrnet48_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/hrnet48_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/hrnet48_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/hrnet48_imagenet_ssld/README.md b/modules/image/classification/hrnet48_imagenet_ssld/README.md index 4b9fa929af3a9df2e95e2b93189818e4f162fa9b..ff49aa29797cf659f6b350b2670b66d6d5b2821e 100644 --- a/modules/image/classification/hrnet48_imagenet_ssld/README.md +++ b/modules/image/classification/hrnet48_imagenet_ssld/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install hrnet48_imagenet_ssld==1.0.0 -``` +# hrnet48_imagenet_ssld -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install hrnet48_imagenet_ssld + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='hrnet48_imagenet_ssld') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet48_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='hrnet48_imagenet_ssld', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="hrnet48_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='hrnet48_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m hrnet48_imagenet_ssld + ``` -```shell -$ hub serving start -m hrnet48_imagenet_ssld -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/hrnet48_imagenet_ssld" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/hrnet48_imagenet_ssld" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/hrnet64_imagenet/README.md b/modules/image/classification/hrnet64_imagenet/README.md index ed6f1b153bf5e1113e3f2aa588ff15fcc5bf9c87..7cf46cc66192040870e59a4a9712fa5ceb986f26 100644 --- a/modules/image/classification/hrnet64_imagenet/README.md +++ b/modules/image/classification/hrnet64_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install hrnet64_imagenet==1.0.0 -``` +# hrnet64_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install hrnet64_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='hrnet64_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用hrnet64_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='hrnet64_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="hrnet64_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='hrnet64_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m hrnet64_imagenet + ``` -```shell -$ hub serving start -m hrnet64_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/hrnet64_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/hrnet64_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/repvgg_a0_imagenet/README.md b/modules/image/classification/repvgg_a0_imagenet/README.md index 826db2eae01b92b08972fa399114e396cec14c9c..c9639fe3c25344caaa50e3736166e4e641920187 100644 --- a/modules/image/classification/repvgg_a0_imagenet/README.md +++ b/modules/image/classification/repvgg_a0_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install repvgg_a0_imagenet==1.0.0 -``` +# repvgg_a0_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install repvgg_a0_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_a0_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_a0_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='repvgg_a0_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="repvgg_a0_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='repvgg_a0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m repvgg_a0_imagenet + ``` -```shell -$ hub serving start -m repvgg_a0_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/repvgg_a0_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/repvgg_a0_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/repvgg_a1_imagenet/README.md b/modules/image/classification/repvgg_a1_imagenet/README.md index 0bda4997214a7709ae35af22e637e4234023f7a6..0331a17d9dc86da5683c738d09a93c98e0cdfcaf 100644 --- a/modules/image/classification/repvgg_a1_imagenet/README.md +++ b/modules/image/classification/repvgg_a1_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install repvgg_a1_imagenet==1.0.0 -``` +# repvgg_a1_imagenet -## 命令行预测 +|模型名称|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: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install repvgg_a1_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'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 + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_a1_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_a1_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='repvgg_a1_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="repvgg_a1_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```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') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='repvgg_a1_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m repvgg_a1_imagenet + ``` -```shell -$ hub serving start -m repvgg_a1_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/repvgg_a1_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/repvgg_a1_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/repvgg_a2_imagenet/README.md b/modules/image/classification/repvgg_a2_imagenet/README.md index ee342fb033fdc00e6166d9074bc278293d22343e..f10d93eb5296d8f4491882f608a328d4e2e9cf72 100644 --- a/modules/image/classification/repvgg_a2_imagenet/README.md +++ b/modules/image/classification/repvgg_a2_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install repvgg_a2_imagenet==1.0.0 -``` +# repvgg_a2_imagenet -## 命令行预测 +|模型名称|repvgg_a2_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|RepVGG| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|163MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run repvgg_a2_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_a2_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install repvgg_a2_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run repvgg_a2_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_a2_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_a2_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='repvgg_a2_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="repvgg_a2_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_a2_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='repvgg_a2_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m repvgg_a2_imagenet + ``` -```shell -$ hub serving start -m repvgg_a2_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/repvgg_a2_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/repvgg_a2_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/repvgg_b0_imagenet/README.md b/modules/image/classification/repvgg_b0_imagenet/README.md index 7a284dd6c937e7a78c2aebb574cf52961ccfdbc5..f8b9c6994853fed5a41df599f6812c1bed5ce1b0 100644 --- a/modules/image/classification/repvgg_b0_imagenet/README.md +++ b/modules/image/classification/repvgg_b0_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install repvgg_b0_imagenet==1.0.0 -``` +# repvgg_b0_imagenet -## 命令行预测 +|模型名称|repvgg_b0_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|RepVGG| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|92MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run repvgg_b0_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_b0_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install repvgg_b0_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run repvgg_b0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b0_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_b0_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='repvgg_b0_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="repvgg_b0_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='repvgg_b0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m repvgg_b0_imagenet + ``` -```shell -$ hub serving start -m repvgg_b0_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/repvgg_b0_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/repvgg_b0_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/repvgg_b1_imagenet/README.md b/modules/image/classification/repvgg_b1_imagenet/README.md index 1a1e4d05f33626856349bbeb48a20be4dea738d5..07578e568aea228b4765026a92a8163b727345bf 100644 --- a/modules/image/classification/repvgg_b1_imagenet/README.md +++ b/modules/image/classification/repvgg_b1_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install repvgg_b1_imagenet==1.0.0 -``` +# repvgg_b1_imagenet -## 命令行预测 +|模型名称|repvgg_b1_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|RepVGG| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|332MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run repvgg_b1_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_b1_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install repvgg_b1_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run repvgg_b1_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b1_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_b1_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='repvgg_b1_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="repvgg_b1_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b1_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='repvgg_b1_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m repvgg_b1_imagenet + ``` -```shell -$ hub serving start -m repvgg_b1_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/repvgg_b1_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/repvgg_b1_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/repvgg_b1g2_imagenet/README.md b/modules/image/classification/repvgg_b1g2_imagenet/README.md index 8fc6517eddc62157cd9ef506cc276c102fa1eb24..cf73a03852e4f85a3cf5f04b6844db40a1af6f8c 100644 --- a/modules/image/classification/repvgg_b1g2_imagenet/README.md +++ b/modules/image/classification/repvgg_b1g2_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install repvgg_b1g2_imagenet==1.0.0 -``` +# repvgg_b1g2_imagenet -## 命令行预测 +|模型名称|repvgg_b1g2_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|RepVGG| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|264MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run repvgg_b1g2_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_b1g2_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install repvgg_b1g2_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run repvgg_b1g2_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b1g2_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_b1g2_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='repvgg_b1g2_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="repvgg_b1g2_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b1g2_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='repvgg_b1g2_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m repvgg_b1g2_imagenet + ``` -```shell -$ hub serving start -m repvgg_b1g2_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/repvgg_b1g2_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/repvgg_b1g2_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/repvgg_b1g4_imagenet/README.md b/modules/image/classification/repvgg_b1g4_imagenet/README.md index 568c4e0c236e276ca137a397b21510904ad4c04d..3ffe7e0cf5c5448b7b8bdbb2f5da403e9c29e389 100644 --- a/modules/image/classification/repvgg_b1g4_imagenet/README.md +++ b/modules/image/classification/repvgg_b1g4_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install repvgg_b1g4_imagenet==1.0.0 -``` +# repvgg_b1g4_imagenet -## 命令行预测 +|模型名称|repvgg_b1g4_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|RepVGG| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|231MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run repvgg_b1g4_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_b1g4_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install repvgg_b1g4_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run repvgg_b1g4_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b1g4_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_b1g4_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='repvgg_b1g4_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="repvgg_b1g4_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b1g4_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='repvgg_b1g4_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m repvgg_b1g4_imagenet + ``` -```shell -$ hub serving start -m repvgg_b1g4_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/repvgg_b1g4_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/repvgg_b1g4_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/repvgg_b2_imagenet/README.md b/modules/image/classification/repvgg_b2_imagenet/README.md index db2e51baf09648523a2b24b3c6d8722454af907e..4252cc7ad56f959419e595bba8397662b3505524 100644 --- a/modules/image/classification/repvgg_b2_imagenet/README.md +++ b/modules/image/classification/repvgg_b2_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install repvgg_b2_imagenet==1.0.0 -``` +# repvgg_b2_imagenet -## 命令行预测 +|模型名称|repvgg_b2_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|RepVGG| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|514MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run repvgg_b2_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_b2_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install repvgg_b2_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run repvgg_b2_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b2_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_b2_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='repvgg_b2_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="repvgg_b2_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b2_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='repvgg_b2_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m repvgg_b2_imagenet + ``` -```shell -$ hub serving start -m repvgg_b2_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/repvgg_b2_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/repvgg_b2_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/repvgg_b2g4_imagenet/README.md b/modules/image/classification/repvgg_b2g4_imagenet/README.md index 6e16aec1eed0cd2dab24a65052015727f08173da..7f54550241bb753cff0abe7a3e84b0eaf2763922 100644 --- a/modules/image/classification/repvgg_b2g4_imagenet/README.md +++ b/modules/image/classification/repvgg_b2g4_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install repvgg_b2g4_imagenet==1.0.0 -``` +# repvgg_b2g4_imagenet -## 命令行预测 +|模型名称|repvgg_b2g4_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|RepVGG| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|357MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run repvgg_b2g4_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_b2g4_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install repvgg_b2g4_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run repvgg_b2g4_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b2g4_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_b2g4_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='repvgg_b2g4_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="repvgg_b2g4_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b2g4_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='repvgg_b2g4_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m repvgg_b2g4_imagenet + ``` -```shell -$ hub serving start -m repvgg_b2g4_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/repvgg_b2g4_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/repvgg_b2g4_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/repvgg_b3g4_imagenet/README.md b/modules/image/classification/repvgg_b3g4_imagenet/README.md index fd76f6b4110558ea9f6b222689fbf0abafc1fa07..fbcf634133d34e26579b7bc2e665e7e7943b5f98 100644 --- a/modules/image/classification/repvgg_b3g4_imagenet/README.md +++ b/modules/image/classification/repvgg_b3g4_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install repvgg_b3g4_imagenet==1.0.0 -``` +# repvgg_b3g4_imagenet -## 命令行预测 +|模型名称|repvgg_b3g4_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|RepVGG| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|485MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run repvgg_b3g4_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_b3g4_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install repvgg_b3g4_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run repvgg_b3g4_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b3g4_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用repvgg_b3g4_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='repvgg_b3g4_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="repvgg_b3g4_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='repvgg_b3g4_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='repvgg_b3g4_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m repvgg_b3g4_imagenet + ``` -```shell -$ hub serving start -m repvgg_b3g4_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/repvgg_b3g4_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/repvgg_b3g4_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/rexnet_1_0_imagenet/README.md b/modules/image/classification/rexnet_1_0_imagenet/README.md index 900c6b35c9693d937f7ac633d189a5a8e2bd0101..c04f376bf099a69ccdd8c8c1948be9f265241ccf 100644 --- a/modules/image/classification/rexnet_1_0_imagenet/README.md +++ b/modules/image/classification/rexnet_1_0_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install rexnet_1_0_imagenet==1.0.0 -``` +# rexnet_1_0_imagenet -## 命令行预测 +|模型名称|rexnet_1_0_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|ReXNet| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|28MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run rexnet_1_0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 -``` -## 脚本预测 +## 一、模型基本信息 -```python -import paddle -import paddlehub as hub +- ### 模型介绍 -if __name__ == '__main__': + - ReXNet 由 NAVER AI Lab 提出的基于新的网络设计原则而设计的网络。作者针对现有网络中具有代表性的瓶颈问题，提出了一套设计原则，他们认为，常规设计会产生代表性瓶颈，这会影响模型性能。为了研究表征瓶颈，作者研究了由一万个随机网络生成的特征的矩阵秩。此外，还研究了整个层的通道配置以设计更准确的网络架构。最后，作者提出了一套简单有效的设计原则来缓解表征瓶颈。 - model = hub.Module(name='rexnet_1_0_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install rexnet_1_0_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run rexnet_1_0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='rexnet_1_0_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用rexnet_1_0_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='rexnet_1_0_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="rexnet_1_0_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='rexnet_1_0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='rexnet_1_0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m rexnet_1_0_imagenet + ``` -```shell -$ hub serving start -m rexnet_1_0_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/rexnet_1_0_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/rexnet_1_0_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/rexnet_1_3_imagenet/README.md b/modules/image/classification/rexnet_1_3_imagenet/README.md index 81d81b4ee83e3861b1acedb4f82e034e682612d4..7d19e797c3a15403d07c88f542bb6829e2cb80eb 100644 --- a/modules/image/classification/rexnet_1_3_imagenet/README.md +++ b/modules/image/classification/rexnet_1_3_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install rexnet_1_3_imagenet==1.0.0 -``` +# rexnet_1_3_imagenet -## 命令行预测 +|模型名称|rexnet_1_3_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|ReXNet| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|44MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run rexnet_1_3_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 -``` -## 脚本预测 +## 一、模型基本信息 -```python -import paddle -import paddlehub as hub +- ### 模型介绍 -if __name__ == '__main__': + - ReXNet 由 NAVER AI Lab 提出的基于新的网络设计原则而设计的网络。作者针对现有网络中具有代表性的瓶颈问题，提出了一套设计原则，他们认为，常规设计会产生代表性瓶颈，这会影响模型性能。为了研究表征瓶颈，作者研究了由一万个随机网络生成的特征的矩阵秩。此外，还研究了整个层的通道配置以设计更准确的网络架构。最后，作者提出了一套简单有效的设计原则来缓解表征瓶颈。 - model = hub.Module(name='rexnet_1_3_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install rexnet_1_3_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run rexnet_1_3_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='rexnet_1_3_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用rexnet_1_3_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='rexnet_1_3_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="rexnet_1_3_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='rexnet_1_3_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='rexnet_1_3_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m rexnet_1_3_imagenet + ``` -```shell -$ hub serving start -m rexnet_1_3_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/rexnet_1_3_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/rexnet_1_3_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/rexnet_1_5_imagenet/README.md b/modules/image/classification/rexnet_1_5_imagenet/README.md index f1ab691194b9508650d4e932c83208356f7e1064..d0708cecc5f3378bfa7643bfa3c9d523f1a5b2ae 100644 --- a/modules/image/classification/rexnet_1_5_imagenet/README.md +++ b/modules/image/classification/rexnet_1_5_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install rexnet_1_5_imagenet==1.0.0 -``` +# rexnet_1_5_imagenet -## 命令行预测 +|模型名称|rexnet_1_5_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|ReXNet| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|57MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run rexnet_1_5_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 -``` -## 脚本预测 +## 一、模型基本信息 -```python -import paddle -import paddlehub as hub +- ### 模型介绍 -if __name__ == '__main__': + - ReXNet 由 NAVER AI Lab 提出的基于新的网络设计原则而设计的网络。作者针对现有网络中具有代表性的瓶颈问题，提出了一套设计原则，他们认为，常规设计会产生代表性瓶颈，这会影响模型性能。为了研究表征瓶颈，作者研究了由一万个随机网络生成的特征的矩阵秩。此外，还研究了整个层的通道配置以设计更准确的网络架构。最后，作者提出了一套简单有效的设计原则来缓解表征瓶颈。 - model = hub.Module(name='rexnet_1_5_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install rexnet_1_5_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run rexnet_1_5_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='rexnet_1_5_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用rexnet_1_5_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='rexnet_1_5_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="rexnet_1_5_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='rexnet_1_5_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='rexnet_1_5_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m rexnet_1_5_imagenet + ``` -```shell -$ hub serving start -m rexnet_1_5_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/rexnet_1_5_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/rexnet_1_5_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/rexnet_2_0_imagenet/README.md b/modules/image/classification/rexnet_2_0_imagenet/README.md index b9b509b774bc6ccd7c32d734c5165e0bbe037716..3f1285b6ad9441d81cd7deb0ed68923420ecaa94 100644 --- a/modules/image/classification/rexnet_2_0_imagenet/README.md +++ b/modules/image/classification/rexnet_2_0_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install rexnet_2_0_imagenet==1.0.0 -``` +# rexnet_2_0_imagenet -## 命令行预测 +|模型名称|rexnet_2_0_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|ReXNet| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|95MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run rexnet_2_0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 -``` -## 脚本预测 +## 一、模型基本信息 -```python -import paddle -import paddlehub as hub +- ### 模型介绍 -if __name__ == '__main__': + - ReXNet 由 NAVER AI Lab 提出的基于新的网络设计原则而设计的网络。作者针对现有网络中具有代表性的瓶颈问题，提出了一套设计原则，他们认为，常规设计会产生代表性瓶颈，这会影响模型性能。为了研究表征瓶颈，作者研究了由一万个随机网络生成的特征的矩阵秩。此外，还研究了整个层的通道配置以设计更准确的网络架构。最后，作者提出了一套简单有效的设计原则来缓解表征瓶颈。 - model = hub.Module(name='rexnet_2_0_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install rexnet_2_0_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run rexnet_2_0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='rexnet_2_0_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用rexnet_2_0_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='rexnet_2_0_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="rexnet_2_0_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='rexnet_2_0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='rexnet_2_0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m rexnet_2_0_imagenet + ``` -```shell -$ hub serving start -m rexnet_2_0_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/rexnet_2_0_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/rexnet_2_0_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/rexnet_3_0_imagenet/README.md b/modules/image/classification/rexnet_3_0_imagenet/README.md index dcfb35de6142b5d0913480f9cec232421af03902..934812ac4dae247b2e80f033e0778a896c8377a8 100644 --- a/modules/image/classification/rexnet_3_0_imagenet/README.md +++ b/modules/image/classification/rexnet_3_0_imagenet/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install rexnet_3_0_imagenet==1.0.0 -``` +# rexnet_3_0_imagenet -## 命令行预测 +|模型名称|rexnet_3_0_imagenet| +| :--- | :---: | +|类别|图像-图像分类| +|网络|ReXNet| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|200MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run rexnet_3_0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 -``` -## 脚本预测 +## 一、模型基本信息 -```python -import paddle -import paddlehub as hub +- ### 模型介绍 -if __name__ == '__main__': + - ReXNet 由 NAVER AI Lab 提出的基于新的网络设计原则而设计的网络。作者针对现有网络中具有代表性的瓶颈问题，提出了一套设计原则，他们认为，常规设计会产生代表性瓶颈，这会影响模型性能。为了研究表征瓶颈，作者研究了由一万个随机网络生成的特征的矩阵秩。此外，还研究了整个层的通道配置以设计更准确的网络架构。最后，作者提出了一套简单有效的设计原则来缓解表征瓶颈。 - model = hub.Module(name='rexnet_3_0_imagenet',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install rexnet_3_0_imagenet + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run rexnet_3_0_imagenet --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='rexnet_3_0_imagenet') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用rexnet_3_0_imagenet对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='rexnet_3_0_imagenet', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="rexnet_3_0_imagenet", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='rexnet_3_0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='rexnet_3_0_imagenet', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m rexnet_3_0_imagenet + ``` -```shell -$ hub serving start -m rexnet_3_0_imagenet -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/rexnet_3_0_imagenet" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/rexnet_3_0_imagenet" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布 diff --git a/modules/image/classification/se_hrnet64_imagenet_ssld/README.md b/modules/image/classification/se_hrnet64_imagenet_ssld/README.md index fd20f3862ecc053a12274fa2f5f4cbaa8ed41cf4..65289a511405a4a840d5100935e27eee58dd0524 100644 --- a/modules/image/classification/se_hrnet64_imagenet_ssld/README.md +++ b/modules/image/classification/se_hrnet64_imagenet_ssld/README.md @@ -1,192 +1,181 @@ -```shell -$ hub install se_hrnet64_imagenet_ssld==1.0.0 -``` +# se_hrnet64_imagenet_ssld -## 命令行预测 +|模型名称|se_hrnet64_imagenet_ssld| +| :--- | :---: | +|类别|图像-图像分类| +|网络|HRNet| +|数据集|ImageNet-2012| +|是否支持Fine-tuning|是| +|模型大小|493MB| +|指标|-| +|最新更新日期|2021-09-14| -```shell -$ hub run se_hrnet64_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='se_hrnet64_imagenet_ssld',) - result = model.predict([PATH/TO/IMAGE]) -``` -## Fine-tune代码步骤 +## 二、安装 -使用PaddleHub Fine-tune API进行Fine-tune可以分为4个步骤。 +- ### 1、环境依赖 -### Step1: 定义数据预处理方式 -```python -import paddlehub.vision.transforms as T + - paddlepaddle >= 2.0.0 -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) -``` + - paddlehub >= 2.0.0 -'transforms' 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 +- ### 2、安装 + - ```shell + $ hub install se_hrnet64_imagenet_ssld + ``` -### Step2: 下载数据集并使用 -```python -from paddlehub.datasets import Flowers + - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md) + | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md) -flowers = Flowers(transforms) -flowers_validate = Flowers(transforms, mode='val') -``` -* transforms(Callable): 数据预处理方式。 -* mode(str): 选择数据模式，可选项有 'train', 'test', 'val'， 默认为'train'。 +## 三、模型API预测 -'hub.datasets.Flowers()' 会自动从网络下载数据集并解压到用户目录下'$HOME/.paddlehub/dataset'目录。 +- ### 1.命令行预测 + ```shell + $ hub run se_hrnet64_imagenet_ssld --input_path "/PATH/TO/IMAGE" --top_k 5 + ``` +- ### 2.预测代码示例 -### Step3: 加载预训练模型 + ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='se_hrnet64_imagenet_ssld') + result = model.predict(['flower.jpg']) + ``` +- ### 3.如何开始Fine-tune -```python -import paddlehub as hub + - 在完成安装PaddlePaddle与PaddleHub后，通过执行`python train.py`即可开始使用se_hrnet64_imagenet_ssld对[Flowers](../../docs/reference/datasets.md#class-hubdatasetsflowers)等数据集进行Fine-tune。 -model = hub.Module(name='se_hrnet64_imagenet_ssld', - 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)。 + - Step1: 定义数据预处理方式 + - ```python + 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) + ``` -如果想尝试efficientnet模型，只需要更换Module中的'name'参数即可. -```python -import paddlehub as hub + - `transforms` 数据增强模块定义了丰富的数据预处理方式，用户可按照需求替换自己需要的数据预处理方式。 -# 更换name参数即可无缝切换efficientnet模型, 代码示例如下 -module = hub.Module(name="efficientnetb7_imagenet") -``` -**NOTE:**目前部分模型还没有完全升级到2.0版本，敬请期待。 + - Step2: 下载数据集并使用 + - ```python + from paddlehub.datasets import Flowers + flowers = Flowers(transforms) + flowers_validate = Flowers(transforms, mode='val') + ``` -### Step4: 选择优化策略和运行配置 + * `transforms`: 数据预处理方式。 + * `mode`: 选择数据模式，可选项有 `train`, `test`, `val`， 默认为`train`。 -```python -import paddle -from paddlehub.finetune.trainer import Trainer + * 数据集的准备代码可以参考 [flowers.py](../../paddlehub/datasets/flowers.py)。`hub.datasets.Flowers()` 会自动从网络下载数据集并解压到用户目录下`$HOME/.paddlehub/dataset`目录。 -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) -``` + - Step3: 加载预训练模型 -#### 优化策略 + - ```python + model = hub.Module(name="se_hrnet64_imagenet_ssld", label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"]) + ``` + * `name`: 选择预训练模型的名字。 + * `label_list`: 设置输出分类类别，默认为Imagenet2012类别。 -Paddle2.0rc提供了多种优化器选择，如'SGD', 'Adam', 'Adamax'等，详细参见[策略](https://www.paddlepaddle.org.cn/documentation/docs/zh/2.0-rc/api/paddle/optimizer/optimizer/Optimizer_cn.html)。 + - Step4: 选择优化策略和运行配置 -其中'Adam': + ```python + 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) + ``` -* learning_rate: 全局学习率。默认为1e-3； -* parameters: 待优化模型参数。 -#### 运行配置 -'Trainer' 主要控制Fine-tune的训练，包含以下可控制的参数: + - 运行配置 -* model: 被优化模型； -* optimizer: 优化器选择； -* use_vdl: 是否使用vdl可视化训练过程； -* checkpoint_dir: 保存模型参数的地址； -* compare_metrics: 保存最优模型的衡量指标； + - `Trainer` 主要控制Fine-tune的训练，包含以下可控制的参数: -'trainer.train' 主要控制具体的训练过程，包含以下可控制的参数： + * `model`: 被优化模型； + * `optimizer`: 优化器选择； + * `use_vdl`: 是否使用vdl可视化训练过程； + * `checkpoint_dir`: 保存模型参数的地址； + * `compare_metrics`: 保存最优模型的衡量指标； -* train_dataset: 训练时所用的数据集； -* epochs: 训练轮数； -* batch_size: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； -* num_workers: works的数量，默认为0； -* eval_dataset: 验证集； -* log_interval: 打印日志的间隔， 单位为执行批训练的次数。 -* save_interval: 保存模型的间隔频次，单位为执行训练的轮数。 + - `trainer.train` 主要控制具体的训练过程，包含以下可控制的参数： -## 模型预测 + * `train_dataset`: 训练时所用的数据集； + * `epochs`: 训练轮数； + * `batch_size`: 训练的批大小，如果使用GPU，请根据实际情况调整batch_size； + * `num_workers`: works的数量，默认为0； + * `eval_dataset`: 验证集； + * `log_interval`: 打印日志的间隔， 单位为执行批训练的次数。 + * `save_interval`: 保存模型的间隔频次，单位为执行训练的轮数。 -当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在'${CHECKPOINT_DIR}/best_model'目录下，其中'${CHECKPOINT_DIR}'目录为Fine-tune时所选择的保存checkpoint的目录。 -我们使用该模型来进行预测。predict.py脚本如下： + - 模型预测 -```python -import paddle -import paddlehub as hub + - 当完成Fine-tune后，Fine-tune过程在验证集上表现最优的模型会被保存在`${CHECKPOINT_DIR}/best_model`目录下，其中`${CHECKPOINT_DIR}`目录为Fine-tune时所选择的保存checkpoint的目录。 我们使用该模型来进行预测。predict.py脚本如下： -if __name__ == '__main__': + - ```python + import paddle + import paddlehub as hub + if __name__ == '__main__': + model = hub.Module(name='se_hrnet64_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') + result = model.predict(['flower.jpg']) + ``` - model = hub.Module(name='se_hrnet64_imagenet_ssld', label_list=["roses", "tulips", "daisy", "sunflowers", "dandelion"], load_checkpoint='/PATH/TO/CHECKPOINT') - 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所用的一样。 -**NOTE:** 进行预测时，所选择的module，checkpoint_dir，dataset必须和Fine-tune所用的一样。 +## 四、服务部署 -## 服务部署 +- PaddleHub Serving可以部署一个在线分类任务服务。 -PaddleHub Serving可以部署一个在线分类任务服务 +- ### 第一步：启动PaddleHub Serving -## Step1: 启动PaddleHub Serving + - 运行启动命令： -运行启动命令： + - ```shell + $ hub serving start -m se_hrnet64_imagenet_ssld + ``` -```shell -$ hub serving start -m se_hrnet64_imagenet_ssld -``` + - 这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 -这样就完成了一个分类任务服务化API的部署，默认端口号为8866。 + - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 -**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA_VISIBLE_DEVICES环境变量，否则不用设置。 +- ### 第二步：发送预测请求 -## Step2: 发送预测请求 + - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 -配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 + ```python + import requests + import json + import cv2 + import base64 + import numpy as np + def cv2_to_base64(image): + data = cv2.imencode('.jpg', image)[1] + return base64.b64encode(data.tostring()).decode('utf8') + def base64_to_cv2(b64str): + data = base64.b64decode(b64str.encode('utf8')) + data = np.fromstring(data, np.uint8) + data = cv2.imdecode(data, cv2.IMREAD_COLOR) + return data + # 发送HTTP请求 + org_im = cv2.imread('/PATH/TO/IMAGE') + data = {'images':[cv2_to_base64(org_im)], 'top_k':2} + headers = {"Content-type": "application/json"} + url = "http://127.0.0.1:8866/predict/se_hrnet64_imagenet_ssld" + r = requests.post(url=url, headers=headers, data=json.dumps(data)) + data =r.json()["results"]['data'] + ``` +## 五、更新历史 -```python -import requests -import json -import cv2 -import base64 +* 1.0.0 -import numpy as np - - -def cv2_to_base64(image): - data = cv2.imencode('.jpg', image)[1] - return base64.b64encode(data.tostring()).decode('utf8') - -def base64_to_cv2(b64str): - data = base64.b64decode(b64str.encode('utf8')) - data = np.fromstring(data, np.uint8) - data = cv2.imdecode(data, cv2.IMREAD_COLOR) - return data - -# 发送HTTP请求 -org_im = cv2.imread('/PATH/TO/IMAGE') - -data = {'images':[cv2_to_base64(org_im)], 'top_k':2} -headers = {"Content-type": "application/json"} -url = "http://127.0.0.1:8866/predict/se_hrnet64_imagenet_ssld" -r = requests.post(url=url, headers=headers, data=json.dumps(data)) -data =r.json()["results"]['data'] -``` - -### 查看代码 - -[PaddleClas](https://github.com/PaddlePaddle/PaddleClas) - -### 依赖 - -paddlepaddle >= 2.0.0 - -paddlehub >= 2.0.0 + 初始发布