def train(net, train_features, train_labels, test_features, test_labels,
num_epochs, learning_rate, weight_decay, batch_size):
train_ls, test_ls = [], []
train_iter = gdata.DataLoader(gdata.ArrayDataset(train_features,
train_labels),
batch_size,
shuffle=True)
trainer = gluon.Trainer(net.collect_params(), 'adam', {
'learning_rate': learning_rate,
'wd': weight_decay
})
for epoch in range(num_epochs):
for x, y in train_iter:
with autograd.record():
l = loss(net(x), y)
l.backward()
trainer.step(batch_size)
train_ls.append(log_rmse(net, train_features, train_labels))
if (test_labels is not None):
test_ls.append(log_rmse(net, test_features, test_labels))
return train_ls, test_ls
def train(net, train_features, train_labels, test_features, test_labels, num_epochs, learning_rate, weight_decay, batch_size):
train_loss, test_loss = [], []
train_iter = gdata.DataLoader(
gdata.ArrayDataset(train_features, train_labels), batch_size, shuffle=True
)
# Adam
trainer = gluon.Trainer(net.collect_params(), optimizer="adam",
optimizer_params={"learning_rate": learning_rate, "wd":weight_decay})
for epoch in range(num_epochs):
for X, y in train_iter:
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
train_loss.append(log_rmse(net, train_features, train_labels))
if test_labels is not None:
test_loss.append(log_rmse(net, test_features, test_labels))
return train_loss, test_loss
def train_gluon_self(trainer_name,
trainer_hyperparams,
features,
labels,
batch_size=10,
num_epochs=2):
# 初始化模型
net = nn.Sequential()
net.add(nn.Dense(1))
net.initialize(init.Normal(sigma=0.01))
loss = gloss.L2Loss()
def eval_loss():
return loss(net(features), labels).mean().asscalar()
ls = [eval_loss()]
data_iter = gdata.DataLoader(gdata.ArrayDataset(features, labels),
batch_size,
shuffle=True)
for _ in range(num_epochs):
# 创建Trainer实例来迭代模型参数
trainer = gluon.Trainer(net.collect_params(), trainer_name,
trainer_hyperparams)
start = time.time()
for batch_i, (X, y) in enumerate(data_iter):
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size) # 在Trainer实例里做梯度平均
if (batch_i + 1) * batch_size % 100 == 0:
ls.append(eval_loss())
trainer_hyperparams['learning_rate'] *= 0.1
print(trainer_hyperparams['learning_rate'])
# 打印结果和作图
print('loss: %f, %f sec per epoch' % (ls[-1], time.time() - start))
d2l.set_figsize()
d2l.plt.plot(np.linspace(0, num_epochs, len(ls)), ls)
d2l.plt.xlabel('epoch')
d2l.plt.ylabel('loss')
def training2(features, labels, position, fire_point, title, batch_size=11):
dataset = gdata.ArrayDataset(features, labels)
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
net = nn.Sequential()
net.add(nn.Dense(1))
net.initialize()
loss = gloss.L2Loss()
trainer = gluon.Trainer(net.collect_params(), 'sgd',
{'learning_rate': 0.01})
epoch = 0
m = 100
while epoch < 1000:
epoch += 1
for X, y in data_iter:
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
l = loss(net(features), labels)
if epoch % 100 == 0 or epoch == 1:
print('epcoh: %d loss: %s' % (epoch, l.mean().asscalar()))
m = l.mean().asscalar()
print("epoch:" + str(epoch))
print("m: " + str(m))
print("w: " + str(net[0].weight.data().asnumpy()))
print("b: " + str(net[0].bias.data().asnumpy()))
print("error square: " +
str(((net(features).reshape(batch_size, 1) -
labels.reshape(batch_size, 1))**2).sum().asscalar()))
p_test = nd.arange(0, 1 / fire_point, 0.1)
q_test = net(p_test)
plt.subplot(1, 3, position)
plt.scatter(features.asnumpy(), labels.asnumpy(), color='#FF4700')
plt.plot(p_test.asnumpy(), q_test.asnumpy(), color='b')
plt.xlabel("1/p (1/kPa)")
plt.ylabel("1/q (g carbon/mmol)")
plt.title(title)
def optimize(batch_size, trainer, num_epochs, decay_epoch, log_interval,
features, labels, net):
"""Optimize an objective function."""
dataset = gdata.ArrayDataset(features, labels)
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
loss = gloss.L2Loss()
ls = [loss(net(features), labels).mean().asnumpy()]
for epoch in range(1, num_epochs + 1):
# Decay the learning rate.
if decay_epoch and epoch > decay_epoch:
trainer.set_learning_rate(trainer.learning_rate * 0.1)
for batch_i, (X, y) in enumerate(data_iter):
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
if batch_i * batch_size % log_interval == 0:
ls.append(loss(net(features), labels).mean().asnumpy())
# To print more conveniently, use numpy.
print('w:', net[0].weight.data(), '\nb:', net[0].bias.data(), '\n')
es = np.linspace(0, num_epochs, len(ls), endpoint=True)
semilogy(es, ls, 'epoch', 'loss')
def train(load_params=False):
batch_size = 128
lr = 0.01
num_epochs = 1 # 演示用
ctx = mx.gpu()
net = get_resnet18(10)
net.initialize(init.Normal(sigma=0.01), ctx=ctx)
if load_params is False:
train_iter = gdata.DataLoader(
gdata.vision.MNIST(train=True).transform_first(flig_aug),
shuffle=True,
batch_size=batch_size)
loss = gloss.SoftmaxCrossEntropyLoss()
trainer = gluon.Trainer(net.collect_params(), 'sgd',
{'learning_rate': lr})
Train(train_iter, net, loss, trainer, ctx, num_epochs, batch_size)
else:
filename = 'Mnist.params'
net.load_parameters(filename, ctx=ctx)
return net
def fit_and_plot(train_features, test_features, train_labels, test_labels):
net = nn.Sequential()
net.add(nn.Dense(1))
net.initialize()
batch_size = min(10, train_labels.shape[0])
train_iter = gdata.DataLoader(gdata.ArrayDataset(train_features, train_labels),
batch_size, shuffle=True)
trainer = gluon.Trainer(net.collect_params(), "sgd", {"learning_rate":0.01})
train_ls, test_ls = [], []
for _ in range(num_epochs):
for X, y in train_iter:
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
train_ls.append(loss(net(train_features),train_labels).mean().asscalar())
test_ls.append(loss(net(test_features), test_labels).mean().asscalar())
print("final epoch:train loss", train_ls[-1], "test loss", test_ls[-1])
semilogy(range(1, num_epochs + 1), train_ls, "epochs", "loss",
range(1, num_epochs + 1), test_ls, ["train", "test"])
print("weight:", net[0].weight.data().asnumpy(),
"\nbias:", net[0].bias.data().asnumpy())
def train_ch7(trainer_fn,
states,
hyperparams,
features,
labels,
batch_size=10,
num_epochs=2):
def eval_loss():
return loss(net(features, w, b), labels).mean().asscalar()
net, loss = d2l.linreg, d2l.squared_loss
# 初始化参数
w = nd.random.normal(scale=0.01, shape=(features.shape[1], 1))
b = nd.zeros(1)
w.attach_grad()
b.attach_grad()
ls = [eval_loss()]
data_iter = gdata.DataLoader(gdata.ArrayDataset(features, labels),
batch_size,
shuffle=True)
for _ in range(num_epochs):
start = time.time()
for batch_i, (X, y) in enumerate(data_iter):
# 反向传播求导
with autograd.record():
mean_loss = loss(net(X, w, b), y).mean()
mean_loss.backward()
# 根据导数调整模型参数
trainer_fn([w, b], states, hyperparams)
if (batch_i + 1) * batch_size % 100 == 0:
ls.append(eval_loss())
# 打印结果和作图
print('loss: %f, %f sec per epoch' % (ls[-1], time.time() - start))
d2l.set_figsize()
d2l.plt.plot(np.linspace(0, num_epochs, len(ls)), ls)
d2l.plt.xlabel('epoch')
d2l.plt.ylabel('loss')
def house_prise_gulon():
"""
使用gulon模型构建房价预估
:return:
"""
features = nd.array(nd.array([[120, 2], [100, 1], [130, 3]]))
labels = nd.array([1200000, 1000000, 1300000])
logger.info(features)
logger.info(labels)
# labels += nd.random.normal(scale=0.01, shape=labels.shape)
batch_size = 10
# 将训练数据的特征和标签组合
dataset = gdata.ArrayDataset(features, labels)
# 随机读取小批量
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
net = nn.Sequential()
net.add(nn.Dense(1))
net.initialize(init.Normal(sigma=0.01))
loss = gloss.L2Loss()
trainer = gluon.Trainer(net.collect_params(), 'sgd',
{'learning_rate': 0.03})
num_epochs = 3
for epoch in range(1, num_epochs + 1):
for X, y in data_iter:
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
l = loss(net(features), labels)
logger.info('epoch %d, loss: %f' % (epoch, l.mean().asnumpy()))
dense = net[0]
logger.info("预测数据")
logger.info(dense.weight.data())
logger.info(dense.bias.data())
logger.info(net(features))
def train_gluon_ch7(trainer_name,
trainer_hyperparams,
features,
labels,
batch_size=10,
num_epochs=2):
# Iniatial model
net = nn.Sequential()
net.add(nn.Dense(1))
net.initialize(init.Normal(sigma=0.01))
loss = gloss.L2Loss()
#Store the loss
def eval_loss():
return loss(net(features), labels).mean().asscalar()
ls = [eval_loss()]
data_iter = gdata.DataLoader(gdata.ArrayDataset(features, labels),
batch_size,
shuffle=True)
# Create Trainer
trainer = gluon.Trainer(net.collect_params(), trainer_name,
trainer_hyperparams)
for _ in range(num_epochs):
start = time.time()
for batch_i, (X, y) in enumerate(data_iter):
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size) # Average the gradient
if (batch_i + 1) * batch_size % 100 == 0:
ls.append(eval_loss())
# Print result and graph
print('loss: %f, %f sec per epoch' % (ls[-1], time.time() - start))
d2l.set_figsize()
d2l.plt.plot(np.linspace(0, num_epochs, len(ls)), ls)
d2l.plt.xlabel('epoch')
d2l.plt.ylabel('loss')
def train(train_features, train_labels, test_features, test_labels, num_epochs,
learning_rate, weight_decay, batch_size, net_in):
train_ls, test_ls = [], []
train_iter = gdata.DataLoader(gdata.ArrayDataset(train_features,
train_labels),
batch_size=batch_size,
shuffle=True)
net = net_in
# 采用Adam优化
loss = get_loss()
trainer = gluon.Trainer(net.collect_params(),
optimizer='adam',
optimizer_params={
'learning_rate': learning_rate,
'wd': weight_decay
})
# 开始训练
for epoch in range(num_epochs):
for X, y in train_iter:
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
train_ls.append(log_rmse(train_features, train_labels, net, loss=loss))
if test_labels is not None:
test_ls.append(log_rmse(test_features, test_labels, net,
loss=loss))
# 保存训练得到的网络参数
# save_or_not = input("Save the trained net? Y/N")
# if save_or_not == 'Y':
# save_params(net)
return train_ls, test_ls
def train_model(net, train_features, train_labels, test_features, test_labels,
num_epochs, trainer, loss, learning_rate, batch_size, ctx):
train_ls, test_ls = [], []
train_iter = gdata.DataLoader(gdata.ArrayDataset(train_features,
train_labels),
batch_size,
shuffle=True)
for epoch in range(num_epochs):
for X, y in train_iter:
X, y = X.as_in_context(ctx), y.as_in_context(ctx)
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
train_ls.append(
evaluate_accuracy_fold(net, train_features, train_labels,
batch_size, ctx))
if test_labels is not None:
test_ls.append(
evaluate_accuracy_fold(net, test_features, test_labels,
batch_size, ctx))
return train_ls, test_ls
def train(net,train_features,train_labels,
test_features,test_labels,
num_epochs,learning_rate,weight_decay,batch_size):
train_ls,test_ls = [],[]
train_iter = gdata.DataLoader(gdata.ArrayDataset(train_features,train_labels),batch_size,shuffle=True)
# 然后使用Adam算法!
trainer = gluon.Trainer(net.collect_params(),'adam',{'learning_rate':learning_rate,'wd':weight_decay})
# 开始epoch训练
for epoch in range(num_epochs):
for X,y in train_iter:
with autograd.record():
y_hat = net(X)
l = loss(y_hat,y).sum()
l.backward()
trainer.step(batch_size)
train_ls.append(log_rmse(net,train_features,train_labels))
if test_labels is not None: # 如果有传入测试数据的话，就一并也做测试集损失！
# 因为到最后的train_and_pred()是不带k-fold玩的！
test_ls.append(log_rmse(net,test_features,test_labels))
return train_ls,test_ls
def train(net, train_features, train_labels, test_features, test_labels,
num_epochs, lr, wd, batch_size):
train_l, test_l = [], []
train_iter = gdata.DataLoader(gdata.ArrayDataset(train_features,
train_labels),
batch_size,
shuffle=True)
trainer = gluon.Trainer(net.collect_params(), 'adam', {
'learning_rate': lr,
'wd': wd
}) # 使用adam优化算法
for _ in range(num_epochs):
for X, y in train_iter:
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
train_l.append(log_rmse(net, train_features,
train_labels)) # 一遍数据打包成一个结果
if test_labels is not None:
test_l.append(log_rmse(net, test_features, test_labels))
return train_l, test_l
def train_loader(path, batch_size=32, num_workers=4):
normalize = transforms.Normalize(mean=0.5, std=0.25)
train_transforms = transforms.Compose([
# transforms.Resize((96, 112)), # W x H
transforms.RandomFlipLeftRight(),
transforms.ToTensor(),
normalize,
])
def my_train_transform(img, label):
return train_transforms(img), label
train_dataset = datasets.ImageFolderDataset(path,
transform=my_train_transform)
num_train = len(train_dataset)
print("number of total examples is %d" % num_train)
train_loader = data.DataLoader(train_dataset,
batch_size=batch_size,
shuffle=True,
num_workers=num_workers)
print("number of batches for train, valid and test is %d" %
(len(train_loader)))
return train_loader
def optimize(optimizer_fn,
params_vars,
hyperparams,
features,
labels,
decay_epoch=None,
batch_size=10,
log_interval=10,
num_epochs=3,
is_adam=False):
"""Optimize an objective function."""
dataset = gdata.ArrayDataset(features, labels)
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
w, b = params_vars[0]
net = linreg
loss = squared_loss
ls = [loss(net(features, w, b), labels).mean().asnumpy()]
if is_adam:
t = 0
for epoch in range(1, num_epochs + 1):
if decay_epoch and decay_epoch and epoch > decay_epoch:
hyperparams['lr'] *= 0.1
for batch_i, (X, y) in enumerate(data_iter):
with autograd.record():
l = loss(net(X, w, b), y)
l.backward()
if is_adam:
t += 1
optimizer_fn(params_vars, hyperparams, batch_size, t)
else:
optimizer_fn(params_vars, hyperparams, batch_size)
if batch_i * batch_size % log_interval == 0:
ls.append(loss(net(features, w, b), labels).mean().asnumpy())
print('w[0]=%.2f, w[1]=%.2f, b=%.2f' %
(w[0].asscalar(), w[1].asscalar(), b.asscalar()))
es = np.linspace(0, num_epochs, len(ls), endpoint=True)
semilogy(es, ls, 'epoch', 'loss')
def train(net, train_features, train_labels, test_features, test_labels,
num_epochs, verbose_epoch, learning_rate, weight_decay, batch_size):
train_ls = []
if test_features is not None:
test_ls = []
train_iter = gdata.DataLoader(gdata.ArrayDataset(train_features,
train_labels),
batch_size,
shuffle=True)
# 这里使用了 Adam 优化算法。
trainer = gluon.Trainer(net.collect_params(), 'adam', {
'learning_rate': learning_rate,
'wd': weight_decay
})
net.initialize(init=init.Xavier(), force_reinit=True)
for epoch in range(1, num_epochs + 1):
for X, y in train_iter:
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
cur_train_l = get_rmse_log(net, train_features, train_labels)
if epoch >= verbose_epoch:
print("epoch %d, train loss: %f" % (epoch, cur_train_l))
train_ls.append(cur_train_l)
if test_features is not None:
cur_test_l = get_rmse_log(net, test_features, test_labels)
test_ls.append(cur_test_l)
if test_features is not None:
gb.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss',
range(1, num_epochs + 1), test_ls, ['train', 'test'])
else:
gb.semilogy(range(1, num_epochs + 1), train_ls, 'epochs', 'loss')
if test_features is not None:
return cur_train_l, cur_test_l
else:
return cur_train_l
def train(encoder, decoder, dataset, out_vocab, lr, batch_size, num_epochs):
"""
:param encoder:
:param decoder:
:param dataset:
:param out_vocab:
:param lr:
:param batch_size:
:param num_epochs:
:return:
"""
encoder.initialize(init.Xavier(), force_reinit=True)
decoder.initialize(init.Xavier(), force_reinit=True)
enc_trainer = gluon.Trainer(encoder.collect_params(), "adam",
{"learning_rate": lr})
dec_trainer = gluon.Trainer(decoder.collect_params(), "adam",
{"learning_rate": lr})
loss = gloss.SoftmaxCrossEntropyLoss()
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
for epoch in range(num_epochs):
l_sum = 0
for X, Y in data_iter:
with autograd.record():
l = batch_loss(encoder, decoder, out_vocab, X, Y, loss)
l.backward()
enc_trainer.step(1)
dec_trainer.step(1)
l_sum += l.asscalar()
if (epoch + 1) % 10 == 0:
print("epoch %d, loss %.3f" % (epoch + 1, l_sum / len(data_iter)))
def train(self,
train_features,
train_labels,
test_features=None,
test_labels=None,
shuffle_=True,
print_iter=True):
train_losses, test_losses = [], []
train_iter = gdata.DataLoader(gdata.ArrayDataset(
train_features, train_labels),
self.batch_size,
shuffle=shuffle_)
trainer = gluon.Trainer(self.net.collect_params(), 'adam', {
'learning_rate': self.learning_rate,
'wd': self.weight_decay
})
for epoch in range(self.num_epochs):
for X, y in train_iter:
with autograd.record():
l = self.loss_func(self.net, X, y)
l.backward()
trainer.step(self.batch_size)
train_losses.append(
self.loss_func(self.net, train_features,
train_labels).asscalar())
if print_iter:
print("Epoch: " + str(epoch + 1))
print("\t Training_Loss: " + str(train_losses[-1]))
if test_labels is not None:
test_losses.append(
self.loss_func(self.net, test_features,
test_labels).asscalar())
self.train_losses = train_losses
self.test_losses = test_losses
return train_losses, test_losses
def optimize(batch_size, trainer, num_epochs, decay_epoch, log_interval, X, y,
net):
# num_examples = 1000
# X, y = genData(num_examples)
dataset = gdata.ArrayDataset(X, y)
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
square_loss = gloss.L2Loss()
y_vals = [square_loss(net(X), y).mean().asnumpy()]
for epoch in range(1, num_epochs + 1):
if decay_epoch and epoch > decay_epoch:
trainer.set_learning_rate(trainer.learning_rate * 0.1)
for batch_i, (features, label) in enumerate(data_iter):
with autograd.record():
output = net(features)
loss = square_loss(output, label)
loss.backward()
trainer.step(batch_size)
if batch_i * batch_size % log_interval == 0:
y_vals.append(square_loss(net(X), y).mean().asnumpy())
# 为了便于打印，改变输出形状并转化成numpy数组。
print('w:', net[0].weight.data(), '\nb:', net[0].bias.data(), '\n')
x_vals = np.linspace(0, num_epochs, len(y_vals), endpoint=True)
utils.semilogy(x_vals, y_vals, 'epoch', 'loss')
def train_gluon(trainer_name, hyperparams, batch_size):
#【读取数据】
data_iter = gdata.DataLoader(gdata.ArrayDataset(features, labels),
batch_size,
shuffle=True)
#【定义模型】
net = nn.Sequential()
net.add(nn.Dense(1))
#【初始化模型参数】
net.initialize(init=init.Normal(sigma=0.01))
#【定义损失函数】
loss = gloss.L2Loss()
#【定义优化算法】
trainer = gluon.Trainer(net.collect_params(), trainer_name, hyperparams)
#【训练模型】
num_epochs = 2
start = 0
ls = []
for _ in range(num_epochs):
start = time.time()
for epoch_i, (X, y) in enumerate(data_iter):
with autograd.record():
y_hat = net(X)
l = loss(y_hat, y)
l.backward()
trainer.step(batch_size)
if (epoch_i + 1) * batch_size % 100 == 0:
ls.append(loss(net(features), labels).mean().asscalar())
print('loss %f,%f sec per epoch' % (ls[-1],
(time.time() - start) / len(ls)))
plt.plot(np.linspace(0, num_epochs, len(ls)), ls)
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()
def optimize_gluon(trainer, features, labels, net, decay_epoch=None,
batch_size=10, log_interval=10, num_epochs=3):
"""Optimize an objective function with a Gluon trainer."""
dataset = gdata.ArrayDataset(features, labels)
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
loss = gloss.L2Loss()
ls = [loss(net(features), labels).mean().asnumpy()]
for epoch in range(1, num_epochs + 1):
# Decay the learning rate.
if decay_epoch and epoch > decay_epoch:
trainer.set_learning_rate(trainer.learning_rate * 0.1)
for batch_i, (X, y) in enumerate(data_iter):
with autograd.record():
l = loss(net(X), y)
l.backward()
trainer.step(batch_size)
if batch_i * batch_size % log_interval == 0:
ls.append(loss(net(features), labels).mean().asnumpy())
print('w[0]=%.2f, w[1]=%.2f, b=%.2f'
% (net[0].weight.data()[0][0].asscalar(),
net[0].weight.data()[0][1].asscalar(),
net[0].bias.data().asscalar()))
es = np.linspace(0, num_epochs, len(ls), endpoint=True)
semilogy(es, ls, 'epoch', 'loss')
def prepare(self):
self.load_data()
self.make_index()
self.get_centers_and_contexts(5)
sampling_weights = [self.counter[w] for w in self.idx_to_token]
self.get_negatives(sampling_weights, 5)
batch_size = 512
worker_num = 0 if sys.platform.startswith('win32') else 4
dataset = gdata.ArrayDataset(self.centers, self.contexts,
self.negatives)
data_iter = gdata.DataLoader(dataset,
batch_size,
shuffle=True,
batchify_fn=self.batchify,
num_workers=worker_num)
for batch in data_iter:
for name, data in zip(
['centers', 'contexts_negatives', 'masks', 'labels'], batch):
print(name, 'shape:', data.shape)
break
self.data_iter = data_iter
self.batch_size = batch_size
def optimize(batch_size, trainer, num_epochs, decay_epoch, log_interval,
features, labels, net):
i = 0
dataset = gdata.ArrayDataset(features, labels)
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
loss = gloss.L2Loss()
ls = [loss(net(features), labels).mean().asnumpy()]
for epoch in range(1, num_epochs + 1):
# 学习率自我衰减。
if decay_epoch and epoch > decay_epoch:
trainer.set_learning_rate(trainer.learning_rate * 0.1)
for batch_i, (X, y) in enumerate(data_iter):
with autograd.record():
l = loss(net(X), y)
l.backward()
i += 1
trainer.step(batch_size)
if batch_i * batch_size % log_interval == 0:
ls.append(loss(net(features), labels).mean().asnumpy())
# 为了便于打印，改变输出形状并转化成 numpy 数组。
print('i:', i, 'w:', net[0].weight.data(), '\nb:', net[0].bias.data(),
'\n')
es = np.linspace(0, num_epochs, len(ls), endpoint=True)
gb.semilogy(es, ls, 'epoch', 'loss')
def train_gluon_ch7(trainer_name,
trainer_hyperparams,
features,
labels,
batch_size=10,
num_epochs=2):
#【定义优化算法】
trainer = gluon.Trainer(net.collect_params(), trainer_name,
trainer_hyperparams)
#【生成数据】
data = gdata.ArrayDataset(features, labels)
#【读取数据】
data_iter = gdata.DataLoader(data, batch_size, shuffle=True)
#【训练模型】
ls = []
for _ in range(num_epochs):
start = time.time()
for batch_i, (X, y) in enumerate(data_iter):
with autograd.record():
y_hat = net(X)
l = loss(y_hat, y)
l.backward()
trainer.step(batch_size)
if (batch_i + 1) * batch_size % 100 == 0:
# 使用当前得到的参数来计算所有的样本的损失函数
ls.append(loss(net(features), labels).mean().asscalar())
print('loss:%f , %f sec per epoch' % (ls[-1], time.time() - start))
# np的两个函数arange(),linespace()都可以用来创建一维数组来构建坐标轴
# 区别在与arange()的参数是起点，终点，精度（越小越圆滑） linespace()的参数是起点，终点，点个数
#个人建议：若要将数组元素在图上表示观察，请使用linespace;若是想单纯画出一个函数图像，请使用arange,调整第三个参数以表示画图的精度
plt.plot(np.linspace(0, num_epochs, len(ls)), ls)
plt.xlabel('epoch')
plt.ylabel('loss')
plt.show()
def getBatchData(self, X, y, batchsize=None):
if batchsize: self.batchsize = batchsize
dataset = gdata.ArrayDataset(X, y)
batchdatas = gdata.DataLoader(dataset, self.batchsize, shuffle=True)
return batchdatas
def test_lamb_for_fashion_mnist():
mnist_train = gdata.vision.FashionMNIST(train=True)
mnist_test = gdata.vision.FashionMNIST(train=False)
batch_size = 512
transformer = gdata.vision.transforms.ToTensor()
if sys.platform.startswith('win'):
num_workers = 0 # 0 disables multi-processing.
else:
num_workers = 4
train_iter = gdata.DataLoader(mnist_train.transform_first(transformer),
batch_size,
shuffle=True,
num_workers=num_workers)
test_iter = gdata.DataLoader(mnist_test.transform_first(transformer),
batch_size,
shuffle=False,
num_workers=num_workers)
net = nn.Sequential()
net.add(nn.Conv2D(6, kernel_size=5), nn.BatchNorm(), nn.Activation('relu'),
nn.MaxPool2D(pool_size=2, strides=2), nn.Conv2D(16, kernel_size=5),
nn.BatchNorm(), nn.Activation('relu'),
nn.MaxPool2D(pool_size=2, strides=2),
nn.Dense(120), nn.BatchNorm(), nn.Activation('relu'), nn.Dense(84),
nn.BatchNorm(), nn.Activation('relu'), nn.Dense(10))
ctx = mx.cpu()
net.initialize(ctx=ctx)
trainer = gluon.Trainer(net.collect_params(), 'LAMB',
{'learning_rate': 0.001})
loss = gluon.loss.SoftmaxCrossEntropyLoss()
num_epochs = 5
def evaluate_accuracy(data_iter, net, ctx):
"""Evaluate accuracy of a model on the given data set."""
acc_sum, n = 0.0, 0.0
for X, y in train_iter:
X = X.as_in_context(ctx)
y = y.as_in_context(ctx)
y_hat = net(X)
y = y.astype('float32')
acc_sum += (y_hat.argmax(axis=1) == y).sum().asscalar()
n += y.size
return acc_sum / n
def train(net, train_iter, test_iter, loss, num_epochs, batch_size,
trainer, ctx):
for epoch in range(num_epochs):
train_l_sum, train_acc_sum, n = 0.0, 0.0, 0
for X, y in train_iter:
X = X.as_in_context(ctx)
y = y.as_in_context(ctx)
with autograd.record():
y_hat = net(X)
l = loss(y_hat, y).sum()
l.backward()
trainer.step(batch_size)
y = y.astype('float32')
train_l_sum += l.asscalar()
train_acc_sum += (y_hat.argmax(axis=1) == y).sum().asscalar()
n += y.size
test_acc = evaluate_accuracy(test_iter, net, ctx)
print('epoch %d, loss %.4f, train acc %.3f, test acc %.3f' %
(epoch + 1, train_l_sum / n, train_acc_sum / n, test_acc))
train(net, train_iter, test_iter, loss, num_epochs, batch_size, trainer,
ctx)
# plt.xlabel('x1')
# plt.ylabel('x2')
# plt.show()
#【生成数据】
data = np.genfromtxt('./data/airfoil_self_noise.dat',
delimiter='\t') #因为数据中每个数据之间使用tab隔开，所以在这里要告诉numpy!
# Z-SCORE标准化处理数据
data = (data - data.mean(axis=0)) / data.std(axis=0)
features, labels = nd.array(data[:1500, :-1]), nd.array(data[:1500, -1])
#【读取数据】
batch_size = 10
data_iter = gdata.DataLoader(gdata.ArrayDataset(features, labels),
batch_size,
shuffle=True)
#【定义计算模型】
def net(X, w, b):
return nd.dot(X, w) + b
#【初始化模型函数】
w = nd.random.normal(scale=0.01, shape=(features.shape[1], 1))
b = nd.zeros(shape=(1, ))
w.attach_grad()
b.attach_grad()
def train(encoder, decoder, decoder_init_state, max_seq_len, ctx, eval_fr_ens):
encoder.initialize(init.Xavier(), ctx=ctx)
decoder.initialize(init.Xavier(), ctx=ctx)
decoder_init_state.initialize(init.Xavier(), ctx=ctx)
encoder_optimizer = gluon.Trainer(encoder.collect_params(), 'adam',
{'learning_rate': lr})
decoder_optimizer = gluon.Trainer(decoder.collect_params(), 'adam',
{'learning_rate': lr})
decoder_init_state_optimizer = gluon.Trainer(
decoder_init_state.collect_params(), 'adam', {'learning_rate': lr})
data_iter = gdata.DataLoader(dataset, batch_size, shuffle=True)
l_sum = 0
for epoch in range(1, num_epochs + 1):
for x, y in data_iter:
cur_batch_size = x.shape[0]
with autograd.record():
l = nd.array([0], ctx=ctx)
valid_length = nd.array([0], ctx=ctx)
encoder_state = encoder.begin_state(func=nd.zeros,
batch_size=cur_batch_size,
ctx=ctx)
# encoder_outputs 包含了编码器在每个时间步的隐藏状态。
encoder_outputs, encoder_state = encoder(x, encoder_state)
#print(encoder_outputs.shape)
encoder_outputs = encoder_outputs.flatten()
#print(encoder_outputs.shape)
# 解码器的第一个输入为 BOS 符号。
decoder_input = nd.array([output_vocab.token_to_idx[BOS]] *
cur_batch_size,
ctx=ctx)
mask = nd.ones(shape=(cur_batch_size, ), ctx=ctx) #用处
decoder_state = decoder_init_state(encoder_state[0])
for i in range(max_seq_len):
decoder_output, decoder_state = decoder(
decoder_input, decoder_state, encoder_outputs)
decoder_input = y[:, i]
valid_length = valid_length + mask.sum()
l = l + (mask * loss(decoder_output, y[:, i])).sum()
mask = mask * (y[:, i] != eos_id)
l = l / valid_length
#with open('train_loss.txt','a',encoding = "utf-8") as f:
#f.write('batch_size_loss'+l+'\n')
l.backward()
encoder_optimizer.step(1)
decoder_optimizer.step(1)
decoder_init_state_optimizer.step(1)
l_sum += l.asscalar()
if epoch % eval_interval == 0 or epoch == 1:
if epoch == 1:
with open('result.txt', 'a', encoding="utf-8") as f:
f.write('epoch: ' + str(epoch) + '\n')
print('epoch %d, loss %f, ' % (epoch, l_sum / len(data_iter)))
else:
print('epoch %d, loss %f, ' %
(epoch, l_sum / eval_interval / len(data_iter)))
if epoch != 1:
l_sum = 0
with open('result.txt', 'a', encoding="utf-8") as f:
f.write('epoch: ' + str(epoch) + '\n')
#在dev集上的训练
translate(encoder, decoder, decoder_init_state, eval_fr_ens, ctx,
max_seq_len)
def build_decision_tree(data_frame, feature_columns, label_column):
# print(data_frame)
# 构造决策树
node = Node()
# 单独取出标记列
label_series = list(data_frame[label_column].iteritems())
# 如果所有样本标记相同,那么直接将该结点定义为叶节点
if False not in [label_series[0][1] == label_series[i][1] for i in range(len(label_series))]:
node.label = label_series[0][1]
return node
# 对每一个label取值进行计数
most_y = 0
most_cnt = 0
cnt = {}
for i, y in label_series:
if y not in cnt.keys():
cnt[y] = 1
else:
cnt[y] += 1
if cnt[y] > most_cnt:
most_y = y
most_cnt = cnt[y]
# 将当前结点标记为出现较多的label
node.label = most_y
# 根据当前结点的数据训练对率回归线性模型
# 定义数据集
dataset = gluon.data.ArrayDataset(
data_frame[feature_columns].as_matrix().astype('float32'), data_frame[[label_column]].as_matrix().astype('float32'))
dataiter = gdata.DataLoader(
dataset, batch_size=len(data_frame), shuffle=False)
# 定义网络
net = nn.Sequential()
net.add(nn.Dense(1))
net.collect_params().initialize(init=mx.init.Normal())
# 定义训练器
trainer = gluon.Trainer(net.collect_params(),
'rmsprop', {'learning_rate': .5,'gamma1': .9})
losser = gluon.loss.LogisticLoss(label_format='binary')
# 训练模型
num_epochs = 10
verbose_epoch = 0
for epoch in range(num_epochs):
for feature, label in dataiter:
with mx.autograd.record():
label_hat = net(feature)
# print(sigmoid.forward(label_hat))
loss = losser(label_hat, label)
loss.backward()
trainer.step(len(data_frame))
if epoch > verbose_epoch:
print('Epoch', epoch, ', Loss =', loss.mean().asscalar())
# 根据对率回归结果划分数据集
positive_rows = []
negative_rows = []
for index, data in data_frame.iterrows():
feature = nd.array(
data[feature_columns].as_matrix()).reshape(shape=(1, -1))
label = net(feature)[0][0]
label = sigmoid.forward(label)
print(label.asscalar(), data[label_column])
if label > .5:
positive_rows.append(index)
else:
negative_rows.append(index)
# 递归建立子结点
if len(positive_rows) == 0:
node.label = 0
elif len(negative_rows) == 0:
node.label = 1
else:
node.positive_child = build_decision_tree(
data_frame.loc[positive_rows], feature_columns, label_column)
node.negative_child = build_decision_tree(
data_frame.loc[negative_rows], feature_columns, label_column)
return node
