def load():
f = cPickle.load(open(U.get_modelpath('dummy.ai'), 'r'))
y = f(X)
yT = f.T(y)
f1 = K.function(X, y)
f2 = K.function(X, yT)
_ = f1(x)
print(_.shape, _.sum())
_ = f2(x)
print(_.shape, _.sum())
def create():
f = N.Sequence([
N.Conv(8, (3, 3), strides=1, pad='same'),
N.Dimshuffle(pattern=(0, 3, 1, 2)),
N.FlattenLeft(outdim=2),
N.Noise(level=0.3, noise_dims=None, noise_type='gaussian'),
N.Dense(128, activation=K.relu),
N.Dropout(level=0.3, noise_dims=None),
N.Dense(10, activation=K.softmax)
],
debug=True)
y = f(X)
yT = f.T(y)
f1 = K.function(X, y)
f2 = K.function(X, yT)
cPickle.dump(f, open(U.get_modelpath('dummy.ai', override=True), 'w'))
_ = f1(x)
print(_.shape, _.sum())
_ = f2(x)
print(_.shape, _.sum())
from odin.utils import ArgController, stdio, one_hot
args = ArgController(
).add('-model', 'model name, specified in models_cifar.py', 'cnn'
).parse()
import os
os.environ['ODIN'] = 'float32,gpu,seed=87654321,log'
import numpy as np
import tensorflow as tf
from odin import fuel as F, nnet as N, backend as K, training, utils
from odin.stats import train_valid_test_split
MODEL_NAME = args.model
MODEL_PATH = utils.get_modelpath(name='cifar10_%s' % MODEL_NAME, override=True)
LOG_PATH = utils.get_logpath(name='cifar10_%s.log' % MODEL_NAME, override=True)
stdio(LOG_PATH)
# ===========================================================================
# Some handmade constants
# ===========================================================================
NB_EPOCH = 10
LEARNING_RATE = 0.001
# ===========================================================================
# Load dataset
# ===========================================================================
ds = F.CIFAR10.get_dataset()
nb_labels = 10
print(ds)
X_train = ds['X_train'][:].astype('float32') / 255.
y_train = one_hot(ds['y_train'][:], nb_classes=nb_labels)
print('Parameters:', [p.name for p in parameters])
optz = K.optimizers.RMSProp()
updates = optz.get_updates(cost_train, parameters)
print("Build training function ...")
f_train = K.function([X, y_true], cost_train, updates=updates)
print("Build scoring function ...")
f_score = K.function([X, y_true], [cost_pred, cost_eval])
# ===========================================================================
# Create trainer
# ===========================================================================
print("Create trainer ...")
trainer = training.MainLoop(batch_size=32, seed=12082518, shuffle_level=2)
trainer.set_save(utils.get_modelpath('cifar10.ai', override=True), f)
trainer.set_task(f_train, [X_learn, y_learn], epoch=25, p=1, name='Train')
trainer.set_subtask(f_score, [X_test, y_test], freq=1, name='Valid')
trainer.set_callback([
training.ProgressMonitor(name='Train', format='Results: {:.4f}'),
training.ProgressMonitor(name='Valid', format='Results: {:.4f},{:.4f}'),
# early stop based on crossentropy on test (not a right procedure,
# but only for testing)
training.EarlyStopGeneralizationLoss(
name='Valid',
threshold=5,
patience=3,
get_value=lambda x: np.mean([j for i, j in x])),
training.History()
])
trainer.run()
import numpy as np
from odin import backend as K, nnet as N, fuel as F
from odin.preprocessing.text import (Tokenizer, language, POSfilter,
TYPEfilter, CasePreprocessor,
TransPreprocessor)
from odin import training
# ===========================================================================
# Const
# ===========================================================================
embedding_dims = 100
MAX_SEQ_LEN = 1000
MAX_NB_WORDS = 20000
OVERRIDE = args['rebuild']
MODEL_PATH = get_modelpath(name='word_embedding_test.ai', override=True)
# ===========================================================================
# Load embedding
# ===========================================================================
embedding = F.load_glove(ndim=embedding_dims)
newsgroup = F.load_20newsgroup()
labels = []
texts = []
for i, j in newsgroup.items():
labels += [i] * len(j)
texts += j
print(i, ':', len(j))
labels_set = list(set(labels))
nb_labels = len(labels_set)
tokenizer_path = get_modelpath('tokenizer', override=False)
parameters = ops.parameters
optimizer = K.optimizers.SGD(lr=arg['lr'])
updates = optimizer(cost_train, parameters)
print('Building training functions ...')
f_train = K.function([X, y], [cost_train, optimizer.norm], updates=updates)
print('Building testing functions ...')
f_test = K.function([X, y], [cost_test_1, cost_test_2, cost_test_3])
print('Building predicting functions ...')
f_pred = K.function(X, y_pred_score)
# ===========================================================================
# Build trainer
# ===========================================================================
print('Start training ...')
task = training.MainLoop(batch_size=64, seed=12, shuffle_level=2)
task.set_save(get_modelpath(name='mnist.ai', override=True), ops)
task.set_task(f_train, (ds['X_train'], ds['y_train']),
epoch=arg['epoch'],
name='train')
task.set_subtask(f_test, (ds['X_test'], ds['y_test']), freq=0.6, name='valid')
task.set_subtask(f_test, (ds['X_test'], ds['y_test']), when=-1, name='test')
task.set_callback([
training.ProgressMonitor(name='train', format='Results: {:.4f}-{:.4f}'),
training.ProgressMonitor(name='valid',
format='Results: {:.4f}-{:.4f}',
tracking={2: lambda x: sum(x)}),
training.ProgressMonitor(name='test', format='Results: {:.4f}-{:.4f}'),
training.History(),
training.EarlyStopGeneralizationLoss('valid', threshold=5, patience=3),
training.NaNDetector(('train', 'valid'), patience=3, rollback=True)
])
print('Params:', [p.name for p in parameters])
updates = K.optimizers.Adam(lr=0.001).get_updates(cost_train, parameters)
print('Building training function ...')
f_train = K.function([X_train, y], cost_train, updates)
print('Building scoring function ...')
f_score = K.function([X_score, y], cost_score)
# ===========================================================================
# Test
# ===========================================================================
trainer = training.MainLoop(batch_size=batch_size,
seed=12082518,
shuffle_level=1)
trainer.set_save(utils.get_modelpath(name='imdb.ai', override=True), f)
trainer.set_task(f_train, (ds['X_train'], ds['y_train']),
epoch=nb_epoch,
name='Train')
trainer.set_subtask(f_score, (ds['X_test'], ds['y_test']),
freq=0.5,
name='Valid')
trainer.set_callback([
training.History(),
training.ProgressMonitor('Train', format='Results: {:.4f}'),
training.ProgressMonitor('Valid', format='Results: {:.4f}')
])
trainer.run()
# ===========================================================================
# Visualization
from odin.stats import train_valid_test_split, freqcount
from odin import training
from odin import preprocessing as pp
from odin.ml import evaluate, fast_tsne
from odin.visual import (print_dist, print_confusion, print_hist, plot_scatter,
plot_figure, plot_spectrogram, plot_save,
plot_confusion_matrix, generate_random_colors,
generate_random_marker)
from odin.utils import (get_logpath, get_modelpath, get_datasetpath,
get_figpath, Progbar, unique_labels, chain,
as_tuple_of_shape, stdio, ctext, ArgController)
# ===========================================================================
# Const
# ===========================================================================
FEAT = ['mspec', 'sad']
MODEL_PATH = get_modelpath(name='DIGITS', override=True)
LOG_PATH = get_logpath(name='digits.log', override=True)
FIG_PATH = get_figpath(name='DIGITS', override=True)
stdio(LOG_PATH)
DEBUG = False
# ====== trainign ====== #
BATCH_SIZE = 32
NB_EPOCH = 20
NB_SAMPLES = 8
VALID_PERCENTAGE = 0.4
# ===========================================================================
# Load dataset
# ===========================================================================
path = get_datasetpath(name='TIDIGITS_feats', override=False)
assert os.path.isdir(path), \
print('Gaussian normalized the data')
X_train = ds['X_train'][:]
X_train = (X_train - np.mean(X_train, 0)) / (np.std(X_train))
X_test = ds['X_test'][:]
X_test = (X_test - np.mean(X_test, 0)) / (np.std(X_test))
datatype = 'float16'
X_train = X_train.astype(datatype)
X_test = X_test.astype(datatype)
print('Data type:', X_train.dtype, X_test.dtype)
# ===========================================================================
# Build trainer
# ===========================================================================
print('Start training ...')
task = training.MainLoop(batch_size=32, seed=12, shuffle_level=2)
task.set_checkpoint(get_modelpath(name='mnist.ai', override=True), ops)
task.set_task(f_train, (X_train, ds['y_train']), epoch=3, name='train')
task.set_subtask(f_test, (X_test, ds['y_test']), freq=0.6, name='valid')
task.set_subtask(f_test, (X_test, ds['y_test']), when=-1, name='test')
task.set_callback([
training.ProgressMonitor(name='train', format='Loss:{:.4f}, Norm:{:.4f}'),
training.ProgressMonitor(name='valid',
format='Results: {:.4f}-{:.4f}',
tracking={2: lambda x: sum(x)}),
training.ProgressMonitor(name='test', format='Results: {:.4f}-{:.4f}'),
training.History(),
training.EarlyStopGeneralizationLoss('valid', threshold=5, patience=3),
training.NaNDetector(('train', 'valid'), patience=3, rollback=True)
])
task.run()
import numpy as np
from odin import backend as K, nnet as N, fuel as F
from odin.preprocessing.text import (Tokenizer, language, POSfilter,
TYPEfilter, CasePreprocessor,
TransPreprocessor)
from odin import training
# ===========================================================================
# Const
# ===========================================================================
embedding_dims = 100
MAX_SEQ_LEN = 1000
MAX_NB_WORDS = 20000
OVERRIDE = args['rebuild']
MODEL_PATH = get_modelpath(name='word_embedding_test.ai',
override=True)
# ===========================================================================
# Load embedding
# ===========================================================================
embedding = F.load_glove(ndim=embedding_dims)
newsgroup = F.load_20newsgroup()
labels = []
texts = []
for i, j in newsgroup.items():
labels += [i] * len(j)
texts += j
print(i, ':', len(j))
labels_set = list(set(labels))
nb_labels = len(labels_set)
tokenizer_path = get_modelpath('tokenizer', override=False)
updates = optimizer.get_updates(cost_train, parameters)
# ====== create function ====== #
print('Building training functions ...')
f_train = K.function([X, y], [cost_train, optimizer.norm], updates=updates)
print('Building testing functions ...')
f_test = K.function([X, y], [cost_test_1, cost_test_2, cost_test_3])
print('Building predicting functions ...')
f_pred = K.function(X, y_score)
# ===========================================================================
# Build trainer
# ===========================================================================
print('Start training ...')
task = training.MainLoop(batch_size=args['bs'], seed=1208, shuffle_level=2)
task.set_save(get_modelpath(name='digit_audio.ai', override=True), f)
task.set_task(f_train, train_feeder, epoch=args['epoch'], name='train')
task.set_subtask(f_test, valid_feeder, freq=0.6, name='valid')
task.set_subtask(f_test, test_feeder, when=-1, name='test')
task.set_callback([
training.ProgressMonitor(name='train', format='Results: {:.4f}-{:.4f}'),
training.ProgressMonitor(name='valid',
format='Results: {:.4f}-{:.4f}',
tracking={2: lambda x: sum(x)}),
training.ProgressMonitor(name='test', format='Results: {:.4f}-{:.4f}'),
training.History(),
training.EarlyStopGeneralizationLoss('valid', threshold=5, patience=3),
training.NaNDetector(('train', 'valid'), patience=3, rollback=True)
])
task.run()
print('Gaussian normalized the data')
X_train = ds['X_train'][:]
X_train = (X_train - np.mean(X_train, 0)) / (np.std(X_train))
X_test = ds['X_test'][:]
X_test = (X_test - np.mean(X_test, 0)) / (np.std(X_test))
datatype = 'float16'
X_train = X_train.astype(datatype)
X_test = X_test.astype(datatype)
print('Data type:', X_train.dtype, X_test.dtype)
# ===========================================================================
# Build trainer
# ===========================================================================
print('Start training ...')
task = training.MainLoop(batch_size=64, seed=12, shuffle_level=2)
task.set_checkpoint(get_modelpath(name='mnist.ai', override=True), ops)
task.set_task(f_train, (X_train, ds['y_train']), epoch=3, name='train')
task.set_subtask(f_test, (X_test, ds['y_test']), freq=0.6, name='valid')
task.set_subtask(f_test, (X_test, ds['y_test']), when=-1, name='test')
task.set_callback([
training.ProgressMonitor(name='train', format='Loss:{:.4f}, Norm:{:.4f}'),
training.ProgressMonitor(name='valid', format='Results: {:.4f}-{:.4f}',
tracking={2: lambda x: sum(x)}),
training.ProgressMonitor(name='test', format='Results: {:.4f}-{:.4f}'),
training.History(),
training.EarlyStopGeneralizationLoss('valid', threshold=5, patience=3),
training.NaNDetector(('train', 'valid'), patience=3, rollback=True)
])
task.run()
# ====== plot the training process ====== #
