def main(): ########### 读取配置文件 ########## ch = config.ConfigHandler("./config.ini") ch.load_config() ########### 读取参数 ########## train_batch_size = int(ch.config["model"]["train_batch_size"]) val_batch_size = int(ch.config["model"]["val_batch_size"]) num_epochs = int(ch.config["model"]["num_epochs"]) learning_rate = float(ch.config["model"]["learning_rate"]) class_size = int(ch.config["model"]["class_size"]) log_interval = int(ch.config["log"]["log_interval"]) ########### 获取数据loader ########## data_loader = dataset.MyDataset(train_batch_size, val_batch_size) data_loader_train =data_loader.load_train_data() data_loader_test = data_loader.load_test_data() ########### 训练和评价 ########## train.train_and_test(num_epochs, learning_rate, class_size, data_loader_train, data_loader_test, log_interval).train_epoch()
def main(): ########### 读取配置文件 ########## ch = config.ConfigHandler("./config.ini") ch.load_config() ########### 读取参数 ########## train_batch_size = int(ch.config["model"]["train_batch_size"]) test_batch_size = int(ch.config["model"]["test_batch_size"]) num_epochs = int(ch.config["model"]["num_epochs"]) learning_rate = float(ch.config["model"]["learning_rate"]) class_size = int(ch.config["model"]["class_size"]) ########### 读取log和model ########## log_interval = int(ch.config["log"]["log_interval"]) version_name = ch.config["log"]["version_name"] train_file = ch.config["data"]["train_file"] test_file = ch.config["data"]["test_file"] ########### 获取训练数据loader ########## data_train = Dataset.ImageDataset(train_file, train=True) data_loader_train = torch.utils.data.DataLoader( dataset=data_train, batch_size=train_batch_size, shuffle=True) ########### 获取测试数据loader ########## data_test = Dataset.ImageDataset(test_file, train=False) data_loader_test = torch.utils.data.DataLoader(dataset=data_test, batch_size=test_batch_size, shuffle=False) ########### 训练和评价 ########## train.train_and_test(num_epochs, learning_rate, class_size, data_loader_train, data_loader_test, log_interval, version_name).train_epoch()
def Input_lr_and_epoch(self, mes1, selection): dlg = wx.TextEntryDialog(None, u"请输入学习率和迭代次数(空格间隔):", u"神经网络BP算法", u"示例:0.1 100") mes2 = "" if dlg.ShowModal() == wx.ID_OK: mes2 = dlg.GetValue() #获取文本框中输入的值 train_and_test(mes1, mes2, selection, self.FileName.GetValue())
def try_CNN(): cfg = CNNConfig() train.train_and_test(load_existing_dataset=False, load_existing_model=False, train_model=True, check_accuracy=True, modelType=CNNModel3D, dataProviderType=FFT3DDataProvider, labelProviderType=SimpleDNNLabelProvider, config=cfg)
def try_SRF(): cfg = SimpleRandomForest() train.train_and_test(load_existing_dataset=False, load_existing_model=False, train_model=True, check_accuracy=True, modelType=SimpleRFModel, dataProviderType=FFTDataProvider, labelProviderType=SRFLabelProvider, config=cfg)
def try_LSTM(): cfg = LSTMConfig() train.train_and_test(load_existing_dataset=True, load_existing_model=True, train_model=True, check_accuracy=False, modelType=LSTMModel, dataProviderType=FFT2DDataProvider, labelProviderType=SimpleDNNLabelProvider, config=cfg)
def train(): model = AttentionUNet() optimizer = torch.optim.Adam(model.parameters(), lr=1e-5) criterion = FocalLoss() trained_model = train_and_test(model, dataloaders, optimizer, criterion, num_epochs=epochs) return trained_model
def main(): ########### 读取配置文件 ########## ch = config.ConfigHandler("./config.ini") ch.load_config() ########### 读取参数 ########## train_batch_size = int(ch.config["model"]["train_batch_size"]) valid_batch_size = int(ch.config["model"]["valid_batch_size"]) test_batch_size = int(ch.config["model"]["test_batch_size"]) num_epochs = int(ch.config["model"]["num_epochs"]) learning_rate = float(ch.config["model"]["learning_rate"]) class_size = int(ch.config["model"]["class_size"]) ########### 读取log和model ########## log_interval = int(ch.config["log"]["log_interval"]) version_name = ch.config["log"]["version_name"] train_file = ch.config["data"]["train_file"] valid_file = ch.config["data"]["valid_file"] test_file = ch.config["data"]["test_file"] ########### 预测结果输出 ########## pred_file = ch.config["save"]["pred_file"] ########### 获取训练数据loader ########## data_train = Dataset.ImageDataset(train_file, train=True) data_loader_train = torch.utils.data.DataLoader( dataset=data_train, batch_size=train_batch_size, shuffle=True) ########### 获取验证数据loader ########## data_valid = Dataset.ImageDataset(valid_file, train=False) data_loader_valid = torch.utils.data.DataLoader( dataset=data_valid, batch_size=valid_batch_size, shuffle=True) ########### 获取测试数据loader ########## data_test = Dataset.ImageDataset(test_file, train=False) data_loader_test = torch.utils.data.DataLoader(dataset=data_test, batch_size=test_batch_size, shuffle=False) ########### 训练和评价 ########## trainer = train.train_and_test(num_epochs, learning_rate, class_size, data_loader_train, data_loader_valid, data_loader_test, log_interval, version_name, pred_file) ########## start train ########### print("start train") begin_time = time() trainer.train_epoch() end_time = time() run_time = end_time - begin_time print('cost time:', run_time) ########## start eval ########### print("start test") trainer.test()
def run_experiment(x_train, y_train, x_valid, y_valid, embeddings, _layers): # Model parameters model_name = "mlp" layers = _layers # Training parameters learning_rate = 1e-3 # learning rate batch_size = 64 # batch size num_epochs = args.epochs # no. of training epochs # Regularization parameters dropout_keep_prob = 0.5 # dropout keep probability l2_reg_lambda = 0.0 # L2 regularization lambda # Training # ================================================== with tf.Graph().as_default(): tf.set_random_seed(42) # set random seed for consistent initialization(s) session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess = tf.Session(config=session_conf) with sess.as_default(): # Init model mlp = MLP(vocab_size=len(train.vocab), num_classes=len(train.class_names), layers=layers, l2_reg_lambda=l2_reg_lambda) # Convert sparse matrices to arrays x_train = x_train.toarray() x_valid = x_valid.toarray() # Output directory for models and summaries timestamp = str(int(time.time())) out_dir = os.path.abspath(os.path.join(os.path.curdir, "runs", args.dataset, model_name, timestamp)) # Train and test model max_accuracy = train_and_test(sess, mlp, x_train, y_train, x_valid, y_valid, learning_rate, batch_size, num_epochs, dropout_keep_prob, out_dir) return timestamp, max_accuracy
with tf.Graph().as_default(): session_conf = tf.ConfigProto(allow_soft_placement=allow_soft_placement, log_device_placement=log_device_placement) sess = tf.Session(config=session_conf) with sess.as_default(): mlp = MLP(vocab_size=len(train.vocab), num_classes=len(train.class_names), layers=layers, l2_reg_lambda=l2_reg_lambda) # Convert sparse matrices to arrays x_train = x_train.toarray() x_test = x_test.toarray() # Output directory for models and summaries timestamp = str(int(time.time())) out_dir = os.path.abspath( os.path.join(os.path.curdir, "runs", args.dataset, model_name, timestamp)) # Train and test model max_accuracy = train_and_test(sess, mlp, x_train, y_train, x_test, y_test, learning_rate, batch_size, num_epochs, dropout_keep_prob, out_dir) # Output for results.csv hyperparams = "{{layers: {}}}".format(layers) utils.print_result(args.dataset, model_name, max_accuracy, data_str, timestamp, hyperparams, args, args.notes)
def run_experiment(x_train, y_train, x_valid, y_valid, embeddings, _num_edges, _filter_size, _num_features): # Feature graph parameters num_edges = _num_edges coarsening_levels = 0 # Model parameters filter_name = "chebyshev" # name of graph conv filter model_name = "gcnn_chebyshev" # append filter name to model name filter_sizes = [_filter_size] # filter sizes num_features = [_num_features] # number of features per GCL pooling_sizes = [1] # pooling sizes (1 (no pooling) or power of 2) fc_layers = [] # fully-connected layers # Training parameters learning_rate = 1e-3 # learning rate batch_size = 64 # batch size num_epochs = args.epochs # no. of training epochs # Regularization parameters dropout_keep_prob = 0.5 # dropout keep probability l2_reg_lambda = 0.0 # L2 regularization lambda # Feature Graph # ================================================== # Construct graph dist, idx = graph.distance_sklearn_metrics(embeddings, k=num_edges, metric="cosine") A = graph.adjacency(dist, idx) A = graph.replace_random_edges(A, 0) # Compute coarsened graphs graphs, perm = coarsening.coarsen(A, levels=coarsening_levels, self_connections=False) laplacians = [graph.laplacian(A, normalized=True) for A in graphs] # Override filter sizes for non-param Fourier filter if filter_name == "fourier": filter_sizes = [l.shape[0] for l in laplacians] del dist, idx, A, graphs # don't need these anymore # Reindex nodes to satisfy a binary tree structure x_train = scipy.sparse.csr_matrix( coarsening.perm_data(x_train.toarray(), perm)) x_valid = scipy.sparse.csr_matrix( coarsening.perm_data(x_valid.toarray(), perm)) # Training # ================================================== with tf.Graph().as_default(): tf.set_random_seed( 42) # set random seed for consistent initialization(s) session_conf = tf.ConfigProto(allow_soft_placement=True, log_device_placement=False) sess = tf.Session(config=session_conf) tf.set_random_seed(42) # set random seed for consistent results with sess.as_default(): # Init model gcnn = GraphCNN(filter_name=filter_name, L=laplacians, K=filter_sizes, F=num_features, P=pooling_sizes, FC=fc_layers, batch_size=batch_size, num_vertices=x_train.shape[1], num_classes=len(train.class_names), l2_reg_lambda=l2_reg_lambda) # Convert sparse matrices to arrays x_train = np.squeeze([x_i.toarray() for x_i in x_train]) x_valid = np.squeeze([x_i.toarray() for x_i in x_valid]) # Output directory for models and summaries timestamp = str(int(time.time())) out_dir = os.path.abspath( os.path.join(os.path.curdir, "runs", args.dataset, model_name, timestamp)) # Train and test model max_accuracy = train_and_test(sess, gcnn, x_train, y_train, x_valid, y_valid, learning_rate, batch_size, num_epochs, dropout_keep_prob, out_dir) return timestamp, max_accuracy