def show_predictions(model_path, tub_paths, start=0, end=100, index=0): images, y, predictions = [], [], [] img_ok = 0 model = MyModel(min_throttle=0., max_throttle=1.) model.load(model_path) pi = PreprocessImage() for path in tub_paths: files = glob.glob(os.path.join(path, 'record*.json')) for filename in files: with open(filename, encoding='utf-8') as data_file: data = json.loads(data_file.read()) if os.path.isfile(os.path.join(path, data['cam/image_array'])): img_ok += 1 y.append([data['user/angle'], data['user/throttle']]) img = Image.open( os.path.join(path, data['cam/image_array'])) predictions.append(model.run(pi.run(np.array(img)))) img = np.array(img) images.append(img) images = np.array(images) y = np.array(y) predictions = np.array(predictions) fig, ax = plt.subplots() plt.plot(y[start:end, index]) plt.plot(predictions[start:end, index]) plt.show()
def main(args): print('----------------------------------------------------') print("{}-way-{}-shot Few-Shot Relation Classification".format( args.N, args.K)) print("Model: {}".format(args.Model)) print("config:", args) print('----------------------------------------------------') start_time = time.time() mymodel = MyModel(args) mymodel_clone = MyModel_Clone(args) best_acc = 0.0 best_loss = 0.0 for file_name in os.listdir('model_checkpoint'): if 'isNPM.tar' in file_name: model_file = 'model_checkpoint/' + file_name mymodel.load_state_dict(torch.load(model_file)) acc, loss = test_model(mymodel, mymodel_clone, args) print('model_name:', model_file) print('[TEST] | loss: {0:2.6f}, accuracy: {1:2.2f}%'.format( loss, acc * 100)) if acc > best_acc: best_acc = acc best_loss = loss best_model_file = model_file print('best_model_name:', best_model_file) print('best_loss:', best_loss) print('best_acc:', best_acc)
def train_model(): # Create instance of model model = MyModel() SGD_OPTIMIZER = SGD(learning_rate=0.01, momentum=0.001, nesterov=False) model.compile(loss='categorical_crossentropy', optimizer=SGD_OPTIMIZER, metrics=["accuracy"]) schedule_lr = LearningRateScheduler(lambda x: 1e-3 * 0.9**x) reduce_lr = ReduceLROnPlateau(monitor='val_loss', factor=0.2, patience=5, min_lr=0.001) (x_train, x_test, y_train, y_test) = load_dataset() # Call data generator datagen = data_generator() history = model.fit_generator(datagen.flow(x_train, y_train, batch_size=60), epochs=10, verbose=2, steps_per_epoch=500, validation_data=(x_test, y_test), callbacks=[schedule_lr, reduce_lr]) if not os.path.exists("fashionClassifier"): os.makedirs("fashionClassifier") tf.saved_model.save(model, "fashionClassifier") else: tf.saved_model.save(model, "fashionClassifier")
def train_model(config): data_transforms = transforms.Compose( [transforms.ToTensor(), transforms.Normalize(0.5, 0.5)]) my_dataset = MyDataset("session-2/data/data/data/", "session-2/data/chinese_mnist.csv", transform=data_transforms) train_dataset, val_dataset, test_dataset = torch.utils.data.random_split( my_dataset, [10000, 2500, 2500]) train_loader = DataLoader(train_dataset, batch_size=config["batch_size"], shuffle=True) val_loader = DataLoader(val_dataset, batch_size=config["batch_size"]) test_loader = DataLoader(test_dataset, batch_size=config["batch_size"]) my_model = MyModel(config["h1"], config["h2"], config["h3"], config["h4"]).to(device) optimizer = optim.Adam(my_model.parameters(), config["lr"]) for epoch in range(config["epochs"]): loss, acc = train_single_epoch(my_model, train_loader, optimizer) print(f"Train Epoch {epoch} loss={loss:.2f} acc={acc:.2f}") loss, acc = eval_single_epoch(my_model, val_loader) print(f"Eval Epoch {epoch} loss={loss:.2f} acc={acc:.2f}") loss, acc = eval_single_epoch(my_model, test_loader) print(f"Test loss={loss:.2f} acc={acc:.2f}") return my_model
def create_confusion_matrix(): ''' creates a confusion matrix ''' X_text, X_num, y = main() X_text_train, X_text_test, X_num_train, X_num_test, y_train, y_test = train_test_split( X_text, X_num, y) model = MyModel() model.fit(X_text_train, X_num_train, y_train) predictions = model.predict(X_text_test, X_num_test) return confusion_matrix(y_test, predictions)
def train(input_dataframe): # Split the dataset to train and test # Since the fold_num is 5, every train data would be around 80% of the dataset and test data would be around 20% of the dataset. fold_num = 5 kf = KFold(n_splits=fold_num) # Store the best model for prediction best_score = 0 best_model = None history_score = [] # This is used for showing the current fold number cnt = 1 # Training part for train_idx, test_idx in kf.split(input_dataframe): # Split the training and testing part from input dataframe. # It is based on the index train = input_dataframe.iloc[train_idx[:data_used_for_training]] test = input_dataframe.iloc[test_idx[:data_used_for_testing]] # Init the model class model = MyModel() # Prepare the data for training the model X = train.loc[:, 'overview'] y = train.loc[:, 'genres'] # Train the model model.fit(X, y) # Prepare the ground truth and prediction for evaluating the performance. truth = test.loc[:, 'genres'] prediction = model.predict(test.loc[:, 'overview']) # Compute the score score = evaluation(truth, prediction) # Store all the score in this list history_score.append(score) # Store the best model and score if score > best_score: best_score = score best_model = model # Print the current states print('Accuracy of fold %d: %.2f' % (cnt, score)) cnt += 1 # Print the contents print('Best score: ' + str(best_score)) print('Worst score: ' + str(min(history_score))) print('Average score: ' + str(np.array(history_score).mean())) # Save the best model best_model.save_weights(model_name)
def test(): opt.device = 'cuda:0' opt.data_root = 'demo/input/' # The location of your testing data opt.mask_root = 'demo/mask/' # The location of your testing data mask testset = MyDataLoader(opt) print('Test with %d' % (len(testset))) model = MyModel() model.initialize(opt) model.load_networks('places_irregular') # For irregular mask inpainting # model.load_networks('celebahq_center') # For centering mask inpainting, i.e., 120*120 hole in 256*256 input val_ssim, val_psnr, val_mae, val_losses_G = [], [], [], [] with torch.no_grad(): for i, data in enumerate(testset): fname = data['fname'][0] model.set_input(data) I_g, I_o, val_loss_G = model.optimize_parameters(val=True) val_s, val_p, val_m = metrics(I_g, I_o) val_ssim.append(val_s) val_psnr.append(val_p) val_mae.append(val_m) val_losses_G.append(val_loss_G.detach().item()) cv2.imwrite('demo/output/' + fname[:-4] + '.png', postprocess(I_o).numpy()[0]) print('Val (%d/%d) G:%5.4f, S:%4.4f, P:%4.2f, M:%4.4f' % ( i + 1, len(testset), np.mean(val_losses_G), np.mean(val_ssim), np.mean(val_psnr), np.mean(val_mae)), end='\r') print('Val G:%5.4f, S:%4.4f, P:%4.2f, M:%4.4f' % (np.mean(val_losses_G), np.mean(val_ssim), np.mean(val_psnr), np.mean(val_mae)))
def make_video(tub_path, video_filename='video.avi', model_path=None, preprocess_angle=None, index=None, min_throttle=0., max_throttle=1.): files = glob.glob(os.path.join(tub_path, 'record*.json')) files = sorted( files, key=lambda x: int(re.findall(r'\d+', os.path.basename(x))[0])) if model_path is not None: model = MyModel(min_throttle=min_throttle, max_throttle=max_throttle) model.load(model_path) pi = PreprocessImage() video = None fourcc = cv2.VideoWriter_fourcc(*'XVID') for filename in files: with open(filename, encoding='utf-8') as data_file: data = json.loads(data_file.read()) if os.path.isfile(os.path.join(tub_path, data['cam/image_array'])): frame = cv2.imread( os.path.join(tub_path, data['cam/image_array'])) throttle = data['user/throttle'] angle = data['user/angle'] xa = int(frame.shape[1] * ((angle + 1) / 2.)) ya = int(frame.shape[0] * .95) xt = int(frame.shape[1] * .95) yt = int(frame.shape[0] - frame.shape[0] * throttle) if index is None or index == 0: cv2.circle(frame, (xa, ya), 2, (255, 128, 0), -1) if index is None or index == 1: cv2.circle(frame, (xt, yt), 2, (255, 128, 0), -1) if model_path is not None: img = Image.open( os.path.join(tub_path, data['cam/image_array'])) p_angle, p_throttle = model.run(pi.run(np.array(img))) if preprocess_angle is not None: p_angle = preprocess_angle(p_angle) xa = int(frame.shape[1] * ((p_angle + 1) / 2.)) ya = int(frame.shape[0] * .9) xt = int(frame.shape[1] * .9) yt = int(frame.shape[0] - frame.shape[0] * p_throttle) if index is None or index == 0: cv2.circle(frame, (xa, ya), 2, (0, 128, 255), -1) if index is None or index == 1: cv2.circle(frame, (xt, yt), 2, (0, 128, 255), -1) if video is None: h, w, ch = frame.shape video = cv2.VideoWriter(video_filename, fourcc, 20., (w, h)) video.write(frame) cv2.destroyAllWindows() video.release()
def initialize(self): opt = elf.Options() net_opt = elf.NetOptions() opt.loadFromArgs("", self.option_map.getOptionSpec()) net_opt.loadFromArgs("", self.option_map.getOptionSpec()) self.rs = elf.RemoteServers(elf.getNetOptions(opt, net_opt), ["actor", "train"]) GC = elf.BatchReceiver(opt, self.rs) GC.setMode(elf.RECV_ENTRY) batchsize = opt.batchsize print("Batchsize: %d" % batchsize) width = 210 // 2 height = 160 // 2 T = 6 num_action = 4 spec = {} spec["actor"] = dict( input=dict(s=("float", (3, height, width))), reply=dict(a=("int32_t", 1), pi=("float", num_action), V=("float", 1)) ) ''' spec["train"] = dict( input=dict(s_=(T, 3, height, width), r_=(T, 1), a_=(T, 1), pi_=(T, num_action), V_=(T, 1)), ) ''' e = GC.getExtractor() desc = allocExtractor(e, batchsize, spec) params = { "input_dim" : width * height * 3, "num_action" : 4 } print("Init GC Wrapper") has_gpu = self.options.gpu is not None and self.options.gpu >= 0 self.wrapper = GCWrapper( GC, None, batchsize, desc, num_recv=1, default_gpu=(self.options.gpu if has_gpu else None), use_numpy=False, params=params) # wrapper.reg_callback("train", self.on_train) self.wrapper.reg_callback("actor", self.on_actor) self.model = MyModel(params) if has_gpu: self.model.cuda(self.options.gpu) # self.optim = torch.optimi.Adam(self.model.parameters()) self.n = 0
def __init__(self, master=None): Frame.__init__(self, master) self.master = master self.query_img = None self.file_path = const.model_path self.canvas = Canvas(root, width=1280, height=720) self.canvas.pack(expand=YES, fill=BOTH) self.init_window() self.model = MyModel(self.file_path) self.kept_images = [] self.images_container = [] self._create_labels() self.binary_signatures = IntVar() self.nn_arhitectures = {'cifar', 'mnist', 'fmnist'}
def main(): args = parse_args() # load network and weights model = Model.load_from_checkpoint(args.model) if not args.no_gpu: model.cuda() model.eval() # TODO load data img = cv2.imread(str(args.input))[..., ::-1] # Network expects RGB data albumentations_transform = A.Compose([ A.Normalize( mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225], ), ToTensorV2(), ]) # TODO input transform # TODO: make sure the input is (1, 3, H, W) # Feed data through network pred = model(img) # TODO: post-processing on prediction. # Save inference result cv2.imwrite(str(args.output), pred)
def _load(self, filePath): checkpoint = torch.load(filePath) model = MyModel( device, checkpoint['inputSize'], checkpoint['gatedCnnOutputSize'], checkpoint['gatedCnnStride1'], checkpoint['gatedCnnStride2'], checkpoint['gatedCnnKernel1'], checkpoint['gatedCnnKernel2'], checkpoint['lstmLayer'], checkpoint['lstmHiddenSize'], checkpoint['fcOutputSize'], checkpoint['dropout']) model.load_state_dict(checkpoint['stateDict']) model.eval() if self.device.type == 'cpu': model.cpu() else: model.cuda(device=self.device) return model
def main(args): mymodel = MyModel(args) cuda = torch.cuda.is_available() # if cuda is True: # mymodel = mymodel.cuda() dist_list = pre_calculate(mymodel, args) np.save("preprocess_file/support_examples_weight_IPN.npy", dist_list)
def train_model(config): data_transforms = transforms.Compose([...]) train_dataset = ImageFolder... train_loader = DataLoader(train_dataset, batch_size=config["batch_size"], shuffle=True) test_dataset = ImageFolder... test_loader = DataLoader(test_dataset, batch_size=config["batch_size"]) my_model = MyModel().to(device) optimizer = optim.Adam(my_model.parameters(), config["lr"]) for epoch in range(config["epochs"]): loss, acc = train_single_epoch(my_model, train_loader, optimizer) print(f"Train Epoch {epoch} loss={loss:.2f} acc={acc:.2f}") loss, acc = eval_single_epoch(my_model, test_loader) print(f"Eval Epoch {epoch} loss={loss:.2f} acc={acc:.2f}") return my_model
def train(train_data, dev_data, my_vocab, train_target, dev_target): #model = None embed_model = MyModel(my_vocab) #model = nn.DataParallel(model) embed_model = embed_model if classifier_embed_model_path is not None: embed_model = torch.load(classifier_embed_model_path) #criteria = torch.nn.CrossEntropyLoss() model = ClassificationModel(embed_model, hidden_dim * 2, num_classes) model = model.to(device) #criteria = torch.nn.MSELoss() criteria = torch.nn.CrossEntropyLoss() model_optim = optim.Adam(filter(lambda p: p.requires_grad, model.parameters()), lr=learning_rate) best_acc = -1 writer = SummaryWriter(exp_name) #print(len(train_data)) all_paragraphs = [ build_paragraph(this_sample, my_vocab) for this_sample in train_data ] all_paragraph_lengths = [len(this_sample) for this_sample in train_data] train_idx = list(range(len(train_data))) for epoch_i in range(num_epoch): random.shuffle(train_idx) total_loss = 0 total_batch = 0 all_paragraphs = [all_paragraphs[i] for i in train_idx] all_paragraph_lengths = [all_paragraph_lengths[i] for i in train_idx] train_target = [train_target[i] for i in train_idx] for current_batch in range( int((len(train_data) - 1) / batch_size) + 1): if current_batch % 100 == 0: print(current_batch) model_optim.zero_grad() paragraphs = all_paragraphs[current_batch * batch_size:(current_batch + 1) * batch_size] paragraph_lengths = all_paragraph_lengths[current_batch * batch_size: (current_batch + 1) * batch_size] scores = model(paragraphs) targets = train_target[current_batch * batch_size:(current_batch + 1) * batch_size] labels = torch.tensor(targets).to(device) loss = criteria(scores, labels) #print(loss) total_loss += loss.item() total_batch += 1 loss.backward() model_optim.step() acc = evaluate_classifier(model, dev_data, dev_target, my_vocab) if acc > best_acc: torch.save(model, classifier_model_path) best_acc = acc writer.add_scalar('accuracy', acc, epoch_i)
def predict(title, description): # Load model and weights model = MyModel() model.load_weights(model_name) # Clean the description des = clean_data_for_overview(description) # Predict genre = model.predict(np.array([des])) # Prepare the output res = r'''{ "title": "%s", "description": "%s", "genre": "%s" }''' % (title, description, genre[0]) print(res)
def train_model(config): my_dataset = MyDataset(...) my_model = MyModel(...).to(device) for epoch in range(config["epochs"]): train_single_epoch(...) eval_single_epoch(...) return my_model
def main(args): app = QtWidgets.QApplication(sys.argv) v = MyView() v.show() m = MyModel() TreeCtrl(m, v) app.exec_()
def train_model(config, train_dataset, val_dataset): my_model = MyModel(config).to(device) train_dataloader = torch.utils.data.DataLoader( train_dataset, batch_size=config["batchsize"], shuffle=True) val_dataloader = torch.utils.data.DataLoader( val_dataset, batch_size=config["batchsize"], shuffle=False) for epoch in range(int(config["epochs"])): train_single_epoch( my_model, torch.optim.Adam(my_model.parameters(), config["lrate"]), torch.nn.CrossEntropyLoss(), train_dataloader) print( eval_single_epoch(my_model, torch.nn.CrossEntropyLoss(), val_dataloader)) return my_model
class Submission: """ API Wrapper class which loads a saved model upon construction, and uses this to implement an API for feature selection and missing value prediction. This API will be used to perform active learning evaluation in private. """ def __init__(self): # Load a saved model here. self.model = MyModel() self.model.load('most_popular.npy', 'num_answers.npy') def select_feature(self, masked_data, can_query): """ Use your model to select a new feature to observe from a list of candidate features for each student in the input data, with the goal of selecting features with maximise performance on a held-out set of answers for each student. Args: masked_data (np.array): Array of shape (num_students, num_questions) containing data revealed to the model at the current step. Unobserved values are denoted by -1. can_query (np.array): Binary array of shape (num_students, num_questions), indicating which features can be queried by the model in the current step. Returns: selections (list): List of ints, length num_students, containing the index of the feature selected to query for each student (row) in the dataset. """ # Use the loaded model to perform feature selection. selections = self.model.select_feature(masked_data, can_query) return selections def predict(self, masked_data): """ Use your model to predict missing values in the input data. Args: masked_data (np.array): Array of shape (num_students, num_questions) containing data revealed to the model at the current step. Unobserved values are denoted by -1. Returns: predictions (np.array): Array of shape (num_students, num_questions) containing predictions for the unobserved values in `masked_data`. The values given to the observed data in this array will be ignored. """ # Use the loaded model to perform missing value prediction. predictions = self.model.predict(masked_data) return predictions
class MyController(): def __init__(self, parent): self.parent = parent self.model = MyModel(self) # initializes the model self.view = MyView(self) #initializes the view #initialize objects in view #a non cheat way to do MVC wiht tkinter control variables #self.view.setEntry_text('Data') #self.view.setLabel_text('>') #event handlers def salirButtonPressed(self): self.parent.destroy() def calcularButtonPressed(self): key = self.view.getEntry_text_key() msg = self.view.getEntry_text_msg() self.model.clearList() if len(key): self.model.addToList(key[0]) if len(msg): self.model.addToList(msg) if (len(key) and len(msg)): self.view.setLabel_text(self.getCipherText(self.model.getList())) def listChangedDelegate(self): #model internally chages and needs to signal a change print(self.model.getList()) def getCipherText(self, in_list): key = in_list[0] msg = in_list[1] values = [] print("Key = ", key, ord(key)) start = time.time() vs = [] for x in msg: vs.append(ord(x)) print(vs) vv = [] low_level_driver.send_key_byte(ord(key)) for x in msg: time.sleep(0.01) low_level_driver.send_data_byte(ord(x)) time.sleep(0.01) v = low_level_driver.get_byte() val = unichr(v) values.append(val) vv.append(v) print("Transaction finished. Time = ", time.time() - start) print(values) print(vv) return ''.join(values)
def build_and_train_gru_model(inputs, labels, num_of_labels, do_train=True): num_of_features = len(inputs[0][0]) model = MyModel(input_len=model_config.input_vec_size, num_features=num_of_features, num_labels=num_of_labels) if model_config.continue_train_existing_model: weights_path = model_config.model_file_name if model_config.many_to_many: model.build_model("GRU", [350, 300, 250], [0.05, 0.05, 0.05], weights_path) if do_train: model.fit(inputs, labels, model_path="model", early_stopping_patience=40, val_percentage=validation_perc, batch_size=batch_size, num_epochs=num_epochs) else: # NOTE: train - many inputs to one label labels_many_to_one = Utils.get_many_to_one_labels(labels, num_of_labels) model.build_model("GRU_1", [350, 300, 250], [0.05, 0.05, 0.05], weights_path) if do_train: model.fit(inputs, labels_many_to_one, model_path="model", early_stopping_patience=40, val_percentage=validation_perc, batch_size=batch_size, num_epochs=num_epochs) return model
def init_model(features): model = MyModel(FLAGS.net) logits, end_points = model(features, tf.constant(False, tf.bool)) predictions = { 'classes': tf.argmax(logits, axis=1), 'top_3': tf.nn.top_k(logits, k=3)[1], 'probs': tf.nn.softmax(logits) } return predictions
def main(): device = torch.device('cpu') torch.manual_seed(1234) layer = 2 size = 1024 func = "relu" model = MyModel(layer, size) model.load_state_dict(torch.load('model_state_dict_final')) model.eval() transforms = T.Compose([T.ToTensor(), T.Normalize((0.5, ), (0.5, ))]) test_dataset = MnistDatasetTest('data', 'test', transforms) test_dataloader = DataLoader(test_dataset, batch_size=64, shuffle=False, num_workers=4) result = open("result.txt", "w") # to create a result with torch.no_grad(): for images, image_name in test_dataloader: images = images.to(device) prediction = model(images, layer, func) for i in range(images.size()[0]): x = image_name[i] + ' ' + str(int(torch.argmax(prediction[i]))) result.write(x) result.write("\n") result.close()
def train(tub_names, model_path, batch_size, epochs): model_path = os.path.expanduser(model_path) m = MyModel() model = m.model model.summary() X, y = tubs_to_arrays(tub_names, seed=10) total_records = len(X) total_train = int(total_records * .8) total_val = total_records - total_train steps_per_epoch = ((total_train // batch_size) + 1) * 2 validation_steps = (total_val // batch_size) + 1 print('Train images: %d, Validation images: %d' % (total_train, total_val)) print('Batch size:', batch_size) print('Epochs:', epochs) print('Training steps:', steps_per_epoch) print('Validation steps:', validation_steps) input("Press Enter to continue...") train_gen = generator(X[:total_train], y[:total_train], batch_size, train=True, categorical_angle=m.categorical_angle, categorical_throttle=m.categorical_throttle) val_gen = generator(X[total_train:], y[total_train:], batch_size, train=False, categorical_angle=m.categorical_angle, categorical_throttle=m.categorical_throttle) save_best = ModelCheckpoint(model_path, monitor='val_loss', verbose=0, save_best_only=True, mode='min') callbacks = [save_best, CSVLogger("logs/train.log"), OutputCallback()] hist = model.fit_generator(train_gen, steps_per_epoch=steps_per_epoch, epochs=epochs, verbose=0, validation_data=val_gen, callbacks=callbacks, validation_steps=validation_steps, workers=4, use_multiprocessing=True) return hist
def test_model(ds_name, encoder, paths, categorical=False): """The main function for executing network testing. It loads the specified dataset iterator and optimized saliency model. By default, when no model checkpoint is found locally, the pretrained weights will be downloaded. Args: ds_name (str): Denotes the dataset that was used during training. encoder (str): the name of the encoder want to be used to predict. paths (dict, str): A dictionary with all path elements. """ w_filename_template = "/%s_%s_%s_weights.h5" # [encoder]_[ds_name]_weights.h5 (test_ds, n_test) = data.load_test_dataset(ds_name, paths["data"], categorical) print(">> Preparing model with encoder %s..." % encoder) model = MyModel(encoder, ds_name, "test") weights_path = paths["weights"] + w_filename_template % (encoder, ds_name, loss_fn_name) if os.path.exists(weights_path): print("Weights are loaded!\n %s"%weights_path) else: download.download_pretrained_weights(paths["weights"], encoder, ds_name, loss_fn_name) model.load_weights(weights_path) del weights_path print(">> Start predicting using model trained on %s..." % ds_name.upper()) results_path = paths["results"] + "%s/%s/%s/" % (ds_name, encoder, loss_fn_name) # Preparing progbar test_progbar = Progbar(n_test) for test_images, test_ori_sizes, test_filenames in test_ds: pred = test_step(test_images, model) for pred, filename, ori_size in zip(pred, test_filenames.numpy(), test_ori_sizes): img = data.postprocess_saliency_map(pred, ori_size, as_image=True) tf.io.write_file(results_path + filename.decode("utf-8"), img) test_progbar.add(test_images.shape[0])
def predict(self, data, test_path='./data/test.csv', checkpoint_save_path='./data/saved_model.h5'): if self.model == 'mlp': # mlp超参数 batch_size = 128 epochs = 1000 init_lr = 5e-4 ''' 参数提取/备用 file = open('./data/pre_weights.txt', 'w') for v in model.trainable_weights: file.write(str(v.name) + '\n') file.write(str(v.shape) + '\n') file.write(str(v.numpy()) + '\n') file.close() ''' to_pre = data[891:].copy() to_pre.drop(['Survived'], axis=1, inplace=True) if reTrain: trainer = Trainer(data, batch_size=batch_size, epochs=epochs, init_lr=init_lr) model = trainer.train() else: model = MyModel.my_mlp() model.load_weights(checkpoint_save_path) to_pre = tf.convert_to_tensor(to_pre.values, dtype=tf.float64) pred_labels = model.predict(to_pre) pred_labels = tf.argmax(pred_labels, axis=1) elif self.model == 'bayes': pred_labels = np.array(MyModel.my_bayes(data)) elif self.model == 'ranforest': pred_labels = np.array(MyModel.my_ranforest(data), dtype=np.int) elif self.model == 'voting': bayes_pred = np.array(MyModel.my_bayes(data)) ranforest_pred = np.array(MyModel.my_ranforest(data), dtype=np.int) model = MyModel.my_mlp() model.load_weights(checkpoint_save_path) to_pre = data[891:].copy() to_pre.drop(['Survived'], axis=1, inplace=True) to_pre = tf.convert_to_tensor(to_pre.values, dtype=tf.float64) pred_labels = model.predict(to_pre) mlp_pred = tf.argmax(pred_labels, axis=1) result = [bayes_pred, ranforest_pred, mlp_pred] pred_labels = stats.mode(np.array(result))[0][0] # 处理结果成kaggle接受的数据格式 test = pd.read_csv(test_path) test.drop(test.columns[1:], axis=1, inplace=True) test.insert(1, 'Survived', pred_labels) return test
def main(): audio_path = 'wav_files\\long_dr1_7.wav' # NOTE: no overlap in the input vectors frames inputs = Utils.audio_to_model_inputs(audio_path, model_config.input_vec_size) inputs_transposed = Utils.convert_to_cnn_inputs(inputs) input_len = len(inputs_transposed[0]) num_of_features = len(inputs_transposed[0][0]) num_of_labels = PhonesSet.get_num_labels() model = MyModel(input_len=input_len, num_features=num_of_features, num_labels=num_of_labels) model_file = model_config.model_file_name model.build_model("CONV1", [], [], weights_path=model_file) thread = threading.Thread(target=send_visemes_to_smartbody, args=(model, inputs_transposed)) thread.daemon = True # Daemon thread thread.start() loader_audio_path = 'wav_files\\long_dr1_7_loader.wav' play_wav(loader_audio_path)
def initialize_data(self, features, adj_train, gamma, eta, beta, l, n_clusters, lr, clustering_labels, epochs): self.number_of_features, self.epochs = features.shape[1], epochs self.gamma, self.eta, self.beta = gamma, eta, beta self.clustering_labels = clustering_labels # normalize the adj adj_train_norm = compute_adj_norm(adj_train) S = getS(adj_train, features, l) F = getF(S) Y = getY(adj_train, beta, features) # this method needs to have the complete adj_train (not only the triu) D = getD(adj_train) # covnert matrices to tensors self.adj_train_norm_tensor = convert_sparse_matrix_to_sparse_tensor( adj_train_norm) self.Y_tensor = tf.convert_to_tensor(Y, dtype="float32") self.D_tensor = tf.convert_to_tensor(D, dtype="float32") self.F_tensor = tf.convert_to_tensor(F, dtype="float32") self.S_tensor = tf.convert_to_tensor(S, dtype="float32") self.feature_tensor = convert_sparse_matrix_to_sparse_tensor(features) # define the ground truth self.y_actual = [adj_train.toarray().flatten(), features.toarray()] # define the optimizer self.optimizer = tf.keras.optimizers.Adam(learning_rate=lr) # define the model self.model = MyModel(self.Y_tensor, n_clusters, self.D_tensor, self.adj_train_norm_tensor, self.number_of_features)
def run(): use_cuda = torch.cuda.is_available() device = torch.device('cuda' if use_cuda else 'cpu') dataset = [ {"in" : [0.0, 0.0], "out" : [0.0]}, {"in" : [0.0, 1.0], "out" : [1.0]}, {"in" : [1.0, 0.0], "out" : [1.0]}, {"in" : [1.0, 1.0], "out" : [0.0]}] data_loader = get_data_loader(dataset=dataset, shuffle=True) model = MyModel() model.to(device) optimizer = optim.Adam(model.parameters()) loss_func = nn.MSELoss() model.train() for _ in range(0, 2000): for output, input in data_loader: input = input.to(device) output = output.to(device) result = model(input) loss = loss_func(result, output) optimizer.zero_grad() loss.backward() optimizer.step() test_data_loader = get_data_loader(dataset=dataset, shuffle=False) model.eval() with torch.no_grad(): for _, input in test_data_loader: print(input) input = input.to(device) result = model(input) print(result)