def run_experiment(self, repeats=10): # load data Preprocesser(self.length).preprocess() Extractor(self.length).extract() trainX, trainy, testX, testy = self.load_dataset() # repeat experiment scores = list() for r in range(repeats): score = self.evaluate_model(trainX, trainy, testX, testy) score = score * 100.0 print('>#%d: %.3f' % (r + 1, score)) scores.append(score) # summarize results return self.summarize_results(scores)
def main(): with open(config.configFile(), "a+") as outFile: json.dump(vars(config), outFile) # set gpus if config.gpus != "": config.gpusNum = len(config.gpus.split(",")) os.environ["CUDA_VISIBLE_DEVICES"] = config.gpus tf.logging.set_verbosity(tf.logging.ERROR) # process data print(bold("Preprocess data...")) start = time.time() preprocessor = Preprocesser() data, embeddings, answerDict = preprocessor.preprocessData() print("took {} seconds".format( bcolored("{:.2f}".format(time.time() - start), "blue"))) # build model print(bold("Building model...")) start = time.time() model = MACnet(embeddings, answerDict, raw=config.raw_image) print("took {} seconds".format( bcolored("{:.2f}".format(time.time() - start), "blue"))) # initializer init = tf.global_variables_initializer() # savers savers = setSavers(model) saver, emaSaver, resnet_saver = \ savers["saver"], savers["emaSaver"], savers['resnet_saver'] # sessionConfig sessionConfig = setSession() with tf.Session(config=sessionConfig) as sess: # ensure no more ops are added after model is built sess.graph.finalize() # restore / initialize weights, initialize epoch variable epoch = loadWeights(sess, saver, init, resnet_saver) if config.train: start0 = time.time() bestEpoch = epoch bestRes = None prevRes = None # epoch in [restored + 1, epochs] for epoch in range(config.restoreEpoch + 1, config.epochs + 1): print(bcolored("Training epoch {}...".format(epoch), "green")) start = time.time() # train # calle = lambda: model.runEpoch(), collectRuntimeStats, writer trainingData, alterData = chooseTrainingData(data) trainRes = runEpoch(sess, model, trainingData, train=True, epoch=epoch, saver=saver, alterData=alterData, raw=config.raw_image) # save weights saver.save(sess, config.weightsFile(epoch)) if config.saveSubset: subsetSaver.save(sess, config.subsetWeightsFile(epoch)) # load EMA weights if config.useEMA: print(bold("Restoring EMA weights")) emaSaver.restore(sess, config.weightsFile(epoch)) # evaluation evalRes = runEvaluation(sess, model, data["main"], epoch, raw=config.raw_image) extraEvalRes = runEvaluation(sess, model, data["extra"], epoch, evalTrain=not config.extraVal, raw=config.raw_image) # restore standard weights if config.useEMA: print(bold("Restoring standard weights")) saver.restore(sess, config.weightsFile(epoch)) print("") epochTime = time.time() - start print("took {:.2f} seconds".format(epochTime)) # print results printDatasetResults(trainRes, evalRes, extraEvalRes) # stores predictions and optionally attention maps if config.getPreds: print(bcolored("Writing predictions...", "white")) writePreds(preprocessor, evalRes, extraEvalRes) logRecord(epoch, epochTime, config.lr, trainRes, evalRes, extraEvalRes) # update best result # compute curr and prior currRes = { "train": trainRes, "val": evalRes["val"], 'test': evalRes['test'] } curr = {"res": currRes, "epoch": epoch} if bestRes is None or better(currRes, bestRes): bestRes = currRes bestEpoch = epoch prior = { "best": { "res": bestRes, "epoch": bestEpoch }, "prev": { "res": prevRes, "epoch": epoch - 1 } } # lr reducing if config.lrReduce: if not improveEnough(curr, prior, config.lr): config.lr *= config.lrDecayRate print( colored("Reducing LR to {}".format(config.lr), "red")) # early stopping if config.earlyStopping > 0: if epoch - bestEpoch > config.earlyStopping: break # update previous result prevRes = currRes # reduce epoch back to the last one we trained on epoch -= 1 print("Training took {:.2f} seconds ({:} epochs)".format( time.time() - start0, epoch - config.restoreEpoch)) if config.finalTest: print("Testing on epoch {}...".format(epoch)) start = time.time() if epoch > 0: if config.useEMA: emaSaver.restore(sess, config.weightsFile(epoch)) else: saver.restore(sess, config.weightsFile(epoch)) evalRes = runEvaluation(sess, model, data["main"], epoch, evalTest=True, raw=config.raw_image) extraEvalRes = runEvaluation(sess, model, data["extra"], epoch, evalTrain=not config.extraVal, evalTest=True, raw=config.raw_image) print("took {:.2f} seconds".format(time.time() - start)) printDatasetResults(None, evalRes, extraEvalRes) print("Writing predictions...") writePreds(preprocessor, evalRes, extraEvalRes) print(bcolored("Done!", "white"))
from classification_lstm import lstmClassifier from preprocess import Preprocesser import matplotlib.pyplot as plt acc_lstm = [] STEP = 10 START = 30 END = 500 for i in [10, 100, 500, 750, 1000]: print("The length is ", i) Preprocesser(i).preprocess() #Extractor(i).extract() acc_lstm.append(lstmClassifier(i).run_experiment()) plt.plot([10, 100, 500, 750, 1000], acc_lstm, color="red", label="LSTM") plt.legend() plt.savefig('plot_lstm', dpi=600) #plt.savefig()将输出图形存储为文件,默认为png格式,可以通过dpi修改输出质量 plt.show()
def main(): # Access the CLODUAMQP_URL environment variable and parse it (fallback to localhost) url = os.environ.get('CLOUDAMQP_URL') params = pika.URLParameters(url) connection = pika.BlockingConnection(params) channel = connection.channel() channel.queue_declare(queue='rpc_queue') ################################ input ################################ global cap if config.input_video == "camera": # camera input cap = cv2.VideoCapture(0) H, W = 480, 640 cap.set(cv2.CAP_PROP_FRAME_WIDTH, W) cap.set(cv2.CAP_PROP_FRAME_HEIGHT, H) else: # static image cap = config.input_video ################################ feature extraction in PyTorch ################################ global fextract_model fextract_model = build_model() ################################ MAC model in TF ################################ global preprocessor, sess, mac_model with open(config.configFile(), "a+") as outFile: json.dump(vars(config), outFile) # set gpus if config.gpus != "": config.gpusNum = len(config.gpus.split(",")) os.environ["CUDA_VISIBLE_DEVICES"] = config.gpus tf.logging.set_verbosity(tf.logging.ERROR) assert config.batchSize == 1, 'Error: always batch size of one' # process data print(bold("Preprocess data...")) start = time.time() preprocessor = Preprocesser() data, embeddings, answerDict = preprocessor.preprocessData(hasTrain=False, hasDebug=True) print("took {} seconds".format( bcolored("{:.2f}".format(time.time() - start), "blue"))) # build model print(bold("Building model...")) start = time.time() mac_model = MACnet(embeddings, answerDict) print("took {} seconds".format( bcolored("{:.2f}".format(time.time() - start), "blue"))) # initializer init = tf.global_variables_initializer() # savers savers = setSavers(mac_model) saver, emaSaver = savers["saver"], savers["emaSaver"] # sessionConfig sessionConfig = setSession() sess = tf.Session(config=sessionConfig) # ensure no more ops are added after model is built sess.graph.finalize() # restore / initialize weights, initialize epoch variable epoch = loadWeights(sess, saver, init) print("Testing on epoch {}...".format(epoch)) if epoch > 0: if config.useEMA: emaSaver.restore(sess, config.weightsFile(epoch)) else: saver.restore(sess, config.weightsFile(epoch)) ################################ RPC Queue ################################ channel.basic_qos(prefetch_count=1) channel.basic_consume(queue='rpc_queue', on_message_callback=on_request) print(" [x] Awaiting RPC requests") try: channel.start_consuming() except KeyboardInterrupt: channel.stop_consuming() connection.close() sess.close() if config.input_video == "camera": cap.release()
def main(): with open(config.configFile(), "a+") as outFile: json.dump(vars(config), outFile) tf.set_random_seed(config.tfseed) # set gpus if config.gpus != "": config.gpusNum = len(config.gpus.split(",")) os.environ["CUDA_VISIBLE_DEVICES"] = config.gpus tf.logging.set_verbosity(tf.logging.ERROR) # process data print(bold("Preprocess data...")) start = time.time() preprocessor = Preprocesser() data, embeddings, answerDict, questionDict = preprocessor.preprocessData() print("took {} seconds".format( bcolored("{:.2f}".format(time.time() - start), "blue"))) nextElement = None dataOps = None # build model print(bold("Building model...")) start = time.time() model = MACnet(embeddings, answerDict, questionDict, nextElement) print("took {} seconds".format( bcolored("{:.2f}".format(time.time() - start), "blue"))) # initializer init = tf.global_variables_initializer() # savers savers = setSavers(model) saver, emaSaver = savers["saver"], savers["emaSaver"] # sessionConfig sessionConfig = setSession() with tf.Session(config=sessionConfig) as sess: # ensure no more ops are added after model is built sess.graph.finalize() # restore / initialize weights, initialize epoch variable epoch = loadWeights(sess, saver, init) trainRes, evalRes = None, None if config.train: start0 = time.time() bestEpoch = epoch bestRes = None prevRes = None # epoch in [restored + 1, epochs] for epoch in range(config.restoreEpoch + 1, config.epochs + 1): print(bcolored("Training epoch {}...".format(epoch), "green")) start = time.time() # train # calle = lambda: model.runEpoch(), collectRuntimeStats, writer trainingData, alterData = chooseTrainingData(data) trainRes = runEpoch( sess, model, trainingData, dataOps, train=True, epoch=epoch, saver=saver, alterData=alterData, maxAcc=trainRes["maxAcc"] if trainRes else 0.0, minLoss=trainRes["minLoss"] if trainRes else float("inf"), ) # save weights saver.save(sess, config.weightsFile(epoch)) if config.saveSubset: subsetSaver.save(sess, config.subsetWeightsFile(epoch)) # load EMA weights if config.useEMA: print(bold("Restoring EMA weights")) emaSaver.restore(sess, config.weightsFile(epoch)) # evaluation getPreds = config.getPreds or (config.analysisType != "") evalRes = runEvaluation(sess, model, data["main"], dataOps, epoch, getPreds=getPreds, prevRes=evalRes) extraEvalRes = runEvaluation(sess, model, data["extra"], dataOps, epoch, evalTrain=not config.extraVal, getPreds=getPreds) # restore standard weights if config.useEMA: print(bold("Restoring standard weights")) saver.restore(sess, config.weightsFile(epoch)) print("") epochTime = time.time() - start print("took {:.2f} seconds".format(epochTime)) # print results printDatasetResults(trainRes, evalRes, extraEvalRes) # stores predictions and optionally attention maps if config.getPreds: print(bcolored("Writing predictions...", "white")) writePreds(preprocessor, evalRes, extraEvalRes) logRecord(epoch, epochTime, config.lr, trainRes, evalRes, extraEvalRes) # update best result # compute curr and prior currRes = {"train": trainRes, "val": evalRes["val"]} curr = {"res": currRes, "epoch": epoch} if bestRes is None or better(currRes, bestRes): bestRes = currRes bestEpoch = epoch prior = { "best": { "res": bestRes, "epoch": bestEpoch }, "prev": { "res": prevRes, "epoch": epoch - 1 } } # lr reducing if config.lrReduce: if not improveEnough(curr, prior, config.lr): config.lr *= config.lrDecayRate print( colored("Reducing LR to {}".format(config.lr), "red")) # early stopping if config.earlyStopping > 0: if epoch - bestEpoch > config.earlyStopping: break # update previous result prevRes = currRes # reduce epoch back to the last one we trained on epoch -= 1 print("Training took {:.2f} seconds ({:} epochs)".format( time.time() - start0, epoch - config.restoreEpoch)) if config.finalTest: print("Testing on epoch {}...".format(epoch)) start = time.time() if epoch > 0: if config.useEMA: emaSaver.restore(sess, config.weightsFile(epoch)) else: saver.restore(sess, config.weightsFile(epoch)) evalRes = runEvaluation(sess, model, data["main"], dataOps, epoch, evalTest=False, getPreds=True) extraEvalRes = runEvaluation(sess, model, data["extra"], dataOps, epoch, evalTrain=not config.extraVal, evalTest=False, getPreds=True) print("took {:.2f} seconds".format(time.time() - start)) printDatasetResults(trainRes, evalRes, extraEvalRes) print("Writing predictions...") writePreds(preprocessor, evalRes, extraEvalRes) if config.interactive: if epoch > 0: if config.useEMA: emaSaver.restore(sess, config.weightsFile(epoch)) else: saver.restore(sess, config.weightsFile(epoch)) tier = config.interactiveTier images = data["main"][tier]["images"] imgsInfoFilename = config.imgsInfoFile(tier) with open(imgsInfoFilename, "r") as file: imageIndex = json.load(file) openImageFiles(images) resInter = {"preds": []} while True: text = inp("Enter <imageId>_<question>\n") if len(text) == 0: break imageId, questionStr = text.split("_") imageInfo = imageIndex[imageId] imageId = { "group": tier, "id": imageId, "idx": imageInfo["idx"] } # int(imageId) question = preprocessor.encodeQuestionStr(questionStr) instance = { "questionStr": questionStr, "question": question, "answer": "yes", # Dummy answer "answerFreq": ["yes"], # Dummy answer "imageId": imageId, "tier": tier, "index": 0 } if config.imageObjects: instance["objectsNum"] = imageInfo["objectsNum"] print(instance) datum = preprocessor.vectorizeData([instance]) image = loadImageBatch(images, {"imageIds": [imageId]}) res = model.runBatch(sess, datum, image, train=False, getPreds=True, getAtt=True) resInter["preds"].append(instance) print(instance["prediction"]) if config.getPreds: print(bcolored("Writing predictions...", "white")) preprocessor.writePreds(resInter, "interactive".format()) closeImageFiles(images) print(bcolored("Done!", "white"))
#loadDatasetConfig["GQA"]() with open(config.configFile(), "a+") as outFile: json.dump(vars(config), outFile) # set gpus # if config.gpus != "": # config.gpusNum = len(config.gpus.split(",")) # os.environ["CUDA_VISIBLE_DEVICES"] = config.gpus tf.logging.set_verbosity(tf.logging.ERROR) # process data print(bold("Preprocess data...")) start = time.time() preprocessor = Preprocesser() data, embeddings, answerDict, questionDict = preprocessor.preprocessData() print("took {} seconds".format( bcolored("{:.2f}".format(time.time() - start), "blue"))) nextElement = None dataOps = None # build model print(bold("Building model...")) start = time.time() model = MACnet(embeddings, answerDict, questionDict, nextElement) print("took {} seconds".format( bcolored("{:.2f}".format(time.time() - start), "blue"))) # initializer
mg[0], forward, reverse)) mtools.divide_fq(mg[0], forward, reverse) mg = [forward, reverse] mg_name = mg[0].split('/')[-1].split('_R')[0] if mg_name not in mg_processed: #several MT samples might correspond to the same MG sample ''' Metagenomics Preprocess ''' if not args.no_preprocessing: mtools.timed_message('Preprocessing metagenomic reads') preprocesser = Preprocesser(files = mg, paired = 'PE' if args.sequencing_technology == 'paired' else 'SE', working_dir = args.output, data = 'dna', name = mg_name, threads = args.threads) if hasattr(args, 'quality_score'): setattr(preprocesser, 'quality_score', args.quality_score) preprocesser.run() mtools.task_is_finished(task = 'Preprocessing', file = monitorization_file, task_output = args.output + '/Preprocess') mg = [args.output + '/Preprocess/Trimmomatic/quality_trimmed_' + mg_name + '_' + fr + '_paired.fq' for fr in ['forward', 'reverse']] '''
def main(): with open(config.configFile(), "a+") as outFile: json.dump(vars(config), outFile) # set gpus if config.gpus != "": config.gpusNum = len(config.gpus.split(",")) os.environ["CUDA_VISIBLE_DEVICES"] = config.gpus tf.logging.set_verbosity(tf.logging.ERROR) assert config.batchSize == 1, 'Error: always batch size of one' # process data print(bold("Preprocess data...")) start = time.time() preprocessor = Preprocesser() data, embeddings, answerDict = preprocessor.preprocessData(hasTrain = False, hasDebug = True) print("took {} seconds".format(bcolored("{:.2f}".format(time.time() - start), "blue"))) # build model print(bold("Building model...")) start = time.time() model = MACnet(embeddings, answerDict) print("took {} seconds".format(bcolored("{:.2f}".format(time.time() - start), "blue"))) # initializer init = tf.global_variables_initializer() # savers savers = setSavers(model) saver, emaSaver = savers["saver"], savers["emaSaver"] # sessionConfig sessionConfig = setSession() with tf.Session(config = sessionConfig) as sess: # ensure no more ops are added after model is built sess.graph.finalize() # restore / initialize weights, initialize epoch variable epoch = loadWeights(sess, saver, init) print("Testing on epoch {}...".format(epoch)) start = time.time() if epoch > 0: if config.useEMA: emaSaver.restore(sess, config.weightsFile(epoch)) else: saver.restore(sess, config.weightsFile(epoch)) #evalRes = runEvaluation(sess, model, data["main"], epoch, evalTest = False, evalDebug = True) ##################################################### imagesFilename = './FRIDGR_v0.1/data/debug.h5' datasetFilename = './FRIDGR_v0.1/data/FRIDGR_debug_questions.json' images = {"imagesFilename": imagesFilename} q = ["Do I have meat?", "How many meats?", "Do I have egg?", "Do I have donut?", "Do I have beer?"] a = [True, 2, True, True, False] with open(datasetFilename, "r") as datasetFile: data = json.load(datasetFile)["questions"] for i in range(5): #evalRes = runDemo(sess, model, data["main"], epoch) # data to instance: instance = data[20] question = q[i] #instance["question"] questionSeq = preprocessor.tokenize(question) answer = a[i] #instance.get("answer", "yes") # DUMMY_ANSWER dummyProgram = [{"function": "FUNC", "value_inputs": [], "inputs": []}] program = instance.get("program", dummyProgram) postfixProgram = program #preprocessor.programTranslator.programToPostfixProgram(program) programSeq = preprocessor.programTranslator.programToSeq(postfixProgram) programInputs = preprocessor.programTranslator.programToInputs(postfixProgram, offset = 2) print('DEBUG1:', question, questionSeq, answer, instance["image_index"]) #print('DEBUG2:', dummyProgram) #print('DEBUG3:', program) # pass other fields to instance? instances = [] instances.append({ "question": question, "questionSeq": questionSeq, "answer": answer, "imageId": instance["image_index"], "program": program, "programSeq": programSeq, "programInputs": programInputs, "index": 0 }) dataset = {"debug": None} buckets = preprocessor.vectorizeData(instances) #print('buckets =', buckets) dataset["debug"] = {"data": buckets, "images": images, "train": False} evalRes = runDemo(sess, model, dataset, epoch) pred = evalRes["debug"]["preds"][0]["prediction"] print('Answer/Predict is', answer, pred) #print('ID/Text decoded is', i, preprocessor.answerDict.decodeId(pred)) ##################################################### #extraEvalRes = None #print("took {:.2f} seconds".format(time.time() - start)) #printDatasetResults(None, evalRes, extraEvalRes) #print("Writing predictions...") #writePreds(preprocessor, evalRes, extraEvalRes) print(bcolored("Done!","white"))