├── README.md
└── SqueezeNet_v1.0
    ├── deploy.prototxt
    ├── solver.prototxt
    ├── squeezenet
        ├── 1602.07360v2.pdf
        ├── GenerateMXNET.py
        ├── calc_accuracy.py
        ├── generate_data.sh
        ├── mxnet_predict_example.py
        ├── symbol_squeezenet.py
        ├── test_squeezenet.sh
        ├── train.py
        ├── train_model.py
        └── train_squeezenet.sh
    ├── squeezenet_v1.0.caffemodel
    └── train_val.prototxt


/README.md:
--------------------------------------------------------------------------------
 1 | 
 2 | The Caffe-compatible files that you are probably looking for:
 3 | 
 4 |     SqueezeNet_v1.0/train_val.prototxt          #model architecture
 5 |     SqueezeNet_v1.0/solver.prototxt             #additional training details (learning rate schedule, etc.)
 6 |     SqueezeNet_v1.0/squeezenet_v1.0.caffemodel  #pretrained model parameters
 7 |     
 8 | If you find SqueezeNet useful in your research, please consider citing the [SqueezeNet paper](http://arxiv.org/abs/1602.07360):
 9 | 
10 |     @article{SqueezeNet,
11 |         Author = {Forrest N. Iandola and Matthew W. Moskewicz and Khalid Ashraf and Song Han and William J. Dally and Kurt Keutzer},
12 |         Title = {SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <1MB model size},
13 |         Journal = {arXiv:1602.07360},
14 |         Year = {2016}
15 |     }
16 | 
17 | 
18 | Helpful hints:
19 | 
20 | 1. **Getting the SqueezeNet model:** `git clone <this repo>`. 
21 | In this repository, we include Caffe-compatible files for the model architecture, the solver configuration, and the pretrained model (4.8MB uncompressed).
22 | 
23 | 2. **Batch size.** For the SqueezeNet model in our paper, we used a batch size of 1024. If implemented naively on a single GPU, this may result in running out of memory. An effective workaround is to use hierarchical batching (sometimes called "delayed batching"). Caffe supports hierarchical batching by doing `train_val.prototxt>batch_size` training samples concurrently in memory. After `solver.prototxt>iter_size` iterations, the gradients are summed and the model is updated. Mathematically, the batch size is `batch_size * iter_size`. In the included prototxt files, we have set `(batch_size=32, iter_size=32)`, but any combination of batch_size and iter_size that multiply to 1024 will produce eqivalent results. In fact, with the same random number generator seed, the model will be fully reproducable if trained multiple times. Finally, note that in Caffe `iter_size` is applied while training on the training set but not while testing on  the test set.
24 | 
25 | 3. **Implementing Fire modules.** In the paper, we describe the `expand` portion of the Fire layer as a collection of 1x1 and 3x3 filters. Caffe does not natively support a convolution layer that has multiple filter sizes. To work around this, we implement `expand1x1` and `expand3x3` layers and concatenate the results together in the channel dimension. 
26 | 
27 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/deploy.prototxt:
--------------------------------------------------------------------------------
  1 | name: "SqueezeNet"
  2 | input: "data"
  3 | input_dim: 1
  4 | input_dim: 3
  5 | input_dim: 227
  6 | input_dim: 227
  7 | layer {
  8 |   name: "conv1"
  9 |   type: "Convolution"
 10 |   bottom: "data"
 11 |   top: "conv1"
 12 |   convolution_param {
 13 |     num_output: 96
 14 |     kernel_size: 7
 15 |     stride: 2
 16 |     weight_filler {
 17 |       type: "xavier"
 18 |     }
 19 |   }
 20 | }
 21 | layer {
 22 |   name: "relu_conv1"
 23 |   type: "ReLU"
 24 |   bottom: "conv1"
 25 |   top: "conv1"
 26 | }
 27 | layer {
 28 |   name: "pool1"
 29 |   type: "Pooling"
 30 |   bottom: "conv1"
 31 |   top: "pool1"
 32 |   pooling_param {
 33 |     pool: MAX
 34 |     kernel_size: 3
 35 |     stride: 2
 36 |   }
 37 | }
 38 | layer {
 39 |   name: "fire2/squeeze1x1"
 40 |   type: "Convolution"
 41 |   bottom: "pool1"
 42 |   top: "fire2/squeeze1x1"
 43 |   convolution_param {
 44 |     num_output: 16
 45 |     kernel_size: 1
 46 |     weight_filler {
 47 |       type: "xavier"
 48 |     }
 49 |   }
 50 | }
 51 | layer {
 52 |   name: "fire2/relu_squeeze1x1"
 53 |   type: "ReLU"
 54 |   bottom: "fire2/squeeze1x1"
 55 |   top: "fire2/squeeze1x1"
 56 | }
 57 | layer {
 58 |   name: "fire2/expand1x1"
 59 |   type: "Convolution"
 60 |   bottom: "fire2/squeeze1x1"
 61 |   top: "fire2/expand1x1"
 62 |   convolution_param {
 63 |     num_output: 64
 64 |     kernel_size: 1
 65 |     weight_filler {
 66 |       type: "xavier"
 67 |     }
 68 |   }
 69 | }
 70 | layer {
 71 |   name: "fire2/relu_expand1x1"
 72 |   type: "ReLU"
 73 |   bottom: "fire2/expand1x1"
 74 |   top: "fire2/expand1x1"
 75 | }
 76 | layer {
 77 |   name: "fire2/expand3x3"
 78 |   type: "Convolution"
 79 |   bottom: "fire2/squeeze1x1"
 80 |   top: "fire2/expand3x3"
 81 |   convolution_param {
 82 |     num_output: 64
 83 |     pad: 1
 84 |     kernel_size: 3
 85 |     weight_filler {
 86 |       type: "xavier"
 87 |     }
 88 |   }
 89 | }
 90 | layer {
 91 |   name: "fire2/relu_expand3x3"
 92 |   type: "ReLU"
 93 |   bottom: "fire2/expand3x3"
 94 |   top: "fire2/expand3x3"
 95 | }
 96 | layer {
 97 |   name: "fire2/concat"
 98 |   type: "Concat"
 99 |   bottom: "fire2/expand1x1"
100 |   bottom: "fire2/expand3x3"
101 |   top: "fire2/concat"
102 | }
103 | layer {
104 |   name: "fire3/squeeze1x1"
105 |   type: "Convolution"
106 |   bottom: "fire2/concat"
107 |   top: "fire3/squeeze1x1"
108 |   convolution_param {
109 |     num_output: 16
110 |     kernel_size: 1
111 |     weight_filler {
112 |       type: "xavier"
113 |     }
114 |   }
115 | }
116 | layer {
117 |   name: "fire3/relu_squeeze1x1"
118 |   type: "ReLU"
119 |   bottom: "fire3/squeeze1x1"
120 |   top: "fire3/squeeze1x1"
121 | }
122 | layer {
123 |   name: "fire3/expand1x1"
124 |   type: "Convolution"
125 |   bottom: "fire3/squeeze1x1"
126 |   top: "fire3/expand1x1"
127 |   convolution_param {
128 |     num_output: 64
129 |     kernel_size: 1
130 |     weight_filler {
131 |       type: "xavier"
132 |     }
133 |   }
134 | }
135 | layer {
136 |   name: "fire3/relu_expand1x1"
137 |   type: "ReLU"
138 |   bottom: "fire3/expand1x1"
139 |   top: "fire3/expand1x1"
140 | }
141 | layer {
142 |   name: "fire3/expand3x3"
143 |   type: "Convolution"
144 |   bottom: "fire3/squeeze1x1"
145 |   top: "fire3/expand3x3"
146 |   convolution_param {
147 |     num_output: 64
148 |     pad: 1
149 |     kernel_size: 3
150 |     weight_filler {
151 |       type: "xavier"
152 |     }
153 |   }
154 | }
155 | layer {
156 |   name: "fire3/relu_expand3x3"
157 |   type: "ReLU"
158 |   bottom: "fire3/expand3x3"
159 |   top: "fire3/expand3x3"
160 | }
161 | layer {
162 |   name: "fire3/concat"
163 |   type: "Concat"
164 |   bottom: "fire3/expand1x1"
165 |   bottom: "fire3/expand3x3"
166 |   top: "fire3/concat"
167 | }
168 | layer {
169 |   name: "fire4/squeeze1x1"
170 |   type: "Convolution"
171 |   bottom: "fire3/concat"
172 |   top: "fire4/squeeze1x1"
173 |   convolution_param {
174 |     num_output: 32
175 |     kernel_size: 1
176 |     weight_filler {
177 |       type: "xavier"
178 |     }
179 |   }
180 | }
181 | layer {
182 |   name: "fire4/relu_squeeze1x1"
183 |   type: "ReLU"
184 |   bottom: "fire4/squeeze1x1"
185 |   top: "fire4/squeeze1x1"
186 | }
187 | layer {
188 |   name: "fire4/expand1x1"
189 |   type: "Convolution"
190 |   bottom: "fire4/squeeze1x1"
191 |   top: "fire4/expand1x1"
192 |   convolution_param {
193 |     num_output: 128
194 |     kernel_size: 1
195 |     weight_filler {
196 |       type: "xavier"
197 |     }
198 |   }
199 | }
200 | layer {
201 |   name: "fire4/relu_expand1x1"
202 |   type: "ReLU"
203 |   bottom: "fire4/expand1x1"
204 |   top: "fire4/expand1x1"
205 | }
206 | layer {
207 |   name: "fire4/expand3x3"
208 |   type: "Convolution"
209 |   bottom: "fire4/squeeze1x1"
210 |   top: "fire4/expand3x3"
211 |   convolution_param {
212 |     num_output: 128
213 |     pad: 1
214 |     kernel_size: 3
215 |     weight_filler {
216 |       type: "xavier"
217 |     }
218 |   }
219 | }
220 | layer {
221 |   name: "fire4/relu_expand3x3"
222 |   type: "ReLU"
223 |   bottom: "fire4/expand3x3"
224 |   top: "fire4/expand3x3"
225 | }
226 | layer {
227 |   name: "fire4/concat"
228 |   type: "Concat"
229 |   bottom: "fire4/expand1x1"
230 |   bottom: "fire4/expand3x3"
231 |   top: "fire4/concat"
232 | }
233 | layer {
234 |   name: "pool4"
235 |   type: "Pooling"
236 |   bottom: "fire4/concat"
237 |   top: "pool4"
238 |   pooling_param {
239 |     pool: MAX
240 |     kernel_size: 3
241 |     stride: 2
242 |   }
243 | }
244 | layer {
245 |   name: "fire5/squeeze1x1"
246 |   type: "Convolution"
247 |   bottom: "pool4"
248 |   top: "fire5/squeeze1x1"
249 |   convolution_param {
250 |     num_output: 32
251 |     kernel_size: 1
252 |     weight_filler {
253 |       type: "xavier"
254 |     }
255 |   }
256 | }
257 | layer {
258 |   name: "fire5/relu_squeeze1x1"
259 |   type: "ReLU"
260 |   bottom: "fire5/squeeze1x1"
261 |   top: "fire5/squeeze1x1"
262 | }
263 | layer {
264 |   name: "fire5/expand1x1"
265 |   type: "Convolution"
266 |   bottom: "fire5/squeeze1x1"
267 |   top: "fire5/expand1x1"
268 |   convolution_param {
269 |     num_output: 128
270 |     kernel_size: 1
271 |     weight_filler {
272 |       type: "xavier"
273 |     }
274 |   }
275 | }
276 | layer {
277 |   name: "fire5/relu_expand1x1"
278 |   type: "ReLU"
279 |   bottom: "fire5/expand1x1"
280 |   top: "fire5/expand1x1"
281 | }
282 | layer {
283 |   name: "fire5/expand3x3"
284 |   type: "Convolution"
285 |   bottom: "fire5/squeeze1x1"
286 |   top: "fire5/expand3x3"
287 |   convolution_param {
288 |     num_output: 128
289 |     pad: 1
290 |     kernel_size: 3
291 |     weight_filler {
292 |       type: "xavier"
293 |     }
294 |   }
295 | }
296 | layer {
297 |   name: "fire5/relu_expand3x3"
298 |   type: "ReLU"
299 |   bottom: "fire5/expand3x3"
300 |   top: "fire5/expand3x3"
301 | }
302 | layer {
303 |   name: "fire5/concat"
304 |   type: "Concat"
305 |   bottom: "fire5/expand1x1"
306 |   bottom: "fire5/expand3x3"
307 |   top: "fire5/concat"
308 | }
309 | layer {
310 |   name: "fire6/squeeze1x1"
311 |   type: "Convolution"
312 |   bottom: "fire5/concat"
313 |   top: "fire6/squeeze1x1"
314 |   convolution_param {
315 |     num_output: 48
316 |     kernel_size: 1
317 |     weight_filler {
318 |       type: "xavier"
319 |     }
320 |   }
321 | }
322 | layer {
323 |   name: "fire6/relu_squeeze1x1"
324 |   type: "ReLU"
325 |   bottom: "fire6/squeeze1x1"
326 |   top: "fire6/squeeze1x1"
327 | }
328 | layer {
329 |   name: "fire6/expand1x1"
330 |   type: "Convolution"
331 |   bottom: "fire6/squeeze1x1"
332 |   top: "fire6/expand1x1"
333 |   convolution_param {
334 |     num_output: 192
335 |     kernel_size: 1
336 |     weight_filler {
337 |       type: "xavier"
338 |     }
339 |   }
340 | }
341 | layer {
342 |   name: "fire6/relu_expand1x1"
343 |   type: "ReLU"
344 |   bottom: "fire6/expand1x1"
345 |   top: "fire6/expand1x1"
346 | }
347 | layer {
348 |   name: "fire6/expand3x3"
349 |   type: "Convolution"
350 |   bottom: "fire6/squeeze1x1"
351 |   top: "fire6/expand3x3"
352 |   convolution_param {
353 |     num_output: 192
354 |     pad: 1
355 |     kernel_size: 3
356 |     weight_filler {
357 |       type: "xavier"
358 |     }
359 |   }
360 | }
361 | layer {
362 |   name: "fire6/relu_expand3x3"
363 |   type: "ReLU"
364 |   bottom: "fire6/expand3x3"
365 |   top: "fire6/expand3x3"
366 | }
367 | layer {
368 |   name: "fire6/concat"
369 |   type: "Concat"
370 |   bottom: "fire6/expand1x1"
371 |   bottom: "fire6/expand3x3"
372 |   top: "fire6/concat"
373 | }
374 | layer {
375 |   name: "fire7/squeeze1x1"
376 |   type: "Convolution"
377 |   bottom: "fire6/concat"
378 |   top: "fire7/squeeze1x1"
379 |   convolution_param {
380 |     num_output: 48
381 |     kernel_size: 1
382 |     weight_filler {
383 |       type: "xavier"
384 |     }
385 |   }
386 | }
387 | layer {
388 |   name: "fire7/relu_squeeze1x1"
389 |   type: "ReLU"
390 |   bottom: "fire7/squeeze1x1"
391 |   top: "fire7/squeeze1x1"
392 | }
393 | layer {
394 |   name: "fire7/expand1x1"
395 |   type: "Convolution"
396 |   bottom: "fire7/squeeze1x1"
397 |   top: "fire7/expand1x1"
398 |   convolution_param {
399 |     num_output: 192
400 |     kernel_size: 1
401 |     weight_filler {
402 |       type: "xavier"
403 |     }
404 |   }
405 | }
406 | layer {
407 |   name: "fire7/relu_expand1x1"
408 |   type: "ReLU"
409 |   bottom: "fire7/expand1x1"
410 |   top: "fire7/expand1x1"
411 | }
412 | layer {
413 |   name: "fire7/expand3x3"
414 |   type: "Convolution"
415 |   bottom: "fire7/squeeze1x1"
416 |   top: "fire7/expand3x3"
417 |   convolution_param {
418 |     num_output: 192
419 |     pad: 1
420 |     kernel_size: 3
421 |     weight_filler {
422 |       type: "xavier"
423 |     }
424 |   }
425 | }
426 | layer {
427 |   name: "fire7/relu_expand3x3"
428 |   type: "ReLU"
429 |   bottom: "fire7/expand3x3"
430 |   top: "fire7/expand3x3"
431 | }
432 | layer {
433 |   name: "fire7/concat"
434 |   type: "Concat"
435 |   bottom: "fire7/expand1x1"
436 |   bottom: "fire7/expand3x3"
437 |   top: "fire7/concat"
438 | }
439 | layer {
440 |   name: "fire8/squeeze1x1"
441 |   type: "Convolution"
442 |   bottom: "fire7/concat"
443 |   top: "fire8/squeeze1x1"
444 |   convolution_param {
445 |     num_output: 64
446 |     kernel_size: 1
447 |     weight_filler {
448 |       type: "xavier"
449 |     }
450 |   }
451 | }
452 | layer {
453 |   name: "fire8/relu_squeeze1x1"
454 |   type: "ReLU"
455 |   bottom: "fire8/squeeze1x1"
456 |   top: "fire8/squeeze1x1"
457 | }
458 | layer {
459 |   name: "fire8/expand1x1"
460 |   type: "Convolution"
461 |   bottom: "fire8/squeeze1x1"
462 |   top: "fire8/expand1x1"
463 |   convolution_param {
464 |     num_output: 256
465 |     kernel_size: 1
466 |     weight_filler {
467 |       type: "xavier"
468 |     }
469 |   }
470 | }
471 | layer {
472 |   name: "fire8/relu_expand1x1"
473 |   type: "ReLU"
474 |   bottom: "fire8/expand1x1"
475 |   top: "fire8/expand1x1"
476 | }
477 | layer {
478 |   name: "fire8/expand3x3"
479 |   type: "Convolution"
480 |   bottom: "fire8/squeeze1x1"
481 |   top: "fire8/expand3x3"
482 |   convolution_param {
483 |     num_output: 256
484 |     pad: 1
485 |     kernel_size: 3
486 |     weight_filler {
487 |       type: "xavier"
488 |     }
489 |   }
490 | }
491 | layer {
492 |   name: "fire8/relu_expand3x3"
493 |   type: "ReLU"
494 |   bottom: "fire8/expand3x3"
495 |   top: "fire8/expand3x3"
496 | }
497 | layer {
498 |   name: "fire8/concat"
499 |   type: "Concat"
500 |   bottom: "fire8/expand1x1"
501 |   bottom: "fire8/expand3x3"
502 |   top: "fire8/concat"
503 | }
504 | layer {
505 |   name: "pool8"
506 |   type: "Pooling"
507 |   bottom: "fire8/concat"
508 |   top: "pool8"
509 |   pooling_param {
510 |     pool: MAX
511 |     kernel_size: 3
512 |     stride: 2
513 |   }
514 | }
515 | layer {
516 |   name: "fire9/squeeze1x1"
517 |   type: "Convolution"
518 |   bottom: "pool8"
519 |   top: "fire9/squeeze1x1"
520 |   convolution_param {
521 |     num_output: 64
522 |     kernel_size: 1
523 |     weight_filler {
524 |       type: "xavier"
525 |     }
526 |   }
527 | }
528 | layer {
529 |   name: "fire9/relu_squeeze1x1"
530 |   type: "ReLU"
531 |   bottom: "fire9/squeeze1x1"
532 |   top: "fire9/squeeze1x1"
533 | }
534 | layer {
535 |   name: "fire9/expand1x1"
536 |   type: "Convolution"
537 |   bottom: "fire9/squeeze1x1"
538 |   top: "fire9/expand1x1"
539 |   convolution_param {
540 |     num_output: 256
541 |     kernel_size: 1
542 |     weight_filler {
543 |       type: "xavier"
544 |     }
545 |   }
546 | }
547 | layer {
548 |   name: "fire9/relu_expand1x1"
549 |   type: "ReLU"
550 |   bottom: "fire9/expand1x1"
551 |   top: "fire9/expand1x1"
552 | }
553 | layer {
554 |   name: "fire9/expand3x3"
555 |   type: "Convolution"
556 |   bottom: "fire9/squeeze1x1"
557 |   top: "fire9/expand3x3"
558 |   convolution_param {
559 |     num_output: 256
560 |     pad: 1
561 |     kernel_size: 3
562 |     weight_filler {
563 |       type: "xavier"
564 |     }
565 |   }
566 | }
567 | layer {
568 |   name: "fire9/relu_expand3x3"
569 |   type: "ReLU"
570 |   bottom: "fire9/expand3x3"
571 |   top: "fire9/expand3x3"
572 | }
573 | layer {
574 |   name: "fire9/concat"
575 |   type: "Concat"
576 |   bottom: "fire9/expand1x1"
577 |   bottom: "fire9/expand3x3"
578 |   top: "fire9/concat"
579 | }
580 | layer {
581 |   name: "drop9"
582 |   type: "Dropout"
583 |   bottom: "fire9/concat"
584 |   top: "fire9/concat"
585 |   dropout_param {
586 |     dropout_ratio: 0.5
587 |   }
588 | }
589 | layer {
590 |   name: "conv10"
591 |   type: "Convolution"
592 |   bottom: "fire9/concat"
593 |   top: "conv10"
594 |   convolution_param {
595 |     num_output: 1000
596 |     pad: 1
597 |     kernel_size: 1
598 |     weight_filler {
599 |       type: "gaussian"
600 |       mean: 0.0
601 |       std: 0.01
602 |     }
603 |   }
604 | }
605 | layer {
606 |   name: "relu_conv10"
607 |   type: "ReLU"
608 |   bottom: "conv10"
609 |   top: "conv10"
610 | }
611 | layer {
612 |   name: "pool10"
613 |   type: "Pooling"
614 |   bottom: "conv10"
615 |   top: "pool10"
616 |   pooling_param {
617 |     pool: AVE
618 |     global_pooling: true
619 |   }
620 | }
621 | 
622 | layer {
623 | 	bottom: "pool10"
624 | 	top: "prob"
625 | 	name: "prob"
626 | 	type: "Softmax"
627 | }
628 | 
629 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/solver.prototxt:
--------------------------------------------------------------------------------
 1 | # please cite:
 2 | # @article{SqueezeNet,
 3 | #     Author = {Forrest N. Iandola and Matthew W. Moskewicz and Khalid Ashraf and Song Han and William J. Dally and Kurt Keutzer},
 4 | #     Title = {SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <1MB model size},
 5 | #     Journal = {arXiv:1602.07360},
 6 | #     Year = {2016}
 7 | # }
 8 | 
 9 | test_iter: 2000 #not subject to iter_size
10 | test_interval: 1000
11 | base_lr: 0.08
12 | display: 40
13 | max_iter: 85000
14 | iter_size: 32 #global batch size = batch_size * iter_size
15 | lr_policy: "poly"
16 | power: 0.5
17 | momentum: 0.9
18 | weight_decay: 0.0002
19 | snapshot: 1000
20 | snapshot_prefix: "train"
21 | solver_mode: GPU
22 | random_seed: 42
23 | net: "train_val.prototxt" #we typically do `cd SqueezeNet_v1.0; caffe train <args>` 
24 | test_initialization: false
25 | average_loss: 40
26 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet/1602.07360v2.pdf:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hariag/SqueezeNet/3ae4e4f38dfba19460346f99ebce37e7be288569/SqueezeNet_v1.0/squeezenet/1602.07360v2.pdf


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet/GenerateMXNET.py:
--------------------------------------------------------------------------------
  1 | #! /bin/python
  2 | import os, sys, time
  3 | import random
  4 | import shutil
  5 | 
  6 | def CheckPathOrFail(path, isFile=True):
  7 |     if os.path.exists(path):
  8 |         if isFile:
  9 |             if os.path.isfile(path):
 10 |                 return True
 11 |             else:
 12 |                 print("path %s not a valid file, exit"%path)
 13 |                 exit(1)
 14 |         if not isFile:
 15 |             if os.path.isdir(path):
 16 |                 return True
 17 |             else:
 18 |                 print("path %s not a valid folder, exit"%path)
 19 |                 exit(1)    
 20 | 
 21 | def getTimestampStr():
 22 |     return str(int(time.time()))
 23 | 
 24 | def CreateImageTree(dataPath, dataFilePath):
 25 |     os.system("tree -i -f %s |grep \".jpg\|.png\|.bmp\" > %s"%(dataPath, dataFilePath))
 26 | 
 27 | def GetImageListFromFile(fileName):
 28 |     f=open(fileName,"rb")
 29 |     lines = [line.strip() for line in f.readlines()]
 30 |     return lines
 31 | 
 32 | def GetClassNameFromImageList(imageList, dataPath):
 33 |     classList=[]
 34 |     for image in imageList:
 35 |         className=image.replace(dataPath,"").split("/")[3]
 36 |         classList.append(className)
 37 |     return list(set(classList))
 38 | 
 39 | def SplitImageFileListIntoTrainAndVal(imageFileList, classNameList, ratio=0.8, countFilter=0, limits=None):
 40 |     trainSet=[]
 41 |     valSet=[]
 42 |     labelSet=[]
 43 |     labelId = 0
 44 |     index =0 
 45 |     for className in classNameList:
 46 |         searchKey="/"+className+"/"
 47 |         currentClassList =[]
 48 |         for image in imageFileList:
 49 |             if image.find(searchKey)>=0:
 50 |                 currentClassList.append(image)
 51 |         if len(currentClassList)<countFilter:
 52 |             #skip small image set.
 53 |             pass
 54 |         else:
 55 |             labelSet.append((labelId,className))
 56 |             random.shuffle (currentClassList)
 57 |             if limits is None:
 58 |                 size_train = int(len(currentClassList)*ratio)
 59 |                 for item in currentClassList[:size_train]:
 60 |                     trainSet.append((index, labelId, item))
 61 |                     index +=1
 62 |                 for item in currentClassList[size_train:]:
 63 |                     valSet.append((index, labelId, item))
 64 |                     index +=1
 65 |             else:
 66 |                 size_train = int(limits*ratio)
 67 |                 for item in currentClassList[:size_train]:
 68 |                     trainSet.append((index, labelId, item))
 69 |                     index +=1
 70 |                 for item in currentClassList[size_train:limits]:
 71 |                     valSet.append((index, labelId, item))
 72 |                     index +=1
 73 |             labelId+=1
 74 |     return (trainSet, valSet, labelSet)
 75 | 
 76 | def WriteDownToFile(dataSet, fileName):
 77 |     ft=open(fileName,"w")
 78 |     if len(dataSet[0])==2:
 79 |         for line in dataSet:
 80 |             wline=str(line[0])+" \t "+str(line[1]) + "\n"
 81 |             ft.write(wline)
 82 |     else:
 83 |         for line in dataSet:
 84 |             wline=str(line[0])+" \t "+str(line[1])+" \t "+str(line[2])+ "\n"
 85 |             ft.write(wline)
 86 |     ft.flush()
 87 |     ft.close()
 88 | 
 89 | if __name__=="__main__":
 90 |     start = time.time()
 91 |     timestamp = getTimestampStr()
 92 |     MXNETHome = os.getenv("MXNET_HOME","/home/haria/mxnet")
 93 |     if MXNETHome is None:
 94 |         print("MXNET_HOME is not defined!")
 95 |         exit(1)
 96 | 
 97 |     if len(sys.argv) <4:
 98 |         print("Usage: python %s dataPath train_out.bin val_out.bin shape [ratio countFilter limits]")
 99 |         exit(1)
100 |     dataPath=os.path.abspath(sys.argv[1])
101 |     trainPath =os.path.abspath(sys.argv[2])
102 |     valPath =os.path.abspath(sys.argv[3])
103 |     CheckPathOrFail(dataPath, False)
104 |     print("Data Path check PASS.")
105 |     
106 |     shape=28
107 |     ratio = 0.8
108 |     countFilter = 0
109 |     limits = None
110 |     if len(sys.argv) >4:
111 |         shape = int(sys.argv[4])
112 |     if len(sys.argv) >5:
113 |         ratio = float(sys.argv[5])
114 |     if len(sys.argv) >6:
115 |         countFilter = int(sys.argv[6])  
116 |     if len(sys.argv) >7:
117 |         limits = int(sys.argv[7])  
118 |     ##################################################################
119 | 
120 |     dataFilePath = "./data.txt"
121 |     labelsFilePath =  "./labels.txt"
122 |     trainFilePath = "./train.txt"
123 |     valFilePath = "./val.txt"
124 |     
125 |     CreateImageTree(dataPath, dataFilePath)
126 |     imageFileList = GetImageListFromFile(dataFilePath)
127 |     # remove dataPath in beginning
128 |     imageFileList = [image.replace(os.path.abspath(dataPath),"") for image in imageFileList]
129 |     classNameList = GetClassNameFromImageList(imageFileList, dataPath)
130 |     trainSet, valSet, labelSet = SplitImageFileListIntoTrainAndVal(imageFileList, classNameList, ratio, countFilter, limits)
131 |     random.shuffle (trainSet)
132 |     WriteDownToFile(trainSet, trainFilePath)
133 |     WriteDownToFile(valSet,   valFilePath)
134 |     WriteDownToFile(labelSet, labelsFilePath)
135 |     
136 |     
137 |     ##################################################################
138 |     im2rec = os.path.join(MXNETHome, "bin/im2rec")
139 |     command = "%s %s %s %s resize=%s"%(im2rec, trainFilePath, dataPath, trainPath, shape)
140 |     print command
141 |     os.system(command)
142 |         
143 |     command = "%s %s %s %s resize=%s"%(im2rec, valFilePath, dataPath, valPath, shape)
144 |     print command
145 |     os.system(command)
146 |    
147 |     end = time.time()
148 |     print ("Time Elapsed: %.3fs."%(end-start))
149 | 
150 | 
151 | 
152 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet/calc_accuracy.py:
--------------------------------------------------------------------------------
 1 | import os, sys, time
 2 | 
 3 | lines = [line.strip() for line in open(sys.argv[1],"r").readlines()]
 4 | correct=0
 5 | for line in lines:
 6 | 	truth=line.split("/")[6]
 7 | 	predict=line.split(" ")[3]
 8 | 	if truth==predict:
 9 | 		correct+=1
10 | print "accuracy=%s"%(float(correct)/len(lines))
11 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet/generate_data.sh:
--------------------------------------------------------------------------------
1 | python GenerateMXNET.py /media/haria/data/data/vgg_face/ train.rec test.rec 227 0.8
2 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet/mxnet_predict_example.py:
--------------------------------------------------------------------------------
  1 | import sys, os, time
  2 | import subprocess
  3 | import threading
  4 | curr_path = os.path.dirname(os.path.abspath(os.path.expanduser(__file__)))
  5 | sys.path.append("~/mxnet/amalgamation/python/")
  6 | sys.path.append("~/mxnet/python/")
  7 | 
  8 | from mxnet_predict import Predictor, load_ndarray_file
  9 | import mxnet as mx
 10 | import logging
 11 | import numpy as np
 12 | from skimage import io, transform
 13 | # Load the pre-trained model
 14 | prefix = "./face-0"
 15 | num_round = 125
 16 | batch_size = 20
 17 | if len(sys.argv) >2:
 18 |     num_round = int(sys.argv[2])
 19 | symbol_file = "%s-symbol.json" % prefix
 20 | param_file = "%s-%s.params" % (prefix,str(num_round).zfill(4))
 21 | predictor = Predictor(open(symbol_file).read(), open(param_file).read(), {'data':(batch_size , 3, 224, 224)},'gpu',0)
 22 | mean_img = load_ndarray_file(open("./mean.bin").read())["mean_img"]
 23 | 
 24 | synset = [l.strip() for l in open('./labels.txt').readlines()]
 25 | 
 26 | def PreprocessImage(batchs, index, path, show_img=False):
 27 |     # load image
 28 |     img = io.imread(path)
 29 |     #print("Original Image Shape: ", img.shape)
 30 |     # we crop image from center
 31 |     short_egde = min(img.shape[:2])
 32 |     yy = int((img.shape[0] - short_egde) / 2)
 33 |     xx = int((img.shape[1] - short_egde) / 2)
 34 |     crop_img = img[yy : yy + short_egde, xx : xx + short_egde]
 35 |     # resize to 224, 224
 36 |     resized_img = transform.resize(crop_img, (224, 224))
 37 |     if show_img:
 38 |         io.imshow(resized_img)
 39 |     # convert to numpy.ndarray
 40 |     sample = np.asarray(resized_img) * 255
 41 |     # swap axes to make image from (224, 224, 3) to (3, 224, 224)
 42 |     sample = np.swapaxes(sample, 0, 2)
 43 |     sample = np.swapaxes(sample, 1, 2)
 44 | 
 45 |     # sub mean
 46 |     normed_img = sample - mean_img
 47 |     normed_img.resize(1, 3, 224, 224)
 48 |     
 49 |     batchs[index] = normed_img
 50 |     
 51 | 
 52 | if __name__=="__main__":
 53 |     imageList=[]
 54 |     if len(sys.argv) >1:
 55 |         folder=sys.argv[1]
 56 |         if os.path.isdir(folder):
 57 |             items= subprocess.check_output("tree -i -f %s|grep \.jpg"%folder,shell=True).strip().split("\n")
 58 |             imageList.extend(items)
 59 |         else:
 60 |             if os.path.exists(folder):
 61 |                 # its a image actually
 62 |                 imageList.append(folder)
 63 | 
 64 |     iters = len(imageList)/batch_size 
 65 |     if len(imageList)%batch_size >0:
 66 |         iters+=1
 67 |     for it in range(iters):
 68 | 
 69 |         # Get preprocessed batch (single image batch)
 70 |         batchs=np.ndarray(shape=[batch_size , 3, 224, 224])
 71 |         threads = []
 72 |         
 73 |         for index in range(batch_size):
 74 |             if it*batch_size+index <len(imageList):
 75 |                 t = threading.Thread(target=PreprocessImage,args=(batchs, index, imageList[it*batch_size+index], False))
 76 |                 t.start()
 77 |                 threads.append(t)
 78 |         
 79 |         for t in threads:
 80 |             t.join()
 81 |         start = time.time()
 82 |         predictor.forward(data=batchs)
 83 |         prob = predictor.get_output(0)
 84 |         for item in range(batch_size):
 85 |             pred = np.argsort(prob[item])[::-1]
 86 |             # Get top1 label
 87 |             top1 = synset[pred[0]],prob[item][pred[0]]
 88 |             if it*batch_size+item <len(imageList):
 89 |                 print  "top-1", imageList[it*batch_size+item], top1[0], top1[1] 
 90 |             # Get top5 label
 91 |             #top5 = [(synset[pred[i]],prob[item][pred[i]]) for i in range(5)]
 92 |             #for index,topx in enumerate(top5):
 93 |             #    print "top-%d"%index, imageList[it*batch_size+item], topx[0], topx[1]
 94 |         print "time elapsed: %f."%((time.time()-start)/batch_size)
 95 |         '''
 96 |         pred = np.argsort(prob)[::-1]
 97 |         # Get top1 label
 98 |         top1 = synset[pred[0]],prob[pred[0]]
 99 |         print image , top1[0], top1[1] , time.time()-start
100 |         # Get top5 label
101 |         #top5 = [(synset[pred[i]],prob[pred[i]]) for i in range(5)]
102 |         #for index,topx in enumerate(top5):
103 |         #    print index, topx[0], topx[1]
104 |         '''
105 | 
106 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet/symbol_squeezenet.py:
--------------------------------------------------------------------------------
 1 | import mxnet as mx
 2 | 
 3 | def get_symbol(num_classes = 1000):
 4 |     data = mx.symbol.Variable(name='data')
 5 |     conv1 = mx.symbol.Convolution(name='conv1', data=data , num_filter=96, pad=(0,0), kernel=(7,7), stride=(2,2), no_bias=False)
 6 |     relu_conv1 = mx.symbol.Activation(name='relu_conv1', data=conv1 , act_type='relu')
 7 |     pool1 = mx.symbol.Pooling(name='pool1', data=relu_conv1 , pad=(0,0), kernel=(3,3), stride=(2,2), pool_type='max')
 8 |     fire2_squeeze1x1 = mx.symbol.Convolution(name='fire2_squeeze1x1', data=pool1 , num_filter=16, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
 9 |     fire2_relu_squeeze1x1 = mx.symbol.Activation(name='fire2_relu_squeeze1x1', data=fire2_squeeze1x1 , act_type='relu')
10 |     fire2_expand1x1 = mx.symbol.Convolution(name='fire2_expand1x1', data=fire2_relu_squeeze1x1 , num_filter=64, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
11 |     fire2_relu_expand1x1 = mx.symbol.Activation(name='fire2_relu_expand1x1', data=fire2_expand1x1 , act_type='relu')
12 |     fire2_expand3x3 = mx.symbol.Convolution(name='fire2_expand3x3', data=fire2_relu_squeeze1x1 , num_filter=64, pad=(1,1), kernel=(3,3), stride=(1,1), no_bias=False)
13 |     fire2_relu_expand3x3 = mx.symbol.Activation(name='fire2_relu_expand3x3', data=fire2_expand3x3 , act_type='relu')
14 |     fire2_concat = mx.symbol.Concat(name='fire2_concat', *[fire2_relu_expand1x1,fire2_relu_expand3x3] )
15 |     fire3_squeeze1x1 = mx.symbol.Convolution(name='fire3_squeeze1x1', data=fire2_concat , num_filter=16, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
16 |     fire3_relu_squeeze1x1 = mx.symbol.Activation(name='fire3_relu_squeeze1x1', data=fire3_squeeze1x1 , act_type='relu')
17 |     fire3_expand1x1 = mx.symbol.Convolution(name='fire3_expand1x1', data=fire3_relu_squeeze1x1 , num_filter=64, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
18 |     fire3_relu_expand1x1 = mx.symbol.Activation(name='fire3_relu_expand1x1', data=fire3_expand1x1 , act_type='relu')
19 |     fire3_expand3x3 = mx.symbol.Convolution(name='fire3_expand3x3', data=fire3_relu_squeeze1x1 , num_filter=64, pad=(1,1), kernel=(3,3), stride=(1,1), no_bias=False)
20 |     fire3_relu_expand3x3 = mx.symbol.Activation(name='fire3_relu_expand3x3', data=fire3_expand3x3 , act_type='relu')
21 |     fire3_concat = mx.symbol.Concat(name='fire3_concat', *[fire3_relu_expand1x1,fire3_relu_expand3x3] )
22 |     fire4_squeeze1x1 = mx.symbol.Convolution(name='fire4_squeeze1x1', data=fire3_concat , num_filter=32, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
23 |     fire4_relu_squeeze1x1 = mx.symbol.Activation(name='fire4_relu_squeeze1x1', data=fire4_squeeze1x1 , act_type='relu')
24 |     fire4_expand1x1 = mx.symbol.Convolution(name='fire4_expand1x1', data=fire4_relu_squeeze1x1 , num_filter=128, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
25 |     fire4_relu_expand1x1 = mx.symbol.Activation(name='fire4_relu_expand1x1', data=fire4_expand1x1 , act_type='relu')
26 |     fire4_expand3x3 = mx.symbol.Convolution(name='fire4_expand3x3', data=fire4_relu_squeeze1x1 , num_filter=128, pad=(1,1), kernel=(3,3), stride=(1,1), no_bias=False)
27 |     fire4_relu_expand3x3 = mx.symbol.Activation(name='fire4_relu_expand3x3', data=fire4_expand3x3 , act_type='relu')
28 |     fire4_concat = mx.symbol.Concat(name='fire4_concat', *[fire4_relu_expand1x1,fire4_relu_expand3x3] )
29 |     pool4 = mx.symbol.Pooling(name='pool4', data=fire4_concat , pad=(0,0), kernel=(3,3), stride=(2,2), pool_type='max')
30 |     fire5_squeeze1x1 = mx.symbol.Convolution(name='fire5_squeeze1x1', data=pool4 , num_filter=32, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
31 |     fire5_relu_squeeze1x1 = mx.symbol.Activation(name='fire5_relu_squeeze1x1', data=fire5_squeeze1x1 , act_type='relu')
32 |     fire5_expand1x1 = mx.symbol.Convolution(name='fire5_expand1x1', data=fire5_relu_squeeze1x1 , num_filter=128, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
33 |     fire5_relu_expand1x1 = mx.symbol.Activation(name='fire5_relu_expand1x1', data=fire5_expand1x1 , act_type='relu')
34 |     fire5_expand3x3 = mx.symbol.Convolution(name='fire5_expand3x3', data=fire5_relu_squeeze1x1 , num_filter=128, pad=(1,1), kernel=(3,3), stride=(1,1), no_bias=False)
35 |     fire5_relu_expand3x3 = mx.symbol.Activation(name='fire5_relu_expand3x3', data=fire5_expand3x3 , act_type='relu')
36 |     fire5_concat = mx.symbol.Concat(name='fire5_concat', *[fire5_relu_expand1x1,fire5_relu_expand3x3] )
37 |     fire6_squeeze1x1 = mx.symbol.Convolution(name='fire6_squeeze1x1', data=fire5_concat , num_filter=48, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
38 |     fire6_relu_squeeze1x1 = mx.symbol.Activation(name='fire6_relu_squeeze1x1', data=fire6_squeeze1x1 , act_type='relu')
39 |     fire6_expand1x1 = mx.symbol.Convolution(name='fire6_expand1x1', data=fire6_relu_squeeze1x1 , num_filter=192, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
40 |     fire6_relu_expand1x1 = mx.symbol.Activation(name='fire6_relu_expand1x1', data=fire6_expand1x1 , act_type='relu')
41 |     fire6_expand3x3 = mx.symbol.Convolution(name='fire6_expand3x3', data=fire6_relu_squeeze1x1 , num_filter=192, pad=(1,1), kernel=(3,3), stride=(1,1), no_bias=False)
42 |     fire6_relu_expand3x3 = mx.symbol.Activation(name='fire6_relu_expand3x3', data=fire6_expand3x3 , act_type='relu')
43 |     fire6_concat = mx.symbol.Concat(name='fire6_concat', *[fire6_relu_expand1x1,fire6_relu_expand3x3] )
44 |     fire7_squeeze1x1 = mx.symbol.Convolution(name='fire7_squeeze1x1', data=fire6_concat , num_filter=48, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
45 |     fire7_relu_squeeze1x1 = mx.symbol.Activation(name='fire7_relu_squeeze1x1', data=fire7_squeeze1x1 , act_type='relu')
46 |     fire7_expand1x1 = mx.symbol.Convolution(name='fire7_expand1x1', data=fire7_relu_squeeze1x1 , num_filter=192, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
47 |     fire7_relu_expand1x1 = mx.symbol.Activation(name='fire7_relu_expand1x1', data=fire7_expand1x1 , act_type='relu')
48 |     fire7_expand3x3 = mx.symbol.Convolution(name='fire7_expand3x3', data=fire7_relu_squeeze1x1 , num_filter=192, pad=(1,1), kernel=(3,3), stride=(1,1), no_bias=False)
49 |     fire7_relu_expand3x3 = mx.symbol.Activation(name='fire7_relu_expand3x3', data=fire7_expand3x3 , act_type='relu')
50 |     fire7_concat = mx.symbol.Concat(name='fire7_concat', *[fire7_relu_expand1x1,fire7_relu_expand3x3] )
51 |     fire8_squeeze1x1 = mx.symbol.Convolution(name='fire8_squeeze1x1', data=fire7_concat , num_filter=64, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
52 |     fire8_relu_squeeze1x1 = mx.symbol.Activation(name='fire8_relu_squeeze1x1', data=fire8_squeeze1x1 , act_type='relu')
53 |     fire8_expand1x1 = mx.symbol.Convolution(name='fire8_expand1x1', data=fire8_relu_squeeze1x1 , num_filter=256, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
54 |     fire8_relu_expand1x1 = mx.symbol.Activation(name='fire8_relu_expand1x1', data=fire8_expand1x1 , act_type='relu')
55 |     fire8_expand3x3 = mx.symbol.Convolution(name='fire8_expand3x3', data=fire8_relu_squeeze1x1 , num_filter=256, pad=(1,1), kernel=(3,3), stride=(1,1), no_bias=False)
56 |     fire8_relu_expand3x3 = mx.symbol.Activation(name='fire8_relu_expand3x3', data=fire8_expand3x3 , act_type='relu')
57 |     fire8_concat = mx.symbol.Concat(name='fire8_concat', *[fire8_relu_expand1x1,fire8_relu_expand3x3] )
58 |     pool8 = mx.symbol.Pooling(name='pool8', data=fire8_concat , pad=(0,0), kernel=(3,3), stride=(2,2), pool_type='max')
59 |     fire9_squeeze1x1 = mx.symbol.Convolution(name='fire9_squeeze1x1', data=pool8 , num_filter=64, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
60 |     fire9_relu_squeeze1x1 = mx.symbol.Activation(name='fire9_relu_squeeze1x1', data=fire9_squeeze1x1 , act_type='relu')
61 |     fire9_expand1x1 = mx.symbol.Convolution(name='fire9_expand1x1', data=fire9_relu_squeeze1x1 , num_filter=256, pad=(0,0), kernel=(1,1), stride=(1,1), no_bias=False)
62 |     fire9_relu_expand1x1 = mx.symbol.Activation(name='fire9_relu_expand1x1', data=fire9_expand1x1 , act_type='relu')
63 |     fire9_expand3x3 = mx.symbol.Convolution(name='fire9_expand3x3', data=fire9_relu_squeeze1x1 , num_filter=256, pad=(1,1), kernel=(3,3), stride=(1,1), no_bias=False)
64 |     fire9_relu_expand3x3 = mx.symbol.Activation(name='fire9_relu_expand3x3', data=fire9_expand3x3 , act_type='relu')
65 |     fire9_concat = mx.symbol.Concat(name='fire9_concat', *[fire9_relu_expand1x1,fire9_relu_expand3x3] )
66 |     drop9 = mx.symbol.Dropout(name='drop9', data=fire9_concat , p=0.500000)
67 |     conv10 = mx.symbol.Convolution(name='conv10', data=drop9 , num_filter=num_classes, pad=(1,1), kernel=(1,1), stride=(1,1), no_bias=False)
68 |     relu_conv10 = mx.symbol.Activation(name='relu_conv10', data=conv10 , act_type='relu')
69 |     pool10 = mx.symbol.Pooling(name='pool10', data=relu_conv10 , pad=(0,0), kernel=(0,0), stride=(1,1), pool_type='avg')
70 |     flatten = mx.symbol.Flatten(data=pool10, name='flatten')
71 |     softmax = mx.symbol.SoftmaxOutput(name='softmax', data=flatten )
72 | 
73 |     return prob
74 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet/test_squeezenet.sh:
--------------------------------------------------------------------------------
1 | export PYTHONPATH=$PYTHONPATH:~/mxnet/python:~/mxnet/amalgamation/python/
2 | python mxnet_predict_example.py $1 $2
3 | 
4 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet/train.py:
--------------------------------------------------------------------------------
 1 | import mxnet as mx
 2 | import argparse
 3 | import os, sys
 4 | import train_model
 5 | 
 6 | parser = argparse.ArgumentParser(description='train an image classifer on cifar10')
 7 | parser.add_argument('--network', type=str, default='inception-bn-28-small',
 8 |                     help = 'the cnn to use')
 9 | parser.add_argument('--data-dir', type=str, default='cifar10/',
10 |                     help='the input data directory')
11 | parser.add_argument('--gpus', type=str, default='0',
12 |                     help='the gpus will be used, e.g "0,1,2,3"')
13 | parser.add_argument('--num-examples', type=int, default=60000,
14 |                     help='the number of training examples')
15 | parser.add_argument('--num-classes', type=int, default=1000,
16 |                     help='the number of classes')
17 | parser.add_argument('--batch-size', type=int, default=128,
18 |                     help='the batch size')
19 | parser.add_argument('--lr', type=float, default=.05,
20 |                     help='the initial learning rate')
21 | parser.add_argument('--lr-factor', type=float, default=1,
22 |                     help='times the lr with a factor for every lr-factor-epoch epoch')
23 | parser.add_argument('--lr-factor-epoch', type=float, default=1,
24 |                     help='the number of epoch to factor the lr, could be .5')
25 | parser.add_argument('--model-prefix', type=str,
26 |                     help='the prefix of the model to load/save')
27 | parser.add_argument('--num-epochs', type=int, default=20,
28 |                     help='the number of training epochs')
29 | parser.add_argument('--load-epoch', type=int,
30 |                     help="load the model on an epoch using the model-prefix")
31 | parser.add_argument('--kv-store', type=str, default='local',
32 |                     help='the kvstore type')
33 | parser.add_argument('--data-shape', type=int, default=227,
34 |                     help='set image\'s shape')
35 | args = parser.parse_args()
36 | 
37 | # network
38 | import importlib
39 | net = importlib.import_module('symbol_' + args.network).get_symbol(args.num_classes)
40 | 
41 | # data
42 | def get_iterator(args, kv):
43 |     data_shape = (3, args.data_shape, args.data_shape)
44 | 
45 |     train = mx.io.ImageRecordIter(
46 |         path_imgrec = args.data_dir + "train.rec",
47 |         mean_img    = args.data_dir + "mean.bin",
48 |         data_shape  = data_shape,
49 |         batch_size  = args.batch_size,
50 |         rand_crop   = True,
51 |         rand_mirror = True,
52 |         num_parts   = kv.num_workers,
53 |         part_index  = kv.rank)
54 | 
55 |     val = mx.io.ImageRecordIter(
56 |         path_imgrec = args.data_dir + "test.rec",
57 |         mean_img    = args.data_dir + "mean.bin",
58 |         rand_crop   = False,
59 |         rand_mirror = False,
60 |         data_shape  = data_shape,
61 |         batch_size  = args.batch_size,
62 |         num_parts   = kv.num_workers,
63 |         part_index  = kv.rank)
64 | 
65 |     return (train, val)
66 | 
67 | # train
68 | train_model.fit(args, net, get_iterator)
69 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet/train_model.py:
--------------------------------------------------------------------------------
 1 | import mxnet as mx
 2 | import logging
 3 | import os
 4 | 
 5 | def fit(args, network, data_loader):
 6 |     # kvstore
 7 |     kv = mx.kvstore.create(args.kv_store)
 8 | 
 9 |     # logging
10 |     head = '%(asctime)-15s Node[' + str(kv.rank) + '] %(message)s'
11 |     if 'log_file' in args and args.log_file is not None:
12 |         log_file = args.log_file
13 |         log_dir = args.log_dir
14 |         log_file_full_name = os.path.join(log_dir, log_file)
15 |         if not os.path.exists(log_dir): 
16 |             os.mkdir(log_dir)
17 |         logger = logging.getLogger()
18 |         handler = logging.FileHandler(log_file_full_name)
19 |         formatter = logging.Formatter(head)
20 |         handler.setFormatter(formatter)
21 |         logger.addHandler(handler)
22 |         logger.setLevel(logging.DEBUG)
23 |         logger.info('start with arguments %s', args)
24 |     else:
25 |         logging.basicConfig(level=logging.DEBUG, format=head)
26 |         logging.info('start with arguments %s', args)
27 | 
28 |     # load model
29 |     model_prefix = args.model_prefix
30 |     if model_prefix is not None:
31 |         model_prefix += "-%d" % (kv.rank)
32 |     model_args = {}
33 |     if args.load_epoch is not None:
34 |         assert model_prefix is not None
35 |         tmp = mx.model.FeedForward.load(model_prefix, args.load_epoch)
36 |         model_args = {'arg_params' : tmp.arg_params,
37 |                       'aux_params' : tmp.aux_params,
38 |                       'begin_epoch' : args.load_epoch}
39 |     # save model
40 |     checkpoint = None if model_prefix is None else mx.callback.do_checkpoint(model_prefix)
41 | 
42 |     # data
43 |     (train, val) = data_loader(args, kv)
44 | 
45 |     # train
46 |     devs = mx.cpu() if args.gpus is None else [
47 |         mx.gpu(int(i)) for i in args.gpus.split(',')]
48 | 
49 |     epoch_size = args.num_examples / args.batch_size
50 | 
51 |     if args.kv_store == 'dist_sync':
52 |         epoch_size /= kv.num_workers
53 |         model_args['epoch_size'] = epoch_size
54 | 
55 |     if 'lr_factor' in args and args.lr_factor < 1:
56 |         model_args['lr_scheduler'] = mx.lr_scheduler.FactorScheduler(
57 |             step = max(int(epoch_size * args.lr_factor_epoch), 1),
58 |             factor = args.lr_factor)
59 | 
60 |     if 'clip_gradient' in args and args.clip_gradient is not None:
61 |         model_args['clip_gradient'] = args.clip_gradient
62 | 
63 |     # disable kvstore for single device
64 |     if 'local' in kv.type and (
65 |             args.gpus is None or len(args.gpus.split(',')) is 1):
66 |         kv = None
67 | 
68 |     model = mx.model.FeedForward(
69 |         ctx                = devs,
70 |         symbol             = network,
71 |         num_epoch          = args.num_epochs,
72 |         learning_rate      = args.lr,
73 |         momentum           = 0.9,
74 |         #wd                 = 0.00001,
75 |         #initializer        = mx.init.Xavier(factor_type="in", magnitude=2.34),
76 |         wd                 = 0.0001,
77 |         initializer        = mx.init.Xavier(rnd_type="gaussian", factor_type="in", magnitude=2.0),
78 |         **model_args)
79 | 
80 |     model.fit(
81 |         X                  = train,
82 |         eval_data          = val,
83 |         kvstore            = kv,
84 |         batch_end_callback = mx.callback.Speedometer(args.batch_size, 50),
85 |         epoch_end_callback = checkpoint)
86 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet/train_squeezenet.sh:
--------------------------------------------------------------------------------
 1 | #./run.sh /media/haria/data/data/vgg_face/ 28
 2 | export PYTHONPATH=$PYTHONPATH:~/mxnet/python:~/mxnet/amalgamation/python/
 3 | num_examples=`cat train.txt |wc -l`
 4 | num_classes=`cat labels.txt |wc -l`
 5 | epochs=200
 6 | batch_size=40
 7 | 
 8 | #python train.py --network squeezenet --num-examples $num_examples --num-classes $num_classes --model-prefix `pwd`/face  --data-dir `pwd`/ --batch-size $batch_size --load-epoch $epoch_first_stage --lr 0.01 --lr-factor 0.1 --lr-factor-epoch 25 --num-epoch $epochs
 9 | python train.py --network squeezenet --num-examples $num_examples --num-classes $num_classes --model-prefix `pwd`/face  --data-dir `pwd`/ --batch-size $batch_size --lr 0.1 --lr-factor 0.1 --lr-factor-epoch 50 --num-epoch $epochs
10 | 


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/squeezenet_v1.0.caffemodel:
--------------------------------------------------------------------------------
https://raw.githubusercontent.com/hariag/SqueezeNet/3ae4e4f38dfba19460346f99ebce37e7be288569/SqueezeNet_v1.0/squeezenet_v1.0.caffemodel


--------------------------------------------------------------------------------
/SqueezeNet_v1.0/train_val.prototxt:
--------------------------------------------------------------------------------
  1 | # please cite:
  2 | # @article{SqueezeNet,
  3 | #     Author = {Forrest N. Iandola and Matthew W. Moskewicz and Khalid Ashraf and Song Han and William J. Dally and Kurt Keutzer},
  4 | #     Title = {SqueezeNet: AlexNet-level accuracy with 50x fewer parameters and <1MB model size},
  5 | #     Journal = {arXiv:1602.07360},
  6 | #     Year = {2016}
  7 | # }
  8 | layer {
  9 |   name: "data"
 10 |   type: "Data"
 11 |   top: "data"
 12 |   top: "label"
 13 |   include {
 14 |     phase: TRAIN
 15 |   }
 16 |   transform_param {
 17 |     crop_size: 227
 18 |     mean_value: 104
 19 |     mean_value: 117
 20 |     mean_value: 123
 21 |   }
 22 |   data_param {
 23 |     source: "examples/imagenet/ilsvrc12_train_lmdb"
 24 |     batch_size: 32 #*iter_size
 25 |     backend: LMDB
 26 |   }
 27 | }
 28 | layer {
 29 |   name: "data"
 30 |   type: "Data"
 31 |   top: "data"
 32 |   top: "label"
 33 |   include {
 34 |     phase: TEST
 35 |   }
 36 |   transform_param {
 37 |     crop_size: 227
 38 |     mean_value: 104
 39 |     mean_value: 117
 40 |     mean_value: 123
 41 |   }
 42 |   data_param {
 43 |     source: "examples/imagenet/ilsvrc12_val_lmdb"
 44 |     batch_size: 25 #not *iter_size
 45 |     backend: LMDB
 46 |   }
 47 | }
 48 | layer {
 49 |   name: "conv1"
 50 |   type: "Convolution"
 51 |   bottom: "data"
 52 |   top: "conv1"
 53 |   convolution_param {
 54 |     num_output: 96
 55 |     kernel_size: 7
 56 |     stride: 2
 57 |     weight_filler {
 58 |       type: "xavier"
 59 |     }
 60 |   }
 61 | }
 62 | layer {
 63 |   name: "relu_conv1"
 64 |   type: "ReLU"
 65 |   bottom: "conv1"
 66 |   top: "conv1"
 67 | }
 68 | layer {
 69 |   name: "pool1"
 70 |   type: "Pooling"
 71 |   bottom: "conv1"
 72 |   top: "pool1"
 73 |   pooling_param {
 74 |     pool: MAX
 75 |     kernel_size: 3
 76 |     stride: 2
 77 |   }
 78 | }
 79 | layer {
 80 |   name: "fire2/squeeze1x1"
 81 |   type: "Convolution"
 82 |   bottom: "pool1"
 83 |   top: "fire2/squeeze1x1"
 84 |   convolution_param {
 85 |     num_output: 16
 86 |     kernel_size: 1
 87 |     weight_filler {
 88 |       type: "xavier"
 89 |     }
 90 |   }
 91 | }
 92 | layer {
 93 |   name: "fire2/relu_squeeze1x1"
 94 |   type: "ReLU"
 95 |   bottom: "fire2/squeeze1x1"
 96 |   top: "fire2/squeeze1x1"
 97 | }
 98 | layer {
 99 |   name: "fire2/expand1x1"
100 |   type: "Convolution"
101 |   bottom: "fire2/squeeze1x1"
102 |   top: "fire2/expand1x1"
103 |   convolution_param {
104 |     num_output: 64
105 |     kernel_size: 1
106 |     weight_filler {
107 |       type: "xavier"
108 |     }
109 |   }
110 | }
111 | layer {
112 |   name: "fire2/relu_expand1x1"
113 |   type: "ReLU"
114 |   bottom: "fire2/expand1x1"
115 |   top: "fire2/expand1x1"
116 | }
117 | layer {
118 |   name: "fire2/expand3x3"
119 |   type: "Convolution"
120 |   bottom: "fire2/squeeze1x1"
121 |   top: "fire2/expand3x3"
122 |   convolution_param {
123 |     num_output: 64
124 |     pad: 1
125 |     kernel_size: 3
126 |     weight_filler {
127 |       type: "xavier"
128 |     }
129 |   }
130 | }
131 | layer {
132 |   name: "fire2/relu_expand3x3"
133 |   type: "ReLU"
134 |   bottom: "fire2/expand3x3"
135 |   top: "fire2/expand3x3"
136 | }
137 | layer {
138 |   name: "fire2/concat"
139 |   type: "Concat"
140 |   bottom: "fire2/expand1x1"
141 |   bottom: "fire2/expand3x3"
142 |   top: "fire2/concat"
143 | }
144 | layer {
145 |   name: "fire3/squeeze1x1"
146 |   type: "Convolution"
147 |   bottom: "fire2/concat"
148 |   top: "fire3/squeeze1x1"
149 |   convolution_param {
150 |     num_output: 16
151 |     kernel_size: 1
152 |     weight_filler {
153 |       type: "xavier"
154 |     }
155 |   }
156 | }
157 | layer {
158 |   name: "fire3/relu_squeeze1x1"
159 |   type: "ReLU"
160 |   bottom: "fire3/squeeze1x1"
161 |   top: "fire3/squeeze1x1"
162 | }
163 | layer {
164 |   name: "fire3/expand1x1"
165 |   type: "Convolution"
166 |   bottom: "fire3/squeeze1x1"
167 |   top: "fire3/expand1x1"
168 |   convolution_param {
169 |     num_output: 64
170 |     kernel_size: 1
171 |     weight_filler {
172 |       type: "xavier"
173 |     }
174 |   }
175 | }
176 | layer {
177 |   name: "fire3/relu_expand1x1"
178 |   type: "ReLU"
179 |   bottom: "fire3/expand1x1"
180 |   top: "fire3/expand1x1"
181 | }
182 | layer {
183 |   name: "fire3/expand3x3"
184 |   type: "Convolution"
185 |   bottom: "fire3/squeeze1x1"
186 |   top: "fire3/expand3x3"
187 |   convolution_param {
188 |     num_output: 64
189 |     pad: 1
190 |     kernel_size: 3
191 |     weight_filler {
192 |       type: "xavier"
193 |     }
194 |   }
195 | }
196 | layer {
197 |   name: "fire3/relu_expand3x3"
198 |   type: "ReLU"
199 |   bottom: "fire3/expand3x3"
200 |   top: "fire3/expand3x3"
201 | }
202 | layer {
203 |   name: "fire3/concat"
204 |   type: "Concat"
205 |   bottom: "fire3/expand1x1"
206 |   bottom: "fire3/expand3x3"
207 |   top: "fire3/concat"
208 | }
209 | layer {
210 |   name: "fire4/squeeze1x1"
211 |   type: "Convolution"
212 |   bottom: "fire3/concat"
213 |   top: "fire4/squeeze1x1"
214 |   convolution_param {
215 |     num_output: 32
216 |     kernel_size: 1
217 |     weight_filler {
218 |       type: "xavier"
219 |     }
220 |   }
221 | }
222 | layer {
223 |   name: "fire4/relu_squeeze1x1"
224 |   type: "ReLU"
225 |   bottom: "fire4/squeeze1x1"
226 |   top: "fire4/squeeze1x1"
227 | }
228 | layer {
229 |   name: "fire4/expand1x1"
230 |   type: "Convolution"
231 |   bottom: "fire4/squeeze1x1"
232 |   top: "fire4/expand1x1"
233 |   convolution_param {
234 |     num_output: 128
235 |     kernel_size: 1
236 |     weight_filler {
237 |       type: "xavier"
238 |     }
239 |   }
240 | }
241 | layer {
242 |   name: "fire4/relu_expand1x1"
243 |   type: "ReLU"
244 |   bottom: "fire4/expand1x1"
245 |   top: "fire4/expand1x1"
246 | }
247 | layer {
248 |   name: "fire4/expand3x3"
249 |   type: "Convolution"
250 |   bottom: "fire4/squeeze1x1"
251 |   top: "fire4/expand3x3"
252 |   convolution_param {
253 |     num_output: 128
254 |     pad: 1
255 |     kernel_size: 3
256 |     weight_filler {
257 |       type: "xavier"
258 |     }
259 |   }
260 | }
261 | layer {
262 |   name: "fire4/relu_expand3x3"
263 |   type: "ReLU"
264 |   bottom: "fire4/expand3x3"
265 |   top: "fire4/expand3x3"
266 | }
267 | layer {
268 |   name: "fire4/concat"
269 |   type: "Concat"
270 |   bottom: "fire4/expand1x1"
271 |   bottom: "fire4/expand3x3"
272 |   top: "fire4/concat"
273 | }
274 | layer {
275 |   name: "pool4"
276 |   type: "Pooling"
277 |   bottom: "fire4/concat"
278 |   top: "pool4"
279 |   pooling_param {
280 |     pool: MAX
281 |     kernel_size: 3
282 |     stride: 2
283 |   }
284 | }
285 | layer {
286 |   name: "fire5/squeeze1x1"
287 |   type: "Convolution"
288 |   bottom: "pool4"
289 |   top: "fire5/squeeze1x1"
290 |   convolution_param {
291 |     num_output: 32
292 |     kernel_size: 1
293 |     weight_filler {
294 |       type: "xavier"
295 |     }
296 |   }
297 | }
298 | layer {
299 |   name: "fire5/relu_squeeze1x1"
300 |   type: "ReLU"
301 |   bottom: "fire5/squeeze1x1"
302 |   top: "fire5/squeeze1x1"
303 | }
304 | layer {
305 |   name: "fire5/expand1x1"
306 |   type: "Convolution"
307 |   bottom: "fire5/squeeze1x1"
308 |   top: "fire5/expand1x1"
309 |   convolution_param {
310 |     num_output: 128
311 |     kernel_size: 1
312 |     weight_filler {
313 |       type: "xavier"
314 |     }
315 |   }
316 | }
317 | layer {
318 |   name: "fire5/relu_expand1x1"
319 |   type: "ReLU"
320 |   bottom: "fire5/expand1x1"
321 |   top: "fire5/expand1x1"
322 | }
323 | layer {
324 |   name: "fire5/expand3x3"
325 |   type: "Convolution"
326 |   bottom: "fire5/squeeze1x1"
327 |   top: "fire5/expand3x3"
328 |   convolution_param {
329 |     num_output: 128
330 |     pad: 1
331 |     kernel_size: 3
332 |     weight_filler {
333 |       type: "xavier"
334 |     }
335 |   }
336 | }
337 | layer {
338 |   name: "fire5/relu_expand3x3"
339 |   type: "ReLU"
340 |   bottom: "fire5/expand3x3"
341 |   top: "fire5/expand3x3"
342 | }
343 | layer {
344 |   name: "fire5/concat"
345 |   type: "Concat"
346 |   bottom: "fire5/expand1x1"
347 |   bottom: "fire5/expand3x3"
348 |   top: "fire5/concat"
349 | }
350 | layer {
351 |   name: "fire6/squeeze1x1"
352 |   type: "Convolution"
353 |   bottom: "fire5/concat"
354 |   top: "fire6/squeeze1x1"
355 |   convolution_param {
356 |     num_output: 48
357 |     kernel_size: 1
358 |     weight_filler {
359 |       type: "xavier"
360 |     }
361 |   }
362 | }
363 | layer {
364 |   name: "fire6/relu_squeeze1x1"
365 |   type: "ReLU"
366 |   bottom: "fire6/squeeze1x1"
367 |   top: "fire6/squeeze1x1"
368 | }
369 | layer {
370 |   name: "fire6/expand1x1"
371 |   type: "Convolution"
372 |   bottom: "fire6/squeeze1x1"
373 |   top: "fire6/expand1x1"
374 |   convolution_param {
375 |     num_output: 192
376 |     kernel_size: 1
377 |     weight_filler {
378 |       type: "xavier"
379 |     }
380 |   }
381 | }
382 | layer {
383 |   name: "fire6/relu_expand1x1"
384 |   type: "ReLU"
385 |   bottom: "fire6/expand1x1"
386 |   top: "fire6/expand1x1"
387 | }
388 | layer {
389 |   name: "fire6/expand3x3"
390 |   type: "Convolution"
391 |   bottom: "fire6/squeeze1x1"
392 |   top: "fire6/expand3x3"
393 |   convolution_param {
394 |     num_output: 192
395 |     pad: 1
396 |     kernel_size: 3
397 |     weight_filler {
398 |       type: "xavier"
399 |     }
400 |   }
401 | }
402 | layer {
403 |   name: "fire6/relu_expand3x3"
404 |   type: "ReLU"
405 |   bottom: "fire6/expand3x3"
406 |   top: "fire6/expand3x3"
407 | }
408 | layer {
409 |   name: "fire6/concat"
410 |   type: "Concat"
411 |   bottom: "fire6/expand1x1"
412 |   bottom: "fire6/expand3x3"
413 |   top: "fire6/concat"
414 | }
415 | layer {
416 |   name: "fire7/squeeze1x1"
417 |   type: "Convolution"
418 |   bottom: "fire6/concat"
419 |   top: "fire7/squeeze1x1"
420 |   convolution_param {
421 |     num_output: 48
422 |     kernel_size: 1
423 |     weight_filler {
424 |       type: "xavier"
425 |     }
426 |   }
427 | }
428 | layer {
429 |   name: "fire7/relu_squeeze1x1"
430 |   type: "ReLU"
431 |   bottom: "fire7/squeeze1x1"
432 |   top: "fire7/squeeze1x1"
433 | }
434 | layer {
435 |   name: "fire7/expand1x1"
436 |   type: "Convolution"
437 |   bottom: "fire7/squeeze1x1"
438 |   top: "fire7/expand1x1"
439 |   convolution_param {
440 |     num_output: 192
441 |     kernel_size: 1
442 |     weight_filler {
443 |       type: "xavier"
444 |     }
445 |   }
446 | }
447 | layer {
448 |   name: "fire7/relu_expand1x1"
449 |   type: "ReLU"
450 |   bottom: "fire7/expand1x1"
451 |   top: "fire7/expand1x1"
452 | }
453 | layer {
454 |   name: "fire7/expand3x3"
455 |   type: "Convolution"
456 |   bottom: "fire7/squeeze1x1"
457 |   top: "fire7/expand3x3"
458 |   convolution_param {
459 |     num_output: 192
460 |     pad: 1
461 |     kernel_size: 3
462 |     weight_filler {
463 |       type: "xavier"
464 |     }
465 |   }
466 | }
467 | layer {
468 |   name: "fire7/relu_expand3x3"
469 |   type: "ReLU"
470 |   bottom: "fire7/expand3x3"
471 |   top: "fire7/expand3x3"
472 | }
473 | layer {
474 |   name: "fire7/concat"
475 |   type: "Concat"
476 |   bottom: "fire7/expand1x1"
477 |   bottom: "fire7/expand3x3"
478 |   top: "fire7/concat"
479 | }
480 | layer {
481 |   name: "fire8/squeeze1x1"
482 |   type: "Convolution"
483 |   bottom: "fire7/concat"
484 |   top: "fire8/squeeze1x1"
485 |   convolution_param {
486 |     num_output: 64
487 |     kernel_size: 1
488 |     weight_filler {
489 |       type: "xavier"
490 |     }
491 |   }
492 | }
493 | layer {
494 |   name: "fire8/relu_squeeze1x1"
495 |   type: "ReLU"
496 |   bottom: "fire8/squeeze1x1"
497 |   top: "fire8/squeeze1x1"
498 | }
499 | layer {
500 |   name: "fire8/expand1x1"
501 |   type: "Convolution"
502 |   bottom: "fire8/squeeze1x1"
503 |   top: "fire8/expand1x1"
504 |   convolution_param {
505 |     num_output: 256
506 |     kernel_size: 1
507 |     weight_filler {
508 |       type: "xavier"
509 |     }
510 |   }
511 | }
512 | layer {
513 |   name: "fire8/relu_expand1x1"
514 |   type: "ReLU"
515 |   bottom: "fire8/expand1x1"
516 |   top: "fire8/expand1x1"
517 | }
518 | layer {
519 |   name: "fire8/expand3x3"
520 |   type: "Convolution"
521 |   bottom: "fire8/squeeze1x1"
522 |   top: "fire8/expand3x3"
523 |   convolution_param {
524 |     num_output: 256
525 |     pad: 1
526 |     kernel_size: 3
527 |     weight_filler {
528 |       type: "xavier"
529 |     }
530 |   }
531 | }
532 | layer {
533 |   name: "fire8/relu_expand3x3"
534 |   type: "ReLU"
535 |   bottom: "fire8/expand3x3"
536 |   top: "fire8/expand3x3"
537 | }
538 | layer {
539 |   name: "fire8/concat"
540 |   type: "Concat"
541 |   bottom: "fire8/expand1x1"
542 |   bottom: "fire8/expand3x3"
543 |   top: "fire8/concat"
544 | }
545 | layer {
546 |   name: "pool8"
547 |   type: "Pooling"
548 |   bottom: "fire8/concat"
549 |   top: "pool8"
550 |   pooling_param {
551 |     pool: MAX
552 |     kernel_size: 3
553 |     stride: 2
554 |   }
555 | }
556 | layer {
557 |   name: "fire9/squeeze1x1"
558 |   type: "Convolution"
559 |   bottom: "pool8"
560 |   top: "fire9/squeeze1x1"
561 |   convolution_param {
562 |     num_output: 64
563 |     kernel_size: 1
564 |     weight_filler {
565 |       type: "xavier"
566 |     }
567 |   }
568 | }
569 | layer {
570 |   name: "fire9/relu_squeeze1x1"
571 |   type: "ReLU"
572 |   bottom: "fire9/squeeze1x1"
573 |   top: "fire9/squeeze1x1"
574 | }
575 | layer {
576 |   name: "fire9/expand1x1"
577 |   type: "Convolution"
578 |   bottom: "fire9/squeeze1x1"
579 |   top: "fire9/expand1x1"
580 |   convolution_param {
581 |     num_output: 256
582 |     kernel_size: 1
583 |     weight_filler {
584 |       type: "xavier"
585 |     }
586 |   }
587 | }
588 | layer {
589 |   name: "fire9/relu_expand1x1"
590 |   type: "ReLU"
591 |   bottom: "fire9/expand1x1"
592 |   top: "fire9/expand1x1"
593 | }
594 | layer {
595 |   name: "fire9/expand3x3"
596 |   type: "Convolution"
597 |   bottom: "fire9/squeeze1x1"
598 |   top: "fire9/expand3x3"
599 |   convolution_param {
600 |     num_output: 256
601 |     pad: 1
602 |     kernel_size: 3
603 |     weight_filler {
604 |       type: "xavier"
605 |     }
606 |   }
607 | }
608 | layer {
609 |   name: "fire9/relu_expand3x3"
610 |   type: "ReLU"
611 |   bottom: "fire9/expand3x3"
612 |   top: "fire9/expand3x3"
613 | }
614 | layer {
615 |   name: "fire9/concat"
616 |   type: "Concat"
617 |   bottom: "fire9/expand1x1"
618 |   bottom: "fire9/expand3x3"
619 |   top: "fire9/concat"
620 | }
621 | layer {
622 |   name: "drop9"
623 |   type: "Dropout"
624 |   bottom: "fire9/concat"
625 |   top: "fire9/concat"
626 |   dropout_param {
627 |     dropout_ratio: 0.5
628 |   }
629 | }
630 | layer {
631 |   name: "conv10"
632 |   type: "Convolution"
633 |   bottom: "fire9/concat"
634 |   top: "conv10"
635 |   convolution_param {
636 |     num_output: 1000
637 |     pad: 1
638 |     kernel_size: 1
639 |     weight_filler {
640 |       type: "gaussian"
641 |       mean: 0.0
642 |       std: 0.01
643 |     }
644 |   }
645 | }
646 | layer {
647 |   name: "relu_conv10"
648 |   type: "ReLU"
649 |   bottom: "conv10"
650 |   top: "conv10"
651 | }
652 | layer {
653 |   name: "pool10"
654 |   type: "Pooling"
655 |   bottom: "conv10"
656 |   top: "pool10"
657 |   pooling_param {
658 |     pool: AVE
659 |     global_pooling: true
660 |   }
661 | }
662 | layer {
663 |   name: "loss"
664 |   type: "SoftmaxWithLoss"
665 |   bottom: "pool10"
666 |   bottom: "label"
667 |   top: "loss"
668 |   include {
669 |     phase: TRAIN
670 |   }
671 | }
672 | layer {
673 |   name: "accuracy"
674 |   type: "Accuracy"
675 |   bottom: "pool10"
676 |   bottom: "label"
677 |   top: "accuracy"
678 |   include {
679 |     phase: TEST
680 |   }
681 | }
682 | layer {
683 |   name: "accuracy_top5"
684 |   type: "Accuracy"
685 |   bottom: "pool10"
686 |   bottom: "label"
687 |   top: "accuracy_top5"
688 |   include {
689 |     phase: TEST
690 |   }
691 |   accuracy_param {
692 |     top_k: 5
693 |   }
694 | }
695 | 


--------------------------------------------------------------------------------