def main(args): dataset = EMNIST() iniciales = np.arange(10) Xinit, Yinit = dataset.load_segment_of_data(iniciales, "train") Xinit, Yinit = shuffle(Xinit, Yinit, random_state=args.seed) #train(Xinit, one_hot(Yinit, 10), args, n_classes=10, exp=1, split=0, n_epochs=25) Xtest, Ytest = dataset.load_segment_of_data(iniciales, "test") Xtest = np.where(Xtest >= 0.5, 1.0, 0.0) eval_str, _ = eval(Xtest, one_hot(Ytest, 10), args, n_classes=10, exp=1, split=0) omax = get_train_fit(Xinit, one_hot(Yinit, 10), args, n_classes=10, exp=1, split=0) Xc, Yc = dataset.load_segment_of_data([10], kind="train") get_novel_detections(Xc, Yc, omax, args, n_classes=11, exp=1, split=0) print("Done!")
def main(args): if args.dataset == "MNIST": dataset = MNIST() elif args.dataset == "CIFAR10": dataset = CIFAR10() elif args.dataset == "EMNIST": dataset = EMNIST() else: # args.dataset == "EMNIST": raise NotImplementedError("Aun no está disponible") with open("res_exp3.txt", "w") as f: for exp in np.arange(1, args.n_exps + 1): f.write("\n-- Experimento {}/{} --\n".format(exp, args.n_exps)) n_epochs = args.n_epochs #Directorios de guardado create_dir(args.save_path + "exp_{}/".format(exp)) img_dir = args.save_path + "imgs/img_{}/".format(exp) create_dir(img_dir) #np.random.seed(args.seed) #clases indexadas #real_classes = np.arange(dataset.n_classes) if args.ordered: shuffled_classes = np.append( np.arange(args.starting), np.random.permutation( np.arange(args.starting, dataset.n_classes))) #Si lo hacemos ordenado else: shuffled_classes = np.random.permutation(dataset.n_classes) initial_classes = shuffled_classes[:args.starting] print("Clases Iniciales: " + ",".join([CARACTERES[ch] for ch in initial_classes])) unknown_classes = shuffled_classes[args.starting:] #Cargamos las clases iniciales Xinit, Yinit = dataset.load_segment_of_data( initial_classes, "train") Yinit = change_indexes( Yinit, initial_classes) #cambiamos del indice de 0- starting Xinit, Yinit = shuffle(Xinit, Yinit, random_state=args.seed) #Xinit = np.where(Xinit >= 0.5, 1.0, 0.0) #binarizar train(Xinit, one_hot(Yinit, args.starting), args, n_classes=args.starting, exp=exp, split=0, n_epochs=n_epochs) #Evaluamos el desempeño inicial Xitest, Yitest = dataset.load_segment_of_data( initial_classes, "test") Yitest = change_indexes(Yitest, initial_classes) Xitest = np.where(Xitest >= 0.5, 1.0, 0.0) #binarizar eval_str, _ = eval(Xitest, one_hot(Yitest, args.starting), args, n_classes=args.starting, exp=exp, split=0) f.write("--" + eval_str) check_dist_space(Xitest, one_hot(Yitest, args.starting), args, n_classes=args.starting, exp=exp, split=0) #Creamos nuestra instancia de OpenMax try: omax = get_train_fit(Xinit, one_hot(Yinit, args.starting), args, n_classes=args.starting, exp=exp, split=0) if omax is None: print("Muy pocos casos") f.write("\nno se pudo ajustar mas\n---END---\n") continue except ValueError: continue for idx, unk in enumerate(unknown_classes): print("Reconociendo " + CARACTERES[unknown_classes[idx]]) n_epochs = 5 + int( args.n_epochs * (0.9**idx) ) if args.decay_epoch else int( args.n_epochs / 2 ) #.astype(np.int) #in(0.95*n_epochs) if n_epochs > 8 else 10 #if not is_increment: # Xitest, Yitest = dataset.load_segment_of_data(initial_classes) #else: initial_classes = shuffled_classes[:args.starting + idx] Xitest, Yitest = dataset.load_segment_of_data(initial_classes, kind="test") Xc, Yc = dataset.load_segment_of_data([unk], kind="train") Xnew = np.concatenate([Xitest, Xc], 0) Ynew = np.concatenate([Yitest, Yc], 0) nclasses = args.starting + idx + 1 Ynew = change_indexes(Ynew, shuffled_classes[:nclasses]) #Xnew = np.where(Xnew >= 0.5, 1.0, 0.0) #binarizar is_unks, Xunk, Yunk, res_text = get_novel_detections( Xnew, Ynew, omax, args, n_classes=nclasses, exp=exp, split=idx) #Revisamos si hay casos nuevos o no: f.write(res_text) if not is_unks: print("---END---") f.write("---END---\n") break #Generamos datos Xgen, Ygen, gen_text = generate(args, n_classes=nclasses - 1, exp=exp, split=idx, n_generados=int(0.9 * len(Yunk))) imagen_grande(Xgen, 10, img_dir + "recuerdo{:02d}.png".format(idx)) #Los unimos con los datos nuevos Xinit = np.concatenate([Xgen, Xunk], axis=0) Yinit = np.concatenate([Ygen, Yunk], axis=0) Xinit, Yinit = shuffle(Xinit, Yinit, random_state=args.seed) #Xinit = np.where(Xinit >= 0.5, 1.0, 0.0) #binarizar #Entrenamos train(Xinit, one_hot(Yinit, nclasses), args, n_classes=nclasses, increment=True, exp=exp, split=idx + 1, n_epochs=n_epochs) #int(0.8*args.n_epochs)) #Evaluamos Xitest, Yitest = dataset.load_segment_of_data( shuffled_classes[:nclasses], "test") Yitest = change_indexes(Yitest, shuffled_classes[:nclasses]) #Xitest = np.where(Xitest >= 0.5, 1.0, 0.0) #binarizar eval_str, acc = eval(Xitest, one_hot(Yitest, nclasses), args, n_classes=nclasses, exp=exp, split=idx + 1) f.write(CARACTERES[unknown_classes[idx]] + "-" + eval_str) #Caso de olvido catastrofico olvido = (1 / nclasses) + 0.05 if acc <= olvido: forget_text = "\nAccuracy {:.3f} <= {:.3f}.\n---Olvido Catastrofico---\n".format( 100 * acc, 100 * olvido) print(forget_text) f.write(forget_text) break check_dist_space(Xitest, one_hot(Yitest, nclasses), args, n_classes=nclasses, exp=exp, split=idx + 1) #Y creamos nuestro nuevo detector omax = get_train_fit(Xinit, one_hot(Yinit, nclasses), args, n_classes=nclasses, exp=exp, split=idx + 1) if omax is None: print("Muy pocos casos") f.write("\nno se pudo ajustar mas\n---END---\n") break
def RNG(self): while True: z = np.random.uniform(-np.sqrt(3), np.sqrt(3), self.z_size) y = np.random.randint(0, self.n_classes) y = one_hot(y, self.n_classes).squeeze() yield (z, y)
def main(args): # Cargar dataset seleccionado if args.dataset == "MNIST": dataset = MNIST() elif args.dataset == "CIFAR10": dataset = CIFAR10() elif args.dataset == "EMNIST": dataset = EMNIST() else: # args.dataset == "EMNIST": raise NotImplementedError("Aun no está disponible") assert dataset.n_classes > args.segments, "Segmentos deben ser menos que las clases" f = open("resultados.txt", "w") for exp in np.arange(1, args.n_exps + 1): f.write("\n-- Experimento {}/{} --\n".format(exp, args.n_exps)) # print("-- Experimento {}/{} --".format(exp, args.n_exps)) create_dir(args.save_path + "exp_{}/".format(exp)) create_dir( args.monitor + "exp_{}/".format(exp)) # Creamos los directorios de guardado create_dir("gen_img/exp_{}/".format(exp)) np.random.seed(args.seed) # Seleccionamos los segmentos de datos splits = np.array_split(np.arange(dataset.n_classes), args.segments) for split_idx, split in enumerate(splits): f.write("Split {}: ".format(split_idx + 1) + str(split) + "\n") # print("Split {}".format(split_idx + 1), split) split_classes = split.max( ) + 1 # Clases para empezar la etapa incremental # Si es la primera etapa: if split_idx == 0: train_epochs = args.n_epochs is_increment = False X_in, Y_in = dataset.load_segment_of_data(split, "train") else: train_epochs = int( 0.75 * train_epochs ) #args.n_epochs / 2) # 5 #Muy pocos epochs de entrenamiento al parecer is_increment = True _X_in, _Y_in = dataset.load_segment_of_data(split, "train") if args.rehearsal: X_r, Y_r = dataset.load_percent_of_data( np.concatenate(splits[:split_idx], axis=0), args.percentage, "train") X_in = np.concatenate([_X_in, X_r, X_pseudo], axis=0) Y_in = np.concatenate([_Y_in, Y_r, Y_pseudo], axis=0) else: X_in = np.concatenate([_X_in, X_pseudo], axis=0) Y_in = np.concatenate([_Y_in, Y_pseudo], axis=0) X_in, Y_in = shuffle(X_in, Y_in, random_state=args.seed) X_in = np.where(X_in >= 0.5, 1.0, 0.0) #binarizar Y_in = one_hot(Y_in, split_classes) train(X_in, Y_in, args, increment=is_increment, n_classes=split_classes, exp=exp, split=split_idx, n_epochs=train_epochs) # Evaluamos el accuracy X_test, Y_test = dataset.load_segment_of_data( np.arange(split_classes), "test") X_test = np.where(X_test >= 0.5, 1.0, 0.0) #binarizar Y_test = one_hot(Y_test, split_classes) eval_str = eval(X_test, Y_test, args, n_classes=split_classes, exp=exp, split=split_idx) f.write(eval_str) X_pseudo, Y_pseudo, gen_str = generate(X_test, Y_test, args, n_classes=split_classes, exp=exp, split=split_idx, n_generados=args.n_generate) f.write(gen_str) gen_img_file = "gen_img/exp_{}/generado_e{:02d}_s{:02d}.png".format( exp, exp, split_idx + 1) imagen_grande(X_pseudo[:100], n=10, out_filename=gen_img_file) f.close()
def main(args): dataset = EMNIST() with open("res_exp2.txt", "w") as f: for exp in np.arange(1, args.n_exps+1): #Haremos 1 validacion por ahora #exp=1 f.write("\n-- Experimento {}/{} --\n".format(exp, args.n_exps))#1, 1))# #Directorios de guardado create_dir(args.save_path + "exp_{}/".format(exp)) np.random.seed(args.seed) #Entrenaremos la red con los datos iniciales de los digitos Xtrain, Ytrain = dataset.load_segment_of_data(np.arange(10), "train") Xtrain, Ytrain = shuffle(Xtrain, Ytrain, random_state=args.seed) Ytrain = one_hot(Ytrain, 10) train(Xtrain, Ytrain, args, n_classes=10, exp=exp, n_epochs=args.n_epochs) #Evaluamos el desempeño del modelo Xtest, Ytest = dataset.load_segment_of_data(np.arange(10), "test") Ytest = one_hot(Ytest, 10) eval_str = eval(Xtest, Ytest, args, n_classes=10, exp=1) f.write(eval_str) f.write("Letra;SoftmaxAcc;OpenMaxAcc;Deteccion;Errores\n") omax = get_train_fit(Xtrain, Ytrain, args, n_classes=10, exp=1) save_file = args.save_path + "exp_{}/model_split{}.ckpt".format(exp, 0) Xtest, Ytest = dataset.load_segment_of_data(np.arange(10), "test") with tf.Graph().as_default(): dset = InputGenerator([None,28,28,1], 10, args.z_size, batch_size=args.batch_size, n_epochs=1) aae = AAE("test", batch_size=args.batch_size, z_size=args.z_size, n_epochs=1, n_classes=10) iterador = dset.create_test_generator() x_input = iterador.get_next() _, y_tilde = aae.encoder(x_input, supervised=True) saver = tf.train.Saver() with tf.Session() as sess: saver.restore(sess, tf.train.latest_checkpoint(args.save_path + "exp_{}/".format(exp))) for i in np.arange(10, dataset.n_classes): Xc, Yc = dataset.load_segment_of_data([i], kind="train") Xchar = np.concatenate([Xtest, Xc], 0) Ychar = np.concatenate([Ytest, Yc], 0) Ychar[Ychar>9] = 10 sess.run(iterador.initializer, {dset.x_input:Xchar}) eval_logits = np.empty((0, 10), dtype=np.float32) try: while True: logit = sess.run(y_tilde) eval_logits = np.append(eval_logits, logit, axis=0) except tf.errors.OutOfRangeError: pass openmax = omax.evaluate(eval_logits, Ychar) softmax = omax._softmax(eval_logits) Ypred = np.where(openmax.max(-1) <= args.threshold, 10, openmax.argmax(-1)) sm_acc = accuracy_score(Ychar, softmax.argmax(-1)) om_acc = accuracy_score(Ychar, Ypred) detect = len(np.intersect1d(np.argwhere(Ypred == 10).squeeze(), np.argwhere(Ychar == 10).squeeze()))/len(Yc) mistakes = len(np.intersect1d(np.argwhere(Ypred == 10).squeeze(), np.argwhere(Ychar < 10).squeeze()))/len(Yc) res_text = "{};{:2.3f};{:2.3f};{:2.3f};{:2.3f}\n".format(CARACTERES[i], 100*sm_acc, 100*om_acc, 100*detect, 100*mistakes) print(res_text) f.write(res_text)