Skip to content

Instantly share code, notes, and snippets.

@ypwhs

ypwhs/visulize_mask_rcnn.ipynb

Created June 2, 2019 13:23
Show Gist options

  • Select an option

    Learn more about clone URLs
  • Save ypwhs/8ba634d480435d3f0abd3ad29da39b25 to your computer and use it in GitHub Desktop.

Select an option

Learn more about clone URLs
Save ypwhs/8ba634d480435d3f0abd3ad29da39b25 to your computer and use it in GitHub Desktop.
Download ZIP
Display the source blob
Display the rendered blob
Raw
visulize_mask_rcnn.ipynb
{
"cells": [
{
"cell_type": "code",
"execution_count": 1,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-02T13:16:07.619792Z",
"start_time": "2019-06-02T13:16:06.982260Z"
}
},
"outputs": [],
"source": [
"import numpy as np\n",
"import torchvision\n",
"import skimage.io\n",
"import colorsys\n",
"import random\n",
"import matplotlib.patches as patches\n",
"from matplotlib import pyplot as plt\n",
"from skimage.measure import find_contours\n",
"from matplotlib.patches import Polygon\n",
"\n",
"%matplotlib inline\n",
"%config InlineBackend.figure_format = 'retina'"
]
},
{
"cell_type": "code",
"execution_count": 2,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-02T13:16:07.628009Z",
"start_time": "2019-06-02T13:16:07.621278Z"
}
},
"outputs": [],
"source": [
"class_names = [\n",
" '__background__', 'person', 'bicycle', 'car', 'motorcycle', 'airplane', 'bus',\n",
" 'train', 'truck', 'boat', 'traffic', 'light', 'fire', 'hydrant', 'N/A', 'stop',\n",
" 'sign', 'parking', 'meter', 'bench', 'bird', 'cat', 'dog', 'horse', 'sheep', 'cow',\n",
" 'elephant', 'bear', 'zebra', 'giraffe', 'N/A', 'backpack', 'umbrella', 'N/A', 'N/A',\n",
" 'handbag', 'tie', 'suitcase', 'frisbee', 'skis', 'snowboard', 'sports', 'ball',\n",
" 'kite', 'baseball', 'bat', 'baseball', 'glove', 'skateboard', 'surfboard', 'tennis',\n",
" 'racket', 'bottle', 'N/A', 'wine', 'glass', 'cup', 'fork', 'knife', 'spoon', 'bowl',\n",
" 'banana', 'apple', 'sandwich', 'orange', 'broccoli', 'carrot', 'hot', 'dog', 'pizza',\n",
" 'donut', 'cake', 'chair', 'couch', 'potted', 'plant', 'bed', 'N/A', 'dining', 'table',\n",
" 'N/A', 'N/A', 'toilet', 'N/A', 'tv', 'laptop', 'mouse', 'remote', 'keyboard', 'cell',\n",
" 'phone', 'microwave', 'oven', 'toaster', 'sink', 'refrigerator', 'N/A', 'book',\n",
" 'clock', 'vase', 'scissors', 'teddy', 'bear', 'hair', 'drier', 'toothbrush'\n",
"]"
]
},
{
"cell_type": "code",
"execution_count": 3,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-02T13:16:07.641481Z",
"start_time": "2019-06-02T13:16:07.629774Z"
},
"code_folding": []
},
"outputs": [],
"source": [
"def apply_mask(image, mask, color, alpha=0.5):\n",
" \"\"\"Apply the given mask to the image.\n",
" \"\"\"\n",
" for c in range(3):\n",
" image[:, :, c] = np.where(mask >= 0.5,\n",
" image[:, :, c] *\n",
" (1 - alpha) + alpha * color[c] * 255,\n",
" image[:, :, c])\n",
" return image\n",
"\n",
"def random_colors(N, bright=True):\n",
" \"\"\"\n",
" Generate random colors.\n",
" To get visually distinct colors, generate them in HSV space then\n",
" convert to RGB.\n",
" \"\"\"\n",
" brightness = 1.0 if bright else 0.7\n",
" hsv = [(i / N, 1, brightness) for i in range(N)]\n",
" colors = list(map(lambda c: colorsys.hsv_to_rgb(*c), hsv))\n",
" random.shuffle(colors)\n",
" return colors\n",
"\n",
"def display_instances(image, boxes, masks, labels, class_names,\n",
" scores=None, title=\"\",\n",
" figsize=(16, 16), ax=None):\n",
" \"\"\"\n",
" boxes: [num_instance, (y1, x1, y2, x2, class_id)] in image coordinates.\n",
" masks: [height, width, num_instances]\n",
" labels: [num_instances]\n",
" class_names: list of class names of the dataset\n",
" scores: (optional) confidence scores for each box\n",
" figsize: (optional) the size of the image.\n",
" \"\"\"\n",
" # Number of instances\n",
" N = boxes.shape[0]\n",
" if not N:\n",
" print(\"\\n*** No instances to display *** \\n\")\n",
" assert boxes.shape[0] == masks.shape[0] == labels.shape[0]\n",
"\n",
" if not ax:\n",
" _, ax = plt.subplots(1, figsize=figsize)\n",
"\n",
" # Generate random colors\n",
" colors = random_colors(N)\n",
"\n",
" # Show area outside image boundaries.\n",
" height, width = image.shape[:2]\n",
" ax.set_ylim(height + 10, -10)\n",
" ax.set_xlim(-10, width + 10)\n",
" ax.axis('off')\n",
" ax.set_title(title)\n",
"\n",
" masked_image = image.astype(np.uint32).copy()\n",
" for i in range(N):\n",
" color = colors[i]\n",
"\n",
" score = scores[i] if scores is not None else None\n",
" if score < 0.55:\n",
" continue\n",
"\n",
" x1, y1, x2, y2, = boxes[i]\n",
" p = patches.Rectangle((x1, y1), x2 - x1, y2 - y1, linewidth=2,\n",
" alpha=0.7, linestyle=\"dashed\",\n",
" edgecolor=color, facecolor='none')\n",
" ax.add_patch(p)\n",
"\n",
" # Label\n",
" labels_id = labels[i]\n",
" label = class_names[labels_id]\n",
" caption = \"{} {:.3f}\".format(label, score) if score else label\n",
" ax.text(x1, y1 + 8, caption,\n",
" color='w', size=11, backgroundcolor=\"none\")\n",
"\n",
" # Mask\n",
" mask = masks[i, :, :].detach().squeeze(-1)\n",
" masked_image = apply_mask(masked_image, mask, color)\n",
"\n",
" # Mask Polygon\n",
" # Pad to ensure proper polygons for masks that touch image edges.\n",
" padded_mask = np.zeros(\n",
" (mask.shape[1] + 2, mask.shape[2] + 2), dtype=np.uint8)\n",
" padded_mask[1:-1, 1:-1] = mask\n",
" contours = find_contours(padded_mask, 0.5)\n",
" for verts in contours:\n",
" # Subtract the padding and flip (y, x) to (x, y)\n",
" verts = np.fliplr(verts) - 1\n",
" p = Polygon(verts, facecolor=\"none\", edgecolor=color)\n",
" ax.add_patch(p)\n",
" ax.imshow(masked_image.astype(np.uint8))\n"
]
},
{
"cell_type": "code",
"execution_count": 4,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-02T13:16:08.287915Z",
"start_time": "2019-06-02T13:16:07.643149Z"
},
"scrolled": false
},
"outputs": [
{
"data": {
"text/plain": [
"MaskRCNN(\n",
" (transform): GeneralizedRCNNTransform()\n",
" (backbone): BackboneWithFPN(\n",
" (body): IntermediateLayerGetter(\n",
" (conv1): Conv2d(3, 64, kernel_size=(7, 7), stride=(2, 2), padding=(3, 3), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" (maxpool): MaxPool2d(kernel_size=3, stride=2, padding=1, dilation=1, ceil_mode=False)\n",
" (layer1): Sequential(\n",
" (0): Bottleneck(\n",
" (conv1): Conv2d(64, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" (downsample): Sequential(\n",
" (0): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (1): FrozenBatchNorm2d()\n",
" )\n",
" )\n",
" (1): Bottleneck(\n",
" (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" (2): Bottleneck(\n",
" (conv1): Conv2d(256, 64, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(64, 64, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(64, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" )\n",
" (layer2): Sequential(\n",
" (0): Bottleneck(\n",
" (conv1): Conv2d(256, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" (downsample): Sequential(\n",
" (0): Conv2d(256, 512, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
" (1): FrozenBatchNorm2d()\n",
" )\n",
" )\n",
" (1): Bottleneck(\n",
" (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" (2): Bottleneck(\n",
" (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" (3): Bottleneck(\n",
" (conv1): Conv2d(512, 128, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(128, 128, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(128, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" )\n",
" (layer3): Sequential(\n",
" (0): Bottleneck(\n",
" (conv1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" (downsample): Sequential(\n",
" (0): Conv2d(512, 1024, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
" (1): FrozenBatchNorm2d()\n",
" )\n",
" )\n",
" (1): Bottleneck(\n",
" (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" (2): Bottleneck(\n",
" (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" (3): Bottleneck(\n",
" (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" (4): Bottleneck(\n",
" (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" (5): Bottleneck(\n",
" (conv1): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(256, 1024, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" )\n",
" (layer4): Sequential(\n",
" (0): Bottleneck(\n",
" (conv1): Conv2d(1024, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(2, 2), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" (downsample): Sequential(\n",
" (0): Conv2d(1024, 2048, kernel_size=(1, 1), stride=(2, 2), bias=False)\n",
" (1): FrozenBatchNorm2d()\n",
" )\n",
" )\n",
" (1): Bottleneck(\n",
" (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" (2): Bottleneck(\n",
" (conv1): Conv2d(2048, 512, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn1): FrozenBatchNorm2d()\n",
" (conv2): Conv2d(512, 512, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1), bias=False)\n",
" (bn2): FrozenBatchNorm2d()\n",
" (conv3): Conv2d(512, 2048, kernel_size=(1, 1), stride=(1, 1), bias=False)\n",
" (bn3): FrozenBatchNorm2d()\n",
" (relu): ReLU(inplace)\n",
" )\n",
" )\n",
" )\n",
" (fpn): FeaturePyramidNetwork(\n",
" (inner_blocks): ModuleList(\n",
" (0): Conv2d(256, 256, kernel_size=(1, 1), stride=(1, 1))\n",
" (1): Conv2d(512, 256, kernel_size=(1, 1), stride=(1, 1))\n",
" (2): Conv2d(1024, 256, kernel_size=(1, 1), stride=(1, 1))\n",
" (3): Conv2d(2048, 256, kernel_size=(1, 1), stride=(1, 1))\n",
" )\n",
" (layer_blocks): ModuleList(\n",
" (0): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" )\n",
" (extra_blocks): LastLevelMaxPool()\n",
" )\n",
" )\n",
" (rpn): RegionProposalNetwork(\n",
" (anchor_generator): AnchorGenerator()\n",
" (head): RPNHead(\n",
" (conv): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (cls_logits): Conv2d(256, 3, kernel_size=(1, 1), stride=(1, 1))\n",
" (bbox_pred): Conv2d(256, 12, kernel_size=(1, 1), stride=(1, 1))\n",
" )\n",
" )\n",
" (roi_heads): RoIHeads(\n",
" (box_roi_pool): MultiScaleRoIAlign()\n",
" (box_head): TwoMLPHead(\n",
" (fc6): Linear(in_features=12544, out_features=1024, bias=True)\n",
" (fc7): Linear(in_features=1024, out_features=1024, bias=True)\n",
" )\n",
" (box_predictor): FastRCNNPredictor(\n",
" (cls_score): Linear(in_features=1024, out_features=91, bias=True)\n",
" (bbox_pred): Linear(in_features=1024, out_features=364, bias=True)\n",
" )\n",
" (mask_roi_pool): MultiScaleRoIAlign()\n",
" (mask_head): MaskRCNNHeads(\n",
" (mask_fcn1): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (relu1): ReLU(inplace)\n",
" (mask_fcn2): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (relu2): ReLU(inplace)\n",
" (mask_fcn3): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (relu3): ReLU(inplace)\n",
" (mask_fcn4): Conv2d(256, 256, kernel_size=(3, 3), stride=(1, 1), padding=(1, 1))\n",
" (relu4): ReLU(inplace)\n",
" )\n",
" (mask_predictor): MaskRCNNPredictor(\n",
" (conv5_mask): ConvTranspose2d(256, 256, kernel_size=(2, 2), stride=(2, 2))\n",
" (relu): ReLU(inplace)\n",
" (mask_fcn_logits): Conv2d(256, 91, kernel_size=(1, 1), stride=(1, 1))\n",
" )\n",
" )\n",
")"
]
},
"execution_count": 4,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"model = torchvision.models.detection.maskrcnn_resnet50_fpn(pretrained=True)\n",
"model.eval()"
]
},
{
"cell_type": "code",
"execution_count": 5,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-02T13:16:11.435178Z",
"start_time": "2019-06-02T13:16:08.289116Z"
}
},
"outputs": [
{
"name": "stdout",
"output_type": "stream",
"text": [
"--2019-06-02 21:16:08-- https://github.com/pjreddie/darknet/raw/master/data/kite.jpg\n",
"Resolving github.com (github.com)... 13.229.188.59\n",
"Connecting to github.com (github.com)|13.229.188.59|:443... connected.\n",
"HTTP request sent, awaiting response... 302 Found\n",
"Location: https://raw.githubusercontent.com/pjreddie/darknet/master/data/kite.jpg [following]\n",
"--2019-06-02 21:16:09-- https://raw.githubusercontent.com/pjreddie/darknet/master/data/kite.jpg\n",
"Resolving raw.githubusercontent.com (raw.githubusercontent.com)... 151.101.108.133\n",
"Connecting to raw.githubusercontent.com (raw.githubusercontent.com)|151.101.108.133|:443... connected.\n",
"HTTP request sent, awaiting response... 200 OK\n",
"Length: 1415684 (1.3M) [image/jpeg]\n",
"Saving to: ‘test.jpg’\n",
"\n",
"test.jpg 100%[===================>] 1.35M 1.09MB/s in 1.2s \n",
"\n",
"2019-06-02 21:16:11 (1.09 MB/s) - ‘test.jpg’ saved [1415684/1415684]\n",
"\n"
]
}
],
"source": [
"!wget -O test.jpg https://github.com/pjreddie/darknet/raw/master/data/kite.jpg"
]
},
{
"cell_type": "code",
"execution_count": 6,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-02T13:16:11.499438Z",
"start_time": "2019-06-02T13:16:11.438420Z"
}
},
"outputs": [
{
"data": {
"text/plain": [
"torch.Size([3, 900, 1352])"
]
},
"execution_count": 6,
"metadata": {},
"output_type": "execute_result"
}
],
"source": [
"image = skimage.io.imread('test.jpg')\n",
"image_tensor = torchvision.transforms.functional.to_tensor(image)\n",
"image_tensor.shape"
]
},
{
"cell_type": "code",
"execution_count": 7,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-02T13:16:13.786873Z",
"start_time": "2019-06-02T13:16:11.501911Z"
}
},
"outputs": [],
"source": [
"output = model([image_tensor])"
]
},
{
"cell_type": "code",
"execution_count": 8,
"metadata": {
"ExecuteTime": {
"end_time": "2019-06-02T13:16:15.773493Z",
"start_time": "2019-06-02T13:16:13.788029Z"
}
},
"outputs": [
{
"data": {
Sign up for free to join this conversation on GitHub. Already have an account? Sign in to comment