def train_fine_tuning(net, learning_rate, batch_size=128, num_epochs=5):
train_iter = gdata.DataLoader(
train_imgs.trainform_first(train_augs), batch_size, shuffle = True)
test_iter = gdata.DataLoader(
test_imgs.transform_first(test_augs), batch_size)
ctx = d2l.try_all_gpus()
net.collect_params().resnet_ctx(ctx)
net.hybridize()
loss = gloss.SoftmaxCrossEntropyLoss()
trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': learning_rate,
'wd': 0.001})
d2l.train(train_iter, test_iter, net, loss, trainer, ctx, num_epochs)
def train_fine_tuning(net, learning_rate, batch_size=32, num_epochs=5):
train_iter = gdata.DataLoader(train_data.transform_first(train_trans),
batch_size,
shuffle=True)
test_iter = gdata.DataLoader(test_data.transform_first(test_trans),
batch_size)
ctx = d2l.try_all_gpus()
net.collect_params().reset_ctx(ctx)
net.hybridize()
if os.path.exists('face_cnn.params'):
print('load params from existing file')
net.load_parameters('face_cnn.params')
# lrs = mx.lr_scheduler.FactorScheduler(500, 0.8)
loss = gloss.L2Loss()
trainer = gluon.Trainer(net.collect_params(), 'sgd', {
'learning_rate': learning_rate,
'wd': 0.001
})
train(train_iter, net, loss, trainer, batch_size, num_epochs, ctx)
def train_fine_tuning(datasetName,
modelName,
learning_rate,
net,
train_iter,
valid_iter,
num_epochs,
n_retrain_epoch=0):
import d2lzh as d2l
ctx = d2l.try_all_gpus()[0]
net.collect_params().reset_ctx(ctx)
net.hybridize()
loss = gloss.SoftmaxCrossEntropyLoss()
trainer = Trainer(net.collect_params(), 'sgd', {
'learning_rate': learning_rate,
'wd': 0.001
})
return train(ctx, loss, trainer, datasetName, modelName, net, train_iter,
valid_iter, num_epochs, n_retrain_epoch)
self.constant_embedding(inputs),
dim=2)
# 根据Conv1D要求的输入格式，将词向量维，即一维卷积层的通道维，变换到前一维
embeddings = embeddings.transpose((0, 2, 1))
# 对于每个一维卷积层，在时序最大池化后会得到一个形状为(批量大小, 通道大小, 1)的
# NDArray。使用flatten函数去掉最后一维，然后在通道维上连结
encoding = nd.concat(
*[nd.flatten(self.pool(conv(embeddings))) for conv in self.convs],
dim=1)
# 应用丢弃法后使用全连接层得到输出
outputs = self.decoder(self.dropout(encoding))
return outputs
embed_size, kernel_sizes, nums_channels = 100, [3, 4, 5], [100, 100, 100]
ctx = d2l.try_all_gpus()
net = TextCNN(vocab, embed_size, kernel_sizes, nums_channels)
net.initialize(init.Xavier(), ctx=ctx)
glove_embedding = text.embedding.create(
'glove', pretrained_file_name='glove.6B.100d.txt', vocabulary=vocab)
net.embedding.weight.set_data(glove_embedding.idx_to_vec)
net.constant_embedding.weight.set_data(glove_embedding.idx_to_vec)
net.constant_embedding.collect_params().setattr('grad_req', 'null')
lr, num_epochs = 0.001, 5
trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': lr})
loss = gloss.SoftmaxCrossEntropyLoss()
d2l.train(train_iter, test_iter, net, loss, trainer, ctx, num_epochs)
d2l.predict_sentiment(net, vocab, ['this', 'movie', 'is', 'so', 'great'])
d2l.predict_sentiment(net, vocab, ['this', 'movie', 'is', 'so', 'bad'])
vocab = d2l.get_vocab_imdb(train_data)
print('分词：')
print('# words in vocab:', len(vocab))
print(train_data[0])
#创建数据迭代器。每次迭代将返回⼀个小批量的数据。
#preprocess_imdb函数对每条评论进⾏分词，并通过词典转换成词索引，然后通过截断或者补 0 来将每条评论⻓度固定成500。
batch_size = 64
train_set = gdata.ArrayDataset(*d2l.preprocess_imdb(train_data, vocab))
test_set = gdata.ArrayDataset(*d2l.preprocess_imdb(test_data, vocab))
train_iter = gdata.DataLoader(train_set, batch_size, shuffle=True)
test_iter = gdata.DataLoader(test_set, batch_size)
#构建循环神经网络的模型
#每个词先通过嵌⼊层得到特征向量。然后，我们使⽤双向循环神经⽹络对特征序列进⼀步编码得到序列信息。最后，我们将编码的序列信息通过全连接层变换为输出
# 创建⼀个含两个隐藏层的双向循环神经⽹络
embed_size, num_hiddens, num_layers, ctx = 100, 100, 2, d2l.try_all_gpus()
net = d2l.BiRNN(vocab, embed_size, num_hiddens, num_layers)
net.initialize(init.Xavier(), ctx=ctx)
#加载预训练的词向量 ⽤这些词向量作为评论中每个词的特征向量
glove_embedding = text.embedding.create('glove', pretrained_file_name='glove.6B.100d.txt', vocabulary=vocab)
#预训练词向量的维度需要跟创建的模型中的嵌⼊层输出⼤小 embed_size ⼀致 在训练中我们不再更新这些词向量
net.embedding.weight.set_data(glove_embedding.idx_to_vec)
net.embedding.collect_params().setattr('grad_req', 'null')
#训练并评价模型
lr, num_epochs = 0.01, 5
trainer = gluon.Trainer(net.collect_params(), 'adam', {'learning_rate': lr})
loss = gloss.SoftmaxCrossEntropyLoss()
d2l.train(train_iter, test_iter, net, loss, trainer, ctx, num_epochs)
