def init(cls): try: path = download_file('https://download.pytorch.org/test_data/legacy_modules.t7') except unittest.SkipTest: return tests = load_lua(path) for name, test in tests['modules'].items(): test_name = 'test_' + name.replace('nn.', '') setattr(cls, test_name, cls._module_test(name, test)) for name, test in tests['criterions'].items(): test_name = 'test_' + name.replace('nn.', '') setattr(cls, test_name, cls._criterion_test(name, test))
def __init__(self, model_file_name, input_shape): super(TorchParser, self).__init__() if not os.path.exists(model_file_name): raise ValueError("Torch7 model file [{}] is not found.".format(model_file_name)) model = load_lua(model_file_name) if type(model).__name__=='hashable_uniq_dict': model = model.model model.evaluate() self.weight_loaded = True # Build network graph self.torch_graph = TorchGraph(model) self.torch_graph.build([[1] + input_shape])
def load_vgg16(model_dir): """ Use the model from https://github.com/abhiskk/fast-neural-style/blob/master/neural_style/utils.py """ if not os.path.exists(model_dir): os.mkdir(model_dir) if not os.path.exists(os.path.join(model_dir, 'vgg16.weight')): if not os.path.exists(os.path.join(model_dir, 'vgg16.t7')): os.system('wget https://www.dropbox.com/s/76l3rt4kyi3s8x7/vgg16.t7?dl=1 -O ' + os.path.join(model_dir, 'vgg16.t7')) vgglua = load_lua(os.path.join(model_dir, 'vgg16.t7')) vgg = Vgg16() for (src, dst) in zip(vgglua.parameters()[0], vgg.parameters()): dst.data[:] = src torch.save(vgg.state_dict(), os.path.join(model_dir, 'vgg16.weight')) vgg = Vgg16() vgg.load_state_dict(torch.load(os.path.join(model_dir, 'vgg16.weight'))) return vgg
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) torch.save(n.state_dict(),outputname+'.pth')
def init(cls): try: path = download_file('https://download.pytorch.org/test_data/legacy_modules.t7') except unittest.SkipTest: return long_size = 8 if sys.platform == 'win32' else None tests = load_lua(path, long_size=long_size) for name, test in tests['modules'].items(): if name == "HardShrink": continue test_name = 'test_' + name.replace('nn.', '') setattr(cls, test_name, cls._module_test(name, test)) for name, test in tests['criterions'].items(): if name == "HardShrink": continue test_name = 'test_' + name.replace('nn.', '') setattr(cls, test_name, cls._criterion_test(name, test))
def generateSampleFace(self, idx): sf = self.scale_factor rf = self.rot_factor main_pts = load_lua(self.anno[idx]) pts = main_pts mins_ = torch.min(pts, 0)[0].view(2) # min vals maxs_ = torch.max(pts, 0)[0].view(2) # max vals c = torch.FloatTensor((maxs_[0] - (maxs_[0] - mins_[0]) / 2, maxs_[1] - (maxs_[1] - mins_[1]) / 2)) # c[0] -= ((maxs_[0] - mins_[0]) * 0.12) c[1] -= ((maxs_[1] - mins_[1]) * 0.12) s = (maxs_[0] - mins_[0] + maxs_[1] - mins_[1]) / 195 img = load_image(self.anno[idx][:-3] + '.jpg') r = 0 if self.is_train: # scale s = s * torch.randn(1).mul_(sf).add_(1).clamp(1 - sf, 1 + sf)[0] # rotatation r = torch.randn(1).mul_(rf).clamp(-2 * rf, 2 * rf)[0] if random.random() <= 0.6 else 0 # flip if random.random() <= 0.5: img = torch.from_numpy(fliplr(img.numpy())).float() pts = shufflelr(pts, width=img.size(2), dataset='w300lp') c[0] = img.size(2) - c[0] # RGB img[0, :, :].mul_(random.uniform(0.7, 1.3)).clamp_(0, 1) img[1, :, :].mul_(random.uniform(0.7, 1.3)).clamp_(0, 1) img[2, :, :].mul_(random.uniform(0.7, 1.3)).clamp_(0, 1) inp = crop(img, c, s, [256, 256], rot=r) # inp = color_normalize(inp, self.mean, self.std) tpts = pts.clone() out = torch.zeros(self.nParts, 64, 64) for i in range(self.nParts): if tpts[i, 0] > 0: tpts[i, 0:2] = to_torch(transform(tpts[i, 0:2] + 1, c, s, [64, 64], rot=r)) out[i] = draw_labelmap(out[i], tpts[i] - 1, sigma=1) return inp, out, pts, c, s
def generateSampleFace(self, idx): sf = self.scale_factor rf = self.rot_factor main_pts = load_lua( os.path.join(self.img_folder, 'landmarks', self.anno[idx].split('_')[0], self.anno[idx][:-4] + '.t7')) pts = main_pts[0] if self.pointType == '2D' else main_pts[1] c = torch.Tensor((450 / 2, 450 / 2 + 50)) s = 1.8 img = load_image( os.path.join(self.img_folder, self.anno[idx].split('_')[0], self.anno[idx][:-8] + '.jpg')) r = 0 if self.is_train: s = s * torch.randn(1).mul_(sf).add_(1).clamp(1 - sf, 1 + sf)[0] r = torch.randn(1).mul_(rf).clamp(-2 * rf, 2 * rf)[0] if random.random() <= 0.6 else 0 if random.random() <= 0.5: img = torch.from_numpy(fliplr(img.numpy())).float() pts = shufflelr(pts, width=img.size(2), dataset='w300lp') c[0] = img.size(2) - c[0] img[0, :, :].mul_(random.uniform(0.7, 1.3)).clamp_(0, 1) img[1, :, :].mul_(random.uniform(0.7, 1.3)).clamp_(0, 1) img[2, :, :].mul_(random.uniform(0.7, 1.3)).clamp_(0, 1) inp = crop(img, c, s, [256, 256], rot=r) inp = color_normalize(inp, self.mean, self.std) tpts = pts.clone() out = torch.zeros(self.nParts, 64, 64) for i in range(self.nParts): if tpts[i, 0] > 0: tpts[i, 0:2] = to_torch(transform(tpts[i, 0:2] + 1, c, s, [64, 64], rot=r)) out[i] = draw_labelmap(out[i], tpts[i] - 1, sigma=1) return inp, out, pts, c, s
def loadgts(datapath, pointType='2D'): if datapath.endswith('300W_LP'): base_dir = os.path.join(datapath, 'landmarks') dirs = os.listdir(base_dir) lines = [] for d in dirs: files = [ f for f in os.listdir(osp.join(base_dir, d)) if f.endswith('mat') and f.find('test') != -1 ] lines.extend(files) all_gts = torch.zeros((len(lines), 68, 2)) for i, f in enumerate(lines): if pointType == '2D': pts = load_lua(osp.join(base_dir, f.split('_')[0], f[:-4] + '.t7'))[0] else: pts = load_lua(osp.join(base_dir, f.split('_')[0], f[:-4] + '.t7'))[1] all_gts[i, :, :] = pts return all_gts, lines elif datapath.find('300VW-3D') != -1: lines = [] for split in ['CatA', 'CatB', 'CatC']: base_dir = os.path.join(datapath, split) dirs = os.listdir(base_dir) for d in dirs: files = [ osp.join(base_dir, d, f) for f in os.listdir(osp.join(base_dir, d)) if f.endswith('t7') ] lines.extend(files) elif datapath.endswith('LS3D-W'): base_dir = osp.join(datapath, 'new_dataset') lines, E, M, H = [],[],[],[] files = [f for f in os.listdir(base_dir) if f.endswith('.t7')] for f in files: num_of_file = int(f.split('.')[0]) if num_of_file % 3 == 1: # 0-30 E.append(os.path.join(base_dir, f)) elif num_of_file % 3 == 2: # 30-60 M.append(os.path.join(base_dir, f)) else: # 60-90 H.append(os.path.join(base_dir, f)) lines.extend(E) lines.extend(M) lines.extend(H) all_gts = torch.zeros((len(lines), 68, 2)) for i, f in enumerate(lines): if pointType == '2D': if datapath.endswith('300W_LP'): pts = load_lua(osp.join(base_dir, f.split('_')[0], f[:-4] + '.t7'))[0] else: print("Given data set do not have 3D annotations.") exit() else: pts = load_lua(f) all_gts[i, :, :] = pts print('Loaded {} sample from {}'.format(len(lines), base_dir)) return all_gts, lines
p_wct.d2.load_state_dict( torch.load('pth_models/feature_invertor_conv2.pth')) p_wct.e3.load_state_dict(torch.load('pth_models/vgg_normalised_conv3.pth')) p_wct.d3.load_state_dict( torch.load('pth_models/feature_invertor_conv3.pth')) p_wct.e4.load_state_dict(torch.load('pth_models/vgg_normalised_conv4.pth')) p_wct.d4.load_state_dict( torch.load('pth_models/feature_invertor_conv4.pth')) if __name__ == '__main__': if not os.path.exists('pth_models'): os.mkdir('pth_models') ## VGGEncoder1 vgg1 = load_lua('models/vgg_normalised_conv1_1_mask.t7') e1 = VGGEncoder(1) weight_assign(vgg1, e1, { 'conv0': 0, 'conv1_1': 2, }) torch.save(e1.state_dict(), 'pth_models/vgg_normalised_conv1.pth') ## VGGDecoder1 inv1 = load_lua('models/feature_invertor_conv1_1_mask.t7') d1 = VGGDecoder(1) weight_assign(inv1, d1, { 'conv1_1': 1, }) torch.save(d1.state_dict(), 'pth_models/feature_invertor_conv1.pth')
all_networks = {} canonical_ordering = [] for language, version in tqdm(p(languages, versions), desc='loading', total=len(languages) * len(versions)): # Standard network name network_name = 'en-%s-%d' % (language, version) canonical_ordering.append(network_name) # Load as 4000x(sentence_length)x500 matrix all_networks[network_name] = load_lua('../descriptions/%s.desc.t7' % network_name) means = {} variances = {} # Eigenvectors and values e, v = torch.load('eigenvalues_and_vectors.pkl') # transforms cca_transforms = torch.load('svcca-99.pkl') # Sort e, indices = torch.abs(e[:, 0]).sort(descending=True) v = v[:, indices] pca_list = []
if __name__ == '__main__': opt = parser.parse_args() impath = opt.data_dir match_data = {name: read_matches_file(os.path.join(impath, name)) for name in os.listdir(impath) if name.startswith('m50_')} info = np.loadtxt(os.path.join(impath, 'info.txt'), dtype=np.uint64)[:,0] image_list = filter(lambda x: x.endswith('.bmp'), os.listdir(impath)) patches = [] for name in tqdm(sorted(image_list)): im = cv2.imread(os.path.join(impath, name), cv2.IMREAD_GRAYSCALE) patches.append(im.reshape(16,64,16,64).transpose(0,2,1,3).reshape(-1,64,64)) patches = np.concatenate(patches)[:info.size] mean = np.mean(patches, axis=(1,2)) np.save(arr={'patches': patches, 'mean': mean, 'info': info, 'match_data': match_data}, file=open(os.path.join(impath, 'data.npy'), 'w')) if opt.test: import torch from torch.utils.serialization import load_lua data_torch = load_lua(os.path.join(impath, 'data.t7')) print((torch.from_numpy(patches).float() - data_torch['patches'].float()).abs().max())
in cuDNN. """ parser = argparse.ArgumentParser() parser.add_argument('--t7_file', required=True) parser.add_argument('--pth_file', required=True) args = parser.parse_args() model_name = os.path.splitext(args.pth_file)[0].split('-')[0] model = getattr(models, model_name)() model.load_state_dict(torch.load(args.pth_file)) model.float() model.eval() test_cases = load_lua(args.t7_file)['tests'] for i, test_case in enumerate(test_cases): print('Running test case %d / %d' % (i + 1, len(test_cases))) x = Variable(test_case['input'].float(), requires_grad=True) expected_y = test_case['output'].float() grad_y = test_case['grad_output'].float() expected_grad_x = test_case['grad_input'].float() y = model(x) y_diff = torch.abs(y.data - expected_y).sum() assert y_diff == 0, 'y_diff = %f' % y_diff y.backward(grad_y) grad_x_diff = torch.abs(x.grad.data - expected_grad_x).sum() assert grad_x_diff == 0, 'grad_x_diff = %f' % grad_x_diff print('All tests pass!')
import torch import torchvision from torch.utils.serialization import load_lua from train_res3d.resnet3d import resnet18 torchvision.models.resnet18() model = resnet18() model_t7 = load_lua('resnet-18-kinetics-cpu.t7') # dummy inputs for the example print('load success') def copy_param(n, m): if m.weight is not None: n.weight.data.copy_(m.weight) if m.bias is not None: n.bias.data.copy_(m.bias) if hasattr(n, 'running_mean'): n.running_mean.copy_(m.running_mean) if hasattr(n, 'running_var'): n.running_var.copy_(m.running_var) copy_param(model.conv1, model_t7.modules[0].modules[0]) copy_param(model.bn1, model_t7.modules[0].modules[1]) # layer1 copy_param( model.layer1[0].conv1, model_t7.modules[0].modules[4].modules[0].modules[0].modules[0].modules[0]) copy_param( model.layer1[0].bn1, model_t7.modules[0].modules[4].modules[0].modules[0].modules[0].modules[1]) copy_param( model.layer1[0].conv2,
import tqdm import cv2 from network import Network from network import model_path import load IMAGE_SIZE = 256 LOCAL_SIZE = 128 HOLE_MIN = 32 HOLE_MAX = 127 LEARNING_RATE = 1e-3 BATCH_SIZE = 8 PRETRAIN_EPOCH = 100 from torch.utils.serialization import load_lua datamean = load_lua(model_path).mean datamean = np.array(datamean) def train(): x = tf.placeholder(tf.float32, [BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 3]) mask = tf.placeholder(tf.float32, [BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 1]) local_x = tf.placeholder(tf.float32, [BATCH_SIZE, LOCAL_SIZE, LOCAL_SIZE, 3]) global_completion = tf.placeholder(tf.float32, [BATCH_SIZE, IMAGE_SIZE, IMAGE_SIZE, 3]) local_completion = tf.placeholder(tf.float32, [BATCH_SIZE, LOCAL_SIZE, LOCAL_SIZE, 3]) is_training = tf.placeholder(tf.bool, []) model = Network(x,
action="store", dest="inputsize", type=int, default=2000, help="The input sequence window size for neural network") parser.add_argument('--batchsize', action="store", dest="batchsize", type=int, default=32, help="Batch size for neural network predictions.") parser.add_argument('--cuda', action='store_true') args = parser.parse_args() genome = pyfasta.Fasta('./resources/hg19.fa') model = load_lua('./resources/deepsea.beluga.2002.cpu') model.evaluate() if args.cuda: model.cuda() CHRS = [ 'chr1', 'chr2', 'chr3', 'chr4', 'chr5', 'chr6', 'chr7', 'chr8', 'chr9', 'chr10', 'chr11', 'chr12', 'chr13', 'chr14', 'chr15', 'chr16', 'chr17', 'chr18', 'chr19', 'chr20', 'chr21', 'chr22', 'chrX', 'chrY' ] inputfile = args.inputfile maxshift = args.maxshift inputsize = args.inputsize batchSize = args.batchsize windowsize = inputsize + 100
import torch import torch.nn as nn from torch.legacy import nn as old_nn from torch.legacy.nn.Sequential import Sequential as old_Sequential from torch.utils.serialization import load_lua from glcic import glcic A = load_lua('completionnet_places2.t7', long_size=8).model B = glcic(in_ch=4, out_ch=3, ch=64) A_layers = list( m for m in A.modules if isinstance(m, (old_nn.SpatialConvolution, old_nn.SpatialFullConvolution, old_nn.SpatialDilatedConvolution, old_nn.SpatialBatchNormalization))) B_layers = list( m for m in B.modules() if isinstance(m, (nn.Conv2d, nn.ConvTranspose2d, nn.BatchNorm2d))) for m1, m2 in zip(A_layers, B_layers): # m1, m2 = A_layers[0], B_layers[0] if isinstance(m2, (nn.Conv2d, nn.ConvTranspose2d)): m2.weight.data.copy_(m1.weight) m2.bias.data.copy_(m1.bias) elif isinstance(m2, nn.BatchNorm2d): m2.running_var.copy_(m1.running_var) m2.running_mean.copy_(m1.running_mean) m2.weight.data.copy_(m1.weight) m2.bias.data.copy_(m1.bias) torch.save({'model': B.state_dict()}, 'completionnet_places2.pth')
opt = parser.parse_args() print(opt) log_file = opt.experiment + '/' + opt.log if not os.path.isdir(opt.experiment): os.system('mkdir {0}'.format(opt.experiment)) noise = torch.FloatTensor(opt.batchSize, 100, 1, 1) noise_int = torch.FloatTensor(opt.batchSize * 3 / 2, 100, 1, 1) # for test fixed_noise = torch.FloatTensor(opt.batchSize, 100, 1, 1).normal_(0, 1) fixed_noise = fixed_noise.cuda() fixed_noise_v = Variable(fixed_noise) fixed_txt = load_lua( './txt1024.t7') #this flower has white petals and a yellow stamen fixed_txt = fixed_txt.view(1, 1024, 1, 1) fixed_txt = fixed_txt.expand(opt.batchSize, 1024, 1, 1) fixed_txt = fixed_txt.cuda() fixed_txt_v = Variable(fixed_txt) input_img = torch.FloatTensor(opt.batchSize, opt.nc, opt.imSize, opt.imSize) input_txt = torch.FloatTensor(opt.batchSize, 1024, 1, 1) input_txt_int = torch.FloatTensor(opt.batchSize * 3 / 2, 1024, 1, 1) input_txt_int_cpu = torch.FloatTensor(opt.batchSize * 3 / 2, 1024, 1, 1) fake_img = torch.FloatTensor(opt.batchSize, 3, opt.imSize, opt.imSize) fake_img_int = torch.FloatTensor(opt.batchSize * 3 / 2, 3, opt.imSize, opt.imSize) wrong_img = torch.FloatTensor(opt.batchSize, 3, opt.imSize, opt.imSize) target_img = torch.FloatTensor(opt.batchSize, 3, opt.imSize, opt.imSize) noise, noise_int = noise.cuda(), noise_int.cuda()
## Weights init function def weights_init(m): classname = m.__class__.__name__ if classname.find('Conv') != -1: m.weight.data.normal_(0.0, 0.02) ## Initialization TNet = Image_transform_net() if not param.trained_model: VGG16 = VGG16() # VGG-16 working on [0,255] scale # Can't use PyTorch trained model (https://github.com/pytorch/vision/blob/master/torchvision/models/vgg.py) because we need access to in-between steps # Need to use Justin Johnson Lua trained model and convert it os.chdir(param.VGG16_folder) os.system('wget -nc http://cs.stanford.edu/people/jcjohns/fast-neural-style/models/vgg16.t7') VGG16_Lua = load_lua('vgg16.t7') for (src, dst) in zip(VGG16_Lua.parameters()[0], VGG16.parameters()): # dst[:].data = src[:] dst.data[:] = src torch.save(VGG16.state_dict(), f"{base_dir}/VGG16.pth") # Initialize weights TNet.apply(weights_init) # Load existing models if param.model_load != '': TNet.load_state_dict(torch.load(param.model_load)) print(TNet) print(TNet, file=log_output) if not param.trained_model: print(VGG16)
def main(): # cofiguration os.environ['CUDA_VISIBLE_DEVICES'] = args.gpu_id torch.manual_seed(args.seed) if args.cuda: print('using CUDA with gpu_id:') print(args.gpu_id) torch.cuda.manual_seed(args.seed) # dataset unlabeledset = load_lua( '/home/hankuan1993/dataset/stl10/stl10-unlabeled-scaled-tensor.t7') unlabeledsetnp = unlabeledset.numpy() trainset = load_lua( '/home/hankuan1993/dataset/stl10/stl10-train-scaled-tensor.t7') trainsetnp = trainset.numpy() testset = load_lua( '/home/hankuan1993/dataset/stl10/stl10-test-scaled-tensor.t7') testsetnp = testset.numpy() trainsetnp = np.concatenate((unlabeledsetnp, trainsetnp), axis=0) trainlen = len(trainsetnp) testlen = len(testsetnp) # model model = CVAE() if args.loadPrev: print('====> loading previously saved model ...') model.load_state_dict(torch.load('./cvaeCheckPoint.pth')) if args.cuda: print('====> loading model to gpu ...') model.cuda() optimizer = optim.Adam(model.parameters(), lr=1e-4) # train and evaluate for epoch in range(1, args.epochs + 1): # train model.train() train_loss = 0 traintime = math.ceil(trainlen / args.batch_size) shuffleidx = np.random.permutation(trainsetnp.shape[0]) for batch_idx in range(traintime): datanp = trainsetnp[shuffleidx[batch_idx * args.batch_size:(batch_idx + 1) * args.batch_size], :, :, :].astype( np.float32) / 255.0 data = torch.from_numpy(datanp) data = Variable(data) if args.cuda: data = data.cuda() optimizer.zero_grad() recon_batch, mu, logvar = model(data) loss = loss_function(recon_batch, data, mu, logvar) loss.backward() train_loss += loss.data[0] optimizer.step() # if batch_idx % args.log_interval == 0: # print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.format( # epoch, batch_idx * len(data), len(train_loader.dataset), # 100. * batch_idx / len(train_loader), # loss.data[0] / len(data))) print('====> Epoch: {} Train Average loss: {:.4f}'.format( epoch, train_loss / traintime / args.batch_size)) # evaluate model.eval() test_loss = 0 for test_idx in range(testlen): datanp = testsetnp[test_idx, :, :, :].astype(np.float32) / 255.0 data = torch.from_numpy(datanp) if args.cuda: data = data.cuda() data = Variable(data, volatile=True) recon_batch, mu, logvar = model(data) test_loss += loss_function(recon_batch, data, mu, logvar).data[0] test_loss /= testlen print('====> Test set loss: {:.4f}'.format(test_loss)) # Since training is finished, save it! :) torch.save(model.state_dict(), './cvaeCheckPoint.pth')
def load_activations(activations_path, num_neurons_per_layer=None, is_brnn=False): """Load extracted activations. Parameters ---------- activations_path : str Path to the activations file. Can be of type t7, pt, acts, json or hdf5 num_neurons_per_layer : int, optional Number of neurons per layer - used to compute total number of layers. This is only necessary in the case of t7/p5/acts activations. is_brnn : bool, optional If the model used to extract activations was bidirectional (default: False) Returns ------- activations : list of numpy.ndarray List of *sentence representations*, where each *sentence representation* is a numpy matrix of shape ``[num tokens in sentence x concatenated representation size]`` num_layers : int Number of layers. This is usually representation_size/num_neurons_per_layer. Divide again by 2 if model was bidirectional """ file_ext = activations_path.split(".")[-1] activations = None num_layers = None # Load activations based on type # Also ensure everything is on the CPU # as activations may have been saved as CUDA variables if file_ext == "t7": # t7 loading requires torch < 1.0 print("Loading seq2seq-attn activations from %s..." % (activations_path)) assert ( num_neurons_per_layer is not None ), "t7 activations require num_neurons_per_layer" from torch.utils.serialization import load_lua activations = load_lua(activations_path)["encodings"] activations = [a.cpu() for a in activations] num_layers = len(activations[0][0]) / num_neurons_per_layer if is_brnn: num_layers /= 2 elif file_ext == "pt": print("Loading OpenNMT-py activations from %s..." % (activations_path)) assert ( num_neurons_per_layer is not None ), "pt activations require num_neurons_per_layer" activations = torch.load(activations_path) activations = [ torch.stack([torch.cat(token) for token in sentence]).cpu() for sentence in activations ] num_layers = len(activations[0][0]) / num_neurons_per_layer elif file_ext == "acts": print("Loading generic activations from %s..." % (activations_path)) assert ( num_neurons_per_layer is not None ), "acts activations require num_neurons_per_layer" with open(activations_path, "rb") as activations_file: activations = pickle.load(activations_file) # Combine all layers sequentially print("Combining layers " + str([a[0] for a in activations])) activations = [a[1] for a in activations] num_layers = len(activations) num_sentences = len(activations[0]) concatenated_activations = [] for sentence_idx in range(num_sentences): sentence_acts = [] for layer_idx in range(num_layers): sentence_acts.append(np.vstack(activations[layer_idx][sentence_idx])) concatenated_activations.append(np.concatenate(sentence_acts, axis=1)) activations = concatenated_activations elif file_ext == "hdf5": print("Loading hdf5 activations from %s..." % (activations_path)) representations = h5py.File(activations_path, "r") sentence_to_index = json.loads(representations.get("sentence_to_index")[0]) activations = [] # TODO: Check order for _, value in sentence_to_index.items(): sentence_acts = torch.FloatTensor(representations[value]) num_layers, sentence_length, embedding_size = ( sentence_acts.shape[0], sentence_acts.shape[1], sentence_acts.shape[2], ) num_neurons_per_layer = embedding_size sentence_acts = np.swapaxes(sentence_acts, 0, 1) sentence_acts = sentence_acts.reshape( sentence_length, num_layers * embedding_size ) activations.append(sentence_acts.numpy()) num_layers = len(activations[0][0]) / num_neurons_per_layer elif file_ext == "json": print("Loading json activations from %s..." % (activations_path)) activations = [] with open(activations_path) as fp: for line in fp: token_acts = [] sentence_activations = json.loads(line)["features"] for act in sentence_activations: num_neurons_per_layer = len(act["layers"][0]["values"]) token_acts.append( np.concatenate([l["values"] for l in act["layers"]]) ) activations.append(np.vstack(token_acts)) num_layers = activations[0].shape[1] / num_neurons_per_layer print(len(activations), num_layers) else: assert False, "Activations must be of type t7, pt, acts, json or hdf5" return activations, int(num_layers)
print("Processing sentences - Building SID Tensor") num_sentences = len(sentences) data = np.empty((num_sentences, 2), dtype=np.int32) for idx, item in enumerate(sentences.items()): if (idx % 100000) == 0: print(idx, num_sentences) key, value = item start_idx, length = value data[idx, 0] = start_idx data[idx, 1] = length return data assert (len(sys.argv) == 3) path = sys.argv[1] filename = sys.argv[2] print("Filepath:", path) print("Output:", filename) word_freq = load_lua(os.path.join(path, 'word_freq.th7')).numpy() print("Loaded Tensor") data = build(os.path.join(path, 'train_data.th7')) print("Build Sentence ID Tensor") with open(filename, 'wb') as f: np.savez(f, item=data) print("Saved Sentence ID Tensor")
################################################################## # prepare our data, we first to build a test dataset which is like # the MIT ecg data. it is <5x1x400> import torch import time import math import torch.nn.functional as F from torch.autograd import Variable from torch.utils.serialization import load_lua N, T, D = 50, 5, 400 #opt.batch_size, opt.seq_length , word_dim train_temp = load_lua('/home/lu/code/D1Train.t7') trainset = train_temp.view(50, -1, 2000).transpose(0, 1).clone() data_len = trainset.size()[0] test_temp = load_lua('/home/lu/code/D1Test.t7') testset = test_temp.view(-1, 2000) test_len = testset.size()[0] print(data_len, test_len) count = 0 def timeSince(since): now = time.time() s = now - since m = math.floor(s / 60) s -= m * 60 return '%dm %ds' % (m, s)
def convert(model, input_shapes, output_shapes=None, input_names=['input'], output_names=['output'], mode=None, image_input_names=[], preprocessing_args={}, image_output_names=[], deprocessing_args={}, class_labels=None, predicted_feature_name='classLabel', unknown_layer_converter_fn=None): """ Convert Torch7 model to CoreML. Parameters ---------- model: Torch7 model (loaded with PyTorch) | str A trained Torch7 model loaded in python using PyTorch or path to file with model (*.t7). input_shapes: list of tuples Shapes of the input tensors. mode: str ('classifier', 'regressor' or None) Mode of the converted coreml model: 'classifier', a NeuralNetworkClassifier spec will be constructed. 'regressor', a NeuralNetworkRegressor spec will be constructed. preprocessing_args: dict 'is_bgr', 'red_bias', 'green_bias', 'blue_bias', 'gray_bias', 'image_scale' keys with the same meaning as https://apple.github.io/coremltools/generated/coremltools.models.neural_network.html#coremltools.models.neural_network.NeuralNetworkBuilder.set_pre_processing_parameters deprocessing_args: dict Same as 'preprocessing_args' but for deprocessing. class_labels: A string or list of strings. As a string it represents the name of the file which contains the classification labels (one per line). As a list of strings it represents a list of categories that map the index of the output of a neural network to labels in a classifier. predicted_feature_name: str Name of the output feature for the class labels exposed in the Core ML model (applies to classifiers only). Defaults to 'classLabel' unknown_layer_converter_fn: function with signature: (builder, name, layer, input_names, output_names) builder: object - instance of NeuralNetworkBuilder class name: str - generated layer name layer: object - pytorch object for corresponding layer input_names: list of strings output_names: list of strings Returns: list of strings for layer output names Callback function to handle unknown for torch2coreml layers Returns ------- model: A coreml model. """ _gen_layer_name.called = 0 _get_layer_converter_fn.unknown_converter_fn = unknown_layer_converter_fn if isinstance(model, basestring): torch_model = load_lua(model, unknown_classes=True) elif isinstance(model, torch.legacy.nn.Sequential): torch_model = model else: raise TypeError( "Model must be file path to .t7 file or pytorch loaded model \ with torch.legacy.nn.Sequential module as root" ) #torch_model.evaluate() if not isinstance(input_shapes, list): raise TypeError("Input shapes should be a list of tuples.") for shape in input_shapes: if not isinstance(shape, tuple): raise TypeError("Input shape should be a tuple.") if len(input_names) != len(input_shapes): raise ValueError( "Input names count must be equal to input shapes count" ) if output_shapes == None: output_shapes = _infer_torch_output_shapes( torch_model, input_shapes ) if len(output_shapes) != len(output_names): raise ValueError( "Model has {} outputs, but you set output_names for {}." .format(len(output_shapes), len(output_names)) ) # create input/output features input_features = [] for i in range(len(input_names)): input_features.append( (input_names[i], datatypes.Array(*input_shapes[i])) ) output_features = [] for i in range(len(output_names)): output_features.append( (output_names[i], datatypes.Array(*output_shapes[i])) ) builder = NeuralNetworkBuilder(input_features, output_features, mode) # build model layer_name = _gen_layer_name(torch_model) _output_names = output_names[:] if len(image_output_names) > 0: for i in range(len(_output_names)): if _output_names[i] in image_output_names: _output_names[i] = _gen_layer_name(_DEPROCESS_LAYER_NAME) model_output_names = _layers._convert_layer( builder, layer_name, torch_model, input_names, _output_names ) # set preprocessing parameters if len(image_input_names) > 0: builder.set_pre_processing_parameters( image_input_names=image_input_names, is_bgr=preprocessing_args.get('is_bgr', False), red_bias=preprocessing_args.get('red_bias', 0.0), green_bias=preprocessing_args.get('green_bias', 0.0), blue_bias=preprocessing_args.get('blue_bias', 0.0), gray_bias=preprocessing_args.get('gray_bias', 0.0), image_scale=preprocessing_args.get('image_scale', 1.0) ) # set deprocessing parameters if len(image_output_names) > 0: for i in range(len(output_names)): output_name = output_names[i] if output_name in image_output_names: output_shape = output_shapes[i] if len(output_shape) == 2 or output_shape[0] == 1: is_grayscale = True elif output_shape[0] == 3: is_grayscale = False else: raise ValueError('Output must be RGB image or Grayscale') _set_deprocessing( is_grayscale, builder, deprocessing_args, model_output_names[i], output_name ) if class_labels is not None: if type(class_labels) is str: labels = [l.strip() for l in open(class_labels).readlines()] elif type(class_labels) is list: labels = class_labels else: raise TypeError( "synset variable of unknown type. Type found: {}. \ Expected either string or list of strings." .format(type(class_labels),)) builder.set_class_labels( class_labels=labels, predicted_feature_name=predicted_feature_name ) return MLModel(builder.spec)
# load_lua is supported in pytorch 0.4.1 but not 1.0.0 import torch import collections from torch.utils.serialization import load_lua multiGPU = False prefix = 'module.' if multiGPU else '' model1 = load_lua('vgg_SCNN_DULR_w9.t7', unknown_classes=True) model2 = collections.OrderedDict() model2[prefix + 'conv1_1.weight'] = model1.modules[0].weight model2[prefix + 'bn1_1.weight'] = model1.modules[1].weight model2[prefix + 'bn1_1.bias'] = model1.modules[1].bias model2[prefix + 'bn1_1.running_mean'] = model1.modules[1].running_mean model2[prefix + 'bn1_1.running_var'] = model1.modules[1].running_var model2[prefix + 'conv1_2.weight'] = model1.modules[3].weight model2[prefix + 'bn1_2.weight'] = model1.modules[4].weight model2[prefix + 'bn1_2.bias'] = model1.modules[4].bias model2[prefix + 'bn1_2.running_mean'] = model1.modules[4].running_mean model2[prefix + 'bn1_2.running_var'] = model1.modules[4].running_var model2[prefix + 'conv2_1.weight'] = model1.modules[7].weight model2[prefix + 'bn2_1.weight'] = model1.modules[8].weight model2[prefix + 'bn2_1.bias'] = model1.modules[8].bias model2[prefix + 'bn2_1.running_mean'] = model1.modules[8].running_mean model2[prefix + 'bn2_1.running_var'] = model1.modules[8].running_var model2[prefix + 'conv2_2.weight'] = model1.modules[10].weight model2[prefix + 'bn2_2.weight'] = model1.modules[11].weight model2[prefix + 'bn2_2.bias'] = model1.modules[11].bias model2[prefix + 'bn2_2.running_mean'] = model1.modules[11].running_mean
import torch import math import torch.nn as nn from torch.autograd import Variable from torch.utils.serialization import load_lua N, T, D = 50, 5, 400 #opt.batch_size, opt.seq_length , word_dim train_temp = load_lua('D1Train.t7') trainset = train_temp.view(50, -1, 2000).transpose(0, 1).clone().cuda() data_len = trainset.size()[0] test_temp = load_lua('D1Test.t7') testset = train_temp.view(-1, 2000).cuda() test_len = testset.size()[0] count = 0 def read_data(): global count, trainset x = trainset[count].view(N, T, D).transpose(0, 1).clone() x = x.type('torch.FloatTensor') count += 1 if (count == data_len): count = 0 y = torch.LongTensor(50)
if pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet152'])) return model import torchfile from torch.utils.serialization import load_lua import torch netparams = torchfile.load('data/resnet152/netparams.t7') #netparams2 = load_lua('data/resnet152/netparams.t7') #import ipdb; ipdb.set_trace() netoutputs = [] for i in range(1, 12): path = 'data/resnet152/output{}.t7'.format(i) out = load_lua(path) #print(out.size()) if out.dim() == 4: pass #out.transpose_(2, 3) netoutputs.append(out) net = resnet152() state_dict = net.state_dict() import collections s = collections.OrderedDict() i = 0 for key in state_dict.keys(): new = torch.from_numpy(netparams[i])
ids.append(vocab('<end>')) return ids for _class in sorted(os.listdir(embedding_path)): split = '' if _class in train_classes: split = train elif _class in val_classes: split = valid elif _class in test_classes: split = test data_path = os.path.join(embedding_path, _class) txt_path = os.path.join(text_path, _class) for example, txt_file in zip(sorted(glob(data_path + "/*.t7")), sorted(glob(txt_path + "/*.txt"))): example_data = load_lua(example) img_path = example_data['img'] embeddings = example_data['txt'].numpy() example_name = img_path.split('/')[-1][:-4] f = open(txt_file, "r") txt = f.readlines() f.close() img_path = os.path.join(images_path, img_path) img = open(img_path, 'rb').read() txt_choice = np.random.choice(range(10), 5) embeddings = embeddings[txt_choice]
parser.add_argument('--save', type=str, default='model.pt', help='path to save the final model') args = parser.parse_args() # Set the random seed manually for reproducibility. torch.manual_seed(args.seed) torch.cuda.manual_seed(args.seed) ############################################################################### # Load data ############################################################################### # Torch word_freq = load_lua(os.path.join(args.data, 'word_freq.th7')).numpy() mapto = torch.from_numpy(util.reverse(np.argsort(-word_freq))).long() print("load word frequency mapping - complete") ntokens = len(word_freq) nsampled = 8192 train_corpus = FastGBWDataset(args.data, 'train_data.th7', 'train_data.sid', mapto) print("load train data - complete") test_corpus = GBWDataset(args.data, 'test_data.th7', mapto) print("load test data - complete") # Streaming '''
def __init__(self, model_file): self.net = load_lua(model_file)
import h5py parser = argparse.ArgumentParser(description='Predict variant chromatin effects') parser.add_argument('inputfile', type=str, help='Input file in vcf format') parser.add_argument('--maxshift', action="store", dest="maxshift", type=int, default=800, help='Maximum shift distance for computing nearby effects') parser.add_argument('--inputsize', action="store", dest="inputsize", type=int, default=2000, help="The input sequence window size for neural network") parser.add_argument('--batchsize', action="store", dest="batchsize", type=int, default=32, help="Batch size for neural network predictions.") parser.add_argument('--cuda', action='store_true') args = parser.parse_args() genome = pyfasta.Fasta('./resources/hg19.fa') model = load_lua('./resources/deepsea.beluga.2002.cpu') model.evaluate() if args.cuda: model.cuda() CHRS = ['chr1', 'chr2', 'chr3', 'chr4', 'chr5', 'chr6', 'chr7', 'chr8', 'chr9', 'chr10', 'chr11', 'chr12', 'chr13', 'chr14', 'chr15', 'chr16', 'chr17', 'chr18', 'chr19', 'chr20', 'chr21', 'chr22', 'chrX','chrY'] inputfile = args.inputfile maxshift = args.maxshift inputsize = args.inputsize batchSize = args.batchsize windowsize = inputsize + 100
""" model = ResNet(Bottleneck, [3, 8, 36, 3], **kwargs) if pretrained: model.load_state_dict(model_zoo.load_url(model_urls['resnet152'])) return model import torchfile from torch.utils.serialization import load_lua import torch netparams = torchfile.load('data/resnet152/netparams.t7') #netparams2 = load_lua('data/resnet152/netparams.t7') #import ipdb; ipdb.set_trace() netoutputs = [] for i in range(1, 12): path = 'data/resnet152/output{}.t7'.format(i) out = load_lua(path) #print(out.size()) if out.dim()==4: pass#out.transpose_(2, 3) netoutputs.append(out) net = resnet152() state_dict = net.state_dict() import collections s = collections.OrderedDict() i=0 for key in state_dict.keys(): new = torch.from_numpy(netparams[i])
def main(args): opt = parser.parse_args(args) print('parsed options:', vars(opt)) os.environ['CUDA_VISIBLE_DEVICES'] = opt.gpu_id if torch.cuda.is_available(): # to prevent opencv from initializing CUDA in workers torch.randn(8).cuda() os.environ['CUDA_VISIBLE_DEVICES'] = '' def load_provider(): print('Loading test data') p = np.load(opt.test_set)[()] for i, t in enumerate(['matches', 'nonmatches']): p[t] = p['match_data'][opt.test_matches][i] return p test_iter = get_iterator(load_provider(), opt.batch_size, opt.nthread) def cast(t): return t.cuda() if torch.cuda.is_available() else t f = models[opt.model] net = load_lua(opt.lua_model) if opt.model == '2ch': params = {} for j, i in enumerate([0, 3, 6]): params['conv%d.weight' % j] = net.get(i).weight params['conv%d.bias' % j] = net.get(i).bias params['fc.weight'] = net.get(9).weight params['fc.bias'] = net.get(9).bias elif opt.model == '2ch2stream': params = {} for j, branch in enumerate(['fovea', 'retina']): for k, layer in enumerate(map(net.get(0).get(j).get(1).get, [1, 4, 7, 9])): params['%s.conv%d.weight' % (branch, k)] = layer.weight params['%s.conv%d.bias' % (branch, k)] = layer.bias for k, layer in enumerate(map(net.get, [1, 3])): params['fc%d.weight' % k] = layer.weight params['fc%d.bias' % k] = layer.bias elif opt.model == 'siam' or opt.model == 'siam_l2': params = {} for k, layer in enumerate(map(net.get(0).get(0).get, [1, 4, 7])): params['conv%d.weight' % k] = layer.weight params['conv%d.bias' % k] = layer.bias for k, layer in enumerate(map(net.get, [1, 3])): params['fc%d.weight' % k] = layer.weight params['fc%d.bias' % k] = layer.bias elif opt.model == 'siam2stream' or opt.model == 'siam2stream_l2': params = {} for stream, name in zip(net.get(0).get(0).modules, ['retina', 'fovea']): for k, layer in enumerate(map(stream.get, [2, 5, 7, 9])): params['%s.conv%d.weight' % (name, k)] = layer.weight params['%s.conv%d.bias' % (name, k)] = layer.bias for k, layer in enumerate(map(net.get, [1, 3])): params['fc%d.weight' % k] = layer.weight params['fc%d.bias' % k] = layer.bias params = {k: Variable(cast(v)) for k, v in params.items()} def create_variables(sample): inputs = Variable(cast(sample['input'].float().view(-1, 2, 64, 64))) targets = Variable(cast(sample['target'].float().view(-1))) return inputs, targets test_outputs, test_targets = [], [] for sample in tqdm(test_iter, dynamic_ncols=True): inputs, targets = create_variables(sample) y = f(inputs, params) test_targets.append(sample['target'].view(-1)) test_outputs.append(y.data.cpu().view(-1)) fpr, tpr, thresholds = metrics.roc_curve(torch.cat(test_targets).numpy(), torch.cat(test_outputs).numpy(), pos_label=1) fpr95 = float(interpolate.interp1d(tpr, fpr)(0.95)) print('FPR95:', fpr95) return fpr95
import argparse import os import torch import torchvision.models as models from torch.utils.serialization import load_lua """ Read a .t7 file written by caffemodel_to_t7.lua and convert it to a PyTorch .pth file containing a state dict for a VGG model. """ parser = argparse.ArgumentParser() parser.add_argument('--input_t7', required=True) parser.add_argument('--model_name', required=True) args = parser.parse_args() t7_model = load_lua(args.input_t7)['model'] pytorch_model = getattr(models, args.model_name)() feature_modules = list(pytorch_model.features.modules()) classifier_modules = list(pytorch_model.classifier.modules()) pytorch_modules = feature_modules + classifier_modules next_pytorch_idx = 0 for i, t7_module in enumerate(t7_model.modules): if not hasattr(t7_module, 'weight'): continue assert hasattr(t7_module, 'bias') while not hasattr(pytorch_modules[next_pytorch_idx], 'weight'): next_pytorch_idx += 1 pytorch_module = pytorch_modules[next_pytorch_idx] next_pytorch_idx += 1
copy_group_conv(block.conv_group_2, parameters[2]) copy_bn_relu(block.bn_relu_3, parameters[3]) copy_conv_bn(block.conv_bn_4, [parameters[4], parameters[5]]) if skip_connection is not None: copy_conv_bn(skip_connection, [parameters[6], parameters[7]]) if __name__ == '__main__': parser = argparse.ArgumentParser( description='convert torch resnext model to chainer resnext model') parser.add_argument('--t7', '-t', default=str, help='t7 file') args = parser.parse_args().__dict__ t7 = args['t7'] print(args) print('start convering') trained_model = load_lua(t7, unknown_classes=True) components = [] def dfs(modules): try: for module in modules.modules: dfs(module) except: components.append(modules) dfs(trained_model) parameters = [] for c in components: for judge, extract in ((judge_bn, extract_bn), (judge_linear, extract_linear), (judge_conv,
# # Up_conv2 # py_model['model.6.weight'] = net.modules[7].weight # py_model['model.6.bias'] = net.modules[7].bias # # HR_conv1 # py_model['model.8.weight'] = net.modules[9].weight # py_model['model.8.bias'] = net.modules[9].bias # # final_conv # py_model['model.10.weight'] = net.modules[11].weight # py_model['model.10.bias'] = net.modules[11].bias # assert ori_keys == len(py_model), 'the keys mismatch! Please check.' # torch.save(py_model, 'SRResNet_noBN_torch.pth') # SRResNet w/ BN net = load_lua('torch_models/01_SRResNet_nnCPU.t7') py_model = torch.load('pytorch_models/SRResNet.pth') for k, v in py_model.items(): print(k) ori_keys = len(py_model) # first conv py_model['model.0.weight'] = net.modules[0].weight py_model['model.0.bias'] = net.modules[0].bias # 16 Residual Blocks for i in range(16): t_bn1_w = net.modules[1].modules[0].modules[i].modules[0].modules[ 0].modules[0].weight t_bn1_b = net.modules[1].modules[0].modules[i].modules[0].modules[ 0].modules[0].bias t_bn1_rm = net.modules[1].modules[0].modules[i].modules[0].modules[
def train_cur_data(cur_epoch, datapart, moving_file, target_file, parameter, output_name, net, criterion, optimizer, registration_spec, args): old_experiments = False if moving_file[-3:] == '.t7': old_experiments = True #only for old data used in the Neuroimage paper. Do not use .t7 format for new data and new experiments. moving_appear_trainset = load_lua(moving_file).float() target_appear_trainset = load_lua(target_file).float() train_m0 = load_lua(parameter).float() else: moving_appear_trainset = torch.load(moving_file).float() target_appear_trainset = torch.load(target_file).float() train_m0 = torch.load(parameter).float() input_batch = torch.zeros(args.batch_size, 2, args.patch_size, args.patch_size, args.patch_size).cuda() output_batch = torch.zeros(args.batch_size, 3, args.patch_size, args.patch_size, args.patch_size).cuda() dataset_size = moving_appear_trainset.size() flat_idx = util.calculatePatchIdx3D(dataset_size[0], args.patch_size * torch.ones(3), dataset_size[1:], args.stride * torch.ones(3)) flat_idx_select = torch.zeros(flat_idx.size()) for patch_idx in range(1, flat_idx.size()[0]): patch_pos = util.idx2pos_4D(flat_idx[patch_idx], dataset_size[1:]) moving_patch = moving_appear_trainset[patch_pos[0], patch_pos[1]:patch_pos[1] + args.patch_size, patch_pos[2]:patch_pos[2] + args.patch_size, patch_pos[3]:patch_pos[3] + args.patch_size] target_patch = target_appear_trainset[patch_pos[0], patch_pos[1]:patch_pos[1] + args.patch_size, patch_pos[2]:patch_pos[2] + args.patch_size, patch_pos[3]:patch_pos[3] + args.patch_size] if (torch.sum(moving_patch) + torch.sum(target_patch) != 0): flat_idx_select[patch_idx] = 1 flat_idx_select = flat_idx_select.byte() flat_idx = torch.masked_select(flat_idx, flat_idx_select) N = flat_idx.size()[0] / args.batch_size for iters in range(0, N): train_idx = (torch.rand(args.batch_size).double() * flat_idx.size()[0]) train_idx = torch.floor(train_idx).long() for slices in range(0, args.batch_size): patch_pos = util.idx2pos_4D(flat_idx[train_idx[slices]], dataset_size[1:]) input_batch[slices, 0] = moving_appear_trainset[patch_pos[0], patch_pos[1]:patch_pos[1] + args.patch_size, patch_pos[2]:patch_pos[2] + args.patch_size, patch_pos[3]:patch_pos[3] + args.patch_size].cuda() input_batch[slices, 1] = target_appear_trainset[patch_pos[0], patch_pos[1]:patch_pos[1] + args.patch_size, patch_pos[2]:patch_pos[2] + args.patch_size, patch_pos[3]:patch_pos[3] + args.patch_size].cuda() output_batch[slices] = train_m0[patch_pos[0], :, patch_pos[1]:patch_pos[1] + args.patch_size, patch_pos[2]:patch_pos[2] + args.patch_size, patch_pos[3]:patch_pos[3] + args.patch_size].cuda() input_batch_variable = Variable(input_batch).cuda() output_batch_variable = Variable(output_batch).cuda() optimizer.zero_grad() recon_batch_variable = net(input_batch_variable) loss = criterion(recon_batch_variable, output_batch_variable) loss.backward() loss_value = loss.data[0] optimizer.step() print( '====> Epoch: {}, datapart: {}, iter: {}/{}, loss: {:.4f}'.format( cur_epoch + 1, datapart + 1, iters, N, loss_value / args.batch_size)) if iters % 100 == 0 or iters == N - 1: if args.n_GPU > 1: cur_state_dict = net.module.state_dict() else: cur_state_dict = net.state_dict() modal_name = output_name model_info = { 'patch_size': args.patch_size, 'network_feature': args.features, 'state_dict': cur_state_dict, 'deformation_params': registration_spec } if old_experiments: model_info['matlab_t7'] = True #endif torch.save(model_info, modal_name)
all_networks = {} canonical_ordering = [] for language, version in tqdm(p(languages, [1, 2, 3]), desc='loading', total=len(languages) * 3): network_name = 'en-%s-%d' % (language, version) canonical_ordering.append(network_name) # Load the description of the network # This will be a 4000x(sentence_length)x500 matrix. # Rehsape to be a (total_tokens)x500 matrix. all_networks[network_name] = torch.cat( load_lua('../descriptions/%s.desc.t7' % (network_name, ))) print(canonical_ordering) # Create enormous data set, which will have # a second dimension of size 500*15 = 7500 # Transfer it to CUDA. full_set = torch.cat([all_networks[network] for network in canonical_ordering], dim=1).cuda() # Whiten the full set full_set -= full_set.mean(0) full_set /= full_set.std(0) # Get covariances covariances = torch.mm(full_set.t(), full_set) / (full_set.size()[1] - 1)
args = parser.parse_args() # Load all the descriptions of networks # Get list of network filenames with open(args.descriptions) as f: network_fnames = [line.strip() for line in f] all_networks = {} for fname in tqdm(network_fnames): network_name = os.path.split(fname)[1] network_name = network_name[:network_name.index('.')] # Load as 4000x(sentence_length)x500 matrix all_networks[network_name] = torch.cat(load_lua(fname)['encodings']) # Whiten dimensions if args.normalize_dimensions: for network in tqdm(all_networks, desc='mu, sigma'): all_networks[network] -= all_networks[network].mean(0) all_networks[network] /= all_networks[network].std(0) # PCA to get independent components whitening_transforms = {} for network in tqdm(all_networks, desc='pca'): X = all_networks[network] covariance = torch.mm(X.t(), X) / (X.size()[0] - 1) e, v = torch.eig(covariance, eigenvectors=True)
p_wct.e1.load_state_dict(torch.load('pth_models/vgg_normalised_conv1.pth')) p_wct.d1.load_state_dict(torch.load('pth_models/feature_invertor_conv1.pth')) p_wct.e2.load_state_dict(torch.load('pth_models/vgg_normalised_conv2.pth')) p_wct.d2.load_state_dict(torch.load('pth_models/feature_invertor_conv2.pth')) p_wct.e3.load_state_dict(torch.load('pth_models/vgg_normalised_conv3.pth')) p_wct.d3.load_state_dict(torch.load('pth_models/feature_invertor_conv3.pth')) p_wct.e4.load_state_dict(torch.load('pth_models/vgg_normalised_conv4.pth')) p_wct.d4.load_state_dict(torch.load('pth_models/feature_invertor_conv4.pth')) if __name__ == '__main__': if not os.path.exists('pth_models'): os.mkdir('pth_models') ## VGGEncoder1 vgg1 = load_lua('models/vgg_normalised_conv1_1_mask.t7') e1 = VGGEncoder(1) weight_assign(vgg1, e1, { 'conv0': 0, 'conv1_1': 2, }) torch.save(e1.state_dict(), 'pth_models/vgg_normalised_conv1.pth') ## VGGDecoder1 inv1 = load_lua('models/feature_invertor_conv1_1_mask.t7') d1 = VGGDecoder(1) weight_assign(inv1, d1, { 'conv1_1': 1, }) torch.save(d1.state_dict(), 'pth_models/feature_invertor_conv1.pth')
def main(): # Hyper Parameters parser = argparse.ArgumentParser() parser.add_argument('--data_path', default='/home/ibrahim/vsepp/', help='path to datasets') parser.add_argument( '--data_name', default='cub', help='{coco,f8k,f30k,10crop}_precomp|coco|f8k|f30k|cub') parser.add_argument('--vocab_path', default='./vocab/', help='Path to saved vocabulary pickle files.') parser.add_argument('--margin', default=0.2, type=float, help='Rank loss margin.') parser.add_argument('--num_epochs', default=30, type=int, help='Number of training epochs.') parser.add_argument('--batch_size', default=60, type=int, help='Size of a training mini-batch.') parser.add_argument('--word_dim', default=300, type=int, help='Dimensionality of the word embedding.') parser.add_argument('--embed_size', default=1024, type=int, help='Dimensionality of the joint embedding.') parser.add_argument('--grad_clip', default=2., type=float, help='Gradient clipping threshold.') parser.add_argument('--crop_size', default=224, type=int, help='Size of an image crop as the CNN input.') parser.add_argument('--num_layers', default=1, type=int, help='Number of GRU layers.') parser.add_argument('--learning_rate', default=.0002, type=float, help='Initial learning rate.') parser.add_argument('--lr_update', default=15, type=int, help='Number of epochs to update the learning rate.') parser.add_argument('--workers', default=10, type=int, help='Number of data loader workers.') parser.add_argument('--log_step', default=10, type=int, help='Number of steps to print and record the log.') parser.add_argument('--val_step', default=500, type=int, help='Number of steps to run validation.') parser.add_argument('--logger_name', default='runs/runX', help='Path to save the model and Tensorboard log.') parser.add_argument('--resume', default='', type=str, metavar='PATH', help='path to latest checkpoint (default: none)') parser.add_argument('--max_violation', action='store_true', help='Use max instead of sum in the rank loss.') parser.add_argument('--img_dim', default=4096, type=int, help='Dimensionality of the image embedding.') parser.add_argument('--finetune', action='store_true', help='Fine-tune the image encoder.') parser.add_argument('--cnn_type', default='vgg19', help="""The CNN used for image encoder (e.g. vgg19, resnet152)""") parser.add_argument('--use_restval', action='store_true', help='Use the restval data for training on MSCOCO.') parser.add_argument('--measure', default='cosine', help='Similarity measure used (cosine|order)') parser.add_argument('--use_abs', action='store_true', help='Take the absolute value of embedding vectors.') parser.add_argument('--no_imgnorm', action='store_true', help='Do not normalize the image embeddings.') parser.add_argument('--reset_train', action='store_true', help='Ensure the training is always done in ' 'train mode (Not recommended).') opt = parser.parse_args() print(opt) logging.basicConfig(format='%(asctime)s %(message)s', level=logging.INFO) tb_logger.configure(opt.logger_name, flush_secs=5) # Load Vocabulary Wrapper from torch.utils.serialization import load_lua vocab = load_lua('vocab_c10.t7') # vocab = pickle.load(open(os.path.join( # opt.vocab_path, '%s_vocab.pkl' % opt.data_name), 'rb')) opt.vocab_size = len(vocab) # Load data loaders train_loader, val_loader = data.get_loaders(opt.data_name, vocab, opt.crop_size, opt.batch_size, opt.workers, opt) # Construct the model model = VSE(opt) # optionally resume from a checkpoint if opt.resume: if os.path.isfile(opt.resume): print("=> loading checkpoint '{}'".format(opt.resume)) checkpoint = torch.load(opt.resume) start_epoch = checkpoint['epoch'] best_rsum = checkpoint['best_rsum'] model.load_state_dict(checkpoint['model']) # Eiters is used to show logs as the continuation of another # training model.Eiters = checkpoint['Eiters'] print("=> loaded checkpoint '{}' (epoch {}, best_rsum {})".format( opt.resume, start_epoch, best_rsum)) validate(opt, val_loader, model) else: print("=> no checkpoint found at '{}'".format(opt.resume)) # Train the Model best_rsum = 0 for epoch in range(opt.num_epochs): adjust_learning_rate(opt, model.optimizer, epoch) # train for one epoch train(opt, train_loader, model, epoch, val_loader) # evaluate on validation set rsum = validate(opt, val_loader, model) # remember best R@ sum and save checkpoint is_best = rsum > best_rsum best_rsum = max(rsum, best_rsum) save_checkpoint( { 'epoch': epoch + 1, 'model': model.state_dict(), 'best_rsum': best_rsum, 'opt': opt, 'Eiters': model.Eiters, }, is_best, prefix=opt.logger_name + '/')