Skip to content

P
PaddleHub

PaddlePaddle / PaddleHub
1 年多 前同步成功

通知 283
Star 12117
Fork 2091
P
PaddleHub
未验证 提交 be73bfb6 编写于 作者: C chenjian 提交者： GitHub
浏览文件
操作

Update image classification docs (#1652)

上级 fd4fb4db
展开全部 隐藏空白更改
内联 并排
Showing with 6983 addition and 951 deletion
modules/image/Image_gan/style_transfer/animegan_v2_paprika_54/README.md
浏览文件 @ be73bfb6
...@@ -4,10 +4,10 @@ ...@@ -4,10 +4,10 @@
| :--- | :---: | | :--- | :---: |
|类别|图像 - 图像生成| |类别|图像 - 图像生成|
|网络|AnimeGAN| |网络|AnimeGAN|
|数据集|The Wind Rises| |数据集|Paprika|
|是否支持Fine-tuning|否| |是否支持Fine-tuning|否|
|模型大小|9.4MB| |模型大小|9.4MB|
|最新更新日期|2021-07-30| |最新更新日期|2021-02-26|
|数据指标|-| |数据指标|-|
...@@ -16,21 +16,20 @@ ...@@ -16,21 +16,20 @@
- ### 应用效果展示 - ### 应用效果展示
- 样例结果示例： - 样例结果示例：
<p align="center"> <p align="center">
<img src="https://user-images.githubusercontent.com/35907364/136652269-48b8c902-3a2b-46b7-a9f2-d500097bbb0e.jpg" width = "450" height = "300" hspace='10'/> <img src="https://ai-studio-static-online.cdn.bcebos.com/bd002c4bb6a7427daf26988770bb18648b7d8d2bfd6746bfb9a429db4867727f" width = "450" height = "300" hspace='10'/>
<br /> <br />
输入图像 输入图像
<br /> <br />
<img src="https://user-images.githubusercontent.com/35907364/136653120-e081cd59-bc2b-4a91-a437-3a7d478e0763.jpg" width = "450" height = "300" hspace='10'/> <img src="https://ai-studio-static-online.cdn.bcebos.com/6574669d87b24bab9627c6e33896528b4a0bf5af1cd84ca29655d68719f2d551" width = "450" height = "300" hspace='10'/>
<br /> <br />
输出图像 输出图像
<br /> <br />
</p> </p>
- ### 模型介绍 - ### 模型介绍
- AnimeGAN V2 图像风格转换模型, 模型可将输入的图像转换成宫崎骏动漫风格，模型权重转换自[AnimeGAN V2官方开源项目](https://github.com/TachibanaYoshino/AnimeGAN)。 - AnimeGAN V2 图像风格转换模型, 模型可将输入的图像转换成今敏红辣椒动漫风格，模型权重转换自[AnimeGAN V2官方开源项目](https://github.com/TachibanaYoshino/AnimeGANv2)。
## 二、安装 ## 二、安装
...@@ -81,12 +80,10 @@ ...@@ -81,12 +80,10 @@
- images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]；<br/> - images (list\[numpy.ndarray\]): 图片数据，ndarray.shape 为 \[H, W, C\]；<br/>
- paths (list\[str\]): 图片的路径；<br/> - paths (list\[str\]): 图片的路径；<br/>
- output\_dir (str): 图片的保存路径，默认设为 output；<br/> - output\_dir (str): 图片的保存路径，默认设为 output；<br/>
- visualization (bool): 是否将识别结果保存为图片文件；<br/> - visualization (bool): 是否将结果保存为图片文件；<br/>
- min\_size (int): 输入图片的短边最小尺寸，默认设为 32；<br/> - min\_size (int): 输入图片的短边最小尺寸，默认设为 32；<br/>
- max\_size (int): 输入图片的短边最大尺寸，默认设为 1024。 - max\_size (int): 输入图片的短边最大尺寸，默认设为 1024。
**NOTE:** paths和images两个参数选择其一进行提供数据
- **返回** - **返回**
- res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\] - res (list\[numpy.ndarray\]): 输出图像数据，ndarray.shape 为 \[H, W, C\]
...@@ -145,3 +142,7 @@ ...@@ -145,3 +142,7 @@
* 1.0.2 * 1.0.2
删除batch_size选项 删除batch_size选项
- ```shell
$ hub install animegan_v2_paprika_54==1.0.2
```
\ No newline at end of file
modules/image/classification/DriverStatusRecognition/README.md
浏览文件 @ be73bfb6
DriverStatusRecognition # DriverStatusRecognition
类别 图像 - 图像分类
网络 MobileNetV3_small_ssld |模型名称|DriverStatusRecognition|
数据集 分心司机检测数据集 | :--- | :---: |
|类别|图像-图像分类|
# 模型概述 |网络|MobileNetV3_small_ssld|
驾驶员状态识别（DriverStatusRecognition），该模型可挖掘出人在疲劳状态下的表情特征，然后将这些定性的表情特征进行量化，提取出面部特征点及特征指标作为判断依据，再结合实验数据总结出基于这些参数的识别方法，最后输入获取到的状态数据进行识别和判断。该PaddleHub Module支持API预测及命令行预测。 |数据集|分心司机检测数据集|
|是否支持Fine-tuning|否|
# 选择模型版本进行安装 |模型大小|6MB|
$ hub install DriverStatusRecognition==1.0.0 |最新更新日期|-|
|数据指标|-|
# 在线体验
[AI Studio快速体验](https://aistudio.baidu.com/aistudio/projectdetail/1649513)
## 一、模型基本信息
# 命令行预测示例
$ hub run DriverStatusRecognition --image 1.png --use_gpu True
# Module API说明 - ### 模型介绍
## def predict(data)
驾驶员状态识别预测接口，输入一张图像，输出该图像上驾驶员的状态 - 驾驶员状态识别（DriverStatusRecognition），该模型可挖掘出人在疲劳状态下的表情特征，然后将这些定性的表情特征进行量化，提取出面部特征点及特征指标作为判断依据，再结合实验数据总结出基于这些参数的识别方法，最后输入获取到的状态数据进行识别和判断。该PaddleHub Module支持API预测及命令行预测。
### 参数
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。 ## 二、安装
### 返回 - ### 1、环境依赖
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率
- paddlepaddle >= 2.0.0
# 代码示例
- paddlehub >= 2.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
## API调用
~~~ - paddlex >= 1.3.7
import cv2
import paddlehub as hub
- ### 2、安装
module = hub.Module(directory='DriverStatusRecognition') # 一行代码实现模型调用
- ```shell
images = [cv2.imread('work/imgs/test/img_1622.jpg'), cv2.imread('work/imgs/test/img_14165.jpg'), cv2.imread('work/imgs/test/img_47183.jpg')] $ hub install DriverStatusRecognition
results = module.predict(images=images) ```
- 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
for result in results: | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
print(result)
~~~ - ### 3、在线体验
[AI Studio 快速体验](https://aistudio.baidu.com/aistudio/projectdetail/1649513)
## 命令行调用
~~~ ## 三、模型API预测
$ hub run DriverStatusRecognition --image 1.png --use_gpu True
~~~ - ### 1、命令行预测
# 效果展示 - ```shell
$ hub run DriverStatusRecognition --input_path /PATH/TO/IMAGE
## 原图 ```
<img src="/docs/imgs/Readme_Related/Image_Classification_Drivers.png"> - 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
## 输出结果 - ### 2、预测代码示例
~~~
[{'category_id': 5, 'category': 'ch5', 'score': 0.47390476}] - ```python
[{'category_id': 2, 'category': 'ch2', 'score': 0.99997914}] import paddlehub as hub
[{'category_id': 1, 'category': 'ch1', 'score': 0.99996376}] import cv2
~~~
classifier = hub.Module(name="DriverStatusRecognition")
# 贡献者 images = [cv2.imread('/PATH/TO/IMAGE')]
郑博培、彭兆帅 results = classifier.predict(images=images)
for result in results:
# 依赖 print(result)
paddlepaddle >= 2.0.0<br> ```
paddlehub >= 2.0.0
- ### 3、API
- ```python
def predict(images)
```
- 分类接口API。
- **参数**
- images：list类型，待检测的图像。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install DriverStatusRecognition==1.0.0
```
modules/image/classification/SnakeIdentification/README.md
浏览文件 @ be73bfb6
SnakeIdentification # SnakeIdentification
类别 图像 - 图像分类
网络 ResNet50_vd_ssld |模型名称|SnakeIdentification|
数据集 蛇种数据集 | :--- | :---: |
|类别|图像-图像分类|
# 模型概述 |网络|ResNet50_vd_ssld|
蛇种识别（SnakeIdentification），该模型可准确识别蛇的种类，并精准判断蛇的毒性。该PaddleHub Module支持API预测及命令行预测。 |数据集|蛇种数据集|
|是否支持Fine-tuning|否|
# 选择模型版本进行安装 |模型大小|84MB|
$ hub install SnakeIdentification==1.0.0 |最新更新日期|-|
|数据指标|-|
# 在线体验
[AI Studio快速体验](https://aistudio.baidu.com/aistudio/projectdetail/1646951)
## 一、模型基本信息
# 命令行预测示例
$ hub run SnakeIdentification --image 1.png --use_gpu True
# Module API说明 - ### 模型介绍
## def predict(data)
蛇种识别预测接口，输入一张图像，输出该图像上蛇的类别 - 蛇种识别（SnakeIdentification），该模型可准确识别蛇的种类，并精准判断蛇的毒性。该PaddleHub Module支持API预测及命令行预测。
### 参数
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。 ## 二、安装
### 返回 - ### 1、环境依赖
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率
- paddlepaddle >= 2.0.0
# 代码示例
- paddlehub >= 2.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
## API调用
~~~ - paddlex >= 1.3.7
import cv2
import paddlehub as hub
- ### 2、安装
module = hub.Module(name="SnakeIdentification")
- ```shell
images = [cv2.imread('snake_data/class_1/2421.jpg')] $ hub install SnakeIdentification
```
# execute predict and print the result - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
results = module.predict(images=images) | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
for result in results:
print(result) - ### 3、在线体验
~~~ [AI Studio 快速体验](https://aistudio.baidu.com/aistudio/projectdetail/1646951)
## 命令行调用 ## 三、模型API预测
~~~
$ hub run SnakeIdentification --image 1.png --use_gpu True - ### 1、命令行预测
~~~
- ```shell
# 效果展示 $ hub run SnakeIdentification --input_path /PATH/TO/IMAGE
```
## 原图 - 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
<img src="/docs/imgs/Readme_Related/Image_Classification_Snake.png">
- ### 2、预测代码示例
## 输出结果
~~~ - ```python
[{'category_id': 0, 'category': '水蛇', 'score': 0.9999205}] import paddlehub as hub
~~~ import cv2
# 贡献者 classifier = hub.Module(name="SnakeIdentification")
郑博培、彭兆帅 images = [cv2.imread('/PATH/TO/IMAGE')]
results = classifier.predict(images=images)
# 依赖 for result in results:
paddlepaddle >= 2.0.0<br> print(result)
paddlehub >= 2.0.0 ```
- ### 3、API
- ```python
def predict(images)
```
- 分类接口API。
- **参数**
- images：list类型，待检测的图像。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install SnakeIdentification==1.0.0
```
modules/image/classification/alexnet_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# alexnet_imagenet
|模型名称|alexnet_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|AlexNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|234MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- AlexNet是图像分类中的经典模型。模型由Alex Krizhevsky于2012年提出，并在2012年ILSVRC比赛中夺得冠军。该PaddleHub Module结构为AlexNet，基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install alexnet_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run alexnet_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="alexnet_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install alexnet_imagenet==1.0.0
```
modules/image/classification/darknet53_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# darknet53_imagenet
|模型名称|darknet53_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DarkNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|160MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DarkNet 是由 Joseph Redmon 提出的图像分类模型，并应用于Yolov3 中作为 Backbone 来完成特征提取。该网络采用连续的 3*3 和 1*1 卷积进行连接，并像ResNet 一样有ShortCut连接。该 PaddleHub Module 基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install darknet53_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run darknet53_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现文字识别模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="darknet53_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install darknet53_imagenet==1.0.0
```
modules/image/classification/densenet121_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# densenet121_imagenet
|模型名称|densenet121_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DenseNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|34MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DenseNet 是 CVPR 2017 最佳论文的模型，DenseNet 以前馈方式将每一层与其他层连接，从而 L 层网络就有 L(L+1)/2 个直接连接。对于每一层，其输入是之前的所有层的特征图，而自己的特征图作为之后所有层的输入。DenseNet 缓解了梯度消失问题，加强特征传播，促进了特征重用，并大幅减少了参数量。该PaddleHub Module结构为 DenseNet121，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install densenet121_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run densenet121_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="densenet121_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install densenet121_imagenet==1.0.0
```
modules/image/classification/densenet161_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# densenet161_imagenet
|模型名称|densenet161_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DenseNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|114MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DenseNet 是 CVPR 2017 最佳论文的模型，DenseNet 以前馈方式将每一层与其他层连接，从而 L 层网络就有 L(L+1)/2 个直接连接。对于每一层，其输入是之前的所有层的特征图，而自己的特征图作为之后所有层的输入。DenseNet 缓解了梯度消失问题，加强特征传播，促进了特征重用，并大幅减少了参数量。该PaddleHub Module结构为 DenseNet161，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install densenet161_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run densenet161_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="densenet161_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install densenet161_imagenet==1.0.0
```
modules/image/classification/densenet169_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# densenet169_imagenet
|模型名称|densenet169_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DenseNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|59MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DenseNet 是 CVPR 2017 最佳论文的模型，DenseNet 以前馈方式将每一层与其他层连接，从而 L 层网络就有 L(L+1)/2 个直接连接。对于每一层，其输入是之前的所有层的特征图，而自己的特征图作为之后所有层的输入。DenseNet 缓解了梯度消失问题，加强特征传播，促进了特征重用，并大幅减少了参数量。该PaddleHub Module结构为 DenseNet169，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install densenet169_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run densenet169_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="densenet169_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install densenet169_imagenet==1.0.0
```
modules/image/classification/densenet201_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# densenet201_imagenet
|模型名称|densenet201_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DenseNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|82MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DenseNet 是 CVPR 2017 最佳论文的模型，DenseNet 以前馈方式将每一层与其他层连接，从而 L 层网络就有 L(L+1)/2 个直接连接。对于每一层，其输入是之前的所有层的特征图，而自己的特征图作为之后所有层的输入。DenseNet 缓解了梯度消失问题，加强特征传播，促进了特征重用，并大幅减少了参数量。该PaddleHub Module结构为 DenseNet201，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install densenet201_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run densenet201_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="densenet201_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install densenet201_imagenet==1.0.0
```
modules/image/classification/densenet264_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# densenet264_imagenet
|模型名称|densenet264_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DenseNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|135MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DenseNet 是 CVPR 2017 最佳论文的模型，DenseNet 以前馈方式将每一层与其他层连接，从而 L 层网络就有 L(L+1)/2 个直接连接。对于每一层，其输入是之前的所有层的特征图，而自己的特征图作为之后所有层的输入。DenseNet 缓解了梯度消失问题，加强特征传播，促进了特征重用，并大幅减少了参数量。该PaddleHub Module结构为 DenseNet264，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install densenet264_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run densenet264_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="densenet264_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install densenet264_imagenet==1.0.0
```
modules/image/classification/dpn107_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# dpn107_imagenet
|模型名称|dpn107_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DPN|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|335MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DPN(Dual Path Networks) 是 ImageNet 2017 目标定位冠军的图像分类模型，融合了 ResNet 和 DenseNet 的核心思想。该PaddleHub Module结构为 DPN107，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install dpn107_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run dpn107_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="dpn107_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install dpn107_imagenet==1.0.0
```
modules/image/classification/dpn131_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# dpn131_imagenet
|模型名称|dpn131_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DPN|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|306MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DPN(Dual Path Networks) 是 ImageNet 2017 目标定位冠军的图像分类模型，融合了 ResNet 和 DenseNet 的核心思想。该PaddleHub Module结构为 DPN98，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install dpn131_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run dpn131_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="dpn131_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install dpn131_imagenet==1.0.0
```
modules/image/classification/dpn68_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# dpn68_imagenet
|模型名称|dpn68_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DPN|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|50MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DPN(Dual Path Networks) 是 ImageNet 2017 目标定位冠军的图像分类模型，融合了 ResNet 和 DenseNet 的核心思想。该PaddleHub Module结构为 DPN68，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install dpn68_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run dpn68_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="dpn68_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install dpn68_imagenet==1.0.0
```
modules/image/classification/dpn92_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# dpn92_imagenet
|模型名称|dpn92_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DPN|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|146MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DPN(Dual Path Networks) 是 ImageNet 2017 目标定位冠军的图像分类模型，融合了 ResNet 和 DenseNet 的核心思想。该PaddleHub Module结构为 DPN92，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install dpn92_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run dpn92_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="dpn92_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install dpn92_imagenet==1.0.0
```
modules/image/classification/dpn98_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# dpn98_imagenet
|模型名称|dpn98_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|DPN|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|238MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- DPN(Dual Path Networks) 是 ImageNet 2017 目标定位冠军的图像分类模型，融合了 ResNet 和 DenseNet 的核心思想。该PaddleHub Module结构为 DPN98，基于ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install dpn98_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run dpn98_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="dpn98_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install dpn98_imagenet==1.0.0
```
modules/image/classification/efficientnetb0_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# efficientnetb0_imagenet
|模型名称|efficientnetb0_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|EfficientNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|22MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- EfficientNet 是谷歌的开源新模型，是一个轻量级网络，它的主干网络由 MBConv 构成，同时采取了 squeeze-and-excitation 操作对网络结构进行优化。该 PaddleHub Module结构为 EfficientNetB0，基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install efficientnetb0_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run efficientnetb0_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="efficientnetb0_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m efficientnetb0_imagenet
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/efficientnetb0_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
提升预测性能以及易用性
- ```shell
$ hub install efficientnetb0_imagenet==1.1.0
```
modules/image/classification/efficientnetb0_small_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# efficientnetb0_small_imagenet
|模型名称|efficientnetb0_small_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|EfficientNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|20MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- EfficientNet 是谷歌的开源新模型，是一个轻量级网络，它的主干网络由 MBConv 构成，同时采取了 squeeze-and-excitation 操作对网络结构进行优化。该 PaddleHub Module结构为 EfficientNetB0，基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install efficientnetb0_small_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run efficientnetb0_small_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="efficientnetb0_small_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m efficientnetb0_small_imagenet
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/efficientnetb0_small_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install efficientnetb0_small_imagenet==1.0.0
```
modules/image/classification/efficientnetb1_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# efficientnetb1_imagenet
|模型名称|efficientnetb1_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|EfficientNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|33MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- EfficientNet 是谷歌的开源新模型，是一个轻量级网络，它的主干网络由 MBConv 构成，同时采取了 squeeze-and-excitation 操作对网络结构进行优化。该 PaddleHub Module结构为 EfficientNetB1，基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install efficientnetb1_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run efficientnetb1_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="efficientnetb1_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m efficientnetb1_imagenet
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/efficientnetb1_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
提升预测性能以及易用性
- ```shell
$ hub install efficientnetb1_imagenet==1.1.0
```
modules/image/classification/efficientnetb2_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# efficientnetb2_imagenet
|模型名称|efficientnetb2_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|EfficientNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|38MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- EfficientNet 是谷歌的开源新模型，是一个轻量级网络，它的主干网络由 MBConv 构成，同时采取了 squeeze-and-excitation 操作对网络结构进行优化。该 PaddleHub Module结构为 EfficientNetB2，基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install efficientnetb2_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run efficientnetb2_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="efficientnetb2_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m efficientnetb2_imagenet
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/efficientnetb2_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
提升预测性能以及易用性
- ```shell
$ hub install efficientnetb2_imagenet==1.1.0
```
modules/image/classification/efficientnetb3_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# efficientnetb3_imagenet
|模型名称|efficientnetb3_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|EfficientNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|51MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- EfficientNet 是谷歌的开源新模型，是一个轻量级网络，它的主干网络由 MBConv 构成，同时采取了 squeeze-and-excitation 操作对网络结构进行优化。该 PaddleHub Module结构为 EfficientNetB3，基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install efficientnetb3_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run efficientnetb3_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="efficientnetb3_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m efficientnetb3_imagenet
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/efficientnetb3_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
提升预测性能以及易用性
- ```shell
$ hub install efficientnetb3_imagenet==1.1.0
```
modules/image/classification/efficientnetb4_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# efficientnetb4_imagenet
|模型名称|efficientnetb4_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|EfficientNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|77MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- EfficientNet 是谷歌的开源新模型，是一个轻量级网络，它的主干网络由 MBConv 构成，同时采取了 squeeze-and-excitation 操作对网络结构进行优化。该 PaddleHub Module结构为 EfficientNetB4，基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install efficientnetb4_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run efficientnetb4_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="efficientnetb4_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m efficientnetb4_imagenet
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/efficientnetb4_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
提升预测性能以及易用性
- ```shell
$ hub install efficientnetb4_imagenet==1.1.0
```
modules/image/classification/efficientnetb5_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# efficientnetb5_imagenet
|模型名称|efficientnetb5_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|EfficientNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|121MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- EfficientNet 是谷歌的开源新模型，是一个轻量级网络，它的主干网络由 MBConv 构成，同时采取了 squeeze-and-excitation 操作对网络结构进行优化。该 PaddleHub Module结构为 EfficientNetB5，基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install efficientnetb5_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run efficientnetb5_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="efficientnetb5_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m efficientnetb5_imagenet
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/efficientnetb5_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
提升预测性能以及易用性
- ```shell
$ hub install efficientnetb5_imagenet==1.1.0
```
modules/image/classification/efficientnetb6_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# efficientnetb6_imagenet
|模型名称|efficientnetb6_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|EfficientNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|170MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- EfficientNet 是谷歌的开源新模型，是一个轻量级网络，它的主干网络由 MBConv 构成，同时采取了 squeeze-and-excitation 操作对网络结构进行优化。该 PaddleHub Module结构为 EfficientNetB6，基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install efficientnetb6_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run efficientnetb6_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="efficientnetb6_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m efficientnetb6_imagenet
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/efficientnetb6_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
提升预测性能以及易用性
- ```shell
$ hub install efficientnetb6_imagenet==1.1.0
```
modules/image/classification/efficientnetb7_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# efficientnetb7_imagenet
|模型名称|efficientnetb7_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|EfficientNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|260MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- EfficientNet 是谷歌的开源新模型，是一个轻量级网络，它的主干网络由 MBConv 构成，同时采取了 squeeze-and-excitation 操作对网络结构进行优化。该 PaddleHub Module结构为 EfficientNetB7，基于 ImageNet-2012 数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install efficientnetb7_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run efficientnetb7_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="efficientnetb7_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m efficientnetb7_imagenet
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/efficientnetb7_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
* 1.1.0
提升预测性能以及易用性
- ```shell
$ hub install efficientnetb7_imagenet==1.1.0
```
modules/image/classification/fix_resnext101_32x48d_wsl_imagenet/README.md
浏览文件 @ be73bfb6
## 命令行预测 # fix_resnext101_32x48d_wsl_imagenet
``` |模型名称|fix_resnext101_32x48d_wsl_imagenet|
hub run fix_resnext101_32x48d_wsl_imagenet --input_path "/PATH/TO/IMAGE" | :--- | :---: |
``` |类别|图像-图像分类|
|网络|ResNeXt|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|3.1GB|
|最新更新日期|-|
|数据指标|-|
## API
```python ## 一、模型基本信息
def get_expected_image_width()
```
返回预处理的图片宽度，也就是224。
```python
def get_expected_image_height()
```
返回预处理的图片高度，也就是224。 - ### 模型介绍
```python - ResNeXt 是由 UC San Diego 和 Facebook AI 研究所于2017年提出的图像分类模型，模型沿袭了 VGG/ResNets 的堆叠思想，并采用 split-transform-merge 策略来增加网络的分支数。该 PaddleHub Module 在包含数十亿张社交媒体图片的数据集上进行弱监督训练，并使用ImageNet-2012数据集finetune，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
def get_pretrained_images_mean()
```
返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
```python ## 二、安装
def get_pretrained_images_std()
```
返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。 - ### 1、环境依赖
- paddlepaddle >= 1.6.2
```python - paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
def context(trainable=True, pretrained=True)
```
**参数**
* trainable (bool): 计算图的参数是否为可训练的； - ### 2、安装
* pretrained (bool): 是否加载默认的预训练模型。
**返回** - ```shell
$ hub install fix_resnext101_32x48d_wsl_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量； ## 三、模型API预测
* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
* classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
* feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
* context\_prog(fluid.Program): 计算图，用于迁移学习。
```python - ### 1、命令行预测
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
**参数** - ```shell
$ hub run fix_resnext101_32x48d_wsl_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； - ### 2、预测代码示例
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU 来预测；
* top\_k (int): 返回预测结果的前 k 个。
**返回** - ```python
import paddlehub as hub
import cv2
res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。 classifier = hub.Module(name="fix_resnext101_32x48d_wsl_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
```python - ### 3、API
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
将模型保存到指定路径。
**参数** - ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
* dirname: 存在模型的目录名称 - images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
* model\_filename: 模型文件名称，默认为\_\_model\_\_ - paths (list\[str\]): 图片的路径； <br/>
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效) - batch\_size (int): batch 的大小；<br/>
* combined: 是否将参数保存到统一的一个文件中 - use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
## 代码示例 - **返回**
```python - res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
import paddlehub as hub
import cv2
classifier = hub.Module(name="fix_resnext101_32x48d_wsl_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
## 服务部署
PaddleHub Serving可以部署一个在线图像识别服务。 ## 四、服务部署
## 第一步：启动PaddleHub Serving - PaddleHub Serving可以部署一个图像识别的在线服务。
运行启动命令： - ### 第一步：启动PaddleHub Serving
```shell
$ hub serving start -m fix_resnext101_32x48d_wsl_imagenet
```
这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。 - 运行启动命令：
- ```shell
$ hub serving start -m fix_resnext101_32x48d_wsl_imagenet
```
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
## 第二步：发送预测请求 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - ### 第二步：发送预测请求
```python - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
import requests
import json
import cv2
import base64
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image): def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1] data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8') return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/fix_resnext101_32x48d_wsl_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 发送HTTP请求 # 打印预测结果
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]} print(r.json()["results"])
headers = {"Content-type": "application/json"} ```
url = "http://127.0.0.1:8866/predict/fix_resnext101_32x48d_wsl_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
### 查看代码 ## 五、更新历史
https://github.com/PaddlePaddle/PaddleClas * 1.0.0
### 依赖 初始发布
- ```shell
paddlepaddle >= 1.6.2 $ hub install fix_resnext101_32x48d_wsl_imagenet==1.0.0
```
paddlehub >= 1.6.0
modules/image/classification/food_classification/README.md
浏览文件 @ be73bfb6
# food_classification # food_classification
类别 图像 - 图像分类 |模型名称|food_classification|
| :--- | :---: |
网络 ResNet50_vd_ssld |类别|图像-图像分类|
|网络|ResNet50_vd_ssld|
|数据集|美食数据集|
> 模型概述 |是否支持Fine-tuning|否|
|模型大小|91MB|
美食分类（food_classification），该模型可识别苹果派，小排骨，烤面包，牛肉馅饼，牛肉鞑靼。该PaddleHub Module支持API预测及命令行预测。 |最新更新日期|-|
|数据指标|-|
> 选择模型版本进行安装
```shell ## 一、模型基本信息
$ hub install food_classification==1.0.0
```
> Module API说明
- ### 模型介绍
```python
def predict(self, - 美食分类（food_classification），该模型可识别苹果派，小排骨，烤面包，牛肉馅饼，牛肉鞑靼。该PaddleHub Module支持API预测及命令行预测。
images=None,
paths=None, ## 二、安装
batch_size=1,
use_gpu=False, - ### 1、环境依赖
**kwargs):
``` - paddlepaddle >= 2.0.0
美食分类预测接口，输入一张图像，输出该图像上食物的类别
- paddlehub >= 2.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
参数
- paddlex >= 1.3.7
* images (list[numpy.ndarray]): 图片数据，ndarray.shape 为 [H, W, C]，BGR格式；
* paths (list[str]): 图片的路径；
* batch_size (int): batch 的大小； - ### 2、安装
* use_gpu (bool): 是否使用 GPU；
- ```shell
返回 $ hub install food_classification
```
* res (list[dict]): 识别结果的列表，列表中每一个元素为 dict，各字段为： - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
* category_id (int): 类别的id； | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
* category（str）: 类别;
* score（float）: 准确率; ## 三、模型API预测
## 代码示例 - ### 1、命令行预测
### API调用 - ```shell
$ hub run food_classification --input_path /PATH/TO/IMAGE
```python ```
import cv2 - 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
import paddlehub as hub
- ### 2、预测代码示例
module = hub.Module(name="food_classification")
- ```python
images = [cv2.imread('PATH/TO/IMAGE')] import paddlehub as hub
import cv2
# execute predict and print the result
results = module.predict(images=images) classifier = hub.Module(name="food_classification")
for result in results: images = [cv2.imread('/PATH/TO/IMAGE')]
print(result) results = classifier.predict(images=images)
``` for result in results:
print(result)
### 命令行调用 ```
```shell
$ hub run food_classification --input_path /PATH/TO/IMAGE --use_gpu True - ### 3、API
```
- ```python
## 效果展示 def predict(images)
```
### 原图 - 分类接口API。
<img src="/docs/imgs/Readme_Related/Image_Classification_apple_pie.png"> - **参数**
- images：list类型，待检测的图像。
### 输出结果
```python - **返回**
[{'category_id': 0, 'category': 'apple_pie', 'score': 0.9985085}] - result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型:
``` - category_id (int): 类别的id；
- category（str）: 类别;
## 贡献者 - score（float）: 准确率
彭兆帅、郑博培
## 依赖
paddlepaddle >= 2.0.0
paddlehub >= 2.0.0 ## 四、更新历史
paddlex >= 1.3.7 * 1.0.0
初始发布
- ```shell
$ hub install food_classification==1.0.0
```
modules/image/classification/food_classification/requirements.txt
浏览文件 @ be73bfb6
paddlepaddle >= 2.0.0 paddlepaddle >= 2.0.0
paddlehub >= 2.0.0 paddlehub >= 2.0.0
paddlex >= 1.3.7 paddlex == 1.3.7
modules/image/classification/googlenet_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# googlenet_imagenet
|模型名称|googlenet_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|GoogleNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|28MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- GoogleNet是图像分类中的经典模型。由Christian Szegedy等人在2014年提出，并获得了2014年ILSVRC竞赛冠军。该PaddleHub Module结构为GoogleNet，基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install googlenet_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run googlenet_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="googlenet_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install googlenet_imagenet==1.0.0
```
modules/image/classification/inception_v4_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# inception_v4_imagenet
|模型名称|inception_v4_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|Inception_V4|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|167MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- Inception 结构最初由 GoogLeNet 引入，因此 GoogLeNet 也被称为 Inception-v1，通过在 Inception-v1 的基础上引入Batch Normalization、分解、残差连接等技术，设计出了Inception-v4。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install inception_v4_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run inception_v4_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="inception_v4_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率。
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install inception_v4_imagenet==1.0.0
```
modules/image/classification/marine_biometrics/README.md
浏览文件 @ be73bfb6
marine_biometrics # marine_biometrics
类别 图像 - 图像分类 |模型名称|marine_biometrics|
| :--- | :---: |
网络 ResNet50_vd_ssld |类别|图像-图像分类|
|网络|ResNet50_vd_ssld|
数据集 Fish4Knowledge |数据集|Fish4Knowledge|
|是否支持Fine-tuning|否|
# 模型概述 |模型大小|84MB|
海洋生物识别（marine_biometrics），该模型可准确识别鱼的种类。该PaddleHub Module支持API预测及命令行预测。 |最新更新日期|-|
|数据指标|-|
# 选择模型版本进行安装
$ hub install marine_biometrics==1.0.0
## 一、模型基本信息
# 在线体验
[AI Studio快速体验](https://aistudio.baidu.com/aistudio/projectdetail/1667809)
# 命令行预测示例 - ### 模型介绍
$ hub run marine_biometrics --image 1.png --use_gpu True
- 海洋生物识别（marine_biometrics），该模型可准确识别鱼的种类。该PaddleHub Module支持API预测及命令行预测。
# Module API说明
## def predict(data) ## 二、安装
海洋生物识别预测接口，输入一张图像，输出该图像上鱼的类别
### 参数 - ### 1、环境依赖
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- paddlepaddle >= 2.0.0
### 返回
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率 - paddlehub >= 2.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
# 代码示例
- ### 2、安装
## API调用
- ```shell
~~~ $ hub install marine_biometrics
import cv2 ```
import paddlehub as hub - 如您安装时遇到问题，可参考：[零基础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)
module = hub.Module(name="MarineBiometrics")
## 三、模型API预测
images = [cv2.imread('PATH/TO/IMAGE')]
- ### 1、命令行预测
# execute predict and print the result
results = module.predict(images=images) - ```shell
for result in results: $ hub run marine_biometrics --input_path "/PATH/TO/IMAGE"
print(result) ```
~~~ - 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
## 命令行调用 - ### 2、预测代码示例
~~~
$ hub run marine_biometrics --image 1.png --use_gpu True - ```python
~~~ import paddlehub as hub
import cv2
# 效果展示
classifier = hub.Module(name="marine_biometrics")
## 原图 images = [cv2.imread('/PATH/TO/IMAGE')]
<img src="/docs/imgs/Readme_Related/Image_Classification_MarineBiometrics.png"> results = classifier.predict(images=images)
for result in results:
## 输出结果 print(result)
~~~ ```
[{'category_id': 16, 'category': 'Plectroglyphidodon_dickii', 'score': 0.9932127}]
~~~ - ### 3、API
# 贡献者 - ```python
郑博培、彭兆帅 def predict(images)
```
# 依赖 - 分类接口API。
paddlepaddle >= 2.0.0 - **参数**
- images：list类型，待检测的图像。
paddlehub >= 2.0.0
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率
## 四、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install marine_biometrics==1.0.0
```
modules/image/classification/mobilenet_v2_animals/README.md
浏览文件 @ be73bfb6
```shell # mobilenet_v2_animals
$ hub install mobilenet_v2_animals==1.0.0
```
<p align="center"> |模型名称|mobilenet_v2_animals|
<img src="http://bj.bcebos.com/ibox-thumbnail98/e7b22762cf42ab0e1e1fab6b8720938b?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-04-08T11%3A49%3A16Z%2F1800%2F%2Faf385f56da3c8ee1298588939d93533a72203c079ae1187affa2da555b9898ea" hspace='5' width=800/> <br /> MobileNet 系列的网络结构 | :--- | :---: |
</p> |类别|图像-图像分类|
|网络|MobileNet_v2|
|数据集|百度自建动物数据集|
|是否支持Fine-tuning|否|
|模型大小|50MB|
|最新更新日期|-|
|数据指标|-|
模型的详情可参考[论文](https://arxiv.org/pdf/1801.04381.pdf)
## 命令行预测 ## 一、模型基本信息
```
hub run mobilenet_v2_animals --input_path "/PATH/TO/IMAGE"
```
## API
```python - ### 模型介绍
def get_expected_image_width()
```
返回预处理的图片宽度，也就是224。 - MobileNet V2 是一个轻量化的卷积神经网络，它在 MobileNet 的基础上，做了 Inverted Residuals 和 Linear bottlenecks 这两大改进。该 PaddleHub Module 是在百度自建动物数据集上训练得到的，可用于图像分类和特征提取，当前已支持7978种动物的分类识别。模型的详情可参考[论文](https://arxiv.org/pdf/1801.04381.pdf)。
```python
def get_expected_image_height()
```
返回预处理的图片高度，也就是224。
```python ## 二、安装
def get_pretrained_images_mean()
```
返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。 - ### 1、环境依赖
```python - paddlepaddle >= 1.6.2
def get_pretrained_images_std()
```
返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。 - paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
```python - ### 2、安装
def context(trainable=True, pretrained=True)
```
**参数** - ```shell
$ hub install mobilenet_v2_animals
```
- 如您安装时遇到问题，可参考：[零基础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)
* trainable (bool): 计算图的参数是否为可训练的； ## 三、模型API预测
* pretrained (bool): 是否加载默认的预训练模型。
**返回** - ### 1、命令行预测
* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量； - ```shell
* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为： $ hub run mobilenet_v2_animals --input_path "/PATH/TO/IMAGE"
* classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出； ```
* feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。 - 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* context\_prog(fluid.Program): 计算图，用于迁移学习。
```python - ### 2、预测代码示例
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
**参数** - ```python
import paddlehub as hub
import cv2
* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； classifier = hub.Module(name="mobilenet_v2_animals")
* paths (list\[str\]): 图片的路径； result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
* batch\_size (int): batch 的大小； # or
* use\_gpu (bool): 是否使用 GPU 来预测； # result = classifier.classification(paths=['/PATH/TO/IMAGE'])
* top\_k (int): 返回预测结果的前 k 个。 ```
**返回** - ### 3、API
res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。
```python - ```python
def save_inference_model(dirname, def classification(images=None,
model_filename=None, paths=None,
params_filename=None, batch_size=1,
combined=True) use_gpu=False,
``` top_k=1):
```
- 分类接口API。
- **参数**
将模型保存到指定路径。 - images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
**参数** - **返回**
* dirname: 存在模型的目录名称 - res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
* model_filename: 模型文件名称，默认为\_\_model\_\_
* params_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中
## 代码示例
```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="mobilenet_v2_animals") ## 四、服务部署
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')]) - PaddleHub Serving可以部署一个动物识别的在线服务。
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
## 服务部署 - ### 第一步：启动PaddleHub Serving
PaddleHub Serving可以部署一个在线动物识别服务。 - 运行启动命令：
- ```shell
$ hub serving start -m mobilenet_v2_animals
```
## 第一步：启动PaddleHub Serving - 这样就完成了一个动物识别的在线服务的部署，默认端口号为8866。
运行启动命令： - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
```shell
$ hub serving start -m mobilenet_v2_animals
```
这样就完成了一个在线动物识别服务化API的部署，默认端口号为8866。 - ### 第二步：发送预测请求
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
## 第二步：发送预测请求 - ```python
import requests
import json
import cv2
import base64
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
```python # 发送HTTP请求
import requests data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
import json headers = {"Content-type": "application/json"}
import cv2 url = "http://127.0.0.1:8866/predict/mobilenet_v2_animals"
import base64 r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
## 五、更新历史
# 发送HTTP请求 * 1.0.0
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/mobilenet_v2_animals"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果 初始发布
print(r.json()["results"]) - ```shell
``` $ hub install mobilenet_v2_animals==1.0.0
```
### 查看代码
[PaddlePaddle/models 图像分类](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification)
### 依赖
paddlepaddle >= 1.6.2
paddlehub >= 1.6.0
modules/image/classification/mobilenet_v2_dishes/README.md
浏览文件 @ be73bfb6
```shell # mobilenet_v2_dishes
$ hub install mobilenet_v2_dishes==1.0.0
```
<p align="center"> |模型名称|mobilenet_v2_dishes|
<img src="http://bj.bcebos.com/ibox-thumbnail98/e7b22762cf42ab0e1e1fab6b8720938b?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-04-08T11%3A49%3A16Z%2F1800%2F%2Faf385f56da3c8ee1298588939d93533a72203c079ae1187affa2da555b9898ea" hspace='5' width=800/> <br /> MobileNet 系列的网络结构 | :--- | :---: |
</p> |类别|图像-图像分类|
|网络|MobileNet_v2|
模型的详情可参考[论文](https://arxiv.org/pdf/1801.04381.pdf) |数据集|百度自建菜品数据集|
|是否支持Fine-tuning|否|
## 命令行预测 |模型大小|52MB|
|最新更新日期|-|
|数据指标|-|
```
hub run mobilenet_v2_dishes --input_path "/PATH/TO/IMAGE"
```
## API ## 一、模型基本信息
```python
def get_expected_image_width()
```
返回预处理的图片宽度，也就是224。
```python - ### 模型介绍
def get_expected_image_height()
```
返回预处理的图片高度，也就是224。 - MobileNet V2 是一个轻量化的卷积神经网络，它在 MobileNet 的基础上，做了 Inverted Residuals 和 Linear bottlenecks 这两大改进。该 PaddleHub Module 是在百度自建菜品数据集上训练得到的，可用于图像分类和特征提取，当前已支持8416种菜品的分类识别。
```python <p align="center">
def get_pretrained_images_mean() <img src="http://bj.bcebos.com/ibox-thumbnail98/e7b22762cf42ab0e1e1fab6b8720938b?authorization=bce-auth-v1%2Ffbe74140929444858491fbf2b6bc0935%2F2020-04-08T11%3A49%3A16Z%2F1800%2F%2Faf385f56da3c8ee1298588939d93533a72203c079ae1187affa2da555b9898ea" width = "800" hspace='10'/> <br />
``` </p>
返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
```python
def get_pretrained_images_std()
```
返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。 - 更多详情参考：[MobileNetV2: Inverted Residuals and Linear Bottlenecks](https://arxiv.org/pdf/1801.04381.pdf)
## 二、安装
```python - ### 1、环境依赖
def context(trainable=True, pretrained=True)
```
**参数** - paddlepaddle >= 1.6.2
* trainable (bool): 计算图的参数是否为可训练的； - paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
* pretrained (bool): 是否加载默认的预训练模型。
**返回**
* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量； - ### 2、安装
* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
* classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
* feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
* context\_prog(fluid.Program): 计算图，用于迁移学习。
```python - ```shell
def classification(images=None, $ hub install mobilenet_v2_dishes
paths=None, ```
batch_size=1, - 如您安装时遇到问题，可参考：[零基础windows安装](../../../../docs/docs_ch/get_start/windows_quickstart.md)
use_gpu=False, | [零基础Linux安装](../../../../docs/docs_ch/get_start/linux_quickstart.md) | [零基础MacOS安装](../../../../docs/docs_ch/get_start/mac_quickstart.md)
top_k=1):
```
**参数** ## 三、模型API预测
* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； - ### 1、命令行预测
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU 来预测；
* top\_k (int): 返回预测结果的前 k 个。
**返回** - ```shell
$ hub run mobilenet_v2_dishes --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现菜品分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。 - ### 2、预测代码示例
```python - ```python
def save_inference_model(dirname, import paddlehub as hub
model_filename=None, import cv2
params_filename=None,
combined=True)
```
将模型保存到指定路径。 classifier = hub.Module(name="mobilenet_v2_dishes")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
**参数** - ### 3、API
* dirname: 存在模型的目录名称 - ```python
* model_filename: 模型文件名称，默认为\_\_model\_\_ def classification(images=None,
* params_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效) paths=None,
* combined: 是否将参数保存到统一的一个文件中 batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
## 代码示例 - images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
```python - **返回**
import paddlehub as hub
import cv2
classifier = hub.Module(name="mobilenet_v2_dishes") - res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
## 服务部署
PaddleHub Serving可以部署一个菜品分类的在线服务。
## 第一步：启动PaddleHub Serving ## 四、服务部署
运行启动命令： - PaddleHub Serving可以部署一个菜品分类的在线服务。
```shell
$ hub serving start -m mobilenet_v2_dishes
```
这样就完成了一个菜品分类的在线服务的部署，默认端口号为8866。 - ### 第一步：启动PaddleHub Serving
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - 运行启动命令：
- ```shell
$ hub serving start -m mobilenet_v2_dishes
```
## 第二步：发送预测请求 - 这样就完成了一个菜品分类的在线服务的部署，默认端口号为8866。
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
```python - ### 第二步：发送预测请求
import requests
import json
import cv2
import base64
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
def cv2_to_base64(image): - ```python
data = cv2.imencode('.jpg', image)[1] import requests
return base64.b64encode(data.tostring()).decode('utf8') import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求 # 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]} data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"} headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/mobilenet_v2_dishes" url = "http://127.0.0.1:8866/predict/mobilenet_v2_dishes"
r = requests.post(url=url, headers=headers, data=json.dumps(data)) r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果 # 打印预测结果
print(r.json()["results"]) print(r.json()["results"])
``` ```
### 查看代码
[PaddlePaddle/models 图像分类](https://github.com/PaddlePaddle/models/tree/develop/PaddleCV/image_classification) ## 五、更新历史
### 依赖 * 1.0.0
paddlepaddle >= 1.6.2 初始发布
paddlehub >= 1.6.0 - ```shell
$ hub install mobilenet_v2_dishes==1.0.0
```
modules/image/classification/mobilenet_v2_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# mobilenet_v2_imagenet
|模型名称|mobilenet_v2_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|Mobilenet_v2|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|15MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- MobileNet V2是Mark Sandler, Andrew Howard等人在2018年提出的一个图像分类模型，该系列模型（MobileNet）是为移动和嵌入式设备提出的高效模型，在模型参数较少的情况下仍然保持了较高的分类准确率。该PaddleHub Module基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install mobilenet_v2_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run mobilenet_v2_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="mobilenet_v2_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率
## 四、更新历史
* 1.0.0
初始发布
* 1.0.1
修复python2中编码问题
- ```shell
$ hub install mobilenet_v2_imagenet==1.0.1
```
modules/image/classification/mobilenet_v2_imagenet_ssld/README.md 0 → 100644
浏览文件 @ be73bfb6
# mobilenet_v2_imagenet_ssld
|模型名称|mobilenet_v2_imagenet_ssld|
| :--- | :---: |
|类别|图像-图像分类|
|网络|Mobilenet_v2|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|15MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- MobileNet V2是Mark Sandler, Andrew Howard等人在2018年提出的一个图像分类模型，该系列模型（MobileNet）是为移动和嵌入式设备提出的高效模型，在模型参数较少的情况下仍然保持了较高的分类准确率。该PaddleHub Module基于ImageNet-2012数据集并采用PaddleClas提供的SSLD蒸馏方法训练得到，接受输入图片大小为224 x 224 x 3，支持finetune，也可以直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install mobilenet_v2_imagenet_ssld
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run mobilenet_v2_imagenet_ssld --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="mobilenet_v2_imagenet_ssld")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m mobilenet_v2_imagenet_ssld
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/mobilenet_v2_imagenet_ssld"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install mobilenet_v2_imagenet_ssld==1.0.0
```
modules/image/classification/mobilenet_v3_large_imagenet_ssld/README.md 0 → 100644
浏览文件 @ be73bfb6
# mobilenet_v3_large_imagenet_ssld
|模型名称|mobilenet_v3_large_imagenet_ssld|
| :--- | :---: |
|类别|图像-图像分类|
|网络|Mobilenet_v3_large|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|23MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- MobileNetV3是Google在2019年发布的新模型，作者通过结合NAS与NetAdapt进行搜索得到该网络结构，提供了Large和Small两个版本，分别适用于对资源不同要求的情况。对比于MobileNetV2，新的模型在速度和精度方面均有提升。该PaddleHubModule的模型结构为MobileNetV3 Large，基于ImageNet-2012数据集并采用PaddleClas提供的SSLD蒸馏方法训练得到，接受输入图片大小为224 x 224 x 3，支持finetune，也可以直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install mobilenet_v3_large_imagenet_ssld
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run mobilenet_v3_large_imagenet_ssld --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="mobilenet_v3_large_imagenet_ssld")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m mobilenet_v3_large_imagenet_ssld
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/mobilenet_v3_large_imagenet_ssld"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install mobilenet_v3_large_imagenet_ssld==1.0.0
```
modules/image/classification/mobilenet_v3_small_imagenet_ssld/README.md 0 → 100644
浏览文件 @ be73bfb6
# mobilenet_v3_small_imagenet_ssld
|模型名称|mobilenet_v3_small_imagenet_ssld|
| :--- | :---: |
|类别|图像-图像分类|
|网络|Mobilenet_v3_Small|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|13MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- MobileNetV3是Google在2019年发布的新模型，作者通过结合NAS与NetAdapt进行搜索得到该网络结构，提供了Large和Small两个版本，分别适用于对资源不同要求的情况。对比于MobileNetV2，新的模型在速度和精度方面均有提升。该PaddleHubModule的模型结构为MobileNetV3 Small，基于ImageNet-2012数据集并采用PaddleClas提供的SSLD蒸馏方法训练得到，接受输入图片大小为224 x 224 x 3，支持finetune，也可以直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install mobilenet_v3_small_imagenet_ssld
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run mobilenet_v3_small_imagenet_ssld --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="mobilenet_v3_small_imagenet_ssld")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m mobilenet_v3_small_imagenet_ssld
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/mobilenet_v3_small_imagenet_ssld"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install mobilenet_v3_small_imagenet_ssld==1.0.0
```
modules/image/classification/nasnet_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# nasnet_imagenet
|模型名称|nasnet_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|NASNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|345MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- NASNet是Google通过AutoML自动训练出来的图像分类模型。该PaddleHub Module基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install nasnet_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run nasnet_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="nasnet_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率
## 四、更新历史
* 1.0.0
初始发布
* 1.0.1
修复python2中编码问题
- ```shell
$ hub install nasnet_imagenet==1.0.1
```
modules/image/classification/pnasnet_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# pnasnet_imagenet
|模型名称|pnasnet_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|PNASNet|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|333MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- PNASNet是Google通过AutoML自动训练出来的图像分类模型。该PaddleHub Module基于ImageNet-2012数据集训练，接受输入图片大小为224 x 224 x 3，支持直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.4.0
- paddlehub >= 1.0.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install pnasnet_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run pnasnet_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现图像分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="pnasnet_imagenet")
test_img_path = "/PATH/TO/IMAGE"
input_dict = {"image": [test_img_path]}
result = classifier.classification(data=input_dict)
```
- ### 3、API
- ```python
def classification(data)
```
- 分类接口API。
- **参数**
- data：dict类型，key为image，str类型，value为待检测的图片路径，list类型。
- **返回**
- result：list类型，每个元素为对应输入图片的预测结果。预测结果为dict类型，key为该图片分类结果label，value为该label对应的概率
## 四、更新历史
* 1.0.0
初始发布
* 1.0.1
修复python2中编码问题
- ```shell
$ hub install pnasnet_imagenet==1.0.1
```
modules/image/classification/res2net101_vd_26w_4s_imagenet/README.md
浏览文件 @ be73bfb6
## 命令行预测 # res2net101_vd_26w_4s_imagenet
``` |模型名称|res2net101_vd_26w_4s_imagenet|
hub run res2net101_vd_26w_4s_imagenet --input_path "/PATH/TO/IMAGE" | :--- | :---: |
``` |类别|图像-图像分类|
|网络|Res2Net|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|179MB|
|最新更新日期|-|
|数据指标|-|
## API
```python ## 一、模型基本信息
def get_expected_image_width()
```
返回预处理的图片宽度，也就是224。
```python
def get_expected_image_height()
```
返回预处理的图片高度，也就是224。 - ### 模型介绍
```python - Res2Net是2019年提出的一种全新的对ResNet的改进方案，该方案可以和现有其他优秀模块轻松整合，在不增加计算负载量的情况下，在ImageNet、CIFAR-100等数据集上的测试性能超过了ResNet。Res2Net结构简单，性能优越，进一步探索了CNN在更细粒度级别的多尺度表示能力。 该 PaddleHub Module 使用 ImageNet-2012数据集训练，接受输入图片大小为 224 x 224 x 3，支持直接通过命令行或者 Python 接口进行预测。
def get_pretrained_images_mean()
```
返回预处理的图片均值，也就是 \[0.485, 0.456, 0.406\]。
```python ## 二、安装
def get_pretrained_images_std()
```
返回预处理的图片标准差，也就是 \[0.229, 0.224, 0.225\]。 - ### 1、环境依赖
- paddlepaddle >= 1.6.2
```python - paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
def context(trainable=True, pretrained=True)
```
**参数**
* trainable (bool): 计算图的参数是否为可训练的； - ### 2、安装
* pretrained (bool): 是否加载默认的预训练模型。
**返回** - ```shell
$ hub install res2net101_vd_26w_4s_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
* inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量； ## 三、模型API预测
* outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
* classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
* feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
* context\_prog(fluid.Program): 计算图，用于迁移学习。
```python - ### 1、命令行预测
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
**参数** - ```shell
$ hub run res2net101_vd_26w_4s_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
* images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； - ### 2、预测代码示例
* paths (list\[str\]): 图片的路径；
* batch\_size (int): batch 的大小；
* use\_gpu (bool): 是否使用 GPU 来预测；
* top\_k (int): 返回预测结果的前 k 个。
**返回** - ```python
import paddlehub as hub
import cv2
res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别动物的类别，value为置信度。 classifier = hub.Module(name="res2net101_vd_26w_4s_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
```python - ### 3、API
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
将模型保存到指定路径。
**参数** - ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
* dirname: 存在模型的目录名称 - images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
* model\_filename: 模型文件名称，默认为\_\_model\_\_ - paths (list\[str\]): 图片的路径； <br/>
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效) - batch\_size (int): batch 的大小；<br/>
* combined: 是否将参数保存到统一的一个文件中 - use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
## 代码示例 - **返回**
```python - res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
import paddlehub as hub
import cv2
classifier = hub.Module(name="res2net101_vd_26w_4s_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
## 服务部署 ## 四、服务部署
PaddleHub Serving可以部署一个在线图像识别服务。 - PaddleHub Serving可以部署一个图像识别的在线服务。
## 第一步：启动PaddleHub Serving - ### 第一步：启动PaddleHub Serving
运行启动命令： - 运行启动命令：
```shell - ```shell
$ hub serving start -m res2net101_vd_26w_4s_imagenet $ hub serving start -m res2net101_vd_26w_4s_imagenet
``` ```
这样就完成了一个在线图像识别服务化API的部署，默认端口号为8866。 - 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
**NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。 - **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
## 第二步：发送预测请求 - ### 第二步：发送预测请求
配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果 - 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
```python - ```python
import requests import requests
import json import json
import cv2 import cv2
import base64 import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
def cv2_to_base64(image): # 发送HTTP请求
data = cv2.imencode('.jpg', image)[1] data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
return base64.b64encode(data.tostring()).decode('utf8') headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/res2net101_vd_26w_4s_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/res2net101_vd_26w_4s_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果 ## 五、更新历史
print(r.json()["results"])
```
### 查看代码 * 1.0.0
https://github.com/PaddlePaddle/PaddleClas 初始发布
### 依赖 - ```shell
$ hub install res2net101_vd_26w_4s_imagenet==1.0.0
paddlepaddle >= 1.6.2 ```
paddlehub >= 1.6.0
modules/image/classification/resnet18_vd_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
# resnet18_vd_imagenet
|模型名称|resnet18_vd_imagenet|
| :--- | :---: |
|类别|图像-图像分类|
|网络|ResNet_vd|
|数据集|ImageNet-2012|
|是否支持Fine-tuning|否|
|模型大小|46MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- ResNet系列模型是图像分类领域的重要模型之一，模型中提出的残差单元有效地解决了深度网络训练困难的问题，通过增加模型的深度提升了模型的准确率，ResNet-vd 其实就是 ResNet-D，是ResNet 原始结构的变种。该PaddleHub Module结构为ResNet_vd，基于ImageNet-2012数据集训练得到，接受输入图片大小为224 x 224 x 3，支持finetune，也可以直接通过命令行或者Python接口进行预测。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install resnet18_vd_imagenet
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、命令行预测
- ```shell
$ hub run resnet18_vd_imagenet --input_path "/PATH/TO/IMAGE"
```
- 通过命令行方式实现分类模型的调用，更多请见 [PaddleHub命令行指令](../../../../docs/docs_ch/tutorial/cmd_usage.rst)
- ### 2、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="resnet18_vd_imagenet")
result = classifier.classification(images=[cv2.imread('/PATH/TO/IMAGE')])
# or
# result = classifier.classification(paths=['/PATH/TO/IMAGE'])
```
- ### 3、API
- ```python
def classification(images=None,
paths=None,
batch_size=1,
use_gpu=False,
top_k=1):
```
- 分类接口API。
- **参数**
- images (list\[numpy.ndarray\]): 图片数据，每一个图片数据的shape 均为 \[H, W, C\]，颜色空间为 BGR； <br/>
- paths (list\[str\]): 图片的路径； <br/>
- batch\_size (int): batch 的大小；<br/>
- use\_gpu (bool): 是否使用 GPU；**若使用GPU，请先设置CUDA_VISIBLE_DEVICES环境变量** <br/>
- top\_k (int): 返回预测结果的前 k 个。
- **返回**
- res (list\[dict\]): 分类结果，列表的每一个元素均为字典，其中 key 为识别的菜品类别，value为置信度。
## 四、服务部署
- PaddleHub Serving可以部署一个图像识别的在线服务。
- ### 第一步：启动PaddleHub Serving
- 运行启动命令：
- ```shell
$ hub serving start -m resnet18_vd_imagenet
```
- 这样就完成了一个图像识别的在线服务的部署，默认端口号为8866。
- **NOTE:** 如使用GPU预测，则需要在启动服务之前，请设置CUDA\_VISIBLE\_DEVICES环境变量，否则不用设置。
- ### 第二步：发送预测请求
- 配置好服务端，以下数行代码即可实现发送预测请求，获取预测结果
- ```python
import requests
import json
import cv2
import base64
def cv2_to_base64(image):
data = cv2.imencode('.jpg', image)[1]
return base64.b64encode(data.tostring()).decode('utf8')
# 发送HTTP请求
data = {'images':[cv2_to_base64(cv2.imread("/PATH/TO/IMAGE"))]}
headers = {"Content-type": "application/json"}
url = "http://127.0.0.1:8866/predict/resnet18_vd_imagenet"
r = requests.post(url=url, headers=headers, data=json.dumps(data))
# 打印预测结果
print(r.json()["results"])
```
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install resnet18_vd_imagenet==1.0.0
```
modules/image/classification/resnet50_vd_10w/README.md 0 → 100644
浏览文件 @ be73bfb6
# resnet50_vd_10w
|模型名称|resnet50_vd_10w|
| :--- | :---: |
|类别|图像-图像分类|
|网络|ResNet_vd|
|数据集|百度自建数据集|
|是否支持Fine-tuning|否|
|模型大小|92MB|
|最新更新日期|-|
|数据指标|-|
## 一、模型基本信息
- ### 模型介绍
- ResNet系列模型是图像分类领域的重要模型之一，模型中提出的残差单元有效地解决了深度网络训练困难的问题，通过增加模型的深度提升了模型的准确率，ResNet-vd 其实就是 ResNet-D，是ResNet 原始结构的变种。该PaddleHub Module结构为ResNet_vd，使用百度自研的基于10万种类别、4千多万的有标签数据进行训练，接受输入图片大小为224 x 224 x 3，支持finetune。
## 二、安装
- ### 1、环境依赖
- paddlepaddle >= 1.6.2
- paddlehub >= 1.6.0 | [如何安装paddlehub](../../../../docs/docs_ch/get_start/installation.rst)
- ### 2、安装
- ```shell
$ hub install resnet50_vd_10w
```
- 如您安装时遇到问题，可参考：[零基础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)
## 三、模型API预测
- ### 1、预测代码示例
- ```python
import paddlehub as hub
import cv2
classifier = hub.Module(name="resnet50_vd_10w")
input_dict, output_dict, program = classifier.context(trainable=True)
```
- ### 2、API
- ```python
def context(trainable=True, pretrained=True)
```
- **参数**
- trainable (bool): 计算图的参数是否为可训练的；<br/>
- pretrained (bool): 是否加载默认的预训练模型。
- **返回**
- inputs (dict): 计算图的输入，key 为 'image', value 为图片的张量；<br/>
- outputs (dict): 计算图的输出，key 为 'classification' 和 'feature_map'，其相应的值为：
- classification (paddle.fluid.framework.Variable): 分类结果，也就是全连接层的输出；
- feature\_map (paddle.fluid.framework.Variable): 特征匹配，全连接层前面的那个张量。
- context\_prog(fluid.Program): 计算图，用于迁移学习。
- ```python
def save_inference_model(dirname,
model_filename=None,
params_filename=None,
combined=True)
```
- **参数**
- dirname: 存在模型的目录名称；<br/>
- model_filename: 模型文件名称，默认为\_\_model\_\_; <br/>
- params_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效); <br/>
- combined: 是否将参数保存到统一的一个文件中。
## 五、更新历史
* 1.0.0
初始发布
- ```shell
$ hub install resnet50_vd_10w==1.0.0
```
modules/image/classification/se_resnet18_vd_imagenet/README.md
浏览文件 @ be73bfb6
...@@ -84,7 +84,7 @@ def save_inference_model(dirname, ...@@ -84,7 +84,7 @@ def save_inference_model(dirname,
* params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效) * params\_filename: 参数文件名称，默认为\_\_params\_\_(仅当`combined`为True时生效)
* combined: 是否将参数保存到统一的一个文件中 * combined: 是否将参数保存到统一的一个文件中
## 代码示例 ## 预测代码示例
```python ```python
import paddlehub as hub import paddlehub as hub
......
modules/image/classification/vgg11_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
此差异已折叠。
modules/image/classification/vgg13_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
此差异已折叠。
modules/image/classification/vgg16_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
此差异已折叠。
modules/image/classification/vgg19_imagenet/README.md 0 → 100644
浏览文件 @ be73bfb6
此差异已折叠。
Markdown is supported
0% 或 .
You are about to add 0 people to the discussion. Proceed with caution.
先完成此消息的编辑！
想要评论请 注册 或