2. run `tensorboard --logdir /tmp/hetr_tb/ --port 6006`
use ssh port forwarding to run on remote server
https://stackoverflow.com/questions/37987839/how-can-i-run-tensorboard-on-a-remote-server
"""
from __future__ import print_function
from contextlib import closing
import ngraph as ng
import ngraph.transformers as ngt
from ngraph.frontends.neon import NgraphArgparser
import numpy as np
# Command Line Parser
parser = NgraphArgparser(description="Distributed HeTr Example")
parser.add_argument("--graph_vis",
action="store_true",
help="enable graph visualization")
args = parser.parse_args()
# Build the graph
H = ng.make_axis(length=6, name='height')
N = ng.make_axis(length=8, name='batch')
W1 = ng.make_axis(length=2, name='W1')
W2 = ng.make_axis(length=4, name='W2')
x = ng.placeholder(axes=[H, N])
w1 = ng.placeholder(axes=[W1, H])
w2 = ng.placeholder(axes=[W2, W1])
with ng.metadata(device_id=('0', '1'), parallel=N):
dot1 = ng.dot(w1, x).named("dot1")
dot2 = ng.dot(w2, dot1).named("dot2")
from ngraph.frontends.neon import GaussianInit, Adam
from ngraph.frontends.neon import make_bound_computation
from ngraph.frontends.neon import NgraphArgparser
from ngraph.frontends.neon import ArrayIterator
from ngraph.frontends.neon import Saver
import ngraph.transformers as ngt
from nlp_architect.data.babi_dialog import BABI_Dialog
from nlp_architect.models.memn2n_dialogue import MemN2N_Dialog
from utils import interactive_loop
from nlp_architect.utils.io import validate_existing_filepath, validate_parent_exists, validate
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument(
'--task',
type=int,
default='1',
choices=range(1, 7),
help='the task ID to train/test on from bAbI-dialog dataset (1-6)')
parser.add_argument(
'--emb_size',
type=int,
default='32',
help='Size of the word-embedding used in the model. (default 128)')
parser.add_argument(
'--nhops',
type=int,
default='3',
help='Number of memory hops in the network',
choices=range(1,10))
parser.add_argument(
'--use_match_type',
benchmark.time(num_iterations, n_skip, dataset + '_msra_bprop',
visualize, 'device_id'))
else:
fprop_computation_op = ng.computation(model_out, 'all')
benchmark = Benchmark(fprop_computation_op, train_set, inputs,
transformer_type, device)
Benchmark.print_benchmark_results(
benchmark.time(num_iterations, n_skip, dataset + '_msra_fprop',
visualize))
if __name__ == "__main__":
parser = NgraphArgparser(description='Train deep residual network')
parser.add_argument('-data',
'--data_set',
default='cifar10',
choices=['cifar10', 'i1k'],
help="data set name")
parser.add_argument('-s',
'--skip_iter',
type=int,
default=1,
help="number of iterations to skip")
parser.add_argument('-m',
'--num_devices',
nargs='+',
type=int,
default=[1],
help="number of devices to run the benchmark on")
parser.add_argument('--hetr_device',
default='cpu',
benchmark_fprop = Benchmark(fprop_computation_op, train_set, inputs,
args.backend, args.hetr_device)
Benchmark.print_benchmark_results(
benchmark_fprop.time(args.num_iterations,
args.skip_iter,
'ds2_fprop',
args.visualize,
preprocess=True))
if __name__ == "__main__":
parser = NgraphArgparser(description='Train mini deep speech 2')
parser.add_argument(
'--nfilters',
type=int,
help='Number of convolutional filters in the first layer',
default=2)
parser.add_argument('--filter_width',
type=int,
help='Width of 1D convolutional filters',
default=11)
parser.add_argument('--str_w', type=int, help='Stride in time', default=1)
parser.add_argument('--depth',
type=int,
help='Number of RNN layers',
default=1)
parser.add_argument(
'--hidden_size',
type=int,
help='Number of hidden units in the RNN and affine layers',
size=self.shape)
else:
raise StopIteration
def next(self):
return self.__next__()
def __iter__(self):
return self
# parse command line arguments
parser = NgraphArgparser()
parser.add_argument(
'--plot_interval',
type=int,
default=200,
help='save generated images with a period of this many iterations')
parser.add_argument('--seed', type=int, default=0, help='random seed')
args = parser.parse_args()
np.random.seed(args.rng_seed)
args.batch_size = 32
# Create the dataloader
train_data, valid_data = MNIST(args.data_dir).load_data()
train_set = ArrayIterator(train_data, args.batch_size)
# noise source
noise_dim = (2, 1, 3, 3)
noise_generator = Noise(train_set.ndata,
from __future__ import division
from __future__ import print_function
from contextlib import closing
import ngraph as ng
from ngraph.frontends.neon import UniformInit, RMSProp, ax, Tanh, Logistic
from ngraph.frontends.neon import NgraphArgparser, make_bound_computation
from ngraph.frontends.neon import LSTM
import ngraph.transformers as ngt
from ngraph.frontends.neon.data.tsp import TSP
from tsp_seqarrayiter import TSPSequentialArrayIterator
from utils import save_plot
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument('--train_file', default='tsp5.txt',
choices=['tsp5.txt', 'tsp10.txt'],
help='specify training filename')
parser.add_argument('--test_file', default='tsp5_test.txt',
choices=['tsp5_test.txt', 'tsp10_test.txt'],
help='specify testing filename')
parser.add_argument('--lr', type=float, default=0.0025, help='learning rate')
parser.add_argument('--hs', type=int, default=256, help='hidden unit size')
parser.add_argument('--emb', type=bool, default=True, help='use embedding')
parser.set_defaults()
args = parser.parse_args()
args.batch_size = 128
args.num_iterations = 20000
gradient_clip_value = 2
num_features = 2 # for planar TSP, each city's location is represented by a 2-d coordinate
gen_txt = [index_to_token[i] for i in gen_txt]
return gen_txt
def expand_onehot(x):
"""
Simply converts an integer to a one-hot vector of the same size as out_axis
"""
return ng.one_hot(x, axis=out_axis)
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument(
'--use_embedding',
default=False,
dest='use_embedding',
action='store_true',
help='If given, embedding layer is used as the first layer')
parser.add_argument('--seq_len',
type=int,
help="Number of time points in each input sequence",
default=32)
parser.add_argument('--recurrent_units',
type=int,
help="Number of recurrent units in the network",
default=256)
parser.set_defaults(num_iterations=20000)
args = parser.parse_args()
use_embedding = args.use_embedding
recurrent_units = args.recurrent_units
usage: python toy_wgan.py -b gpu -t 100000
"""
from contextlib import closing
import ngraph.transformers as ngt
from ngraph.frontends.neon import Adam, Affine, Rectlin, Sequential
from ngraph.frontends.neon import ConstantInit, KaimingInit
from ngraph.frontends.neon import make_bound_computation, NgraphArgparser
from ngraph.frontends.neon.logging import ProgressBar
import ngraph as ng
import os
import numpy as np
from toy_utils import DataGenerator, NormalNoise, generate_plot
parser = NgraphArgparser()
parser.add_argument('--plot_interval', type=int, default=200,
help='Plot results every this many iterations')
parser.add_argument('--loss_type', type=str, default='WGAN-GP',
help='Choose loss type', choices=['WGAN-GP', 'WGAN'])
parser.add_argument('--gp_scale', type=int, default=1,
help='Scale of the gradient penalty')
parser.add_argument('--w_clip', type=int, default=0.01,
help='Weight clipping value for WGAN')
parser.add_argument('--data_type', type=str, default='Roll',
help='Choose ground truth distribution',
choices=['Rectangular', 'Circular', 'Roll'])
parser.add_argument('--dim', type=int, default=512,
help='Hidden layer dimension for the model')
parser.add_argument('--num_critic', type=int, default=5,
help='Number of discriminator iterations per generator iteration')
parser.add_argument('--plot_dir', type=str, default='WGAN_Toy_Plots',
help='Directory name to save the results')
import numpy as np
import ngraph as ng
from ngraph.frontends.neon import Layer, Affine, Preprocess, Sequential
from ngraph.frontends.neon import GaussianInit, Rectlin, Logistic, GradientDescentMomentum
from ngraph.frontends.neon import ax, loop_train, make_bound_computation, make_default_callbacks
from ngraph.frontends.neon import loop_eval
from ngraph.frontends.neon import NgraphArgparser
from ngraph.frontends.neon import ArrayIterator
from ngraph.frontends.neon import MNIST
from ngraph.frontends.neon import Saver
import ngraph.transformers as ngt
parser = NgraphArgparser(description='Train simple mlp on mnist dataset')
parser.add_argument('--save_file',
type=str,
default=None,
help="File to save weights")
parser.add_argument('--load_file',
type=str,
default=None,
help="File to load weights")
parser.add_argument('--inference',
action="store_true",
help="Run Inference with loaded weight")
args = parser.parse_args()
if args.inference and (args.load_file is None):
print("Need to set --load_file for Inference problem")
quit()
if args.save_file is not None:
from ngraph.frontends.neon import make_bound_computation
from ngraph.frontends.neon import NgraphArgparser
from ngraph.frontends.neon import ArrayIterator
from ngraph.frontends.neon import Saver
import ngraph.transformers as ngt
from nlp_architect.models.kvmemn2n import KVMemN2N
from nlp_architect.data.wikimovies import WIKIMOVIES
from nlp_architect.utils.io import validate_parent_exists, check_size
from examples.kvmemn2n.interactive_util import interactive_loop
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument(
'--emb_size',
type=int,
default='50',
help='Size of the word-embedding used in the model. (default 50)',
action=check_size(1, 20000))
parser.add_argument('--nhops',
type=int,
default='3',
help='Number of memory hops in the network',
action=check_size(1, 20))
parser.add_argument('--lr',
type=float,
default=0.01,
help='learning rate',
action=check_size(0, 5))
parser.add_argument('--subset',
type=str,
default='wiki-entities',
from ngraph.frontends.neon import GaussianInit, Adam
from ngraph.frontends.neon import make_bound_computation
from ngraph.frontends.neon import NgraphArgparser
from ngraph.frontends.neon import ArrayIterator
from ngraph.frontends.neon import Saver
import ngraph.transformers as ngt
from nlp_architect.data.babi_dialog import BABI_Dialog
from nlp_architect.models.memn2n_dialogue import MemN2N_Dialog
from utils import interactive_loop
from nlp_architect.utils.io import validate_existing_filepath, validate_parent_exists, validate
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument(
'--task',
type=int,
default='1',
choices=range(1, 7),
help='the task ID to train/test on from bAbI-dialog dataset (1-6)')
parser.add_argument(
'--emb_size',
type=int,
default='32',
help='Size of the word-embedding used in the model. (default 128)')
parser.add_argument('--nhops',
type=int,
default='3',
help='Number of memory hops in the network',
choices=range(1, 10))
parser.add_argument('--use_match_type',
default=False,
action='store_true',
base_lr = 0.1
gamma = 0.1
momentum_coef = 0.9
wdecay = 0.0001
nesterov = False
print("HyperParameters")
print("Learning Rate: " + str(base_lr))
print("Momentum: " + str(momentum_coef))
print("Weight Decay: " + str(wdecay))
print("Nesterov: " + str(nesterov))
# Command Line Parser
parser = NgraphArgparser(description="Resnet for Imagenet and Cifar10")
parser.add_argument('--dataset',
type=str,
default="cifar10",
help="Enter cifar10 or i1k")
parser.add_argument('--size',
type=int,
default=56,
help="Enter size of resnet")
parser.add_argument('--tb',
action="store_true",
help="1- Enables tensorboard")
parser.add_argument('--logfile',
type=str,
default=None,
help="Name of the csv which \
logs different metrics of model")
parser.add_argument('--hetr_device',
type=str,
valid_set = make_validation_loader(manifest[0], manifest_root, batch_size,
subset_pct)
return train_set, valid_set
if __name__ == "__main__":
# Load training configuration and parse arguments
train_config = os.path.join(os.path.dirname(os.path.realpath(__file__)),
'train.cfg')
config_files = [train_config] if os.path.exists(train_config) else []
parser = NgraphArgparser(__doc__, default_config_files=config_files)
parser.add_argument('--subset_pct',
type=float,
default=100,
help='subset of training dataset to use (percentage)')
parser.add_argument('--log_file',
type=str,
default='training_log.pkl',
help='name for the trainig log file')
args = parser.parse_args()
np.random.seed = args.rng_seed
# Load data
train_set, valid_set = get_data(args.manifest, args.manifest_root,
args.batch_size, args.subset_pct,
args.rng_seed)
# Define model and train
cal_f1_score)
import math
from nlp_architect.contrib.ngraph.weight_initilizers import (make_placeholder, make_weights)
from nlp_architect.utils.io import sanitize_path
from nlp_architect.utils.io import validate, validate_existing_directory, \
validate_existing_filepath, validate_parent_exists, check_size
"""
Training script for reading comprehension model
"""
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument('--data_path', help='enter path for training data',
type=str)
parser.add_argument('--gpu_id', default="0", help='enter gpu id',
type=str,action=check_size(0,10))
parser.add_argument('--max_para_req', default=100, help='enter the max length of paragraph',
type=int, action=check_size(30,300))
parser.add_argument('--batch_size_squad',default=16, help='enter the batch size',
type=int, action=check_size(1,256))
parser.set_defaults()
args = parser.parse_args()
os.environ["CUDA_VISIBLE_DEVICES"] = args.gpu_id
bias_init=ConstantInit(0.),
activation=Rectlin()))
layers.append(Dropout(keep=0.5))
layers.append(
Affine(axes=(ax.Y, ),
weight_init=init,
bias_init=ConstantInit(0.),
activation=Softmax()))
return layers
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument('--sentence_length',
type=int,
default=1014,
help='the number of characters in a sentence')
parser.add_argument(
'--use_uppercase',
action='store_true',
default=False,
help='whether to use uppercase characters in the vocabulary')
parser.add_argument('--use_large',
action='store_true',
default=False,
help='whether to use the large model')
parser.add_argument('-e',
'--num_epochs',
type=int,
default=10,
help='the number of epochs to train')
action="store_true",
help="Use Nesterov accelerated gradient")
data_params = parser.add_argument_group("Data Parameters")
data_params.add_argument('--max_length',
type=float,
help="max duration for each audio sample",
default=7.5)
data_params.add_argument("--manifest_train",
help="Path to training manifest file")
data_params.add_argument("--manifest_val",
help="Path to validation manifest file")
# TODO: Remove this once testing is further along
parser.add_argument("--small",
action="store_true",
help="Use a small version of the model with fake data")
args = parser.parse_args()
if args.small is True:
args.nfilters = 20
args.depth = 3
args.hidden_size = 20
args.max_length = .3
args.fake = True
logger = logging.getLogger(__name__)
logger.setLevel(logging.DEBUG)
logger.addHandler(PBStreamHandler(level=logging.DEBUG))
# Data parameters
from ngraph.frontends.neon import ArrayIterator
from ngraph.frontends.neon import Saver
import ngraph.transformers as ngt
from nlp_architect.models.memn2n_dialogue import MemN2N_Dialog
import numpy as np
import os
from tqdm import tqdm
from utils import interactive_loop
from nlp_architect.utils.io import validate_parent_exists, check_size, validate
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument(
'--task',
type=int,
default='1',
choices=range(1,7),
help='the task ID to train/test on from bAbI-dialog dataset (1-6)')
parser.add_argument(
'--emb_size',
type=int,
default='32',
help='Size of the word-embedding used in the model.')
parser.add_argument(
'--nhops',
type=int,
default='3',
help='Number of memory hops in the network',
choices=range(1,10))
parser.add_argument(
'--use_match_type',
}
else:
for name, res in zip(metric_names, results):
all_results[name].extend(list(res))
reduced_results = {
k: np.mean(v[:dataset._dataloader.ndata])
for k, v in all_results.items() if k != 'predictions'
}
return all_results, reduced_results
parser = NgraphArgparser(description=__doc__)
parser.add_argument('--mini',
default=False,
dest='mini',
action='store_true',
help='If given, builds a mini version of Inceptionv3')
parser.add_argument("--image_dir",
default='/dataset/aeon/I1K/i1k-extracted/',
help="Path to extracted imagenet data")
parser.add_argument("--train_manifest_file",
default='train-index-tabbed.csv',
help="Name of tab separated Aeon training manifest file")
parser.add_argument("--valid_manifest_file",
default='val-index-tabbed.csv',
help="Name of tab separated Aeon validation manifest file")
parser.add_argument("--optimizer_name",
default='rmsprop',
help="Name of optimizer (rmsprop or sgd)")
parser.set_defaults(batch_size=4, num_iterations=10000000, iter_interval=2000)
import ngraph as ng
from ngraph.frontends.neon import Layer, Sequential, LSTM, Affine
from ngraph.frontends.neon import UniformInit, Tanh, Logistic, Identity, Adam
from ngraph.frontends.neon import NgraphArgparser, loop_train
from ngraph.frontends.neon import make_bound_computation, make_default_callbacks
import ngraph.transformers as ngt
from ngraph.frontends.neon import ArrayIterator
import timeseries
import utils
import imp
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument('--predict_seq',
default=False,
dest='predict_seq',
action='store_true',
help='If given, seq_len future timepoints are predicted')
parser.add_argument('--look_ahead',
type=int,
help="Number of time steps to start predicting from",
default=1)
parser.add_argument('--seq_len',
type=int,
help="Number of time points in each input sequence",
default=32)
parser.add_argument('--epochs', type=int, help="Number of epochs", default=200)
parser.set_defaults()
args = parser.parse_args()
# Plot the inference / generation results
from contextlib import closing
import ngraph as ng
from ngraph.frontends.neon import (Layer, Sequential, Preprocess, LSTM, Affine,
Softmax, Tanh, Logistic)
from ngraph.frontends.neon import UniformInit, RMSProp
from ngraph.frontends.neon import ax, loop_train
from ngraph.frontends.neon import NgraphArgparser, make_bound_computation, make_default_callbacks
from ngraph.frontends.neon import SequentialArrayIterator
import ngraph.transformers as ngt
from ngraph.frontends.neon import PTB
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument('--layer_type',
default='lstm',
choices=['lstm'],
help='type of recurrent layer to use (lstm)')
parser.set_defaults()
args = parser.parse_args()
# these hyperparameters are from the paper
args.batch_size = 64
time_steps = 50
hidden_size = 128
gradient_clip_value = 5
# download penn treebank
tree_bank_data = PTB(path=args.data_dir)
ptb_data = tree_bank_data.load_data()
train_set = SequentialArrayIterator(ptb_data['train'],
batch_size=args.batch_size,
epsilon=1e-8,
weight_clip_value=weight_clip_value)
if loss_type == "WGAN-GP":
optimizer = Adam(learning_rate=1e-4,
beta_1=0.5,
beta_2=0.9,
epsilon=1e-8,
weight_clip_value=weight_clip_value)
return optimizer
parser = NgraphArgparser(description='WGAN on LSUN bedroom dataset')
parser.add_argument('--plot_interval',
type=int,
default=500,
help='display generated samples at this frequency')
parser.add_argument('--lsun_dir',
default="/dataset/lsun",
help='LSUN data directory')
parser.add_argument(
'--subset_pct',
type=float,
default=50.0,
help='subset of training dataset to use (percentage), default 50.0')
parser.add_argument('--loss_type',
default='WGAN-GP',
help='Loss Function',
choices=['WGAN', 'WGAN-GP'])
parser.add_argument('--im_size',
type=int,
from contextlib import closing
import ngraph as ng
from ngraph.frontends.neon import (Layer, Sequential, BiRNN, Recurrent, Affine,
Softmax, Tanh, LookupTable)
from ngraph.frontends.neon import UniformInit, RMSProp
from ngraph.frontends.neon import ax, loop_train, make_bound_computation, make_default_callbacks
from ngraph.frontends.neon import NgraphArgparser
from ngraph.frontends.neon import ArrayIterator
import ngraph.transformers as ngt
from imdb import IMDB
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument('--layer_type',
default='rnn',
choices=['rnn', 'birnn'],
help='type of recurrent layer to use (rnn or birnn)')
parser.set_defaults()
args = parser.parse_args()
# these hyperparameters are from the paper
args.batch_size = 128
time_steps = 128
hidden_size = 10
gradient_clip_value = 15
embed_size = 128
vocab_size = 20000
pad_idx = 0
# download IMDB
imdb_dataset = IMDB(path=args.data_dir,
def default_argparser():
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument(
'--predict_seq',
default=False,
dest='predict_seq',
action='store_true',
help='If given, seq_len future timepoints are predicted')
parser.add_argument('--look_ahead',
type=int,
help="Number of time steps to start predicting from",
default=1)
parser.add_argument('--seq_len',
type=int,
help="Number of time points in each input sequence",
default=32)
parser.add_argument(
'--log_interval',
type=int,
default=100,
help="frequency, in number of iterations, after which loss is evaluated"
)
parser.add_argument('--save_plots',
action="store_true",
help="save plots to disk")
parser.add_argument('--results_dir',
type=str,
help="Directory to write results to",
default='./')
parser.add_argument('--resume',
type=str,
default=None,
help="weights of the model to resume training with")
parser.set_defaults()
return parser
from __future__ import print_function
from contextlib import closing
import numpy as np
import ngraph as ng
from ngraph.frontends.neon import Layer, Affine, Preprocess, Convolution, Pool2D, Sequential
from ngraph.frontends.neon import UniformInit, Rectlin, Softmax, GradientDescentMomentum
from ngraph.frontends.neon import ax, loop_train
from ngraph.frontends.neon import NgraphArgparser, make_bound_computation, make_default_callbacks
from ngraph.frontends.neon import ArrayIterator
from ngraph.frontends.neon import CIFAR10
import ngraph.transformers as ngt
parser = NgraphArgparser(description='Train simple CNN on cifar10 dataset')
parser.add_argument('--use_batch_norm',
action='store_true',
help='whether to use batch normalization')
args = parser.parse_args()
np.random.seed(args.rng_seed)
# Create the dataloader
train_data, valid_data = CIFAR10(args.data_dir).load_data()
train_set = ArrayIterator(train_data,
args.batch_size,
total_iterations=args.num_iterations)
valid_set = ArrayIterator(valid_data, args.batch_size)
inputs = train_set.make_placeholders()
ax.Y.length = 10
import ngraph.transformers as ngt
from ngraph.frontends.neon import (Sequential, Deconvolution, Convolution,
Rectlin, Logistic, Tanh, Adam,
ArrayIterator, KaimingInit,
make_bound_computation)
from ngraph.frontends.neon import NgraphArgparser
from ngraph.frontends.neon import MNIST
from ngraph.frontends.neon.logging import ProgressBar
from ngraph.util.names import name_scope
from utils import save_plots, get_image, train_schedule, Noise
# parse command line arguments
parser = NgraphArgparser()
parser.add_argument(
'--plot_interval',
type=int,
default=200,
help='Save generated images with a period of this many iterations')
parser.add_argument('--loss_type',
default='WGAN-GP',
help='Loss Function',
choices=['DCGAN', 'WGAN', 'WGAN-GP'])
parser.add_argument('--gp_scale',
type=int,
default=10,
help='Scale of the gradient penalty')
parser.add_argument('--w_clip',
type=int,
default=0.01,
help='Weight clipping value for WGAN')
parser.add_argument('--plot_dir',
import ngraph as ng
from ngraph.frontends.neon import (Layer, Sequential, Preprocess, BiRNN,
Recurrent, Affine, Softmax, Tanh,
LookupTable)
from ngraph.frontends.neon import UniformInit, RMSProp
from ngraph.frontends.neon import ax, loop_train
from ngraph.frontends.neon import NgraphArgparser, make_bound_computation, make_default_callbacks
from ngraph.frontends.neon import SequentialArrayIterator
import ngraph.transformers as ngt
from ngraph.frontends.neon import PTB
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument('--layer_type',
default='rnn',
choices=['rnn', 'birnn'],
help='type of recurrent layer to use (rnn or birnn)')
parser.add_argument('--use_lut',
action='store_true',
help='choose to use lut as first layer')
parser.set_defaults()
args = parser.parse_args()
# these hyperparameters are from the paper
args.batch_size = 50
time_steps = 150
hidden_size = 500
# download penn treebank
tree_bank_data = PTB(path=args.data_dir)
ptb_data = tree_bank_data.load_data()
embeddings_placeholders = []
for lut in range(len(data.parameters['dimensions_embeddings'])):
embedding_placeholder = ng.placeholder(ng.make_axes(
[placeholders['N']]),
name="EMB")
embeddings_placeholders.append(embedding_placeholder)
placeholders['embeddings_placeholders'] = embeddings_placeholders
return placeholders
parser = NgraphArgparser(description=__doc__)
parser.add_argument("--learning_rate",
type=float,
default=0.01,
help="Learning rate")
parser.add_argument("--epochs", type=int, default=41, help="Number of epochs")
parser.add_argument(
"--deep_parameters",
default='100,50',
type=str,
help=
"Comma separated list of hidden neurons on the deep section of the model")
parser.set_defaults(batch_size=40)
args = parser.parse_args()
fc_layers_deep = [int(s) for s in args.deep_parameters.split(',')]
cs_loader = data.CensusDataset(args.batch_size)
for name, res in zip(metric_names, results):
all_results[name].extend(list(res))
reduced_results = {
k: np.mean(v[:dataset.ndata])
for k, v in all_results.items()
}
return reduced_results
if __name__ == "__main__":
parser = NgraphArgparser(
description='Train deep residual network on cifar10 dataset')
parser.add_argument(
'--stage_depth',
type=int,
default=2,
help='depth of each stage (network depth will be 9n+2)')
parser.add_argument('--use_aeon',
action='store_true',
help='whether to use aeon dataloader')
args = parser.parse_args()
np.random.seed(args.rng_seed)
# Create the dataloader
if args.use_aeon:
from data import make_aeon_loaders
train_set, valid_set = make_aeon_loaders(args.data_dir,
args.batch_size,
args.num_iterations)
get_data_array_squad_ngraph, cal_f1_score)
import math
from nlp_architect.contrib.ngraph.weight_initilizers import (make_placeholder,
make_weights)
from nlp_architect.utils.io import sanitize_path
from nlp_architect.utils.io import validate, validate_existing_directory, \
validate_existing_filepath, validate_parent_exists, check_size
"""
Training script for reading comprehension model
"""
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.add_argument('--data_path',
help='enter path for training data',
type=str)
parser.add_argument('--gpu_id',
default="0",
help='enter gpu id',
type=str,
action=check_size(0, 10))
parser.add_argument('--max_para_req',
default=100,
help='enter the max length of paragraph',
type=int,
action=check_size(30, 300))
parser.add_argument('--batch_size_squad',