preprocess=True))
else:
fprop_computation_op = ng.computation(model_out, "all")
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(
from contextlib import closing
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
Reference paper: https://arxiv.org/pdf/1506.03134.pdf
"""
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
benchmark = Benchmark(batch_cost_computation_op, train_set, inputs,
transformer_type, device)
Benchmark.print_benchmark_results(
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],
"""
import numpy as np
from contextlib import closing
import ngraph as ng
from ngraph.frontends.neon import Layer, Preprocess, Recurrent, Affine, Softmax, Tanh
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.set_defaults(batch_size=128, num_iterations=2000)
args = parser.parse_args()
# model parameters
time_steps = 5
hidden_size = 256
gradient_clip_value = 5
# download penn treebank
# set shift_target to be False, since it is going to predict the same sequence
tree_bank_data = PTB(path=args.data_dir, shift_target=False)
ptb_data = tree_bank_data.load_data()
train_set = SequentialArrayIterator(ptb_data['train'],
batch_size=args.batch_size,
time_steps=time_steps,
self.cnt += 1
return np.random.normal(loc=self.mean,
scale=self.std,
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)
from __future__ import division, print_function
from contextlib import closing
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()
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')
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.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',
# WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
# See the License for the specific language governing permissions and
# limitations under the License.
# ----------------------------------------------------------------------------
import ngraph as ng
from ngraph.frontends.neon import Sequential, Preprocess, Recurrent, Affine, Softmax, Tanh
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 SequentialArrayIterator
import ngraph.transformers as ngt
from ptb import PTB
# parse the command line arguments
parser = NgraphArgparser(__doc__)
parser.set_defaults(gen_be=False)
args = parser.parse_args()
# these hyperparameters are from the paper
args.batch_size = 50
time_steps = 10
hidden_size = 20
gradient_clip_value = 15
# 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,
time_steps=time_steps,
Affine(nout=fc_nout,
weight_init=init,
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',
gen_txt.append(pred_char)
# Convert integer index of tokens to actual tokens
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)
import ngraph as ng
from ngraph.frontends.neon import Layer
from ngraph.frontends.neon import 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.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',
"""
from __future__ import division
from __future__ import print_function
import numpy as np
import ngraph as ng
from ngraph.frontends.neon import Affine, Preprocess, Convolution, Pool2D, Sequential
from ngraph.frontends.neon import UniformInit, Rectlin, Softmax, GradientDescentMomentum
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
from cifar10 import CIFAR10
import ngraph.transformers as ngt
parser = NgraphArgparser(description='Train simple CNN on cifar10 dataset')
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)
######################
# Model specification
def cifar_mean_subtract(x):
optimizer = RMSProp(learning_rate=5e-5,
decay_rate=0.99,
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',
from contextlib import closing
import os
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")
environment = DimShuffleWrapper(environment)
# todo: perhaps these should be defined in the environment itself
state_axes = ng.make_axes([
ng.make_axis(environment.observation_space.shape[0], name='C'),
ng.make_axis(environment.observation_space.shape[1], name='H'),
ng.make_axis(environment.observation_space.shape[2], name='W'),
])
agent = dqn.Agent(
state_axes,
environment.action_space,
model=model,
epsilon=dqn.linear_generator(start=1.0, end=0.1, steps=1000000),
gamma=0.99,
learning_rate=0.00025,
memory=dqn.Memory(maxlen=1000000),
target_network_update_frequency=1000,
learning_starts=10000,
)
rl_loop.rl_loop_train(environment, agent, episodes=200000)
if __name__ == "__main__":
from ngraph.frontends.neon import NgraphArgparser
parser = NgraphArgparser()
parser.parse_args()
main()
""" from __future__ import division from __future__ import print_function import numpy as np import ngraph as ng from ngraph.frontends.neon import 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 NgraphArgparser from ngraph.frontends.neon import ArrayIterator from mnist import MNIST import ngraph.transformers as ngt parser = NgraphArgparser(description='Train simple mlp on mnist dataset') args = parser.parse_args() np.random.seed(args.rng_seed) # Create the dataloader train_data, valid_data = MNIST(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 ###################### # Model specification seq1 = Sequential([Preprocess(functor=lambda x: x / 255.),
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
all_results = {
name: list(np.transpose(res))
for name, res in zip(metric_names, results)
}
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",
from contextlib import closing
import ngraph as ng
import os
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,
"""
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)
from __future__ import division
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, Pooling, Sequential
from ngraph.frontends.neon import XavierInit, 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 MNIST
import ngraph.transformers as ngt
parser = NgraphArgparser(description='Train LeNet topology on Mnist dataset')
args = parser.parse_args()
np.random.seed(args.rng_seed)
# Create the dataloader
train_data, valid_data = MNIST(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
######################
from __future__ import division
from __future__ import print_function
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
axes=[placeholders['WF'], placeholders['N']], name="X_w")
placeholders['Y'] = ng.placeholder(axes=[placeholders['N']], name="Y")
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()
"""
from __future__ import division
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()
max_values_squad,
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',default=16, help='enter the batch size',
type=int, action=check_size(1,256))
parser.set_defaults()
import numpy as np
import ngraph as ng
import ngraph.transformers as ngt
from tqdm import tqdm
from contextlib import closing
from ngraph.frontends.neon import NgraphArgparser, ArrayIterator
from ngraph.frontends.neon import GaussianInit, UniformInit
from ngraph.frontends.neon import Affine, Convolution, Pool2D, Sequential
from ngraph.frontends.neon import Rectlin, Softmax, GradientDescentMomentum
from ngraph.frontends.neon import ax
np.seterr(all='raise')
parser = NgraphArgparser(
description='Train convnet-vgg_a model on random dataset')
# Default batch_size for convnet-vgg_a is 64
parser.set_defaults(batch_size=64, num_iterations=100)
args = parser.parse_args()
# Setup data provider
image_size = 224
X_train = np.random.uniform(-1, 1,
(args.batch_size, 3, image_size, image_size))
y_train = np.ones(shape=(args.batch_size), dtype=np.int32)
train_data = {
'image': {
'data': X_train,
'axes': ('batch', 'C', 'height', 'width')
},
'label': {
noise_samples = self.noise_samples(self.batch_size, self.num_iter)
self.train_set = {
'data_sample': {
'data': data_samples,
'axes': ('batch', 'sample')
},
'noise_sample': {
'data': noise_samples,
'axes': ('batch', 'sample')
}
}
return self.train_set
parser = NgraphArgparser(description='MLP GAN example')
args = parser.parse_args()
# model parameters
h_dim = 4
minibatch_discrimination = False
num_iterations = 600
batch_size = 12
num_examples = num_iterations * batch_size
# generator
generator_layers = [
affine_layer(h_dim, Rectlin(), name='g0'),
affine_layer(1, Identity(), name='g1')
]
generator = Sequential(generator_layers)
1. run `python dist_hetr.py --graph_vis`
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")
Tuple of (ground truth transcript, decoded transcript, CER)
"""
ground_truth = decoder.process_string(decoder.convert_to_string(inds),
remove_repetitions=False)
decoded_string = decoder.decode(probs)
cer = decoder.cer(ground_truth, decoded_string) / float(len(ground_truth))
return ground_truth, decoded_string, cer
if __name__ == "__main__":
import logging
from ngraph.frontends.neon.logging import ProgressBar, PBStreamHandler
from ngraph.frontends.neon import NgraphArgparser
parser = NgraphArgparser()
structure = parser.add_argument_group("Network Structure")
structure.add_argument(
'--nfilters',
type=int,
help='Number of convolutional filters in the first layer',
default=256)
structure.add_argument('--filter_width',
type=int,
help='Width of 1D convolutional filters',
default=11)
structure.add_argument('--str_w',
type=int,
help='Stride in time',
default=3)
structure.add_argument('--depth',
name: list(res)
for name, res in zip(metric_names, results)
}
else:
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
from contextlib import closing
import ngraph as ng
from ngraph.frontends.neon import Layer
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',
