def plot_cm_roc(self,data_loader):
print("*****************Calculating Confusion Matrix*****************")
save_path = os.path.join(self.output_model_dir, self.config.model_name, self.config.file_type,"data/")
classes = np.arange(self.num_classes)
probOutput,trueOutput,predictedOutput = self.test(data_loader)
trueOutput = prepareData(trueOutput)
predictedOutput = prepareData(predictedOutput)
probOutput = prepareData(probOutput)
one_hot_true_out = one_hot(trueOutput)
normalized_confusion_matrix(trueOutput,predictedOutput,classes,save_path)
plot_roc_curve(one_hot_true_out,probOutput,classes,save_path)
if(self.config.debug == False):
path = os.path.join(self.output_model_dir, self.config.model_name, self.config.file_type,"data/")
cm = Image.open(path+"confusion_matrix.png")
roc = Image.open(path+"roc_curve.png")
wandb.log({"Confusion Matrix": [wandb.Image(cm, caption="Confusion Matrix")]})
wandb.log({"ROC Curve": [wandb.Image(roc, caption="ROC Curve")]})
# wandb.sklearn.plot_confusion_matrix(trueOutput,predictedOutput,classes)
# wandb.sklearn.plot_roc(one_hot_true_out,probOutput,classes)
return None
def main(config):
trainLoader = trainDataLoaderFn(config.train_images_path,
config.train_labels_path,
config.train_csv_path, config.batch_size)
validLoader = testDataLoaderFn(config.validation_images_path,
config.validation_labels_path,
config.validation_csv_path,
config.batch_size)
testLoader = testDataLoaderFn(config.test_images_path,
config.test_labels_path,
config.test_csv_path, config.batch_size)
# temp = iter(trainLoader)
# temp.next()
model = Trainer(config, trainLoader, validLoader)
input_images, output_maps = model.test(testLoader)
input_images = prepareData(input_images)
output_maps = prepareData(output_maps)
print(input_images.shape)
print(output_maps.shape)
for i in range(len(input_images)):
current_input_image = input_images[i, :, :, :]
current_input_image = np.transpose(current_input_image, (1, 2, 0))
current_input_image = 255.0 * current_input_image
current_input_image = current_input_image.astype("uint8")
current_output_map = output_maps[i, :, :, :]
current_output_map = np.transpose(current_output_map, (1, 2, 0))
current_output_map = 255.0 * current_output_map
current_output_map = current_output_map.astype("uint8")
print(current_input_image.shape)
print(current_output_map.shape)
rgb_map = cv2.cvtColor(current_output_map, cv2.COLOR_GRAY2RGB)
output_image = cv2.addWeighted(current_input_image, 0.5, rgb_map, 0.5,
0.0)
cv2.imwrite('outputs/saved_images/input_images/' + str(i) + ".png",
current_input_image)
cv2.imwrite('outputs/saved_images/output_maps/' + str(i) + ".png",
current_output_map)
cv2.imwrite('outputs/saved_images/output_images/' + str(i) + ".png",
output_image)
del (model)
def main():
# import dataset
dataset = pd.read_csv('Churn_Modelling.csv')
# prepareDate
X, Y = utils.prepareData(dataset)
# create model
model = utils.getModel()
# compile model
model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
#model.fit(X, Y, validation_split = 0.33, batch_size = 10, epochs = 100)
# Split the dataset into the Training set(80%) and Test set(20%)
X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size = 0.2)
# fit the model
model.fit(X_train, Y_train, validation_data = (X_test, Y_test), batch_size = 10, epochs = 100)
# evaluate the model
scores = model.evaluate(X_test, X_test)
print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
def main(model_path: str, img_fld: str):
# Training the KNN
model = keras.models.load_model(model_path)
img_h = img_w = model.inputs[0].shape[1]
train_x, test_x, train_y, test_y = prepareData(img_fld,
img_h,
sample_size=-30,
normalize=True)
print("Building KNN model..")
knn = getKNN(model, train_x, train_y)
print("Predicting the Test dataset..")
test_vecs = model.predict(test_x)
test_pred = knn.predict(test_vecs)
accuracy = np.asarray(test_pred == test_y).sum() / len(test_y)
print("Accuracy: %f" % accuracy)
def main(
data_path,
architecture,
n_iters,
max_length,
hidden_size,
learning_rate,
teacher_forcing_ratio,
):
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
input_lang, output_lang, pairs = prepareData('eng', 'fra', path=data_path, max_length= max_length, prefixes=None)
if architecture=="rnn_attention_s2s":
model = RnnAttentionS2S(input_lang, output_lang, max_length=max_length, hidden_size=hidden_size, device=device)
else:
raise Exception('Unknown architecture')
model.train(pairs, n_iters = n_iters, learning_rate=learning_rate, max_length=max_length, teacher_forcing_ratio=teacher_forcing_ratio)
def main():
# import dataset
dataset = pd.read_csv('Churn_Modelling.csv')
# prepare data set
X, Y = utils.prepareData(dataset)
print(X.shape)
# create model
model = utils.getModel()
# compile model
model.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])
# fit the model
model.fit(X, Y, batch_size = 10, epochs = 100)
model.summary()
# evaluate the model
scores = model.evaluate(X, Y)
# print accuracy
print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
Y_predict = model.predict(X)
#Y_predict = (Y_predict > 0.5)
print(type(Y_predict[:10]))
# print head first 10 rows
print(Y_predict[:100])
# print head first 10 rows
print(Y[:100])
from sklearn.metrics import confusion_matrix
cm = confusion_matrix(Y, Y_predict)
print(cm)
def main(training_path_a, training_path_b):
'''
Main function. Trains a classifier.
Args:
training_path_a (str): directory containing sample images
of class positive(1).
training_path_b (str): directory containing sample images
of class positive(0).
'''
logger.info("prepareing data")
x_train, x_test, y_train, y_test = prepareData(
training_path_a,
training_path_b,
feature.getFeature)
logger.info("prepare data done.")
logger.info('Training classifier')
classifier = model.getModel(x_train, x_test, y_train, y_test)
logger.info("done. Saving model to file " + model_file)
with open(model_file, 'wb') as fid:
cPickle.dump(classifier, fid)
logger.info("model saved successfully")
def payment_update():
postData = request.json
rowInsert = prepareData(postData)
print 'INSERT IT', rowInsert
#Check if ref_id already exist
row = BillPayment.query.filter_by(ref_id=rowInsert['ref_id']).first()
if row:
return jsonify({
"status": "SUCCESS",
"data": {
"ackID": row.ack_id
}
}), 202
else:
key = generateId()
transactionRow = BillPayment(date=rowInsert['date'],
amount_paid=rowInsert['amount_paid'],
id=rowInsert['id'],
ref_id=rowInsert['ref_id'],
ack_id=key)
db.session.add(transactionRow)
db.session.commit()
return jsonify({"status": "SUCCESS", "data": {"ackID": key}}), 201
def main(config):
prepareDirs(config)
print('==> Preparing data...')
trainLoader = trainDataLoaderFn(config.train_path, config.train_csv_path,
config.batch_size)
validLoader = testDataLoaderFn(config.validation_path,
config.validation_csv_path,
config.batch_size)
testLoader = testDataLoaderFn(config.test_path, config.test_csv_path,
config.batch_size)
# it = iter(trainLoader)
# next(it)
model = Trainer(config, trainLoader, validLoader)
output_map = model.test(testLoader)
# output_map
final_output_map = prepareData(output_map)
np.save("output_maps.npy", final_output_map)
print(final_output_map.shape)
# print(len(output_map))
del (model)
def evaluateAndShowAttention(input_sentence, max_length):
output_words, attentions = evaluate(encoder1, syntax_attn_decoder1,
input_sentence, max_length)
#output_words, attentions = evaluate(encoder2, syntax_attn_decoder2, input_sentence, max_length)
print('input =', input_sentence)
print('output =', ' '.join(output_words))
showAttention(input_sentence, output_words, attentions)
if __name__ == "__main__":
device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
data_path = '/content/drive/My Drive/colab qz_seq2seq/data/dataset3/'
eval_data_path = '/content/drive/My Drive/colab qz_seq2seq/data/dataset3/syntax_info_eval_data.txt'
input_lang, output_lang, pairs, max_length = prepareData(
data_path, 'zh', 'en', False)
MAX_LENGTH = max_length + 1
hidden_size = 512
encoder_model_path = '/content/drive/My Drive/colab qz_seq2seq/data/dataset3/path2 lstm/encoder.pt'
#attn_decoder_model_path = '/content/drive/My Drive/colab qz_seq2seq/data/dataset1/path2 lstm/attn_decoder.pt'
syntax_decoder_model_path = '/content/drive/My Drive/colab qz_seq2seq/data/dataset3/path2 lstm/syntax_attn_decoder.pt'
output_path = '/content/drive/My Drive/colab qz_seq2seq/data/dataset3/path2 lstm/result.txt'
eval_data = read_eval_data(eval_data_path)
#encoder1 = EncoderRNN_GRU(input_lang.n_words, hidden_size).to(device)
encoder2 = EncoderRNN_LSTM(input_lang.n_words, hidden_size).to(device)
#attn_decoder1 = AttnDecoderRNN(hidden_size, output_lang.n_words, MAX_LENGTH, dropout_p=0.1).to(device)
#syntax_attn_decoder1 = SyntaxAttnDecoderRNN_1(hidden_size, output_lang.n_words, MAX_LENGTH, dropout_p=0.1).to(device)
syntax_attn_decoder2 = SyntaxAttnDecoderRNN_2(hidden_size,
output_lang.n_words,
def main():
DATADIR = "data/mini_data"
CATEGORIES = os.listdir(DATADIR)
img_h = img_w = img_size = 256
train_x, test_x, train_y, test_y = prepareData(img_folder=DATADIR, img_size=img_size, sample_size=-10)
epoch = len(train_x)
model = tf.keras.Sequential([
tf.keras.layers.Conv2D(20, (5, 5), input_shape=(img_h, img_w, 1), activation='relu', padding='same'),
tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
tf.keras.layers.Reshape((32, 32, 32, 16)),
tf.keras.layers.Conv2D(40, (3, 3), activation='relu', padding='same'),
tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
tf.keras.layers.Conv2D(40, (3, 3), activation='relu', padding='same'),
tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
tf.keras.layers.Conv2D(80, (3, 3), activation='relu', padding='same'),
tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
tf.keras.layers.Conv2D(80, (3, 3), activation='relu', padding='same'),
tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
tf.keras.layers.Conv2D(120, (3, 3), activation='relu', padding='same'),
tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
tf.keras.layers.Conv2D(120, (3, 3), activation='relu', padding='same'),
tf.keras.layers.MaxPooling2D(pool_size=(2, 2)),
tf.keras.layers.Flatten(),
tf.keras.layers.Dense(256, activation='relu'),
tf.keras.layers.Dense(256, activation='relu'),
tf.keras.layers.Dropout(0.4),
tf.keras.layers.Dense(256, activation='relu'),
tf.keras.layers.Dense(len(CATEGORIES), activation='softmax')
])
initial_learning_rate = 1e-3
lr_schedule = keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate,
decay_steps=epoch * 5,
decay_rate=.1,
staircase=True)
model.compile(optimizer=keras.optimizers.Adam(learning_rate=lr_schedule),
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
print(model.summary())
log_dir = os.path.join("tf_logs\\CNN\\", datetime.now().strftime("%Y%m%d-%H%M%S/"))
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=log_dir, profile_batch=0)
save_callback = keras.callbacks.ModelCheckpoint(log_dir, monitor='val_accuracy', verbose=True, save_best_only=True,
save_weights_only=False, mode='max', save_freq='epoch')
model.fit(x=train_x,
y=train_y,
batch_size=256,
epochs=100,
validation_data=(test_x, test_y),
callbacks=[tensorboard_callback,
save_callback])
testSize = len(sourceTest)
H = 0.
c = 0
for b in range(0, testSize, batchSize):
sourceBatch = sourceTest[b:min(b + batchSize, testSize)]
targetBatch = targetTest[b:min(b + batchSize, testSize)]
l = sum(len(s) - 1 for s in targetBatch)
c += l
with torch.no_grad():
H += l * nmt(sourceBatch, targetBatch)
return math.exp(H / c)
if len(sys.argv) > 1 and sys.argv[1] == 'prepare':
sourceCorpus, sourceWord2ind, targetCorpus, targetWord2ind, sourceDev, targetDev = utils.prepareData(
sourceFileName, targetFileName, sourceDevFileName, targetDevFileName,
startToken, endToken, unkToken, padToken)
pickle.dump((sourceCorpus, targetCorpus, sourceDev, targetDev),
open(corpusDataFileName, 'wb'))
pickle.dump((sourceWord2ind, targetWord2ind), open(wordsDataFileName,
'wb'))
print('Data prepared.')
if len(sys.argv) > 1 and (sys.argv[1] == 'train'
or sys.argv[1] == 'extratrain'):
(sourceCorpus, targetCorpus, sourceDev,
targetDev) = pickle.load(open(corpusDataFileName, 'rb'))
(sourceWord2ind,
targetWord2ind) = pickle.load(open(wordsDataFileName, 'rb'))
nmt = model.NMTmodel(embedding_size, hidden_size, targetWord2ind,
parser.add_argument('--pretrain', type=str, default=None)
parser.add_argument('--translate', type=str, default=None)
parser.add_argument('--model_name', type=str, default=None)
parser.add_argument('--batch_size', type=int, default=62)
args = parser.parse_args()
training_fp = args.train_dataset
eval_fp = args.eval_dataset
train = args.train
load_model_name = args.pretrain
sentence = args.translate
batch_size = args.batch_size
model_name = args.model_name if args.model_name is not None else str(
).join(str(training_fp.split("/")[-1]).split(".")[:-1])
input_lang, output_lang, training_pairs, eval_pairs, VOCAB_SIZE = utils.prepareData(
training_fp, eval_fp, False)
'''
eval_tensors = [utils.tensorsFromPair(pair, input_lang, output_lang, nl.device) for pair in eval_pairs ]
eval_inputs = [ tensors[0] for tensors in eval_tensors ]
eval_targets = [ tensors[1] for tensors in eval_tensors ]
eval_inputs = rnn_utils.pad_sequence(eval_inputs, batch_first=True, padding_value=0)
eval_targets = rnn_utils.pad_sequence(eval_targets, batch_first=True, padding_value=0)
torch.save(eval_inputs, "./model/eval_inputs.pt")
torch.save(eval_targets, "./model/eval_targets.pt")'''
seq2seq = Transformer(input_lang,
output_lang) #Seq2SeqModel(output_lang, VOCAB_SIZE)
if load_model_name is not None:
def senteces2Tensors(lang, sentences):
outputs = []
outputs_lens = []
for sentence in sentences:
tokens = [lang.word2index[word] for word in sentence.split(' ')]
tokens.append(lang.EOS_token)
#tokens_tensor = torch.tensor(tokens, dtype=torch.long, device=device).view(-1, 1)
tokens_tensor = torch.tensor(tokens, dtype=torch.long, device=device)
outputs.append(tokens_tensor)
outputs_lens.append(tokens_tensor.size()[0])
return outputs, torch.LongTensor(outputs_lens, device=device)
if __name__ == "__main__":
input_lang, output_lang, pairs = utils.prepareData('eng', 'fra', True)
print(random.choice(pairs))
train_ratio = 0.7
test_ratio = 0.1
# Parameters
params = {'batch_size': 10, 'shuffle': False, 'num_workers': 6}
max_epochs = 100
train_src, train_trg, train_ids = ([
pairs[i][0] for i in range(int(len(pairs) * train_ratio))
], [pairs[i][1] for i in range(int(len(pairs) * train_ratio))
], [i for i in range(int(len(pairs) * train_ratio))])
test_src, test_trg, test_ids = ([
pairs[i][0]
for i in range(len(pairs) - int(len(pairs) * test_ratio), len(pairs))
], [
def main():
parser = argparse.ArgumentParser()
# construct the argument parse and parse the arguments
parser = argparse.ArgumentParser(
description='Please specify model.',
usage='use "python %(prog)s --help" for more information',
formatter_class=argparse.RawTextHelpFormatter)
parser.add_argument('-m',
'--model',
required=True,
help=textwrap.dedent('''\
Possible MODEL:
conv_net
conv_net_dropout
conv_net_batch_norm
conv_net_l1
conv_net_l2
all -> will train all models listed above
'''))
args = vars(parser.parse_args())
model_name = args["model"]
# list of the implemented models, second parameter defined is model convolutional or not
existing_model_names = (('conv_net', 'True'), ('conv_net_dropout', 'True'),
('conv_net_batch_norm', 'True'),
('conv_net_l1', 'True'), ('conv_net_l2', 'True'))
if (any(model_name in i for i in existing_model_names)):
# if model name is supported
tmp_dict = dict(existing_model_names)
modelNames = ((model_name, tmp_dict[model_name]), )
elif (model_name == 'all'):
modelNames = existing_model_names
else:
# if model name is not supported
print("MODEL:" + model_name +
' is not supported, please speficy correct MODEL')
exit()
# named tuple which is holding hyper parameters values
HyperParams = namedtuple('HyperParams', 'optimizer epochs batch_size loss')
hyper_params = HyperParams(
optimizer='adam', #rmsprop
epochs=2,
batch_size=256,
loss='categorical_crossentropy')
reportList = []
print(
"load dataset ..., the images are encoded as numpy arrays and labels are an array of digits, ranging from 0 to 9"
)
# load data
(train_images, train_labels), (test_images,
test_labels) = mnist.load_data()
for (modelName, isConvModel) in modelNames:
# prepare data
(train_data,
train_labels_one_hot), (test_data,
test_labels_one_hot) = utils.prepareData(
train_images, train_labels, test_images,
test_labels, isConvModel)
# now data is processed and we are ready to build a network
model = Model.getModel(modelName)
# print model summary
model.summary()
# compile the model
model.compile(optimizer=hyper_params.optimizer,
loss=hyper_params.loss,
metrics=['accuracy'])
# checkpoint callbacks
model_checkpoint_callback = keras.callbacks.ModelCheckpoint(
'./outputs/' + utils.getStartTime() + '_' + modelName + '.h5',
monitor='val_acc',
verbose=1,
period=hyper_params.epochs)
# time callback
time_callback = TimeCallback()
gen = ImageDataGenerator(rotation_range=8,
width_shift_range=0.08,
shear_range=0.3,
height_shift_range=0.08,
zoom_range=0.08)
test_gen = ImageDataGenerator()
train_generator = gen.flow(train_data,
train_labels_one_hot,
batch_size=64)
test_generator = test_gen.flow(test_data,
test_labels_one_hot,
batch_size=64)
history = model.fit_generator(
train_generator,
steps_per_epoch=60000 // 1000,
epochs=hyper_params.epochs,
verbose=1,
callbacks=[time_callback, model_checkpoint_callback],
validation_data=test_generator,
validation_steps=10000 // 1000)
[test_loss, test_acc] = model.evaluate(test_data, test_labels_one_hot)
print("Baseline Error: {} test_loss {} , test_acc {} ".format(
(100 - test_acc * 100), test_loss, test_acc))
prediction = model.predict(test_data, hyper_params.batch_size)
le = LabelBinarizer()
le_train_labels = le.fit_transform(train_labels)
le_test_labels = le.transform(test_labels)
classificationReport = classification_report(
le_test_labels.argmax(axis=1),
prediction.argmax(axis=1),
target_names=[str(x) for x in le.classes_])
print(classificationReport)
reportList.append([
model, modelName, history, classificationReport, hyper_params,
time_callback.times
])
utils.generateReport(reportList)
def uploadData(upload_file, port=PSQL_PORT, table_name='default', data=''):
try:
psycopg2.connect(user='******',
password='******',
host='127.0.0.1',
port=port,
database='postgres')
except:
ut.goLog('PostgresSQL_uploadData: Failed to connect to PSQL',
level='error')
return
connection = psycopg2.connect(user='******',
password='******',
host='127.0.0.1',
port=port,
database='postgres')
cursor = connection.cursor()
if upload_file.endswith('csv'):
try:
f = open(upload_file, 'r')
except IOError:
raise IOError('Cannot read the file.')
lines = f.readlines()
f.close()
columns = lines[0].replace('/', '_').replace(' ', '_').lower()[2:]
columns_list = columns.split(',')
if date == '':
table_name = 'corona_data_' + ut.getDate().replace('-', '_')
else:
table_name = 'corona_data_' + date
create_table_query = 'CREATE TABLE ' + table_name + ' ('
for column in columns_list:
create_table_query += column + ' text NOT NULL,'
create_table_query = create_table_query[:-1] + ');'
try:
cursor.execute(create_table_query)
except:
ut.goLog('PostgresSQL_uploadData: Failed to create table.',
level='error')
return
cursor.execute('SELECT * FROM ' + table_name)
existing_column = [desc[0] for desc in cursor.description]
datas = lines[1:]
add_data_query = 'INSERT INTO ' + table_name + ' (' + columns + ')' + ' VALUES '
for data in datas:
data = data.split(',')
del data[0]
data_query = '(' + ut.prepareData(data) + ');'
cursor.execute(add_data_query + data_query)
elif upload_file.endswith('.png'):
f = open(upload_file, 'rb')
data = f.read()
f.close()
date = ut.getDate()
add_data_query = 'INSERT INTO ' + table_name + ' (date, img) VALUES (' + date + ', ' + str(
psycopg2.Binary(data)) + ')'
cursor.execute(add_data_query)
ut.goLog('PostgresSQL_uploadData: Successfully uploaded data to Database')
connection.commit()
connection.close()
import utils
import generator
import train
import model
import pickle
from parameters import *
startChar = '{'
endChar = '}'
unkChar = '@'
padChar = '|'
if len(sys.argv)>1 and sys.argv[1] == 'prepare':
testCorpus, trainCorpus, char2id = utils.prepareData(corpusFileName, startChar, endChar, unkChar, padChar)
pickle.dump(testCorpus, open(testDataFileName, 'wb'))
pickle.dump(trainCorpus, open(trainDataFileName, 'wb'))
pickle.dump(char2id, open(char2idFileName, 'wb'))
print('Data prepared.')
if len(sys.argv)>1 and sys.argv[1] == 'train':
testCorpus = pickle.load(open(testDataFileName, 'rb'))
trainCorpus = pickle.load(open(trainDataFileName, 'rb'))
char2id = pickle.load(open(char2idFileName, 'rb'))
lm = model.LSTMLanguageModelPack(char_emb_size, hid_size, char2id, unkChar, padChar, endChar, lstm_layers=lstm_layers, dropout=dropout).to(device)
if len(sys.argv)>2: lm.load(sys.argv[2])
optimizer = torch.optim.Adam(lm.parameters(), lr=learning_rate)
train.trainModel(trainCorpus, lm, optimizer, epochs, batchSize)
def main():
DATA_DIR = "data/mini_data"
CATEGORIES = os.listdir(DATA_DIR)
img_size = img_h = img_w = 64
train_x, test_x, train_y, test_y = \
prepareData(
img_folder=DATA_DIR,
img_size=img_size,
sample_size=-128,
normalize=True)
epoch = len(train_x)
# Network construction
# Encoder
input_img = layers.Input(shape=(img_h, img_w, 1))
x = layers.Conv2D(32, (5, 5), activation='relu', padding='same')(input_img)
x = layers.Conv2D(32, (5, 5), activation='relu', padding='same')(x)
x = layers.Conv2D(32, (5, 5), activation='relu', padding='same')(x)
x = layers.Conv2D(32, (5, 5),
strides=(2, 2),
activation='relu',
padding='same')(x)
x = layers.Conv2D(64, (5, 5), activation='relu', padding='same')(x)
x = layers.Conv2D(64, (5, 5), activation='relu', padding='same')(x)
x = layers.Conv2D(64, (5, 5), activation='relu', padding='same')(x)
x = layers.Conv2D(32, (5, 5),
strides=(2, 2),
activation='relu',
padding='same')(x)
x = layers.Conv2D(128, (5, 5), activation='relu', padding='same')(x)
x = layers.Conv2D(128, (5, 5), activation='relu', padding='same')(x)
x = layers.Conv2D(128, (5, 5), activation='relu', padding='same')(x)
x = layers.Flatten()(x)
mid_size = img_size // 4
encoder = layers.Dense(mid_size**2,
activation='relu',
name='encoder_output')(x)
# Decoder
x = layers.Dense(128 * (mid_size**2), activation='relu')(encoder)
x = layers.Reshape((mid_size, mid_size, 128))(x)
x = layers.Conv2DTranspose(128, (5, 5), activation='relu',
padding='same')(x)
x = layers.Conv2DTranspose(128, (5, 5), activation='relu',
padding='same')(x)
x = layers.Conv2DTranspose(128, (5, 5),
strides=2,
activation='relu',
padding='same')(x)
x = layers.Conv2DTranspose(64, (5, 5), activation='relu',
padding='same')(x)
x = layers.Conv2DTranspose(64, (5, 5), activation='relu',
padding='same')(x)
x = layers.Conv2DTranspose(64, (5, 5),
strides=2,
activation='relu',
padding='same')(x)
x = layers.Conv2DTranspose(64, (5, 5), activation='relu',
padding='same')(x)
x = layers.Conv2DTranspose(64, (5, 5), activation='relu',
padding='same')(x)
# AutoEncoder output
decoder = layers.Conv2D(1, (5, 5),
activation='relu',
padding='same',
name="decoder_output")(x)
# ANN connected to the encoder
x = layers.Flatten()(encoder)
x = layers.Dense(32, activation='relu', name="Reg_nn")(x)
x = layers.Dense(32, activation='relu')(x)
x = layers.Dense(32, activation='relu')(x)
x = layers.Dropout(0.4)(x)
# Main output
main_output = layers.Dense(len(CATEGORIES),
activation=tf.keras.activations.softmax,
name='main_output')(x)
model = keras.Model(input_img, [main_output, decoder])
decoder_model = keras.Model(input_img, decoder)
initial_learning_rate_main = 1e-4
lr_schedule_main = keras.optimizers.schedules.ExponentialDecay(
initial_learning_rate_main,
decay_steps=epoch * 5,
decay_rate=1e-1,
staircase=True)
model.compile(
optimizer=keras.optimizers.Adam(learning_rate=lr_schedule_main),
metrics={'main_output': 'accuracy'},
loss={
'main_output': keras.losses.sparse_categorical_crossentropy,
'decoder_output': tf.keras.losses.mse
},
loss_weights={
'main_output': 1,
'decoder_output': 1
})
log_dir = os.path.join("tf_logs", "AL",
datetime.now().strftime("%Y%m%d-%H%M%S/"))
os.makedirs(os.path.join(log_dir, 'encoder'))
tensorboard_callback = keras.callbacks.TensorBoard(log_dir=log_dir,
profile_batch=0)
save_callback = keras.callbacks.ModelCheckpoint(
log_dir,
monitor='val_main_output_accuracy',
verbose=True,
save_best_only=True,
save_weights_only=False,
mode='max',
save_freq='epoch')
print(model.summary())
file_writer = tf.summary.create_file_writer(log_dir)
# Use the model to display the state of the autoencoder from the validation dataset.
def log_img_pred(epoch, logs):
test_img = decoder_model.predict(test_x[2:3, :, :, :])
test_img = test_img.reshape((1, img_size, img_size, 1))
fig, ax = plt.subplots(1, 2)
ax[0].imshow(test_x[2, :, :, :].squeeze())
ax[1].imshow(test_img.squeeze())
buf = io.BytesIO()
plt.savefig(buf, format='png')
plt.close(fig)
buf.seek(0)
# Convert PNG buffer to TF image
image = tf.image.decode_png(buf.getvalue(), channels=4)
# Add the batch dimension
image = tf.expand_dims(image, 0)
# Log the confusion matrix as an image summary.
with file_writer.as_default():
tf.summary.image("Test prediction", image, step=epoch)
# Define the per-epoch callback.
cm_callback = keras.callbacks.LambdaCallback(on_epoch_end=log_img_pred)
model.fit(x=train_x,
y=[train_y, train_x],
batch_size=128,
epochs=200,
use_multiprocessing=True,
validation_data=(test_x, [test_y, test_x]),
callbacks=[tensorboard_callback, save_callback, cm_callback])
img = test_x[0, :, :, 0].reshape((img_h, img_w))
showTest(model, img)
pair = random.choice(pairs)
print('query', pair[0])
print('true ques', pair[1])
output_words, attentions = evaluate(encoder, decoder, pair[0])
output_sentence = ' '.join(output_words)
print('predicted', output_sentence)
print('')
def evaluateAndShowAttention(input_sentence):
output_words, attentions = evaluate(encoder1, attn_decoder1,
input_sentence)
print('input =', input_sentence)
print('output =', ' '.join(output_words))
showAttention(input_sentence, output_words, attentions)
input_lang, output_lang, pairs = prepareData()
print(random.choice(pairs))
teacher_forcing_ratio = 0.5
hidden_size = 512
encoder1 = EncoderRNN(input_lang.n_words, hidden_size).to(device)
attn_decoder1 = AttnDecoderRNN(hidden_size, output_lang.n_words,
dropout_p=0.1).to(device)
trainIters(encoder1, attn_decoder1, 150000, print_every=5000)
evaluateRandomly(encoder1, attn_decoder1)
torch.save(encoder1.state_dict(), "../models/encoder.pt")
torch.save(attn_decoder1.state_dict(), "../models/attnDecoder.pt")
def test_load_prepareData(self):
(train_images, train_labels), (test_images,
test_labels) = mnist.load_data()
# check loaded dataset
self.assertEqual(len(train_images.shape), 3)
self.assertEqual(train_images.shape[0], 60000)
self.assertEqual(train_images.shape[1], 28)
self.assertEqual(train_images.shape[2], 28)
self.assertEqual(len(test_images.shape), 3)
self.assertEqual(test_images.shape[0], 10000)
self.assertEqual(test_images.shape[1], 28)
self.assertEqual(test_images.shape[2], 28)
self.assertEqual(len(train_labels.shape), 1)
self.assertEqual(train_labels.shape[0], 60000)
self.assertEqual(len(test_labels.shape), 1)
self.assertEqual(test_labels.shape[0], 10000)
# unique number of test_labels
self.assertEqual(len(np.unique(test_labels)), 10)
# prepare data
(train_data,
train_labels_one_hot), (test_data,
test_labels_one_hot) = utils.prepareData(
train_images, train_labels, test_images,
test_labels, 'False')
self.assertEqual(len(train_data.shape), 2)
self.assertEqual(train_data.shape[0], 60000)
self.assertEqual(train_data.shape[1], 784)
self.assertEqual(train_data.dtype, 'float64')
self.assertEqual(test_data.dtype, 'float64')
self.assertEqual(len(test_data.shape), 2)
self.assertEqual(test_data.shape[0], 10000)
self.assertEqual(test_data.shape[1], 784)
self.assertEqual(len(train_labels_one_hot.shape), 2)
self.assertEqual(train_labels_one_hot.shape[0], 60000)
self.assertEqual(train_labels_one_hot.shape[1], 10)
# prepare data
(train_data,
train_labels_one_hot), (test_data,
test_labels_one_hot) = utils.prepareData(
train_images, train_labels, test_images,
test_labels, 'True')
self.assertEqual(len(train_data.shape), 4)
self.assertEqual(train_data.shape[0], 60000)
self.assertEqual(train_data.shape[1], 28)
self.assertEqual(train_data.shape[2], 28)
self.assertEqual(train_data.shape[3], 1)
self.assertEqual(train_data.dtype, 'float64')
self.assertEqual(test_data.dtype, 'float64')
self.assertEqual(len(test_data.shape), 4)
self.assertEqual(test_data.shape[0], 10000)
self.assertEqual(test_data.shape[1], 28)
self.assertEqual(test_data.shape[2], 28)
self.assertEqual(test_data.shape[3], 1)
self.assertEqual(len(train_labels_one_hot.shape), 2)
self.assertEqual(train_labels_one_hot.shape[0], 60000)
self.assertEqual(train_labels_one_hot.shape[1], 10)
