diff --git a/.gitignore b/.gitignore new file mode 100644 index 0000000..df81f3a --- /dev/null +++ b/.gitignore @@ -0,0 +1,3 @@ +*/MODEL* +*/.ipynb_checkpoints +*/__pycache__ diff --git a/Unet_buildings_detection/Dummy_buildings_dataset_generator.py b/Unet_buildings_detection/Dummy_buildings_dataset_generator.py new file mode 100644 index 0000000..bfc1d17 --- /dev/null +++ b/Unet_buildings_detection/Dummy_buildings_dataset_generator.py @@ -0,0 +1,70 @@ +import torch +from torch.utils.data import Dataset +import numpy as np +import cv2 +import matplotlib.pyplot as plt + + + +COLORS = ['#F44336',"#E91E63",'#9C27B0','#673AB7','#3F51B5','#2196F3','#03A9F4','#00BCD4','#4CAF50', + '#8BC34A','#CDDC39','#FFEB3B','#FFC107','#FF9800','#FF5722'] + +COLORS = ['#F44336',"#E91E63",'#9C27B0','#673AB7','#3F51B5','#2196F3','#03A9F4','#00BCD4','#4CAF50', + '#8BC34A','#CDDC39','#FFEB3B','#FFC107','#FF9800','#FF5722'] + + +r_min = 12 +r_max = 36 +line_width_min = 2 +line_width_max = 4 +background_intensity = 30.0 / 255.0 +def hex2rgb(h): + h = h.lstrip('#') + return tuple(int(h[i:i+2], 16) for i in (0, 2 ,4)) + +def DrawRandomSquare(img,segments,r_min,r_max,alpha): + color = hex2rgb( np.random.choice(COLORS) ) + t = np.random.random() + r = int(t * r_min + (1-t) * r_max) + i = int(np.random.random()*img.shape[0]) + j = int(np.random.random()*img.shape[1]) + theta = np.pi * np.random.random() + ri = r*np.cos(theta) + rj = r*np.sin(theta) + pts = [(ri,rj),(-rj,ri),(-ri,-rj),(rj,-ri) ] + pts = [(i+y,j+x) for (y,x) in pts] + pts = np.array(pts, np.int32) + pts = pts.reshape((-1,1,2)) + canvas = img.copy() + cv2.fillPoly(canvas,[pts],color) + cv2.fillPoly(segments,[pts],(0,1,0)) + img = cv2.addWeighted(img, 1.0 - alpha, canvas, alpha, 0, img ) + box = [min(pts[:,:,0])[0],min(pts[:,:,1])[0], max(pts[:,:,0])[0]-min(pts[:,:,0])[0], max(pts[:,:,1])[0] - min(pts[:,:,1])[0] ] + return img,segments,box + +def generateSegmentation(canvas_size, n_max, alpha = 0.5): + canvas = background_intensity * np.ones((canvas_size,canvas_size,3)) + segments = np.zeros((canvas_size,canvas_size,2)) + + for _ in range(np.random.choice(range(n_max))): + canvas,segments,b = DrawRandomSquare(canvas,segments,r_min,r_max,alpha) + return canvas,segments + + + +class SimpleSegmentationDataset(Dataset): + """A simple dataset for image segmentation purpose""" + def __init__(self, patch_size, n_max, alpha =1.0,virtual_size=1000): + self.virtual_size = virtual_size + self.patch_size = patch_size + self.n_max = n_max + self.alpha = alpha + + + def __len__(self): + return self.virtual_size + + def __getitem__(self,idx): + x,y= generateSegmentation(self.patch_size, self.n_max, self.alpha) + sample = {'input': x, 'groundtruth': y} + return sample \ No newline at end of file diff --git a/Unet_buildings_detection/IOU_computations.py b/Unet_buildings_detection/IOU_computations.py new file mode 100644 index 0000000..831a546 --- /dev/null +++ b/Unet_buildings_detection/IOU_computations.py @@ -0,0 +1,95 @@ +from osgeo import gdal, osr,ogr +import numpy as np +import json + +def vectorize_raster(geoJsonFileName,array2d,layerName="BuildingID",fieldName="BuildingID"): + + + memdrv = gdal.GetDriverByName('MEM') + src_ds = memdrv.Create('', array2d.shape[1], array2d.shape[0], 1) + band = src_ds.GetRasterBand(1) + band.WriteArray(array2d) + + dst_layername = "BuildingID" + drv = ogr.GetDriverByName("geojson") + dst_ds = drv.CreateDataSource(geoJsonFileName) + dst_layer = dst_ds.CreateLayer(layerName, srs=None) + + fd = ogr.FieldDefn(fieldName, ogr.OFTInteger) + dst_layer.CreateField(fd) + dst_field = 0 + + gdal.Polygonize(band, None, dst_layer, dst_field, [], callback=None) + + + + return +def predict_score_batch(temporary_fold,batch_y,prediction): + + """ + Predicts scores considering IoU metrics following https://github.com/SpaceNetChallenge/utilities + temporary_fold: path of the folder where to store temporary used geojson files extraced from raster input batch_y + batch_y (np array): One hot pixel wise labels batch groundtruth(size_batch x WIDTH X HEIGHT x nb_channels) where nb_channels=2 + batch_y[:,:,:,0] should represent the background mask + batch_y[:,:,:,1] should represent the buildings mask + prediction (np array): One hot pixel wise labels batch predidction (size_batch x WIDTH X HEIGHT x nb_channels) where nb_channels=2 + return averaged accuracy, f1 score, IoU of the batch + + """ + tot_score_batch=0 + tot_f1_score_batch=0 + tot_ious_batch=0 + + for i in range(len(batch_y)): + vectorize_raster(temporary_fold+str(i)+'_test_gt.geojson',batch_y[i]) + vectorize_raster(temporary_fold+str(i)+'_test_pred.geojson',prediction[i]) + with open(temporary_fold+str(i)+'_test_gt.geojson') as f: + geojson_groundtruth = json.load(f) + with open(temporary_fold+str(i)+'_test_pred.geojson') as f: + geojson_prediction = json.load(f) + + + M=len(geojson_prediction['features']) + N=len(geojson_groundtruth['features']) +# print('Image %d: %d predictions proposed and %d groundtruth'%(i,M,N)) + score=0 + IOUs_sum=0 + for feature_pred in geojson_prediction['features']: + IoUs=[] + IoUs_accu=[] +# print(ogr.CreateGeometryFromJson(json.dumps(feature_pred['geometry'])).GetArea()) +# print('Polygone') + + for feature_gt in geojson_groundtruth['features']: +# print(ogr.CreateGeometryFromJson(json.dumps(feature_gt['geometry'])).GetArea()) + poly1=ogr.CreateGeometryFromJson(json.dumps(feature_gt['geometry'])) + poly2=ogr.CreateGeometryFromJson(json.dumps(feature_pred['geometry'])) + intersection = poly1.Intersection(poly2) + union = poly1.Union(poly2) + if intersection is None: + IoUs.append(0.0) + else: + IoUs.append(intersection.GetArea()/union.GetArea()) + + IoUs=np.asarray(IoUs) +# print(IoUs) + IoUs_accu=(IoUs>0.5).astype(int)*IoUs +# print(IoUs_accu) + if (IoUs_accu.size and np.amax(IoUs_accu)>0): + index=np.argmax(IoUs_accu) +# print('index %d'%index) + geojson_groundtruth['features'].remove(geojson_groundtruth['features'][index]) +# print('new size groundtruth %d'%len(geojson_groundtruth['features'])) + score+=1 + IOUs_sum+=IoUs[index] +# print('score: %f: '%score) +# print('IOUs_sum: %f: '%IOUs_sum) + tot_ious_batch+=IOUs_sum/N + tot_score_batch+=score/N + tot_f1_score_batch+=2*score/(M+N) + tot_ious_batch/=len(batch_y) + tot_score_batch/=len(batch_y) + tot_f1_score_batch/=len(batch_y) + return tot_score_batch*100,tot_f1_score_batch*100,tot_ious_batch + + \ No newline at end of file diff --git a/Unet_buildings_detection/image_utils.py b/Unet_buildings_detection/image_utils.py new file mode 100644 index 0000000..2bbd302 --- /dev/null +++ b/Unet_buildings_detection/image_utils.py @@ -0,0 +1,60 @@ +import numpy as np +from osgeo import gdal,osr,ogr +import torch +from scipy.ndimage.morphology import distance_transform_bf + + + +def standardize(data): + ''' + Standardize the input data of the network + :param data to be standardized (size size_batch x WIDTH x HEIGHT x number of channels) + + returns data standardized size size_batch x WIDTH x HEIGHT x number of channels + + ''' + + WIDTH=data.shape[1] + HEIGHT=data.shape[2] + channels=data.shape[3] + + + mean_t=torch.mean(data.view(len(data)*WIDTH*HEIGHT,channels),0) + std_t=torch.std(data.view(len(data)*WIDTH*HEIGHT,channels), 0) + data=(data-mean_t)/std_t + + #For normalization + min_t=torch.min(data.view(len(data)*WIDTH*HEIGHT,channels), 0) + max_t=torch.max(data.view(len(data)*WIDTH*HEIGHT,channels), 0) + data=(data-min_t[0])/((max_t[0]-min_t[0])) + + return data + + +def distance_map_batch(Y,threshold=20,bins=15): + + """ + Compute the distance map following https://arxiv.org/pdf/1709.05932.pdf + Y: One hot pixel wise labels ( size_batch x WIDTH x HEIGHT x nb_classes) with nb_classes=2 + Y[:,:,:,0] should represent the background mask + Y[:,:,:,1] should represent the buildings mask + threshold: distance threshold + bins: number of bins considered for the distance map + Default values are computed for resolution of input image of 50cm per pixel + return torch distance map for buildings (size_batch x WIDTH x HEIGHT x bins) + """ + Y_dist=[] + for i in range(len(Y)): + distance=distance_transform_bf(np.asarray(Y)[i,:,:,1],sampling=2) + distance=np.minimum(distance,threshold*(distance>0))*(bins-1)/threshold + inp=torch.LongTensor(distance) + inp_ = torch.unsqueeze(inp, len(distance.shape)) + one_hot = torch.FloatTensor(distance.shape[0],distance.shape[1], bins).zero_() + one_hot.scatter_(len(distance.shape), inp_, 1) + one_hot=np.asarray(one_hot) + Y_dist.append(one_hot) + + return torch.FloatTensor(np.asarray(Y_dist)) + + + diff --git a/Unet_buildings_detection/potential_usage.ipynb b/Unet_buildings_detection/potential_usage.ipynb new file mode 100644 index 0000000..c59fb93 --- /dev/null +++ b/Unet_buildings_detection/potential_usage.ipynb @@ -0,0 +1,10637 @@ +{ + "cells": [ + { + "cell_type": "code", + "execution_count": 1, + "metadata": {}, + "outputs": [], + "source": [ + "import numpy as np\n", + "from image_utils import *\n", + "import matplotlib.pyplot as plt\n", + "from Dummy_buildings_dataset_generator import SimpleSegmentationDataset\n", + "from torch.utils.data import DataLoader\n", + "import torch\n", + "from unet_meli import UNet\n", + "import torch.backends.cudnn as cudnn\n", + "import torch.nn as nn\n", + "from torch.autograd import Variable\n", + "from random import randint\n", + "import os\n", + "import logging\n", + "import time\n", + "from IOU_computations import *\n", + "from torch import optim\n", + "\n", + "\n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 1) Visualize dataset" + ] + }, + { + "cell_type": "code", + "execution_count": 2, + "metadata": {}, + "outputs": [ + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Visualize one batch of the test set\n", + "Image 0\n", + "Input\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groundtruth\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance Map\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image 1\n", + "Input\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groundtruth\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance Map\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image 2\n", + "Input\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groundtruth\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance Map\n" + ] + }, + { + "data": { + "image/png": "iVBORw0KGgoAAAANSUhEUgAAAQUAAAD8CAYAAAB+fLH0AAAABHNCSVQICAgIfAhkiAAAAAlwSFlzAAALEgAACxIB0t1+/AAAADl0RVh0U29mdHdhcmUAbWF0cGxvdGxpYiB2ZXJzaW9uIDIuMS4yLCBodHRwOi8vbWF0cGxvdGxpYi5vcmcvNQv5yAAADshJREFUeJzt3V2sXWWdx/Hvz56+UBTbAtbadgYmEolxRiGNg2EyMaIZZIxwYQzEjB3TpDfOiC+JlpkLM3eaGBUTQ6YRtU4M6iAZGmJUrJjJXEy1KOGlFak4QElfwLaUKJae9j8Xex08TzntKWe/neL3k+zstZ611l7/POfs337W2uuclapCkqa8YtwFSJpfDAVJDUNBUsNQkNQwFCQ1DAVJDUNBUmMooZDk6iQPJ9mdZNMw9iFpODLoi5eSLAB+BbwL2AP8DLihqnYOdEeShmJiCK/5VmB3VT0KkORbwLXAKUPhghUL6qK1C4dQytz89nivW547sQiAZ55fAsCJ493A6nhYcLQ3mcne88Rzx3sTk72GOjY5mmKlM/Qsh56uqgtnW28YobAaeGLa/B7gr09eKclGYCPAn62e4Kc/WDuEUubmG0cuAOCB3/dq+uHjlwLw7OGlAOTQQs77dS8glhw8AcCynUcAeMX+gwBM7t03uoKlM/Cjuv2xM1lvbCcaq2pzVa2rqnUXnr9gXGVIOskwQuFJYPrH/pquTdJZYBih8DPgkiQXJ1kEXA9sHcJ+5pWjr1nK0dcsfWF+YtVrx1iNNHcDP6dQVZNJ/gn4AbAA+GpVPTTo/YzS2mWHAdh5+I9v+qPLp6Z6uXrO0725EytX9Fq7cwvS2WYYJxqpqu8B3xvGa0sarqGEwtnuLUv2AH/89mHKq5b9HoBnWcpRel+hLj7UGyk8d0GvKxcfGFWV0nB4mbOkhiOF0/jLpU80808cXjamSqTRcaQgqeFIYQZ/tah3WfN9fxhzIdIYOFKQ1DAUJDUMBUkNQ0FSw1CQ1DAUJDUMBUkNQ0FSw1CQ1DAUJDUMBUkNQ0FSw1CQ1DAUJDUMBUkNQ0FSw1CQ1DAUJDUMBUmNefs/Gu9/vv0Hiff9Yc2s20zdr2HK1P9a7Ge/0p8aRwqSGvNypHD/8394YWRw8l2aTmdq3an7Ncz1vzG/lH1KLzdzHikkWZvkniQ7kzyU5MaufUWSu5M80j0vn+21JM0f/YwUJoFPVNXPk7wKuDfJ3cA/Atuq6jNJNgGbgE+d7oV+e3yCbxy5oGmb+rTedaS9pftMd2mauiv0oJzJPk9l6nb05+w/+MLt6Cf37htccdKQzTkUqmovsLebfjbJLmA1cC3w9m61LcBPmCUUnjuxqBmyT39TTr0hn512G/iTTd0ifuoGsIO6vdvp9jnldLek93b0OhsN5ERjkouAy4DtwMouMAD2ASsHsQ9Jo9H3icYkrwS+C3y0qo4keWFZVVWSOsV2G4GNAAsvfDU/fPzSZvnJn9I5tHDWWp5l9k/2l+JM9nl0xQnAW9Lr5aOvkUKShfQC4ZtVdUfXvD/Jqm75KmDGt0dVba6qdVW1bsF5g30zS5q7OY8U0hsS3ArsqqrPT1u0FVgPfKZ7vnO21zpx/BWzjgwWH+zl1+JDL95+6rj+KLN/sr8Up9un9HLVz+HDlcA/AA8kua9r+xd6YfCdJBuAx4D391eipFHq59uH/wFyisVXvaQXO55THr+f9+v2CGfJwRMzrDX1iT6cCzRn3qf08uRlzpIa8+Iy5wVHXzwiONnyXz3fzC8+0Lsm4ehrlr5wbcDUmf9BOefpyRn3Kb2czYtQyOSZD9HPeaD9S8hz9h/kxMoVwPC+BvQiJP0p8fBBUmNejBQmnjvOsp1HXtI2U39PMLHqtSP7JPdvGPSnwJGCpMa8GCkwOfmSP+39C0RpOBwpSGrMi5FCHZv0E1+aJxwpSGoYCpIahoKkhqEgqWEoSGoYCpIahoKkhqEgqWEoSGoYCpIahoKkhqEgqWEoSGoYCpIahoKkhqEgqWEoSGoYCpIafYdCkgVJfpHkrm7+4iTbk+xO8u0ki/ovU9KoDGKkcCOwa9r8Z4EvVNXrgUPAhgHsQ9KI9BUKSdYAfw98pZsP8A7g9m6VLcB1/exD0mj1O1L4IvBJYOpGkOcDh6tq6s6se4DVfe5D0gjNORSSvAc4UFX3znH7jUl2JNlxjKNzLUPSgPVz34crgfcmuQZYApwH3AwsSzLRjRbWAE/OtHFVbQY2A5yXFdVHHZIGaM4jhaq6qarWVNVFwPXAj6vqA8A9wPu61dYDd/ZdpaSRGcZ1Cp8CPp5kN71zDLcOYR+ShmQgt42rqp8AP+mmHwXeOojXlTR6XtEoqWEoSGoYCpIahoKkhqEgqWEoSGoYCpIahoKkhqEgqWEoSGoYCpIahoKkhqEgqWEoSGoYCpIahoKkhqEgqWEoSGoYCpIahoKkhqEgqWEoSGoYCpIahoKkhqEgqWEoSGoYCpIafYVCkmVJbk/yyyS7krwtyYokdyd5pHtePqhiJQ1fvyOFm4HvV9WlwJuBXcAmYFtVXQJs6+YlnSXmHApJXg38Ld2t5qvq+ao6DFwLbOlW2wJc12+Rkkann5HCxcBTwNeS/CLJV5KcC6ysqr3dOvuAlf0WKWl0+gmFCeBy4Jaqugz4HScdKlRVATXTxkk2JtmRZMcxjvZRhqRB6icU9gB7qmp7N387vZDYn2QVQPd8YKaNq2pzVa2rqnULWdxHGZIGac6hUFX7gCeSvKFrugrYCWwF1ndt64E7+6pQ0khN9Ln9PwPfTLIIeBT4EL2g+U6SDcBjwPv73IekEeorFKrqPmDdDIuu6ud1JY2PVzRKahgKkhqGgqSGoSCpYShIahgKkhqGgqSGoSCpYShIahgKkhqGgqSGoSCpYShIahgKkhqGgqSGoSCpYShIahgKkhqGgqSGoSCpYShIahgKkhqGgqSGoSCpYShIahgKkhqGgqSGoSCp0VcoJPlYkoeSPJjktiRLklycZHuS3Um+3d2RWtJZYs6hkGQ18BFgXVW9CVgAXA98FvhCVb0eOARsGEShkkaj38OHCeCcJBPAUmAv8A7g9m75FuC6PvchaYTmHApV9STwOeBxemHwDHAvcLiqJrvV9gCrZ9o+ycYkO5LsOMbRuZYhacD6OXxYDlwLXAy8DjgXuPpMt6+qzVW1rqrWLWTxXMuQNGD9HD68E/hNVT1VVceAO4ArgWXd4QTAGuDJPmuUNEL9hMLjwBVJliYJcBWwE7gHeF+3znrgzv5KlDRK/ZxT2E7vhOLPgQe619oMfAr4eJLdwPnArQOoU9KITMy+yqlV1aeBT5/U/Cjw1n5eV9L4eEWjpIahIKlhKEhqGAqSGoaCpIahIKlhKEhqGAqSGoaCpIahIKlhKEhqGAqSGoaCpIahIKlhKEhqGAqSGoaCpIahIKlhKEhqGAqSGoaCpIahIKlhKEhqGAqSGoaCpIahIKlhKEhqzBoKSb6a5ECSB6e1rUhyd5JHuuflXXuSfCnJ7iT3J7l8mMVLGrwzGSl8Hbj6pLZNwLaqugTY1s0DvBu4pHtsBG4ZTJmSRmXWUKiq/wYOntR8LbClm94CXDet/RvV87/AsiSrBlWspOGb6zmFlVW1t5veB6zsplcDT0xbb0/X9iJJNibZkWTHMY7OsQxJg9b3icaqKqDmsN3mqlpXVesWsrjfMiQNyFxDYf/UYUH3fKBrfxJYO229NV2bpLPEXENhK7C+m14P3Dmt/YPdtxBXAM9MO8yQdBaYmG2FJLcBbwcuSLIH+DTwGeA7STYAjwHv71b/HnANsBv4PfChIdQsaYhmDYWquuEUi66aYd0CPtxvUZLGxysaJTUMBUkNQ0FSw1CQ1DAUJDUMBUkNQ0FSw1CQ1DAUJDUMBUkNQ0FSw1CQ1DAUJDUMBUkNQ0FSw1CQ1DAUJDUMBUkNQ0FSw1CQ1DAUJDUMBUkNQ0FSw1CQ1DAUJDUMBUkNQ0FSw1CQ1DAUJDUMBUmN9O4eP+YikqeA3wFPj7uWaS7AemYz32qyntP786q6cLaV5kUoACTZUVXrxl3HFOuZ3XyryXoGw8MHSQ1DQVJjPoXC5nEXcBLrmd18q8l6BmDenFOQND/Mp5GCpHlg7KGQ5OokDyfZnWTTmGpYm+SeJDuTPJTkxq59RZK7kzzSPS8fcV0LkvwiyV3d/MVJtnd99e0ki0ZYy7Iktyf5ZZJdSd42zv5J8rHuZ/VgktuSLBl1/yT5apIDSR6c1jZjn6TnS11t9ye5fJi19WOsoZBkAfBl4N3AG4EbkrxxDKVMAp+oqjcCVwAf7urYBGyrqkuAbd38KN0I7Jo2/1ngC1X1euAQsGGEtdwMfL+qLgXe3NU1lv5Jshr4CLCuqt4ELACuZ/T983Xg6pPaTtUn7wYu6R4bgVuGXNvcVdXYHsDbgB9Mm78JuGmcNXV13Am8C3gYWNW1rQIeHmENa+j9Ur0DuAsIvQthJmbquyHX8mrgN3TnoKa1j6V/gNXAE8AKYKLrn78bR/8AFwEPztYnwL8DN8y03nx7jPvwYeqHO2VP1zY2SS4CLgO2Ayuram+3aB+wcoSlfBH4JHCimz8fOFxVk938KPvqYuAp4Gvd4cxXkpzLmPqnqp4EPgc8DuwFngHuZXz9M92p+mTe/a6fyrhDYV5J8krgu8BHq+rI9GXVi/eRfFWT5D3Agaq6dxT7OwMTwOXALVV1Gb1L0ptDhRH3z3LgWnph9TrgXF48jB+7UfbJII07FJ4E1k6bX9O1jVyShfQC4ZtVdUfXvD/Jqm75KuDAiMq5Enhvkv8DvkXvEOJmYFmSiW6dUfbVHmBPVW3v5m+nFxLj6p93Ar+pqqeq6hhwB70+G1f/THeqPpk3v+uzGXco/Ay4pDtrvIjeyaKtoy4iSYBbgV1V9flpi7YC67vp9fTONQxdVd1UVWuq6iJ6ffLjqvoAcA/wvjHUsw94IskbuqargJ2MqX/oHTZckWRp97Obqmcs/XOSU/XJVuCD3bcQVwDPTDvMmF/GfVIDuAb4FfBr4F/HVMPf0Bvm3Q/c1z2uoXccvw14BPgRsGIMtb0duKub/gvgp8Bu4D+BxSOs4y3Ajq6P/gtYPs7+Af4N+CXwIPAfwOJR9w9wG71zGsfojaY2nKpP6J0o/nL3e/4AvW9ORv67fiYPr2iU1Bj34YOkecZQkNQwFCQ1DAVJDUNBUsNQkNQwFCQ1DAVJjf8HEjbTdkGxfQoAAAAASUVORK5CYII=\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image 3\n", + "Input\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groundtruth\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance Map\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image 4\n", + "Input\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groundtruth\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance Map\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image 5\n", + "Input\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groundtruth\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance Map\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image 6\n", + "Input\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groundtruth\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance Map\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image 7\n", + "Input\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groundtruth\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance Map\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image 8\n", + "Input\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groundtruth\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance Map\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Image 9\n", + "Input\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Groundtruth\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stdout", + "output_type": "stream", + "text": [ + "Distance Map\n" + ] + }, + { + "data": { + "image/png": "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\n", + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + } + ], + "source": [ + "SIZE_PATCH=120\n", + "nb_objects_max_perimage=3\n", + "test_batch_size=10\n", + "\n", + "test_generator=SimpleSegmentationDataset(SIZE_PATCH, nb_objects_max_perimage, alpha =1.0,virtual_size=100)\n", + "test_loader = DataLoader(test_generator, batch_size=test_batch_size,shuffle=True, num_workers=1)\n", + "sample_test=next(iter(test_loader))\n", + "X_test=sample_test['input']\n", + "Y_test=sample_test['groundtruth']\n", + "X_test=standardize(X_test)\n", + "\n", + "%matplotlib inline\n", + "print('Visualize one batch of the test set')\n", + "for i in range(len(X_test)):\n", + " print('Image %d'%i)\n", + " print('Input')\n", + " plt.imshow(np.asarray(X_test)[i])\n", + " plt.show()\n", + " print('Groundtruth')\n", + " plt.imshow(np.argmax(np.asarray(Y_test)[i],axis=-1))\n", + " plt.show()\n", + " print('Distance Map')\n", + " plt.imshow(np.argmax(np.asarray(distance_map_batch(Y_test))[i],axis=-1))\n", + " plt.show()" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "## 3) Unet version" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Configuration" + ] + }, + { + "cell_type": "code", + "execution_count": 50, + "metadata": {}, + "outputs": [], + "source": [ + "INPUT_CHANNELS=3\n", + "NB_CLASSES=2\n", + "DROPOUT=0.2\n", + "DEFAULT_BATCH_SIZE = 32\n", + "DEFAULT_EPOCHS =10\n", + "DEFAULT_VALID=50\n", + "DISPLAY_STEP=100\n", + "TRAINING_SIZE=4500\n", + "VALIDATION_SIZE=500\n", + "DISPLAY_STEP=100\n", + "\n", + "\n", + "DEFAULT_LAYERS=3\n", + "DEFAULT_FEATURES_ROOT=32\n", + "DEFAULT_FILTERS_SIZE=3\n", + "DEFAULT_FILTER_WIDTH=3\n", + "DEFAULT_LR=0.01\n", + "REDUCE_LR_STEPS = [1,5,8]\n", + "\n", + "\n", + "DISTANCE_NET=False\n", + "BINS=15\n", + "THRESHOLD=33\n", + "\n", + "TEST_SAVE='MODEL_TEST/'\n", + "\n", + "if not os.path.exists(TEST_SAVE):\n", + " os.makedirs(TEST_SAVE)\n", + " \n", + "TMP_IOU=TEST_SAVE+'TMP_IOU/'\n", + "if not os.path.exists(TMP_IOU):\n", + " os.makedirs(TMP_IOU)\n", + " \n" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Utils" + ] + }, + { + "cell_type": "code", + "execution_count": 51, + "metadata": {}, + "outputs": [], + "source": [ + "\n", + "logger=logging.getLogger()\n", + "logger.setLevel(logging.INFO)\n", + "logging.basicConfig(format='%(asctime)s %(message)s')\n", + "%matplotlib notebook" + ] + }, + { + "cell_type": "code", + "execution_count": 52, + "metadata": {}, + "outputs": [], + "source": [ + "loss_fn=nn.CrossEntropyLoss()\n", + "def criterion(y,y_):\n", + "\n", + " y = y.contiguous().view(-1,y.size()[-1])\n", + " y_ = y_.contiguous().view(-1,y.size()[-1])\n", + " y = y.max(-1)[1]\n", + " loss = loss_fn(y_,y)\n", + " \n", + " return loss\n", + "\n", + "\n", + "def predict(net,batch_x,dist_net=False):\n", + " \n", + " if dist_net:\n", + " logits_dist,logits_seg=net(batch_x)\n", + " return logits_dist.permute(0,2,3,1),logits_seg.permute(0,2,3,1) \n", + " else:\n", + " logits=net(batch_x)\n", + " return logits.permute(0,2,3,1)\n", + " \n", + "\n", + "def error_rate(predictions, labels):\n", + " \"\"\"\n", + " Return the error rate based on dense predictions and 1-hot labels.\n", + " \"\"\"\n", + "\n", + " return 100.0 - (\n", + " 100.0 *\n", + " np.sum(np.argmax(predictions, 3) == np.argmax(labels, 3)) /\n", + " (predictions.shape[0]*predictions.shape[1]*predictions.shape[2]))\n", + "def plot_summary(predictions,labels,prediction_dist,groundtruth_dist,pansharp,epoch):\n", + "\n", + " if prediction_dist is None and groundtruth_dist is None:\n", + " fig,axs=plt.subplots(3, len(pansharp),figsize=(3*len(pansharp),9))\n", + "\n", + " labels=np.argmax(labels, 3) \n", + " logits=np.argmax(predictions, 3)\n", + "\n", + " for i in range(len(pansharp)):\n", + "\n", + " axs[0,i].imshow(pansharp[i])\n", + " axs[1,i].imshow(labels[i]) \n", + " axs[2,i].imshow(logits[i])\n", + "\n", + " else:\n", + " \n", + " fig,axs=plt.subplots(5, len(pansharp),figsize=(5*len(pansharp),15))\n", + "\n", + " labels_seg=np.argmax(labels, 3) \n", + " logits_seg=np.argmax(predictions, 3)\n", + " labels_dist=np.argmax(groundtruth_dist, 3) \n", + " logits_dist=np.argmax(prediction_dist, 3)\n", + "\n", + " for i in range(len(pansharp)):\n", + "\n", + " axs[0,i].imshow(pansharp[i])\n", + " axs[1,i].imshow(labels_seg[i]) \n", + " axs[2,i].imshow(logits_seg[i])\n", + " axs[3,i].imshow(labels_dist[i],cmap=\"jet\")\n", + " axs[4,i].imshow(logits_dist[i],cmap=\"jet\")\n", + "\n", + " fig.canvas.draw()\n", + " time.sleep(2)\n", + " plt.close(fig)\n", + " \n", + "def draw_update(loss,avg_loss_train,avg_loss_val,avg_iou, avg_f1,lr,fig,axs):\n", + " if len(loss)==0 and len(lr)==0 and len(avg_loss_train)==0:\n", + "\n", + " axs[0].set_ylim(0,0.1)\n", + " axs[0].set_title('Loss train')\n", + " axs[1].set_ylim(0,0.001)\n", + " axs[1].set_title('Avg losses')\n", + " axs[2].set_ylim(0,DEFAULT_LR+DEFAULT_LR/10)\n", + " axs[2].set_title('Learning rate')\n", + " axs[3].set_title('Val IoU Avg')\n", + " axs[4].set_title('Val F1 IoU')\n", + "\n", + " else:\n", + " \n", + " epoch=np.arange(len(avg_loss_train))\n", + " ite=np.arange(len(loss))\n", + " axs[0].plot(ite, loss, 'r-') \n", + " axs[1].plot(epoch, avg_loss_train, 'r-',epoch, avg_loss_val, 'g-')\n", + " axs[2].plot(ite, lr, 'b-') \n", + " axs[3].plot(epoch, avg_iou, 'm-') \n", + " axs[4].plot(epoch, avg_f1, 'm-') \n", + " fig.canvas.draw()\n", + " time.sleep(4)" + ] + }, + { + "cell_type": "markdown", + "metadata": {}, + "source": [ + "### Initialization" + ] + }, + { + "cell_type": "code", + "execution_count": 53, + "metadata": {}, + "outputs": [ + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2018-04-22 18:47:27,566 Initialization\n", + "/home/s161362/.conda/envs/env_dhi/lib/python3.6/site-packages/torch/nn/modules/upsampling.py:180: UserWarning: nn.UpsamplingBilinear2d is deprecated. Use nn.Upsample instead.\n", + " warnings.warn(\"nn.UpsamplingBilinear2d is deprecated. Use nn.Upsample instead.\")\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2018-04-22 18:47:44,613 Start optimization\n", + "/home/s161362/.conda/envs/env_dhi/lib/python3.6/site-packages/torch/nn/modules/upsampling.py:180: UserWarning: nn.UpsamplingBilinear2d is deprecated. Use nn.Upsample instead.\n", + " warnings.warn(\"nn.UpsamplingBilinear2d is deprecated. Use nn.Upsample instead.\")\n", + "2018-04-22 18:48:20,988 Training epoch_0, Minibatch Loss= 0.0295\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2018-04-22 18:52:01,390 Verification loss= 0.0000,error rate= 0.0000,IOU = 1.0000, F1 IOU= 100.0000%\n", + "2018-04-22 18:52:39,482 Training epoch_2, Minibatch Loss= 0.0000\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2018-04-22 18:56:20,564 Verification loss= 0.0000,error rate= 0.0000,IOU = 1.0000, F1 IOU= 100.0000%\n", + "2018-04-22 18:56:57,410 Training epoch_4, Minibatch Loss= 0.0000\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2018-04-22 19:00:37,652 Verification loss= 0.0000,error rate= 0.0000,IOU = 1.0000, F1 IOU= 100.0000%\n", + "2018-04-22 19:01:14,297 Training epoch_6, Minibatch Loss= 0.0000\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2018-04-22 19:04:56,947 Verification loss= 0.0000,error rate= 0.0000,IOU = 1.0000, F1 IOU= 99.9200%\n", + "2018-04-22 19:05:34,213 Training epoch_8, Minibatch Loss= 0.0000\n" + ] + }, + { + "data": { + "application/javascript": [ + "/* Put everything inside the global mpl namespace */\n", + "window.mpl = {};\n", + "\n", + "\n", + "mpl.get_websocket_type = function() {\n", + " if (typeof(WebSocket) !== 'undefined') {\n", + " return WebSocket;\n", + " } else if (typeof(MozWebSocket) !== 'undefined') {\n", + " return MozWebSocket;\n", + " } else {\n", + " alert('Your browser does not have WebSocket support.' +\n", + " 'Please try Chrome, Safari or Firefox ≥ 6. ' +\n", + " 'Firefox 4 and 5 are also supported but you ' +\n", + " 'have to enable WebSockets in about:config.');\n", + " };\n", + "}\n", + "\n", + "mpl.figure = function(figure_id, websocket, ondownload, parent_element) {\n", + " this.id = figure_id;\n", + "\n", + " this.ws = websocket;\n", + "\n", + " this.supports_binary = (this.ws.binaryType != undefined);\n", + "\n", + " if (!this.supports_binary) {\n", + " var warnings = document.getElementById(\"mpl-warnings\");\n", + " if (warnings) {\n", + " warnings.style.display = 'block';\n", + " warnings.textContent = (\n", + " \"This browser does not support binary websocket messages. \" +\n", + " \"Performance may be slow.\");\n", + " }\n", + " }\n", + "\n", + " this.imageObj = new Image();\n", + "\n", + " this.context = undefined;\n", + " this.message = undefined;\n", + " this.canvas = undefined;\n", + " this.rubberband_canvas = undefined;\n", + " this.rubberband_context = undefined;\n", + " this.format_dropdown = undefined;\n", + "\n", + " this.image_mode = 'full';\n", + "\n", + " this.root = $('
');\n", + " this._root_extra_style(this.root)\n", + " this.root.attr('style', 'display: inline-block');\n", + "\n", + " $(parent_element).append(this.root);\n", + "\n", + " this._init_header(this);\n", + " this._init_canvas(this);\n", + " this._init_toolbar(this);\n", + "\n", + " var fig = this;\n", + "\n", + " this.waiting = false;\n", + "\n", + " this.ws.onopen = function () {\n", + " fig.send_message(\"supports_binary\", {value: fig.supports_binary});\n", + " fig.send_message(\"send_image_mode\", {});\n", + " if (mpl.ratio != 1) {\n", + " fig.send_message(\"set_dpi_ratio\", {'dpi_ratio': mpl.ratio});\n", + " }\n", + " fig.send_message(\"refresh\", {});\n", + " }\n", + "\n", + " this.imageObj.onload = function() {\n", + " if (fig.image_mode == 'full') {\n", + " // Full images could contain transparency (where diff images\n", + " // almost always do), so we need to clear the canvas so that\n", + " // there is no ghosting.\n", + " fig.context.clearRect(0, 0, fig.canvas.width, fig.canvas.height);\n", + " }\n", + " fig.context.drawImage(fig.imageObj, 0, 0);\n", + " };\n", + "\n", + " this.imageObj.onunload = function() {\n", + " fig.ws.close();\n", + " }\n", + "\n", + " this.ws.onmessage = this._make_on_message_function(this);\n", + "\n", + " this.ondownload = ondownload;\n", + "}\n", + "\n", + "mpl.figure.prototype._init_header = function() {\n", + " var titlebar = $(\n", + " '
');\n", + " var titletext = $(\n", + " '
');\n", + " titlebar.append(titletext)\n", + " this.root.append(titlebar);\n", + " this.header = titletext[0];\n", + "}\n", + "\n", + "\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(canvas_div) {\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._init_canvas = function() {\n", + " var fig = this;\n", + "\n", + " var canvas_div = $('
');\n", + "\n", + " canvas_div.attr('style', 'position: relative; clear: both; outline: 0');\n", + "\n", + " function canvas_keyboard_event(event) {\n", + " return fig.key_event(event, event['data']);\n", + " }\n", + "\n", + " canvas_div.keydown('key_press', canvas_keyboard_event);\n", + " canvas_div.keyup('key_release', canvas_keyboard_event);\n", + " this.canvas_div = canvas_div\n", + " this._canvas_extra_style(canvas_div)\n", + " this.root.append(canvas_div);\n", + "\n", + " var canvas = $('');\n", + " canvas.addClass('mpl-canvas');\n", + " canvas.attr('style', \"left: 0; top: 0; z-index: 0; outline: 0\")\n", + "\n", + " this.canvas = canvas[0];\n", + " this.context = canvas[0].getContext(\"2d\");\n", + "\n", + " var backingStore = this.context.backingStorePixelRatio ||\n", + "\tthis.context.webkitBackingStorePixelRatio ||\n", + "\tthis.context.mozBackingStorePixelRatio ||\n", + "\tthis.context.msBackingStorePixelRatio ||\n", + "\tthis.context.oBackingStorePixelRatio ||\n", + "\tthis.context.backingStorePixelRatio || 1;\n", + "\n", + " mpl.ratio = (window.devicePixelRatio || 1) / backingStore;\n", + "\n", + " var rubberband = $('');\n", + " rubberband.attr('style', \"position: absolute; left: 0; top: 0; z-index: 1;\")\n", + "\n", + " var pass_mouse_events = true;\n", + "\n", + " canvas_div.resizable({\n", + " start: function(event, ui) {\n", + " pass_mouse_events = false;\n", + " },\n", + " resize: function(event, ui) {\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " stop: function(event, ui) {\n", + " pass_mouse_events = true;\n", + " fig.request_resize(ui.size.width, ui.size.height);\n", + " },\n", + " });\n", + "\n", + " function mouse_event_fn(event) {\n", + " if (pass_mouse_events)\n", + " return fig.mouse_event(event, event['data']);\n", + " }\n", + "\n", + " rubberband.mousedown('button_press', mouse_event_fn);\n", + " rubberband.mouseup('button_release', mouse_event_fn);\n", + " // Throttle sequential mouse events to 1 every 20ms.\n", + " rubberband.mousemove('motion_notify', mouse_event_fn);\n", + "\n", + " rubberband.mouseenter('figure_enter', mouse_event_fn);\n", + " rubberband.mouseleave('figure_leave', mouse_event_fn);\n", + "\n", + " canvas_div.on(\"wheel\", function (event) {\n", + " event = event.originalEvent;\n", + " event['data'] = 'scroll'\n", + " if (event.deltaY < 0) {\n", + " event.step = 1;\n", + " } else {\n", + " event.step = -1;\n", + " }\n", + " mouse_event_fn(event);\n", + " });\n", + "\n", + " canvas_div.append(canvas);\n", + " canvas_div.append(rubberband);\n", + "\n", + " this.rubberband = rubberband;\n", + " this.rubberband_canvas = rubberband[0];\n", + " this.rubberband_context = rubberband[0].getContext(\"2d\");\n", + " this.rubberband_context.strokeStyle = \"#000000\";\n", + "\n", + " this._resize_canvas = function(width, height) {\n", + " // Keep the size of the canvas, canvas container, and rubber band\n", + " // canvas in synch.\n", + " canvas_div.css('width', width)\n", + " canvas_div.css('height', height)\n", + "\n", + " canvas.attr('width', width * mpl.ratio);\n", + " canvas.attr('height', height * mpl.ratio);\n", + " canvas.attr('style', 'width: ' + width + 'px; height: ' + height + 'px;');\n", + "\n", + " rubberband.attr('width', width);\n", + " rubberband.attr('height', height);\n", + " }\n", + "\n", + " // Set the figure to an initial 600x600px, this will subsequently be updated\n", + " // upon first draw.\n", + " this._resize_canvas(600, 600);\n", + "\n", + " // Disable right mouse context menu.\n", + " $(this.rubberband_canvas).bind(\"contextmenu\",function(e){\n", + " return false;\n", + " });\n", + "\n", + " function set_focus () {\n", + " canvas.focus();\n", + " canvas_div.focus();\n", + " }\n", + "\n", + " window.setTimeout(set_focus, 100);\n", + "}\n", + "\n", + "mpl.figure.prototype._init_toolbar = function() {\n", + " var fig = this;\n", + "\n", + " var nav_element = $('
')\n", + " nav_element.attr('style', 'width: 100%');\n", + " this.root.append(nav_element);\n", + "\n", + " // Define a callback function for later on.\n", + " function toolbar_event(event) {\n", + " return fig.toolbar_button_onclick(event['data']);\n", + " }\n", + " function toolbar_mouse_event(event) {\n", + " return fig.toolbar_button_onmouseover(event['data']);\n", + " }\n", + "\n", + " for(var toolbar_ind in mpl.toolbar_items) {\n", + " var name = mpl.toolbar_items[toolbar_ind][0];\n", + " var tooltip = mpl.toolbar_items[toolbar_ind][1];\n", + " var image = mpl.toolbar_items[toolbar_ind][2];\n", + " var method_name = mpl.toolbar_items[toolbar_ind][3];\n", + "\n", + " if (!name) {\n", + " // put a spacer in here.\n", + " continue;\n", + " }\n", + " var button = $('');\n", + " button.click(method_name, toolbar_event);\n", + " button.mouseover(tooltip, toolbar_mouse_event);\n", + " nav_element.append(button);\n", + " }\n", + "\n", + " // Add the status bar.\n", + " var status_bar = $('');\n", + " nav_element.append(status_bar);\n", + " this.message = status_bar[0];\n", + "\n", + " // Add the close button to the window.\n", + " var buttongrp = $('
');\n", + " var button = $('');\n", + " button.click(function (evt) { fig.handle_close(fig, {}); } );\n", + " button.mouseover('Stop Interaction', toolbar_mouse_event);\n", + " buttongrp.append(button);\n", + " var titlebar = this.root.find($('.ui-dialog-titlebar'));\n", + " titlebar.prepend(buttongrp);\n", + "}\n", + "\n", + "mpl.figure.prototype._root_extra_style = function(el){\n", + " var fig = this\n", + " el.on(\"remove\", function(){\n", + "\tfig.close_ws(fig, {});\n", + " });\n", + "}\n", + "\n", + "mpl.figure.prototype._canvas_extra_style = function(el){\n", + " // this is important to make the div 'focusable\n", + " el.attr('tabindex', 0)\n", + " // reach out to IPython and tell the keyboard manager to turn it's self\n", + " // off when our div gets focus\n", + "\n", + " // location in version 3\n", + " if (IPython.notebook.keyboard_manager) {\n", + " IPython.notebook.keyboard_manager.register_events(el);\n", + " }\n", + " else {\n", + " // location in version 2\n", + " IPython.keyboard_manager.register_events(el);\n", + " }\n", + "\n", + "}\n", + "\n", + "mpl.figure.prototype._key_event_extra = function(event, name) {\n", + " var manager = IPython.notebook.keyboard_manager;\n", + " if (!manager)\n", + " manager = IPython.keyboard_manager;\n", + "\n", + " // Check for shift+enter\n", + " if (event.shiftKey && event.which == 13) {\n", + " this.canvas_div.blur();\n", + " event.shiftKey = false;\n", + " // Send a \"J\" for go to next cell\n", + " event.which = 74;\n", + " event.keyCode = 74;\n", + " manager.command_mode();\n", + " manager.handle_keydown(event);\n", + " }\n", + "}\n", + "\n", + "mpl.figure.prototype.handle_save = function(fig, msg) {\n", + " fig.ondownload(fig, null);\n", + "}\n", + "\n", + "\n", + "mpl.find_output_cell = function(html_output) {\n", + " // Return the cell and output element which can be found *uniquely* in the notebook.\n", + " // Note - this is a bit hacky, but it is done because the \"notebook_saving.Notebook\"\n", + " // IPython event is triggered only after the cells have been serialised, which for\n", + " // our purposes (turning an active figure into a static one), is too late.\n", + " var cells = IPython.notebook.get_cells();\n", + " var ncells = cells.length;\n", + " for (var i=0; i= 3 moved mimebundle to data attribute of output\n", + " data = data.data;\n", + " }\n", + " if (data['text/html'] == html_output) {\n", + " return [cell, data, j];\n", + " }\n", + " }\n", + " }\n", + " }\n", + "}\n", + "\n", + "// Register the function which deals with the matplotlib target/channel.\n", + "// The kernel may be null if the page has been refreshed.\n", + "if (IPython.notebook.kernel != null) {\n", + " IPython.notebook.kernel.comm_manager.register_target('matplotlib', mpl.mpl_figure_comm);\n", + "}\n" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "data": { + "text/html": [ + "" + ], + "text/plain": [ + "" + ] + }, + "metadata": {}, + "output_type": "display_data" + }, + { + "name": "stderr", + "output_type": "stream", + "text": [ + "2018-04-22 19:09:24,171 Verification loss= 0.0000,error rate= 0.0000,IOU = 1.0000, F1 IOU= 99.9600%\n" + ] + } + ], + "source": [ + "## Visualize live mode \n", + "fig_follow,axs_follow =plt.subplots(1, 5,figsize=(10,3))\n", + "draw_update(loss_train,avg_loss_train,avg_loss_val,avg_iou,avg_f1,lr_train,fig_follow,axs_follow)\n", + "\n", + "logging.info(\"Start optimization\")\n", + "\n", + "lr=DEFAULT_LR \n", + "optimizer=optim.Adam(net.parameters(),lr=lr)\n", + "\n", + "for epoch in range(DEFAULT_EPOCHS):\n", + " ##tune learning reate\n", + " if epoch in REDUCE_LR_STEPS:\n", + " lr = lr * 0.5\n", + " optimizer = torch.optim.Adam(net.parameters(), lr)\n", + " \n", + " total_loss = 0\n", + " error_tot=0 \n", + " train_loader = DataLoader(train_generator, batch_size=DEFAULT_BATCH_SIZE,shuffle=True, num_workers=1)\n", + " counter=0\n", + " for i_batch,sample_batch in enumerate(train_loader):\n", + " \n", + " batch_x=standardize(sample_batch['input'])\n", + " batch_y=sample_batch['groundtruth']\n", + "\n", + " ##Variables input and output transformed for cuda\n", + " X = Variable(batch_x.float())\n", + " X=X.permute(0,3,1,2).cuda() \n", + " Y = Variable(batch_y.float())\n", + " Y=Y.cuda()\n", + "\n", + " ## fwd\n", + " if DISTANCE_NET:\n", + " Y_dist=distance_map_batch(batch_y,THRESHOLD,BINS)\n", + " Y_dist = Variable(Y_dist.float())\n", + " Y_dist=Y_dist.cuda()\n", + "\n", + " probs_dist,probs_seg=predict(net,X,DISTANCE_NET)\n", + " optimizer.zero_grad()\n", + " loss_seg=criterion(Y,probs_seg)\n", + " loss_dist=criterion(Y_dist,probs_dist)\n", + " loss=loss_seg+loss_dist\n", + "\n", + " else: \n", + " probs=predict(net,X)\n", + " optimizer.zero_grad()\n", + " loss=criterion(Y,probs)\n", + " Y_dist=None\n", + "\n", + " loss.backward()\n", + " optimizer.step()\n", + "\n", + " total_loss+=loss.data[0]\n", + " loss_train.append(loss.data[0])\n", + " lr_train.append(lr)\n", + " \n", + " if counter % DISPLAY_STEP == 0:\n", + " draw_update(loss_train,avg_loss_train,avg_loss_val,avg_iou,avg_f1,lr_train,fig_follow,axs_follow)\n", + " counter+=1\n", + " \n", + " avg_loss_train.append(total_loss/train_loader.__len__())\n", + " logging.info(\" Training {:}, Minibatch Loss= {:.4f}\".format(\"epoch_%s\"%epoch,total_loss/train_loader.__len__()))\n", + " loss_v=0\n", + " iou_v=0\n", + " f1_v=0\n", + " error_rate_v=0\n", + " name=\"epoch_%s\"%epoch\n", + "\n", + " for i_batch,sample in enumerate(val_loader):\n", + " batch_x=standardize(sample['input'])\n", + " batch_y=sample['groundtruth']\n", + "\n", + " X = Variable(batch_x.float())\n", + " X=X.permute(0,3,1,2).cuda() \n", + " Y = Variable(batch_y.float())\n", + " Y=Y.cuda()\n", + " if DISTANCE_NET:\n", + " y_dist=distance_map_batch(batch_y,THRESHOLD,BINS)\n", + " Y_dist = Variable(y_dist.float())\n", + " Y_dist=Y_dist.cuda()\n", + " probs_dist,probs_seg=predict(net,X,DISTANCE_NET)\n", + " loss_seg=criterion(Y,probs_seg)\n", + " loss_dist=criterion(Y_dist,probs_dist)\n", + " loss=loss_seg+loss_dist\n", + " prediction_seg_v=probs_seg.data.cpu().numpy()\n", + " groundtruth_seg_v=np.asarray(batch_y)\n", + " prediction_dist_v=probs_dist.data.cpu().numpy()\n", + " groundtruth_dist=np.asarray(y_dist)\n", + "\n", + " else:\n", + " probs=predict(net,X)\n", + " loss=criterion(Y,probs)\n", + " prediction_seg_v=probs.data.cpu().numpy()\n", + " groundtruth_seg_v=np.asarray(batch_y)\n", + " prediction_dist_v=None\n", + " groundtruth_dist=None\n", + "\n", + " loss_v+=loss.data[0]\n", + " \n", + " __,f1,iou=predict_score_batch(TMP_IOU,np.argmax(groundtruth_seg_v,3),np.argmax(prediction_seg_v,3))\n", + " \n", + " iou_v+=iou\n", + " f1_v+=f1\n", + " \n", + " error_rate_v+=error_rate(prediction_seg_v,groundtruth_seg_v)\n", + " \n", + " if i_batch==RBD:\n", + " pansharp=np.asarray(batch_x)\n", + " \n", + " plot_summary(prediction_seg_v,groundtruth_seg_v,prediction_dist_v,groundtruth_dist,pansharp,name)\n", + " \n", + "\n", + " loss_v/=val_loader.__len__()\n", + " error_rate_v/=val_loader.__len__()\n", + " avg_loss_val.append(loss_v)\n", + " iou_v/=val_loader.__len__() \n", + " f1_v/=val_loader.__len__() \n", + " avg_iou.append(iou_v)\n", + " avg_f1.append(f1_v)\n", + " logging.info(\"Verification loss= {:.4f},error rate= {:.4f},IOU = {:.4f}, F1 IOU= {:.4f}%\".format(loss_v,error_rate_v,iou_v,f1_v)) \n", + " \n", + " " + ] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + }, + { + "cell_type": "code", + "execution_count": null, + "metadata": {}, + "outputs": [], + "source": [] + } + ], + "metadata": { + "kernelspec": { + "display_name": "env_dhi", + "language": "python", + "name": "env_dhi" + }, + "language_info": { + "codemirror_mode": { + "name": "ipython", + "version": 3 + }, + "file_extension": ".py", + "mimetype": "text/x-python", + "name": "python", + "nbconvert_exporter": "python", + "pygments_lexer": "ipython3", + "version": "3.6.4" + } + }, + "nbformat": 4, + "nbformat_minor": 2 +} diff --git a/Unet_buildings_detection/readme_buildings.md b/Unet_buildings_detection/readme_buildings.md new file mode 100644 index 0000000..c86d3be --- /dev/null +++ b/Unet_buildings_detection/readme_buildings.md @@ -0,0 +1,19 @@ +# Unet buildings detection + +## Required libraries installation +On Linux + +```sh + +$pip install scipy +$pip install matplotlib +$conda install gdal +$conda install -c ioos rtree +$pip install centerline +$pip install osmnx +$pip install torch torchvision +$conda install -c menpo opencv +``` + + + diff --git a/Unet_buildings_detection/requirements.txt b/Unet_buildings_detection/requirements.txt new file mode 100644 index 0000000..8a44148 --- /dev/null +++ b/Unet_buildings_detection/requirements.txt @@ -0,0 +1,5 @@ +python 3.6 +pytorch +scipy +gdal +cv2 \ No newline at end of file diff --git a/Unet_buildings_detection/unet_meli.py b/Unet_buildings_detection/unet_meli.py new file mode 100644 index 0000000..401a828 --- /dev/null +++ b/Unet_buildings_detection/unet_meli.py @@ -0,0 +1,201 @@ +""" +U-net model from https://arxiv.org/abs/1505.04597 implemented with residual blocks, batch norm and dropout +couple with distance net module, multi task learning described in https://arxiv.org/pdf/1709.05932.pdf + +""" + +import torch +from torch import nn +from torch.nn import functional as F + + + +class inconv(nn.Module): + """ + initial convolution for the U-Net model + """ + def __init__(self, in_ch, out_ch,width_kernel,dropout,batch_norm): + super(inconv, self).__init__() + self.conv = make_residual_layer(ResidualBlock, in_ch, out_ch, 1, width_kernel,dropout=dropout,batch_norm=batch_norm) + + def forward(self, x): + x = self.conv(x) + return x +class outconv(nn.Module): + """ + last convolution for the U-Net (Fully connected layer) + """ + def __init__(self, in_ch, out_ch): + super(outconv, self).__init__() + self.conv = nn.Conv2d(in_ch, out_ch, 1) + + def forward(self, x): + x = self.conv(x) + return x +def conv3x3(in_channels, out_channels, width_kernel,stride=1): + """ + 3x3 convolution + """ + return nn.Conv2d(in_channels, out_channels, kernel_size=width_kernel, + stride=stride, padding=int((width_kernel-1)/2), bias=False) + +class ResidualBlock(nn.Module): + """ + Residual Block with two convolution, dropout and batch normalization + dropout set according to https://arxiv.org/pdf/1605.07146.pdf + """ + def __init__(self, in_channels, out_channels, width_kernel,stride=1, downsample=None, dropout=0,batch_norm=False): + super(ResidualBlock, self).__init__() + self.dropout = dropout + self.batch_norm = batch_norm + self.conv1 = conv3x3(in_channels, out_channels,width_kernel, stride) + if self.batch_norm: + self.bn1 = nn.BatchNorm2d(out_channels) + if self.dropout > 0: + self.drop = nn.Dropout2d(self.dropout) + self.conv2 = conv3x3(out_channels, out_channels,width_kernel) + if self.batch_norm: + self.bn2 = nn.BatchNorm2d(out_channels) + self.relu = nn.ReLU(inplace=True) + self.downsample = downsample + + def forward(self, x): + residual = x + out = self.conv1(x) + if self.batch_norm: + out = self.bn1(out) + if self.dropout > 0: + out = self.drop(out) + #out = self.relu(out) + out = self.conv2(out) + if self.batch_norm: + out = self.bn2(out) + if self.downsample: + residual = self.downsample(x) + out += residual + out = self.relu(out) + return out + +def make_residual_layer(block,in_channels, out_channels, blocks, width_kernel,stride=1, dropout=0,batch_norm=False): + """ + make a layer from intermediate blocks + """ + downsample = None + if (stride != 1) or (in_channels != out_channels): + downsample = nn.Sequential( + conv3x3(in_channels, out_channels, width_kernel,stride=stride), + nn.BatchNorm2d(out_channels)) + layers = [] + layers.append(block(in_channels, out_channels,width_kernel, stride, downsample, dropout=dropout, batch_norm=batch_norm)) + in_channels = out_channels + for i in range(1, blocks): + layers.append(block(out_channels, out_channels,width_kernel, dropout=dropout, batch_norm=batch_norm)) + return nn.Sequential(*layers) + + +class down_residual(nn.Module): + """ + U-Net down block using on residual block + """ + def __init__(self, in_ch, out_ch,width_kernel, dropout=0,batch_norm=False): + super(down_residual, self).__init__() + self.mpconv = nn.Sequential( + nn.MaxPool2d(2), + make_residual_layer(ResidualBlock, in_ch, out_ch, 1, width_kernel,dropout=dropout,batch_norm=batch_norm) + ) + + def forward(self, x): + x = self.mpconv(x) + return x + +class up_residual(nn.Module): + """ + U-Net up block using one residual block + """ + def __init__(self, in_ch, out_ch,width_kernel, dropout=0,batch_norm=False): + super(up_residual, self).__init__() + self.up = nn.UpsamplingBilinear2d(scale_factor=2) + #self.up = nn.ConvTranspose2d(in_ch, out_ch, 2, stride=2) + self.conv = make_residual_layer(ResidualBlock, in_ch, out_ch,1, width_kernel,dropout=dropout,batch_norm=batch_norm) + + def forward(self, x1, x2): + x1 = self.up(x1) + diffX = x1.size()[2] - x2.size()[2] + diffY = x1.size()[3] - x2.size()[3] + x2 = F.pad(x2, (diffX // 2, diffX // 2,diffY // 2, diffY // 2)) + x = torch.cat([x2, x1], dim=1) + x = self.conv(x) + return x + +class UNet(nn.Module): + """ + U-Net model with custom number of layers, dropout and batch normalization + """ + def __init__(self, in_channels, out_channels, depth = 5, n_features_zero = 64, width_kernel=3,dropout=0,batch_norm=True,distance_net=False,bins=15): + """ + initialize the model + Args: + in_channels (int): number of input channels (image=3) + out_channels (int): number of output channels (n_classes) + depth (int): number of down/up layers + n_features (int): number of initial features + dropout (float): float in [0,1]: dropout probability + batch_norm (bool): use batch normalization or not + distance_net (bool): add distance Net module + bins (int): number of bins of the distance map + + """ + super(UNet, self).__init__() + n_features = n_features_zero + self.inc = inconv(in_channels,n_features,width_kernel,dropout=dropout,batch_norm=batch_norm) + # DOWN + self.downs = torch.nn.ModuleList() + for k in range(depth-1): + d = down_residual(n_features, 2*n_features,width_kernel, dropout=dropout,batch_norm=batch_norm) + n_features = 2 * n_features + self.downs += [d] + self.downs += [down_residual(n_features, n_features,width_kernel, dropout=dropout,batch_norm=batch_norm)] + # UP + self.ups = torch.nn.ModuleList() + for k in range(depth): + u = up_residual(2*n_features, n_features//2,width_kernel, dropout=dropout,batch_norm=batch_norm) + n_features = n_features // 2 + self.ups += [u] + self.outc = outconv(n_features, out_channels) + self.distance_net=distance_net + if self.distance_net: + self.outc2= outconv(n_features, bins) + + def forward(self, x): + x = self.inc(x) + bridges = [] + for d in self.downs: + bridges += [x] + x = d(x) + + for k,u in enumerate(self.ups): + x = u(x,bridges[len(bridges)-1-k]) + if self.distance_net: + x_seg=self.outc(x) + x_dist=torch.cat((x, x_seg), 1) + x_dist = self.outc2(x) + return x_dist,x_seg + else: + x = self.outc(x) + return x + + + def debug(self, x): + x = self.inc(x) + bridges = [] + downs = [] + ups = [] + for d in self.downs: + bridges += [x] + x = d(x) + downs.append(x) + for k,u in enumerate(self.ups): + x = u(x,bridges[len(bridges)-1-k]) + ups.append(x) + x = self.outc(x) + return x, downs, ups