def load_vgg_all_weights(model, path):
# load a pre-trained VGG16 from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/VGG/'
filename = 'VGG_D.p'
size = 554227541
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print('De-serializing the pre-trained VGG16 model...')
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers[0].layers]
param_dict_list = pdict['model']['config']['layers']
i = 0
for layer, ps in zip(param_layers, param_dict_list):
i += 1
if i == 43:
break
layer.load_weights(ps, load_states=True)
print(layer.name + " <-- " + ps['config']['name'])
# to load the fc6 and fc7 from caffe into neon fc layers after ROI pooling
neon_fc_layers = model.layers.layers[2].layers[1].layers[0].layers[2:5] +\
model.layers.layers[2].layers[1].layers[0].layers[6:9]
vgg_fc_layers = param_dict_list[44:47] + param_dict_list[48:51]
for layer, ps in zip(neon_fc_layers, vgg_fc_layers):
layer.load_weights(ps, load_states=True)
print(layer.name + " <-- " + ps['config']['name'])
def load_vgg_all_weights(model, path):
# load a pre-trained VGG16 from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/VGG/'
filename = 'VGG_D.p'
size = 554227541
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print('De-serializing the pre-trained VGG16 model...')
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers[0].layers]
param_dict_list = pdict['model']['config']['layers']
i = 0
for layer, ps in zip(param_layers, param_dict_list):
i += 1
if i == 43:
break
layer.load_weights(ps, load_states=True)
print(layer.name + " <-- " + ps['config']['name'])
# to load the fc6 and fc7 from caffe into neon fc layers after ROI pooling
neon_fc_layers = model.layers.layers[2].layers[1].layers[0].layers[2:5] +\
model.layers.layers[2].layers[1].layers[0].layers[6:9]
vgg_fc_layers = param_dict_list[44:47] + param_dict_list[48:51]
for layer, ps in zip(neon_fc_layers, vgg_fc_layers):
layer.load_weights(ps, load_states=True)
print(layer.name + " <-- " + ps['config']['name'])
def load_imagenet_weights(model, path):
# load a pre-trained Alexnet from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/'
filename = 'alexnet.p'
size = 488808400
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print 'De-serializing the pre-trained Alexnet using ImageNet I1K ...'
pdict = load_obj(filepath)
param_layers = [l for l in model.layers_to_optimize]
param_dict_list = pdict['layer_params_states']
i = 0
for layer, ps in zip(param_layers, param_dict_list):
i = i+1
print i, layer.name
layer.set_params(ps)
if 'states' in ps:
layer.set_states(ps)
if i == 10:
print 'Only load the pre-trained weights up to conv5 layer of Alexnet'
break
def load_imagenet_weights(model, path):
# load a pre-trained Alexnet from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/alexnet/old/pre_v1.4.0/'
filename = 'alexnet.p'
size = 488808400
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print 'Loading the Alexnet pre-trained with ImageNet I1K from: ' + filepath
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers]
param_dict_list = pdict['model']['config']['layers']
skip_loading = False
for i, layer in enumerate(param_layers):
if not load_pre_trained_weight(i, layer):
skip_loading = True
if not skip_loading:
ps = param_dict_list[i]
print "Loading weights for:{} [src: {}]".format(
layer.name, ps['config']['name'])
layer.load_weights(ps, load_states=True)
else:
config_name = param_dict_list[i]['config']['name'] if i < len(
param_dict_list) else ""
print "Skipped loading weights for: {} [src: {}]".format(
layer.name, config_name)
return
def load_imagenet_weights(model, path):
# load a pre-trained Alexnet from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/'
filename = 'alexnet.p'
size = 488808400
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print 'De-serializing the pre-trained Alexnet using ImageNet I1K ...'
pdict = load_obj(filepath)
param_layers = [l for l in model.layers_to_optimize]
param_dict_list = pdict['layer_params_states']
i = 0
for layer, ps in zip(param_layers, param_dict_list):
i = i + 1
print i, layer.name
layer.set_params(ps)
if 'states' in ps:
layer.set_states(ps)
if i == 10:
print 'Only load the pre-trained weights up to conv5 layer of Alexnet'
break
def load_vgg_weights(model, path):
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/'
filename = 'VGG_ILSVRC_16_layers_fc_reduced_fused_conv_bias.p'
size = 86046032
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print('De-serializing the pre-trained VGG16 model with dilated convolutions...')
pdict = load_obj(filepath)
model_layers = [l for l in model.layers.layers[0].layers]
# convert source model into dictionary with layer name as keys
src_layers = {layer['config']['name']: layer for layer in pdict['model']['config']['layers']}
i = 0
for layer in model_layers:
if layer.classnm == 'Convolution_bias' and i < 15:
# no states in above parameter file
layer.load_weights(src_layers['Convolution_bias_'+str(i)], load_states=False)
print('{} loaded from source file'.format(layer.name))
i += 1
elif hasattr(layer, 'W'):
print('Skipping {} layer'.format(layer.name))
def load_vgg_weights(model, path):
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/'
filename = 'VGG_ILSVRC_16_layers_fc_reduced.p'
size = 244190212
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print(
'De-serializing the pre-trained VGG16 model with dilated convolutions...'
)
pdict = load_obj(filepath)
model_layers = [l for l in model.layers.layers[0].layers]
# convert source model into dictionary with layer name as keys
src_layers = {
layer['config']['name']: layer
for layer in pdict['model']['config']['layers']
}
for layer in model_layers:
if layer.name in src_layers.keys():
layer.load_weights(src_layers[layer.name], load_states=True)
print('{} loaded from source file'.format(layer.name))
elif hasattr(layer, 'W'):
print('Skipping {} layer'.format(layer.name))
def test_pascalvoc(backend_default, data):
url = "https://s3-us-west-1.amazonaws.com/nervana-pascal-voc-data"
filename = "pascal_data_ref.pkl"
size = 423982870
workdir, filepath = Dataset._valid_path_append(data, "", filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
with open(filepath, "rb") as handle:
neon_data_ref = pickle.loads(handle.read())
n_mb = neon_data_ref["n_mb"]
img_per_batch = neon_data_ref["img_per_batch"]
rois_per_img = neon_data_ref["rois_per_img"]
dataset = neon_data_ref["dataset"]
year = neon_data_ref["year"]
output_type = neon_data_ref["output_type"]
rois_random_sample = neon_data_ref["rois_random_sample"]
shuffle = neon_data_ref["shuffle"]
train_set = PASCALVOC(
dataset,
year,
path=data,
output_type=output_type,
n_mb=n_mb,
img_per_batch=img_per_batch,
rois_per_img=rois_per_img,
rois_random_sample=rois_random_sample,
shuffle=shuffle,
)
# X_batch[0]: image - (3e6, 2)
# X_batch[1]: ROIs - (128, 5)
# Y_batch[0]: labels - (21, 128)
# Y_batch[1][0]: bbtarget - (84, 128)
# Y_batch[1][1]: bb mask - (84, 128)
for mb_i, (X_batch, y_batch) in enumerate(train_set):
image_neon = X_batch[0].get()
image_ref = neon_data_ref["X_batch_img"][mb_i]
rois_neon = X_batch[1].get()
rois_ref = neon_data_ref["X_batch_rois"][mb_i]
label_neon = y_batch[0].get()
label_ref = neon_data_ref["y_batch_label"][mb_i]
bbtarget_neon = y_batch[1][0].get()
bbtarget_ref = neon_data_ref["y_batch_bbtarget"][mb_i]
mask_neon = y_batch[1][1].get()
mask_ref = neon_data_ref["y_batch_mask"][mb_i]
assert np.allclose(image_neon, image_ref, atol=1e-5, rtol=0)
assert np.allclose(rois_neon, rois_ref, atol=1e-5, rtol=0)
assert np.allclose(label_neon, label_ref, atol=1e-5, rtol=0)
assert np.allclose(bbtarget_neon, bbtarget_ref, atol=1e-5, rtol=0)
assert np.allclose(mask_neon, mask_ref, atol=1e-5, rtol=0)
def load_imagenet_weights(model, path):
# load a pre-trained Alexnet from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/alexnet/old/pre_v1.4.0/'
filename = 'alexnet.p'
size = 488808400
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print 'Loading the Alexnet pre-trained with ImageNet I1K from: ' + filepath
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers]
param_dict_list = pdict['model']['config']['layers']
skip_loading = False
for i, layer in enumerate(param_layers):
if not load_pre_trained_weight(i, layer):
skip_loading = True
if not skip_loading:
ps = param_dict_list[i]
print "Loading weights for:{} [src: {}]".format(layer.name, ps['config']['name'])
layer.load_weights(ps, load_states=True)
else:
config_name = param_dict_list[i]['config']['name'] if i < len(param_dict_list) else ""
print "Skipped loading weights for: {} [src: {}]".format(layer.name, config_name)
return
def load_vgg_weights(model, path):
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/'
filename = 'VGG_ILSVRC_16_layers_fc_reduced_fused_conv_bias.p'
size = 86046032
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print(
'De-serializing the pre-trained VGG16 model with dilated convolutions...'
)
pdict = load_obj(filepath)
model_layers = [l for l in model.layers.layers[0].layers]
# convert source model into dictionary with layer name as keys
src_layers = {
layer['config']['name']: layer
for layer in pdict['model']['config']['layers']
}
i = 0
for layer in model_layers:
if layer.classnm == 'Convolution_bias' and i < 15:
# no states in above parameter file
layer.load_weights(src_layers['Convolution_bias_' + str(i)],
load_states=False)
print('{} loaded from source file'.format(layer.name))
i += 1
elif hasattr(layer, 'W'):
print('Skipping {} layer'.format(layer.name))
def test_pascalvoc(backend_default, data):
url = 'https://s3-us-west-1.amazonaws.com/nervana-pascal-voc-data'
filename = 'pascal_data_ref.pkl'
size = 423982870
workdir, filepath = Dataset._valid_path_append(data, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
with open(filepath, 'rb') as handle:
neon_data_ref = pickle.loads(handle.read())
n_mb = neon_data_ref['n_mb']
img_per_batch = neon_data_ref['img_per_batch']
rois_per_img = neon_data_ref['rois_per_img']
dataset = neon_data_ref['dataset']
year = neon_data_ref['year']
output_type = neon_data_ref['output_type']
rois_random_sample = neon_data_ref['rois_random_sample']
shuffle = neon_data_ref['shuffle']
train_set = PASCALVOC(dataset,
year,
path=data,
output_type=output_type,
n_mb=n_mb,
img_per_batch=img_per_batch,
rois_per_img=rois_per_img,
rois_random_sample=rois_random_sample,
shuffle=shuffle)
# X_batch[0]: image - (3e6, 2)
# X_batch[1]: ROIs - (128, 5)
# Y_batch[0]: labels - (21, 128)
# Y_batch[1][0]: bbtarget - (84, 128)
# Y_batch[1][1]: bb mask - (84, 128)
for mb_i, (X_batch, y_batch) in enumerate(train_set):
image_neon = X_batch[0].get()
image_ref = neon_data_ref['X_batch_img'][mb_i]
rois_neon = X_batch[1].get()
rois_ref = neon_data_ref['X_batch_rois'][mb_i]
label_neon = y_batch[0].get()
label_ref = neon_data_ref['y_batch_label'][mb_i]
bbtarget_neon = y_batch[1][0].get()
bbtarget_ref = neon_data_ref['y_batch_bbtarget'][mb_i]
mask_neon = y_batch[1][1].get()
mask_ref = neon_data_ref['y_batch_mask'][mb_i]
assert np.allclose(image_neon, image_ref, atol=1e-5, rtol=0)
assert np.allclose(rois_neon, rois_ref, atol=1e-5, rtol=0)
assert np.allclose(label_neon, label_ref, atol=1e-5, rtol=0)
assert np.allclose(bbtarget_neon, bbtarget_ref, atol=1e-5, rtol=0)
assert np.allclose(mask_neon, mask_ref, atol=1e-5, rtol=0)
def get_data():
"""
Download bilingual text dataset for Machine translation example.
"""
# vocab_size and time_steps are hard coded here
vocab_size = 16384
time_steps = 20
# download dataset
url = 'http://www-lium.univ-lemans.fr/~schwenk/cslm_joint_paper/data/'
filename = 'bitexts.tgz'
size = 1313280000
parser = NeonArgparser(__doc__)
args = parser.parse_args(gen_be=False)
data_dir = os.path.join(args.data_dir, 'nmt')
_, filepath = Dataset._valid_path_append(data_dir, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
# extract selected datasets
datafiles = dict()
datafiles['un2000'] = ('un2000_pc34.en.gz', 'un2000_pc34.fr.gz')
datafiles['europarl7'] = ('ep7_pc45.en.gz', 'ep7_pc45.fr.gz')
extractpath = os.path.join(data_dir, 'bitexts.selected')
with tarfile.open(filepath, 'r') as tar_ref:
for dset, files in datafiles.items():
datasetpath = os.path.join(data_dir, dset)
# extract the files for dataset, if not already there
for zipped in files:
fname = '.'.join(zipped.split('.')[:-1])
fpath = os.path.join(datasetpath, fname)
if not os.path.exists(fpath):
gzpath = os.path.join(extractpath, zipped)
if not os.path.exists(gzpath):
select = [ti for ti in tar_ref if os.path.split(ti.name)[1] == zipped]
tar_ref.extractall(path=data_dir, members=select)
# get contents of gz files
if not os.path.exists(datasetpath):
os.makedirs(datasetpath)
with gzip.open(gzpath, 'r') as fin, open(fpath, 'w') as fout:
fout.write(fin.read())
os.remove(gzpath)
if os.path.exists(extractpath):
os.rmdir(extractpath)
# process data and save to h5 file
# loop through all datasets and get train and valid splits
for dataset in datafiles.keys():
s_vocab, t_vocab = create_h5py(data_dir, dataset, 'train',
vocab_size=vocab_size, time_steps=time_steps)
create_h5py(data_dir, dataset, 'valid', s_vocab=s_vocab, t_vocab=t_vocab,
time_steps=time_steps)
def load_imagenet_weights(self, model_path):
# download trained Alexnet weights
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/alexnet/'
filename = 'alexnet_conv_ns_fused_conv_bias.p'
size = 19763308
_, filepath = Dataset._valid_path_append(model_path, '', filename)
if not osp.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
return filepath
def load_imagenet_weights(self, model_path):
# download trained Alexnet weights
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/alexnet/'
filename = 'alexnet_conv_ns_fused_conv_bias.p'
size = 19763308
_, filepath = Dataset._valid_path_append(model_path, '', filename)
if not osp.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
return filepath
def load_imagenet_weights(self, model_path):
# download trained Alexnet weights
url = "https://s3-us-west-1.amazonaws.com/nervana-modelzoo/alexnet/"
filename = "alexnet_conv_ns.p"
size = 20550623
_, filepath = Dataset._valid_path_append(model_path, "", filename)
if not osp.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
return filepath
def load_vgg_weights(model, path):
# load a pre-trained VGG16 from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/VGG/'
filename = 'VGG_D_Conv.p'
size = 169645138
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
neon_logger.display('De-serializing the pre-trained VGG16 model...')
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers[0].layers[0].layers]
param_dict_list = pdict['model']['config']['layers']
for layer, ps in zip(param_layers, param_dict_list):
neon_logger.display("{}".format(layer.name, ps['config']['name']))
layer.load_weights(ps, load_states=True)
def load_vgg_weights(model, path):
# load a pre-trained VGG16 from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/VGG/'
filename = 'VGG_D_Conv.p'
size = 169645138
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
neon_logger.display('De-serializing the pre-trained VGG16 model...')
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers[0].layers[0].layers]
param_dict_list = pdict['model']['config']['layers']
for layer, ps in zip(param_layers, param_dict_list):
neon_logger.display("{}".format(layer.name, ps['config']['name']))
layer.load_weights(ps, load_states=True)
def bleu_score(self, sents, targets):
"""
Compute the BLEU score from a list of predicted sentences and reference sentences
Args:
sents (list): list of predicted sentences
targets (list): list of reference sentences where each element is a list of
multiple references.
"""
num_ref = len(targets[0])
output_file = self.path + '/output'
reference_files = [
self.path + '/reference%d' % i for i in range(num_ref)
]
bleu_script_url = 'https://raw.githubusercontent.com/karpathy/neuraltalk/master/eval/'
bleu_script = 'multi-bleu.perl'
neon_logger.display("Writing output and reference sents to dir %s" %
self.path)
output_f = open(output_file, 'w+')
for sent in sents:
sent = sent.strip(self.end_token).split()
output_f.write(" ".join(sent) + '\n')
reference_f = [open(f, 'w') for f in reference_files]
for i in range(num_ref):
for target_sents in targets:
reference_f[i].write(target_sents[i] + '\n')
output_f.close()
[x.close() for x in reference_f]
owd = os.getcwd()
os.chdir(self.path)
if not os.path.exists(bleu_script):
Dataset.fetch_dataset(bleu_script_url, bleu_script, bleu_script,
6e6)
bleu_command = 'perl multi-bleu.perl reference < output'
neon_logger.display(
"Executing bleu eval script: {}".format(bleu_command))
os.system(bleu_command)
os.chdir(owd)
def load_imagenet_weights(model, path):
# load a pre-trained Alexnet from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/alexnet/'
filename = 'alexnet.p'
size = 488808400
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print 'De-serializing the pre-trained Alexnet using ImageNet I1K ...'
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers[0].layers[0].layers]
param_dict_list = pdict['model']['config']['layers']
for layer, ps in zip(param_layers, param_dict_list):
print layer.name, ps['config']['name']
layer.load_weights(ps, load_states=True)
if ps['config']['name'] == 'Pooling_2':
print 'Only load the pre-trained weights up to conv5 layer of Alexnet'
break
def load_imagenet_weights(model, path):
# load a pre-trained Alexnet from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/alexnet/'
filename = 'alexnet.p'
size = 488808400
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print 'De-serializing the pre-trained Alexnet using ImageNet I1K ...'
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers[0].layers[0].layers]
param_dict_list = pdict['model']['config']['layers']
for layer, ps in zip(param_layers, param_dict_list):
print layer.name, ps['config']['name']
layer.load_weights(ps, load_states=True)
if ps['config']['name'] == 'Pooling_2':
print 'Only load the pre-trained weights up to conv5 layer of Alexnet'
break
def bleu_score(self, sents, targets):
"""
Compute the BLEU score from a list of predicted sentences and reference sentences
Args:
sents (list): list of predicted sentences
targets (list): list of reference sentences where each element is a list of
multiple references.
"""
num_ref = len(targets[0])
output_file = self.path + '/output'
reference_files = [self.path + '/reference%d' % i for i in range(num_ref)]
bleu_script_url = 'https://raw.githubusercontent.com/karpathy/neuraltalk/master/eval/'
bleu_script = 'multi-bleu.perl'
print "Writing output and reference sents to dir %s" % self.path
output_f = open(output_file, 'w+')
for sent in sents:
sent = sent.strip(self.end_token).split()
output_f.write(" ".join(sent) + '\n')
reference_f = [open(f, 'w') for f in reference_files]
for i in range(num_ref):
for target_sents in targets:
reference_f[i].write(target_sents[i] + '\n')
output_f.close()
[x.close() for x in reference_f]
owd = os.getcwd()
os.chdir(self.path)
if not os.path.exists(bleu_script):
Dataset.fetch_dataset(bleu_script_url, bleu_script, bleu_script, 6e6)
bleu_command = 'perl multi-bleu.perl reference < output'
print "Executing bleu eval script: ", bleu_command
os.system(bleu_command)
os.chdir(owd)
def load_vgg_weights(model, path):
# load a pre-trained VGG16 from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/VGG/'
filename = 'VGG_D.p'
size = 554227541
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print 'De-serializing the pre-trained VGG16 model...'
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers[0].layers[0].layers]
param_dict_list = pdict['model']['config']['layers']
i = 0
for layer, ps in zip(param_layers, param_dict_list):
i += 1
print layer.name, ps['config']['name']
layer.load_weights(ps, load_states=True)
if i == 43:
break
def load_vgg_weights(model, path):
# load a pre-trained VGG16 from Neon model zoo to the local
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/VGG/'
filename = 'VGG_D.p'
size = 554227541
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print 'De-serializing the pre-trained VGG16 model...'
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers[0].layers[0].layers]
param_dict_list = pdict['model']['config']['layers']
i = 0
for layer, ps in zip(param_layers, param_dict_list):
i += 1
print layer.name, ps['config']['name']
layer.load_weights(ps, load_states=True)
if i == 43:
break
def load_vgg_weights(model, path):
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/VGG/'
filename = 'VGG_D_Conv_fused_conv_bias.p'
size = 58867537
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print('De-serializing the pre-trained VGG16 model...')
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers[0].layers]
param_dict_list = pdict['model']['config']['layers']
i = 0
for layer, ps in zip(param_layers, param_dict_list):
# finished loading param_dict_list[00 - 29] and param_layers[00-29]
if i == 30:
break
layer.load_weights(ps, load_states=False)
i += 1
print(layer.name + " <-- " + ps['config']['name'])
def load_vgg_weights(model, path):
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/VGG/'
filename = 'VGG_D_Conv_fused_conv_bias.p'
size = 58867537
workdir, filepath = Dataset._valid_path_append(path, '', filename)
if not os.path.exists(filepath):
Dataset.fetch_dataset(url, filename, filepath, size)
print('De-serializing the pre-trained VGG16 model...')
pdict = load_obj(filepath)
param_layers = [l for l in model.layers.layers[0].layers]
param_dict_list = pdict['model']['config']['layers']
i = 0
for layer, ps in zip(param_layers, param_dict_list):
# finished loading param_dict_list[00 - 29] and param_layers[00-29]
if i == 30:
break
layer.load_weights(ps, load_states=False)
i += 1
print(layer.name + " <-- " + ps['config']['name'])
def fetch_dataset(url, sourcefile, destfile, totalsz):
Dataset.fetch_dataset(url, sourcefile, destfile, totalsz)
# use cross-entropy cost to train the network
cost = GeneralizedCost(costfunc=CrossEntropyBinary())
lunaModel = Model(layers=vgg_layers)
# location and size of the VGG weights file
url = 'https://s3-us-west-1.amazonaws.com/nervana-modelzoo/VGG/'
filename = 'VGG_E.p' # VGG_E.p is VGG19; VGG_D.p is VGG16
size = 554227541
# edit filepath below if you have the file elsewhere
_, filepath = Dataset._valid_path_append('data', '', filename)
if not os.path.exists(filepath):
print('Need to fetch VGG pre-trained weights from cloud. Please wait...')
Dataset.fetch_dataset(url, filename, filepath, size)
# load the weights param file
print("Loading VGG weights from {}...".format(filepath))
trained_vgg = load_obj(filepath)
print("Done!")
param_layers = [l for l in lunaModel.layers.layers]
param_dict_list = trained_vgg['model']['config']['layers']
for layer, params in zip(param_layers, param_dict_list):
if (layer.name == 'class_layer'):
break
# To be sure, we print the name of the layer in our model
# and the name in the vgg model.
#print(layer.name + ", " + params['config']['name'])
def fetch_dataset(url, sourcefile, destfile, totalsz):
Dataset.fetch_dataset(url, sourcefile, destfile, totalsz)
