def main(config, **kwargs):
''' DATASETS '''
# transforms
data_transforms = {
'train':
transforms.Compose([
transforms.RandomCrop(32, padding=4),
transforms.RandomHorizontalFlip(),
RandAugment(bag_of_ops, 2, 14 / 30),
transforms.RandomErasing(p=1, scale=(0.25, 0.25), ratio=(1., 1.)),
]),
'val':
transforms.Compose([]),
}
# datasets & dataloaders
if config.dataset == 'cifar10':
dataset = EfficientCIFAR10
elif config.dataset == 'cifar100':
dataset = EfficientCIFAR100
else:
raise ValueError('invalid dataset')
dataloaders = {}
for mode in ['train', 'val']:
dataloaders[mode] = dataset(config.data_path,
train=mode == 'train',
transform=data_transforms[mode])
dataloaders[mode] = torch.utils.data.DataLoader(
dataloaders[mode],
batch_size=config.batch_size,
shuffle=mode == 'train',
drop_last=True,
num_workers=6)
''' TRAINING '''
# model
model = WideResNet(28, 10, 0.3, 10)
criterion = nn.CrossEntropyLoss(reduction='none')
optimizer = optim.SGD(model.parameters(),
lr=0.1,
momentum=0.9,
nesterov=True,
weight_decay=5e-4)
normalize = transforms.Normalize([0.4914, 0.4822, 0.4465],
[0.2023, 0.1994, 0.2010])
# RL
'''
c = SGC(bag_of_ops, op_layers=2)
c_optimizer = optim.Adam(c.parameters(), lr=0.035)
ppo = PPOAgent(c, name=f'{config.name}_ppo.pt',
grad_norm=0.01,
batch_size=config.M,
augmentation=None,
device=torch.device('cpu'))
'''
trainer = Trainer(model=model,
optimizer=optimizer,
criterion=criterion,
name=config.name,
bag_of_ops=bag_of_ops,
rl_n_steps=12,
M=config.M,
normalize=normalize,
rl_agent=None) # ppo)
print(bag_of_ops.ops)
scheduler = torch.optim.lr_scheduler.CosineAnnealingLR(
optimizer, config.epochs)
trainer.fit(dataloaders['train'],
dataloaders['val'],
n_epochs=config.epochs,
scheduler=scheduler)
if __name__ == '__main__':
window_size = 1
hidden_size = 5
batch_size = 3
max_epoch = 1000
text = 'You say goodbye and I say hello.'
corpus, word_to_id, id_to_word = preprocess(text)
vocab_size = len(word_to_id)
contexts, target = create_contexts_target(corpus, window_size=window_size)
contexts = convert_one_hot(contexts, vocab_size=vocab_size)
target = convert_one_hot(target, vocab_size=vocab_size)
# モデル
#model = SimpleCBOW(vocab_size, hidden_size)
model = SimpleSkipGram(vocab_size, hidden_size)
optimizer = Adam()
#optimizer = SGD()
# 学習
trainer = Trainer(model, optimizer)
trainer.fit(contexts, target, max_epoch=max_epoch, batch_size=batch_size)
# plot
trainer.plot('chap3.png')
# 単語の分散表現print
for word, word_id in word_to_id.items():
print('{0} {1}'.format(word, model.word_vecs[word_id]))
# coding: utf-8
import sys
from trainers import Trainer
from two_layers_net import TwoLayersNet
from optimizers import SGD
from dataset import spiral
if __name__ == '__main__':
max_epoch = 300
batch_size = 30
hidden_size = 10
learning_rate = 1.0
# データ, モデル, optimizer
x, t = spiral.load_data()
model = TwoLayersNet(input_size=2, hidden_size=hidden_size, output_size=3)
opt = SGD(learning_rate)
# 学習
trainer = Trainer(model, opt)
trainer.fit(x, t, max_epoch, batch_size, eval_interval=10)
# plot
trainer.plot('chap1.png')
