def run(): import sys, getopt, os load_from = None opts, args = getopt.getopt(sys.argv[1:], "l:") for opt, val in opts: if opt == "-l": load_from = val bg = QuestionsBatchGenerator(args[0], 1000) trainig_set_size = bg.training_samples() validation_data = bg.validateSet() print "Validation set created" #print validation_data model = createModel(bg.rowSize, 2) if load_from: model.load_weights(load_from) for i in range(100): pair_x, pair_truth = bg.loadPair(i) q1, q2, dup_ = pair_truth print "Question 1: ", q1 print "Question 2: ", q2 y = model.predict(pair_x)[0] dup = y[1] > 0.5 correct = dup == dup_ print "Same: %s model: %.3f (%s)" % (dup_, y[1], "CORRECT" if correct else "incorrect") print
def Test(): _model = model.createModel(True) np.set_printoptions(threshold=20) generator = data.ClockGenerator(model.IMG_SIZE, model.INCLUDE_SECONDS_HAND, 0.5) generator.shakeVariance = 0 input, output = generator.generateClocksForLocalization( model.MODEL_SUBDIVIDE, 20) results = _model.predict(input) correct = 0 for i in range(0, len(output)): # save the image with the expect and predicted rectangles drawn on it?? sourceImg = Image.fromarray( input[i].reshape(model.IMG_SIZE[1], model.IMG_SIZE[0]) * 255.0).convert("RGB") draw = ImageDraw.Draw(sourceImg) draw.rectangle(generator.GetCoordsFromOutput(output[i], model.IMG_SIZE), outline="green") draw.rectangle(generator.GetCoordsFromOutput(results[i], model.IMG_SIZE), outline="red") filepath = '/tmp/clock_%s_%d.png' % (generator.convertOutputToRect( output[i]), i) sourceImg.save(filepath)
def Learn(): # 1. create the model print("creating the model") _model = model.createModel(True) # 2. train the model print("initializing the generator") batch_size = 1 generator = data.ClockGenerator(model.IMG_SIZE, model.INCLUDE_SECONDS_HAND, 0.5) generator.shakeVariance = 0 iterations = 1000000 print("beginning training") handler = SignalHandler() i = 0 while True: if handler.stop_processing: break #n = int(random.random() * 43200) n = 10000 print(i) Train(generator, _model, n) i += n if i >= iterations: break _model.save(model.MODEL_H5_NAME)
def train(): train, test = img_gen.loadDataset() train_data = [] train_labels_one_hot = [] test_data = [] test_labels_one_hot = [] for dat in train: train_data.append(dat[0]) train_labels_one_hot.append(dat[1]) for dat in test: test_data.append(dat[0]) test_labels_one_hot.append(dat[1]) train_data = np.asarray(train_data) train_labels_one_hot = np.asarray(train_labels_one_hot) test_data = np.asarray(test_data) test_labels_one_hot = np.asarray(test_labels_one_hot) model1 = model.createModel() batch_size = 15 epochs = 50 LoadPretrained = False if (LoadPretrained): model1.load_weights("model1.h5") history = model1.fit(train_data, train_labels_one_hot, batch_size=batch_size, epochs=epochs, verbose=1, validation_data=(test_data, test_labels_one_hot)) model1.evaluate(test_data, test_labels_one_hot) model1.save_weights("model1.h5") import matplotlib.pyplot as plt # Loss Curves plt.figure(figsize=[8, 6]) plt.plot(history.history['loss'], 'r', linewidth=3.0) plt.plot(history.history['val_loss'], 'b', linewidth=3.0) plt.legend(['Training loss', 'Validation Loss'], fontsize=18) plt.xlabel('Epochs ', fontsize=16) plt.ylabel('Loss', fontsize=16) plt.title('Loss Curves', fontsize=16) # Accuracy Curves plt.figure(figsize=[8, 6]) plt.plot(history.history['acc'], 'r', linewidth=3.0) plt.plot(history.history['val_acc'], 'b', linewidth=3.0) plt.legend(['Training Accuracy', 'Validation Accuracy'], fontsize=18) plt.xlabel('Epochs ', fontsize=16) plt.ylabel('Accuracy', fontsize=16) plt.title('Accuracy Curves', fontsize=16) plt.waitforbuttonpress() input("press enter to finish:")
def run(): import sys, getopt, os save_to = None load_from = None batch_size = 60 nworkers = 2 verbose = 1 opts, args = getopt.getopt(sys.argv[1:], "s:l:n:qw:") for opt, val in opts: if opt == "-s": save_to = val if opt == "-l": load_from = val if opt == "-w": load_from = val save_to = val if opt == "-n": nworkers = int(val) if opt == "-q": verbose = 0 os.system("rm logs/*") bg = QuestionsBatchGenerator(args[0], 1000) print "Row size=", bg.rowSize trainig_set_size = bg.training_samples() validation_data = bg.validateSet() print "Validation set created" #print validation_data model = createModel(bg.rowSize, 2) if load_from: model.load_weights(load_from, by_name=True) print print "model weights loaded from %s" % (load_from, ) print tb = TensorBoard(write_images=False, histogram_freq=1.0) callbacks = [tb] if save_to: callbacks.append( ModelCheckpoint(filepath=save_to, verbose=1, save_best_only=True, save_weights_only=True, monitor="val_loss")) model.fit_generator(bg.batches_guargded(batch_size), int(trainig_set_size / batch_size / 20), epochs=1000, verbose=verbose, workers=nworkers, callbacks=callbacks, validation_data=validation_data)
def __init__(self): self.X0 = None self.predictions = [] self.lastPredictions = None self.model = createModel(nbClasses=3, imageSize=datasetImageSize, maxlength=datasetMaxSerieLength) print "Loading model parameters..." self.model.load(modelsPath + 'eyeDNN_HD_SLIDE.tflearn') #History of last 3 predictions self.history = [None for i in range(averageWindowSize)]
def process(X_train, X_test, y_train, y_test): bestS, bestAF = mdl.getBestModel(X_train, y_train, loss=cfg.loss, metrics=cfg.metrics) model = mdl.createModel(len(X_train[0]), bestS, bestAF, loss=cfg.loss, metrics=cfg.metrics) model.compile(loss=cfg.loss, optimizer='adam', metrics=cfg.metrics) # mdl.estimateScore(model, X, y, epochs=cfg.epochs, batch_size=cfg.batch_size, n_folds = cfg.n_folds, repeats = cfg.repeats) model.fit(X_train, y_train, batch_size=cfg.batch_size, epochs=cfg.epochs, verbose=2) _, score = model.evaluate(X_test, y_test) if cfg.regr == True: pred_y = model.predict(X_test) from sklearn.metrics import mean_squared_error if cfg.normalization == None: mse = mean_squared_error(y_test, pred_y) elif cfg.normalization.lower() == 'standard': pred_y_back = pp.u_y + pred_y * pp.s_y y_test_back = pp.u_y + y_test * pp.s_y mse = mean_squared_error(y_test_back, pred_y_back) elif cfg.normalization.lower() == 'minmax': pred_y_back = pred_y / pp.s_y y_test_back = y_test / pp.s_y mse = mean_squared_error(y_test_back, pred_y_back) #mse = mean_squared_error(y_test/pp.s_y, pred_y/pp.s_y) from sklearn.metrics import r2_score r2 = r2_score(y_test, pred_y) lg.logger.info(f'Test score: {score}, R2: {r2}, mse: {mse}') else: lg.logger.info(f'Test score: {score}') fu.saveModel(model, bestAF, bestS) #fu.saveConfigNN_h() Now, substituted by savePPParams() fu.savePPParams()
def Test2(timeAsString): parsedTime = parser.parse(timeAsString) _model = model.createModel(True) generator = data.ClockGenerator(model.IMG_SIZE, model.INCLUDE_SECONDS_HAND, 0.2) generator.shakeVariance = 16 train, label = generator.generateClockFace(parsedTime.hour, parsedTime.minute) results = _model.predict(train) for i in range(0, len(label)): filepath = '/tmp/clock_%s.png' % (generator.convertOutputToTime( results[i])) generator.saveImageToFile(train[i], filepath) print("expected", generator.convertOutputToTime(label[i]), "predicted", generator.convertOutputToTime(results[i]), "file", filepath)
def Test(): _model = model.createModel(True) generator = data.ClockGenerator(model.IMG_SIZE, model.INCLUDE_SECONDS_HAND, 0.2) generator.shakeVariance = 16 train, label = generator.generateClockFaces(12 * 60 * 60) results = _model.predict(train) correct = 0 for i in range(0, len(label)): expected = generator.convertOutputToTime(label[i]) predicted = generator.convertOutputToTime(results[i]) if expected == predicted: correct += 1 print("expected", expected, "predicted", predicted, "correct", expected == predicted) print("correct", correct, "total", len(label))
def run(): import sys, getopt, os save_to = None load_from = None batch_size = 30 opts, args = getopt.getopt(sys.argv[1:], "s:l:") for opt, val in opts: if opt == "-s": save_to = val if opt == "-l": load_from = val os.system("rm logs/*") bg = QuestionsBatchGenerator(args[0], 1000) trainig_set_size = bg.training_samples() validation_data = bg.validateSet() print "Validation set created" #print validation_data model = createModel(bg.rowSize, 2) tb = TensorBoard(write_images=False, histogram_freq=1.0) callbacks = [tb] if save_to: callbacks.append( ModelCheckpoint(filepath=save_to, verbose=1, save_best_only=True, save_weights_only=True, monitor="val_loss")) model.fit_generator(bg.batches_guargded(batch_size), int(trainig_set_size / batch_size / 100), epochs=1000, workers=4, callbacks=callbacks, validation_data=validation_data)
def _createNewAgent(self): self._agents = [] models = [] for i, x in enumerate(glob.iglob('weights/*.h5')): filename = os.path.abspath(x) model = createModel(shape=self._maze.input_size) model.load_weights(filename) name = os.path.basename(filename) if name.startswith('agent-'): models.append(model) agent = DQNAgent(model) self._agents.append(RLAgent(name[:-3], agent, None, None)) self._agents.insert( 0, RLAgent('ensemble', DQNEnsembleAgent(models), None, None)) self._assignMaze2Agents() self._activeAgent = 0 self._paused = True return
#genres ={'(14)R&B':0,'中国风':1, '古典':2, '摇滚':3,'民谣':4, '爵士':5,'说唱':6} #List genres genres = os.listdir(slicesPath) genres = [ filename for filename in genres if os.path.isdir(slicesPath + filename) ] print("genresw:", genres) nbClasses = len(genres) total = 0 genre_haven = [0, 0, 0, 0, 0, 0, 0] right_haven = [0, 0, 0, 0, 0, 0, 0] #Create model model = createModel(nbClasses, sliceSize) #生成模型(未填录数据) if "train" in args.mode: #Create or load new dataset train_X, train_y, validation_X, validation_y = getDataset(filesPerGenre, genres, sliceSize, validationRatio, testRatio, mode="train") #Define run id for graphs run_id = "MusicGenres - " + str(batchSize) + " " + ''.join( random.SystemRandom().choice(string.ascii_uppercase) for _ in range(10))
def classify(): #List genres genres = os.listdir(slicesPath) genres = [filename for filename in genres if os.path.isdir(slicesPath+filename)] nbClasses = len(genres) #Create model model = createModel(nbClasses, sliceSize) #s = song() #lib = library() #create spectrogram path if it doesn't exist if not os.path.exists(os.path.dirname(predictSpect)): try: os.makedirs(os.path.dirname(predictSpect)) except OSError as exc: # Guard against race condition if exc.errno != errno.EEXIST: raise #create slice path if it doesn't exist if not os.path.exists(os.path.dirname(predSlicePath)): try: os.makedirs(os.path.dirname(predSlicePath)) except OSError as exc: # Guard against race condition if exc.errno != errno.EEXIST: raise counter = 0 #print ("Creating Spectrogams") #parse through all files in library and create spectrograms for filename in os.listdir(predictionPath): if filename.endswith(".mp3"): newFilename = 'new_' + filename newFilename = newFilename.replace(".mp3", "") if (Path(predictSpect+newFilename)).exists(): break if(isMono(predictionPath+filename)): command = "cp '{}' '/tmp/{}.wav' remix 1,2".format(predictionPath+filename, newFilename) else: command = "sox '{}' '/tmp/{}.wav' remix 1,2".format(predictionPath+filename,newFilename) p = Popen(command, shell=True, stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True, cwd=currentPath) output, errors = p.communicate() if errors: print (errors) #create spectrogram from given file filename.replace(".mp3","") #print "Creating spectrogram for file {}".format(filename) command = "sox '/tmp/{}.wav' -n spectrogram -Y 200 -X 50 -m -r -o '{}.png'".format(newFilename,predictSpect+newFilename) p = Popen(command, shell=True, stdin=PIPE, stdout=PIPE, stderr=STDOUT, close_fds=True, cwd=currentPath) output, errors = p.communicate() if errors: print (errors) #Remove tmp mono track #os.remove("/tmp/{}.wav".format(newFilename)) counter += 1 subdata = [] data = [] #print ("Spectrogams Created! ") #slice spectrograms #print ("Slicing Spectrogams") for newFilename in os.listdir(predictSpect): if newFilename.endswith(".png"): #slice img = Image.open(predictSpect+newFilename) width, height = img.size nbSamples = int(width/sliceSize) width - sliceSize #For each sample for i in range(nbSamples): #print "Creating slice: ", (i+1), "/", nbSamples, "for", newFilename #Extract and save 128x128 sample startPixel = i*sliceSize imgTmp = img.crop((startPixel, 1, startPixel + sliceSize, sliceSize + 1)) imgTmp.save(predSlicePath+"{}_{}.png".format(newFilename[:-4],i)) img_array = getImageData(predSlicePath+newFilename[:-4]+"_"+str(i)+".png", sliceSize) #append each loaded image to a sub-data array, and break to new subdata element when name changes subdata.append(img_array) #os.remove() #append sub-data array to super array data.append(subdata) subdata = [] #print ("Slices Created! ") model.load('python/musicDNN.tflearn') #print ("Model loaded! ") #print data #parse through super array predicting each one #and assign name to song object then append song object to songList in library #print ("Predicting") for vec in data: predictionSoftmax = model.predict(vec)[0] predictedIndex = max(enumerate(predictionSoftmax), key=lambda x:x[1])[0] s.vector = predictionSoftmax s.name = filename in os.listdir(predictionPath) s.genre = genres[predictedIndex] lib.songList.append(s.vector) lib.labels.append(s.genre) for x in lib.songList: print x
import numpy as np import tensorflow as tf import math import random from config import config from model import createModel from data import UnclassifiedGenome # Generate a GFF file from the model output genome = UnclassifiedGenome(input_file=config["files"]["evaluate"]) model = createModel(output_nodes=14) clustering = [ 'transcript', 'centromere', 'trna', 'exon', 'region', 'snorna', 'sequence_feature', 'ncrna', 'mrna', 'gene', 'snrna', 'rrna', 'cds', 'pseudogene' ] clustering = sorted(clustering) annotations = dict() model.load_weights(config["files"]["save-to"]) threshold = config["evaluation"]["threshold"] minimum_basepairs = config["evaluation"]["minimum-basepairs"] def computeNucleotideScores(vector):
validTgtFilePath=Parameter.validTgtFilePath, testTgtFilePath=Parameter.testTgtFilePath, trainGraph=Parameter.trainGraph, validGraph=Parameter.validGraph, testGraph=Parameter.testGraph, min_freq=Parameter.min_freq, BATCH_SIZE=Parameter.BATCH_SIZE, dataPath=Parameter.dataPath, dataFile=Parameter.dataFile, checkpointPath=Parameter.checkpointPath, checkpointFile=Parameter.checkpointFile, mode=Parameter.mode) trainDataSet, validDataSet, testDataSet, index2word, gword2index = checkpoint.LoadData( ) model = createModel(len(index2word), len(gword2index)).to(device) if Parameter.mode == 'train': criterion = LabelSmoothing(smoothing=Parameter.smoothing, lamda=Parameter.lamda).to(device) optimizer = WarmUpOpt(optimizer=optim.Adam( params=model.parameters(), lr=Parameter.learning_rate, betas=(Parameter.beta_1, Parameter.beta_2), eps=Parameter.eps, weight_decay=Parameter.weight_decay), d_model=Parameter.embedding_dim, warmup_steps=Parameter.warmup_steps, factor=Parameter.factor) fit = fit(model=model,
# PandasのdataFrameからNumpy配列へ変換 LSTM_training_inputs = [ np.array(LSTM_training_input) for LSTM_training_input in LSTM_training_inputs ] LSTM_training_inputs = np.array(LSTM_training_inputs) LSTM_test_inputs = [ np.array(LSTM_test_input) for LSTM_test_input in LSTM_test_inputs ] LSTM_test_inputs = np.array(LSTM_test_inputs) # ランダムシードの設定(randomで生成される数値の固定) np.random.seed(202) # モデルの構築 eth_model = model.createModel(LSTM_training_inputs, output_size=1, neurons=20) # モデルのアウトプットは次の窓の10番目の価格(正規化されている) LSTM_training_outputs = (training_set['Close**_y'][window_len:].values / training_set['Close**_y'][:-window_len].values) - 1 # データを流してフィッティング eth_history = eth_model.fit(LSTM_training_inputs, LSTM_training_outputs, epochs=50, batch_size=1, verbose=2, shuffle=True) # lossの変化をプロットして確認 fig, ax1 = plt.subplots(1, 1) print("eth_history.epoch\n" + str(eth_history.epoch))
def main(): # Check to see if GPU is being used print(tensorflow.test.gpu_device_name()) print("Num GPUs Available: ", tf.config.experimental.list_physical_devices('GPU')) print("Num GPUs Available: ", len(tf.config.experimental.list_physical_devices('GPU'))) # # Dataloader creation and test # NEW MODIS DATASET img_paths = glob.glob(DATA_PATH) print("len(img_paths):", len(img_paths)) random.shuffle(img_paths) train_test_split = 0.8 X_train_paths = img_paths[:int(train_test_split * len(img_paths))] X_test_paths = img_paths[int(train_test_split * len(img_paths)):] dims = (448, 448, 3) # Loading Training Data X_train = np.empty((len(X_train_paths), *dims)) for i, p in enumerate(X_train_paths): X_train[i, :, :, :] = np.load(p) # Loading Testing Data X_test = np.empty((len(X_test_paths), *dims)) for i, p in enumerate(X_test_paths): X_test[i, :, :, :] = np.load(p) print("X_train:", X_train.shape) print("X_test:", X_test.shape) # To check what percentage of pixels are 'nan' print(np.sum(np.isnan(X_train)) / np.prod(X_train.shape)) print(np.sum(np.isnan(X_test)) / np.prod(X_test.shape)) # Checking min max to see if normalization is needed or not print("Before normalization") print(np.nanmin(X_train), np.nanmax(X_train)) print(np.nanmin(X_test), np.nanmax(X_test)) # Normalize Inputs X_train = utils.normalize(X_train) X_test = utils.normalize(X_test) # Checking min max after normalization print("After normalization") print(np.nanmin(X_train), np.nanmax(X_train)) print(np.nanmin(X_test), np.nanmax(X_test)) # Set nan values to 0 # X_train[np.isnan(X_train)] = 0.0 # X_test[np.isnan(X_test)] = 0.0 X_train_reshaped = X_train del X_train X_test_reshaped = X_test del X_test batch_size = 64 AUTOTUNE = tensorflow.data.experimental.AUTOTUNE train_dataset = tf.data.Dataset.from_tensor_slices( (X_train_reshaped, X_train_reshaped)) test_dataset = tf.data.Dataset.from_tensor_slices( (X_test_reshaped, X_test_reshaped)) train_dataset = train_dataset.map(utils.convert, num_parallel_calls=AUTOTUNE) train_dataset = train_dataset.cache() train_dataset = train_dataset.batch(batch_size) train_dataset = train_dataset.repeat() train_dataset = train_dataset.prefetch(buffer_size=AUTOTUNE) test_dataset = test_dataset.map(utils.convert, num_parallel_calls=AUTOTUNE) test_dataset = test_dataset.cache() test_dataset = train_dataset.prefetch(buffer_size=AUTOTUNE) # # Model creation complete_model = model.createModel(dims) print(complete_model.summary()) complete_model.compile(optimizer='rmsprop', loss='mse') image = np.expand_dims(X_test_reshaped[0], 0) # image = X_test_reshaped[0:10] print(image.shape) # Define the Activation Visualization callback output_dir = TENSORBOARD_LOG_DIR callbacks = [ ActivationsVisualizationCallback( validation_data=(image, ), layers_name=['conv2d_8'], output_dir=output_dir, ), ] # tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir="./tf_callback") tensorboard_callback = tf.keras.callbacks.TensorBoard( log_dir=TENSORBOARD_LOG_DIR) complete_model.fit(train_dataset, epochs=NUM_EPOCHS, steps_per_epoch=len(X_train_reshaped) / batch_size, validation_data=test_dataset, validation_steps=len(X_test_reshaped) / batch_size, callbacks=[callbacks, tensorboard_callback], use_multiprocessing=True) complete_model.save(OUTPUT_MODEL_PATH) # ## Model Testing # Define the Activation Visualization explainer # index = np.random.randint(0, len(X_test_reshaped)) # image = input_test[index].reshape((1, 32, 32, 3)) # image = np.expand_dims(X_test_reshaped[index],0) image = X_test_reshaped[:10] label = image print('val:', image.shape) data = ([image]) explainer = ExtractActivations() layers_of_interest = ['conv2d_1'] grid = explainer.explain(validation_data=data, model=complete_model, layers_name=['conv2d_1']) print(grid.shape) explainer.save(grid, ACTIVATION_IMG_PATH, 'conv2d_1.png') grid = explainer.explain(validation_data=data, model=complete_model, layers_name=['conv2d_2']) print(grid.shape) explainer.save(grid, ACTIVATION_IMG_PATH, 'conv2d_2.png') grid = explainer.explain(validation_data=data, model=complete_model, layers_name=['conv2d_3']) print(grid.shape) explainer.save(grid, ACTIVATION_IMG_PATH, 'conv2d_3.png') grid = explainer.explain(validation_data=data, model=complete_model, layers_name=['conv2d_8']) print(grid.shape) explainer.save(grid, ACTIVATION_IMG_PATH, 'conv2d_8.png') # In[ ]: for i in range(10): index = np.random.randint(0, len(X_test_reshaped)) X_test_im = np.expand_dims(X_test_reshaped[index], 0) out_image = np.squeeze(complete_model.predict(X_test_im)) im_min = out_image.min(axis=(0, 1), keepdims=True) im_max = out_image.max(axis=(0, 1), keepdims=True) out_image = (out_image - im_min) / (im_max - im_min) print("Orig ", np.min(X_test_im), np.max(X_test_im)) print("Gen ", np.min(out_image), np.max(out_image)) fig = plt.figure() plt.subplot(1, 3, 1) plt.imshow(X_test_reshaped[index]) plt.subplot(1, 3, 2) plt.imshow(np.squeeze(X_test_im)) plt.subplot(1, 3, 3) plt.imshow(out_image) plt.show()
def getModel(shape): model = createModel(shape=MODEL_INPUT_SHAPE) model.compile(optimizer=Adam(lr=1e-3), loss=Huber(delta=1)) return model
def main(): dims = (448, 448, 3) # # Dataloader creation and test # img_paths = glob.glob(DATA_PATH) # print("len(img_paths):", len(img_paths)) # print("Discarding the unusable images") # img_paths = utils.getUsableImagePaths(img_paths, "png") # print("len(img_paths):", len(img_paths)) f = open("hurricane_input.txt", 'r') img_paths = [fi.strip("\n") for fi in f.readlines()] print("len(img_paths):", len(img_paths)) train_split = 1.0 valid_split = 0.0 test_split = 0.0 X_train_paths = img_paths[:int(train_split * len(img_paths))] X_valid_paths = img_paths[int(train_split * len(img_paths)):int((train_split + valid_split) * len(img_paths))] X_test_paths = img_paths[len(img_paths) - int(test_split * len(img_paths)):] # More efficient data fetch pipeline AUTOTUNE = tensorflow.data.experimental.AUTOTUNE train_dataset = tf.data.Dataset.from_generator( generator=customGenerator, output_types=(np.float32, np.float32), output_shapes=(dims, dims), args=[X_train_paths, dims, "png"]) output = list(train_dataset.take(1).as_numpy_iterator()) print("@#@#@#@#@#@#@ 1") print("train_dataset:", train_dataset) print("len(output):", len(output)) print("len(output[0]):", len(output[0])) x, y = output[0] print("Printing the output:", x.shape, y.shape) print("x:", x.min(), x.max()) print("y:", y.min(), y.max()) print(x.shape, y.shape) valid_dataset = tf.data.Dataset.from_generator( generator=customGenerator, output_types=(np.float32, np.float32), output_shapes=(dims, dims), args=[X_valid_paths, dims, "png"]) test_dataset = tf.data.Dataset.from_generator( generator=customGenerator, output_types=(tf.float32, tf.float32), args=[X_test_paths, dims, "png"]) train_dataset = train_dataset.batch(BATCH_SIZE) train_dataset = train_dataset.map(utils.convert, num_parallel_calls=AUTOTUNE) train_dataset = train_dataset.cache().shuffle(buffer_size=3 * BATCH_SIZE) train_dataset = train_dataset.repeat() train_dataset = train_dataset.prefetch(buffer_size=AUTOTUNE) valid_dataset = valid_dataset.batch(BATCH_SIZE) valid_dataset = valid_dataset.map(utils.convert, num_parallel_calls=AUTOTUNE) valid_dataset = valid_dataset.cache().shuffle(buffer_size=3 * BATCH_SIZE) valid_dataset = valid_dataset.repeat() valid_dataset = valid_dataset.prefetch(buffer_size=AUTOTUNE) test_dataset = test_dataset.batch(BATCH_SIZE) test_dataset = test_dataset.map(utils.convert, num_parallel_calls=AUTOTUNE) test_dataset = test_dataset.cache() test_dataset = test_dataset.prefetch(buffer_size=AUTOTUNE) output = list(train_dataset.take(1).as_numpy_iterator()) print("@#@#@#@#@#@#@ 2") print("train_dataset:", train_dataset) print("len(output):", len(output)) print("len(output[0]):", len(output[0])) x, y = output[0] print("Printing the output:", x.shape, y.shape) print("x:", x.min(), x.max()) print("y:", y.min(), y.max()) print(x.shape, y.shape) print("---------------------------------") # ARCHITECTURE complete_model = model.createModel(dims) print(complete_model.summary()) opt = tf.keras.optimizers.Adam(learning_rate=0.001) complete_model.compile(optimizer=opt, loss=ssim_loss) image = resize(plt.imread(X_train_paths[0])[:, :, :3], dims) print("Activation visualization image shape orig:", image.shape) image = np.expand_dims(image, 0) print("Activation visualization image shape extended:", image.shape) print("image:", image.min(), image.max()) # image = X_test_reshaped[0:10] # print(image.shape) # Define the Activation Visualization callback output_dir = TENSORBOARD_LOG_DIR activation_viz_callbacks = [ ActivationsVisualizationCallback( validation_data=(image, ), layers_name=['conv2d_8'], output_dir=output_dir, ), ] # tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir="./tf_callback") tensorboard_callback = tf.keras.callbacks.TensorBoard( log_dir=TENSORBOARD_LOG_DIR) # # Schedule LR updates # lr_callback = tf.keras.callbacks.LearningRateScheduler(lr_scheduler, verbose=1) # Reduce LR only when the loss graph plateaus lr_plateau_callback = tf.keras.callbacks.ReduceLROnPlateau( monitor='loss', factor=0.2, patience=5, verbose=1, mode='auto', min_delta=0.0001, cooldown=5, min_lr=0.00000005) # save after every 10 epochs ckpt_path = OUTPUT_MODEL_PATH + "/checkpoints/" subprocess.call("mkdir -p %s" % ckpt_path, shell=True) model_ckpt_callback = tf.keras.callbacks.ModelCheckpoint( filepath=ckpt_path + "epoch{epoch:03d}-loss{loss:.6f}.hdf5", monitor='loss', verbose=1, save_best_only=False, save_weights_only=False, mode='auto', save_freq=(10 * (len(X_train_paths) // BATCH_SIZE))) earlystopping_callback = tf.keras.callbacks.EarlyStopping( monitor='loss', min_delta=0.000001, patience=5, verbose=1, mode='auto') callback_functions = [ activation_viz_callbacks, tensorboard_callback, lr_plateau_callback, model_ckpt_callback, earlystopping_callback, WandbCallback() ] model_history = complete_model.fit( train_dataset, epochs=NUM_EPOCHS, steps_per_epoch=len(X_train_paths) // BATCH_SIZE, initial_epoch=0, # validation_split=0.2, # validation_data=valid_dataset, # validation_steps=len(X_valid_paths) // BATCH_SIZE, callbacks=callback_functions, # use_multiprocessing=True ) # print("model_history.epoch:", model_history.epoch) # print("model_history:") # pprint(model_history.history) complete_model.save(OUTPUT_MODEL_PATH) # sys.exit(0) # ## Model Testing # Define the Activation Visualization explainer # index = np.random.randint(0, len(X_test_reshaped)) # image = input_test[index].reshape((1, 32, 32, 3)) # image = np.expand_dims(X_test_reshaped[index],0) # image = X_test[0][0][:10] image = np.array([ resize(plt.imread(train_img_path)[:, :, :3], dims) for train_img_path in X_train_paths[:10] ]) # image = np.array([resize(plt.imread(test_img_path)[:,:,:3], dims) for test_img_path in X_test_paths[:10]]) # image = X_test_reshaped[:10] label = image print('val:', image.shape) data = ([image]) explainer = ExtractActivations() layers_of_interest = [ 'conv2d_1', 'conv2d_2', 'conv2d_3', 'conv2d_4', 'conv2d_5', 'conv2d_6', 'conv2d_7', 'conv2d_8', 'conv2d_transpose', 'conv2d_transpose_1', 'conv2d_transpose_2', 'conv2d_transpose_3', 'conv2d_9', 'conv2d_transpose_4' ] for layer in layers_of_interest: grid = explainer.explain(validation_data=data, model=complete_model, layers_name=[layer]) print(grid.shape) explainer.save(grid, ACTIVATION_IMG_PATH, '%s.png' % (layer)) # complete_model = model.load_model(OUTPUT_MODEL_PATH) for i in range(10): index = np.random.randint(0, len(X_train_paths)) image_train = resize(plt.imread(X_train_paths[index])[:, :, :3], dims) X_image_train = np.expand_dims(image_train, 0) out_image = np.squeeze(complete_model.predict(X_image_train)) im_min = out_image.min(axis=(0, 1), keepdims=True) im_max = out_image.max(axis=(0, 1), keepdims=True) out_image = (out_image - im_min) / (im_max - im_min) print("Orig ", np.min(X_image_train), np.max(X_image_train)) print("Gen ", np.min(out_image), np.max(out_image))
def main(clean=True, diff=False, reference=False, threshold=False, only_matches=False, match_file=None, reference_file=None): if clean: print('Cleaning output.') subprocess.call(['rm', '-rf', 'output']) if not match_file and not reference_file: filenames = sorted(glob.glob('2018-03-26_*/*.jpeg')) else: filenames = [reference_file, match_file] i1 = cv2.imread(filenames[0]) i1_gray = cv2.cvtColor(i1, cv2.COLOR_BGR2GRAY) reference_filename = filenames[0] os.makedirs('output', exist_ok=True) os.makedirs('matches', exist_ok=True) font = cv2.FONT_HERSHEY_SIMPLEX model1 = createModel() model1.load_weights('weights.hdf5') last_images = deque(maxlen=2) counter = 0 for filename in filenames[1:]: orig_i2 = cv2.imread(filename) filename = os.path.basename(filename) i2_gray = cv2.cvtColor(orig_i2, cv2.COLOR_BGR2GRAY) i2_with_rects = orig_i2.copy() cv2.putText(i2_with_rects, f'{filename}', (10, 400), font, .7, (0, 255, 255), 2, cv2.LINE_AA) d, tres, rects = get_diff_between_images(i1_gray, i2_gray) filtered_rects = [] for rect in rects: matched_img = orig_i2[rect[1]:rect[3], rect[0]:rect[2]] img = cv2.resize(matched_img, (32, 32)) predicted = model1.predict(np.array([img]))[0][0] print(predicted) if round(predicted): filtered_rects.append(rect) cv2.rectangle(i2_with_rects, rect[:2], rect[2:], (0, 255, 0), 1) else: cv2.rectangle(i2_with_rects, rect[:2], rect[2:], (255, 0, 0), 1) cv2.putText(i2_with_rects, str(round(predicted, 6)), (rect[0], rect[1] - 10), font, .7, (0, 255, 255), 2, cv2.LINE_AA) rects = filtered_rects output_filename = f'output/{filename}' if diff or threshold or reference: output_filename = f'output/{filename}-00.jpeg' print( '[Ref:', reference_filename, ']', filename, sorted([((x2 - x1) * (y2 - y1), (x2 - x1) / (y2 - y1)) for x1, y1, x2, y2 in rects])) cv2.imwrite(output_filename, i2_with_rects) if len(rects) or not only_matches: if threshold: cv2.imwrite(f'output/{filename}-0-threshold.jpeg', tres) if diff: cv2.imwrite(f'output/{filename}-0-diff.jpeg', d) if reference: cv2.imwrite(f'output/{filename}-0-reference.jpeg', i1) if not len(rects): reference_filename = filename i1 = orig_i2 i1_gray = i2_gray last_images.append(i2_gray)
def trainModel(options): inputReader = input_reader.InputReader(options) # Data placeholders # Image height is fixed while the system automatically adjusts the image width with tf.variable_scope('Model'): inputBatchImages = tf.placeholder(dtype=tf.float32, shape=[None, options.imageHeight, None, 3], name="inputBatchImages") inputBatchLabels = tf.placeholder(dtype=tf.float32, shape=[None, options.maxSequenceLength, inputReader.vocabSize], name="inputBatchLabels") inputKeepProbability = tf.placeholder(dtype=tf.float32, name="inputKeepProbability") scaledInputBatchImages = tf.scalar_mul((1.0/255), inputBatchImages) scaledInputBatchImages = tf.subtract(scaledInputBatchImages, 0.5) scaledInputBatchImages = tf.multiply(scaledInputBatchImages, 2.0) predictions = model.createModel(scaledInputBatchImages, maximumSeqLength=options.maxSequenceLength, isTrain=options.trainModel, imageHeight=options.imageHeight, networkOutputStride=options.networkStride, numLayersRNN=options.numLayersRNN, attentionSize=options.attentionSize): # Create list of vars to restore before train op variables_to_restore = slim.get_variables_to_restore(include=["InceptionResnetV2"]) with tf.name_scope('Loss'): # Define loss weights = tf.to_float(tf.not_equal(train_output[:, :-1], 1)) sequence_loss = tf.contrib.seq2seq.sequence_loss(predictions, inputBatchLabels, weights=weights) tf.losses.add_loss(sequence_loss) # tf.losses.add_loss(cross_entropy_loss_aux_logits) loss = tf.reduce_mean(tf.losses.get_losses()) with tf.name_scope('Accuracy'): correct_predictions = tf.equal(tf.argmax(end_points['Predictions'], 1), tf.argmax(inputBatchLabels, 1)) accuracy = tf.reduce_mean(tf.cast(correct_predictions, tf.float32), name='accuracy') with tf.name_scope('Optimizer'): # Define Optimizer optimizer = tf.train.AdamOptimizer(learning_rate=options.learningRate) # Op to calculate every variable gradient gradients = tf.gradients(loss, tf.trainable_variables()) gradients = list(zip(gradients, tf.trainable_variables())) # Op to update all variables according to their gradient applyGradients = optimizer.apply_gradients(grads_and_vars=gradients) # Initializing the variables init = tf.global_variables_initializer() init_local = tf.local_variables_initializer() if options.tensorboardVisualization: # Create a summary to monitor cost tensor tf.summary.scalar("loss", loss) # Create summaries to visualize weights for var in tf.trainable_variables(): tf.summary.histogram(var.name, var) # Summarize all gradients for grad, var in gradients: tf.summary.histogram(var.name + '/gradient', grad) # Merge all summaries into a single op mergedSummaryOp = tf.summary.merge_all() # 'Saver' op to save and restore all the variables saver = tf.train.Saver() bestLoss = 1e9 step = 1 # Train model if options.trainModel: with tf.Session() as sess: # Initialize all variables sess.run(init) sess.run(init_local) if options.startTrainingFromScratch: print ("Removing previous checkpoints and logs") os.system("rm -rf " + options.logsDir) os.system("rm -rf " + options.modelDir) os.system("mkdir " + options.modelDir) # Load the pre-trained Inception ResNet v2 model restorer = tf.train.Saver(variables_to_restore) restorer.restore(sess, inc_res_v2_checkpoint_file) # Restore checkpoint else: print ("Restoring from checkpoint") saver = tf.train.import_meta_graph(options.modelDir + options.modelName + ".meta") saver.restore(sess, options.modelDir + options.modelName) if options.tensorboardVisualization: # Op for writing logs to Tensorboard summaryWriter = tf.summary.FileWriter(options.logsDir, graph=tf.get_default_graph()) print ("Starting network training") try: # Keep training until reach max iterations while True: batchImagesTrain, batchLabelsTrain = inputReader.getTrainBatch() # print ("Batch images shape: %s, Batch labels shape: %s" % (batchImagesTrain.shape, batchLabelsTrain.shape)) # If training iterations completed if batchImagesTrain is None: print ("Training completed") break # Run optimization op (backprop) if options.tensorboardVisualization: [trainLoss, currentAcc, _, summary] = sess.run([loss, accuracy, applyGradients, mergedSummaryOp], feed_dict={inputBatchImages: batchImagesTrain, inputBatchLabels: batchLabelsTrain, inputKeepProbability: options.neuronAliveProbability}) # Write logs at every iteration summaryWriter.add_summary(summary, step) else: [trainLoss, currentAcc, _] = sess.run([loss, accuracy, applyGradients], feed_dict={inputBatchImages: batchImagesTrain, inputBatchLabels: batchLabelsTrain, inputKeepProbability: options.neuronAliveProbability}) print ("Iteration: %d, Minibatch Loss: %f, Accuracy: %f" % (step, trainLoss, currentAcc * 100)) step += 1 if step % options.saveStep == 0: # Save model weights to disk saver.save(sess, options.modelDir + options.modelName) print ("Model saved: %s" % (options.modelDir + options.modelName)) #Check the accuracy on test data if step % options.evaluateStep == 0: # Report loss on test data batchImagesTest, batchLabelsTest = inputReader.getTestBatch() [testLoss, testAcc] = sess.run([loss, accuracy], feed_dict={inputBatchImages: batchImagesTest, inputBatchLabels: batchLabelsTest, inputKeepProbability: 1.0}) print ("Test loss: %f, Test Accuracy: %f" % (testLoss, testAcc)) # #Check the accuracy on test data # if step % options.saveStepBest == 0: # # Report loss on test data # batchImagesTest, batchLabelsTest = inputReader.getTestBatch() # [testLoss] = sess.run([loss], feed_dict={inputBatchImages: batchImagesTest, inputBatchLabels: batchLabelsTest, inputKeepProbability: 1.0}) # print ("Test loss: %f" % testLoss) # # If its the best loss achieved so far, save the model # if testLoss < bestLoss: # bestLoss = testLoss # # bestModelSaver.save(sess, best_checkpoint_dir + 'checkpoint.data') # bestModelSaver.save(sess, checkpointPrefix, global_step=0, latest_filename=checkpointStateName) # print ("Best model saved in file: %s" % checkpointPrefix) # else: # print ("Previous best accuracy: %f" % bestLoss) except KeyboardInterrupt: print("Process interrupted by user") # Save the model and exit # Save final model weights to disk saver.save(sess, options.modelDir + options.modelName) print ("Model saved: %s" % (options.modelDir + options.modelName)) # Report loss on test data batchImagesTest, batchLabelsTest = inputReader.getTestBatch() testLoss = sess.run(loss, feed_dict={inputBatchImages: batchImagesTest, inputBatchLabels: batchLabelsTest, inputKeepProbability: 1.0}) print ("Test loss (current): %f" % testLoss) print ("Optimization Finished!") # Test model if options.testModel: print ("Testing saved model") os.system("rm -rf " + options.imagesOutputDirectory) os.system("mkdir " + options.imagesOutputDirectory) # Now we make sure the variable is now a constant, and that the graph still produces the expected result. with tf.Session() as session: saver = tf.train.import_meta_graph(options.modelDir + options.modelName + ".meta") saver.restore(session, options.modelDir + options.modelName) # Get reference to placeholders predictionsNode = session.graph.get_tensor_by_name("Predictions:0") accuracyNode = session.graph.get_tensor_by_name("Accuracy/accuracy:0") inputBatchImages = session.graph.get_tensor_by_name("Model/inputBatchImages:0") inputBatchLabels = session.graph.get_tensor_by_name("Model/inputBatchLabels:0") inputKeepProbability = session.graph.get_tensor_by_name("Model/inputKeepProbability:0") inputReader.resetTestBatchIndex() accumulatedAccuracy = 0.0 numBatches = 0 fileNames = [] predictedLabels = [] while True: batchImagesTest, batchLabelsTest = inputReader.getTestBatch() files = inputReader.getFileNames(isTrain=False) if batchLabelsTest is None: break [predictions, accuracy] = session.run([predictionsNode, accuracyNode], feed_dict={inputBatchImages: batchImagesTest, inputBatchLabels: batchLabelsTest, inputKeepProbability: 1.0}) # print ('Current test batch accuracy: %f' % (accuracy)) accumulatedAccuracy += accuracy fileNames = fileNames + files predictedLabels = predictedLabels + np.argmax(predictions, axis=1).tolist() numBatches += 1 # Save image results inputReader.saveLastBatchResults(batchImagesTest, predictedLabels, isTrain=False) if numBatches == 20: break with open('results.npy', 'wb') as fp: pkl.dump(fileNames, fp) pkl.dump(predictedLabels, fp) with open("output.txt", "w") as file: for i in range(len(fileNames)): file.write(fileNames[i] + " " + str(predictedLabels[i]) + "\n") accumulatedAccuracy = accumulatedAccuracy / numBatches print ('Cummulative test set accuracy: %f' % (accumulatedAccuracy * 100)) print ("Model tested")
print("| Slice size: {}".format(sliceSize)) print("--------------------------") if "slice" in args.mode: createSlicesFromAudio() sys.exit() #List genres genres = os.listdir(slicesPath) genres = [ filename for filename in genres if os.path.isdir(slicesPath + filename) ] nbClasses = len(genres) #Create model model = createModel(nbClasses, sliceSize) if "train" in args.mode: #Create or load new dataset train_X, train_y, validation_X, validation_y = getDataset(filesPerGenre, genres, sliceSize, validationRatio, testRatio, mode="train") #Define run id for graphs run_id = "MusicGenres - " + str(batchSize) + " " + ''.join( random.SystemRandom().choice(string.ascii_uppercase) for _ in range(10))
import cv2 import glob import numpy as np import random from model import createModel random.seed(128) model1 = createModel() model1.load_weights('weights.hdf5') for fname in sorted(glob.glob('matches/non-pidgeon-32/*')): i = cv2.imread(fname) pred = model1.predict(np.array([i]))[0][0] if round(pred): print(fname, pred)
import tensorflow as tf import math import random from config import config from model import createModel from data import Genome genome = Genome() model = createModel(output_nodes=len(genome.annotation_fields)) max_frames = config["genome"]["max-scaffolds-per-batch"] # Run through genome epoch = int() while True: if epoch >= config["training"]["epoch-limit"]: break print("Running epoch #{}".format(str(epoch))) for contig in genome.contigs: print("################ Running framed contig: {} ################". format(contig)) size = random.randint(config["genome"]["min-scaffold-length"], config["genome"]["max-scaffold-length"]) frame_limit = math.floor(config["genome"]["frame-adjustment-ratio"] *
slot_labels = tf.placeholder(tf.int32, [None, None], name='slots') # [batch, input_sequence_length] slot_weights = tf.placeholder( tf.float32, [None, None], name='slot_weights') # [batch, input_sequence_length] intent_label = tf.placeholder(tf.int32, [None], name='intent') # [batch] use_batch_crossent = True with tf.variable_scope('model'): print("create train model") training_outputs = createModel( input_data, len(in_vocab['vocab']), sequence_length, len(slot_vocab['vocab']), len(intent_vocab['vocab']), remove_slot_attn, add_final_state_to_intent, use_crf=arg.use_crf, layer_size=arg.layer_size, use_batch_crossent=use_batch_crossent) # layer_size:64 # slot_output_logits:[batch * input_sequence_length, slot_size] # slot_output_logits_crf or use_batch_crossent:[batch, input_sequence_length, slot_size] slot_output_logits = training_outputs[0] # intent:[batch, intent_size] intent_output_logit = training_outputs[1] with tf.variable_scope('slot_loss'): if arg.use_crf: """
train_loader = torch.utils.data.ConcatDataset([train_loader, val_loader]) train_loader = torch.utils.data.DataLoader(train_loader, batch_size=args.batch_size, shuffle=True, num_workers=1) val_loader = torch.utils.data.DataLoader(val_loader, batch_size=args.batch_size, shuffle=False, num_workers=1) else: assert False # Neural network and optimizer # We define neural net in model.py so that it can be reused by the evaluate.py script from model import createModel model = createModel() if use_cuda: print('Using GPU') model.cuda() else: print('Using CPU') optimizer = optim.Adam(model.parameters(), weight_decay=0) def train(epoch): model.train() for batch_idx, (data, target) in enumerate(train_loader): if use_cuda: data, target = data.cuda(), target.cuda() optimizer.zero_grad()
def main(): # Create Parser parser = argparse.ArgumentParser(description='Pytorch MNIST LAB1') parser.add_argument("--batch-Size", type=int, default=64, metavar='N', help='input batch size for training (default: 64)') parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--epochs', type=int, default=5, metavar='N', help='number of epochs to train (default: 5)') parser.add_argument('--neural-network', type=str, default='MLP', metavar='M', help='NN type (MLP | Linear)') parser.add_argument('--loss', type=str, default='NLL', metavar='M', help='NN type (Margin | NLL)') parser.add_argument('--optim-Method', type=str, default='ASGD', metavar='M', help='NN type (SGD | ASGD | LBFGS |)') parser.add_argument('--lr', type=float, default=0.01, metavar='LR', help='learning rate (default: 0.01)') parser.add_argument('--weight-decay', type=float, default=0.001, metavar='LR', help='weight decay (default: 0.001)') parser.add_argument('--momentum', type=float, default=0.5, metavar='M', help='SGD momentum (default: 0.5)') parser.add_argument('--max-iter', type=float, default=2, metavar='M', help='CG and LBFGS max iterations (default: 2)') parser.add_argument('--t0', type=float, default=1, metavar='LR', help='t0 for ASGD (default: 1)') arguments = parser.parse_args() print(arguments) # Get Batch Size # USE CUDA use_cuda = torch.cuda.is_available() device = torch.device("cuda:0") cudnn.benchmark = True # device = "cpu" # Parameters params = { 'shuffle': True, 'pin_memory': True, 'num_workers': 4 } # Exception because of bad multiworker handling !! FIXED IN NEW PYTORCH VERSION # Download dataset # torchvision.transforms.Normalize(0.5,0.5) datasetPath = r"..\Datasets" Ttransform = torchvision.transforms.Compose( [ torchvision.transforms.ToTensor(), torchvision.transforms.Normalize((0.1307, ), (0.3081, )) ] ) # Needs the 0.5, not 0,5 to make the object iterable !! Try with 0.5, Normalization to see the results testData = torch.utils.data.DataLoader( torchvision.datasets.MNIST(datasetPath, download=True, transform=Ttransform, train=False), **params, batch_size=arguments.test_batch_size) trainData = torch.utils.data.DataLoader(torchvision.datasets.MNIST( datasetPath, download=True, transform=Ttransform, train=True), **params, batch_size=arguments.batch_Size) # Start creating the model from loss import createLoss from model import createModel from train import train from test import test model = createModel(arguments) criterion = createLoss(arguments) train(arguments, trainData, device, criterion, model) test(model, criterion, testData)
def main(): # # Dataloader creation and test # img_paths = glob.glob(DATA_PATH) # print("len(img_paths):", len(img_paths)) # random.shuffle(img_paths) train_test_split = 0.8 # X_train_paths = img_paths[:int(train_test_split * len(img_paths))] # X_test_paths = img_paths[int(train_test_split * len(img_paths)):] X_train_path = DATA_PATH + "/train" X_test_path = DATA_PATH + "/test" dims = (448, 448, 3) # Loading Data # X_train = CustomDataGenerator(X_train_paths, batch_size=32, dim=dims) # X_test = CustomDataGenerator(X_train_paths, batch_size=32, dim=dims) train_generator = ImageDataGenerator(horizontal_flip=True, vertical_flip=True, validation_split=(1 - train_test_split)) X_train = train_generator.flow_from_directory(X_train_path, target_size=(448, 448), class_mode="input", batch_size=32, seed=324, subset='training') X_valid = train_generator.flow_from_directory(X_train_path, target_size=(448, 448), class_mode="input", batch_size=32, seed=324, subset='validation') X_test = ImageDataGenerator().flow_from_directory(X_test_path, target_size=(448, 448), class_mode="input", batch_size=32, seed=324) sample_train = next(X_train) print("sample train:", sample_train[0].shape, sample_train[1].shape) for i, img in enumerate(sample_train[0][0][:10]): print(np.sum(np.isnan(img)), img.min(), img.max()) sample_test = next(X_test) print("sample test:", sample_test[0].shape, sample_test[1].shape) # # RESHAPE IMAGES TO THE DESIRED SIZE # X_train_reshaped = X_train[0] # print(X_train_reshaped[0].shape, X_train_reshaped[1].shape) # X_test_reshaped = X_test[0] # print(X_test_reshaped[0].shape, X_test_reshaped[1].shape) # # More efficient data fetch pipeline # AUTOTUNE = tensorflow.data.experimental.AUTOTUNE # train_dataset = tf.data.Dataset.from_generator(generator=X_train, output_types=(tf.float32, tf.float32)) # test_dataset = tf.data.Dataset.from_generator(generator=X_test, output_types=(tf.float32, tf.float32)) # # train_dataset = tf.data.Dataset.from_tensor_slices((X_train_reshaped, X_train_reshaped)) # # test_dataset = tf.data.Dataset.from_tensor_slices((X_test_reshaped, X_test_reshaped)) # train_dataset = train_dataset.map(utils.convert, num_parallel_calls=AUTOTUNE) # train_dataset = train_dataset.cache().shuffle(buffer_size=3*BATCH_SIZE) # train_dataset = train_dataset.batch(BATCH_SIZE) # train_dataset = train_dataset.repeat() # train_dataset = train_dataset.prefetch(buffer_size=AUTOTUNE) # test_dataset = test_dataset.map(utils.convert, num_parallel_calls=AUTOTUNE) # test_dataset = test_dataset.cache() # test_dataset = train_dataset.prefetch(buffer_size=AUTOTUNE) # ARCHITECTURE complete_model = model.createModel(dims) print(complete_model.summary()) complete_model.compile(optimizer='rmsprop', loss='mse') image = np.expand_dims(X_test[0][0][0], 0) # image = X_test_reshaped[0:10] print(image.shape) # Define the Activation Visualization callback output_dir = TENSORBOARD_LOG_DIR callbacks = [ ActivationsVisualizationCallback( validation_data=(image, ), layers_name=['conv2d_8'], output_dir=output_dir, ), ] # tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir="./tf_callback") tensorboard_callback = tf.keras.callbacks.TensorBoard( log_dir=TENSORBOARD_LOG_DIR) complete_model.fit( X_train, epochs=NUM_EPOCHS, steps_per_epoch=X_train.samples // BATCH_SIZE, # validation_split=0.2, validation_data=X_valid, validation_steps=X_valid.samples / BATCH_SIZE, callbacks=[callbacks, tensorboard_callback, WandbCallback()], use_multiprocessing=True) complete_model.save(OUTPUT_MODEL_PATH) # ## Model Testing # Define the Activation Visualization explainer # index = np.random.randint(0, len(X_test_reshaped)) # image = input_test[index].reshape((1, 32, 32, 3)) # image = np.expand_dims(X_test_reshaped[index],0) image = X_test[0][0][:10] # image = X_test_reshaped[:10] label = image print('val:', image.shape) data = ([image]) explainer = ExtractActivations() layers_of_interest = [ 'conv2d_1', 'conv2d_2', 'conv2d_3', 'conv2d_4', 'conv2d_5', 'conv2d_6', 'conv2d_7', 'conv2d_8', 'conv2d_transpose', 'conv2d_transpose_1', 'conv2d_transpose_2', 'conv2d_transpose_3', 'conv2d_9', 'conv2d_transpose_4' ] for layer in layers_of_interest: grid = explainer.explain(validation_data=data, model=complete_model, layers_name=[layer]) print(grid.shape) explainer.save(grid, ACTIVATION_IMG_PATH, '%s.png' % (layer))
def batch_lab( batch_size, data_generator, data): # Does basically nothing, but just to help with later tasks for batch in data_generator.flow(data, batch_size=batch_size): batch = resize(batch, (batch_size, *dims)) # print(np.max(batch),np.min(batch)) yield batch, batch # # Model creation # In[7]: complete_model = model.createModel(dims) print(complete_model.summary()) complete_model.compile(optimizer='rmsprop', loss='mse') image = np.expand_dims(X_test_reshaped[0], 0) # image = X_test_reshaped[0:10] print(image.shape) # Define the Activation Visualization callback output_dir = TENSORBOARD_LOG_DIR callbacks = [ ActivationsVisualizationCallback( validation_data=(image, ), layers_name=['conv2d_8'], output_dir=output_dir,
def main(): dims = (448, 448, 3) # Dataloader creation and test img_paths = glob.glob(DATA_PATH) print("len(img_paths):", len(img_paths)) train_split = 0.6 valid_split = 0.2 test_split = 0.2 X_train_paths = img_paths[:int(train_split * len(img_paths))] X_valid_paths = img_paths[int(train_split * len(img_paths)):int((train_split + valid_split) * len(img_paths))] X_test_paths = img_paths[len(img_paths) - int(test_split * len(img_paths)):] # More efficient data fetch pipeline AUTOTUNE = tensorflow.data.experimental.AUTOTUNE # X_train = customGenerator(X_train_paths, dims) # X_test = customGenerator(X_test_paths, dims) train_dataset = tf.data.Dataset.from_generator(generator=customGenerator, output_types=(np.float32, np.float32), output_shapes=(dims, dims), args=[X_train_paths, dims, "tif"]) output = list(train_dataset.take(1).as_numpy_iterator()) print("@#@#@#@#@#@#@ 1") print("train_dataset:", train_dataset) print("len(output):", len(output)) print("len(output[0]):", len(output[0])) x,y = output[0] print("Printing the output:", x.shape, y.shape) print("x:", x.min(), x.max()) print("y:", y.min(), y.max()) print(x.shape, y.shape) valid_dataset = tf.data.Dataset.from_generator(generator=customGenerator, output_types=(np.float32, np.float32), output_shapes=(dims, dims), args=[X_valid_paths, dims, "tif"]) test_dataset = tf.data.Dataset.from_generator(generator=customGenerator, output_types=(tf.float32, tf.float32), args=[X_test_paths, dims, "tif"]) # train_dataset = tf.data.Dataset.from_tensor_slices((X_train_reshaped, X_train_reshaped)) # test_dataset = tf.data.Dataset.from_tensor_slices((X_test_reshaped, X_test_reshaped)) train_dataset = train_dataset.map(utils.convert, num_parallel_calls=AUTOTUNE) train_dataset = train_dataset.cache().shuffle(buffer_size=3*BATCH_SIZE) train_dataset = train_dataset.batch(BATCH_SIZE) train_dataset = train_dataset.repeat() train_dataset = train_dataset.prefetch(buffer_size=AUTOTUNE) valid_dataset = valid_dataset.map(utils.convert, num_parallel_calls=AUTOTUNE) valid_dataset = valid_dataset.cache().shuffle(buffer_size=3*BATCH_SIZE) valid_dataset = valid_dataset.batch(BATCH_SIZE) valid_dataset = valid_dataset.repeat() valid_dataset = valid_dataset.prefetch(buffer_size=AUTOTUNE) test_dataset = test_dataset.map(utils.convert, num_parallel_calls=AUTOTUNE) test_dataset = test_dataset.cache() test_dataset = train_dataset.prefetch(buffer_size=AUTOTUNE) # print("train_dataset:", train_dataset) # print(train_dataset[0]) output = list(train_dataset.take(1).as_numpy_iterator()) print("@#@#@#@#@#@#@ 2") print("train_dataset:", train_dataset) print("len(output):", len(output)) print("len(output[0]):", len(output[0])) x,y = output[0] print("Printing the output:", x.shape, y.shape) print("x:", x.min(), x.max()) print("y:", y.min(), y.max()) print(x.shape, y.shape) print("---------------------------------") # ARCHITECTURE complete_model = model.createModel(dims) print(complete_model.summary()) complete_model.compile(optimizer='rmsprop', loss='mse') image = resize(plt.imread(X_test_paths[0])[:,:,:3], dims) print("Activation visualization image shape orig:", image.shape) image = np.expand_dims(image, 0) print("Activation visualization image shape extended:", image.shape) print("image:", image.min(), image.max()) # image = X_test_reshaped[0:10] # print(image.shape) # Define the Activation Visualization callback output_dir = TENSORBOARD_LOG_DIR callbacks = [ ActivationsVisualizationCallback( validation_data=(image,), layers_name=['conv2d_8'], output_dir=output_dir, ), ] # tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir="./tf_callback") tensorboard_callback = tf.keras.callbacks.TensorBoard(log_dir=TENSORBOARD_LOG_DIR) complete_model.fit(train_dataset, epochs=NUM_EPOCHS, steps_per_epoch=len(X_train_paths) // BATCH_SIZE, # validation_split=0.2, validation_data=valid_dataset, validation_steps=len(X_valid_paths) // BATCH_SIZE, callbacks=[callbacks, tensorboard_callback, WandbCallback()], # use_multiprocessing=True ) complete_model.save(OUTPUT_MODEL_PATH) # sys.exit(0) # ## Model Testing # Define the Activation Visualization explainer # index = np.random.randint(0, len(X_test_reshaped)) # image = input_test[index].reshape((1, 32, 32, 3)) # image = np.expand_dims(X_test_reshaped[index],0) # image = X_test[0][0][:10] image = np.array([resize(plt.imread(test_img_path)[:,:,:3], dims) for test_img_path in X_test_paths[:10]]) # image = X_test_reshaped[:10] label = image print('val:', image.shape) data = ([image]) explainer = ExtractActivations() layers_of_interest = ['conv2d_1', 'conv2d_2', 'conv2d_3', 'conv2d_4', 'conv2d_5', 'conv2d_6', 'conv2d_7', 'conv2d_8', 'conv2d_transpose', 'conv2d_transpose_1', 'conv2d_transpose_2', 'conv2d_transpose_3', 'conv2d_9', 'conv2d_transpose_4'] for layer in layers_of_interest: grid = explainer.explain(validation_data=data, model=complete_model, layers_name=[layer]) print(grid.shape) explainer.save(grid, ACTIVATION_IMG_PATH, '%s.png' % (layer))
print("| Test ratio: {}".format(testRatio)) print("| Slices per genre: {}".format(filesPerGenre)) print("| Slice size: {}".format(sliceSize)) print("--------------------------") if "slice" in args.mode: createSlicesFromAudio() sys.exit() #List genres genres = os.listdir(slicesPath) genres = [filename for filename in genres if os.path.isdir(slicesPath+filename)] nbClasses = len(genres) #Create model model = createModel(nbClasses, sliceSize) if "train" in args.mode: #Create or load new dataset train_X, train_y, validation_X, validation_y = getDataset(filesPerGenre, genres, sliceSize, validationRatio, testRatio, mode="train") #Define run id for graphs run_id = "MusicGenres - "+str(batchSize)+" "+''.join(random.SystemRandom().choice(string.ascii_uppercase) for _ in range(10)) #Train the model print("[+] Training the model...") model.fit(train_X, train_y, n_epoch=nbEpoch, batch_size=batchSize, shuffle=True, validation_set=(validation_X, validation_y), snapshot_step=100, show_metric=True, run_id=run_id) print(" Model trained! ✅") #Save trained model