lr = Tensor(
get_lr(global_step=cfg.global_step,
lr_init=cfg.lr_init,
lr_end=cfg.lr_end,
lr_max=cfg.lr_max,
warmup_epochs=cfg.warmup_epochs,
total_epochs=cfg.num_epochs,
steps_per_epoch=ds_train.get_dataset_size(),
lr_adjust_epoch=cfg.lr_adjust_epoch))
else:
lr = cfg.learning_rate
opt = nn.Momentum(network.trainable_params(), lr, cfg.momentum)
loss_cb = LossMonitor()
model = Model(network, loss, opt, {'acc': Accuracy()})
print("============== Starting Training ==============")
config_ck = CheckpointConfig(
save_checkpoint_steps=cfg.save_checkpoint_steps,
keep_checkpoint_max=cfg.keep_checkpoint_max)
ckpoint_cb = ModelCheckpoint(prefix="lstm",
directory=args.ckpt_path,
config=config_ck)
time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())
if args.device_target == "CPU":
model.train(cfg.num_epochs,
ds_train,
callbacks=[time_cb, ckpoint_cb, loss_cb],
dataset_sink_mode=False)
else:
# set args, train it
context.set_context(mode=context.GRAPH_MODE, device_target="CPU")
train_data_path = "./datasets/MNIST_Data/train"
eval_data_path = "./datasets/MNIST_Data/test"
ckpt_save_dir = "./lenet_ckpt"
epoch_size = 10
eval_per_epoch = 2
repeat = 1
train_data = create_dataset(train_data_path, repeat_size=repeat)
eval_data = create_dataset(eval_data_path, repeat_size=repeat)
# define the net
network = LeNet5()
# define the loss function
net_loss = SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
# define the optimizer
net_opt = nn.Momentum(network.trainable_params(),
learning_rate=0.01,
momentum=0.9)
config_ck = CheckpointConfig(save_checkpoint_steps=eval_per_epoch * 1875,
keep_checkpoint_max=15)
ckpoint_cb = ModelCheckpoint(prefix="checkpoint_lenet",
directory=ckpt_save_dir,
config=config_ck)
model = Model(network, net_loss, net_opt, metrics={"Accuracy": Accuracy()})
epoch_per_eval = {"epoch": [], "acc": []}
eval_cb = EvalCallBack(model, eval_data, eval_per_epoch, epoch_per_eval)
model.train(epoch_size,
train_data,
callbacks=[ckpoint_cb, LossMonitor(375), eval_cb],
dataset_sink_mode=False)
network = SentimentNet(vocab_size=embedding_table.shape[0],
embed_size=cfg.embed_size,
num_hiddens=cfg.num_hiddens,
num_layers=cfg.num_layers,
bidirectional=cfg.bidirectional,
num_classes=cfg.num_classes,
weight=Tensor(embedding_table),
batch_size=cfg.batch_size)
loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction='mean')
ds_eval = lstm_create_dataset(args.preprocess_path,
cfg.batch_size,
training=False)
model = Model(network,
loss,
metrics={
'acc': Accuracy(),
'recall': Recall(),
'f1': F1()
})
print("============== Starting Testing ==============")
param_dict = load_checkpoint(args.ckpt_path)
load_param_into_net(network, param_dict)
if args.device_target == "CPU":
acc = model.eval(ds_eval, dataset_sink_mode=False)
else:
acc = model.eval(ds_eval)
print("============== {} ==============".format(acc))
parser.add_argument('--ckpt_path', type=str, default="./ckpt", help='if mode is test, must provide\
path where the trained ckpt file')
parser.add_argument('--dataset_sink_mode', type=ast.literal_eval, default=True,
help='dataset_sink_mode is False or True')
args = parser.parse_args()
context.set_context(mode=context.GRAPH_MODE, device_target=args.device_target)
network = AlexNet(cfg.num_classes)
loss = nn.SoftmaxCrossEntropyWithLogits(sparse=True, reduction="mean")
repeat_size = 1
# when batch_size=32, steps is 1562
lr = Tensor(get_lr(0, cfg.learning_rate, cfg.epoch_size, 1562))
opt = nn.Momentum(network.trainable_params(), lr, cfg.momentum)
model = Model(network, loss, opt, metrics={"Accuracy": Accuracy()}) # test
if args.mode == 'train':
print("============== Starting Training ==============")
ds_train = create_dataset(args.data_path,
cfg.batch_size,
repeat_size,
args.mode)
config_ck = CheckpointConfig(save_checkpoint_steps=cfg.save_checkpoint_steps,
keep_checkpoint_max=cfg.keep_checkpoint_max)
ckpoint_cb = ModelCheckpoint(prefix="checkpoint_alexnet", directory=args.ckpt_path, config=config_ck)
model.train(cfg.epoch_size, ds_train, callbacks=[ckpoint_cb, LossMonitor()],
dataset_sink_mode=args.dataset_sink_mode)
elif args.mode == 'test':
print("============== Starting Testing ==============")
param_dict = load_checkpoint(args.ckpt_path)
self.fc2 = nn.Dense(hidden_size, 1)
self.sig = ops.Sigmoid()
def construct(self, x):
x = self.fc1(x)
x = self.sig(x)
x = self.fc2(x)
return x
m = Net(HIDDEN_SIZE)
optim = nn.Momentum(m.trainable_params(), 0.05, 0.9)
loss = nn.MSELoss()
loss_cb = LossMonitor()
model = Model(m, loss, optim, {'acc': Accuracy()})
time_cb = TimeMonitor(data_size=ds_train.get_dataset_size())
model.train(ITERATIONS,
ds_train,
callbacks=[time_cb, loss_cb],
dataset_sink_mode=False)
print("TF", model.predict(Tensor([[1, 0]], mindspore.float32)).asnumpy())
print("FF", model.predict(Tensor([[0, 0]], mindspore.float32)).asnumpy())
print("TT", model.predict(Tensor([[1, 1]], mindspore.float32)).asnumpy())
print("FT", model.predict(Tensor([[0, 1]], mindspore.float32)).asnumpy())
