def run(self):
starttime = time.time()
rootName = (self.rootDir)
if os.path.exists(rootName):
root = loadModel(rootName)
else:
dictName = self.dictDir
word_freq = loadWords(dictName)
root = TrieNode('*', word_freq)
saveModel(root, rootName)
# 加载新的文章
fileName = self.demoDir
data = self.loadData(fileName, self.stopwords)
# 将新的文章插入到Root中
self.loadData2Root(root, data)
# 定义取TOP5个
N = 5
result, add_word = root.wordFind(N)
# 如果想要调试和选择其他的阈值，可以print result来调整
print("\n----\n", '增加了 %d 个新词, 词语和得分分别为: \n' % len(add_word))
print('#############################')
for word, score in add_word.items():
print(word + ' ----> ', score)
print('#############################\n')
for word, score in add_word.items():
jieba.add_word(word)
print("互信息、信息熵：")
print("".join([(x + '/ ') for x in jieba.cut(self.test_text, cut_all=False) if x not in self.stopwords]))
endtime = time.time()
print('time cost:' + str(round((endtime - starttime), 4)) + ' seconds.\n')
def runNetwork(model, batch_size, epochs):
"""
Compiles and runs the network with ImageDataGenerator.
Args:
model: A neural network model structure
batch_size: no. of training examples per iteration
epochs: no. of iterations the neurons update their weights
Returns:
printed results of the model's running accuracy
"""
x_train, y_train, x_test, y_test = prepareData()
# Compile the network
model.compile(loss="categorical_crossentropy", # use the loss function to take into note the probabilities of each category
optimizer="rmsprop",
metrics=["accuracy"]) # use accuracy as a metric of progress during training
# Training
model.fit_generator(createGenerator().flow(x_train, y_train, batch_size=batch_size),
steps_per_epoch=x_train.shape[0] // batch_size, epochs=epochs, verbose=1,
validation_data=(x_test, y_test))
# Evaluate performance. If training accuracy >> evaluation accuracy, overfitting is present.
test_loss, test_acc = model.evaluate(x_test, y_test)
print("Accuracy: ", str(test_acc))
utils.saveModel(model)
def trainingLoopAE(obj, model, num_epoch, train_dataloader, criterion,
optimizer, loss_dict, path, device):
"""
A universal training loop to optimize any loss function
Args:
obj : Object on which model is to be trained
model : Architecture of the neural network
num_epoch : number of iterations
criterion : loss function which we need to optimize
train_dataloader : Training Dataset
optimizer : optimize the loss using this optimizer
loss_dict : A dictionary to keep track of loss
path : location where to store model
device : GPU or CPU device
"""
# Check if path to directory exist. If no: then create one
if not os.path.exists(path):
os.makedirs(path)
curr_epoch = currEpoch(path)
epochs_left = num_epoch - curr_epoch
# Load Model
if curr_epoch is not -1:
model.load_state_dict(torch.load(path + '/' + str(curr_epoch)))
# print(model)
model.eval()
for epoch in range(epochs_left): # loop over the dataset multiple times
running_loss = 0.0
for data in train_dataloader:
data = data.to(device)
# zero the parameter gradients
optimizer.zero_grad()
# forward + backward + optimize
outputs = model(data)
loss = criterion(outputs, data)
loss.backward()
optimizer.step()
# print statistics
running_loss += loss.item()
loss_dict[model.name].append(running_loss)
if epoch % 50 == 0: # print every 50 mini-batches
plotLoss(loss_dict, model.name)
plotPointCloud(obj, model)
saveModel(path, model, epoch)
print(epoch)
def train(self, epoch=5):
self.iteration = 0
best_dev_loss = self.eval()
for ep in range(epoch):
epoch_tic = time.time()
for batch_idx, (data, target, imageName) in enumerate(self.loader):
self.model.train() # set training mode
self.optimizer.zero_grad()
#self.model.zero_grad()
self.model.hidden = self.model.init_hidden(data[0].shape[0])
if self.device != None:
data = (data[0].cuda(self.device),
data[1].cuda(self.device),
data[2].cuda(self.device))
target = target.cuda(self.device)
self.model.hidden = (self.model.hidden[0].cuda(
self.device), self.model.hidden[1].cuda(self.device))
# forward pass
output = self.model(data)
loss = self.loss_fn(torch.squeeze(output), target.float())
# backward pass
loss.backward()
# weight update
self.optimizer.step()
if self.iteration % self.log_interval == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.
format(ep, batch_idx * len(data),
len(self.loader.dataset),
100. * batch_idx / len(self.loader),
loss.item()))
self.train_logger.writeLoss(self.iteration, loss.item())
if self.iteration != 0 and self.iteration % self.eval_interval == 0:
dev_loss = self.eval()
if dev_loss < best_dev_loss:
best_dev_loss = dev_loss
saveModel('%s/hp-best.pth' % self.exp_path, self.model,
self.optimizer)
#if self.iteration % self.save_interval == 0:
# self.saveModel()
self.iteration += 1
epoch_toc = time.time()
print('End of epoch %i. Seconds took: %.2f s.' %
(ep, epoch_toc - epoch_tic))
def train(model,
x_train,
y_train,
x_test,
y_test,
loss_op,
optimization,
epochs,
model_save_path='',
model_name='model'):
train_loss, train_accuracy, test_loss, test_accuracy = getTrainAndTestMetrics(
)
train_summary_writer, test_summary_writer = trainLogging.getTrainAndTestSummaryWriters(
)
n_batches = len(x_train)
best_accuracy = 0
for epoch in range(epochs):
n_batch = 0
for x, y in zip(x_train, y_train):
n_batch += 1
trainLogging.printTrainingBatchProgress(epoch + 1, epochs, n_batch,
n_batches, train_loss,
train_accuracy)
trainStep(model, x, y, loss_op, optimization, train_loss,
train_accuracy)
testStep(model, x_test, y_test, loss_op, test_loss, test_accuracy)
trainLogging.printTrainingEpochProgress(epoch + 1, epochs, n_batch,
n_batches, train_loss,
train_accuracy, test_loss,
test_accuracy)
if test_accuracy.result() > best_accuracy:
best_accuracy = test_accuracy.result()
utils.saveModel(model, model_save_path, model_name)
print(
'Saved new best model with accuracy: {}'.format(best_accuracy))
# Reset the metrics for the next epoch
train_loss, train_accuracy, test_loss, test_accuracy = resetMetrics(
train_loss, train_accuracy, test_loss, test_accuracy)
return model
def train(self, epoch=5):
self.model.train() # set training mode
self.iteration = 0
best_dev_loss = self.eval()
for ep in range(epoch):
epoch_tic = time.time()
for batch_idx, (data, target) in enumerate(self.loader):
if self.device != None:
data, target = data.cuda(self.device), target.cuda(
self.device)
self.optimizer.zero_grad()
# forward pass
output = self.model(data)
output = func.log_softmax(output, dim=1)
loss = func.nll_loss(output, target)
# backward pass
loss.backward()
# weight update
self.optimizer.step()
if self.iteration % self.log_interval == 0:
print('Train Epoch: {} [{}/{} ({:.0f}%)]\tLoss: {:.6f}'.
format(ep, batch_idx * len(data),
len(self.loader.dataset),
100. * batch_idx / len(self.loader),
loss.item()))
self.train_logger.writeLoss(self.iteration, loss.item())
if self.iteration != 0 and self.iteration % self.eval_interval == 0:
dev_loss = self.eval()
if dev_loss < best_dev_loss:
best_dev_loss = dev_loss
saveModel('%s/lm-best.pth' % self.exp_path, self.model,
self.optimizer)
#if self.iteration % self.save_interval == 0:
# self.saveModel()
self.iteration += 1
epoch_toc = time.time()
print('End of epoch %i. Seconds took: %.2f s.' %
(ep, epoch_toc - epoch_tic))
def runNetwork(model, batch_size, epochs):
x_train, y_train, x_test, y_test = prepareData()
# Compile the network
model.compile(
loss=
"categorical_crossentropy", # use the loss function to take into note the probabilities of each category
optimizer="rmsprop",
metrics=["accuracy"
]) # use accuracy as a metric of progress during training
# Training
model.fit_generator(createGenerator().flow(x_train,
y_train,
batch_size=batch_size),
steps_per_epoch=x_train.shape[0] // batch_size,
epochs=epochs,
verbose=1,
validation_data=(x_test, y_test))
test_loss, test_acc = model.evaluate(x_test, y_test)
print("Accuracy: ", str(test_acc))
utils.saveModel(model)
r2 = sklearn.metrics.r2_score(x1.cpu().data, y1.cpu().data)
print(' Test R² = %.2f' % (r2), '\n')
avg_time_per_epoch += (timer() - start)
# Early stopping
if arg.patience > 0: # When 0 or smaller, run until end of epochs
if test_score > prev_test_score:
early_stop_count += 1
if early_stop_count == arg.patience:
print('Early stopping condition reached')
last_epoch = epoch + 1
break
else:
early_stop_count = 0
saveModel(model, save_path)
prev_test_score = test_score
best_epoch = epoch + 1
avg_time_per_epoch = avg_time_per_epoch / last_epoch
print('Average time per epoch: %.2fs\n' % avg_time_per_epoch)
# ---- REVERT TO BEST MODEL ----
if arg.patience > 0:
print('Load best known configuration (epoch %d)\n' % best_epoch)
model.load_state_dict(torch.load(
'%s/PoNDeR.pth' % (save_path))) # Load best known configuration
# ---- PLOTTING ----
print('Running final eval on test set...')
test_score, x1, y1 = evaluateModel(model,
def train(model,
old_model,
epoch,
lr,
tempature,
lamda,
train_loader,
test_loader,
modelPath,
checkPoint,
useCuda=True,
adjustLR=False,
earlyStop=False,
tolearnce=4):
tolerance_cnt = 0
step = 0
best_acc = 0
if useCuda:
model = model.cuda()
old_model = old_model.cuda()
ceriation = nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(),
lr=lr,
momentum=0.9,
weight_decay=5e-4)
# train
for epoch_index in range(1, epoch + 1):
sum_loss = 0
sum_dist_loss = 0
model.train()
old_model.eval()
old_model.freeze_weight()
if adjustLR: # use LR adjustment
cifar100_adjust_lr(optimizer, lr, epoch_index)
for batch_idx, (x, target) in enumerate(train_loader):
optimizer.zero_grad()
if useCuda: # use GPU
x, target = x.cuda(), target.cuda()
x, target = Variable(x), Variable(target)
logits = model(x)
cls_loss = ceriation(logits, target)
dist_loss = Variable(torch.zeros(1).cuda())
if i > 1: # distill loss is not used in first class batch
dist_target = old_model(x)
logits_dist = logits[:, :-CLASS_NUM_IN_BATCH]
dist_loss = MultiClassCrossEntropy(logits_dist, dist_target,
tempature)
loss = cls_loss + lamda * dist_loss
else:
loss = cls_loss
sum_loss += loss.data[0]
sum_dist_loss += dist_loss.data[0]
loss.backward()
optimizer.step()
step += 1
if (batch_idx + 1) % checkPoint == 0 or (batch_idx +
1) == len(trainLoader):
print(
'==>>> epoch: {}, batch index: {}, step: {}, train loss: {:.6f}, dist loss:{:.6f}'
.format(epoch_index, batch_idx + 1, step,
sum_loss / (batch_idx + 1),
sum_dist_loss / (batch_idx + 1)))
acc = inference(net, test_loader, useCuda=True, k=1)
# early stopping
if earlyStop:
if acc < best_acc:
tolerance_cnt += 1
else:
best_acc = acc
tolerance_cnt = 0
saveModel(model, epoch_index, best_acc, modelPath)
if tolerance_cnt >= tolearnce:
print("early stopping training....")
saveModel(model, epoch_index, best_acc, modelPath)
return model
else:
if best_acc < acc:
saveModel(model, epoch_index, acc, modelPath)
best_acc = acc
print("best acc:", best_acc)
def trainingLoopGAN(obj,
training_generator,
generator,
discriminator,
model_name,
num_epoch,
optimizer_g,
optimizer_d,
loss_dict,
path,
device,
ae=None,
mu=0,
sigma=0.2,
discriminator_boost=5,
lambda_gp=10):
"""
A universal training loop to optimize any loss function
Args:
obj : Object on which model is to be trained
training_generator : Training Set Generator
generator : Architecture of the generator
discriminator : Architecture of the generator
num_epoch : number of iterations
optimizer_g : optimize the loss for generator using this optimizer
optimizer_d : optimize the loss for discriminator using this optimizer
loss_dict : A dictionary to keep track of loss
path : location where to store model
device : GPU or CPU device
ae : Autoencoder Model
mu, sigma : Mean and Standard Deviation for Normal Distribution
discriminator_boost : For every training iteration of generator train the
critic this many times
lambda_gp : Regularizing factor for Gradient Penalty
"""
# Check if path to directory exist. If no: then create one
if not os.path.exists(path):
os.makedirs(path)
for epoch in range(num_epoch): # loop over the dataset multiple times
running_loss_g = 0.0
running_loss_d = 0.0
for data in training_generator:
data = data.to(device)
if ae is not None:
data = ae(data)
for _ in range(discriminator_boost):
# zero the parameter gradients
optimizer_d.zero_grad()
# forward + backward + optimize
noise = noiseFunc(mu, sigma, data.shape[0], device)
outputs = generator(noise)
loss_d_fake = discriminator(outputs).mean()
loss_d_fake.backward()
loss_d_real = discriminator(data).mean()
loss_d = loss_d_real + loss_d_fake
# Gradient Penalty for Latent GAN
if 'Latent' in generator.name:
grad_penal = compute_gradient_penalty(
discriminator, data, outputs, device)
loss_d = loss_d + lambda_gp * grad_penal
optimizer_d.step()
running_loss_d += loss_d
optimizer_g.zero_grad()
noise = torch.randn((50, 128)).to(device)
outputs = generator(noise)
loss_g = discriminator(outputs).mean()
loss_g.backward()
optimizer_g.step()
running_loss_g += loss_g
loss_dict[generator.name].append(running_loss_g)
loss_dict[discriminator.name].append(running_loss_d)
if epoch % 50 == 0: # print every 10 mini-batches
plotLoss(loss_dict, model_name)
plotPointCloud(obj, generator)
saveModel(path + 'Gen ', generator, epoch)
saveModel(path + 'Dis ', discriminator, epoch)
print(epoch)
def train(model, head_index, epoch, lr, output_dim, train_loader, test_loader, label_dict,
modelPath, checkPoint, useCuda=True, adjustLR=False, earlyStop=False, tolearnce=4):
tolerance_cnt = 0
step = 0
best_acc, best_new_acc, best_old_acc = 0, 0, 0
old_model = copy.deepcopy(model) # copy the old model
if useCuda:
model = model.cuda()
old_model = old_model.cuda()
ceriation = CosineLoss(output_dim)
# optimizer = optim.Adam(net.parameters(), lr=lr)
optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)
# train
for epoch_index in range(1, epoch+1):
sum_loss = 0
model.train()
old_model.eval()
# old_model.freeze_weight()
if adjustLR: # use LR adjustment
ImgaeNet200_adjust_lr(optimizer, lr, epoch_index)
for batch_idx, (x, target) in enumerate(train_loader):
optimizer.zero_grad()
# get label vector
y_vec_train_np = labels2Vec(target, label_dict, output_dim)
y_vec_train = torch.from_numpy(y_vec_train_np)
if useCuda: # use GPU
x, y_vec_train = x.cuda(), y_vec_train.cuda()
x, y_vec_train = Variable(x), Variable(y_vec_train)
# only calculate new loss
out = model(x, head_index)
loss = ceriation(out, y_vec_train)
sum_loss += loss.data[0]
loss.backward()
optimizer.step()
step += 1
if (batch_idx + 1) % checkPoint == 0 or (batch_idx + 1) == len(trainLoader):
print('==>>> epoch: {}, batch index: {}, step: {}, train loss: {:.6f},'.
format(epoch_index, batch_idx + 1, step, sum_loss/(batch_idx+1),))
acc = inference(model, test_loader, label_dict, useCuda=True, k=5)
# observe old and new class acc
new_testLoader, new_test_classes = load_ImageNet200_online([test_root],
category_indexs=class_index[i:i + CLASS_NUM_IN_BATCH],
batchSize=batch_size, train=False)
print("new test classes")
new_acc = inference(model, new_testLoader, label_dict, useCuda=True, k=5)
old_acc = 0
if i != 0:
old_testLoader, old_test_classes = load_ImageNet200_online([test_root],
category_indexs=class_index[:i],
batchSize=batch_size, train=False)
print("old test classes")
old_acc = inference(model, old_testLoader, label_dict, useCuda=True, k=5)
# early stopping
if earlyStop:
if acc < best_acc:
tolerance_cnt += 1
else:
best_acc = acc
tolerance_cnt = 0
saveModel(model, epoch_index, best_acc, modelPath)
if tolerance_cnt >= tolearnce:
print("early stopping training....")
saveModel(model, epoch_index, best_acc, modelPath)
return model
else:
if best_acc < acc:
saveModel(model, epoch_index, acc, modelPath)
best_acc = acc
best_new_acc = new_acc
best_old_acc = old_acc
print("best acc:", best_acc)
print("best new acc:", best_new_acc)
print("best old acc:", best_old_acc)
def train(model,
head_index,
lamda,
epoch,
lr,
train_loader,
test_loader,
T,
modelPath,
checkPoint,
useCuda=True,
adjustLR=False,
earlyStop=False,
tolearnce=4):
tolerance_cnt = 0
step = 0
best_acc = 0
old_model = copy.deepcopy(model) # copy old model
if useCuda:
model = model.cuda()
old_model = old_model.cuda()
ceriation = nn.CrossEntropyLoss()
optimizer = optim.Adam(net.parameters(), lr=lr)
# optimizer = optim.SGD(model.parameters(), lr=lr, momentum=0.9, weight_decay=5e-4)
# train
for epoch_index in range(1, epoch + 1):
sum_loss = 0
old_sum_loss = 0
new_sum_loss = 0
model.train()
old_model.eval()
old_model.freeze_weight()
if adjustLR: # use LR adjustment
ImgaeNet200_adjust_lr(optimizer, lr, epoch_index)
for batch_idx, (x, target) in enumerate(train_loader):
optimizer.zero_grad()
if useCuda: # use GPU
x, target = x.cuda(), target.cuda()
test_x = Variable(x, volatile=True)
x, target = Variable(x), Variable(target)
# get response from old heads
old_outputs = []
old_mid_out = old_model.get_middle_output(test_x)
for head_idx in range(len(model.head_list) - 1):
old_output = old_model.get_output(old_mid_out, head_idx)
old_output = old_output.cpu().data.numpy()
old_output = Variable(torch.from_numpy(old_output).cuda())
old_outputs.append(old_output)
# distilling loss
old_loss = Variable(torch.zeros(1).cuda())
new_mid_out = model.get_middle_output(x)
for idx in range(len(old_outputs)):
out = model.get_output(new_mid_out, idx)
old_loss += MultiClassCrossEntropy(out, old_outputs[idx], T=T)
# calculate new loss
out = model.get_output(new_mid_out, head_index)
target -= CLASS_NUM_IN_BATCH * head_index # transform the class labels
new_loss = ceriation(out, target)
loss = new_loss + lamda * old_loss
sum_loss += loss.data[0]
old_sum_loss += old_loss.data[0]
new_sum_loss += new_loss.data[0]
loss.backward()
optimizer.step()
step += 1
if (batch_idx + 1) % checkPoint == 0 or (batch_idx +
1) == len(trainLoader):
print(
'==>>> epoch: {}, batch index: {}, step: {}, train loss: {:.6f},'
' new loss: {:.6f}, old loss: {:.6f}'.format(
epoch_index, batch_idx + 1, step,
sum_loss / (batch_idx + 1),
new_sum_loss / (batch_idx + 1),
old_sum_loss / (batch_idx + 1)))
acc = inference(model, test_loader, useCuda=True, k=5)
# observe new and old classes acc
new_testLoader, new_test_classes = load_ImageNet200_online(
[test_root],
category_indexs=class_index[i:i + CLASS_NUM_IN_BATCH],
batchSize=batch_size,
train=False)
print("new test classes")
new_acc = inference(model, new_testLoader, useCuda=True, k=5)
if i != 0:
old_testLoader, old_test_classes = load_ImageNet200_online(
[test_root],
category_indexs=class_index[:i],
batchSize=batch_size,
train=False)
print("old test classes")
old_acc = inference(model, old_testLoader, useCuda=True, k=5)
# early stopping
if earlyStop:
if acc < best_acc:
tolerance_cnt += 1
else:
best_acc = acc
tolerance_cnt = 0
saveModel(model, epoch_index, best_acc, modelPath)
if tolerance_cnt >= tolearnce:
print("early stopping training....")
saveModel(model, epoch_index, best_acc, modelPath)
return model
else:
if best_acc < acc:
saveModel(model, epoch_index, acc, modelPath)
best_acc = acc
print("best acc:", best_acc)
def train(model,
batchSize,
epoch,
checkPoint,
savePoint,
modelPath,
curEpoch=0,
best_acc=0,
useCuda=True,
adjustLR=True,
earlyStop=True,
tolearnce=4):
tolerance_cnt = 0
step = 0
if useCuda:
model = model.cuda()
ceriation = nn.CrossEntropyLoss()
# optimizer = optim.Adam(net.parameters(), lr=args.lr)
optimizer = optim.SGD(net.parameters(),
lr=args.lr,
momentum=0.9,
weight_decay=5e-4)
trainLoader, testLoader = loadCIFAR10(batchSize=batchSize)
for i in range(curEpoch, curEpoch + epoch):
model.train()
# trainning
sum_loss = 0
for batch_idx, (x, target) in enumerate(trainLoader):
optimizer.zero_grad()
if adjustLR:
adjust_lr(optimizer, epoch)
if useCuda:
x, target = x.cuda(), target.cuda()
x, target = Variable(x), Variable(target)
out = model(x)
loss = ceriation(out, target)
sum_loss += loss.item()
loss.backward()
optimizer.step()
step += 1
if (batch_idx + 1) % checkPoint == 0 or (batch_idx +
1) == len(trainLoader):
print(
'==>>> epoch: {}, batch index: {}, step: {}, train loss: {:.6f}'
.format(i, batch_idx + 1, step,
sum_loss / (batch_idx + 1)))
# save model every savepoint steps
# if (step + 1) % savePoint == 0:
# saveModel(model, i, best_acc, modelPath)
# print("----------save finish----------------")
acc = test(net, testLoader, useCuda=True)
# early stopping
if earlyStop:
if acc < best_acc:
tolerance_cnt += 1
else:
best_acc = acc
tolerance_cnt = 0
saveModel(model, epoch, best_acc, modelPath)
if tolerance_cnt >= tolearnce:
print("early stopping training....")
saveModel(model, epoch, best_acc, modelPath)
return
else:
if best_acc < acc:
saveModel(model, epoch, acc, modelPath)
best_acc = acc
import preprocess
from config import config
import modelCNN
from utils import saveModel
if __name__ == '__main__':
raw_data = preprocess.readData(config)
sms_text, sms_label = preprocess.cleanData(raw_data)
x_train, y_train, x_val, y_val = preprocess.categorical(
sms_text, sms_label, config)
embedding_layer = preprocess.train_dic(sms_text, config)
clf = modelCNN.trainCNN(x_train, y_train, x_val, y_val, embedding_layer)
saveModel(clf, "CNN", config)
import preprocess
from config import config
import models
from utils import saveModel, logging
if __name__ == '__main__':
raw_data = preprocess.readData(config)
sms_text, sms_label = preprocess.cleanData(raw_data)
x_train, y_train, x_test, y_test = preprocess.vectorize(
sms_text, sms_label, config)
clf = models.trainNB(x_train, y_train, x_test, y_test)
saveModel(clf, "贝叶斯", config)
clf = models.trainTree(x_train, y_train, x_test, y_test)
saveModel(clf, "决策树", config)
clf = models.trainRandomForest(x_train, y_train, x_test, y_test)
saveModel(clf, "随机森林", config)
clf = models.trainLinearSVC(x_train, y_train, x_test, y_test)
saveModel(clf, "线性SVC", config)
clf = models.trainSGDSVM(x_train, y_train, x_test, y_test)
saveModel(clf, "SGDSVM", config)
clf = models.trainSGDLog(x_train, y_train, x_test, y_test)
saveModel(clf, "SDD逻辑回归", config)
def train(epoch):
generator_loss = []
discriminator_loss = []
discriminator_acc = []
for i, (imgs, labels) in enumerate(dataloader, 1):
batch_size = imgs.shape[0]
# Adversarial ground truths
valid = FloatTensor(batch_size, 1).fill_(1.0)
fake = FloatTensor(batch_size, 1).fill_(0.0)
# Configure input
real_imgs = imgs.type(FloatTensor)
labels = labels.type(FloatTensor)
# print("Label.shape: \t{}".format(labels.shape))
# --------------------- #
# Train Generator #
# --------------------- #
optimizer_G.zero_grad()
# Sample noise and labels as generator input
z = FloatTensor(
np.random.normal(0, 1, size=(batch_size, opt.latent_dim)))
gen_labels = FloatTensor(np.random.randint(0, 2, size=(batch_size, 1)))
gen_labels = torch.cat((1 - gen_labels, gen_labels), dim=1)
# Generate a batch of images
gen_imgs = generator(z, gen_labels)
# Loss measures generator's ability to fool the discriminator
validity, pred_label = discriminator(gen_imgs)
g_loss = adversarial_loss(validity, valid) + auxiliary_loss(
pred_label, gen_labels)
# Comment:
# Adversarial loss:
# Measure the loss where caused by generated images
# (because the G(z, class) seems too fake)
# Need to minimize the loss of G(z, class)
# Auxiliary loss:
# Measure P(class | G(z, class))
# Want to maximize Prob(), that is, minimized the difference between D(G(z, class)) and class
g_loss.backward()
optimizer_G.step()
generator_loss.append(g_loss.item())
# --------------------- #
# Train Discriminator #
# --------------------- #
optimizer_D.zero_grad()
# Loss for real images
# real_pred, real_aux = discriminator(real_imgs)
# d_real_loss = (adversarial_loss(real_pred, valid) + auxiliary_loss(real_aux, labels))
# Loss for fake images
# fake_pred, fake_aux = discriminator(gen_imgs.detach())
# d_fake_loss = (adversarial_loss(fake_pred, fake) + auxiliary_loss(fake_aux, gen_labels))
# Loss for Adversarial loss
real_adv, real_aux = discriminator(real_imgs)
fake_adv, fake_aux = discriminator(gen_imgs.detach())
d_loss_adv = adversarial_loss(real_adv, valid) + adversarial_loss(
fake_adv, fake)
d_loss_aux = auxiliary_loss(real_aux, labels)
# Total discriminator loss
# d_loss = 0.5 * (d_real_loss + d_fake_loss)
d_loss = d_loss_adv + d_loss_aux
# Comment:
# Adversarial loss:
# Measure the loss where caused by difference sources
# Classify G(z, class) as fake and X as real.
# Auxiliary loss:
# Measure P(class | X)
# Want to maximize Prob(), that is, minimized the difference between D(X) and class
# Calculate discriminator class accuracy
# pred = np.concatenate([real_aux.data.cpu().numpy(), fake_aux.data.cpu().numpy()], axis=0)
# gt = np.concatenate([labels.data.cpu().numpy(), gen_labels.data.cpu().numpy()], axis=0)
# d_acc = np.mean(np.argmax(pred, axis=1) == gt)
cls_pred = real_aux.data.cpu().numpy()
gt = labels.data.cpu().numpy()
d_acc_real = np.mean(
np.argmax(cls_pred, axis=1) == np.argmax(gt, axis=1))
cls_pred = fake_aux.data.cpu().numpy()
gt = gen_labels.data.cpu().numpy()
d_acc_fake = np.mean(
np.argmax(cls_pred, axis=1) == np.argmax(gt, axis=1))
d_loss.backward()
optimizer_D.step()
discriminator_loss.append(d_loss.item())
discriminator_acc.append((d_acc_real + d_acc_fake) / 2)
batches_done = (epoch - 1) * len(dataloader) + i
# 1. Logging
if batches_done % opt.log_interval == 0:
print(
"[Epoch %d] [Batch %d/%d] [D loss: %f, accR: %d%%, accF: %d%%] [G loss: %f]"
% (epoch, i, len(dataloader), d_loss.item(), 100 * d_acc_real,
100 * d_acc_fake, g_loss.item()))
# 2. Sampling
if batches_done % opt.sample_interval == 0:
number = batches_done // opt.sample_interval
sample_image(number)
# 3. Saving
if batches_done % opt.save_interval == 0:
number = batches_done // opt.save_interval
savepath = "./models/acgan/{}-{}".format(opt.tag, feature)
utils.saveModel(
os.path.join(savepath, "generator_{}.pth".format(number)),
generator)
print("Model saved to: {}, iteration: {}".format(savepath, number))
return generator_loss, discriminator_loss, discriminator_acc
from Models.bilstm import BiLSTM
from torch.optim import Adamax
import torch
import torch.nn.functional as F
trainWordLists,trainTagLists,word2id,tag2id=utils.create('train.txt',make_vocab=True)
devWordLists,devTagList=utils.create('dev.txt',make_vocab=False)
#隐马尔科夫模型训练
print('HMM************************')
if os.path.exists('ckpts/hmm.pkl'):
hmm=utils.loadModel('ckpts/hmm.pkl')
predictTags = hmm.test(devWordLists, word2id, tag2id)
else:
hmm=HMM(len(tag2id),len(word2id))
hmm.train(trainWordLists,trainTagLists,tag2id,word2id)
utils.saveModel('ckpts/hmm.pkl',hmm)
predictTags=hmm.test(devWordLists,word2id,tag2id)
accuracy=metric.accuracy(predictTags,devTagList)
print('accuracy: ',accuracy)
print('CRF****************************')
# #条件随机序列场模型训练
if os.path.exists('ckpts/crf.pkl'):
crf=utils.loadModel('ckpts/crf.pkl')
print(crf)
predictTags=crf.test(devWordLists)
else:
crf=CRFModel()
crf.train(trainWordLists,trainTagLists)
utils.saveModel('ckpts/crf.pkl',crf)
predictTags=crf.test(devWordLists)
accuracy=metric.accuracy(predictTags,devTagList)
if (it + 1) % 1000 == 0:
save_path = saver.save(
sess, '%s/Epoch_(%d)_(%dof%d).ckpt' %
(ckpt_dir, epoch, it_epoch, batch_epoch))
print('Model saved in file: % s' % save_path)
# sample
if (it + 1) % 100 == 0:
f_sample_opt = sess.run(f_sample, feed_dict={z: z_ipt_sample})
f_sample_opt = (f_sample_opt + 1) * 0.5
f_sample_opt = np.round(f_sample_opt, decimals=0)
save_dir = './sample_images_while_training/3dganFix'
utils.mkdir(save_dir + '/')
utils.saveModel(f_sample_opt, save_dir, sample_batch_size, it)
# # sample
# if (it + 1) % 1 == 0:
## np.set_printoptions(threshold=np.inf)
## f_sample_opt = sess.run(real, feed_dict={real: real_ipt})
## print(f_sample_opt.shape)
## f_sample_opt = (f_sample_opt+1)*0.5
## f_sample_opt = np.round(f_sample_opt, decimals=0)
# output_data = np.load("3dDataIntFake.npy")
## np.savetxt("./data.txt",output_data[0,:,:,:,0])
# print("play1")
# save_dir = './sample_images_while_training/3dganFakeSlim1'
# utils.mkdir(save_dir + '/')
# utils.saveModel(output_data,save_dir,100,it)
# print("play2")
import utils
def saveModel(data, save_dir, sample_batch_size, it):
file_path = "./1a0c94a2e3e67e4a2e4877b52b3fca7.binvox"
with open(file_path, 'rb') as f:
model = binvox_rw.read_as_3d_array(f)
divide = 4
model.dims = [
model.dims[0] // divide, model.dims[1] // divide,
model.dims[2] // divide
]
model.scale = model.scale / divide
data = data.astype("bool")
data = np.reshape(data, [sample_batch_size] + model.dims)
# print(data[0])
for i in range(sample_batch_size):
filename = str(it) + '_' + str(i) + '.binvox'
print(data[i].shape)
model.data = data[i]
print(model.data.shape)
with open(save_dir + '/' + filename, mode='w') as f_test:
model.write(f_test)
data = np.load("3dDataInt.npy")
save_dir = './data_view'
utils.mkdir(save_dir + '/')
utils.saveModel(data, save_dir, 100, 1)
# QNet_moving_input:minibatch_s_next,
# QNet_moving_a_input:minibatch_a})
#train_writer.add_summary(summary, step_tot)
# 5. Overwite 'target' with 'moving' Q-network
if(step_tot % Qnetwork_update_frequency == 0):
merge = tf.summary.merge_all()
summary = sess.run(merge, feed_dict={QNet_moving_target_term:target_term,
QNet_moving_input:minibatch_s_next,
QNet_moving_a_input:minibatch_a})
train_writer.add_summary(summary, step_tot)
updateTargetNetwork(QNet_target_update_op_list, sess)
S = s_next
if done:
print("ep {:d} | steps {:d} | ep_r {:.0f} | exp {:.2f}".format(ep,step_tot,ep_r,random_action_chance))
break
# Save
if(ep % save_ep_interval == 0):
saveModel(ep, save_path, tf_saver, sess, save_model)
# Final save
saveModel(ep, save_path, tf_saver, sess, save_model)
ascending=False).to_csv(os.path.join(
output_DIR, output_filename),
index=False,
header=True,
sep=';',
encoding='utf-8')
df_results.set_index('Model', inplace=True)
print(df_results)
print(
df_results.drop(['Pipeline'],
axis=1).sort_values(by=['F1score'],
ascending=False).iloc[:, 7:])
print(
df_results.drop(['Pipeline'],
axis=1).sort_values(by=['eval_F1score'],
ascending=False).iloc[:, :7])
# --------------------------#
# SAVE Best MODEL #
# --------------------------#
# -- Just run the script with the best model obtained (comment unwanted ones)
Makedir(model_DIR)
print(f'[BEST MODEL] {Best_model_name} pipeline saved as best model')
print(f'\n {Best_model}')
saveModel(
Best_model,
os.path.join(
model_DIR,
Best_model_name.replace(' ', '').replace('+', '-') + '_' +
saved_model_suffix_filename))
logger.info(f"Loaded {savedModel}")
logger.info("Model defined")
criterion = nn.CrossEntropyLoss()
optimizer = torch.optim.Adam(
filter(lambda p: p.requires_grad, net.parameters()), 1e-3)
#Defining Learning Rate scheduler
exp_lr_scheduler = lr_scheduler.StepLR(optimizer, step_size=2, gamma=0.1)
print("Reached here")
#### TRAINING PROCESS
net = freezeLayers(net)
optimizer = torch.optim.Adam(
filter(lambda p: p.requires_grad, net.parameters()), 1e-3)
net, val_acc = trainModel(model=net,
traindl=trainLoader,
criterion=criterion,
optimizer=optimizer,
scheduler=exp_lr_scheduler,
logger=logger,
num_epochs=5,
validdl=validLoader,
test_valsubset=False)
saveModel(net, modelFolder, modelNo, 5, val_acc)
def printTopics(model):
predicted_topics = model.print_topics(num_topics=5, num_words=5)
for i, topics in predicted_topics:
print('Words in Topic {}:\n {}'.format(i + 1, topics))
if __name__ == '__main__':
arguments = parseArgs()
dataset = utils.loadDataset(arguments.reprocessDataset,
classification=False,
splitWords=True)
# Creating dictionary from dataset, where each unique term is assigned an index
dictionary = corpora.Dictionary(dataset)
# Converting list of documents into Bag of Words using dictionary
doc_term_matrix = [dictionary.doc2bow(doc) for doc in dataset]
# Training models on the document term matrix
modelList = [
LdaModel(doc_term_matrix, num_topics=10, id2word=dictionary, passes=2),
LsiModel(doc_term_matrix, num_topics=10, id2word=dictionary)
]
for model in modelList:
print('Topic Modelling using %s' % utils.getClassName(model))
printTopics(model)
utils.saveModel(model)
# loss = sess.run(cost, feed_dict={Z: xs})
# log = '%s batch: %10d cost: %.8e nmi-1: %.8f nmi-2: %.8f nmi-3: %.8f' % (
# dt.datetime.now(), i, loss, 0, 0, 0)
# print(log)
if not epoch % 1:
loss, dys = sess.run([cost, Y], feed_dict={Z: X})
nmi1 = 0
nmi2 = 0
nmi3 = 0
log = '%s epoch: %10d cost: %.8e nmi-1: %.8f nmi-2: %.8f nmi-3: %.8f' % (
dt.datetime.now(), epoch, loss, nmi1, nmi2, nmi3)
utils.writeLog('../log', name, log)
print(log)
# dhs = np.histogram(dys, bins=outdim)[0]
# print(khs)
# print(dhs)
if not epoch % 100:
utils.saveModel(sess, '../model', name, epoch)
epoch += 1
flag = False
if flag: break
print("optimization is finished! ")
def train(model,
epoch,
lr,
train_loader,
test_loader,
modelPath,
checkPoint,
useCuda=True,
adjustLR=False,
earlyStop=False,
tolearnce=4):
tolerance_cnt = 0
step = 0
best_acc = 0
if useCuda:
model = model.cuda()
# optimizer = optim.Adam(net.parameters(), lr=lr)
optimizer = optim.SGD(model.parameters(),
lr=lr,
momentum=0.9,
weight_decay=5e-4)
# trainning
for i in range(1, epoch + 1):
sum_loss = 0
model.train()
# class_weight = get_class_weight(trainLoader, train_classes)
# class_weight = torch.FloatTensor(class_weight).cuda()
if adjustLR: # use LR adjustment
ImgaeNet200_adjust_lr(optimizer, lr, i)
for batch_idx, (x, target) in enumerate(train_loader):
optimizer.zero_grad()
if useCuda: # use GPU
x, target = x.cuda(), target.cuda()
x, target = Variable(x), Variable(target)
out = model(x)
loss = nn.CrossEntropyLoss()(out, target)
sum_loss += loss.data[0]
loss.backward()
optimizer.step()
step += 1
if (batch_idx + 1) % checkPoint == 0 or (batch_idx +
1) == len(trainLoader):
print(
'==>>> epoch: {}, batch index: {}, step: {}, train loss: {:.6f}'
.format(i, batch_idx + 1, step,
sum_loss / (batch_idx + 1)))
acc = inference(net, test_loader, useCuda=True, k=5)
# early stopping
if earlyStop:
if acc < best_acc:
tolerance_cnt += 1
else:
best_acc = acc
tolerance_cnt = 0
saveModel(model, i, best_acc, modelPath)
if tolerance_cnt >= tolearnce:
print("early stopping training....")
saveModel(model, i, best_acc, modelPath)
return model
else:
if best_acc < acc:
saveModel(model, i, acc, modelPath)
best_acc = acc
print("best acc:", best_acc)
def save(self, outFile):
cu.saveModel(self, outFile)
linear_model.LogisticRegression(solver='saga', multi_class='auto'),
ensemble.RandomForestClassifier(n_estimators=25),
xgboost.XGBClassifier()
]
for xEncoder, yEncoder in dataEncodersList:
print('Using {} and {} for encoding xData and yData'.format(
utils.getClassName(xEncoder), utils.getClassName(yEncoder)))
# fit the encoders on the dataset
xEncoder.fit(xData)
yEncoder.fit(yData)
print('Encoding and splitting xData, yData')
xDataEncoded, yDataEncoded = xEncoder.transform(
xData), yEncoder.transform(yData)
xTrain, xValid, yTrain, yValid = model_selection.train_test_split(
xDataEncoded, yDataEncoded)
for model in modelsList:
print('Training model:', utils.getClassName(model))
trainedModel, accuracy = trainModel(model, xTrain, yTrain, xValid,
yValid)
print('Accuracy:', accuracy)
if arguments.printMetrics:
printMetrics(trainedModel, xValid, yValid)
filePrefix = utils.getClassName(xEncoder) + '_'
utils.saveModel(trainedModel, filePrefix=filePrefix)
def train(model,
epoch,
lr,
train_loader,
test_loader,
modelPath,
checkPoint=10,
lamda=15,
useCuda=True,
adjustLR=False,
earlyStop=False,
tolearnce=4):
tolerance_cnt = 0
step = 0
best_acc = 0
if useCuda:
model = model.cuda()
ceriation = nn.CrossEntropyLoss()
# optimizer = optim.Adam(net.parameters(), lr=lr)
optimizer = optim.SGD(model.parameters(),
lr=lr,
momentum=0.9,
weight_decay=5e-4)
# train
for epoch_idx in range(1, epoch + 1):
sum_loss = 0
sum_ewc_loss = 0
model.train()
if adjustLR: # use LR adjustment
ImgaeNet200_adjust_lr(optimizer, lr, epoch_idx)
for batch_idx, (x, target) in enumerate(train_loader):
optimizer.zero_grad()
if useCuda:
x, target = x.cuda(), target.cuda()
x, target = Variable(x), Variable(target)
out = model(x)
objective_loss = ceriation(out, target)
ewc_loss = model.ewc_loss(lamda, cuda=use_cuda)
loss = objective_loss + ewc_loss
sum_ewc_loss += ewc_loss.data[0]
sum_loss += loss.data[0]
loss.backward()
optimizer.step()
step += 1
if (batch_idx + 1) % checkPoint == 0 or (batch_idx +
1) == len(trainLoader):
print(
'==>>> epoch: {}, batch index: {}, step: {}, train loss: {:.6f}, ewc loss: {:.6f}'
.format(epoch_idx, batch_idx + 1, step,
sum_loss / (batch_idx + 1),
sum_ewc_loss / (batch_idx + 1)))
acc = inference(net, test_loader, useCuda=True, k=5)
# early stopping
if earlyStop:
if acc < best_acc:
tolerance_cnt += 1
else:
best_acc = acc
tolerance_cnt = 0
saveModel(model, i, best_acc, modelPath)
if tolerance_cnt >= tolearnce:
print("early stopping training....")
saveModel(model, i, best_acc, modelPath)
return model
else:
if best_acc < acc:
saveModel(model, epoch_idx, acc, modelPath)
best_acc = acc
print("best acc:", best_acc)
root.add(d)
print('------> 插入成功')
if __name__ == "__main__":
# 加载停用词
stopwords = getStopwords()
rootName = ("data/root.pkl")
if os.path.exists(rootName):
root = loadModel(rootName)
else:
dictName = 'data/dict.txt'
word_freq = loadWords(dictName)
root = TrieNode('*', word_freq)
saveModel(root, rootName)
# 加载新的文章
fileName = 'data/demo.txt'
data = loadDate(fileName, stopwords)
# 将新的文章插入到Root中
loadDate2Root(data)
# 定义取TOP5个
N = 5
result, add_word = root.wordFind(N)
# 如果想要调试和选择其他的阈值，可以print result来调整
# print("\n----\n", result)
print("\n----\n", '增加了 %d 个新词, 词语和得分分别为: \n' % len(add_word))
print('#############################')
for word, score in add_word.items():
decoderInputs = [attrCodeTensor, childrenCodeTensor]
# Apply decoder on encoder outputs.
childrenCodeActivated = childrenCodec.decode(decoderInputs)
attrsCodeActivated = attributeCodec.decode(decoderInputs)
# Define the model that will turn
# `encoder_input_data` & `decoder_input_data` into `decoder_target_data`
trainer_model = Model(
[*attributesEncoderInputs, *childrenEncoderInputs, *decoderInputs],
[childrenCodeActivated, attrsCodeActivated])
# Get inputs.
inputData = get_inputs(modelArgs)
plot_model(trainer_model, to_file="plot.png")
# Run training
trainer_model.compile(optimizer='rmsprop', loss='categorical_crossentropy')
trainer_model.fit([inputData.encoder_input_data, inputData.decoder_input_data],
inputData.decoder_target_data,
batch_size=modelArgs.batch_size,
epochs=modelArgs.epochs,
validation_split=0.2)
# Save model
saveModel(trainer_model, 't_s2s.json')
with open("modelArgs.json", "w") as fp:
json.dump(modelArgs, fp)
def save(self,outFile): cu.saveModel(self,outFile)
