Add files via upload

pytorch_vision_googlenet.md

@@ -0,0 +1,46 @@
+---
+layout: pytorch_hub_detail
+background-class: pytorch-hub-background
+body-class: pytorch-hub
+title: GoogLeNet
+summary: GoogLeNet was based on a deep convolutional neural network architecture codenamed "Inception" which won ImageNet 2014.
+category: researchers
+image: pytorch-logo.png
+author: Pytorch Team
+tags: [CV, image classification]
+github-link: https://github.com/pytorch/vision.git
+featured_image_1: googlenet1.png
+featured_image_2: googlenet2.png
+---
+
+### Model Description
+
+GoogLeNet was based on a deep convolutional neural network architecture codenamed "Inception", which was responsible for setting the new state of the art for classification and detection in the ImageNet Large-Scale Visual Recognition Challenge 2014 (ILSVRC 2014). The 1-crop error rates on the ImageNet dataset with a pretrained model are list below.
+
+| Model structure | Top-1 error | Top-5 error |
+| --------------- | ----------- | ----------- |
+|  googlenet       | 30.22       | 10.47       |
+
+
+### Notes on Inputs
+
+All pre-trained models expect input images normalized in the same way,
+i.e. mini-batches of 3-channel RGB images of shape `(3 x H x W)`, where `H` and `W` are expected to be at least `224`.
+The images have to be loaded in to a range of `[0, 1]` and then normalized using `mean = [0.485, 0.456, 0.406]`
+and `std = [0.229, 0.224, 0.225]`. You can use the following transform to normalize:
+
+```
+normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                 std=[0.229, 0.224, 0.225])
+```
+
+### Example:
+
+```python
+import torch
+model = torch.hub.load('pytorch/vision', 'googlenet', pretrained=True)
+```
+
+### Resources:
+
+ - [Going Deeper with Convolutions](https://arxiv.org/abs/1409.4842)

pytorch_vision_mobilenet_v2.md

@@ -0,0 +1,46 @@
+---
+layout: pytorch_hub_detail
+background-class: pytorch-hub-background
+body-class: pytorch-hub
+title: MobileNet v2
+summary: The MobileNetV2 architecture is based on an inverted residual structure where the input and output of the residual block are thin bottleneck layers opposite to traditional residual models.
+category: researchers
+image: pytorch-logo.png
+author: Pytorch Team
+tags: [CV, image classification]
+github-link: https://github.com/pytorch/vision.git
+featured_image_1: mobilenet_v2_1.png
+featured_image_2: mobilenet_v2_2.png
+---
+
+### Model Description
+
+The MobileNetV2 architecture is based on an inverted residual structure where the input and output of the residual block are thin bottleneck layers opposite to traditional residual models which use expanded representations in the input. MobileNetV2 uses lightweight depthwise convolutions to filter features in the intermediate expansion layer. Additionally, non-linearities in the narrow layers were removed in order to maintain representational power.
+
+| Model structure | Top-1 error | Top-5 error |
+| --------------- | ----------- | ----------- |
+|  mobilenet_v2       | 28.12       | 9.71       |
+
+
+### Notes on Inputs
+
+All pre-trained models expect input images normalized in the same way,
+i.e. mini-batches of 3-channel RGB images of shape `(3 x H x W)`, where `H` and `W` are expected to be at least `224`.
+The images have to be loaded in to a range of `[0, 1]` and then normalized using `mean = [0.485, 0.456, 0.406]`
+and `std = [0.229, 0.224, 0.225]`. You can use the following transform to normalize:
+
+```
+normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                 std=[0.229, 0.224, 0.225])
+```
+
+### Example:
+
+```python
+import torch
+model = torch.hub.load('pytorch/vision', 'mobilenet_v2', pretrained=True)
+```
+
+### Resources:
+
+ - [MobileNetV2: Inverted Residuals and Linear Bottlenecks](https://arxiv.org/abs/1801.04381)

pytorch_vision_shufflenet_v2.md

@@ -0,0 +1,46 @@
+---
+layout: pytorch_hub_detail
+background-class: pytorch-hub-background
+body-class: pytorch-hub
+title: ShuffleNet v2
+summary: ShuffleNet v2: Based on a series of controlled experiments, this work derives several practical guidelines for efficient network design.
+category: researchers
+image: pytorch-logo.png
+author: Pytorch Team
+tags: [CV, image classification]
+github-link: https://github.com/pytorch/vision.git
+featured_image_1: shufflenet_v2_1.png
+featured_image_2: shufflenet_v2_2.png
+---
+
+### Model Description
+
+Previously, neural network architecture design was mostly guided by the indirect metric of computation complexity, i.e., FLOPs. However, the direct metric, e.g., speed, also depends on the other factors such as memory access cost and platform characteristics. Based on a series of controlled experiments, this work derives several practical guidelines for efficient network design. Accordingly, a new architecture is presented, called ShuffleNet V2. Comprehensive ablation experiments verify that our model is the state of-the-art in terms of speed and accuracy tradeoff.
+
+| Model structure | Top-1 error | Top-5 error |
+| --------------- | ----------- | ----------- |
+|  shufflenet_v2       | 30.64       | 11.68       |
+
+
+### Notes on Inputs
+
+All pre-trained models expect input images normalized in the same way,
+i.e. mini-batches of 3-channel RGB images of shape `(3 x H x W)`, where `H` and `W` are expected to be at least `224`.
+The images have to be loaded in to a range of `[0, 1]` and then normalized using `mean = [0.485, 0.456, 0.406]`
+and `std = [0.229, 0.224, 0.225]`. You can use the following transform to normalize:
+
+```
+normalize = transforms.Normalize(mean=[0.485, 0.456, 0.406],
+                                 std=[0.229, 0.224, 0.225])
+```
+
+### Example:
+
+```python
+import torch
+model = torch.hub.load('pytorch/vision', 'shufflenet_v2_x1_0', pretrained=True)
+```
+
+### Resources:
+
+ - [ShuffleNet V2: Practical Guidelines for Efficient CNN Architecture Design](https://arxiv.org/abs/1807.11164)