siamese-lasagne-theano.py

# Run on GPU: THEANO_FLAGS=mode=FAST_RUN,device=gpu,floatX=float32 python mnist_siamese_graph.py
from __future__ import print_function

import sys
import os
import time
import numpy as np
import theano
import theano.tensor as T
import lasagne
import utils 
from progressbar import AnimatedMarker, Bar, BouncingBar, Counter, ETA, \
    FileTransferSpeed, FormatLabel, Percentage, \
    ProgressBar, ReverseBar, RotatingMarker, \
    SimpleProgress, Timer
import matplotlib.pyplot as plt
from matplotlib import gridspec
import cPickle as pickle
import time
from sklearn import metrics
from scipy import interpolate
from lasagne.regularization import regularize_layer_params_weighted, l2, l1
from lasagne.regularization import regularize_layer_params
 
NUM_EPOCHS = 40
BATCH_SIZE = 100
LEARNING_RATE = 0.001
MOMENTUM = 0.9

# def build_cnn(input_var=None):
#     net = lasagne.layers.InputLayer(shape=(None, 1, 64, 64),
#                                         input_var=input_var)
#     cnn1 = lasagne.layers.Conv2DLayer(
#             net, num_filters=96, filter_size=(7, 7),
#             nonlinearity=lasagne.nonlinearities.rectify,
#             W=lasagne.init.GlorotNormal())
#     pool1 = lasagne.layers.MaxPool2DLayer(cnn1, pool_size=(2, 2))
#     cnn2 = lasagne.layers.Conv2DLayer(
#             pool1, num_filters=64, filter_size=(6, 6),
#             nonlinearity=lasagne.nonlinearities.rectify,
#             W=lasagne.init.GlorotNormal())
#     fc1 = lasagne.layers.DenseLayer(cnn2, num_units=128)
#     # network = lasagne.layers.FlattenLayer(fc1)
#     return fc1

def build_cnn(input_var=None):
    net = lasagne.layers.InputLayer(shape=(None, 1, 64, 64),
                                        input_var=input_var)
    cnn1 = lasagne.layers.Conv2DLayer(
            net, num_filters=96, filter_size=(7, 7),
            nonlinearity=lasagne.nonlinearities.rectify,
            stride = (3,3),
            W=lasagne.init.GlorotNormal())
    pool1 = lasagne.layers.MaxPool2DLayer(cnn1, pool_size=(2, 2))
    cnn2 = lasagne.layers.Conv2DLayer(
            pool1, num_filters=192, filter_size=(5, 5),
            nonlinearity=lasagne.nonlinearities.rectify,
            W=lasagne.init.GlorotNormal())
    pool2 = lasagne.layers.MaxPool2DLayer(cnn2, pool_size=(2, 2))
    cnn3 = lasagne.layers.Conv2DLayer(
            pool2, num_filters=256, filter_size=(3, 3),
            nonlinearity=lasagne.nonlinearities.rectify,
            W=lasagne.init.GlorotNormal())
    # fc1 = lasagne.layers.DenseLayer(cnn2, num_units=128)
    network = lasagne.layers.FlattenLayer(cnn3)
    return network

def init_data(train,test):
    dtrain = utils.load_brown_dataset("/home/vassilis/Datasets/"+train+"/")
    dtest = utils.load_brown_dataset("/home/vassilis/Datasets/"+test+"/")

    dtrain['patches'] = dtrain['patches'].astype('float32')
    dtest['patches'] = dtest['patches'].astype('float32')

    dtrain['patches'] /= 255
    dtest['patches'] /= 255

    mu = dtrain['patches'].mean()
    dtrain['patches'] = dtrain['patches'] - mu
    dtest['patches'] = dtest['patches'] - mu
    return dtrain,dtest

