update network scripts

scripts/networks/getImageNet.ssc

@@ -0,0 +1,53 @@
+
+val tt = "train";
+
+val imagenetroot = "/data/ImageNet/2012resized/"+tt+"/";
+val dataroot = "../../data/ImageNet/";
+val savefname = tt+"/part%04d.fmat.lz4";
+val labelfname = tt+"/label%04d.imat.lz4";
+val namesfname = tt+"/names%04d.csmat.txt";
+val loadtable = loadCSMat(dataroot+tt+".txt");
+
+val bsize = 1024;
+
+val nimgs = loadtable.nrows;
+
+val fnames = loadtable(?,0);
+val alllabels = loadtable(?,1).toIMat;
+
+val perm = randperm(nimgs);
+val mat = zeros(4 \ 256 \ 256 \ bsize);
+val labels = izeros(1, bsize);
+val names = CSMat(bsize,1);
+var i = 0;
+var jin = 0;
+while (jin < nimgs) {
+    val todo = math.min(bsize, nimgs - jin);
+    var j = 0;
+    while (j < todo && jin < nimgs) {
+	val indx = perm(jin);
+	try {
+	    val im = loadImage(imagenetroot+fnames(indx));
+	    mat(?,?,?,j) = im.toFMat;
+	    labels(0, j) = alllabels(indx);
+	    names(j) = fnames(indx);
+	    j += 1;
+	} catch {
+	    case e:Exception => println("\nProblem reading %s, continuing" format fnames(indx));
+	}
+	jin += 1;
+    }
+    if (j == bsize) {
+	saveFMat(dataroot+savefname format i, mat);
+	saveIMat(dataroot+labelfname format i, labels);
+	saveCSMat(dataroot+namesfname format i, names);
+    } else {
+	saveFMat(dataroot+savefname format i, mat.colslice(0,j));
+	saveIMat(dataroot+labelfname format i, labels.colslice(0,j));
+	saveCSMat(dataroot+namesfname format i, names(0->j,0));
+    }
+    i += 1;
+    print(".");
+}
+println("");
+

scripts/networks/getImageNetLabels.ssc

@@ -0,0 +1,29 @@
+:silent
+
+val tt = "train";
+
+val dataroot = "../../data/ImageNet/";
+val labelfname = dataroot+tt+"/label%04d.imat.lz4";
+val labelsout = dataroot+tt+"/labels%04d.fmat.lz4";
+
+val bsize = 1024;
+val nparts = 1252;
+
+print("\nComputing one-hot labels");
+val omat = zeros(1000,bsize);
+val coln = irow(0->bsize) *@ 1000;
+for (i <- 0 until nparts) {
+    val mat = loadIMat(labelfname format i);
+    omat.clear;
+    val inds = mat + coln(0,0->mat.ncols);
+    omat(inds) = 1f;
+    if (mat.ncols == bsize) {
+	saveFMat(labelsout format i, omat);
+    } else {
+	saveFMat(labelsout format i, omat.colslice(0,mat.ncols));
+    }
+    print(".");
+}
+println("");
+
+:silent

scripts/networks/getImageNetMeans.ssc

@@ -0,0 +1,41 @@
+:silent
+
+val tt = "train";
+
+val dataroot = "../../data/ImageNet/";
+val datafname = dataroot+tt+"/part%04d.fmat.lz4";
+val labelfname = dataroot+tt+"/label%04d.imat.lz4";
+val namesfname = dataroot+tt+"/names%04d.csmat.txt";
+
+val bsize = 1024;
+val nparts = 1252;
+
+val triminds = irow(16 -> 240);
+val trimcolors = irow(0,1,2);
+
+var nimgs = 0L;
+val msum = dzeros(3\224\224\1);
+
+print("\nComputing mean");
+val times = zeros(1,4)
+for (i <- 0 until nparts) {
+    tic;
+    val mat = loadFMat(datafname format i);
+    val t1 = toc;
+    val trim = mat(trimcolors, triminds, triminds, ?);
+    val t2 = toc;
+    val tmpsum = trim.sum(irow(3));
+    val t3 = toc;
+    msum ~ msum + DMat(tmpsum);
+    val t4 = toc;
+    times ~ times + row(t1,t2-t1,t3-t2,t4-t3);
+    nimgs = nimgs + trim.ncols;
+    print(".");
+}
+println("");
+
+msum ~ msum / nimgs.toDouble;
+val means = FMat(msum);
+saveFMat(dataroot+tt+"/means.fmat.lz4", means);
+
+:silent

