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)