def build_net(self):
# [1.0] first layer
first_layer = nn.ConcatTable()
# [1.1] feed forward neural net, produce v1, v2
feedforward = nn.Sequential()
feedforward.add(nn.Linear(self.input_size, self.hidden_layer_size))
feedforward.add(nn.PReLU())
# add hidden layers
for i in range(self.hidden_layer_count - 1):
feedforward.add(
nn.Linear(self.hidden_layer_size, self.hidden_layer_size))
feedforward.add(nn.PReLU())
feedforward.add(nn.Linear(self.hidden_layer_size, self.output_size))
# [1.2] right part, discard pot_size, produce r1, r2
right_part = nn.Sequential()
right_part.add(nn.Narrow(1, 0, self.output_size))
first_layer.add(feedforward)
first_layer.add(right_part)
# [2.0] outer net force counterfactual values satisfy 0-sum property
second_layer = nn.ConcatTable()
# accept v1,v2; ignore r1, r2
left_part2 = nn.Sequential()
left_part2.add(nn.SelectTable(0))
# accept, r1,r2, v1,v2; produce -0.5k=-0.5(r1v1 + r2v2)
right_part2 = nn.Sequential()
right_part2.add(nn.DotProduct())
right_part2.add(nn.Unsqueeze(1))
right_part2.add(nn.Replicate(self.output_size, 1))
right_part2.add(nn.Squeeze(2))
right_part2.add(nn.MulConstant(-0.5))
second_layer.add(left_part2)
second_layer.add(right_part2)
final_mlp = nn.Sequential()
final_mlp.add(first_layer)
final_mlp.add(second_layer)
# accept v1,v2 and -0.5k, product v1-0.5k, v2-0.5k
final_mlp.add(nn.CAddTable())
return final_mlp
def _build_net(self):
return (nn.Sequential()
.add(nn.Concat(0)
.add(nn.Linear(2, 5))
.add(nn.Linear(2, 5)))
.add(nn.ReLU())
.add(nn.Linear(10, 20)))
def build_conv_block(dim, padding_type, use_instance_norm):
conv_block = nn.Sequential()
p = 0
if padding_type == 'reflect':
conv_block.add(nn.SpatialReflectionPadding(1,1,1,1))
elif padding_type == 'replicate':
conv_block.add(nn.SpatialReplicationPadding(1,1,1,1))
elif padding_type == 'zero':
p = 1
conv_block.add(nn.SpationConvolution(dim, dim, 3, 3, 1, 1, p, p))
if use_instance_norm == 1:
conv_block.add(nn.InstanceNormalization(dim))
else:
conv_block.add(nn.SpatialBatchNormalization(dim))
conv_block.add(F.ReLU(True))
if padding_type == 'reflect':
conv_block.add(nn.SpatialReflectionPadding(1, 1, 1, 1))
elif padding_type == 'replicate':
conv_block.add(nn.SpatialReplicationPadding(1, 1, 1, 1))
conv_block.add(nn.SpatialConvolution(dim, dim, 3, 3, 1, 1, p, p))
if use_instance_norm == 1:
conv_block.add(nn.InstanceNormalization(dim))
else:
conv_block.add(nn.SpatialBatchNormalization(dim))
return conv_block
def torch_to_pytorch(t7_filename, outputname=None):
model = load_lua(t7_filename, unknown_classes=True)
if type(model).__name__ == 'hashable_uniq_dict':
model = model.model
model.gradInput = None
cvt = Convertor(model)
s = cvt.lua_recursive_source(lnn.Sequential().add(model))
s = cvt.simplify_source(s)
varname = os.path.basename(t7_filename).replace('.t7', '').replace(
'.', '_').replace('-', '_')
with open("header.py") as f:
header = f.read()
s = '{}\n{}\n\n{} = {}'.format(header, '\n'.join(cvt.prefix_code), varname,
s[:-2])
if outputname is None:
outputname = os.path.join('/tmp', varname)
with open(outputname + '.py', "w") as pyfile:
pyfile.write(s)
n = nn.Sequential()
cvt.lua_recursive_model(model, n)
torch.save(n.state_dict(), outputname + '.pth')
def torch_to_pytorch(t7_filename, outputname=None):
model = load_lua(t7_filename, unknown_classes=True)
if type(model).__name__ == 'hashable_uniq_dict': model = model.model
model.gradInput = None
slist = lua_recursive_source(lnn.Sequential().add(model))
s = simplify_source(slist)
header = '''
import torch
import torch.nn as nn
import torch.legacy.nn as lnn
from functools import reduce
from torch.autograd import Variable
class LambdaBase(nn.Sequential):
def __init__(self, fn, *args):
super(LambdaBase, self).__init__(*args)
self.lambda_func = fn
def forward_prepare(self, input):
output = []
for module in self._modules.values():
output.append(module(input))
return output if output else input
class Lambda(LambdaBase):
def forward(self, input):
return self.lambda_func(self.forward_prepare(input))
class LambdaMap(LambdaBase):
def forward(self, input):
return list(map(self.lambda_func,self.forward_prepare(input)))
class LambdaReduce(LambdaBase):
def forward(self, input):
return reduce(self.lambda_func,self.forward_prepare(input))
'''
varname = t7_filename.replace('.t7', '').replace('.',
'_').replace('-', '_')
s = '{}\n\n{} = {}'.format(header, varname, s[:-2])
if outputname is None: outputname = varname
with open(outputname + '.py', "w") as pyfile:
pyfile.write(s)
n = nn.Sequential()
lua_recursive_model(model, n)
#print("numpy", np.load('vgg_places.npy') )
np_file = np.load('vgg_places.npy')
print(np_file.shape)
print(np_file[0])
torch.save(n.state_dict(), outputname + '.pth')
def torch_to_keras(self, t7_filename, outputname=None):
model = load_lua(t7_filename, unknown_classes=True)
if type(model).__name__ == 'hashable_uniq_dict':
model = model.model
model.gradInput = None
slist = self.lua_recursive_source(lnn.Sequential().add(model),
isFirst=True)
s = self.simplify_source(slist)
header = '''from keras.models import Model
from keras.layers import Convolution2D
from keras.layers import Input
from keras.layers import ZeroPadding2D
from keras.layers import Activation
from keras.layers import BatchNormalization
from keras.layers import MaxPooling2D
from keras.layers import Lambda
from keras.layers import AveragePooling2D
from keras.layers import Dense
from keras.layers import Reshape
from keras.layers import concatenate
from Torch2KerasConverter.utils import lrn, sqrt, square, mulConstant, l2Normalize
'''
if outputname is None:
outputname = t7_filename
varname = outputname.replace('.t7', '').replace('.',
'_').replace('-', '_')
s = '{}\n\n{}\n{} = Model(inputs=[inp], outputs=x)\n{}.summary()\n'.format(
header, s[:], varname, varname)
with open(outputname + '.py', "w") as pyfile:
pyfile.write(s)
inp = Input(shape=self.inputShape)
layers = self.lua_recursive_model(lnn.Sequential().add(model),
isFirst=True,
inp=inp)
model = Model(inputs=[inp], outputs=layers)
print(model.summary())
model.save_weights(outputname + '.h5')
def torch_to_pytorch(t7_filename, out_py, out_pth):
model = load_lua(t7_filename, unknown_classes=True)
if type(model).__name__ == 'hashable_uniq_dict':
model = model.model
model.gradInput = None
slist = lua_recursive_source(lnn.Sequential().add(model))
s = simplify_source(slist)
header = """
import torch
import torch.nn as nn
import torch.legacy.nn as lnn
from functools import reduce
from torch.autograd import Variable
class LambdaBase(nn.Sequential):
def __init__(self, fn, *args):
super(LambdaBase, self).__init__(*args)
self.lambda_func = fn
def forward_prepare(self, input):
output = []
for module in self._modules.values():
output.append(module(input))
return output if output else input
class Lambda(LambdaBase):
def forward(self, input):
return self.lambda_func(self.forward_prepare(input))
class LambdaMap(LambdaBase):
def forward(self, input):
return list(map(self.lambda_func,self.forward_prepare(input)))
class LambdaReduce(LambdaBase):
def forward(self, input):
return reduce(self.lambda_func,self.forward_prepare(input))
"""
varname = t7_filename.split("/")[-1].replace('.t7',
'').replace('.', '_').replace(
'-', '_')
s = '{}\n\n{} = {}'.format(header, varname, s[:-2])
# save py file
open(out_py + ".py", "w").write(s)
# save pytorch model
n = nn.Sequential()
lua_recursive_model(model, n)
torch.save(n.state_dict(), out_pth + '.pth')
def torch_to_pytorch(t7_filename, outputname=None):
model = load_lua(t7_filename, unknown_classes=True)
if type(model).__name__ == 'hashable_uniq_dict': model = model.model
model.gradInput = None
slist = lua_recursive_source(lnn.Sequential().add(model))
s = simplify_source(slist)
header = ''
varname = t7_filename.replace('.t7', '').replace('.',
'_').replace('-', '_')
s = '{}\n\n{} = {}'.format(header, varname, s[:-2])
if outputname is None: outputname = varname
with open(outputname + '.py', "w") as pyfile:
pyfile.write(s)
n = nn.Sequential()
lua_recursive_model(model, n)
torch.save(n.state_dict(), outputname + '.pth')
def _test_single_layer(self, layer, decimal=7):
torch_model = nn.Sequential()
torch_model.add(layer)
coreml_output = self._forward_coreml(torch_model)
if not isinstance(coreml_output, list):
coreml_output = coreml_output.copy()
# XXX: pytorch legacy.nn has problem with state clearing, so we need to
# do it manually
for l in torch_model.modules:
if isinstance(l.output, torch.Tensor):
l.output = l.output.new()
torch_output = self._forward_torch(torch_model)
if not isinstance(torch_output, list):
torch_output = torch_output.copy()
self._assert_outputs(torch_output, coreml_output, decimal)
def torch_to_pytorch(t7_filename, varname=None):
if varname is None:
varname = os.path.splitext(os.path.basename(t7_filename))[0].replace(
'.', '_').replace('-', '_')
outputname = os.path.join(os.path.dirname(t7_filename), varname)
model = load_lua(t7_filename, unknown_classes=True)
if type(model).__name__ == 'hashable_uniq_dict': model = model.model
model.gradInput = None
slist, pooling_code = lua_recursive_source(lnn.Sequential().add(model),
varname)
s = simplify_source(slist)
header = open("header.py").read()
s = '\n'.join([header] + pooling_code + ['', s])
with open(outputname + '.py', "w") as pyfile:
pyfile.write(s)
n = lua_recursive_model(model)
torch.save(n.state_dict(), outputname + '.pth')
def test_ParallelTable(self):
input = torch.randn(3, 4, 5)
p = nn.ParallelTable()
p.add(nn.View(4, 5, 1))
p.add(nn.View(4, 5, 1))
p.add(nn.View(4, 5, 1))
m = nn.Sequential()
m.add(nn.SplitTable(0))
m.add(p)
m.add(nn.JoinTable(2))
# Check that these don't raise errors
p.__repr__()
str(p)
output = m.forward(input)
output2 = input.transpose(0, 2).transpose(0, 1)
self.assertEqual(output2, output)
gradInput = m.backward(input, output2)
self.assertEqual(gradInput, input)
def build_volumetric_unpooling_net():
pool = nn.VolumetricMaxPooling(2, 2, 2, 2)
unpool = nn.VolumetricMaxUnpooling(pool)
return nn.Sequential().add(pool).add(unpool)
def build_spatial_unpooling_net():
pool = nn.SpatialMaxPooling(2, 2, 2, 2)
unpool = nn.SpatialMaxUnpooling(pool)
return nn.Sequential().add(pool).add(unpool)
desc='split_dim'),
OldModuleTest(nn.View, (2, -1, 2, 5),
input_size=(2, 4, 5),
reference_fn=lambda i, _: i.view(2, -1, 2, 5),
desc='infer_middle'),
OldModuleTest(nn.Sum, (1, ),
input_size=(2, 4, 5),
reference_fn=lambda i, _: i.sum(1)),
OldModuleTest(nn.Sum, (1, True),
input_size=(2, 4, 5),
reference_fn=lambda i, _: i.sum(1).div(i.size(1)),
desc='sizeAverage'),
OldModuleTest(nn.Mean, (1, ),
input_size=(2, 4, 5),
reference_fn=lambda i, _: torch.mean(i, 1)),
OldModuleTest(lambda: nn.Sequential().add(nn.GradientReversal()).add(
nn.GradientReversal()),
input_size=(4, 3, 2, 2),
fullname='GradientReversal'),
OldModuleTest(nn.Identity,
input_size=(4, 3, 2, 4),
reference_fn=lambda i, _: i),
OldModuleTest(nn.DotProduct,
input_size=[(10, 4), (10, 4)],
reference_fn=lambda i, _: torch.Tensor(
list(a.dot(b) for a, b in zip(i[0], i[1])))),
OldModuleTest(nn.CosineDistance,
input_size=[(10, 4), (10, 4)],
reference_fn=lambda i, _: torch.Tensor(
list(
a.dot(b) / (a.norm(2) * b.norm(2))
for a, b in zip(i[0], i[1])))),
def FCNN():
num_classes = 2
n_layers_enc = 32
n_layers_ctx = 128
n_input = 5
prob_drop = 0.25
layers = []
# Encoder
model = nn.Sequential()
pool = nn.SpatialMaxPooling(2, 2, 2, 2)
model.add(nn.SpatialConvolution(n_input, n_layers_enc, 3, 3, 1, 1, 1, 1))
model.add(nn.ELU())
model.add(
nn.SpatialConvolution(n_layers_enc, n_layers_enc, 3, 3, 1, 1, 1, 1))
model.add(nn.ELU())
model.add(pool)
# Context Module
model.add(
nn.SpatialDilatedConvolution(n_layers_enc, n_layers_ctx, 3, 3, 1, 1, 1,
1, 1, 1))
model.add(nn.ELU())
model.add(nn.SpatialDropout(prob_drop))
model.add(
nn.SpatialDilatedConvolution(n_layers_ctx, n_layers_ctx, 3, 3, 1, 1, 2,
2, 2, 2))
model.add(nn.ELU())
model.add(nn.SpatialDropout(prob_drop))
model.add(
nn.SpatialDilatedConvolution(n_layers_ctx, n_layers_ctx, 3, 3, 1, 1, 4,
4, 4, 4))
model.add(nn.ELU())
model.add(nn.SpatialDropout(prob_drop))
model.add(
nn.SpatialDilatedConvolution(n_layers_ctx, n_layers_ctx, 3, 3, 1, 1, 8,
8, 8, 8))
model.add(nn.ELU())
model.add(nn.SpatialDropout(prob_drop))
model.add(
nn.SpatialDilatedConvolution(n_layers_ctx, n_layers_ctx, 3, 3, 1, 1,
16, 16, 16, 16))
model.add(nn.ELU())
model.add(nn.SpatialDropout(prob_drop))
model.add(
nn.SpatialDilatedConvolution(n_layers_ctx, n_layers_ctx, 3, 3, 1, 1,
32, 32, 32, 32))
model.add(nn.ELU())
model.add(nn.SpatialDropout(prob_drop))
model.add(
nn.SpatialDilatedConvolution(n_layers_ctx, n_layers_ctx, 3, 3, 1, 1,
64, 64, 64, 64))
model.add(nn.ELU())
model.add(nn.SpatialDropout(prob_drop))
model.add(nn.SpatialDilatedConvolution(n_layers_ctx, n_layers_enc, 1, 1))
model.add(nn.ELU()) # Nao havia no paper
# Decoder
model.add(nn.SpatialMaxUnpooling(pool))
model.add(
nn.SpatialConvolution(n_layers_enc, n_layers_enc, 3, 3, 1, 1, 1, 1))
model.add(nn.ELU())
model.add(
nn.SpatialConvolution(n_layers_enc, num_classes, 3, 3, 1, 1, 1, 1))
model.add(nn.ELU())
model.add(nn.SoftMax()) # Nao havia no paper
return model
def setUp(self):
self.input = np.random.ranf(_INPUT_SHAPE)
self.model = nn.Sequential()
self.model.add(nn.MulConstant(1.0))
def torch_to_pytorch(t7_filename, outputname=None):
model = load_lua(t7_filename, unknown_classes=True)
if type(model).__name__ == 'hashable_uniq_dict': model = model.model
model.gradInput = None
slist = lua_recursive_source(lnn.Sequential().add(model))
s = simplify_source(slist)
header = '''import torch
import torch.nn as nn
from functools import reduce
class LambdaBase(nn.Sequential):
def __init__(self, fn, *args):
super(LambdaBase, self).__init__(*args)
self.lambda_func = fn
def forward_prepare(self, input):
output = []
for module in self._modules.values():
output.append(module(input))
return output if output else input
class Lambda(LambdaBase):
def forward(self, input):
return self.lambda_func(self.forward_prepare(input))
class LambdaMap(LambdaBase):
def forward(self, input):
return list(map(self.lambda_func, self.forward_prepare(input)))
class LambdaReduce(LambdaBase):
def forward(self, input):
return reduce(self.lambda_func, self.forward_prepare(input))
class TVLoss(nn.Module):
def __init__(self, TVLoss_weight=1):
super(TVLoss, self).__init__()
self.TVLoss_weight = TVLoss_weight
def forward(self, x):
batch_size = x.size()[0]
h_x = x.size()[2]
w_x = x.size()[3]
count_h = self._tensor_size(x[:, :, 1:, :])
count_w = self._tensor_size(x[:, :, :, 1:])
h_tv = torch.pow((x[:, :, 1:, :] - x[:, :, :h_x - 1, :]), 2).sum()
w_tv = torch.pow((x[:, :, :, 1:] - x[:, :, :, :w_x - 1]), 2).sum()
return self.TVLoss_weight * 2 * (h_tv / count_h + w_tv / count_w) / batch_size + x
def _tensor_size(self, t):
return t.size()[1] * t.size()[2] * t.size()[3]
class TransformerNetwork(nn.Module):
def __init__(self):
super(TransformerNetwork, self).__init__()
'''
footer = '''
def forward(self, input):
return self.style.forward(input)
'''
varname = t7_filename.replace('.t7', '').replace('.',
'_').replace('-', '_')
s = '{} self.style = {}{}'.format(header, s[:-2], footer)
if outputname is None: outputname = varname
with open(outputname + '.py', "w") as pyfile:
pyfile.write(s)
n = nn.Sequential()
lua_recursive_model(model, n)
model = TransformerNetwork()
model.style = n
torch.save(model.state_dict(), outputname + '.pth')
# All rights reserved.
#
# This source code is licensed under the license found in the
# LICENSE file in the root directory of this source tree.
import torch
import torch.legacy.nn as nn
import sparseconvnet.legacy as scn
from data import getIterators
# Use the GPU if there is one, otherwise CPU
dtype = 'torch.cuda.FloatTensor' if torch.cuda.is_available(
) else 'torch.FloatTensor'
# two-dimensional SparseConvNet
model = nn.Sequential()
sparseModel = scn.Sequential()
denseModel = nn.Sequential()
model.add(sparseModel).add(denseModel)
sparseModel.add(scn.ValidConvolution(2, 3, 16, 3, False))
sparseModel.add(scn.MaxPooling(2, 3, 2))
sparseModel.add(
scn.SparseResNet(
2, 16,
[['b', 16, 2, 1], ['b', 32, 2, 2], ['b', 48, 2, 2], ['b', 96, 2, 2]]))
sparseModel.add(scn.Convolution(2, 96, 128, 4, 1, False))
sparseModel.add(scn.BatchNormReLU(128))
sparseModel.add(scn.SparseToDense(2))
denseModel.add(nn.View(-1, 128))
denseModel.add(nn.Linear(128, 3755))
model.type(dtype)
googlenet = nn.Sequential( # Sequential,
nn.Conv2d(3, 64, (7, 7), (2, 2), (3, 3)),
nn.ReLU(),
nn.MaxPool2d((3, 3), (2, 2), (0, 0), ceil_mode=True),
Lambda(lambda x, lrn=torch.legacy.nn.SpatialCrossMapLRN(*(
5, 0.0001, 0.75, 1)): Variable(lrn.forward(x.data))),
nn.Conv2d(64, 64, (1, 1)),
nn.ReLU(),
nn.Conv2d(64, 192, (3, 3), (1, 1), (1, 1)),
nn.ReLU(),
Lambda(lambda x, lrn=torch.legacy.nn.SpatialCrossMapLRN(*(
5, 0.0001, 0.75, 1)): Variable(lrn.forward(x.data))),
nn.MaxPool2d((3, 3), (2, 2), (0, 0), ceil_mode=True),
nn.Conv2d(192, 64, (1, 1)),
nn.ReLU(),
nn.Conv2d(192, 96, (1, 1)),
nn.ReLU(),
nn.Conv2d(96, 128, (3, 3), (1, 1), (1, 1)),
nn.ReLU(),
nn.Conv2d(192, 16, (1, 1)),
nn.ReLU(),
nn.Conv2d(16, 32, (5, 5), (1, 1), (2, 2)),
nn.ReLU(),
nn.MaxPool2d((3, 3), (1, 1), (1, 1), ceil_mode=True),
nn.Conv2d(192, 32, (1, 1)),
nn.ReLU(),
nn.Conv2d(256, 128, (1, 1)),
nn.ReLU(),
nn.Conv2d(256, 128, (1, 1)),
nn.ReLU(),
nn.Conv2d(128, 192, (3, 3), (1, 1), (1, 1)),
nn.ReLU(),
nn.Conv2d(256, 32, (1, 1)),
nn.ReLU(),
nn.Conv2d(32, 96, (5, 5), (1, 1), (2, 2)),
nn.ReLU(),
nn.MaxPool2d((3, 3), (1, 1), (1, 1), ceil_mode=True),
nn.Conv2d(256, 64, (1, 1)),
nn.ReLU(),
nn.MaxPool2d((3, 3), (2, 2), (0, 0), ceil_mode=True),
nn.Conv2d(480, 192, (1, 1)),
nn.ReLU(),
nn.Conv2d(480, 96, (1, 1)),
nn.ReLU(),
nn.Conv2d(96, 208, (3, 3), (1, 1), (1, 1)),
nn.ReLU(),
nn.Conv2d(480, 16, (1, 1)),
nn.ReLU(),
nn.Conv2d(16, 48, (5, 5), (1, 1), (2, 2)),
nn.ReLU(),
nn.MaxPool2d((3, 3), (1, 1), (1, 1), ceil_mode=True),
nn.Conv2d(480, 64, (1, 1)),
nn.ReLU(),
nn.AvgPool2d((5, 5), (3, 3), (0, 0), ceil_mode=True), #AvgPool2d,
nn.Conv2d(512, 128, (1, 1)),
nn.ReLU(),
Lambda(lambda x: x.view(x.size(0), -1)), # View,
nn.Sequential(Lambda(lambda x: x.view(1, -1) if 1 == len(x.size()) else x),
nn.Linear(2048, 1024)), # Linear,
nn.ReLU(),
nn.Dropout(0.7),
nn.Sequential(Lambda(lambda x: x.view(1, -1) if 1 == len(x.size()) else x),
nn.Linear(1024, 365)), # Linear,
)
