def train(weight_src, learning_rate):
# Loading train dataset
print 'Loading datasets'
train_dataset = TrainDataset(path_to_training_set)
test_dataset = TestDataset(path_to_testing_set)
# Prepare Theano variables for inputs and targets
ftensor5 = t.TensorType('float32', (False, ) * 5)
input_var = t.tensor4('inputs')
target_var = ftensor5('targets')
# Build CNN model
print 'Building model and compiling functions'
if weight_src is None:
network = cnn.empty_cnn(num_classes * 2, False, batch_size, image_size,
input_var)
else:
network = cnn.file_cnn(weight_src, False, batch_size, image_size,
input_var, num_classes * 2)
prediction = lasagne.layers.get_output(network)
# Create a loss expression for training (categorical crossentropy)
loss = categorical_crossentropy_logdomain(prediction, target_var)
loss = loss.mean()
# Create update expressions for training (Stochastic Gradient Descent with Nesterov momentum)
params = lasagne.layers.get_all_params(network, trainable=True)
updates = lasagne.updates.nesterov_momentum(
loss, params, learning_rate=float(learning_rate), momentum=0.9)
# Compile a function performing a training step on a mini-batch (by giving the updates dictionary) and
# returning the corresponding training loss:
train_fn = theano.function([input_var, target_var],
loss,
updates=updates,
allow_input_downcast=True)
# Launch the training loop
print 'Starting training'
for epoch in range(1, num_epochs + 1):
print '\n\n---- EPOCH %i ----\n' % epoch
train_err = 0
train_time = time.time()
for inputs, targets in train_dataset.iterate_data():
train_err += train_fn(inputs, targets)
print 'Training took %.3f s loss: %f' % (time.time() - train_time,
train_err / epoch_size)
save('snapshot', lasagne.layers.get_all_param_values(network))
save('snapshot_' + str(epoch).zfill(4),
lasagne.layers.get_all_param_values(network))
# Test the model
network_model = cnn.pretrained_cnn(
lasagne.layers.get_all_param_values(network), True)
print 'Calculating score'
test(network_model, test_dataset)
def train_with_pooling(models, num_scenes, learning_rates, num_epochs, evaluate_loss_after=1, is_training=True):
prev_cost = {c: float("inf") for c in classes}
training_set = TrainDataset()
training_generator = DataLoader(dataset=training_set, batch_size=1,
shuffle=False, collate_fn=collate_fn)
epochs = {s: {c: [] for c in classes} for s in range(4)}
costs = {s: {c: [] for c in classes} for s in range(4)}
for epoch in range(num_epochs):
cost = {c: 0 for c in classes}
s = 0
for i in training_generator:
scene = i[0][0]
if (epoch + 1) % evaluate_loss_after == 0:
cost = step_through_scene(models, scene, epoch, num_epochs, s, True, __IS_TRAINING)
torch.cuda.empty_cache()
for c in classes:
epochs[s][c].append(epoch)
costs[s][c].append(cost[c])
plt.clf()
plt.plot(epochs[s][c], costs[s][c], color='red',linewidth=2, alpha=0.5)
plt.savefig('costs/' + 'epoch' + str(epoch+1) + '_scene' + str(s+1) + '_' + c.lower() + '.jpg')
if (s+1) == num_scenes:
for c in cost:
print "{} COST : {}".format(c, cost[c])
if cost[c] > prev_cost[c]:
learning_rates[c] *= 0.5
print "LEARNING RATE FOR {} WAS HALVED".format(c)
prev_cost = cost
s = s + 1
continue
step_through_scene(models, scene, epoch, num_epochs, s, False, __IS_TRAINING)
torch.cuda.empty_cache() s = s + 1
for c in models:
torch.save(models[c], 'models/' + c.lower() + '_' + str(epoch+1) + '.pkl')
def get_tested_dataset(self, last=False):
"""
Get tested data for training
Args:
last: bool, True - the last question, False - all the tested questions
Returns:
TrainDataset
"""
triplets = []
for sid, qids in self._tested.items():
if last:
qid = qids[-1]
triplets.append((sid, qid, self.data[sid][qid]))
else:
for qid in qids:
triplets.append((sid, qid, self.data[sid][qid]))
return TrainDataset(triplets, self.concept_map,
self.num_students, self.num_questions, self.num_concepts)
import torchvision.models as models
import torchvision.transforms as transforms
# 训练数据的变换
train_data_transforms = transforms.Compose([
# transforms.Resize([config['image_size'], config['image_size']]), # resize
#transforms.RandomHorizontalFlip(), # 随机翻转
transforms.ToTensor(), # 变成tensor
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
# 训练数据生成器
trainDataSet = TrainDataset(
face_dir="Datasets/vggface2_train_face",
csv_name='Datasets/vggface2_train_face.csv',
num_triplets=1000,
training_triplets_path="Datasets/training_triplets_1000.npy",
transform=train_data_transforms,
predicter_path='shape_predictor_68_face_landmarks.dat',
img_size=256)
train_dataloader = torch.utils.data.DataLoader(dataset=trainDataSet,
batch_size=30,
num_workers=1,
shuffle=False)
class Resnet18Triplet(nn.Module):
"""Constructs a ResNet-18 model for FaceNet training using triplet loss.
Args:
embedding_dimension (int): Required dimension of the resulting embedding layer that is outputted by the model.
# transforms.Resize([config['image_size'], config['image_size']]), # resize
#transforms.RandomHorizontalFlip(), # 随机翻转
transforms.ToTensor(), # 变成tensor
transforms.Normalize(
mean=[0.5, 0.5, 0.5],
std=[0.5, 0.5, 0.5]
)
])
# 训练数据生成器
train_dataloader = torch.utils.data.DataLoader(
dataset=TrainDataset(
face_dir="Datasets/vggface2_test_face_notmask",
csv_name='Datasets/vggface2_test_face_notmask.csv',
num_triplets=100000,
training_triplets_path='Datasets/vggface2_test_face_notmask_triplets.npy',
transform=train_data_transforms,
predicter_path='shape_predictor_68_face_landmarks.dat',
img_size=256
),
batch_size=128,
num_workers=0,
shuffle=True
)
class Resnet18Triplet(nn.Module):
"""Constructs a ResNet-18 model for FaceNet training using triplet loss.
Args:
embedding_dimension (int): Required dimension of the resulting embedding layer that is outputted by the model.
using triplet loss. Defaults to 128.
NUM_TRIPLETS = 10
MODEL_VERSION = '18'
# 训练数据的变换
train_data_transforms = transforms.Compose([
# transforms.Resize([config['image_size'], config['image_size']]), # resize
#transforms.RandomHorizontalFlip(), # 随机翻转
transforms.ToTensor(), # 变成tensor
transforms.Normalize(mean=[0.5, 0.5, 0.5], std=[0.5, 0.5, 0.5])
])
# 训练数据生成器
train_dataloader = torch.utils.data.DataLoader(dataset=TrainDataset(
face_dir="./Datasets/vggface2_train_face_mask",
csv_name='./Datasets/vggface2_train_face_mask.csv',
num_triplets=NUM_TRIPLETS,
training_triplets_path='./Datasets/training_triplets_1000_mask.npy',
transform=train_data_transforms,
predicter_path='shape_predictor_68_face_landmarks.dat',
img_size=256),
batch_size=BATCH_SIZE,
num_workers=0,
shuffle=False)
pwd = os.path.abspath('./')
start_epoch = 0
model = ResnetCBAMTriplet(model_version=MODEL_VERSION,
pretrained=False,
embedding_dimension=EMBEDDING_DIMENSION)
device = torch.device('cuda:0') if torch.cuda.is_available() else torch.device(
'cpu')
model = model.to(device)