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