def test_masking_noise(self):
""" test masking noise function.
"""
x_noise = utils.masking_noise(self.x, self.v)
for sample in x_noise:
self.assertEqual(sum([i == 0 for i in sample]), self.v)
def test_masking_noise(self):
""" test masking noise function.
"""
x_noise = utils.masking_noise(self.x, self.v)
for sample in x_noise:
self.assertEqual(sum([i == 0 for i in sample]), self.v)
def corrupt_input(self, data, v):
if self.corruption_type == 'masking':
x_corrupted = utils.masking_noise(data, v)
elif self.corruption_type == 'salt_and_pepper':
x_corrupted = utils.salt_and_pepper_noise(data, v)
elif self.corruption_type == 'gaussian':
x_corrupted = utils.gaussian_noise(data, v)
elif self.corruption_type == 'none':
x_corrupted = data
else:
x_corrupted = None
return x_corrupted
def _corrupt_input(self, data, v): ''' Corrupt a fraction 'v' of 'data' according to the noise method of this autoencoder. Returns ------- corrupted data ''' if self.corr_type == 'none': return np.copy(data) if v > 0.0: if self.corr_type == 'masking': return utils.masking_noise(data, v) elif self.corr_type == 'salt_and_pepper': return utils.salt_and_pepper_noise(data, v) else: return np.copy(data)
def _corrupt_input(self, data, v):
""" Corrupt a fraction 'v' of 'data' according to the
noise method of this autoencoder.
:return: corrupted data
"""
if self.corr_type == 'masking':
x_corrupted = utils.masking_noise(data, v)
elif self.corr_type == 'salt_and_pepper':
x_corrupted = utils.salt_and_pepper_noise(data, v)
elif self.corr_type == 'none':
x_corrupted = data
else:
x_corrupted = None
return x_corrupted
def fit(self,
trainloader,
validloader,
device,
lr=0.001,
batch_size=128,
num_epochs=10,
corrupt=0.3,
loss_type="mse"):
"""
data_x: FloatTensor
valid_x: FloatTensor
"""
self.to(device)
print("=====Denoising Autoencoding layer=======")
optimizer = optim.SGD(filter(lambda p: p.requires_grad,
self.parameters()),
lr=lr)
if loss_type == "mse":
criterion = nn.MSELoss()
elif loss_type == "cross-entropy":
criterion = nn.BCELoss()
# validate
total_loss = 0.0
total_num = 0
for batch_idx, (inputs, _) in enumerate(validloader):
inputs = inputs.float().to(device)
inputs = Variable(inputs)
hidden = self.encode(inputs, train=False)
if loss_type == "cross-entropy":
outputs = self.decode(hidden, binary=True)
else:
outputs = self.decode(hidden)
valid_recon_loss = criterion(outputs, inputs)
total_loss += valid_recon_loss.item() * len(inputs)
total_num += inputs.size()[0]
valid_loss = total_loss / total_num
print("#Epoch 0: Valid Reconstruct Loss: %.3f" % (valid_loss))
for epoch in range(num_epochs):
# train 1 epoch
train_loss = 0.0
for batch_idx, (inputs, _) in enumerate(trainloader):
inputs = inputs.float().to(device)
inputs_corr = masking_noise(inputs, corrupt).to(device)
optimizer.zero_grad()
inputs = Variable(inputs)
inputs_corr = Variable(inputs_corr)
hidden = self.encode(inputs_corr)
if loss_type == "cross-entropy":
outputs = self.decode(hidden, binary=True)
else:
outputs = self.decode(hidden)
recon_loss = criterion(outputs, inputs)
train_loss += recon_loss.item() * len(inputs)
recon_loss.backward()
optimizer.step()
# validate
valid_loss = 0.0
for batch_idx, (inputs, _) in enumerate(validloader):
inputs = inputs.float().to(device)
inputs = Variable(inputs)
hidden = self.encode(inputs, train=False)
if loss_type == "cross-entropy":
outputs = self.decode(hidden, binary=True)
else:
outputs = self.decode(hidden)
valid_recon_loss = criterion(outputs, inputs)
valid_loss += valid_recon_loss.item() * len(inputs)
print(
"#Epoch %3d: Reconstruct Loss: %.3f, Valid Reconstruct Loss: %.3f"
% (epoch + 1, train_loss / len(trainloader.dataset),
valid_loss / len(validloader.dataset)))
def fit(self, trX, vlX=None, restore_previous_model=False):
""" Fit the model to the data.
:type trX: array_like, shape (n_samples, n_features).
:param trX: Training data.
:type vlX: array_like, shape (n_validation_samples, n_features).
:param vlX: optional, default None. Validation data.
:return: self
"""
n_features = trX.shape[1]
self._create_graph(n_features)
# Merge all the summaries
merged = tf.merge_all_summaries()
# Initialize variables
init_op = tf.initialize_all_variables()
# Add ops to save and restore all the variables
self.saver = tf.train.Saver()
with tf.Session() as self.sess:
self.sess.run(init_op)
if restore_previous_model:
# Restore previous model
self.saver.restore(self.sess,
self.models_dir + self.model_name)
# Change model name
self.model_name += '-restored{}'.format(self.n_iter)
# ################## #
# Training phase #
# ################## #
v = np.round(self.corr_frac * n_features).astype(np.int)
# Write the summaries to summary_dir
writer = tf.train.SummaryWriter(self.summary_dir,
self.sess.graph_def)
for i in range(self.n_iter):
# #################### #
# Input Corruption #
# #################### #
if self.corr_type == 'masking':
x_corrupted = utils.masking_noise(trX, v)
elif self.corr_type == 'salt_and_pepper':
x_corrupted = utils.salt_and_pepper_noise(trX, v)
else: # none, normal autoencoder
x_corrupted = trX
# Randomly shuffle the input
shuff = zip(trX, x_corrupted)
np.random.shuffle(shuff)
# # Divide dataset into mini-batches
batches = [
_ for _ in utils.gen_batches(shuff, self.batch_size)
]
# All the batches for each epoch
for batch in batches:
x_batch, x_corr_batch = zip(*batch)
tr_feed = {
self.x: x_batch,
self.x_corr: x_corr_batch,
self.keep_prob: self.dropout
}
self.sess.run(self.train_step, feed_dict=tr_feed)
# Record summary data
if vlX is not None:
vl_feed = {
self.x: vlX,
self.x_corr: vlX,
self.keep_prob: 1.
}
result = self.sess.run([merged, self.cost],
feed_dict=vl_feed)
summary_str = result[0]
err = result[1]
writer.add_summary(summary_str, i)
if self.verbose == 1:
print("Validation cost at step %s: %s" % (i, err))
# Save trained model
self.saver.save(self.sess, self.models_dir + self.model_name)
# model = autoencoder().cuda()
model = autoencoder()
criterion = nn.MSELoss()
optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate,
weight_decay=1e-5)
if False:
losses = []
for epoch in range(num_epochs):
# for data in dataloader:
for i, data in enumerate(dataloader, 1):
img, _ = data # torch.Size([128, 1, 28, 28])
# img = Variable(img).cuda()
# img = Variable(img)
inputs_corr = masking_noise(img, corrupt)
# ===================forward=====================
output = model(inputs_corr)
loss = criterion(output, img)
losses.append(loss)
# ===================backward====================
optimizer.zero_grad()
loss.backward()
optimizer.step()
# ===================log========================
print('epoch [{}/{}], loss:{:.4f}'
.format(epoch+1, num_epochs, loss.item()))
if epoch % 10 == 0:
# pic = to_img(output.cpu().data)
pic = to_img(output.data)
save_image(pic, './img/image_{}.png'.format(epoch))