def FeedForward_UnitTest():
featureSize = 12
colorChannels = 1
# Load Centroids and Initialize KMean module
centroids = datamanipulation.LoadCentroids("C:/Images/TempCentroids_" +
str(colorChannels) + ".txt")
KMean = kmean.KMean(featureSize * featureSize * colorChannels,
len(centroids))
# Load image and slice it
image_a = datamanipulation.LoadImageData(["C:/Images/Satellite_1.png"],
colorChannels)
image_b = datamanipulation.LoadImageData(["C:/Images/Satellite_1_LQ.png"],
colorChannels)
compare_1 = datamanipulation.CompareImages(image_a, image_a)
compare_2 = datamanipulation.CompareImages(image_a, image_b)
data = datamanipulation.SliceImage(image_b, featureSize * colorChannels,
featureSize)
loadedPoints = len(data)
# Classify points
data = KMean.KmeanClassification(data, centroids)
# Sort points by centroid
classifiedPoints = 0
for centroid in range(0, len(centroids)):
points = [x for x in data if x[-3] == centroid]
classifiedPoints = classifiedPoints + len(points)
encoder = autoencoder.AutoEncoder([
featureSize * featureSize * colorChannels, 100,
featureSize * featureSize * colorChannels
])
if (encoder.LoadParameters("C:/Images/EncoderParameters_" +
str(colorChannels) + "_" + str(centroid) +
".txt")):
print("feeding points into encoder")
for point in points:
output = encoder.FeedForward(
np.array(point[:-3]).reshape(144, 1))
image_b = datamanipulation.InsertSubImage(
image_b,
output.flatten(),
featureSize,
colorChannels,
point[-2],
point[-1],
referenceImage=image_a)
else:
print("unable to load encoder")
# return False
compare_3 = datamanipulation.CompareImages(image_a, image_b)
print("Compare 1: " + str(compare_1))
print("Compare 2: " + str(compare_2))
print("Compare 3: " + str(compare_3))
if (loadedPoints == classifiedPoints):
return True
return False
def autoEncode(sizes, input, autoencoder_eta=0.000001):
''' Pretraining using stacked autoencoders '''
ae_wb_list = []
for i in range(len(sizes) - 1):
inpLayer = sizes[i]
hidLayer = sizes[i + 1]
print "Running stack", i + 1, "of autoencoding"
costs = []
cost = 0
ae = autoencoder.AutoEncoder(inpLayer,
hidLayer) #Create autoencoder object
if i == 0:
for ep in range(400): #400 Epochs
cost = ae.train(input,
eta=autoencoder_eta) #Train the autoencoder
print "Epoch", ep, "Cost :", cost
costs.append(cost)
#Pass the output of the hidden layer of current stack as input to the next stack
input = ae.getHiddenLayerOutput(input)
else:
for ep in range(400):
cost = ae.train(input, eta=autoencoder_eta)
print "Epoch", ep, "Cost :", cost
costs.append(cost)
if (i != len(sizes) - 2):
input = ae.getHiddenLayerOutput(input)
#Get weights and bias learnt by the autoencoder
for wb in ae.getWeightsAndBias():
ae_wb_list.append(wb)
return ae_wb_list
def AutoEncoderOutput_UnitTest():
print("AutoEncoder Output UnitTest")
inputSize = 144
encoder = autoencoder.AutoEncoder([inputSize, 100, inputSize])
input = np.random.rand(inputSize, 1)
output = encoder.FeedForward(input)
if (output.shape[0] == inputSize):
return True
return False
def SaveLoadAutoEncoderParameters_UnitTest():
print("AutoEncoder: Save and Load Parameters Unit Test")
encoder = autoencoder.AutoEncoder([435, 100, 435])
initialParameters = encoder.GetParameters()
encoder.SaveParameters("C:/Images/testParameters.txt")
encoder.LoadParameters("C:/Images/testParameters.txt")
finalParameters = encoder.GetParameters()
for a, b in zip(initialParameters, finalParameters):
for m, n in zip(a, b):
for p, q in zip(m, n):
if (p == q):
return False
return True
def trained_autoencoder(dataset, dropout_prob=0.1, path_to_pretrained=None):
'''
Returns a model with pretrained parameters
Arguments:
- dataset: either 'mnist' or 'cifar'
- dropout_prob: dropout probability
- path_to_pretrained: path to file where parameters are stored
'''
if path_to_pretrained is None:
path_to_pretrained = '{}_autoencoder_model'.format(dataset)
path_to_pretrained = 'models/{}'.format(path_to_pretrained)
model = autoencoder.AutoEncoder(dataset, dropout_prob)
model.load_state_dict(torch.load(path_to_pretrained)['state_dict'])
return model
def train_AE(X_train, X_test, encoder_size, decoder_size, epochs, lr):
model = autoencoder.AutoEncoder(encoder_size, decoder_size).to(device)
autoencoder.train(model,
dataset=X_train,
num_epochs=epochs,
batch_size=batch_size,
lr=lr)
# Calculate training error
AE_reconstruction = model(X_train)
training_error = np.mean(
((X_train - AE_reconstruction[0])**2).cpu().detach().numpy())
# Calculate test error
AE_reconstruction = model(X_test)
test_error = np.mean(
((X_test - AE_reconstruction[0])**2).cpu().detach().numpy())
return model, training_error, test_error
def autoEncode(sizes, input):
""" Pretraining using stacked autoencoders """
assert (input.shape[1] == sizes[0])
ae_eta = 0.0000001
n_epochs = 300
batch_size = 1000 # Batch size
# Minibatches for autoencoder training
n_batches = input.shape[0] / batch_size
ae_wb_list = [] # Weights and bias obtained from autoencoder
# Input for the next stack of the autoencoder (Output of previous hidden
# layer)
nextStackInput = []
for i in range(len(sizes) - 1):
inpLayer = sizes[i]
hidLayer = sizes[i + 1]
ae = autoencoder.AutoEncoder(inpLayer, hidLayer)
print("Running stack", i + 1, "of autoencoding")
if i == 0:
for ep in range(n_epochs):
cost_avg = []
for idx in range(n_batches):
x = input[idx * batch_size:(idx + 1) * batch_size]
cost_avg.append(ae.train(x, eta=ae_eta))
print("Epoch", ep, "Cost :", (sum(cost_avg) / len(cost_avg)))
''' Get output from the hidden layer to pass as input for the next stack '''
nextStackInput = ae.getHiddenLayerOutput(input)
else:
input = nextStackInput
for ep in range(n_epochs):
cost_avg = []
for idx in range(n_batches):
x = input[idx * batch_size:(idx + 1) * batch_size]
cost_avg.append(ae.train(x, eta=ae_eta))
print("Epoch", ep, "Cost :", (sum(cost_avg) / len(cost_avg)))
if (i != len(sizes) - 2):
nextLayerInput = ae.getHiddenLayerOutput(input)
""" Get the weights and bias learnt by the autoencoder """
for wb in ae.getWeightsAndBias():
ae_wb_list.append(wb)
return ae_wb_list
def autodec(data, gpu_id):
#print (data.shape)
scaler = StandardScaler()
X_std = scaler.fit_transform(data)
initiald = X_std.shape[1] # Feature Dimensions
targetd = 500 # TO-DO Change to Desired Output with sys.argv[*]
autoEncoder = autoenc.AutoEncoder(initiald,
targetd,
lr_=1,
momentum_=0.001,
decay_=0.0001,
nesterov_=False)
#lr_=0.5
autoEncoder.fit(X_std,
gpuid=gpu_id,
batch_size=100,
epochs=10,
verbose=1,
validation_split=0.2)
def __init__(self, n, w):
"""
This initializes a phrase embedding model which is based on a
recursive autoencoder (RAE). This model can be trained with
backpropagation and stochastic gradient descent
Parameters:
n : The dimensionality of the input
w : A word vector object that contains pre-trained word embeddings
"""
self.n = n
self.w = w
self.a = autoencoder.AutoEncoder(self.n)
#self.a.paramMatrix = np.array([[-0.66901207, -0.18282628, -0.05600838, -0.93896959],
#[-0.10363659, -0.53908909, 0.24603079, 0.50378757]])
#self.a.reconParamMatrix = np.array([[-0.22829916, 0.92183385],
#[-0.4777748, 0.47174915],
#[ 0.22207423, -0.22005313],
#[-0.53727245, -0.70092649]])
self.totalReconstructionError = 0
self.backPropTrainingData = []
self.finalLayerBackPropData = []
def main():
args = parse_program_arguments()
device = utils.best_device()
test_data = utils.load_mnist_digits(
root=args.data_folder,
training=False)
test_data_loader = torch.utils.data.DataLoader(
test_data,
batch_size=args.num_images,
shuffle=True)
# load the model
model = autoencoder.AutoEncoder(latent_size=16)
model.load_state_dict(torch.load(args.model))
model.to(device)
model.eval()
utils.plot(
model=model,
loader=test_data_loader,
device=device,
num_images=args.num_images)
batch_size = 128
lr = 0.002
optimizer_cls = optim.Adam
# Data loader
loader = utils.get_data('cifar',
_train=True,
_transforms=transforms.ToTensor(),
_batch_size=batch_size)
test_loader = utils.get_data('cifar',
_train=False,
_transforms=transforms.ToTensor(),
_batch_size=batch_size)
# Instantiate model
auto = autoencoder.AutoEncoder('cifar', 0.1)
loss_fn = nn.BCELoss()
optimizer = optimizer_cls(auto.parameters(), lr=lr)
num_batches = 150
# Training loop
for epoch in range(num_epochs):
print('Epoch: {}. Time elapsed: {:.1f} minutes'.format(
epoch, (time.time() - start) / 60.0))
batch_num = 0
auto.train()
for i, (orig, _) in enumerate(loader):
def main():
print("Image Sharpening with Machine Learning\n")
print("Sebastian Pendola, NY 2017\n\n")
print("1) Train KMean Clustering")
print("2) Train AutoEncoders")
print("3) Enhance Image")
print("4) Display Centroids")
print("5) Test on Image")
task = int(raw_input("\nChoose a Task: "))
if task == 1:
featureSize = int(raw_input("Feature Size: "))
colorChannels = int(raw_input("Color Channels: "))
numberOfCentroids = int(raw_input("Clusters: "))
epochs = int(raw_input("Epochs: "))
useLastCentroids = raw_input("Use last centroids? (y/n) ")
startTime = dt.datetime.now().replace(microsecond=0)
#images = ("images/Satellite_1.png", "images/Satellite_2.png", "images/Satellite_3.png", "images/Satellite_4.png", "images/Satellite_5.png")
images = ("images/image_1.png", "images/image_2.png",
"images/image_3.png", "images/image_4.png",
"images/image_5.png", "images/image_6.png",
"images/image_7.png", "images/image_8.png")
data = datamanipulation.SliceImage(
datamanipulation.LoadImageData(images),
featureSize * colorChannels, featureSize)
publisher.PublishMsg("KMean Clustering Started")
publisher.PublishMsg(
str(numberOfCentroids) + " clusters of size " + str(featureSize) +
"x" + str(featureSize))
publisher.PublishCmd("validationgraph")
publisher.PublishCmd("flushgraph")
KMean = kmean.KMean(featureSize * featureSize * colorChannels,
numberOfCentroids)
if (useLastCentroids == "y" or useLastCentroids == "Y"):
data, centroids = KMean.KMeanClustering(
data,
datamanipulation.LoadCentroids("images/TempCentroids_" +
str(colorChannels) + ".txt"),
limit=epochs)
else:
data, centroids = KMean.KMeanClustering(data, limit=epochs)
for centroid in range(0, len(centroids)):
points = [x for x in data if x[-3] == centroid]
print("Cluster " + str(centroid) + " has " + str(len(points)) +
" points")
print("Execution Time: " +
str(dt.datetime.now().replace(microsecond=0) - startTime))
datamanipulation.SaveCentroids(
centroids, "images/TempCentroids_" + str(colorChannels) + ".txt")
elif task == 2:
learningRate = float(raw_input("Learning Rate: "))
lmbda = float(raw_input("Lambda: "))
epochs = int(raw_input("Epochs: "))
featureSize = int(raw_input("Feature Size: "))
colorChannels = int(raw_input("Color Channels: "))
# Load Centroids and Initialize KMean module
centroids = datamanipulation.LoadCentroids("images/TempCentroids_" +
str(colorChannels) + ".txt")
KMean = kmean.KMean(featureSize * featureSize * colorChannels,
len(centroids))
# Load points and classify them
#images = ("images/Satellite_1.png", "images/Satellite_2.png", "images/Satellite_3.png", "images/Satellite_4.png", "images/Satellite_5.png")
images = ("images/image_1.png", "images/image_2.png",
"images/image_3.png", "images/image_4.png",
"images/image_5.png", "images/image_6.png",
"images/image_7.png", "images/image_8.png")
data = datamanipulation.SliceImage(
datamanipulation.LoadImageData(images),
featureSize * colorChannels, featureSize)
data = KMean.KmeanClassification(data, centroids)
trainingCosts = []
for centroid in range(0, len(centroids)):
encoder = autoencoder.AutoEncoder([
featureSize * featureSize * colorChannels, 100,
featureSize * featureSize * colorChannels
])
encoder.LoadParameters("images/EncoderParameters_" +
str(colorChannels) + "_" + str(centroid) +
".txt")
trainingSet = datamanipulation.CreateTrainingSetFromData(
data, centroids, centroid, threshold=False)
if (len(trainingSet) > 0):
print("Training Samples of size " + str(len(trainingSet[0])))
savePath = "images/EncoderParameters_" + str(
colorChannels) + "_" + str(centroid) + ".txt"
trainingCosts.append(
encoder.Train(
trainingSet,
learningRate,
lmbda,
epochs,
len(trainingSet) if len(trainingSet) < 20 else 20,
path=savePath))
else:
print("Training Set " + str(index) + " is empty")
trainingCosts.append(-1)
for index in range(0, len(centroids)):
print("AutoEncoder for Feature " + str(index) +
" has a learning cost of " + str(trainingCosts[index]))
elif task == 3:
featureSize = int(raw_input("Feature Size: "))
colorChannels = int(raw_input("Color Channels: "))
# Load Centroids and Initialize KMean module
centroids = datamanipulation.LoadCentroids("images/TempCentroids_" +
str(colorChannels) + ".txt")
KMean = kmean.KMean(featureSize * featureSize * colorChannels,
len(centroids))
# Load reference and target images
image_a = datamanipulation.LoadImageData(["images/Satellite_1.png"],
colorChannels)
image_b = datamanipulation.LoadImageData(["images/Satellite_1_LQ.png"],
colorChannels)
compare_1 = datamanipulation.CompareImages(image_a, image_b)
# Slice reference image and classify slices
data = datamanipulation.SliceImage(image_b,
featureSize * colorChannels,
featureSize)
data = KMean.KmeanClassification(data, centroids)
for centroid in range(0, len(centroids)):
points = [x for x in data if x[-3] == centroid]
if (len(points) > 0):
encoder = autoencoder.AutoEncoder([
featureSize * featureSize * colorChannels, 100,
featureSize * featureSize * colorChannels
])
if (encoder.LoadParameters("images/EncoderParameters_" +
str(colorChannels) + "_" +
str(centroid) + ".txt")):
for point in points:
input = np.array(point[:-3]).reshape(144, 1)
output = encoder.FeedForward(input / 256.0) * 256.0
image_b = datamanipulation.InsertSubImage(
image_b,
output.flatten(),
featureSize,
colorChannels,
point[-2],
point[-1],
reference=image_a)
else:
print("unable to load encoder")
compare_2 = datamanipulation.CompareImages(image_a, image_b)
print("Initial Comparation: " + str(compare_1))
print("Final Comparation: " + str(compare_2))
elif task == 4:
centroids = datamanipulation.LoadCentroids("images/TempCentroids.txt")
datamanipulation.DisplayCentroids(centroids)
elif task == 5:
featureSize = int(raw_input("Feature Size: "))
colorChannels = int(raw_input("Color Channels: "))
centroids = datamanipulation.LoadCentroids("images/TempCentroids_" +
str(colorChannels) + ".txt")
datamanipulation.MarkImage("images/Satellite_2.png", centroids,
featureSize, colorChannels)
def train():
with tf.Graph().as_default():
with tf.device('/gpu:' + str(0)):
ae = autoencoder.AutoEncoder(paras=para_config)
print_trainable_vars()
reconstr_loss, reconstr, _ = ae.model()
optimizer = ae.make_optimizer(reconstr_loss)
# metrics for tensorboard visualization
with tf.name_scope('metrics'):
reconstr_loss_mean, reconstr_loss_mean_update = tf.metrics.mean(
reconstr_loss)
reset_metrics = tf.variables_initializer([
var for var in tf.local_variables()
if var.name.split('/')[0] == 'metrics'
])
tf.summary.scalar('loss/train',
reconstr_loss_mean,
collections=['train'])
tf.summary.scalar('loss/test',
reconstr_loss_mean,
collections=['test'])
summary_op = tf.summary.merge_all('train')
summary_test_op = tf.summary.merge_all('test')
train_writer = tf.summary.FileWriter(
os.path.join(LOG_DIR, 'summary', 'train'))
test_writer = tf.summary.FileWriter(
os.path.join(LOG_DIR, 'summary', 'test'))
saver = tf.train.Saver(max_to_keep=None)
# print
log_string('Net layers:')
log_string(str(ae))
# Create a session
config = tf.ConfigProto()
config.gpu_options.allow_growth = True
config.allow_soft_placement = True
config.log_device_placement = False
sess = tf.Session(config=config)
# Init variables
init = tf.global_variables_initializer()
sess.run(init)
sess.run(reset_metrics)
total_batch_idx = 0
for ep_idx in range(para_config['epoch']):
log_string('-----------Epoch %d:-------------' % ep_idx)
# train one epoch
while TRAIN_DATASET.has_next_batch():
sess.run(reset_metrics)
if para_config['ae_type'] == 'c2c':
input_batch = TRAIN_DATASET.next_batch()
elif para_config['ae_type'] == 'n2n':
input_batch = TRAIN_DATASET.next_batch_noise_added(
noise_mu=para_config['noise_mu'],
noise_sigma=para_config['noise_sigma'])
elif para_config['ae_type'] == 'np2np':
input_batch = TRAIN_DATASET.next_batch_noise_partial_by_percentage(
noise_mu=para_config['noise_mu'],
noise_sigma=para_config['noise_sigma'],
p_min=para_config['p_min'],
p_max=para_config['p_max'],
partial_portion=para_config['partial_portion'])
else:
log_string('Unknown ae type: %s' %
(para_config['ae_type']))
exit
if para_config['data_aug'] is not None:
input_batch = TRAIN_DATASET.aug_data_batch(
input_batch,
scale_low=para_config['data_aug']['scale_low'],
scale_high=para_config['data_aug']['scale_high'],
rot=para_config['data_aug']['rot'],
snap2ground=para_config['data_aug']['snap2ground'],
trans=para_config['data_aug']['trans'])
_, _ = sess.run([optimizer, reconstr_loss_mean_update],
feed_dict={
ae.input_pl: input_batch,
ae.is_training: True
})
if TRAIN_DATASET.batch_idx % para_config[
'output_interval'] == 0:
reconstr_loss_mean_val, summary = sess.run(
[reconstr_loss_mean, summary_op])
sess.run(reset_metrics)
log_string(
'-----------batch %d statistics snapshot:-------------'
% TRAIN_DATASET.batch_idx)
log_string(' Reconstruction loss : {:.6f}'.format(
reconstr_loss_mean_val))
train_writer.add_summary(summary, total_batch_idx)
train_writer.flush()
total_batch_idx += 1
# after each epoch, reset
TRAIN_DATASET.reset()
# test and save
if ep_idx % para_config['save_interval'] == 0:
# test on whole test dataset
sess.run(reset_metrics)
TEST_DATASET.reset()
while TEST_DATASET.has_next_batch():
if para_config['ae_type'] == 'c2c':
input_batch_test = TEST_DATASET.next_batch()
elif para_config['ae_type'] == 'n2n':
input_batch_test = TEST_DATASET.next_batch_noise_added(
noise_mu=para_config['noise_mu'],
noise_sigma=para_config['noise_sigma'])
elif para_config['ae_type'] == 'np2np':
input_batch_test = TEST_DATASET.next_batch_noise_partial_by_percentage(
noise_mu=para_config['noise_mu'],
noise_sigma=para_config['noise_sigma'],
p_min=para_config['p_min'],
p_max=para_config['p_max'],
partial_portion=para_config['partial_portion'])
else:
log_string('Unknown ae type: %s' %
(para_config['ae_type']))
exit
if para_config['data_aug'] is not None:
input_batch_test = TEST_DATASET.aug_data_batch(
input_batch_test,
scale_low=para_config['data_aug']['scale_low'],
scale_high=para_config['data_aug']['scale_high'],
rot=para_config['data_aug']['rot'],
snap2ground=para_config['data_aug']['snap2ground'],
trans=para_config['data_aug']['trans'])
reconstr_val_test, _ = sess.run(
[reconstr, reconstr_loss_mean_update],
feed_dict={
ae.input_pl: input_batch_test,
ae.is_training: False
})
log_string('--------- on test split: --------')
reconstr_loss_mean_val, summary_test = sess.run(
[reconstr_loss_mean, summary_test_op])
log_string('Mean Reconstruction loss: {:.6f}'.format(
reconstr_loss_mean_val))
sess.run(reset_metrics) # reset metrics
# tensorboard
test_writer.add_summary(summary_test, ep_idx)
test_writer.flush()
# write out only one batch for check
if False:
pc_util.write_ply_batch(
np.asarray(reconstr_val_test),
os.path.join(LOG_DIR, 'pcloud',
'reconstr_%d' % (ep_idx)))
pc_util.write_ply_batch(
np.asarray(input_batch_test),
os.path.join(LOG_DIR, 'pcloud', 'input_%d' % (ep_idx)))
# save model
save_path = saver.save(
sess,
os.path.join(LOG_DIR, 'ckpts', 'model_%d.ckpt' % (ep_idx)))
log_string("Model saved in file: %s" % save_path)
verbosity_level = False
network_structure_list = [
dh.MNIST_WIDTH * dh.MNIST_HEIGHT, # Input layer size
32,
dh.MNIST_WIDTH * dh.MNIST_HEIGHT # Output layer size
]
# Read input data
file_name = sys.argv[1]
data = dh.read_data(file_name)
random.shuffle(data)
N = len(data)
nvd = int(0.1 * N)
print("Number of images: " + str(N))
print("Number of validation images: " + str(nvd))
print("Number of training data: " + str(N - nvd))
training_data = data[nvd:]
validation_data = data[0:nvd]
# Setup the network
ae_one = ae.AutoEncoder(dh.MNIST_WIDTH, dh.MNIST_HEIGHT,
network_structure_list, standard_deviation,
initial_bias, loss, verbosity_level)
# Train the network.
ae_one.train(training_data, validation_data, n_epochs, mini_batch_size,
learning_rate)
nc /= nc.max()
return nc
def novelty_seg(ftr, kernel_size):
ftr -= ftr.min()
ftr /= ftr.max()
n = get_novelty_curve(ftr, kernel_size)
print("Finding slices")
tp, prop = signal.find_peaks(n, height=np.mean(n) + np.std(n), distance=1)
return tp.astype(np.int32)
stft_file = sys.argv[1]
outPath = sys.argv[2]
kernel_size = int(sys.argv[3])
iterations = sys.argv[4]
net = ae.AutoEncoder(513, 13)
print("performing STFT")
x = Wave.read(stft_file).to_mono()
X = STFT().process(x).magnitude().T
print("done")
ae.train_ae(net, X)
print("Getting feature vectors")
features = ae.get_learnt_features(net, X)
print("Computing novelty")
boundaries = novelty_seg(features, kernel_size)
np.savetxt(
os.path.expanduser(outPath + '/' + Path(stft_file).name + '.ae_segs.ds'),
boundaries)
# Hyperparameters
num_epochs = 15
batch_size = 128
lr = 0.002
optimizer_cls = optim.Adam
# Data loader
loader = utils.get_data('mnist', _train=True, _transforms=transforms.ToTensor(),
_batch_size=batch_size)
test_loader = utils.get_data('mnist', _train=False, _transforms=transforms.ToTensor(),
_batch_size=batch_size)
# Instantiate model
auto = autoencoder.AutoEncoder('mnist',0.1)
loss_fn = nn.BCELoss()
optimizer = optimizer_cls(auto.parameters(), lr=lr)
num_batches = 150
# Training loop
for epoch in range(num_epochs):
print('Epoch: {}. Time elapsed: {:.1f} minutes'.format(epoch, (time.time() - start)/60.0) )
batch_num = 0
auto.train()
for i, (orig, _) in enumerate(loader):
if batch_num > num_batches:
def __init__(self,
inputs,
masks,
numpy_rng,
theano_rng=None,
n_ins=4096,
hidden_layers_sizes=[200, 100, 100, 200],
n_outs=4096):
self.sigmoid_layers = []
self.HL_output = []
self.AutoEncoder_layers = []
self.params = []
self.n_layers = len(hidden_layers_sizes)
if not theano_rng:
theano_rng = RandomStreams(numpy_rng.randint(2**30))
if masks is None:
self.Y = T.dmatrix(name='masks')
else:
self.Y = masks
if input is None:
self.X = T.dmatrix(name='input')
else:
self.X = inputs
for i in xrange(self.n_layers):
# construct the sigmoidal layer
# the size of the input
if i == 0:
input_size = n_ins
else:
input_size = hidden_layers_sizes[i - 1]
# the input to this layer
if i == 0:
layer_input = self.X
else:
layer_input = self.sigmoid_layers[-1].output
sigmoid_layer = HL.HiddenLayer(
rng=numpy_rng,
input=layer_input,
n_in=input_size,
n_out=hidden_layers_sizes[i],
activation=theano.tensor.nnet.sigmoid)
# add the layer to our list of layers
self.sigmoid_layers.append(sigmoid_layer)
self.params.extend(sigmoid_layer.params)
# Construct an autoencoder that shared weights with this layer and append to list
AutoEncoder_layer = AC.AutoEncoder(numpy_rng=numpy_rng,
theano_rng=theano_rng,
input=layer_input,
n_visible=input_size,
n_hidden=hidden_layers_sizes[i],
Whid=sigmoid_layer.W,
bhid=sigmoid_layer.b)
self.AutoEncoder_layers.append(AutoEncoder_layer)
# We now need to add a logistic layer on top of the MLP
self.logLayer = LR.LogisticRegression(
input=self.sigmoid_layers[-1].output,
masks=self.Y,
n_in=hidden_layers_sizes[-1],
n_out=n_outs)
self.params.extend(self.logLayer.params)
width = 1280
height = 720
DATA_PATH = "./../DATA/"
MODEL_DIR = "model/"
BEST_MODELE = "best_model.pt"
run_dir = "run-1584468877/"
LOG_DIR = "./../log/"
IMAGE_FOLDER_PATH = DATA_PATH + "Images/train/images/"
IMG_SIZE = 512
EXTENTION_JPG = ".jpg"
def generate(num_run)
run_dir = "run-"+str(num_run)+"/"
model = nw.AutoEncoder(num_block=3, depth = 6)
data_frame = pd.read_csv(DATA_PATH + "train_label.csv")
print(data_frame.shape)
model.load_state_dict(torch.load(LOG_DIR +run_dir + MODEL_DIR + BEST_MODELE))
data_submission = pd.DataFrame(columns=['img', 'rle_mask'])
for idx in range(data_frame.shape[0]):
img_name = os.path.join(
IMAGE_FOLDER_PATH, data_frame["img"].iloc[idx] + EXTENTION_JPG)
image = cv2.imread(img_name, cv2.IMREAD_COLOR)
image = cv2.resize(image, (IMG_SIZE, IMG_SIZE))
assert (image is not None), "This image is None: image name: {}".format(img_name)
image = image.transpose((2, 0, 1))
input = torch.from_numpy(image).float()
input = input/255
input = input.view(1,image.shape[0],image.shape[1],image.shape[2])
output = (model(input)).view(image.shape[1],image.shape[2])