scripts/networks/testConv.ssc

@@ -20,48 +20,48 @@ opts.lookahead = 0;
 import BIDMach.networks.layers.Node._;
 
 val in = input;
-val crop1 = crop(in);
+val crop1 = crop(in)(sizes=irow(3,224,224,0),offsets=irow(0,-1,-1,-1));
 val means1 = constant(means);
 
 val diff2 = crop1 - means1;
-val fmt2 = format(diff2);
+val fmt2 = format(diff2)();
 
 val conv3 = conv(fmt2)(w=7,h=7,nch=64,stride=4,pad=3);
-val bns3 = batchNormScale(conv3);
+val bns3 = batchNormScale(conv3)();
 val relu3 = relu(bns3);
 
 val conv4 = conv(relu3)(w=5,h=5,nch=256,stride=2,pad=2);
-val bns4 = batchNormScale(conv4);
+val bns4 = batchNormScale(conv4)();
 val relu4 = relu(bns4);
 
 val conv5 = conv(relu4)(w=3,h=3,nch=256,stride=1,pad=1);
-val bns5 = batchNormScale(conv5);
+val bns5 = batchNormScale(conv5)();
 val relu5 = relu(bns5);
 
 val conv6 = conv(relu5)(w=5,h=5,nch=1024,stride=2,pad=2);
-val bns6 = batchNormScale(conv6);
+val bns6 = batchNormScale(conv6)();
 val relu6 = relu(bns6);
 
 val conv7 = conv(relu6)(w=3,h=3,nch=1024,stride=1,pad=1);
-val bns7 = batchNormScale(conv7);
+val bns7 = batchNormScale(conv7)();
 val relu7 = relu(bns7);
 
 val conv8 = conv(relu7)(w=3,h=3,nch=1024,stride=1,pad=1);
-val bns8 = batchNormScale(conv8);
+val bns8 = batchNormScale(conv8)();
 val relu8 = relu(bns8);
 
-val fc9 = lin(relu8)(outdim=4096);
-val relu9 = relu(fc8);
+val fc9 = linear(relu8)(outdim=4096);
+val relu9 = relu(fc9);
 
-val fc10 = lin(relu9)(outdim=4096);
+val fc10 = linear(relu9)(outdim=4096);
 val relu10 = relu(fc10);
 
-val fc11 = lin(relu10)(outdim=1000);
+val fc11 = linear(relu10)(outdim=1000);
 val out = glm(fc11)(opts.links);
 
-val nodes = in     \ diff2   \ conv3  \ conv4  \ conv5  \ conv6  \ conv7  \ conv8  \ fc9    \ fc10    \ fc11 on
-            crop1  \ fmt2    \ bns3   \ bns4   \ bns5   \ bns6   \ bns7   \ bns8   \ relu9  \ relu10  \ out  on
-            means1 \ null    \ relu3  \ relu4  \ relu5  \ relu6  \ relu7  \ relu8  \ null   \ null    \ null;
+val nodes = (in     \ diff2   \ conv3  \ conv4  \ conv5  \ conv6  \ conv7  \ conv8  \ fc9    \ fc10    \ fc11  on 
+             crop1  \ fmt2    \ bns3   \ bns4   \ bns5   \ bns6   \ bns7   \ bns8   \ relu9  \ relu10  \ out   on
+             means1 \ null    \ relu3  \ relu4  \ relu5  \ relu6  \ relu7  \ relu8  \ null   \ null    \ null  );
 
 
 opts.nodemat = nodes;