def eval_test(net,d):
    bs = 100
    pb = np.array_split(d['patches'],bs)
    descrs = []
    for i,minib in enumerate(pb):
        dd = lasagne.layers.get_output(net,minib).eval()
        descrs.append(dd)

    descrs = np.vstack(descrs)
    dists = np.zeros(100000,)
    lbls = np.zeros(100000,)
    
    for i in range(100000):
        idx1 = d['testgt'][i][0]
        idx2 = d['testgt'][i][1]
        lbl = d['testgt'][i][2]
        dists[i] = np.linalg.norm(descrs[idx1]-descrs[idx2])
        lbls[i] = lbl
        #print(dists[i],lbls[i])
    fpr, tpr, thresholds = metrics.roc_curve(lbls, -dists, pos_label=1)
    f = interpolate.interp1d(tpr, fpr)
    fpr95 = f(0.95)
    print('fpr95-> '+str(fpr95))

def main(num_epochs=NUM_EPOCHS):
    widgets = ['Mini-batch training: ', Percentage(), ' ', Bar(),
             ' ', ETA(), ' ']
    print("> Loading data...")
    dtrain,dtest = init_data('liberty','notredame')
    net = build_cnn()

    dtr = utils.gen_pairs(dtrain,1200000)
    ntr = dtr.shape[0]

    X = T.tensor4()
    y = T.ivector()
    a = lasagne.layers.get_output(net,X)

    fx1 = a[1::2, :]
    fx2 = a[::2, :]
    d = T.sum(( fx1- fx2)**2, -1)

    l2_penalty = regularize_layer_params(net, l2) * 1e-3

    loss = T.mean(y * d + 
                  (1 - y) * T.maximum(0, 1 - d))+l2_penalty

    all_params = lasagne.layers.get_all_params(net)
    updates = lasagne.updates.nesterov_momentum(
        loss, all_params, LEARNING_RATE, MOMENTUM)

    trainf = theano.function([X, y], loss,updates=updates)    

    num_batches = ntr // BATCH_SIZE
    print(num_batches)
    print("> Done loading data...")
    print("> Started learning with "+str(num_batches)+" batches")

    shuf = np.random.permutation(ntr)

    X_tr = np.zeros((BATCH_SIZE*2,1,64,64)).astype('float32')
    y_tr = np.zeros(BATCH_SIZE).astype('int32')

    for epoch in range(NUM_EPOCHS):
        batch_train_losses = []
        pbar = ProgressBar(widgets=widgets, maxval=num_batches).start()
        for k in range(num_batches):
            sh = shuf[k*BATCH_SIZE:k*BATCH_SIZE+BATCH_SIZE]
            pbar.update(k)
            # fill batch here
            for s in range(0,BATCH_SIZE*2,2):
                # idx1 = dtrain['traingt'][sh[s/2],0]
                # idx2 = dtrain['traingt'][sh[s/2],1]
                # lbl = dtrain['traingt'][sh[s/2],2]

                idx1 = dtr[sh[s/2]][0]
                idx2 = dtr[sh[s/2]][1]
                lbl = dtr[sh[s/2]][2]
                
                X_tr[s] = dtrain['patches'][idx1]
                X_tr[s+1] = dtrain['patches'][idx2]
                y_tr[s/2] = lbl

            batch_train_loss = trainf(X_tr,y_tr)
            batch_train_losses.append(batch_train_loss)
        avg_train_loss = np.mean(batch_train_losses)
        pbar.finish()
        print("> Epoch " + str(epoch) + ", loss: "+str(avg_train_loss))

        eval_test(net,dtest)

        with open('net.pickle', 'wb') as f:
            pickle.dump(net, f, -1)
    
        # netlayers = lasagne.layers.get_all_layers(net)
        # print(netlayers)
        # layer = netlayers[1]
        # print(layer)
        # print(layer.num_filters)
        # W = layer.W.get_value()
        # b = layer.b.get_value()
        # f = [w + bb for w, bb in zip(W, b)]
        # gs = gridspec.GridSpec(8, 12)
        # for i in range(layer.num_filters):
        #     g = gs[i]
        #     ax = plt.subplot(g)
        #     ax.grid()
        #     ax.set_xticks([])
        #     ax.set_yticks([])
        #     ax.imshow(f[i][0])
        # plt.show()
        

if __name__ == '__main__':
   main(sys.argv[1])