for param in child.conv13[0].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))

        for child in net.children():
                for param in child.fc1[1].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))
        for child in net.children():
                for param in child.fc2[1].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))
        for child in net.children():
                for param in child.fc3[0].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))'''

# Train+inference vs. Inference
mode = args.mode
if mode == 1:  # mode=1 is training & inference @ each epoch
    for epoch in range(start_epoch, start_epoch + num_epoch):
        train(epoch)

        #For 0.125 dirty train
        mask = cn.set_mask(cn.set_mask(mask, 1, 1), 2, 0)
        net = cn.net_mask_mul(net, mask)
        net = cn.add_network(net, net2)

        test()

elif mode == 0:  # only inference
    test()
else:
    pass
                for param in child.conv13[0].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))

        for child in net.children():
                for param in child.fc1[1].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))
        for child in net.children():
                for param in child.fc2[1].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))
        for child in net.children():
                for param in child.fc3[0].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))'''

# Train+inference vs. Inference
mode = args.mode
if mode == 1:  # mode=1 is training & inference @ each epoch
    for epoch in range(start_epoch, start_epoch + num_epoch):
        train(epoch)

        #For 0.125 dirty train
        mask = cn.set_mask(cn.set_mask(mask, 3, 1), 4, 0)
        net = cn.net_mask_mul(net, mask)
        net = cn.add_network(net, net2)

        test()

elif mode == 0:  # only inference
    test()
else:
    pass
                                     (2**-(pprec))) * (2**-(pprec))
    for child in net.children():
        for param in child.fc2[1].parameters():
            param.data = torch.round(param.data /
                                     (2**-(pprec))) * (2**-(pprec))
    for child in net.children():
        for param in child.fc3[0].parameters():
            param.data = torch.round(param.data /
                                     (2**-(pprec))) * (2**-(pprec))


mask_channel = torch.load('mask_null.dat')

# Train+inference vs. Inference

mask_channel = cn.set_mask(mask_channel, 0, 0)

#0.125
if args.mode == 1:
    mask_channel = cn.set_mask(mask_channel, 3, 1)
    mask_channel = cn.set_mask(mask_channel, 4, 0)
    net = cn.net_mask_mul(net, mask_channel)

#0.25
elif args.mode == 2:
    mask_channel = cn.set_mask(mask_channel, 2, 1)
    mask_channel = cn.set_mask(mask_channel, 3, 0)
    net = cn.net_mask_mul(net, mask_channel)

#1
elif args.mode == 3:
                for param in child.conv13[0].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))

        for child in net.children():
                for param in child.fc1[1].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))
        for child in net.children():
                for param in child.fc2[1].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))
        for child in net.children():
                for param in child.fc3[0].parameters():
                        param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))'''

# Train+inference vs. Inference
mode = args.mode
if mode == 1:  # mode=1 is training & inference @ each epoch
    for epoch in range(start_epoch, start_epoch + num_epoch):
        train(epoch)

        #For 0.125 dirty train
        mask = cn.set_mask(cn.set_mask(mask, 2, 1), 3, 0)
        net = cn.net_mask_mul(net, mask)
        net = cn.add_network(net, net2)

        test()

elif mode == 0:  # only inference
    test()
else:
    pass
コード例 #5
0
            'mask_conv37': mask_conv37,
            'mask_conv40': mask_conv40,
            'mask_fc1': mask_fc1,
            'mask_fc4': mask_fc4,
            'mask_fc6': mask_fc6
        }
        torch.save(mask, 'mask_{}_half_clean.dat'.format(args.pr))

    for epoch in range(0, 15):
        retrain(epoch, mask_conv0, mask_conv3, mask_conv7, mask_conv10,
                mask_conv14, mask_conv17, mask_conv20, mask_conv24,
                mask_conv27, mask_conv30, mask_conv34, mask_conv37,
                mask_conv40, mask_fc1, mask_fc4, mask_fc6)

        mask = torch.load('mask_null.dat')
        mask = cn.set_mask(mask, 4, 1)
        net = cn.net_mask_mul(net, mask)

        test()

# Truncate weight param
'''
pprec = args.pprec
if args.fixed:
	for child in net.children():
		for param in child.conv1[0].parameters():
			param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))
	for child in net.children():
		for param in child.conv2[0].parameters():
			param.data = torch.round(param.data / (2 ** -(pprec))) * (2 ** -(pprec))
	for child in net.children():