29 |
30 |
31 |
32 |
33 |
34 |
--------------------------------------------------------------------------------
/results-viewer/get-tile-url.js:
--------------------------------------------------------------------------------
1 | const getAccessToken = require('./access-token')
2 |
3 | module.exports = function (opts, z, x, y) {
4 | let url
5 | if (opts.imagery_source && /^[^\/]+:\/\//.test(opts.imagery_source)) {
6 | url = opts.imagery_source
7 | } else {
8 | url = '//b.tiles.mapbox.com/v4/{mapid}/{z}/{x}/{y}.png?access_token={token}'
9 | .replace('{mapid}', opts.imagery_source || 'mapbox.satellite')
10 | .replace('{token}', getAccessToken(opts))
11 | }
12 |
13 | return url
14 | .replace('{z}', z)
15 | .replace('{x}', x)
16 | .replace('{y}', y)
17 | }
18 |
--------------------------------------------------------------------------------
/results-viewer/map.js:
--------------------------------------------------------------------------------
1 | const mapboxgl = require('mapbox-gl')
2 | const labelLayers = require('mapbox-gl-styles/styles/basic-v9.json').layers
3 | .filter((l) => /poi|place|country/.test(l.id))
4 | const getAccessToken = require('./access-token')
5 |
6 | module.exports = function (opts) {
7 | let style
8 | if (opts.imagery_source) {
9 | let source
10 | if (!/^[^\/]+:\/\//.test(opts.imagery_source)) {
11 | source = { url: 'mapbox://' + opts.imagery_source }
12 | } else {
13 | source = { tiles: [ opts.imagery_source ] }
14 | }
15 | Object.assign(source, { type: 'raster', tileSize: 256 })
16 | style = {
17 | version: 8,
18 | sources: {
19 | mapbox: { url: 'mapbox://mapbox.mapbox-streets-v7', type: 'vector' },
20 | imagery: source
21 | },
22 | sprite: 'mapbox://sprites/mapbox/basic-v9',
23 | glyphs: 'mapbox://fonts/mapbox/{fontstack}/{range}.pbf',
24 | layers: [
25 | {id: 'background', type: 'background', paint: { 'background-color': '#121212' }},
26 | {id: 'imagery', type: 'raster', source: 'imagery'}
27 | ].concat(labelLayers)
28 | }
29 | } else {
30 | style = 'mapbox://styles/mapbox/satellite-streets-v9'
31 | }
32 |
33 | mapboxgl.accessToken = getAccessToken(opts)
34 | const map = window._map = new mapboxgl.Map({
35 | container: opts.container || 'map',
36 | style: style,
37 | center: [0, 0],
38 | zoom: 1,
39 | hash: true
40 | })
41 |
42 | if (opts.showTileBoundaries) {
43 | map.showTileBoundaries = true
44 | }
45 |
46 | return map
47 | }
48 |
49 |
--------------------------------------------------------------------------------
/results-viewer/view.js:
--------------------------------------------------------------------------------
1 | const qs = require('querystring')
2 | const http = require('choo/http')
3 | const choo = require('choo')
4 | const tilebelt = require('tilebelt')
5 | const createMap = require('./map')
6 | const getSatelliteTileURL = require('./get-tile-url')
7 |
8 | const query = qs.parse(window.location.search.substring(1))
9 | const accessToken = require('./access-token')(query)
10 | let baseurls = query.baseurl || ''
11 | if (!Array.isArray(baseurls)) { baseurls = [baseurls] }
12 | // add trailing slash
13 | baseurls = baseurls.map(b => (b === '' || b.endsWith('/')) ? b : `${b}/`)
14 |
15 | let map = accessToken && !query.hasOwnProperty('no-map') && createMap(query)
16 | .on('load', function () {
17 | map.addSource('tile', { type: 'geojson', data: { type: 'FeatureCollection', features: [] } })
18 | map.addLayer({
19 | 'id': 'tile',
20 | 'source': 'tile',
21 | 'type': 'line',
22 | 'paint': {
23 | 'line-color': 'red',
24 | 'line-width': 4
25 | }
26 | })
27 | })
28 |
29 | const app = choo()
30 |
31 | app.model({
32 | namespace: 'app',
33 | state: { results: [], limit: 50, sort: 'index' },
34 | subscriptions: [
35 | function (send) { send('http:get_json') } // grab json data at startup
36 | ],
37 | reducers: {
38 | 'setTestOutput': (action, state) => {
39 | return Object.assign({}, state, {
40 | results: state.results.concat({
41 | baseurl: action.payload.baseurl,
42 | items: action.payload.images,
43 | metrics: {
44 | correctness: action.payload.correctness,
45 | completeness: action.payload.completeness
46 | }
47 | })
48 | })
49 | },
50 | 'loadMore': logged((action, state) => ({ limit: state.limit + 50 }), 'loadMore'),
51 | 'sort': (action, state) => ({ sort: action.key })
52 | },
53 | effects: {
54 | 'error': (state, event) => console.error(`error: ${event.payload}`),
55 | 'print': (state, event) => console.log(`http: ${event.payload}`)
56 | }
57 | })
58 |
59 | app.model({
60 | namespace: 'http',
61 | effects: {
62 | 'get_json': getJson
63 | }
64 | })
65 |
66 | const view = (params, state, send) => {
67 | const results = [].concat(state.app.results)
68 | .sort((r, s) => baseurls.indexOf(r.baseurl) - baseurls.indexOf(s.baseurl))
69 |
70 | const sort = state.app.sort.split(':')
71 | let items
72 | if (!results.length) {
73 | items = []
74 | } else if (sort[0] === 'index') {
75 | items = [].concat(results[0].items)
76 | } else {
77 | items = results[0].items
78 | .filter(function (item) {
79 | return item.metrics[sort[0]] >= 0
80 | })
81 | .sort(function (a, b) {
82 | var diff = a.metrics[sort[0]] - b.metrics[sort[0]]
83 | return sort[1] === 'ascending' ? diff : -diff
84 | })
85 | }
86 |
87 | const resultNames = stripCommon(results.map(r => r.baseurl))
88 |
89 | const colCount = 2 + baseurls.length
90 | const colMargin = 2
91 | const colStyle = [
92 | `width: calc((100% - ${colMargin * colCount}px) / ${colCount})`,
93 | `margin-left: ${colMargin}px`
94 | ].join('; ')
95 |
96 | let missingAccessToken = ''
97 | if (!query.hasOwnProperty('no-map') && !accessToken) {
98 | const url = window.location.href.replace(/#.*$/, '')
99 | missingAccessToken = choo.view`
100 |
101 | To view results on the map, add a Mapbox access token to the URL like so:
102 | ${url}${/\?/.test(url) ? '&' : '?'}access_token=ACCESSTOKEN
103 |
`
104 | }
105 |
106 | return choo.view`
107 |
108 |
109 |
110 |
111 |
112 |
113 | ${missingAccessToken}
114 |
163 | `
164 | }
165 |
166 | app.router((route) => [
167 | route('/', logged(view, 'view'))
168 | ])
169 |
170 | document.querySelector('#app').appendChild(app.start())
171 |
172 | function getTile (item) {
173 | var match = /(\d*)-(\d*)-(\d*).png/.exec(item.test_data)
174 | return match && match.slice(1, 4)
175 | }
176 |
177 | function onClick (event) {
178 | if (!map) { return }
179 |
180 | let node = event.currentTarget
181 | while (node && !(node.dataset && node.dataset.tile)) {
182 | if (node.parentNode === node) { break }
183 | node = node.parentNode
184 | }
185 |
186 | var tile = node.dataset.tile.split(',').map(Number)
187 | tile = [tile[1], tile[2], tile[0]]
188 | var [w, s, e, n] = tilebelt.tileToBBOX(tile)
189 | var z = +tile[2]
190 |
191 | var coordinates = [
192 | [w, n],
193 | [e, n],
194 | [e, s],
195 | [w, s]
196 | ]
197 |
198 | map.jumpTo({center: [ (w + e) / 2, (s + n) / 2 ], zoom: z - 1, speed: 2})
199 | map.getSource('tile').setData({
200 | type: 'Feature',
201 | properties: {},
202 | geometry: {
203 | type: 'Polygon',
204 | coordinates: [ coordinates.concat([[w, n]]) ]
205 | }
206 | })
207 |
208 | showOverlay(event.currentTarget.src, coordinates)
209 | }
210 |
211 | function showOverlay (url, coords) {
212 | console.log('show overlay', url, coords)
213 | if (map.getLayer('class-overlay')) {
214 | map.removeLayer('class-overlay')
215 | }
216 | if (map.getSource('class-overlay')) {
217 | map.removeSource('class-overlay')
218 | }
219 |
220 | map.addSource('class-overlay', {
221 | type: 'image',
222 | url: url,
223 | coordinates: coords
224 | })
225 |
226 | map.addLayer({
227 | 'id': 'class-overlay',
228 | 'source': 'class-overlay',
229 | 'type': 'raster',
230 | 'paint': { 'raster-opacity': 0.5 }
231 | })
232 | }
233 |
234 | function getJson (state, action, send) {
235 | baseurls.forEach((baseurl, i) => {
236 | http.get(baseurl + 'index.json', { json: true }, function (err, res, body) {
237 | if (err) return send('app:error', { payload: err.message })
238 | if (res.statusCode !== 200 || !body) {
239 | return send('app:error', { payload: 'something went wrong' })
240 | }
241 | if (typeof body === 'string') {
242 | body = JSON.parse(body.replace(/NaN/g, '-1'))
243 | }
244 | body.baseurl = baseurl
245 | send('app:setTestOutput', { payload: body })
246 | })
247 | })
248 | }
249 |
250 | function logged (view, tag) {
251 | return function () {
252 | console.log(tag || '', arguments)
253 | return view.apply(this, Array.prototype.slice.call(arguments))
254 | }
255 | }
256 |
257 | /**
258 | * Given an array of strings, return a new array wherein the common prefix
259 | * and common postfix for the given strings is removed.
260 | *
261 | * Example: stripCommon(['abcHello Worldxyz', 'abc123xyz', 'abcxyz']) ===
262 | * ['Hello World', '123', '']
263 | *
264 | * One small exception: do only treat numerical digits (and "K") as 'common'
265 | * if the whole string of them is common -- otherwise
266 | * ['abc_123_5000', 'abc_123_55000'] would become ['', '5'], whereas we really
267 | * want ['5000', '55000']
268 | */
269 | function stripCommon (strings) {
270 | if (strings.length <= 1) return strings
271 | let digits = []
272 | let pre = 0
273 | while (pre < strings[0].length) {
274 | let chars = strings.map(s => s.charAt(pre))
275 | if (chars.some(c => !c)) { break }
276 | if (chars.some(c => c !== chars[0])) {
277 | break
278 | }
279 | if (/[\dK]/.test(chars[0])) {
280 | digits.push(chars[0])
281 | } else {
282 | digits = []
283 | }
284 | pre++
285 | }
286 | console.log(digits)
287 | strings = strings.map(s => digits.join('') + s.slice(Math.max(pre, 0)))
288 |
289 | let post = 0
290 | digits = []
291 | while (post < strings[0].length) {
292 | let chars = strings.map(s => s.charAt(s.length - post - 1))
293 | if (chars.some(c => !c.length)) { break }
294 | if (chars.some(c => c !== chars[0])) {
295 | break
296 | }
297 | if (/[\dK]/.test(chars[0])) {
298 | digits.unshift(chars[0])
299 | } else {
300 | digits = []
301 | }
302 | post++
303 | }
304 | return strings.map(s => s.slice(0, s.length - post) + digits.join(''))
305 | }
306 |
307 |
--------------------------------------------------------------------------------
/segnet/.gitignore:
--------------------------------------------------------------------------------
1 | env
2 |
--------------------------------------------------------------------------------
/segnet/batch_inference.py:
--------------------------------------------------------------------------------
1 | # https://github.com/BVLC/caffe/issues/861
2 | import matplotlib
3 | matplotlib.use('Agg')
4 |
5 | import re
6 | import os
7 | import os.path
8 | import sys
9 | import time
10 | import random
11 | import requests
12 | import numpy as np
13 | from PIL import Image
14 | import click
15 | import json
16 | import StringIO
17 | import subprocess
18 | import tempfile
19 | from boto3.session import Session
20 | caffe_root = os.getenv('CAFFE_ROOT', '/home/ubuntu/caffe-segnet/')
21 | sys.path.insert(0, caffe_root + 'python')
22 | import caffe
23 |
24 | from inference import predict
25 | from queue import receive
26 | from vectorize import vectorize
27 |
28 | aws_session = Session()
29 | s3 = aws_session.client('s3')
30 | dirname = os.path.dirname(os.path.realpath(__file__))
31 | polys_to_lines = os.path.join(dirname, '../vectorize.js')
32 |
33 |
34 | class TileNotFoundError(Exception):
35 | def __init__(self, msg):
36 | Exception.__init__(self, msg)
37 |
38 |
39 | def parse_s3_uri(s3uri):
40 | match = re.search('s3://([^/]*)/(.*)$', s3uri)
41 | if not match:
42 | return None
43 | return (match.group(1), match.group(2))
44 |
45 |
46 | def resolve_s3(s3uri, temp=False):
47 | parsed = parse_s3_uri(s3uri)
48 | if not parsed:
49 | return s3uri
50 | (bucket, key) = parsed
51 | if temp:
52 | target = '/tmp/' + os.path.basename(key)
53 | else:
54 | target = '/model/' + os.path.basename(key)
55 | if not os.path.isfile(target):
56 | print('downloading ' + s3uri + ' to ' + target)
57 | s3.download_file(bucket, key, target)
58 | else:
59 | print(s3uri + ' appears to have already been downloaded to ' + target +
60 | '; using local copy.')
61 | return target
62 |
63 |
64 | def setup_net(model, weights, gpu, cpu_only):
65 | model_file = resolve_s3(model)
66 | weights_file = resolve_s3(weights)
67 | if not os.path.isfile(weights_file) and os.path.isdir('/model'):
68 | caffemodels = filter(lambda x: x.endswith('.caffemodel'), os.listdir('/model'))
69 | if len(caffemodels) == 0:
70 | raise Exception('No .caffemodel files found in /model.')
71 | weights_file = '/model/%s' % caffemodels[0]
72 |
73 | # read model definition
74 | model = open(model_file, 'r').read()
75 | # create net
76 | if cpu_only:
77 | caffe.set_mode_cpu()
78 | else:
79 | caffe.set_mode_gpu()
80 | caffe.set_device(gpu)
81 |
82 | return caffe.Net(model_file.encode('utf8'),
83 | weights_file.encode('utf8'),
84 | caffe.TEST)
85 |
86 |
87 | def make_prediction(net, colors, im, outfile):
88 | bands = len(im.getbands())
89 | imdata = np.array(im.getdata()).reshape(im.size[0], im.size[1], bands)
90 | predicted = predict(net, colors, imdata)
91 | predicted.save(outfile, 'PNG')
92 |
93 |
94 | def get_image_tile(url, x, y, z):
95 | image_url = url.replace('{x}', str(x)).replace('{y}', str(y)).replace('{z}', str(z))
96 |
97 | # First check if image is on S3
98 | if 's3://' in image_url:
99 | img_to_load = resolve_s3(image_url, temp=True)
100 |
101 | # Otherwise, pull it from other source
102 | else:
103 | resp = requests.get(image_url)
104 | if not resp.ok:
105 | raise TileNotFoundError({'status': resp.status_code, 'content': resp.content})
106 | img_to_load = StringIO.StringIO(resp.content)
107 |
108 | return Image.open(img_to_load).convert('RGB')
109 |
110 |
111 | def upload_centerlines(filename, output_bucket, prefix):
112 | uid = ''.join(random.choice('abcdef0123456789') for _ in range(6))
113 | key = '%s/centerlines.%s-%s.geojson' % (prefix, time.time(), uid)
114 | click.echo('Uploading geojson %s' % key)
115 | s3.upload_file(filename, output_bucket, key, ExtraArgs={
116 | 'ContentType': 'application/ndjson'
117 | })
118 |
119 |
120 | @click.command()
121 | @click.argument('queue_name')
122 | @click.option('--model', type=str, default='/model/segnet_deploy.prototxt')
123 | @click.option('--weights', type=str, default='/model/weights.caffemodel')
124 | @click.option('--classes', type=str, default='/model/classes.json')
125 | @click.option('--gpu', type=int, default=0)
126 | @click.option('--cpu-only', is_flag=True, default=False)
127 | def run_batch(queue_name, model, weights, classes, gpu, cpu_only):
128 | net = setup_net(model, weights, gpu, cpu_only)
129 | classes_file = resolve_s3(classes)
130 |
131 | # read classes metadata
132 | with open(classes_file) as classes:
133 | colors = map(lambda x: x['color'][1:], json.load(classes))
134 | colors.append('000000')
135 | colors = map(lambda rgbstr: tuple(map(ord, rgbstr.decode('hex'))), colors)
136 |
137 | count = 0
138 | centerlines = tempfile.NamedTemporaryFile(suffix='.geojson', delete=False)
139 | click.echo('geojson output: %s' % centerlines.name)
140 |
141 | for message in receive(queue_name):
142 | try:
143 | click.echo('processing: %s' % message.body)
144 | (output_bucket, prefix, image_tiles, z, x, y) = json.loads(message.body)
145 |
146 | image = get_image_tile(image_tiles, x, y, z)
147 |
148 | # run prediction
149 | predicted = tempfile.NamedTemporaryFile(suffix='.png', delete=False)
150 | make_prediction(net, colors, image, predicted)
151 | predicted.close()
152 |
153 | # upload raster prediction image
154 | key = '%s/%s/%s/%s.png' % (prefix, z, x, y)
155 | s3.upload_file(predicted.name, output_bucket, key, ExtraArgs={
156 | 'ContentType': 'image/png'
157 | })
158 |
159 | # trace raster -> polygons
160 | polygonized = tempfile.NamedTemporaryFile(suffix='.geojson', delete=False)
161 | polygonized.write(json.dumps(vectorize(predicted.name)))
162 | polygonized.close()
163 |
164 | # upload polygon geojson for this tile
165 | key = '%s/%s/%s/%s.polygons.geojson' % (prefix, z, x, y)
166 | s3.upload_file(polygonized.name, output_bucket, key, ExtraArgs={
167 | 'ContentType': 'application/json'
168 | })
169 |
170 | # polygons => centerlines
171 | polyspine_args = map(str, [polys_to_lines, polygonized.name, x, y, z, 0.2])
172 | exitcode = subprocess.call(polyspine_args, stdout=centerlines)
173 |
174 | # clean up tempfiles
175 | os.remove(predicted.name)
176 | os.remove(polygonized.name)
177 |
178 | if exitcode != 0:
179 | raise Exception('Vectorize exited nonzero')
180 |
181 | # upload centerlines geojson to S3 every so often
182 | count += 1
183 | if count % 5000 == 0:
184 | centerlines.close()
185 | upload_centerlines(centerlines.name, output_bucket, prefix)
186 | # clear the file out and continue writing
187 | centerlines = open(centerlines.name, 'w+b')
188 |
189 | # remove message from the queue
190 | message.delete()
191 | except TileNotFoundError:
192 | click.echo('Imagery tile not found.')
193 | message.delete()
194 | except Exception as err:
195 | click.echo(err)
196 | try:
197 | message.delete()
198 | except Exception:
199 | pass
200 |
201 | centerlines.close()
202 | upload_centerlines(centerlines.name, output_bucket, prefix)
203 |
204 |
205 | if __name__ == '__main__':
206 | run_batch(auto_envvar_prefix='SKYNET')
207 |
--------------------------------------------------------------------------------
/segnet/compute_bn_statistics.py:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env python
2 |
3 | # Modified from https://github.com/alexgkendall/SegNet-Tutorial
4 |
5 | # > The Batch Normalisation layers in SegNet shift the input feature maps
6 | # > according to their mean and variance statistics for each mini batch during
7 | # > training. At test time we must use the statistics for the entire dataset.
8 | # (http://mi.eng.cam.ac.uk/projects/segnet/tutorial.html)
9 |
10 | import matplotlib
11 | matplotlib.use('Agg') # https://github.com/BVLC/caffe/issues/861
12 |
13 | import os
14 | import numpy as np
15 | from skimage.io import ImageCollection
16 | from argparse import ArgumentParser
17 |
18 |
19 | caffe_root = os.getenv('CAFFE_ROOT', '/home/ubuntu/caffe-segnet/')
20 | import sys
21 | sys.path.insert(0, os.path.join(caffe_root, 'python'))
22 |
23 | import caffe
24 | from caffe.proto import caffe_pb2
25 | from google.protobuf import text_format
26 |
27 |
28 | def extract_dataset(net_message):
29 | assert net_message.layer[0].type == "DenseImageData"
30 | source = net_message.layer[0].dense_image_data_param.source
31 | with open(source) as f:
32 | data = f.read().split()
33 | ims = ImageCollection(data[::2])
34 | labs = ImageCollection(data[1::2])
35 | assert len(ims) == len(labs) > 0
36 | return ims, labs
37 |
38 |
39 | def make_testable(train_model_path):
40 | # load the train net prototxt as a protobuf message
41 | with open(train_model_path) as f:
42 | train_str = f.read()
43 | train_net = caffe_pb2.NetParameter()
44 | text_format.Merge(train_str, train_net)
45 |
46 | # add the mean, var top blobs to all BN layers
47 | for layer in train_net.layer:
48 | if layer.type == "BN" and len(layer.top) == 1:
49 | layer.top.append(layer.top[0] + "-mean")
50 | layer.top.append(layer.top[0] + "-var")
51 |
52 | # remove the test data layer if present
53 | if train_net.layer[1].name == "data" and train_net.layer[1].include:
54 | train_net.layer.remove(train_net.layer[1])
55 | if train_net.layer[0].include:
56 | # remove the 'include {phase: TRAIN}' layer param
57 | train_net.layer[0].include.remove(train_net.layer[0].include[0])
58 | return train_net
59 |
60 |
61 | def make_test_files(testable_net_path, train_weights_path, num_iterations,
62 | in_h, in_w):
63 | # load the train net prototxt as a protobuf message
64 | with open(testable_net_path) as f:
65 | testable_str = f.read()
66 | testable_msg = caffe_pb2.NetParameter()
67 | text_format.Merge(testable_str, testable_msg)
68 |
69 | bn_layers = [l.name for l in testable_msg.layer if l.type == "BN"]
70 | bn_blobs = [l.top[0] for l in testable_msg.layer if l.type == "BN"]
71 | bn_means = [l.top[1] for l in testable_msg.layer if l.type == "BN"]
72 | bn_vars = [l.top[2] for l in testable_msg.layer if l.type == "BN"]
73 |
74 | net = caffe.Net(testable_net_path, train_weights_path, caffe.TEST)
75 |
76 | # init our blob stores with the first forward pass
77 | res = net.forward()
78 | bn_avg_mean = {bn_mean: np.squeeze(res[bn_mean]).copy() for bn_mean in bn_means}
79 | bn_avg_var = {bn_var: np.squeeze(res[bn_var]).copy() for bn_var in bn_vars}
80 |
81 | # iterate over the rest of the training set
82 | for i in xrange(1, num_iterations):
83 | res = net.forward()
84 | for bn_mean in bn_means:
85 | bn_avg_mean[bn_mean] += np.squeeze(res[bn_mean])
86 | for bn_var in bn_vars:
87 | bn_avg_var[bn_var] += np.squeeze(res[bn_var])
88 | print 'progress: {}/{}'.format(i, num_iterations)
89 |
90 | # compute average means and vars
91 | for bn_mean in bn_means:
92 | bn_avg_mean[bn_mean] /= num_iterations
93 | for bn_var in bn_vars:
94 | bn_avg_var[bn_var] /= num_iterations
95 |
96 | for bn_blob, bn_var in zip(bn_blobs, bn_vars):
97 | m = np.prod(net.blobs[bn_blob].data.shape) / np.prod(bn_avg_var[bn_var].shape)
98 | bn_avg_var[bn_var] *= (m / (m - 1))
99 |
100 | # calculate the new scale and shift blobs for all the BN layers
101 | scale_data = {bn_layer: np.squeeze(net.params[bn_layer][0].data)
102 | for bn_layer in bn_layers}
103 | shift_data = {bn_layer: np.squeeze(net.params[bn_layer][1].data)
104 | for bn_layer in bn_layers}
105 |
106 | var_eps = 1e-9
107 | new_scale_data = {}
108 | new_shift_data = {}
109 | for bn_layer, bn_mean, bn_var in zip(bn_layers, bn_means, bn_vars):
110 | gamma = scale_data[bn_layer]
111 | beta = shift_data[bn_layer]
112 | Ex = bn_avg_mean[bn_mean]
113 | Varx = bn_avg_var[bn_var]
114 | new_gamma = gamma / np.sqrt(Varx + var_eps)
115 | new_beta = beta - (gamma * Ex / np.sqrt(Varx + var_eps))
116 |
117 | new_scale_data[bn_layer] = new_gamma
118 | new_shift_data[bn_layer] = new_beta
119 | print "New data:"
120 | print new_scale_data.keys()
121 | print new_shift_data.keys()
122 |
123 | # assign computed new scale and shift values to net.params
124 | for bn_layer in bn_layers:
125 | net.params[bn_layer][0].data[...] = new_scale_data[bn_layer].reshape(
126 | net.params[bn_layer][0].data.shape
127 | )
128 | net.params[bn_layer][1].data[...] = new_shift_data[bn_layer].reshape(
129 | net.params[bn_layer][1].data.shape
130 | )
131 |
132 | # build a test net prototxt
133 | test_msg = testable_msg
134 | # replace data layers with 'input' net param
135 | data_layers = [l for l in test_msg.layer if l.type.endswith("Data")]
136 | for data_layer in data_layers:
137 | test_msg.layer.remove(data_layer)
138 | test_msg.input.append("data")
139 | test_msg.input_dim.append(1)
140 | test_msg.input_dim.append(3)
141 | test_msg.input_dim.append(in_h)
142 | test_msg.input_dim.append(in_w)
143 | # Set BN layers to INFERENCE so they use the new stat blobs
144 | # and remove mean, var top blobs.
145 | for l in test_msg.layer:
146 | if l.type == "BN":
147 | if len(l.top) > 1:
148 | dead_tops = l.top[1:]
149 | for dl in dead_tops:
150 | l.top.remove(dl)
151 | l.bn_param.bn_mode = caffe_pb2.BNParameter.INFERENCE
152 | # replace output loss, accuracy layers with a softmax
153 | dead_outputs = [l for l in test_msg.layer if l.type in ["SoftmaxWithLoss", "Accuracy"]]
154 | out_bottom = dead_outputs[0].bottom[0]
155 | for dead in dead_outputs:
156 | test_msg.layer.remove(dead)
157 | test_msg.layer.add(
158 | name="prob", type="Softmax", bottom=[out_bottom], top=['prob']
159 | )
160 | return net, test_msg
161 |
162 |
163 | def make_parser():
164 | p = ArgumentParser()
165 | p.add_argument('train_model')
166 | p.add_argument('weights')
167 | p.add_argument('out_dir')
168 | p.add_argument('--gpu', type=int, default=None)
169 | return p
170 |
171 |
172 | if __name__ == '__main__':
173 | caffe.set_mode_gpu()
174 | p = make_parser()
175 | args = p.parse_args()
176 |
177 | if args.gpu is not None:
178 | caffe.set_device(args.gpu)
179 |
180 | # build and save testable net
181 | if not os.path.exists(args.out_dir):
182 | os.makedirs(args.out_dir)
183 | print "Building BN calc net..."
184 | testable_msg = make_testable(args.train_model)
185 | BN_calc_path = os.path.join(
186 | args.out_dir, '__for_calculating_BN_stats_' + os.path.basename(args.train_model)
187 | )
188 | with open(BN_calc_path, 'w') as f:
189 | f.write(text_format.MessageToString(testable_msg))
190 |
191 | # use testable net to calculate BN layer stats
192 | print "Calculate BN stats..."
193 | train_ims, train_labs = extract_dataset(testable_msg)
194 | train_size = len(train_ims)
195 | minibatch_size = testable_msg.layer[0].dense_image_data_param.batch_size
196 | num_iterations = train_size // minibatch_size + train_size % minibatch_size
197 | in_h, in_w =(360, 480)
198 | test_net, test_msg = make_test_files(BN_calc_path, args.weights, num_iterations,
199 | in_h, in_w)
200 |
201 | # save deploy prototxt
202 | #print "Saving deployment prototext file..."
203 | #test_path = os.path.join(args.out_dir, "deploy.prototxt")
204 | #with open(test_path, 'w') as f:
205 | # f.write(text_format.MessageToString(test_msg))
206 |
207 | print "Saving test net weights..."
208 | test_net.save(os.path.join(args.out_dir, "test_weights.caffemodel"))
209 | print "done"
210 |
211 |
--------------------------------------------------------------------------------
/segnet/demo.js:
--------------------------------------------------------------------------------
1 | const qs = require('querystring')
2 | const http = require('choo/http')
3 | const tilebelt = require('tilebelt')
4 | const createMap = require('../results-viewer/map')
5 | const getSatelliteTileURL = require('../results-viewer/get-tile-url')
6 |
7 | const query = qs.parse(window.location.search.substring(1))
8 |
9 | const predictions = window.location.href.replace(/static.*$/, 'index.json')
10 |
11 | let map = createMap(query).on('load', function () {
12 | map.addSource('prediction', {
13 | type: 'raster',
14 | tileSize: 256,
15 | url: predictions
16 | })
17 | map.addLayer({
18 | id: 'prediction',
19 | type: 'raster',
20 | source: 'prediction',
21 | paint: {
22 | 'raster-opacity': 0.5
23 | }
24 | })
25 | })
26 |
27 |
--------------------------------------------------------------------------------
/segnet/extract-log-data.sh:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | # Dump data parsed from caffe logs to stdout
4 |
5 | set -eu
6 |
7 | SKYNET_TRAIN=${SKYNET_TRAIN:-"."}
8 |
9 | MODEL=$1
10 | NAME=${2:-$(basename $MODEL)}
11 | TO_CSV="sed -re s/[[:blank:]]+/,/g"
12 | PREPEND_NAME="sed s/^/$NAME,/"
13 |
14 |
15 | FIRST=true
16 | for log in $MODEL/train_*.log; do
17 | $SKYNET_TRAIN/util/parse_log.sh $log
18 | data="$(basename $log).train"
19 |
20 | # header
21 | if $FIRST; then head -n 1 $data | $TO_CSV | sed s/^/Model,/; fi
22 | # data
23 | tail -n +2 $data | $TO_CSV | $PREPEND_NAME
24 |
25 | rm $data
26 | rm "$(basename $log).test"
27 | FIRST=false
28 | done
29 |
30 |
--------------------------------------------------------------------------------
/segnet/get-model-metadata:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env bash
2 |
3 | # Download from S3 all of the non-huge data from model training:
4 | # - caffe prototxt files
5 | # - training logs
6 | # - test output (metrics only, not the images)
7 |
8 | # Usage: get-model-metadata bucketname/prefix path/to/local/dir [model_name]
9 |
10 | set -eu
11 |
12 | INPUT=$1
13 | OUTPUT=$2
14 | # optionally accept a specific model as third arg
15 | if [[ $# -gt 2 ]]; then
16 | INPUT="$INPUT/$3"
17 | OUTPUT="$OUTPUT/$3"
18 | fi
19 |
20 | aws s3 cp --recursive s3://$INPUT/ $OUTPUT \
21 | --exclude '*.caffemodel' \
22 | --exclude '*.solverstate' \
23 | --exclude '*.png' --include 'train-loss-vs-iters.png' \
24 | --exclude '*.inference/*'
25 |
26 |
--------------------------------------------------------------------------------
/segnet/inference.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 | import scipy
3 | import time
4 |
5 |
6 | def predict(net, label_colors, threshold, image=None):
7 | num_classes = len(label_colors)
8 |
9 | if image is not None:
10 | image = image.transpose((2, 0, 1))
11 | net.blobs['data'].data[0] = image
12 |
13 | start = time.time()
14 | net.forward()
15 | print('Prediction time', time.time() - start)
16 |
17 | predicted = net.blobs['prob'].data
18 | output = np.squeeze(predicted[0, :, :, :])
19 |
20 | # only use the max-probability non-background class if its probability is
21 | # above some threshold
22 | ind = np.argmax(output, axis=0)
23 | fg = output[:-1, :, :] # foreground classes only
24 | bg = np.full(ind.shape, num_classes - 1)
25 | ind = np.where(np.max(fg, axis=0) > threshold, ind, bg)
26 |
27 | max_prob = np.max(output, axis=0)
28 | return labels_to_image(ind, label_colors, max_prob)
29 |
30 |
31 | def labels_to_image(labels, label_colors, alpha=None):
32 | num_classes = len(label_colors)
33 | # construct output image
34 | r = labels.copy()
35 | g = labels.copy()
36 | b = labels.copy()
37 | a = np.zeros(labels.shape)
38 | label_colors = np.array(label_colors)
39 | for l in range(0, num_classes):
40 | r[labels == l] = label_colors[l, 0]
41 | g[labels == l] = label_colors[l, 1]
42 | b[labels == l] = label_colors[l, 2]
43 |
44 | if (alpha is not None):
45 | a[labels != num_classes - 1] = alpha[labels != num_classes - 1] * 255
46 | else:
47 | a[:] = 255
48 |
49 | rgb = np.zeros((labels.shape[0], labels.shape[1], 4))
50 | rgb[:, :, 0] = r
51 | rgb[:, :, 1] = g
52 | rgb[:, :, 2] = b
53 | rgb[:, :, 3] = a
54 |
55 | return scipy.misc.toimage(rgb, cmin=0.0, cmax=255, mode='RGBA')
56 |
--------------------------------------------------------------------------------
/segnet/local_inference.py:
--------------------------------------------------------------------------------
1 | # https://github.com/BVLC/caffe/issues/861
2 | import matplotlib
3 | matplotlib.use('Agg')
4 |
5 | import json
6 | import os
7 | from os import path as op
8 | import sys
9 | import subprocess
10 |
11 | caffe_root = os.getenv('CAFFE_ROOT', '/home/ubuntu/caffe-segnet/')
12 | sys.path.insert(0, caffe_root + 'python')
13 | import caffe
14 | import click
15 | import numpy as np
16 | import rasterio
17 | from mercantile import bounds
18 | from pyproj import Proj, transform
19 | from PIL import Image
20 |
21 | from inference import predict
22 | from vectorize import vectorize
23 |
24 | dirname = op.dirname(op.realpath(__file__))
25 | polys_to_lines = op.join(dirname, '../vectorize.js')
26 |
27 | class TileNotFoundError(Exception):
28 | def __init__(self, msg):
29 | Exception.__init__(self, msg)
30 |
31 |
32 | def setup_net(model_file, weights_file, gpu, cpu_only):
33 | if not op.isfile(weights_file) and op.isdir('/model'):
34 | caffemodels = filter(lambda x: x.endswith('.caffemodel'), os.listdir('/model'))
35 | if len(caffemodels) == 0:
36 | raise Exception('No .caffemodel files found in /model.')
37 | weights_file = '/model/%s' % caffemodels[0]
38 |
39 | # read model definition
40 | model = open(model_file, 'r').read()
41 | # create net
42 | if cpu_only:
43 | caffe.set_mode_cpu()
44 | else:
45 | caffe.set_mode_gpu()
46 | caffe.set_device(gpu)
47 |
48 | return caffe.Net(model_file.encode('utf8'),
49 | weights_file.encode('utf8'),
50 | caffe.TEST)
51 |
52 |
53 | def make_prediction(net, colors, im, threshold, outfile):
54 | bands = len(im.getbands())
55 | imdata = np.array(im.getdata()).reshape(im.size[0], im.size[1], bands)
56 | predicted = predict(net, colors, threshold, imdata)
57 | predicted.save(outfile, 'PNG')
58 |
59 |
60 | def get_image_tile(raster, x, y, z):
61 | try:
62 | bound = bounds(x, y, z)
63 |
64 | with rasterio.open(raster) as src:
65 | x_res, y_res = src.transform[0], src.transform[4]
66 | p1 = Proj({'init': 'epsg:4326'})
67 | p2 = Proj(**src.crs)
68 |
69 | # project tile boundaries from lat/lng to source CRS
70 | tile_ul_proj = transform(p1, p2, bound.west, bound.north)
71 | tile_lr_proj = transform(p1, p2, bound.east, bound.south)
72 | # get origin point from the TIF
73 | tif_ul_proj = (src.bounds.left, src.bounds.top)
74 |
75 | # use the above information to calculate the pixel indices of the window
76 | top = int((tile_ul_proj[1] - tif_ul_proj[1]) / y_res)
77 | left = int((tile_ul_proj[0] - tif_ul_proj[0]) / x_res)
78 | bottom = int((tile_lr_proj[1] - tif_ul_proj[1]) / y_res)
79 | right = int((tile_lr_proj[0] - tif_ul_proj[0]) / x_res)
80 |
81 | window = ((top, bottom), (left, right))
82 |
83 | # read the first three bands (assumed RGB) of the TIF into an array
84 | data = np.empty(shape=(3, 256, 256)).astype(src.profile['dtype'])
85 | for k in (1, 2, 3):
86 | src.read(k, window=window, out=data[k - 1], boundless=True)
87 |
88 | return Image.fromarray(np.moveaxis(data, 0, -1), mode='RGB')
89 | except Exception as err:
90 | raise TileNotFoundError(err)
91 |
92 |
93 | @click.command()
94 | @click.argument('raster')
95 | @click.argument('tiles')
96 | @click.option('--model', type=str, default='/model/segnet_deploy.prototxt')
97 | @click.option('--weights', type=str, default='/model/weights.caffemodel')
98 | @click.option('--classes', type=str, default='/model/classes.json')
99 | @click.option('--output', type=str, default='/inference')
100 | @click.option('--gpu', type=int, default=0)
101 | @click.option('--cpu-only', is_flag=True, default=False)
102 | @click.option('--threshold', type=float, default=0.5)
103 | def run_batch(raster, tiles, model, weights, classes, output, gpu, cpu_only):
104 | net = setup_net(model, weights, gpu, cpu_only)
105 |
106 | # read classes metadata
107 | with open(classes) as c:
108 | colors = map(lambda x: x['color'][1:], json.load(c))
109 | colors.append('000000')
110 | colors = map(lambda rgbstr: tuple(map(ord, rgbstr.decode('hex'))), colors)
111 |
112 | centerlines_file = op.join(output, 'complete.geojson')
113 | centerlines = open(centerlines_file, 'w')
114 |
115 | with open(tiles) as tile_list:
116 | for tile in tile_list:
117 | try:
118 | click.echo('processing: %s' % tile.strip())
119 | x, y, z = [int(t) for t in tile.strip().split('-')]
120 | image = get_image_tile(raster, x, y, z)
121 | image.save(op.join(output, '%s_real.png' % tile.strip()))
122 |
123 | # run prediction
124 | predicted_file = op.join(output, '%s.png' % tile.strip())
125 | make_prediction(net, colors, image, threshold, predicted_file)
126 |
127 | # trace raster -> polygons
128 | polygonized_file = op.join(output, '%s.geojson' % tile.strip())
129 | with open(polygonized_file, 'w') as p:
130 | p.write(json.dumps(vectorize(predicted_file)))
131 |
132 | # polygons => centerlines
133 | polyspine_args = map(str, [polys_to_lines, polygonized_file, x, y, z, 0.2])
134 | exitcode = subprocess.call(polyspine_args, stdout=centerlines)
135 |
136 | if exitcode != 0:
137 | raise Exception('Vectorize exited nonzero')
138 |
139 | except TileNotFoundError:
140 | click.echo('Imagery tile not found.')
141 | except Exception as err:
142 | click.echo(err)
143 |
144 | centerlines.close()
145 |
146 |
147 | if __name__ == '__main__':
148 | run_batch()
149 |
--------------------------------------------------------------------------------
/segnet/metrics.py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 |
3 |
4 | # + + + + + + + + + + + + + + + + +
5 | # + + + + + + + + + + + + + + + + +
6 | # + + + + + + + + + + + + + + + + +
7 | # + + + @ + + + + + + + + + + + + +
8 | # + + + + + + + + + + + + + + + + +
9 | # + + + + + + + + + + + + + + + + +
10 | # + + + + + + + + + + + + + + + + +
11 | def complete_and_correct(output, label, r, threshold):
12 | num_classes = output.shape[0]
13 | bg = num_classes - 1
14 | predicted_pixels = np.zeros((num_classes,))
15 | actual_pixels = np.zeros((num_classes,))
16 |
17 | # only use the max-probability non-background class if its probability is
18 | # above the threshold
19 | ind = np.argmax(output, axis=0)
20 | fg = output[:-1, :, :] # foreground classes only
21 | prediction = np.where(np.max(fg, axis=0) > threshold, ind, num_classes - 1)
22 |
23 | # for each class, the number of pixels where that class is predicted and
24 | # the groundtruth includes a pixel with that class within r pixels.
25 | # (i.e., number of true positives)
26 | correct = np.zeros((num_classes - 1,))
27 |
28 | # for each class, the number of pixels where that class is the true value
29 | # and the predicted output includes a pixel with that class within r pixels
30 | # (i.e., actual_pixels - number of false negatives)
31 | complete = np.zeros((num_classes - 1,))
32 |
33 | # todo -- deal with image boundaries
34 | for x in range(r + 1, label.shape[0] - r - 1):
35 | for y in range(r + 1, label.shape[1] - r - 1):
36 | # assess completeness contribution of this pixel
37 | a_class = label[x, y]
38 | p_win = prediction[x - r: x + r, y - r: y + r]
39 | actual_pixels[a_class] += 1
40 | if a_class != bg and (p_win == a_class).any():
41 | complete[a_class] += 1
42 | # assess correctness contribution of this pixel
43 | p_class = prediction[x, y]
44 | a_win = label[x - r: x + r, y - r: y + r]
45 | predicted_pixels[p_class] += 1
46 | if p_class != bg and (a_win == p_class).any():
47 | correct[p_class] += 1
48 |
49 | return {
50 | 'pixels_correct': correct.tolist(),
51 | 'pixels_predicted': predicted_pixels.tolist(),
52 | 'pixels_actual': actual_pixels.tolist(),
53 | 'pixels_complete': complete.tolist(),
54 | 'completeness_score': np.sum(complete) / np.sum(actual_pixels[:-1]),
55 | 'correctness_score': np.sum(correct) / np.sum(predicted_pixels[:-1])
56 | }
57 |
--------------------------------------------------------------------------------
/segnet/queue.py:
--------------------------------------------------------------------------------
1 | import json
2 | import click
3 | from boto3.session import Session
4 | session = Session()
5 |
6 | sqs = session.resource('sqs')
7 | s3 = session.client('s3')
8 |
9 |
10 | def send(queue, messages, dryrun):
11 | messages = [{'Id': str(i), 'MessageBody': m} for i, m in enumerate(messages)]
12 | if dryrun:
13 | print('DRYRUN %s' % json.dumps({'Entries': messages}))
14 | return
15 | q = sqs.get_queue_by_name(QueueName=queue)
16 | resp = q.send_messages(Entries=messages)
17 | assert len(resp.get('Failed', [])) == 0, str(resp)
18 |
19 |
20 | def receive(queue):
21 | q = sqs.get_queue_by_name(QueueName=queue)
22 | while True:
23 | for message in q.receive_messages(MaxNumberOfMessages=10, VisibilityTimeout=60):
24 | yield message
25 |
26 |
27 | @click.command()
28 | @click.argument('queue_name')
29 | @click.argument('output_bucket')
30 | @click.argument('tileset')
31 | @click.argument('image_tiles')
32 | @click.argument('input', default='-')
33 | @click.option('--tile-url', type=str)
34 | @click.option('--dryrun', is_flag=True, default=False)
35 | def populate(queue_name, output_bucket, tileset, image_tiles, input, tile_url, dryrun):
36 | """
37 | Populate the given SQS queue with tasks of the form [bucket, tileset, image_tiles, z, x, y],
38 | to be consumed by batch_process.py.
39 |
40 | Works well with cover.js. E.g.:
41 |
42 | ./cover.js file.geojson 15 16 | python segnet/queue.py my_queue my_bucket my_tileset "http://api.mapbox.com/v4/mapbox.satellite/{z}/{x}/{y}.png?access_token={MAPBOX_ACCESS_TOKEN}"
43 | """
44 |
45 | try:
46 | input = click.open_file(input).readlines()
47 | except IOError:
48 | input = [input]
49 | batch = []
50 | count = 0
51 | for tile in input:
52 | tile = (x, y, z) = json.loads(tile.strip())
53 | count += 1
54 | batch.append(json.dumps((output_bucket, tileset, image_tiles, z, x, y)))
55 | if (len(batch) == 10):
56 | send(queue_name, batch, dryrun)
57 | batch = []
58 |
59 | if len(batch) > 0:
60 | send(queue_name, batch, dryrun)
61 |
62 | if not tile_url:
63 | tile_url = 'https://%s.s3.amazonaws.com/%s/{z}/{x}/{y}.png' % (output_bucket, tileset)
64 | tilejson = json.dumps({
65 | 'tilejson': '2.0.0',
66 | 'tiles': [tile_url]
67 | })
68 | key = '%s/index.json' % tileset
69 | click.echo('%s tiles queued. Pushing TileJSON to %s/%s' % (count, output_bucket, tileset))
70 | click.echo(tilejson)
71 | if not dryrun:
72 | s3.put_object(Body=tilejson, Bucket=output_bucket, Key=key, ContentType='application/json')
73 |
74 |
75 | if __name__ == '__main__':
76 | populate()
77 |
--------------------------------------------------------------------------------
/segnet/run-test:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 |
3 | /*
4 | * Convenience script for testing net from a particular snapshot during
5 | * training.
6 | *
7 | * 1. Compute the 'batch normalization' statistics from the training data, and
8 | * create a new copy of the trained weights with this normalization applied to
9 | * them. (See compute_bn_statistics.py for details.)
10 | * If the given weights were `snapshots/segnet_iter_X.caffemodel`, the
11 | * normalized weights will be at `snapshots/segnet_iter_X.inference/test_weights.caffemodel`
12 | *
13 | * 2. Run forward inference on the test data, outputting prediction images and
14 | * completeness/correctness metrics into `snapshots/segnet_iter_X.results/`.
15 | * (See test_segmentation.py for details.)
16 | */
17 |
18 | var fs = require('fs-extra')
19 | var path = require('path')
20 | var spawnSync = require('child_process').spawnSync
21 | var argv = require('minimist')(process.argv.slice(2), {
22 | alias: {
23 | output: 'o',
24 | train: 't',
25 | weights: 'w',
26 | classes: 'c'
27 | }
28 | })
29 |
30 | var computeStats = path.join(__dirname, 'compute_bn_statistics.py')
31 | var runTest = path.join(__dirname, 'test_segmentation.py')
32 |
33 | if (!argv.train || !argv.weights || !argv.classes) {
34 | console.error('Usage: ' + process.argv.slice(0, 2).join(' ') + ' --train train.prototxt --weights weights.caffemodel --classes class-defs.json --output /path/to/results/output')
35 | console.log(argv)
36 | process.exit(1)
37 | }
38 |
39 | var train = path.resolve(argv.train)
40 | var weights = path.resolve(argv.weights)
41 | var classes = path.resolve(argv.classes)
42 | if (argv.output) {
43 | argv.output = weights.replace('.caffemodel', '.results')
44 | }
45 | var output = path.resolve(argv.output)
46 | if (!fs.existsSync(output)) {
47 | fs.mkdirSync(output)
48 | }
49 |
50 | // guess the inference.prototxt filename
51 | var inference = argv.inference || train.replace('_train.prototxt', '_inference.prototxt')
52 |
53 | // dir for outputting the BN-stats-infused weights
54 | var inferenceDir = weights.replace('.caffemodel', '.inference')
55 | fs.mkdirSync(inferenceDir)
56 |
57 | console.log('Computing batch normalization stats.')
58 | spawnSync('python', [
59 | computeStats,
60 | train,
61 | weights,
62 | inferenceDir
63 | ].concat(argv.gpu ? ['--gpu', argv.gpu] : []), { stdio: 'inherit' })
64 |
65 | console.log('Running inference.')
66 | spawnSync('python', [
67 | runTest,
68 | '--model', inference,
69 | '--weights', path.join(inferenceDir, 'test_weights.caffemodel'),
70 | '--classes', classes,
71 | '--output', output
72 | ].concat(argv.gpu ? ['--gpu', argv.gpu] : []), { stdio: 'inherit' })
73 |
74 | fs.copySync(path.join(__dirname, '../results-viewer/dist'), output)
75 |
76 | console.log('Done!')
77 |
78 |
--------------------------------------------------------------------------------
/segnet/setup-model:
--------------------------------------------------------------------------------
1 | #!/usr/bin/env node
2 | var fs = require('fs')
3 | var path = require('path')
4 |
5 | // Set up the caffe model prototxt files for a given training data set
6 | module.exports = setupModel
7 | function setupModel (model, batchSize, trainingData, testData, crop, stats, output) {
8 | var cw = classWeights(stats).map(function (weight) {
9 | return 'class_weighting: ' + weight
10 | })
11 |
12 | batchSize = isNaN(batchSize) ? (model === 'segnet' ? 6 : 16) : batchSize
13 |
14 | renderModel('train', model, cw, output)
15 | renderModel('inference', model, cw, output)
16 | renderModel('deploy', model, cw, output)
17 |
18 | // phase: 'train' or 'inference'
19 | // model: 'segnet' or 'segnet_basic'
20 | function renderModel (phase, model, classWeights, outputDir) {
21 | var template = model + '_' + (phase === 'train' ? 'train' : 'inference') + '.prototxt'
22 | template = path.join(__dirname, 'templates', template)
23 | var batch = phase === 'train' ? batchSize : 1
24 | var inputLayer = phase === 'deploy' ? `input: "data"
25 | input_shape: {
26 | dim: 1
27 | dim: 3
28 | dim: 256
29 | dim: 256
30 | }` : `layer {
31 | name: "data"
32 | type: "DenseImageData"
33 | top: "data"
34 | top: "label"
35 | dense_image_data_param {
36 | source: "${phase === 'train' ? trainingData : testData}"
37 | batch_size: ${batch}
38 | shuffle: ${phase === 'train' ? 'true' : 'false'}
39 | ${crop ? 'crop_height: ' + crop : ''}
40 | ${crop ? 'crop_width: ' + crop : ''}
41 | }
42 | }`
43 |
44 | var tmpl = fs.readFileSync(template, 'utf-8')
45 | .replace(/INPUT/g, inputLayer)
46 | .replace(/CLASS_COUNT/g, classWeights.length)
47 | .replace(/(\s+)CLASS_WEIGHTING/g, (_, space) => {
48 | return classWeights.map(w => space + w).join('')
49 | })
50 |
51 | var file = path.join(outputDir, model + '_' + phase + '.prototxt')
52 | fs.writeFileSync(file, tmpl)
53 | }
54 |
55 | // compute class weighting according to SegNet paper: http://arxiv.org/abs/1511.00561
56 | function classWeights (stats) {
57 | var data = fs.readFileSync(stats, 'utf-8').split('\n')
58 | .slice(1)
59 | .filter(Boolean)
60 | .map(x => x.split(',').map(Number))
61 | var frequencies = data.map(x => x[1] / (x[2] * 65536))
62 | var sorted = [].concat(frequencies).sort((a, b) => (a - b))
63 | var n = sorted.length
64 | var median = n % 2 === 0 ? (sorted[n / 2] + sorted[n / 2 - 1]) / 2 : sorted[n / 2 - 0.5]
65 | return frequencies.map(x => (median / x))
66 | }
67 | }
68 |
69 | if (require.main === module) {
70 | var args = require('minimist')(process.argv.slice(2), {
71 | alias: {
72 | d: 'data',
73 | o: 'output',
74 | m: 'model',
75 | b: 'batch-size'
76 | }
77 | })
78 | var trainingData = args['train'] || (args['data'] + '/' + 'train.txt')
79 | var testData = args['test'] || (args['data'] + '/' + 'val.txt')
80 | var stats = args['label-stats'] || (args['data'] + '/labels/label-stats.csv')
81 | var model = args['model']
82 | var output = args['output']
83 | var crop = args['crop']
84 | if (!(output && model && stats && trainingData && testData)) {
85 | console.log('Usage: setup-model --model segnet|segnet_basic --train /path/to/train.txt --test /path/to/train.txt --label-stats /path/to/labelstats.csv --output /path/to/output/dir')
86 | console.log('label-stats refers to a the label stats csv generated by skynet-data scripts')
87 | process.exit(1)
88 | }
89 | setupModel(model, args.b, trainingData, testData, crop, stats, output)
90 | }
91 |
--------------------------------------------------------------------------------
/segnet/static/index.html:
--------------------------------------------------------------------------------
1 |
2 |
3 |
4 |
5 |
6 |
10 |
11 |
12 |
13 |
14 |
15 |
16 |
--------------------------------------------------------------------------------
/segnet/templates/bayesian_segnet_basic_inference.prototxt:
--------------------------------------------------------------------------------
1 | name: "segnet"
2 | INPUT
3 | layer {
4 | name: "norm"
5 | type: "LRN"
6 | bottom: "data"
7 | top: "norm"
8 | lrn_param {
9 | local_size: 5
10 | alpha: 0.0001
11 | beta: 0.75
12 | }
13 | }
14 | layer {
15 | name: "conv1"
16 | type: "Convolution"
17 | bottom: "norm"
18 | top: "conv1"
19 | param {
20 | lr_mult: 1
21 | decay_mult: 1
22 | }
23 | param {
24 | lr_mult: 2
25 | decay_mult: 0
26 | }
27 | convolution_param {
28 | num_output: 64
29 | kernel_size: 7
30 | pad: 3
31 | weight_filler {
32 | type: "msra"
33 | }
34 | bias_filler {
35 | type: "constant"
36 | }
37 | }
38 | }
39 | layer {
40 | bottom: "conv1"
41 | top: "conv1"
42 | name: "conv1_bn"
43 | type: "BN"
44 | bn_param {
45 | bn_mode: INFERENCE
46 | scale_filler {
47 | type: "constant"
48 | value: 1
49 | }
50 | shift_filler {
51 | type: "constant"
52 | value: 0.001
53 | }
54 | }
55 | }
56 | layer {
57 | name: "relu1"
58 | type: "ReLU"
59 | bottom: "conv1"
60 | top: "conv1"
61 | }
62 | layer {
63 | name: "pool1"
64 | type: "Pooling"
65 | bottom: "conv1"
66 | top: "pool1"
67 | top: "pool1_mask"
68 | pooling_param {
69 | pool: MAX
70 | kernel_size: 2
71 | stride: 2
72 | }
73 | }
74 | layer {
75 | name: "conv2"
76 | type: "Convolution"
77 | bottom: "pool1"
78 | top: "conv2"
79 | param {
80 | lr_mult: 1
81 | decay_mult: 1
82 | }
83 | param {
84 | lr_mult: 2
85 | decay_mult: 0
86 | }
87 | convolution_param {
88 | num_output: 64
89 | kernel_size: 7
90 | pad: 3
91 | weight_filler {
92 | type: "msra"
93 | }
94 | bias_filler {
95 | type: "constant"
96 | }
97 | }
98 | }
99 | layer {
100 | bottom: "conv2"
101 | top: "conv2"
102 | name: "conv2_bn"
103 | type: "BN"
104 | bn_param {
105 | bn_mode: INFERENCE
106 | scale_filler {
107 | type: "constant"
108 | value: 1
109 | }
110 | shift_filler {
111 | type: "constant"
112 | value: 0.001
113 | }
114 | }
115 | }
116 | layer {
117 | name: "relu2"
118 | type: "ReLU"
119 | bottom: "conv2"
120 | top: "conv2"
121 | }
122 | layer {
123 | name: "pool2"
124 | type: "Pooling"
125 | bottom: "conv2"
126 | top: "pool2"
127 | top: "pool2_mask"
128 | pooling_param {
129 | pool: MAX
130 | kernel_size: 2
131 | stride: 2
132 | }
133 | }
134 | layer {
135 | name: "conv3"
136 | type: "Convolution"
137 | bottom: "pool2"
138 | top: "conv3"
139 | param {
140 | lr_mult: 1
141 | decay_mult: 1
142 | }
143 | param {
144 | lr_mult: 2
145 | decay_mult: 0
146 | }
147 | convolution_param {
148 | num_output: 64
149 | kernel_size: 7
150 | pad: 3
151 | weight_filler {
152 | type: "msra"
153 | }
154 | bias_filler {
155 | type: "constant"
156 | }
157 | }
158 | }
159 | layer {
160 | bottom: "conv3"
161 | top: "conv3"
162 | name: "conv3_bn"
163 | type: "BN"
164 | bn_param {
165 | bn_mode: INFERENCE
166 | scale_filler {
167 | type: "constant"
168 | value: 1
169 | }
170 | shift_filler {
171 | type: "constant"
172 | value: 0.001
173 | }
174 | }
175 | }
176 | layer {
177 | name: "relu3"
178 | type: "ReLU"
179 | bottom: "conv3"
180 | top: "conv3"
181 | }
182 | layer {
183 | name: "pool3"
184 | type: "Pooling"
185 | bottom: "conv3"
186 | top: "pool3"
187 | top: "pool3_mask"
188 | pooling_param {
189 | pool: MAX
190 | kernel_size: 2
191 | stride: 2
192 | }
193 | }
194 | layer {
195 | name: "encdrop3"
196 | type: "Dropout"
197 | bottom: "pool3"
198 | top: "pool3"
199 | dropout_param {
200 | dropout_ratio: 0.5
201 | sample_weights_test: true
202 | }
203 | }
204 | layer {
205 | name: "conv4"
206 | type: "Convolution"
207 | bottom: "pool3"
208 | top: "conv4"
209 | param {
210 | lr_mult: 1
211 | decay_mult: 1
212 | }
213 | param {
214 | lr_mult: 2
215 | decay_mult: 0
216 | }
217 | convolution_param {
218 | num_output: 64
219 | kernel_size: 7
220 | pad: 3
221 | weight_filler {
222 | type: "msra"
223 | }
224 | bias_filler {
225 | type: "constant"
226 | }
227 | }
228 | }
229 | layer {
230 | bottom: "conv4"
231 | top: "conv4"
232 | name: "conv4_bn"
233 | type: "BN"
234 | bn_param {
235 | bn_mode: INFERENCE
236 | scale_filler {
237 | type: "constant"
238 | value: 1
239 | }
240 | shift_filler {
241 | type: "constant"
242 | value: 0.001
243 | }
244 | }
245 | }
246 | layer {
247 | name: "relu4"
248 | type: "ReLU"
249 | bottom: "conv4"
250 | top: "conv4"
251 | }
252 | layer {
253 | name: "pool4"
254 | type: "Pooling"
255 | bottom: "conv4"
256 | top: "pool4"
257 | top: "pool4_mask"
258 | pooling_param {
259 | pool: MAX
260 | kernel_size: 2
261 | stride: 2
262 | }
263 | }
264 | layer {
265 | name: "encdrop4"
266 | type: "Dropout"
267 | bottom: "pool4"
268 | top: "pool4"
269 | dropout_param {
270 | dropout_ratio: 0.5
271 | sample_weights_test: true
272 | }
273 | }
274 | layer {
275 | name: "upsample4"
276 | type: "Upsample"
277 | bottom: "pool4"
278 | bottom: "pool4_mask"
279 | top: "upsample4"
280 | upsample_param {
281 | scale: 2
282 | }
283 | }
284 | layer {
285 | name: "conv_decode4"
286 | type: "Convolution"
287 | bottom: "upsample4"
288 | top: "conv_decode4"
289 | param {
290 | lr_mult: 1
291 | decay_mult: 1
292 | }
293 | param {
294 | lr_mult: 2
295 | decay_mult: 0
296 | }
297 | convolution_param {
298 | num_output: 64
299 | kernel_size: 7
300 | pad: 3
301 | weight_filler {
302 | type: "msra"
303 | }
304 | bias_filler {
305 | type: "constant"
306 | }
307 | }
308 | }
309 | layer {
310 | bottom: "conv_decode4"
311 | top: "conv_decode4"
312 | name: "conv_decode4_bn"
313 | type: "BN"
314 | bn_param {
315 | bn_mode: INFERENCE
316 | scale_filler {
317 | type: "constant"
318 | value: 1
319 | }
320 | shift_filler {
321 | type: "constant"
322 | value: 0.001
323 | }
324 | }
325 | }
326 | layer {
327 | name: "decdrop4"
328 | type: "Dropout"
329 | bottom: "conv_decode4"
330 | top: "conv_decode4"
331 | dropout_param {
332 | dropout_ratio: 0.5
333 | sample_weights_test: true
334 | }
335 | }
336 | layer {
337 | name: "upsample3"
338 | type: "Upsample"
339 | bottom: "conv_decode4"
340 | bottom: "pool3_mask"
341 | top: "upsample3"
342 | upsample_param {
343 | scale: 2
344 | }
345 | }
346 | layer {
347 | name: "conv_decode3"
348 | type: "Convolution"
349 | bottom: "upsample3"
350 | top: "conv_decode3"
351 | param {
352 | lr_mult: 1
353 | decay_mult: 1
354 | }
355 | param {
356 | lr_mult: 2
357 | decay_mult: 0
358 | }
359 | convolution_param {
360 | num_output: 64
361 | kernel_size: 7
362 | pad: 3
363 | weight_filler {
364 | type: "msra"
365 | }
366 | bias_filler {
367 | type: "constant"
368 | }
369 | }
370 | }
371 | layer {
372 | bottom: "conv_decode3"
373 | top: "conv_decode3"
374 | name: "conv_decode3_bn"
375 | type: "BN"
376 | bn_param {
377 | bn_mode: INFERENCE
378 | scale_filler {
379 | type: "constant"
380 | value: 1
381 | }
382 | shift_filler {
383 | type: "constant"
384 | value: 0.001
385 | }
386 | }
387 | }
388 | layer {
389 | name: "decdrop3"
390 | type: "Dropout"
391 | bottom: "conv_decode3"
392 | top: "conv_decode3"
393 | dropout_param {
394 | dropout_ratio: 0.5
395 | sample_weights_test: true
396 | }
397 | }
398 | layer {
399 | name: "upsample2"
400 | type: "Upsample"
401 | bottom: "conv_decode3"
402 | bottom: "pool2_mask"
403 | top: "upsample2"
404 | upsample_param {
405 | scale: 2
406 | }
407 | }
408 | layer {
409 | name: "conv_decode2"
410 | type: "Convolution"
411 | bottom: "upsample2"
412 | top: "conv_decode2"
413 | param {
414 | lr_mult: 1
415 | decay_mult: 1
416 | }
417 | param {
418 | lr_mult: 2
419 | decay_mult: 0
420 | }
421 | convolution_param {
422 | num_output: 64
423 | kernel_size: 7
424 | pad: 3
425 | weight_filler {
426 | type: "msra"
427 | }
428 | bias_filler {
429 | type: "constant"
430 | }
431 | }
432 | }
433 | layer {
434 | bottom: "conv_decode2"
435 | top: "conv_decode2"
436 | name: "conv_decode2_bn"
437 | type: "BN"
438 | bn_param {
439 | bn_mode: INFERENCE
440 | scale_filler {
441 | type: "constant"
442 | value: 1
443 | }
444 | shift_filler {
445 | type: "constant"
446 | value: 0.001
447 | }
448 | }
449 | }
450 | layer {
451 | name: "upsample1"
452 | type: "Upsample"
453 | bottom: "conv_decode2"
454 | bottom: "pool1_mask"
455 | top: "upsample1"
456 | upsample_param {
457 | scale: 2
458 | }
459 | }
460 | layer {
461 | name: "conv_decode1"
462 | type: "Convolution"
463 | bottom: "upsample1"
464 | top: "conv_decode1"
465 | param {
466 | lr_mult: 1
467 | decay_mult: 1
468 | }
469 | param {
470 | lr_mult: 2
471 | decay_mult: 0
472 | }
473 | convolution_param {
474 | num_output: 64
475 | kernel_size: 7
476 | pad: 3
477 | weight_filler {
478 | type: "msra"
479 | }
480 | bias_filler {
481 | type: "constant"
482 | }
483 | }
484 | }
485 | layer {
486 | bottom: "conv_decode1"
487 | top: "conv_decode1"
488 | name: "conv_decode1_bn"
489 | type: "BN"
490 | bn_param {
491 | bn_mode: INFERENCE
492 | scale_filler {
493 | type: "constant"
494 | value: 1
495 | }
496 | shift_filler {
497 | type: "constant"
498 | value: 0.001
499 | }
500 | }
501 | }
502 | layer {
503 | name: "dense_softmax_inner_prod"
504 | type: "Convolution"
505 | bottom: "conv_decode1"
506 | top: "dense_softmax_inner_prod"
507 | param {
508 | lr_mult: 1
509 | decay_mult: 1
510 | }
511 | param {
512 | lr_mult: 2
513 | decay_mult: 0
514 | }
515 | convolution_param {
516 | num_output: CLASS_COUNT
517 | kernel_size: 1
518 | weight_filler {
519 | type: "msra"
520 | }
521 | bias_filler {
522 | type: "constant"
523 | }
524 | }
525 | }
526 | layer {
527 | name: "prob"
528 | type: "Softmax"
529 | bottom: "dense_softmax_inner_prod"
530 | top: "prob"
531 | softmax_param {engine: CAFFE}
532 | }
533 |
--------------------------------------------------------------------------------
/segnet/templates/bayesian_segnet_basic_train.prototxt:
--------------------------------------------------------------------------------
1 | name: "segnet"
2 | INPUT
3 | layer {
4 | name: "norm"
5 | type: "LRN"
6 | bottom: "data"
7 | top: "norm"
8 | lrn_param {
9 | local_size: 5
10 | alpha: 0.0001
11 | beta: 0.75
12 | }
13 | }
14 | layer {
15 | name: "conv1"
16 | type: "Convolution"
17 | bottom: "norm"
18 | top: "conv1"
19 | param {
20 | lr_mult: 1
21 | decay_mult: 1
22 | }
23 | param {
24 | lr_mult: 2
25 | decay_mult: 0
26 | }
27 | convolution_param {
28 | num_output: 64
29 | kernel_size: 7
30 | pad: 3
31 | weight_filler {
32 | type: "msra"
33 | }
34 | bias_filler {
35 | type: "constant"
36 | }
37 | }
38 | }
39 | layer {
40 | bottom: "conv1"
41 | top: "conv1"
42 | name: "conv1_bn"
43 | type: "BN"
44 | bn_param {
45 | scale_filler {
46 | type: "constant"
47 | value: 1
48 | }
49 | shift_filler {
50 | type: "constant"
51 | value: 0.001
52 | }
53 | }
54 | }
55 | layer {
56 | name: "relu1"
57 | type: "ReLU"
58 | bottom: "conv1"
59 | top: "conv1"
60 | }
61 | layer {
62 | name: "pool1"
63 | type: "Pooling"
64 | bottom: "conv1"
65 | top: "pool1"
66 | top: "pool1_mask"
67 | pooling_param {
68 | pool: MAX
69 | kernel_size: 2
70 | stride: 2
71 | }
72 | }
73 | layer {
74 | name: "conv2"
75 | type: "Convolution"
76 | bottom: "pool1"
77 | top: "conv2"
78 | param {
79 | lr_mult: 1
80 | decay_mult: 1
81 | }
82 | param {
83 | lr_mult: 2
84 | decay_mult: 0
85 | }
86 | convolution_param {
87 | num_output: 64
88 | kernel_size: 7
89 | pad: 3
90 | weight_filler {
91 | type: "msra"
92 | }
93 | bias_filler {
94 | type: "constant"
95 | }
96 | }
97 | }
98 | layer {
99 | bottom: "conv2"
100 | top: "conv2"
101 | name: "conv2_bn"
102 | type: "BN"
103 | bn_param {
104 | scale_filler {
105 | type: "constant"
106 | value: 1
107 | }
108 | shift_filler {
109 | type: "constant"
110 | value: 0.001
111 | }
112 | }
113 | }
114 | layer {
115 | name: "relu2"
116 | type: "ReLU"
117 | bottom: "conv2"
118 | top: "conv2"
119 | }
120 | layer {
121 | name: "pool2"
122 | type: "Pooling"
123 | bottom: "conv2"
124 | top: "pool2"
125 | top: "pool2_mask"
126 | pooling_param {
127 | pool: MAX
128 | kernel_size: 2
129 | stride: 2
130 | }
131 | }
132 | layer {
133 | name: "conv3"
134 | type: "Convolution"
135 | bottom: "pool2"
136 | top: "conv3"
137 | param {
138 | lr_mult: 1
139 | decay_mult: 1
140 | }
141 | param {
142 | lr_mult: 2
143 | decay_mult: 0
144 | }
145 | convolution_param {
146 | num_output: 64
147 | kernel_size: 7
148 | pad: 3
149 | weight_filler {
150 | type: "msra"
151 | }
152 | bias_filler {
153 | type: "constant"
154 | }
155 | }
156 | }
157 | layer {
158 | bottom: "conv3"
159 | top: "conv3"
160 | name: "conv3_bn"
161 | type: "BN"
162 | bn_param {
163 | scale_filler {
164 | type: "constant"
165 | value: 1
166 | }
167 | shift_filler {
168 | type: "constant"
169 | value: 0.001
170 | }
171 | }
172 | }
173 | layer {
174 | name: "relu3"
175 | type: "ReLU"
176 | bottom: "conv3"
177 | top: "conv3"
178 | }
179 | layer {
180 | name: "pool3"
181 | type: "Pooling"
182 | bottom: "conv3"
183 | top: "pool3"
184 | top: "pool3_mask"
185 | pooling_param {
186 | pool: MAX
187 | kernel_size: 2
188 | stride: 2
189 | }
190 | }
191 | layer {
192 | name: "encdrop3"
193 | type: "Dropout"
194 | bottom: "pool3"
195 | top: "pool3"
196 | dropout_param {
197 | dropout_ratio: 0.5
198 | }
199 | }
200 | layer {
201 | name: "conv4"
202 | type: "Convolution"
203 | bottom: "pool3"
204 | top: "conv4"
205 | param {
206 | lr_mult: 1
207 | decay_mult: 1
208 | }
209 | param {
210 | lr_mult: 2
211 | decay_mult: 0
212 | }
213 | convolution_param {
214 | num_output: 64
215 | kernel_size: 7
216 | pad: 3
217 | weight_filler {
218 | type: "msra"
219 | }
220 | bias_filler {
221 | type: "constant"
222 | }
223 | }
224 | }
225 | layer {
226 | bottom: "conv4"
227 | top: "conv4"
228 | name: "conv4_bn"
229 | type: "BN"
230 | bn_param {
231 | scale_filler {
232 | type: "constant"
233 | value: 1
234 | }
235 | shift_filler {
236 | type: "constant"
237 | value: 0.001
238 | }
239 | }
240 | }
241 | layer {
242 | name: "relu4"
243 | type: "ReLU"
244 | bottom: "conv4"
245 | top: "conv4"
246 | }
247 | layer {
248 | name: "pool4"
249 | type: "Pooling"
250 | bottom: "conv4"
251 | top: "pool4"
252 | top: "pool4_mask"
253 | pooling_param {
254 | pool: MAX
255 | kernel_size: 2
256 | stride: 2
257 | }
258 | }
259 | layer {
260 | name: "encdrop4"
261 | type: "Dropout"
262 | bottom: "pool4"
263 | top: "pool4"
264 | dropout_param {
265 | dropout_ratio: 0.5
266 | }
267 | }
268 | layer {
269 | name: "upsample4"
270 | type: "Upsample"
271 | bottom: "pool4"
272 | bottom: "pool4_mask"
273 | top: "upsample4"
274 | upsample_param {
275 | scale: 2
276 | }
277 | }
278 | layer {
279 | name: "conv_decode4"
280 | type: "Convolution"
281 | bottom: "upsample4"
282 | top: "conv_decode4"
283 | param {
284 | lr_mult: 1
285 | decay_mult: 1
286 | }
287 | param {
288 | lr_mult: 2
289 | decay_mult: 0
290 | }
291 | convolution_param {
292 | num_output: 64
293 | kernel_size: 7
294 | pad: 3
295 | weight_filler {
296 | type: "msra"
297 | }
298 | bias_filler {
299 | type: "constant"
300 | }
301 | }
302 | }
303 | layer {
304 | bottom: "conv_decode4"
305 | top: "conv_decode4"
306 | name: "conv_decode4_bn"
307 | type: "BN"
308 | bn_param {
309 | scale_filler {
310 | type: "constant"
311 | value: 1
312 | }
313 | shift_filler {
314 | type: "constant"
315 | value: 0.001
316 | }
317 | }
318 | }
319 | layer {
320 | name: "decdrop4"
321 | type: "Dropout"
322 | bottom: "conv_decode4"
323 | top: "conv_decode4"
324 | dropout_param {
325 | dropout_ratio: 0.5
326 | }
327 | }
328 | layer {
329 | name: "upsample3"
330 | type: "Upsample"
331 | bottom: "conv_decode4"
332 | bottom: "pool3_mask"
333 | top: "upsample3"
334 | upsample_param {
335 | scale: 2
336 | }
337 | }
338 | layer {
339 | name: "conv_decode3"
340 | type: "Convolution"
341 | bottom: "upsample3"
342 | top: "conv_decode3"
343 | param {
344 | lr_mult: 1
345 | decay_mult: 1
346 | }
347 | param {
348 | lr_mult: 2
349 | decay_mult: 0
350 | }
351 | convolution_param {
352 | num_output: 64
353 | kernel_size: 7
354 | pad: 3
355 | weight_filler {
356 | type: "msra"
357 | }
358 | bias_filler {
359 | type: "constant"
360 | }
361 | }
362 | }
363 | layer {
364 | bottom: "conv_decode3"
365 | top: "conv_decode3"
366 | name: "conv_decode3_bn"
367 | type: "BN"
368 | bn_param {
369 | scale_filler {
370 | type: "constant"
371 | value: 1
372 | }
373 | shift_filler {
374 | type: "constant"
375 | value: 0.001
376 | }
377 | }
378 | }
379 | layer {
380 | name: "decdrop3"
381 | type: "Dropout"
382 | bottom: "conv_decode3"
383 | top: "conv_decode3"
384 | dropout_param {
385 | dropout_ratio: 0.5
386 | }
387 | }
388 | layer {
389 | name: "upsample2"
390 | type: "Upsample"
391 | bottom: "conv_decode3"
392 | bottom: "pool2_mask"
393 | top: "upsample2"
394 | upsample_param {
395 | scale: 2
396 | }
397 | }
398 | layer {
399 | name: "conv_decode2"
400 | type: "Convolution"
401 | bottom: "upsample2"
402 | top: "conv_decode2"
403 | param {
404 | lr_mult: 1
405 | decay_mult: 1
406 | }
407 | param {
408 | lr_mult: 2
409 | decay_mult: 0
410 | }
411 | convolution_param {
412 | num_output: 64
413 | kernel_size: 7
414 | pad: 3
415 | weight_filler {
416 | type: "msra"
417 | }
418 | bias_filler {
419 | type: "constant"
420 | }
421 | }
422 | }
423 | layer {
424 | bottom: "conv_decode2"
425 | top: "conv_decode2"
426 | name: "conv_decode2_bn"
427 | type: "BN"
428 | bn_param {
429 | scale_filler {
430 | type: "constant"
431 | value: 1
432 | }
433 | shift_filler {
434 | type: "constant"
435 | value: 0.001
436 | }
437 | }
438 | }
439 | layer {
440 | name: "upsample1"
441 | type: "Upsample"
442 | bottom: "conv_decode2"
443 | bottom: "pool1_mask"
444 | top: "upsample1"
445 | upsample_param {
446 | scale: 2
447 | }
448 | }
449 | layer {
450 | name: "conv_decode1"
451 | type: "Convolution"
452 | bottom: "upsample1"
453 | top: "conv_decode1"
454 | param {
455 | lr_mult: 1
456 | decay_mult: 1
457 | }
458 | param {
459 | lr_mult: 2
460 | decay_mult: 0
461 | }
462 | convolution_param {
463 | num_output: 64
464 | kernel_size: 7
465 | pad: 3
466 | weight_filler {
467 | type: "msra"
468 | }
469 | bias_filler {
470 | type: "constant"
471 | }
472 | }
473 | }
474 | layer {
475 | bottom: "conv_decode1"
476 | top: "conv_decode1"
477 | name: "conv_decode1_bn"
478 | type: "BN"
479 | bn_param {
480 | scale_filler {
481 | type: "constant"
482 | value: 1
483 | }
484 | shift_filler {
485 | type: "constant"
486 | value: 0.001
487 | }
488 | }
489 | }
490 | layer {
491 | name: "dense_softmax_inner_prod"
492 | type: "Convolution"
493 | bottom: "conv_decode1"
494 | top: "dense_softmax_inner_prod"
495 | param {
496 | lr_mult: 1
497 | decay_mult: 1
498 | }
499 | param {
500 | lr_mult: 2
501 | decay_mult: 0
502 | }
503 | convolution_param {
504 | num_output: CLASS_COUNT
505 | kernel_size: 1
506 | weight_filler {
507 | type: "msra"
508 | }
509 | bias_filler {
510 | type: "constant"
511 | }
512 | }
513 | }
514 | layer {
515 | name: "loss"
516 | type: "SoftmaxWithLoss"
517 | bottom: "dense_softmax_inner_prod"
518 | bottom: "label"
519 | top: "loss"
520 | softmax_param {engine: CAFFE}
521 | loss_param: {
522 | weight_by_label_freqs: true
523 | CLASS_WEIGHTING
524 | }
525 | }
526 | layer {
527 | name: "accuracy"
528 | type: "Accuracy"
529 | bottom: "dense_softmax_inner_prod"
530 | bottom: "label"
531 | top: "accuracy"
532 | top: "per_class_accuracy"
533 | }
534 |
--------------------------------------------------------------------------------
/segnet/templates/segnet_basic_inference.prototxt:
--------------------------------------------------------------------------------
1 | name: "segnet"
2 | INPUT
3 | layer {
4 | name: "norm"
5 | type: "LRN"
6 | bottom: "data"
7 | top: "norm"
8 | lrn_param {
9 | local_size: 5
10 | alpha: 0.0001
11 | beta: 0.75
12 | }
13 | }
14 | layer {
15 | name: "conv1"
16 | type: "Convolution"
17 | bottom: "norm"
18 | top: "conv1"
19 | param {
20 | lr_mult: 1
21 | decay_mult: 1
22 | }
23 | param {
24 | lr_mult: 2
25 | decay_mult: 0
26 | }
27 | convolution_param {
28 | num_output: 64
29 | kernel_size: 7
30 | pad: 3
31 | weight_filler {
32 | type: "msra"
33 | }
34 | bias_filler {
35 | type: "constant"
36 | }
37 | }
38 | }
39 | layer {
40 | bottom: "conv1"
41 | top: "conv1"
42 | name: "conv1_bn"
43 | type: "BN"
44 | bn_param {
45 | bn_mode: INFERENCE
46 | scale_filler {
47 | type: "constant"
48 | value: 1
49 | }
50 | shift_filler {
51 | type: "constant"
52 | value: 0.001
53 | }
54 | }
55 | }
56 | layer {
57 | name: "relu1"
58 | type: "ReLU"
59 | bottom: "conv1"
60 | top: "conv1"
61 | }
62 | layer {
63 | name: "pool1"
64 | type: "Pooling"
65 | bottom: "conv1"
66 | top: "pool1"
67 | top: "pool1_mask"
68 | pooling_param {
69 | pool: MAX
70 | kernel_size: 2
71 | stride: 2
72 | }
73 | }
74 | layer {
75 | name: "conv2"
76 | type: "Convolution"
77 | bottom: "pool1"
78 | top: "conv2"
79 | param {
80 | lr_mult: 1
81 | decay_mult: 1
82 | }
83 | param {
84 | lr_mult: 2
85 | decay_mult: 0
86 | }
87 | convolution_param {
88 | num_output: 64
89 | kernel_size: 7
90 | pad: 3
91 | weight_filler {
92 | type: "msra"
93 | }
94 | bias_filler {
95 | type: "constant"
96 | }
97 | }
98 | }
99 | layer {
100 | bottom: "conv2"
101 | top: "conv2"
102 | name: "conv2_bn"
103 | type: "BN"
104 | bn_param {
105 | bn_mode: INFERENCE
106 | scale_filler {
107 | type: "constant"
108 | value: 1
109 | }
110 | shift_filler {
111 | type: "constant"
112 | value: 0.001
113 | }
114 | }
115 | }
116 | layer {
117 | name: "relu2"
118 | type: "ReLU"
119 | bottom: "conv2"
120 | top: "conv2"
121 | }
122 | layer {
123 | name: "pool2"
124 | type: "Pooling"
125 | bottom: "conv2"
126 | top: "pool2"
127 | top: "pool2_mask"
128 | pooling_param {
129 | pool: MAX
130 | kernel_size: 2
131 | stride: 2
132 | }
133 | }
134 | layer {
135 | name: "conv3"
136 | type: "Convolution"
137 | bottom: "pool2"
138 | top: "conv3"
139 | param {
140 | lr_mult: 1
141 | decay_mult: 1
142 | }
143 | param {
144 | lr_mult: 2
145 | decay_mult: 0
146 | }
147 | convolution_param {
148 | num_output: 64
149 | kernel_size: 7
150 | pad: 3
151 | weight_filler {
152 | type: "msra"
153 | }
154 | bias_filler {
155 | type: "constant"
156 | }
157 | }
158 | }
159 | layer {
160 | bottom: "conv3"
161 | top: "conv3"
162 | name: "conv3_bn"
163 | type: "BN"
164 | bn_param {
165 | bn_mode: INFERENCE
166 | scale_filler {
167 | type: "constant"
168 | value: 1
169 | }
170 | shift_filler {
171 | type: "constant"
172 | value: 0.001
173 | }
174 | }
175 | }
176 | layer {
177 | name: "relu3"
178 | type: "ReLU"
179 | bottom: "conv3"
180 | top: "conv3"
181 | }
182 | layer {
183 | name: "pool3"
184 | type: "Pooling"
185 | bottom: "conv3"
186 | top: "pool3"
187 | top: "pool3_mask"
188 | pooling_param {
189 | pool: MAX
190 | kernel_size: 2
191 | stride: 2
192 | }
193 | }
194 | layer {
195 | name: "conv4"
196 | type: "Convolution"
197 | bottom: "pool3"
198 | top: "conv4"
199 | param {
200 | lr_mult: 1
201 | decay_mult: 1
202 | }
203 | param {
204 | lr_mult: 2
205 | decay_mult: 0
206 | }
207 | convolution_param {
208 | num_output: 64
209 | kernel_size: 7
210 | pad: 3
211 | weight_filler {
212 | type: "msra"
213 | }
214 | bias_filler {
215 | type: "constant"
216 | }
217 | }
218 | }
219 | layer {
220 | bottom: "conv4"
221 | top: "conv4"
222 | name: "conv4_bn"
223 | type: "BN"
224 | bn_param {
225 | bn_mode: INFERENCE
226 | scale_filler {
227 | type: "constant"
228 | value: 1
229 | }
230 | shift_filler {
231 | type: "constant"
232 | value: 0.001
233 | }
234 | }
235 | }
236 | layer {
237 | name: "relu4"
238 | type: "ReLU"
239 | bottom: "conv4"
240 | top: "conv4"
241 | }
242 | layer {
243 | name: "pool4"
244 | type: "Pooling"
245 | bottom: "conv4"
246 | top: "pool4"
247 | top: "pool4_mask"
248 | pooling_param {
249 | pool: MAX
250 | kernel_size: 2
251 | stride: 2
252 | }
253 | }
254 | layer {
255 | name: "upsample4"
256 | type: "Upsample"
257 | bottom: "pool4"
258 | bottom: "pool4_mask"
259 | top: "upsample4"
260 | upsample_param {
261 | scale: 2
262 | }
263 | }
264 | layer {
265 | name: "conv_decode4"
266 | type: "Convolution"
267 | bottom: "upsample4"
268 | top: "conv_decode4"
269 | param {
270 | lr_mult: 1
271 | decay_mult: 1
272 | }
273 | param {
274 | lr_mult: 2
275 | decay_mult: 0
276 | }
277 | convolution_param {
278 | num_output: 64
279 | kernel_size: 7
280 | pad: 3
281 | weight_filler {
282 | type: "msra"
283 | }
284 | bias_filler {
285 | type: "constant"
286 | }
287 | }
288 | }
289 | layer {
290 | bottom: "conv_decode4"
291 | top: "conv_decode4"
292 | name: "conv_decode4_bn"
293 | type: "BN"
294 | bn_param {
295 | bn_mode: INFERENCE
296 | scale_filler {
297 | type: "constant"
298 | value: 1
299 | }
300 | shift_filler {
301 | type: "constant"
302 | value: 0.001
303 | }
304 | }
305 | }
306 | layer {
307 | name: "upsample3"
308 | type: "Upsample"
309 | bottom: "conv_decode4"
310 | bottom: "pool3_mask"
311 | top: "upsample3"
312 | upsample_param {
313 | scale: 2
314 | }
315 | }
316 | layer {
317 | name: "conv_decode3"
318 | type: "Convolution"
319 | bottom: "upsample3"
320 | top: "conv_decode3"
321 | param {
322 | lr_mult: 1
323 | decay_mult: 1
324 | }
325 | param {
326 | lr_mult: 2
327 | decay_mult: 0
328 | }
329 | convolution_param {
330 | num_output: 64
331 | kernel_size: 7
332 | pad: 3
333 | weight_filler {
334 | type: "msra"
335 | }
336 | bias_filler {
337 | type: "constant"
338 | }
339 | }
340 | }
341 | layer {
342 | bottom: "conv_decode3"
343 | top: "conv_decode3"
344 | name: "conv_decode3_bn"
345 | type: "BN"
346 | bn_param {
347 | bn_mode: INFERENCE
348 | scale_filler {
349 | type: "constant"
350 | value: 1
351 | }
352 | shift_filler {
353 | type: "constant"
354 | value: 0.001
355 | }
356 | }
357 | }
358 | layer {
359 | name: "upsample2"
360 | type: "Upsample"
361 | bottom: "conv_decode3"
362 | bottom: "pool2_mask"
363 | top: "upsample2"
364 | upsample_param {
365 | scale: 2
366 | }
367 | }
368 | layer {
369 | name: "conv_decode2"
370 | type: "Convolution"
371 | bottom: "upsample2"
372 | top: "conv_decode2"
373 | param {
374 | lr_mult: 1
375 | decay_mult: 1
376 | }
377 | param {
378 | lr_mult: 2
379 | decay_mult: 0
380 | }
381 | convolution_param {
382 | num_output: 64
383 | kernel_size: 7
384 | pad: 3
385 | weight_filler {
386 | type: "msra"
387 | }
388 | bias_filler {
389 | type: "constant"
390 | }
391 | }
392 | }
393 | layer {
394 | bottom: "conv_decode2"
395 | top: "conv_decode2"
396 | name: "conv_decode2_bn"
397 | type: "BN"
398 | bn_param {
399 | bn_mode: INFERENCE
400 | scale_filler {
401 | type: "constant"
402 | value: 1
403 | }
404 | shift_filler {
405 | type: "constant"
406 | value: 0.001
407 | }
408 | }
409 | }
410 | layer {
411 | name: "upsample1"
412 | type: "Upsample"
413 | bottom: "conv_decode2"
414 | bottom: "pool1_mask"
415 | top: "upsample1"
416 | upsample_param {
417 | scale: 2
418 | }
419 | }
420 | layer {
421 | name: "conv_decode1"
422 | type: "Convolution"
423 | bottom: "upsample1"
424 | top: "conv_decode1"
425 | param {
426 | lr_mult: 1
427 | decay_mult: 1
428 | }
429 | param {
430 | lr_mult: 2
431 | decay_mult: 0
432 | }
433 | convolution_param {
434 | num_output: 64
435 | kernel_size: 7
436 | pad: 3
437 | weight_filler {
438 | type: "msra"
439 | }
440 | bias_filler {
441 | type: "constant"
442 | }
443 | }
444 | }
445 | layer {
446 | bottom: "conv_decode1"
447 | top: "conv_decode1"
448 | name: "conv_decode1_bn"
449 | type: "BN"
450 | bn_param {
451 | bn_mode: INFERENCE
452 | scale_filler {
453 | type: "constant"
454 | value: 1
455 | }
456 | shift_filler {
457 | type: "constant"
458 | value: 0.001
459 | }
460 | }
461 | }
462 | layer {
463 | name: "conv_classifier"
464 | type: "Convolution"
465 | bottom: "conv_decode1"
466 | top: "conv_classifier"
467 | param {
468 | lr_mult: 1
469 | decay_mult: 1
470 | }
471 | param {
472 | lr_mult: 2
473 | decay_mult: 0
474 | }
475 | convolution_param {
476 | num_output: CLASS_COUNT
477 | kernel_size: 1
478 | weight_filler {
479 | type: "msra"
480 | }
481 | bias_filler {
482 | type: "constant"
483 | }
484 | }
485 | }
486 | layer {
487 | name: "prob"
488 | type: "Softmax"
489 | bottom: "conv_classifier"
490 | top: "prob"
491 | softmax_param {engine: CAFFE}
492 | }
493 |
--------------------------------------------------------------------------------
/segnet/templates/segnet_basic_train.prototxt:
--------------------------------------------------------------------------------
1 | name: "segnet"
2 | INPUT
3 | layer {
4 | name: "norm"
5 | type: "LRN"
6 | bottom: "data"
7 | top: "norm"
8 | lrn_param {
9 | local_size: 5
10 | alpha: 0.0001
11 | beta: 0.75
12 | }
13 | }
14 | layer {
15 | name: "conv1"
16 | type: "Convolution"
17 | bottom: "norm"
18 | top: "conv1"
19 | param {
20 | lr_mult: 1
21 | decay_mult: 1
22 | }
23 | param {
24 | lr_mult: 2
25 | decay_mult: 0
26 | }
27 | convolution_param {
28 | num_output: 64
29 | kernel_size: 7
30 | pad: 3
31 | weight_filler {
32 | type: "msra"
33 | }
34 | bias_filler {
35 | type: "constant"
36 | }
37 | }
38 | }
39 | layer {
40 | bottom: "conv1"
41 | top: "conv1"
42 | name: "conv1_bn"
43 | type: "BN"
44 | bn_param {
45 | scale_filler {
46 | type: "constant"
47 | value: 1
48 | }
49 | shift_filler {
50 | type: "constant"
51 | value: 0.001
52 | }
53 | }
54 | }
55 | layer {
56 | name: "relu1"
57 | type: "ReLU"
58 | bottom: "conv1"
59 | top: "conv1"
60 | }
61 | layer {
62 | name: "pool1"
63 | type: "Pooling"
64 | bottom: "conv1"
65 | top: "pool1"
66 | top: "pool1_mask"
67 | pooling_param {
68 | pool: MAX
69 | kernel_size: 2
70 | stride: 2
71 | }
72 | }
73 | layer {
74 | name: "conv2"
75 | type: "Convolution"
76 | bottom: "pool1"
77 | top: "conv2"
78 | param {
79 | lr_mult: 1
80 | decay_mult: 1
81 | }
82 | param {
83 | lr_mult: 2
84 | decay_mult: 0
85 | }
86 | convolution_param {
87 | num_output: 64
88 | kernel_size: 7
89 | pad: 3
90 | weight_filler {
91 | type: "msra"
92 | }
93 | bias_filler {
94 | type: "constant"
95 | }
96 | }
97 | }
98 | layer {
99 | bottom: "conv2"
100 | top: "conv2"
101 | name: "conv2_bn"
102 | type: "BN"
103 | bn_param {
104 | scale_filler {
105 | type: "constant"
106 | value: 1
107 | }
108 | shift_filler {
109 | type: "constant"
110 | value: 0.001
111 | }
112 | }
113 | }
114 | layer {
115 | name: "relu2"
116 | type: "ReLU"
117 | bottom: "conv2"
118 | top: "conv2"
119 | }
120 | layer {
121 | name: "pool2"
122 | type: "Pooling"
123 | bottom: "conv2"
124 | top: "pool2"
125 | top: "pool2_mask"
126 | pooling_param {
127 | pool: MAX
128 | kernel_size: 2
129 | stride: 2
130 | }
131 | }
132 | layer {
133 | name: "conv3"
134 | type: "Convolution"
135 | bottom: "pool2"
136 | top: "conv3"
137 | param {
138 | lr_mult: 1
139 | decay_mult: 1
140 | }
141 | param {
142 | lr_mult: 2
143 | decay_mult: 0
144 | }
145 | convolution_param {
146 | num_output: 64
147 | kernel_size: 7
148 | pad: 3
149 | weight_filler {
150 | type: "msra"
151 | }
152 | bias_filler {
153 | type: "constant"
154 | }
155 | }
156 | }
157 | layer {
158 | bottom: "conv3"
159 | top: "conv3"
160 | name: "conv3_bn"
161 | type: "BN"
162 | bn_param {
163 | scale_filler {
164 | type: "constant"
165 | value: 1
166 | }
167 | shift_filler {
168 | type: "constant"
169 | value: 0.001
170 | }
171 | }
172 | }
173 | layer {
174 | name: "relu3"
175 | type: "ReLU"
176 | bottom: "conv3"
177 | top: "conv3"
178 | }
179 | layer {
180 | name: "pool3"
181 | type: "Pooling"
182 | bottom: "conv3"
183 | top: "pool3"
184 | top: "pool3_mask"
185 | pooling_param {
186 | pool: MAX
187 | kernel_size: 2
188 | stride: 2
189 | }
190 | }
191 | layer {
192 | name: "conv4"
193 | type: "Convolution"
194 | bottom: "pool3"
195 | top: "conv4"
196 | param {
197 | lr_mult: 1
198 | decay_mult: 1
199 | }
200 | param {
201 | lr_mult: 2
202 | decay_mult: 0
203 | }
204 | convolution_param {
205 | num_output: 64
206 | kernel_size: 7
207 | pad: 3
208 | weight_filler {
209 | type: "msra"
210 | }
211 | bias_filler {
212 | type: "constant"
213 | }
214 | }
215 | }
216 | layer {
217 | bottom: "conv4"
218 | top: "conv4"
219 | name: "conv4_bn"
220 | type: "BN"
221 | bn_param {
222 | scale_filler {
223 | type: "constant"
224 | value: 1
225 | }
226 | shift_filler {
227 | type: "constant"
228 | value: 0.001
229 | }
230 | }
231 | }
232 | layer {
233 | name: "relu4"
234 | type: "ReLU"
235 | bottom: "conv4"
236 | top: "conv4"
237 | }
238 | layer {
239 | name: "pool4"
240 | type: "Pooling"
241 | bottom: "conv4"
242 | top: "pool4"
243 | top: "pool4_mask"
244 | pooling_param {
245 | pool: MAX
246 | kernel_size: 2
247 | stride: 2
248 | }
249 | }
250 | layer {
251 | name: "upsample4"
252 | type: "Upsample"
253 | bottom: "pool4"
254 | bottom: "pool4_mask"
255 | top: "upsample4"
256 | upsample_param {
257 | scale: 2
258 | }
259 | }
260 | layer {
261 | name: "conv_decode4"
262 | type: "Convolution"
263 | bottom: "upsample4"
264 | top: "conv_decode4"
265 | param {
266 | lr_mult: 1
267 | decay_mult: 1
268 | }
269 | param {
270 | lr_mult: 2
271 | decay_mult: 0
272 | }
273 | convolution_param {
274 | num_output: 64
275 | kernel_size: 7
276 | pad: 3
277 | weight_filler {
278 | type: "msra"
279 | }
280 | bias_filler {
281 | type: "constant"
282 | }
283 | }
284 | }
285 | layer {
286 | bottom: "conv_decode4"
287 | top: "conv_decode4"
288 | name: "conv_decode4_bn"
289 | type: "BN"
290 | bn_param {
291 | scale_filler {
292 | type: "constant"
293 | value: 1
294 | }
295 | shift_filler {
296 | type: "constant"
297 | value: 0.001
298 | }
299 | }
300 | }
301 | layer {
302 | name: "upsample3"
303 | type: "Upsample"
304 | bottom: "conv_decode4"
305 | bottom: "pool3_mask"
306 | top: "upsample3"
307 | upsample_param {
308 | scale: 2
309 | }
310 | }
311 | layer {
312 | name: "conv_decode3"
313 | type: "Convolution"
314 | bottom: "upsample3"
315 | top: "conv_decode3"
316 | param {
317 | lr_mult: 1
318 | decay_mult: 1
319 | }
320 | param {
321 | lr_mult: 2
322 | decay_mult: 0
323 | }
324 | convolution_param {
325 | num_output: 64
326 | kernel_size: 7
327 | pad: 3
328 | weight_filler {
329 | type: "msra"
330 | }
331 | bias_filler {
332 | type: "constant"
333 | }
334 | }
335 | }
336 | layer {
337 | bottom: "conv_decode3"
338 | top: "conv_decode3"
339 | name: "conv_decode3_bn"
340 | type: "BN"
341 | bn_param {
342 | scale_filler {
343 | type: "constant"
344 | value: 1
345 | }
346 | shift_filler {
347 | type: "constant"
348 | value: 0.001
349 | }
350 | }
351 | }
352 | layer {
353 | name: "upsample2"
354 | type: "Upsample"
355 | bottom: "conv_decode3"
356 | bottom: "pool2_mask"
357 | top: "upsample2"
358 | upsample_param {
359 | scale: 2
360 | }
361 | }
362 | layer {
363 | name: "conv_decode2"
364 | type: "Convolution"
365 | bottom: "upsample2"
366 | top: "conv_decode2"
367 | param {
368 | lr_mult: 1
369 | decay_mult: 1
370 | }
371 | param {
372 | lr_mult: 2
373 | decay_mult: 0
374 | }
375 | convolution_param {
376 | num_output: 64
377 | kernel_size: 7
378 | pad: 3
379 | weight_filler {
380 | type: "msra"
381 | }
382 | bias_filler {
383 | type: "constant"
384 | }
385 | }
386 | }
387 | layer {
388 | bottom: "conv_decode2"
389 | top: "conv_decode2"
390 | name: "conv_decode2_bn"
391 | type: "BN"
392 | bn_param {
393 | scale_filler {
394 | type: "constant"
395 | value: 1
396 | }
397 | shift_filler {
398 | type: "constant"
399 | value: 0.001
400 | }
401 | }
402 | }
403 | layer {
404 | name: "upsample1"
405 | type: "Upsample"
406 | bottom: "conv_decode2"
407 | bottom: "pool1_mask"
408 | top: "upsample1"
409 | upsample_param {
410 | scale: 2
411 | }
412 | }
413 | layer {
414 | name: "conv_decode1"
415 | type: "Convolution"
416 | bottom: "upsample1"
417 | top: "conv_decode1"
418 | param {
419 | lr_mult: 1
420 | decay_mult: 1
421 | }
422 | param {
423 | lr_mult: 2
424 | decay_mult: 0
425 | }
426 | convolution_param {
427 | num_output: 64
428 | kernel_size: 7
429 | pad: 3
430 | weight_filler {
431 | type: "msra"
432 | }
433 | bias_filler {
434 | type: "constant"
435 | }
436 | }
437 | }
438 | layer {
439 | bottom: "conv_decode1"
440 | top: "conv_decode1"
441 | name: "conv_decode1_bn"
442 | type: "BN"
443 | bn_param {
444 | scale_filler {
445 | type: "constant"
446 | value: 1
447 | }
448 | shift_filler {
449 | type: "constant"
450 | value: 0.001
451 | }
452 | }
453 | }
454 | layer {
455 | name: "conv_classifier"
456 | type: "Convolution"
457 | bottom: "conv_decode1"
458 | top: "conv_classifier"
459 | param {
460 | lr_mult: 1
461 | decay_mult: 1
462 | }
463 | param {
464 | lr_mult: 2
465 | decay_mult: 0
466 | }
467 | convolution_param {
468 | num_output: CLASS_COUNT
469 | kernel_size: 1
470 | weight_filler {
471 | type: "msra"
472 | }
473 | bias_filler {
474 | type: "constant"
475 | }
476 | }
477 | }
478 | layer {
479 | name: "loss"
480 | type: "SoftmaxWithLoss"
481 | bottom: "conv_classifier"
482 | bottom: "label"
483 | top: "loss"
484 | softmax_param {engine: CAFFE}
485 | loss_param: {
486 | weight_by_label_freqs: true
487 | CLASS_WEIGHTING
488 | }
489 | }
490 | layer {
491 | name: "accuracy"
492 | type: "Accuracy"
493 | bottom: "conv_classifier"
494 | bottom: "label"
495 | accuracy_param {
496 | }
497 | top: "accuracy"
498 | top: "per_class_accuracy"
499 | }
500 |
--------------------------------------------------------------------------------
/segnet/templates/solver.prototxt:
--------------------------------------------------------------------------------
1 | net: "TRAIN_NET"
2 | test_initialization: false
3 | test_iter: 1
4 | test_interval: 1000000
5 | base_lr: BASE_LR
6 | lr_policy: "step"
7 | gamma: GAMMA
8 | stepsize: STEPSIZE
9 | weight_decay: 0.0005
10 | momentum: 0.9
11 | display: 50
12 | max_iter: MAX_ITER
13 | snapshot: SNAPSHOT_FREQUENCY
14 | snapshot_prefix: "SNAPSHOT_PREFIX"
15 | solver_mode: GPU
16 |
--------------------------------------------------------------------------------
/segnet/test_segmentation.py:
--------------------------------------------------------------------------------
1 | # https://github.com/BVLC/caffe/issues/861
2 | import matplotlib
3 | matplotlib.use('Agg')
4 |
5 | import numpy as np
6 | import os.path
7 | import re
8 | import json
9 | import scipy
10 | import argparse
11 | caffe_root = os.getenv('CAFFE_ROOT', '/home/ubuntu/caffe-segnet/')
12 | import sys
13 | sys.path.insert(0, caffe_root + 'python')
14 |
15 | import caffe
16 |
17 | from metrics import complete_and_correct
18 | from inference import predict
19 | from inference import labels_to_image
20 |
21 |
22 | # Import arguments
23 | parser = argparse.ArgumentParser()
24 | parser.add_argument('--model', type=str, required=True)
25 | parser.add_argument('--weights', type=str, required=True)
26 | parser.add_argument('--output', type=str, required=True)
27 | parser.add_argument('--classes', type=str, required=True)
28 | parser.add_argument('--metrics-only', default=False, action='store_true')
29 | parser.add_argument('--gpu', type=int, default=None)
30 | args = parser.parse_args()
31 |
32 | with open(args.classes) as classes:
33 | colors = map(lambda x: x['color'][1:], json.load(classes))
34 | colors.append('000000')
35 | colors = map(lambda rgbstr: tuple(map(ord, rgbstr.decode('hex'))), colors)
36 |
37 | num_classes = len(colors)
38 |
39 | model = open(args.model, 'r').read()
40 | m = re.search('source:\s*"(.*)"', model)
41 | test_data = m.group(1)
42 | test_data = open(test_data, 'r').readlines()
43 |
44 | caffe.set_mode_gpu()
45 | if args.gpu is not None:
46 | caffe.set_device(args.gpu)
47 |
48 | net = caffe.Net(args.model,
49 | args.weights,
50 | caffe.TEST)
51 |
52 | pixels_correct = 0
53 | pixels_complete = 0
54 | pixels_predicted_fg = 0
55 | pixels_actual_fg = 0
56 | outputs = []
57 |
58 | for i in range(0, len(test_data)):
59 | prediction_image = predict(net, colors)
60 |
61 | image = net.blobs['data'].data
62 | image = np.squeeze(image[0, :, :, :])
63 | label = net.blobs['label'].data
64 | label = np.squeeze(label).astype(np.uint8)
65 | predicted = net.blobs['prob'].data
66 | predicted = np.squeeze(predicted[0, :, :, :])
67 |
68 | metrics = complete_and_correct(predicted, label, 3, 0.5)
69 |
70 | result = {'index': i, 'metrics': metrics}
71 | print(result)
72 | outputs.append(result)
73 | pixels_correct += sum(metrics['pixels_correct'])
74 | pixels_complete += sum(metrics['pixels_complete'])
75 | pixels_predicted_fg += sum(metrics['pixels_predicted'][:-1])
76 | pixels_actual_fg += sum(metrics['pixels_actual'][:-1])
77 | if args.metrics_only:
78 | continue
79 |
80 | image = np.transpose(image, (1, 2, 0))
81 | image = image[:, :, (2, 1, 0)]
82 |
83 | prediction = str(i) + '_prediction.png'
84 | input_image = str(i) + '_input.png'
85 | groundtruth = str(i) + '_groundtruth.png'
86 |
87 | prediction_image.save(os.path.join(args.output, prediction))
88 | labels_to_image(label, colors).save(os.path.join(args.output, groundtruth))
89 | scipy.misc.toimage(image, cmin=0.0, cmax=255).save(
90 | os.path.join(args.output, input_image))
91 |
92 | result['input'] = input_image
93 | result['prediction'] = prediction
94 | result['groundtruth'] = groundtruth
95 | result['test_data'] = test_data[i]
96 |
97 | with open(os.path.join(args.output, 'index.json'), 'w') as outfile:
98 | json.dump({
99 | 'correctness': pixels_correct / pixels_predicted_fg,
100 | 'completeness': pixels_complete / pixels_actual_fg,
101 | 'images': outputs
102 | }, outfile)
103 |
104 | print 'Success!'
105 |
--------------------------------------------------------------------------------
/segnet/tile_server.py:
--------------------------------------------------------------------------------
1 | # https://github.com/BVLC/caffe/issues/861
2 | import matplotlib
3 | matplotlib.use('Agg')
4 |
5 | import re
6 | import os.path
7 | import sys
8 | from flask import Flask
9 | from flask import request
10 | from flask import send_file
11 | from flask import jsonify
12 | from flask import abort
13 | import requests
14 | import numpy as np
15 | from PIL import Image
16 | import argparse
17 | import json
18 | import StringIO
19 | from boto3.session import Session
20 | caffe_root = os.getenv('CAFFE_ROOT', '/home/ubuntu/caffe-segnet/')
21 | sys.path.insert(0, caffe_root + 'python')
22 | import caffe
23 |
24 | from inference import predict
25 |
26 | app = Flask(__name__)
27 | app.config['SEND_FILE_MAX_AGE_DEFAULT'] = 300
28 | aws_session = Session()
29 | s3 = aws_session.client('s3')
30 |
31 | # Import arguments
32 | cpu_only_env = bool(os.getenv('SKYNET_CPU_ONLY', False))
33 | parser = argparse.ArgumentParser()
34 | parser.add_argument('image_tiles', type=str)
35 | parser.add_argument('--model', type=str, default='/model/segnet_deploy.prototxt')
36 | parser.add_argument('--weights', type=str, default='/model/weights.caffemodel')
37 | parser.add_argument('--classes', type=str, default='/model/classes.json')
38 | parser.add_argument('--cpu-mode', action='store_true', default=cpu_only_env)
39 | parser.add_argument('--min-zoom', type=int, default=0)
40 | parser.add_argument('--max-zoom', type=int, default=18)
41 | args = parser.parse_args()
42 |
43 |
44 | def resolve_s3(s3uri):
45 | match = re.search('s3://([^/]*)/(.*)$', s3uri)
46 | if not match:
47 | return s3uri
48 | bucket = match.group(1)
49 | key = match.group(2)
50 | target = '/model/' + os.path.basename(key)
51 | if not os.path.isfile(target):
52 | print('downloading ' + s3uri + ' to ' + target)
53 | s3.download_file(bucket, key, target)
54 | else:
55 | print(s3uri + ' appears to have already been downloaded to ' + target +
56 | '; using local copy.')
57 | return target
58 |
59 |
60 | model_file = resolve_s3(args.model)
61 | weights_file = resolve_s3(args.weights)
62 | classes_file = resolve_s3(args.classes)
63 |
64 |
65 | # read classes metadata
66 | with open(classes_file) as classes:
67 | colors = map(lambda x: x['color'][1:], json.load(classes))
68 | colors.append('000000')
69 | colors = map(lambda rgbstr: tuple(map(ord, rgbstr.decode('hex'))), colors)
70 | num_classes = len(colors)
71 |
72 | # read model definition
73 | model = open(model_file, 'r').read()
74 |
75 | # create net
76 | if args.cpu_mode:
77 | caffe.set_mode_cpu()
78 | else:
79 | caffe.set_mode_gpu()
80 |
81 | net = caffe.Net(model_file,
82 | weights_file,
83 | caffe.TEST)
84 |
85 |
86 | @app.route('/index.json')
87 | def index():
88 | return jsonify(tilejson='2.0.0',
89 | tiles=[request.url.replace('index.json', '{z}/{x}/{y}/tile.png')],
90 | minzoom=args.min_zoom,
91 | maxzoom=args.max_zoom)
92 |
93 |
94 | def send_prediction(im):
95 | bands = len(im.getbands())
96 | imdata = np.array(im.getdata()).reshape(im.size[0], im.size[1], bands)
97 | prediction = predict(net, colors, imdata)
98 | strio = StringIO.StringIO()
99 | prediction.save(strio, 'PNG')
100 | strio.seek(0)
101 | return send_file(strio, mimetype='image/png')
102 |
103 |
104 | @app.route('/-
115 |
-
116 | Input Image117 |OSM "ground truth"118 | ${results.map((result, i) => { 119 | return choo.view` 120 |121 | ${resultNames[i]}` 127 | })} 128 |
122 |123 | Correct: ${result.metrics.correctness.toFixed(3)}126 |
124 | Complete: ${result.metrics.completeness.toFixed(3)}
125 |
129 | ${items
130 | .slice(0, state.app.limit)
131 | .map(item => {
132 | var tile = getTile(item)
133 | var image = tile ? getSatelliteTileURL(query, tile[0], tile[1], tile[2])
134 | : (baseurls[0] + item.input)
135 | return choo.view`
136 | -
137 | 138 |140 |
139 |
141 |143 | ${results.map(result => { 144 | const it = result.items.find(i => tile.join('') === getTile(i).join('')) 145 | return choo.view` 146 |142 |
147 |` 153 | })} 154 |148 |
149 | Complete: ${it.metrics.completeness_score.toFixed(3)} 150 | Correct: ${it.metrics.correctness_score.toFixed(3)} 151 |152 |
155 | `
156 | })
157 | }
158 |