def __init__(self, opt):
super(LSTHM, self).__init__()
self.input_dims = opt.input_dims
self.output_dim = opt.output_dim
if type(opt.hidden_dims) == int:
self.hidden_dims = [opt.hidden_dims]
else:
self.hidden_dims = [int(s) for s in opt.hidden_dims.split(',')]
if opt.embedding_enabled:
embedding_matrix = torch.tensor(opt.lookup_table,
dtype=torch.float)
self.embed = nn.Embedding.from_pretrained(embedding_matrix,
freeze=False)
self.num_modalities = len(self.input_dims)
self.device = opt.device
self.hybrid_in_size = opt.hybrid_in_size
self.hybrid_cell_size = opt.hybrid_cell_size
self.hybrid_dropout_rate = opt.hybrid_dropout_rate
self.output_cell_dim = opt.output_cell_dim
self.output_dropout_rate = opt.output_dropout_rate
self.lsthms = nn.ModuleList([LSTHMCell(hidden_dim, input_dim,self.hybrid_in_size, \
device = self.device) for hidden_dim, input_dim \
in zip(self.hidden_dims, self.input_dims)])
self.fc_hybrid = SimpleNet(sum(self.hidden_dims),
self.hybrid_cell_size,
self.hybrid_dropout_rate,
self.hybrid_in_size, nn.Softmax(dim=1))
self.fc_out = SimpleNet(
sum(self.hidden_dims) + self.hybrid_in_size, self.output_cell_dim,
self.output_dropout_rate, self.output_dim)
def __init__(self, opt):
super(QMultiTask, self).__init__()
self.device = opt.device
self.input_dims = opt.input_dims
self.total_input_dim = sum(self.input_dims)
self.embed_dim = opt.embed_dim
self.speaker_num = opt.speaker_num
self.dataset_name = opt.dataset_name
self.features = opt.features
# MELD data
# The one-hot vectors are not the global user ID
if self.dataset_name.lower() == 'meld':
self.speaker_num = 1
self.n_classes_emo = opt.output_dim_emo
self.n_classes_act = opt.output_dim_act
self.projections = nn.ModuleList(
[nn.Linear(dim, self.embed_dim) for dim in self.input_dims])
self.multiply = ComplexMultiply()
self.outer = QOuter()
self.norm = L2Norm(dim=-1)
self.mixture = QMixture(device=self.device)
self.output_cell_dim = opt.output_cell_dim
self.phase_embeddings = nn.ModuleList([
PositionEmbedding(
self.embed_dim, input_dim=self.speaker_num, device=self.device)
] * len(self.input_dims))
self.out_dropout_rate = opt.out_dropout_rate
self.measurement_emotion = QMeasurement(self.embed_dim)
self.measurement_act = QMeasurement(self.embed_dim)
self.fc_out_emo = SimpleNet(self.embed_dim,
self.output_cell_dim,
self.out_dropout_rate,
self.n_classes_emo,
output_activation=nn.Tanh())
self.fc_out_act = SimpleNet(self.embed_dim,
self.output_cell_dim,
self.out_dropout_rate,
self.n_classes_act,
output_activation=nn.Tanh())
self.num_layers = opt.num_layers
#self.rnn=nn.ModuleList([QRNNCell(self.embed_dim, device = self.device)]*self.num_layers)
self.RNNs = nn.ModuleList([
QRNN(self.embed_dim, self.device, self.num_layers)
for i in range(len(opt.features))
])
self.rnn_outer = QOuter()
self.action_qrnn = QRNN(self.embed_dim, self.device, self.num_layers)
def __init__(self, opt):
super(RMFN, self).__init__()
self.input_dims = opt.input_dims
self.output_dim = opt.output_dim
if type(opt.hidden_dims) == int:
self.hidden_dims = [opt.hidden_dims]
else:
self.hidden_dims = [int(s) for s in opt.hidden_dims.split(',')]
self.num_modalities = len(self.input_dims)
self.steps = opt.steps
self.device = opt.device
self.compression_cell_dim = opt.compression_cell_dim
self.compression_dropout_rate = opt.compression_dropout_rate
self.hlt_memory_init_cell_dim = opt.hlt_memory_init_cell_dim
self.hlt_memory_init_dropout_rate = opt.hlt_memory_init_dropout_rate
self.output_cell_dim = opt.output_cell_dim
self.output_dropout_rate = opt.output_dropout_rate
# initialize the LSTHM for each modality
self.compressed_dim = opt.compressed_dim
if opt.embedding_enabled:
embedding_matrix = torch.tensor(opt.lookup_table,
dtype=torch.float)
self.embed = nn.Embedding.from_pretrained(
embedding_matrix, freeze=not opt.embedding_trainable)
self.lsthms = nn.ModuleList([LSTHMCell(hidden_dim,input_dim,self.compressed_dim,self.device) \
for input_dim,hidden_dim in zip(self.input_dims,self.hidden_dims)])
self.hlt_memory_init_net = SimpleNet(sum(self.hidden_dims),
self.hlt_memory_init_cell_dim,
self.hlt_memory_init_dropout_rate,
sum(self.hidden_dims),
nn.Sigmoid())
self.compression_net = SimpleNet(self.steps * sum(self.hidden_dims),
self.compression_cell_dim,
self.compression_dropout_rate,
self.compressed_dim, nn.Sigmoid())
self.recurrent_fusion = RecurrentFusion(self.hidden_dims,
self.hlt_memory_init_net,
self.compression_net,
self.steps, self.device)
self.fc_out = SimpleNet(self.compressed_dim + sum(self.hidden_dims),
self.output_cell_dim, self.output_dropout_rate,
self.output_dim)
def __init__(self, opt):
super(QAttN, self).__init__()
self.device = opt.device
self.input_dims = opt.input_dims
self.total_input_dim = sum(self.input_dims)
self.embed_dim = opt.embed_dim
self.speaker_num = opt.speaker_num
self.n_classes = opt.output_dim
self.output_cell_dim = opt.output_cell_dim
self.dataset_name = opt.dataset_name
self.projections = nn.ModuleList(
[nn.Linear(dim, self.embed_dim) for dim in self.input_dims])
if self.dataset_name.lower() == 'meld':
self.speaker_num = 1
self.multiply = ComplexMultiply()
self.outer = QOuter()
self.norm = L2Norm(dim=-1)
self.mixture = QMixture(device=self.device)
self.phase_embeddings = nn.ModuleList([
PositionEmbedding(self.embed_dim, input_dim=1, device=self.device)
] * len(self.input_dims))
self.out_dropout_rate = opt.out_dropout_rate
self.attention = QAttention()
self.num_modalities = len(self.input_dims)
#self.out_dropout = QDropout(p=self.out_dropout_rate)
#self.dense = QDense(self.embed_dim, self.n_classes)
self.measurement_type = opt.measurement_type
if opt.measurement_type == 'quantum':
self.measurement = QMeasurement(self.embed_dim)
self.fc_out = SimpleNet(self.embed_dim * self.num_modalities,
self.output_cell_dim,
self.out_dropout_rate,
self.n_classes,
output_activation=nn.Tanh())
else:
self.measurement = ComplexMeasurement(self.embed_dim *
self.num_modalities,
units=20)
self.fc_out = SimpleNet(20,
self.output_cell_dim,
self.out_dropout_rate,
self.n_classes,
output_activation=nn.Tanh())
def __init__(self, opt):
super(QMPN, self).__init__()
self.device = opt.device
self.input_dims = opt.input_dims
self.total_input_dim = sum(self.input_dims)
if type(opt.embed_dims) == int:
self.embed_dims = [opt.embed_dims]
self.embed_dims = [int(s) for s in opt.embed_dims.split(',')]
self.speaker_num = opt.speaker_num
self.dataset_name = opt.dataset_name
# MELD data
# The one-hot vectors are not the global user ID
if self.dataset_name.lower() == 'meld':
self.speaker_num = 1
self.n_classes = opt.output_dim
self.projections = nn.ModuleList([
nn.Linear(dim, embed_dim)
for dim, embed_dim in zip(self.input_dims, self.embed_dims)
])
self.multiply = ComplexMultiply()
self.outer = QOuter()
self.norm = L2Norm(dim=-1)
self.mixture = QMixture(device=self.device)
self.output_cell_dim = opt.output_cell_dim
self.phase_embeddings = nn.ModuleList([
PositionEmbedding(embed_dim,
input_dim=self.speaker_num,
device=self.device)
for embed_dim in self.embed_dims
])
self.out_dropout_rate = opt.out_dropout_rate
self.num_layers = opt.num_layers
self.state_product = QProduct()
self.recurrent_dim = 1
for embed_dim in self.embed_dims:
self.recurrent_dim = self.recurrent_dim * embed_dim
self.recurrent_cells = nn.ModuleList(
[QRNNCell(self.recurrent_dim, device=self.device)] *
self.num_layers)
self.out_dropout = QDropout(p=self.out_dropout_rate)
self.activation = QActivation(scale_factor=1, beta=0.8)
self.measurement = QMeasurement(self.recurrent_dim)
self.fc_out = SimpleNet(self.recurrent_dim,
self.output_cell_dim,
self.out_dropout_rate,
self.n_classes,
output_activation=nn.Tanh())
def train_models(trainX, testX, trainY, testY):
print("[INFO] initialize models")
models = []
models.append(SimpleNet(width, height, depth, classes))
models.append(LeNet5(width, height, depth, classes))
print("[INFO] the number of models :", len(models))
Hs = []
# 遍历模型训练个数
for i in np.arange(0, len(models)):
# 初始化优化器和模型
print("[INFO] training model {}/{}".format(i + 1, len(models)))
# opt = Adam(lr=lr, decay=1e-4 / epochs)
# opt = SGD(lr=0.001,decay=0.01/ 40,momentum=0.9,
# nesterov=True)
# 训练网络
H = models[i].fit_generator(aug.flow(trainX, trainY, batch_size=bs),
validation_data=(testX, testY),
epochs=epochs,
steps_per_epoch=len(trainX) // bs,
verbose=1)
# 将模型保存到磁盘中
p = ['save_models', "model_{}.model".format(i)]
models[i].save(os.path.sep.join(p))
Hs.append(models[i])
# plot the training loss and accuracy
N = epochs
p = ['model_{}.png'.format(i)]
plt.style.use('ggplot')
plt.figure()
plt.plot(np.arange(0, N), H.history['loss'], label='train_loss')
plt.plot(np.arange(0, N), H.history['val_loss'], label='val_loss')
plt.plot(np.arange(0, N), H.history['acc'], label='train-acc')
plt.plot(np.arange(0, N), H.history['val_acc'], label='val-acc')
plt.title("Training Loss and Accuracy for model {}".format(i))
plt.xlabel("Epoch #")
plt.ylabel("Loss/Accuracy")
plt.legend()
plt.savefig(os.path.sep.join(p))
plt.close()
def __init__(self, opt):
super(EFLSTM, self).__init__()
self.device = opt.device
self.input_dims = opt.input_dims
self.total_input_dim = sum(self.input_dims)
self.hidden_dim = opt.hidden_dim
if opt.embedding_enabled:
embedding_matrix = torch.tensor(opt.lookup_table,
dtype=torch.float)
self.embed = nn.Embedding.from_pretrained(
embedding_matrix, freeze=not opt.embedding_trainable)
if self.hidden_dim == -1:
self.hidden_dim = self.total_input_dim
self.output_dim = opt.output_dim
self.output_cell_dim = opt.output_cell_dim
self.output_dropout_rate = opt.output_dropout_rate
self.lstm = nn.LSTMCell(self.total_input_dim, self.hidden_dim)
self.fc_out = SimpleNet(self.hidden_dim, self.output_cell_dim,
self.output_dropout_rate, self.output_dim)
def __init__(self, opt): #, n_layers, bidirectional, dropout):
super(LFLSTM, self).__init__()
self.device = opt.device
self.input_dims = opt.input_dims
if type(opt.hidden_dims) == int:
self.hidden_dims = [opt.hidden_dims]
else:
self.hidden_dims = [int(s) for s in opt.hidden_dims.split(',')]
if opt.embedding_enabled:
embedding_matrix = torch.tensor(opt.lookup_table, dtype=torch.float)
self.embed = nn.Embedding.from_pretrained(embedding_matrix, freeze=False)
self.num_modalities = len(self.input_dims)
self.output_dim = opt.output_dim
self.output_cell_dim = opt.output_cell_dim
self.output_dropout_rate = opt.output_dropout_rate
self.lstms = nn.ModuleList([nn.LSTMCell(input_dim, hidden_dim) \
for input_dim, hidden_dim in \
zip(self.input_dims, self.hidden_dims)])
self.fc_out = SimpleNet(sum(self.hidden_dims),self.output_cell_dim,
self.output_dropout_rate,self.output_dim)
def __init__(self, opt):
super(MFN, self).__init__()
self.device = opt.device
self.input_dims = opt.input_dims
self.num_modalities = len(self.input_dims)
if type(opt.hidden_dims) == int:
self.hidden_dims = [opt.hidden_dims]
else:
self.hidden_dims = [int(s) for s in opt.hidden_dims.split(',')]
self.total_cell_dim = sum(self.hidden_dims)
self.memory_dim = opt.memory_dim
self.window_dim = opt.window_dim
self.output_dim = opt.output_dim
self.attn_in_dim = self.total_cell_dim * self.window_dim
self.gamma_in_dim = self.attn_in_dim + self.memory_dim
self.final_fc_in_dim = self.total_cell_dim + self.memory_dim
if type(opt.attn_cell_dims) == int:
self.attn_cell_dims = [opt.attn_cell_dims]
else:
self.attn_cell_dims = [
int(s) for s in opt.attn_cell_dims.split(',')
]
if type(opt.gamma_cell_dims) == int:
self.gamma_cell_dims = [opt.gamma_cell_dims]
else:
self.gamma_cell_dims = [
int(s) for s in opt.gamma_cell_dims.split(',')
]
self.output_cell_dim = opt.output_cell_dim
if type(opt.attn_dropout_rates) == float:
self.attn_dropout_rates = [opt.attn_dropout_rates]
else:
self.attn_dropout_rates = [
float(s) for s in opt.attn_dropout_rates.split(',')
]
if type(opt.gamma_dropout_rates) == float:
self.gamma_dropout_rates = [opt.gamma_dropout_rates]
else:
self.gamma_dropout_rates = [
float(s) for s in opt.gamma_dropout_rates.split(',')
]
self.out_dropout_rate = opt.out_dropout_rate
if opt.embedding_enabled:
embedding_matrix = torch.tensor(opt.lookup_table,
dtype=torch.float)
self.embed = nn.Embedding.from_pretrained(
embedding_matrix, freeze=not opt.embedding_trainable)
self.lstms = nn.ModuleList([nn.LSTMCell(input_dim, cell_dim) \
for input_dim, cell_dim in zip(self.input_dims, self.hidden_dims)])
self.fc_attn_1 = SimpleNet(self.attn_in_dim, self.attn_cell_dims[0],
self.attn_dropout_rates[0],
self.attn_in_dim, nn.Softmax(dim=1))
self.fc_attn_2 = SimpleNet(self.attn_in_dim, self.attn_cell_dims[1],
self.attn_dropout_rates[1], self.memory_dim,
nn.Tanh())
self.fc_gamma = nn.ModuleList([
SimpleNet(self.gamma_in_dim, cell_dim, dropout, self.memory_dim,
nn.Sigmoid()) for cell_dim, dropout in zip(
self.gamma_cell_dims, self.gamma_dropout_rates)
])
self.fc_out = SimpleNet(self.final_fc_in_dim, self.output_cell_dim,
self.out_dropout_rate, self.output_dim)
def main(params, config):
data_pedestal = PedestalDataset(config)
train_loader, validation_loader = split_dataset(data_pedestal,
params['batch_size'])
if config['experiment']['load_model'] != None:
PATH = config['experiment']['load_model']
checkpoint = torch.load(PATH)
# Load Model
net = SimpleNet(params, config)
net.load_state_dict(checkpoint['model_state_dict'])
# Load Optimizer
optimizer = model_utils.map_optimizer(params['optimizer'],
net.parameters(), 0.0)
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
# Assign Loss Function
loss_func = model_utils.map_loss_func(params['loss'])
# Set EPOCH and LOSS for retraining
epoch = checkpoint['epoch']
loss = checkpoint['loss']
else:
net = SimpleNet(params, config)
optimizer = model_utils.map_optimizer(params['optimizer'],
net.parameters(),
params['learning_rate'])
loss_func = model_utils.map_loss_func(params['loss'])
epochs = config['epochs']
last_results = []
metrics = {}
for epoch in range(epochs):
# TRAINING
net.train()
for i, batch in enumerate(train_loader):
optimizer.zero_grad()
inputs, targets = batch['input'], batch['target']
output = net(inputs)
loss = loss_func(output, targets)
loss.backward()
optimizer.step()
# Validation
if epoch % 5 == 4:
net.eval()
max_error = 0.0
for i, batch in enumerate(validation_loader):
inputs, targets = batch['input'], batch['target']
output = net(inputs)
MSE = torch.sum((output - targets)**
2) / (len(output) * params['batch_size'])
max_error = max(MSE, max_error)
score = -math.log10(max_error)
# print(epoch, score)
if epoch > epochs - 5:
last_results.append(score)
final_score = min(last_results)
metrics['default'] = final_score
if config['experiment']['save_model'] is not None:
PATH = config['experiment']['save_model']
# save mode
torch.save(
{
'epoch': epoch,
'model_state_dict': net.state_dict(),
'optimizer_state_dict': optimizer.state_dict(),
'loss': loss
}, PATH)
def __init__(self, opt):
super(QMNAblation, self).__init__()
self.device = opt.device
self.input_dims = opt.input_dims
self.total_input_dim = sum(self.input_dims)
self.embed_dim = opt.embed_dim
self.speaker_num = opt.speaker_num
self.dataset_name = opt.dataset_name
# MELD data
if self.dataset_name.lower() == 'meld':
self.speaker_num = 1
self.n_classes = opt.output_dim
self.input_concat = opt.input_concat
self.zero_phase = opt.zero_phase
self.measurement_type = opt.measurement_type
self.classical_recurrent = opt.classical_recurrent
self.quantum_recurrent = opt.quantum_recurrent
if self.input_concat:
self.projections = nn.ModuleList(
[nn.Linear(self.total_input_dim, self.embed_dim)])
elif self.classical_recurrent:
self.projections = nn.ModuleList(
[nn.GRU(dim, self.embed_dim, 1) for dim in self.input_dims])
else:
self.projections = nn.ModuleList(
[nn.Linear(dim, self.embed_dim) for dim in self.input_dims])
self.multiply = ComplexMultiply()
self.outer = QOuter()
self.norm = L2Norm(dim=-1)
self.mixture = QMixture(device=self.device)
self.output_cell_dim = opt.output_cell_dim
self.phase_embeddings = nn.ModuleList([PositionEmbedding(self.embed_dim, input_dim = self.speaker_num,\
zero_phase = self.zero_phase, device = self.device)]*len(self.input_dims))
self.out_dropout_rate = opt.out_dropout_rate
self.num_layers = opt.num_layers
self.recurrent_cells = nn.ModuleList(
[QRNNCell(self.embed_dim, device=self.device)] * self.num_layers)
self.out_dropout = QDropout(p=self.out_dropout_rate)
self.activation = QActivation(scale_factor=1, beta=0.8)
self.measurement_type = opt.measurement_type
if self.measurement_type == 'quantum':
self.measurement = QMeasurement(self.embed_dim)
self.fc_out = SimpleNet(self.embed_dim,
self.output_cell_dim,
self.out_dropout_rate,
self.n_classes,
output_activation=nn.Tanh())
elif self.measurement_type == 'flatten':
self.fc_out = SimpleNet(self.embed_dim,
self.output_cell_dim,
self.out_dropout_rate,
self.n_classes,
output_activation=nn.Tanh())
else:
self.measurement = ComplexMeasurement(self.embed_dim,
units=self.embed_dim)
self.fc_out = SimpleNet(self.embed_dim,
self.output_cell_dim,
self.out_dropout_rate,
self.n_classes,
output_activation=nn.Tanh())
def __init__(self, opt):
super(MARN, self).__init__()
self.input_dims = opt.input_dims
self.output_dim = opt.output_dim
if type(opt.hidden_dims) == int:
self.hidden_dims = [opt.hidden_dims]
else:
self.hidden_dims = [int(s) for s in opt.hidden_dims.split(',')]
self.device = opt.device
self.attn_num = opt.attn_num
self.attn_cell_dim = opt.attn_cell_dim
self.attn_dropout_rate = opt.attn_dropout_rate
if opt.embedding_enabled:
embedding_matrix = torch.tensor(opt.lookup_table,
dtype=torch.float)
self.embed = nn.Embedding.from_pretrained(
embedding_matrix, freeze=not opt.embedding_trainable)
if type(opt.compression_cell_dims) == int:
self.compression_cell_dims = [opt.compression_cell_dims]
else:
self.compression_cell_dims = [
int(s) for s in opt.compression_cell_dims.split(',')
]
if type(opt.compression_dropout_rates) == float:
self.compression_dropout_rates = [opt.compression_dropout_rates]
else:
self.compression_dropout_rates = [
float(s) for s in opt.compression_dropout_rates.split(',')
]
self.total_hidden_dim = sum(self.hidden_dims)
self.output_cell_dim = opt.output_cell_dim
self.output_dropout_rate = opt.output_dropout_rate
# self.batch_size = opt.batch_size
# initialize the LSTHM for each modalitye
if type(opt.compressed_dims) == int:
self.compressed_dims = [opt.compressed_dims]
else:
self.compressed_dims = [
int(s) for s in opt.compressed_dims.split(',')
]
self.num_modalities = len(self.input_dims)
self.lsthms = nn.ModuleList([LSTHMCell(hidden_dim,input_dim,sum(self.compressed_dims),self.device) \
for input_dim,hidden_dim in zip(self.input_dims,self.hidden_dims)])
attention = SimpleNet(self.total_hidden_dim,
self.attn_cell_dim * self.attn_num,
self.attn_dropout_rate,
self.total_hidden_dim * self.attn_num,
nn.Sigmoid())
compression_nets = nn.ModuleList([
SimpleNet(hidden_dim * self.attn_num, compression_cell_dim,
compression_dropout_rate, compressed_dim, nn.Sigmoid())
for compressed_dim, hidden_dim,
compression_cell_dim, compression_dropout_rate in zip(
self.compressed_dims, self.hidden_dims,
self.compression_cell_dims, self.compression_dropout_rates)
])
self.multi_attention = MultipleAttention(attention, compression_nets,
self.attn_num)
self.fc_output_in_dim = sum(
self.compressed_dims) + self.total_hidden_dim
self.fc_out = SimpleNet(self.fc_output_in_dim, self.output_cell_dim,
self.output_dropout_rate, self.output_dim)
def train_model(dataset,
model_output,
model_type,
training_ratio=0.7,
validation_ratio=0.1,
epoch=10,
batch_size=50,
learning_rate=0.01):
if dataset is None:
raise ValueError('No dataset specified')
hdf5_file = h5py.File(dataset, 'r')
train, validation, test, validation_data = data_split(
hdf5_file=hdf5_file,
training_ratio=training_ratio,
validation_ratio=validation_ratio)
train_start, train_end = train
validation_start, validation_end = validation
test_start, test_end = test
shape = input_shape(hdf5_file=hdf5_file)
height, width, channels = shape
if model_type in [
'AlexNet', 'alexnet', 'ALEXNET', 'Alex', 'alex', 'ALEX',
'alex_net', 'Alex_Net', 'ALEX_NET'
]:
model = AlexNet(learning_rate=learning_rate,
width=width,
height=height,
channels=channels)
elif model_type in [
'NvidiaNet', 'nvidianet', 'NVIDIANET', 'Nvidia', 'nvidia',
'NVIDIA', 'nvidia_net', 'Nvidia_Net', 'NVIDIA_NET'
]:
model = NvidiaNet(learning_rate=learning_rate,
width=width,
height=height,
channels=channels)
elif model_type in ['VGG16', 'vgg16', 'Vgg16', 'VGG', 'Vgg', 'vgg']:
model = VGG16Net(learning_rate=learning_rate,
width=width,
height=height,
channels=channels)
elif model_type in [
'SimpleNet', 'simplenet', 'SIMPLENET', 'Simplenet', 'simple',
'SIMPLE'
]:
model = SimpleNet(learning_rate=learning_rate,
width=width,
height=height,
channels=channels)
else:
raise ValueError('Not a valid model type')
sys.exit(0)
train_start_time = datetime.datetime.now().strftime("%Y-%m-%d-%H-%M-%S")
if model_output:
model_output_path, _ = os.path.splitext(model_output)
model_filename = model_output_path + '-' + train_start_time
else:
dataset_path, _ = os.path.splitext(dataset)
dataset_filename = dataset_path[dataset_path.find('/') + 1:]
model_filename = 'models/' + dataset_filename + '-' + train_start_time
loss_checkpoint = ModelCheckpoint(model_filename + '-val-loss-lowest.h5',
monitor='val_loss',
verbose=1,
save_best_only=True,
mode='min')
accuracy_checkpoint = ModelCheckpoint(model_filename +
'-val-acc-highest.h5',
monitor='val_acc',
verbose=1,
save_best_only=True,
mode='max')
early_stopping = EarlyStopping(monitor='val_loss',
patience=6,
verbose=1,
mode='min')
reduce_learning_rate = ReduceLROnPlateau(monitor='val_loss',
factor=0.1,
patience=5)
callbacks = [loss_checkpoint, accuracy_checkpoint]
if validation_data:
train_gen = generate_examples(hdf5_file=hdf5_file,
batch_size=batch_size,
start=train_start,
end=train_end)
validation_gen = generate_examples(hdf5_file=hdf5_file,
batch_size=batch_size,
start=validation_start,
end=validation_end)
model.fit_generator(train_gen,
samples_per_epoch=train_end - train_start,
validation_data=validation_gen,
nb_val_samples=validation_end - validation_start,
nb_epoch=epoch,
verbose=1,
callbacks=callbacks)
else:
train_gen = generate_examples(hdf5_file=hdf5_file,
batch_size=batch_size,
start=train_start,
end=train_end)
model.fit_generator(train_gen,
samples_per_epoch=train_end - train_start,
nb_epoch=epoch,
verbose=1,
callbacks=callbacks)
model.save(model_filename + '.h5')
# Just to be safe
model.save('tmp.h5')
return model
def main(params, config):
dataset = PedestalDataset(config)
train_loader, validation_loader = split_dataset(dataset,
params['batch_size'])
if config['experiment']['load_model'] != None:
PATH = config['experiment']['load_model']
checkpoint = torch.load(PATH)
# Load Model
net = SimpleNet(params, config)
net.load_state_dict(checkpoint['model_state_dict'])
# Load Optimizer
optimizer = model_utils.map_optimizer(params['optimizer'],
net.parameters(), 0.0)
optimizer.load_state_dict(checkpoint['optimizer_state_dict'])
# Assign Loss Function
loss_func = model_utils.map_loss_func(params['loss'])
# Set EPOCH and LOSS for retraining
epoch = checkpoint['epoch']
loss = checkpoint['loss']
else:
net = SimpleNet(params, config)
optimizer = model_utils.map_optimizer(params['optimizer'],
net.parameters(),
params['learning_rate'])
loss_func = model_utils.map_loss_func(params['loss'])
metrics = {}
target_norms = dataset.targets_norms
input_norms = dataset.inputs_norms
target_list = dataset.target_params
input_list = dataset.input_params
net.eval()
outputs = []
actual_array = []
scaled_list = []
save_path = config['experiment']['name']
for i, batch in enumerate(validation_loader):
inputs, targets = batch['input'], batch['target']
for val in inputs:
output = net(val).detach().numpy()
output = denormalize(output, target_list, target_norms)
outputs.append(output[0])
normed_vals = denormalize(val.numpy(), input_list, input_norms)
for tar in targets:
denorm_targ = denormalize(tar.numpy(), target_list, target_norms)
actual_array.append(denorm_targ[0])
if config['experiment']['target'] == 'density':
for i, batch in enumerate(validation_loader):
inputs, targets = batch['input'], batch['target']
for val in inputs:
normed_vals = denormalize(val.numpy(), input_list, input_norms)
scaled_vals = fitted_scale(normed_vals)
scaled_list.append(scaled_vals)
plt.scatter(actual_array, scaled_list, label='Scale Law')
plt.scatter(actual_array, actual_array, label='Actual')
plt.scatter(actual_array, outputs, label='NN')
plt.legend()
plt.ylabel('Predicted')
plt.xlabel('Actual Density Height')
plt.ylim(0, 12)
plt.title('Neural Network vs Scaling Law')
plt.savefig('./results/' + save_path)
plt.show()