Train on Pascal VOC2012

Hi,
I'm trying to use segnet on the Pascal VOC2012 dataset. I modified a little to make the network suit for different input size as shown in Pascal. But, unfortunately, I found it still hard to converge. I add the net make function here and I'm looking forward any help. Thanks in advance.
def segnet(split):
    n = caffe.NetSpec()

    pydata_params = dict(split=split, mean=(104.00699, 116.66877, 122.67892),
                         seed=1337)
    pydata_params['voc_dir'] = '/mnt/hdd0/PascalVOC/VOCdevkit/VOC2012'
    pylayer = 'VOCSegDataLayer'
    n.data, n.label = L.Python(module='voc_layers', layer=pylayer,
                               ntop=2, param_str=str(pydata_params))

    n.conv1_1, n.conv1_1_bn, n.relu1_1 = conv_bn_relu(n.data, 64, param=frozen_param)
    n.conv1_2, n.conv1_2_bn, n.relu1_2 = conv_bn_relu(n.conv1_1, 64, param=frozen_param)
    n.pool1, n.pool1_mask = max_pool(n.conv1_2)

    n.conv2_1, n.conv2_1_bn, n.relu2_1 = conv_bn_relu(n.pool1, 128, param=frozen_param)
    n.conv2_2, n.conv2_2_bn, n.relu2_2 = conv_bn_relu(n.conv2_1, 128, param=frozen_param)
    n.pool2, n.pool2_mask = max_pool(n.conv2_2)

    n.conv3_1, n.conv3_1_bn, n.relu3_1 = conv_bn_relu(n.pool2, 256, param=frozen_param)
    n.conv3_2, n.conv3_2_bn, n.relu3_2 = conv_bn_relu(n.conv3_1, 256, param=frozen_param)
    n.conv3_3, n.conv3_3_bn, n.relu3_3 = conv_bn_relu(n.conv3_2, 256, param=frozen_param)
    n.pool3, n.pool3_mask = max_pool(n.conv3_3)

    n.conv4_1, n.conv4_1_bn, n.relu4_1 = conv_bn_relu(n.pool3, 512, param=frozen_param)
    n.conv4_2, n.conv4_2_bn, n.relu4_2 = conv_bn_relu(n.conv4_1, 512, param=frozen_param)
    n.conv4_3, n.conv4_3_bn, n.relu4_3 = conv_bn_relu(n.conv4_2, 512, param=frozen_param)
    n.pool4, n.pool4_mask = max_pool(n.conv4_3)

    n.conv5_1, n.conv5_1_bn, n.relu5_1 = conv_bn_relu(n.pool4, 512, param=frozen_param)
    n.conv5_2, n.conv5_2_bn, n.relu5_2 = conv_bn_relu(n.conv5_1, 512, param=frozen_param)
    n.conv5_3, n.conv5_3_bn, n.relu5_3 = conv_bn_relu(n.conv5_2, 512, param=frozen_param)
    n.pool5, n.pool5_mask = max_pool(n.conv5_3)

    n.upsample5 = upsample(n.pool5, n.pool5_mask, w=-1, h=-1)
    n.conv5_3_D, n.conv5_3_bn_D, n.relu5_3_D = conv_bn_relu(n.upsample5, 512)
    n.conv5_2_D, n.conv5_2_bn_D, n.relu5_2_D = conv_bn_relu(n.conv5_3_D, 512)
    n.conv5_1_D, n.conv5_1_bn_D, n.relu5_1_D = conv_bn_relu(n.conv5_2_D, 512)

    n.conv5_1_D_crop = L.Crop(n.conv5_1_D, n.pool4_mask, crop_param=dict(axis=2, offset=[0, 0]))
    n.upsample4 = upsample(n.conv5_1_D_crop, n.pool4_mask, w=-1, h=-1)
    n.conv4_3_D, n.conv4_3_bn_D, n.relu4_3_D = conv_bn_relu(n.upsample4, 512)
    n.conv4_2_D, n.conv4_2_bn_D, n.relu4_2_D = conv_bn_relu(n.conv4_3_D, 512)
    n.conv4_1_D, n.conv4_1_bn_D, n.relu4_1_D = conv_bn_relu(n.conv4_2_D, 256)

    n.conv4_1_D_crop = L.Crop(n.conv4_1_D, n.pool3_mask, crop_param=dict(axis=2, offset=[0, 0]))
    n.upsample3 = upsample(n.conv4_1_D_crop, n.pool3_mask, w=-1, h=-1)
    n.conv3_3_D, n.conv3_3_bn_D, n.relu3_3_D = conv_bn_relu(n.upsample3, 256)
    n.conv3_2_D, n.conv3_2_bn_D, n.relu3_2_D = conv_bn_relu(n.conv3_3_D, 256)
    n.conv3_1_D, n.conv3_1_bn_D, n.relu3_1_D = conv_bn_relu(n.conv3_2_D, 128)

    n.conv3_1_D_crop = L.Crop(n.conv3_1_D, n.pool2_mask, crop_param=dict(axis=2, offset=[0, 0]))
    n.upsample2 = upsample(n.conv3_1_D_crop, n.pool2_mask, w=-1, h=-1)
    n.conv2_2_D, n.conv2_2_bn_D, n.relu2_2_D = conv_bn_relu(n.upsample2, 128)
    n.conv2_1_D, n.conv2_1_bn_D, n.relu2_1_D = conv_bn_relu(n.conv2_2_D, 64)

    n.conv2_1_D_crop = L.Crop(n.conv2_1_D, n.pool1_mask, crop_param=dict(axis=2, offset=[0, 0]))
    n.upsample1 = upsample(n.conv2_1_D_crop, n.pool1_mask, w=-1, h=-1)
    n.conv1_2_D, n.conv1_2_bn_D, n.relu1_2_D = conv_bn_relu(n.upsample1, 64)
    n.conv1_1_D = L.Convolution(n.conv1_2_D, kernel_size=3, stride=1,
                                num_output=21, pad=1, param=learned_param)

    n.score = L.Crop(n.conv1_1_D, n.data, crop_param=dict(axis=2, offset=[0, 0]))

    n.loss = L.SoftmaxWithLoss(n.score, n.label,
                               loss_param=dict(ignore_label=255, normalize=True),
                               softmax_param=dict(engine=2))
    n.accuracy, n.per_class_accuracy = L.Accuracy(
        n.score, n.label, ntop=2)

    return n.to_proto()
alexgkendall / SegNet-Tutorial

Train on Pascal VOC2012 #56
