def test_api(self): rd.flushall() main.test("/signup", {"name": "tomtomtom", "password": "******", "email": "*****@*****.**"}) main.test( "/trip", {"name": "tomtomtom", "password": "******", "loc": "51x4", "cam-num": "2", "cam-direction": "2"} )
def main(_): config = flags.FLAGS if config.mode == "train": train(config) elif config.mode == "prepro": copyfile(_[0], dir + 'config.py') prepro(config) elif config.mode == "debug": config.num_steps = 2 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 train(config) elif config.mode == "test": if config.use_cudnn: print( "Warning: Due to a known bug in Tensorlfow, the parameters of CudnnGRU may not be properly restored." ) test(config) elif config.mode == "predict": if config.use_cudnn: print( "Warning: Due to a known bug in Tensorlfow, the parameters of CudnnGRU may not be properly restored." ) predict(config) elif config.mode == "test_sber": if config.use_cudnn: print( "Warning: Due to a known bug in Tensorlfow, the parameters of CudnnGRU may not be properly restored." ) test_sber(config) else: print("Unknown mode") exit(0)
def main(_): config = flags.FLAGS if config.mode == "train": while True: try: train(config) except Exception: print("exception...") print('restart....') pass else: break elif config.mode == "prepro": prepro(config) elif config.mode == "debug": config.num_steps = 2 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 train(config) elif config.mode == "test": test(config) elif config.mode == "demo": demo(config) else: print("Unknown mode") exit(0)
def Problem2D_LeakyRelu(): x, y = NN.get_component([2, 10, 10, 1], "xavier") k = x.copy() l = y.copy() input = [] output = [] for i in range(500): a = int(np.random.uniform(-1000, 1000)) / 1000 b = int(np.random.uniform(-1000, 1000)) / 1000 input_sub = [a, b] r = None if ((a < 0 and b < 0) or (a > 0 and b > 0)): r = 1 else: r = 0 output_sub = [r] input.append(input_sub) output.append(output_sub) input = np.array(input) output = np.array(output) #NN.test(x,y,input[0:100],output[0:100],NN.L_Relu,NN.sig) w, b = NN.train(input, output, k, l, NN.L_Relu, NN.L_Relu_D, NN.L_Relu, NN.L_Relu_D, 1, 40000, 0.008) NN.test(w, b, input[0:100], output[0:100], NN.L_Relu, NN.sig)
def main(_): config = flags.FLAGS if config.mode == "prepare": prepare(config) elif config.mode == "test": test(config) elif config.mode == "train": train(config) else: print("Unknown mode") exit(0)
def main(_): config = flags.FLAGS if config.mode == 'prepro': prepro(config) elif config.mode == 'train': train(config) elif config.mode == 'test': test(config) else: raise ValueError('The mode must choose from [prepro/train/test]!')
def test_test_function(self): """Testing function :func:`main.test`.""" # Ensure reproducibility. torch.manual_seed(42) torch.cuda.manual_seed_all(42) rand = np.random.RandomState(42) n_in = 5 n_out = 5 n_samples = 2 x = rand.uniform(low=0, high=1, size=(n_samples, n_in)) y = rand.uniform(low=0, high=1, size=(n_samples, n_out)) data = utils.RegressionDataset(x, y) data_loader1 = DataLoader(data, batch_size=n_samples) assert (len(data_loader1) == 1) data_loader2 = DataLoader(data, batch_size=n_samples // 2) assert (len(data_loader2) > 1) device = torch.device("cpu") net = MLP(n_in=n_in, n_out=n_out) net.eval() with torch.no_grad(): predictions = net.forward(data.inputs) # Avoid any console prints. with open(os.devnull, 'w') as devnull: with contextlib.redirect_stdout(devnull): mse1_test = main.test(device, data_loader1, net) # See docstring of method `_pytorch_mse` in # `tests.public.lib.test_backprop_functions`. mse1 = F.mse_loss(predictions, data.outputs, reduction='none') mse1 = 0.5 * mse1.sum(dim=1).mean() self.assertAlmostEqual(mse1_test, float(mse1), 5, 'Method "main.test" does not work correctly.') ### Check if `test` handles multiple batches correctly correctly. # Avoid any console prints. with open(os.devnull, 'w') as devnull: with contextlib.redirect_stdout(devnull): mse2_test = main.test(device, data_loader2, net) self.assertAlmostEqual( mse2_test, float(mse1), 5, 'Method "main.test" does not work correctly when iterating ' + 'over multiple mini batches.')
def test_api(self): rd.flushall() main.test('/signup', { 'name':'Tomtomtom', 'password':'******', 'email':'*****@*****.**' }) main.test('/trip', { 'name':'tomtomtom', 'password':'******', 'loc':'51x4', 'cam-num':'2', 'cam-direction':'2' }) main.test('/trip', { 'name':'tomtomtom', 'password':'******', 'loc':'51x4.002', 'cam-num':'2', 'cam-direction':'2' }) main.test('/get-user', { 'name':'tomtomtom', 'password':'******' })
def main(_): config = flags.FLAGS if config.mode == "train": train(config) elif config.mode == "debug": config.num_steps = 2 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 train(config) elif config.mode == "test": test(config) else: print("Unknown mode") exit(0)
def run_problems(self, dir): start = datetime.datetime.now() print('--------------------------') print(start) print('--------------------------') for sub_dir in os.listdir(dir): p = os.path.join(os.getcwd(), dir, sub_dir) t = os.getcwd() os.chdir(p) sys.path.append(p) try: importlib.reload(main) except NameError: import main importlib.reload(main) print(dir + sub_dir, end=': ') self.assertTrue(main.test()) os.chdir(t) sys.path.remove(p) end = datetime.datetime.now() duration = end - start print('--------------------------') print(end) print('--------------------------') print(duration) print('--------------------------')
def testFaces(self): numCorrect = 0 total = 0 # should be 120 in total incorrect = {} for imgName in glob.glob("./img/*_*_.bmp"): imgName = imgName.replace("\\","/") # determine the slicing indices based on file name #start = 6 #end = 8 if self.isNumber(imgName[start:8]) else 7 #expected = imgName[start:end] expected = imgName.split("/")[-1].split("_")[0] print("expecting: " + imgName) actual = main.test(imgName) # test each face from the data set print expected, actual if (expected == actual[0]): print "PASS\n" numCorrect += 1 else: print "FAIL\n" incorrect[imgName] = actual total += 1 print "Incorrect images and their matches:" pprint.pprint(incorrect) print "\nNumber correct: " + str(numCorrect) + " out of " + str(total) print "Percentage correct: " + str ( (float(numCorrect)/float(total) ) * 100) + "%\n"
def testFaces(self): numCorrect = 0 total = 0 # should be 120 in total incorrect = {} for imgName in glob.glob("./img/*_*_.bmp"): imgName = imgName.replace("\\", "/") # determine the slicing indices based on file name #start = 6 #end = 8 if self.isNumber(imgName[start:8]) else 7 #expected = imgName[start:end] expected = imgName.split("/")[-1].split("_")[0] print("expecting: " + imgName) actual = main.test(imgName) # test each face from the data set print expected, actual if (expected == actual[0]): print "PASS\n" numCorrect += 1 else: print "FAIL\n" incorrect[imgName] = actual total += 1 print "Incorrect images and their matches:" pprint.pprint(incorrect) print "\nNumber correct: " + str(numCorrect) + " out of " + str(total) print "Percentage correct: " + str( (float(numCorrect) / float(total)) * 100) + "%\n"
def food_classify(img_path): label, score = main.test(img_path, model, opt) ret = [] for li, si in zip(label, score): if si < 1e-4 : si = si + 1e-4 ret.append({"label": int(li), "score": "%.2f" % (float(si)*100)}) return ret
def main(_): config = flags.FLAGS if config.mode == "train": train(config) elif config.mode == "prepro": prepro(config) elif config.mode == "debug": config.num_steps = 2 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 train(config) elif config.mode == "test": test(config) else: print("Unknown mode, you must choose mode from [train/prepro/debug/test]") exit(0)
def main(_): config = flags.FLAGS if config.mode == 'train': train(config) elif config.mode == 'prepro': prepro(config) elif config.mode == 'debug': config.num_steps = 2 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 train(config) elif config.mode == 'test': test(config) else: print('Unknown mode') exit(0)
def chooseSeq(): print(test()) inp=input('choose 4 colors sequece \tEx: [1,2,3,4]') a,b,c,d=str(inp) lst=[] for i in [a,b,c,d]: lst+= getColor(int(i)-1) lst+='\t'+compare(int(inp),int(table.key))+'\n' return lst
def main(_): config = flags.FLAGS os.environ["CUDA_VISIBLE_DEVICES"] = config.gpu # 选择一块gpu if config.mode == "train": train(config) elif config.mode == "prepro": data_process_addAnswer.prepro(config) elif config.mode == "test": test(config) elif config.mode == "examine": examine_dev(config) elif config.mode == "save_dev": save_dev(config) elif config.mode == "save_test": save_test(config) else: print("Unknown mode") exit(0)
def main(_): config = flags.FLAGS if config.mode == "train": train(config) elif config.mode == "prepro": prepro(config) elif config.mode == "debug": config.num_steps = 2 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 train(config) elif config.mode == "test": if config.use_cudnn: print("Warning: Due to a known bug in Tensorlfow, the parameters of CudnnGRU may not be properly restored.") test(config) else: print("Unknown mode") exit(0)
def main(_): config = flags.FLAGS if config.mode == "train": train(config) elif config.mode == "prepro": prepro(config) elif config.mode == "debug": config.num_steps = 2 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 train(config) elif config.mode == "test": test(config) elif config.mode == "demo": demo(config) else: print("Unknown mode") exit(0)
def run(): # Training settings parser = argparse.ArgumentParser(description='PyTorch MNIST Example') parser.add_argument('--test-batch-size', type=int, default=1000, metavar='N', help='input batch size for testing (default: 1000)') parser.add_argument('--no-cuda', action='store_true', default=True, help='disables CUDA training') parser.add_argument('--seed', type=int, default=1, metavar='S', help='random seed (default: 1)') parser.add_argument('--log-interval', type=int, default=10, metavar='N', help='how many batches to wait before logging training status') parser.add_argument('--test-AWGN', action='store_true', default=False, help='Test AWGN transformation') parser.add_argument('--sigma', type=float, default=0.0, metavar='N', help='standard deviation of AWGN') args = parser.parse_args() use_cuda = not args.no_cuda and torch.cuda.is_available() torch.manual_seed(args.seed) device = torch.device("cuda" if use_cuda else "cpu") test_kwargs = {'batch_size': args.test_batch_size} ## import model from main and import weights model = main.Net().to(device) model.load_state_dict(torch.load("mnist_cnn.pt")) # Print model's state_dict print("Model's state_dict:") for param_tensor in model.state_dict(): print(param_tensor, "\t", model.state_dict()[param_tensor].size()) for i, sigma in enumerate([0, 0.3, 0.6, 1.0]): transform = transforms.Compose([transforms.ToTensor(), main.AWGN(sigma), transforms.Normalize((0.1307,), (0.3081,))]) test_dataset = datasets.MNIST('../data', train=False, transform=transform) test_loader = torch.utils.data.DataLoader(test_dataset, **test_kwargs) print(f"\nAccuracy for AWGN with a standard deviation of {sigma}") main.test(model, device, test_loader)
def main(_): jieba.re_han_default = re.compile("([\u4E00-\u9FD5a-zA-Z0-9+#&\._%\xd7]+)", re.U) config = flags.FLAGS if config.mode == "train": train(config) elif config.mode == "prepro": prepro(config) elif config.mode == "debug": config.num_steps = 2 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 train(config) elif config.mode == "test": test(config) elif config.mode == "demo": demo(config) else: print("Unknown mode") exit(0)
def main(_): config = flags.FLAGS if config.mode == "train": train(config) elif config.mode == "debug": config.train_file = os.path.join(data_dir, "debug") config.dev_file = os.path.join(data_dir, "debug") config.test_file = os.path.join(data_dir, "debug") config.batch_size = 2 config.eval_batch_size = 2 config.num_steps = 2 config.checkpoint = 2 config.period = 1 config.dev_val_num_sentences = 2 config.test_val_num_sentences = 2 train(config) elif config.mode == "test": test(config) else: print("Unknown mode") exit(0)
def main(_): config = flags.FLAGS if config.mode == "get_vocab": get_vocab(config) elif config.mode == "prepare": prepare(config) elif config.mode == "train": train(config) elif config.mode == "train_rl": train_rl(config) elif config.mode == "train_qpp": train_qpp(config) elif config.mode == "train_qap": train_qap(config) elif config.mode == "train_qqp_qap": train_qqp_qap(config) elif config.mode == "test": test(config) else: print("Unknown mode") exit(0)
def main(_): config = flags.FLAGS get_args(config) if config.mode == "train": train(config) elif config.mode == "prepro": prepro(config) elif config.mode == "debug": config.num_steps = 1 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 train(config) elif config.mode == "test": test(config) # # elif config.mode == "predict": # predict(config) else: print("Unknown mode") exit(0)
def slots(): sentence = str(request.args.get('sentence')) with graph.as_default(): response_time, slots = test(process, [sentence], read_file=False) response = { 'sentence': sentence, 'slots': slots, 'response_time': str(response_time)[:4] + 's', 'model': str(best_model_filename) } return sendResponse(response)
def execute_command(): if request.method == 'POST': command = request.form['command'] result = test(command, True) if result != None: if request.form['is_sql_command'] == 'run': op, flash_message = run_command(result, True) flash(flash_message) return redirect(url_for('index')) if request.form['is_sql_command'] == 'evaluate': op, flash_message = run_command(result, False) flash(flash_message) return redirect(url_for('index')) return "Sin respuesta"
def main(_): config = flags.FLAGS if config.mac == "m40": config.ta_w2v = os.path.join(home, "data", "word2vec", "race_word_vector_300.txt") config.ta_c2v = os.path.join(home, "data", "word2vec", "single_w2v_300.txt") if config.mode == "train": train(config) elif config.mode == "prepro": prepro(config) elif config.mode == "debug": config.num_steps = 1 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 config.batch_size = 2 train(config) elif config.mode == "test": test(config) elif config.mode == "demo": demo(config) else: print("Unknown mode") exit(0)
def main(_): config = flags.FLAGS os.environ["CUDA_VISIBLE_DEVICES"] = config.gpu # 选择一块gpu if config.mode == "train": train(config) elif config.mode == "prepro": data_process.prepro(config) elif config.mode == "debug": config.num_steps = 2 config.val_num_batches = 1 config.checkpoint = 1 config.period = 1 train(config) elif config.mode == "test": test(config) elif config.mode == "examine": examine_dev(config) elif config.mode == "save_dev": save_dev(config) elif config.mode == "save_test": save_test(config) else: print("Unknown mode") exit(0)
def test_taxi(): main.test()
def test(): main.test()
label_dict = reddit.empty_label_dictionary() label_list = list(label_dict.keys()) for eachpair in pair_labels: label0 = eachpair[0] label1 = eachpair[1] index0 = label_list.index(label0) index1 = label_list.index(label1) label_counts[index0, index1] += 1 # Grab the predicted and test set labels predicted, groundtruth = main.test(save=False) # Convert into a row predicted = predicted.reshape(-1) test_len = predicted.shape[0] counter = 0 while counter < test_len: test_pair_labels = convert_label_pairs_num2string(predicted[counter]) label0 = test_pair_labels[0] label1 = test_pair_labels[1] index0 = label_list.index(label0) index1 = label_list.index(label1) test_label_counts[index0, index1] += 1 test_pair_truth = convert_label_pairs_num2string(groundtruth[counter]) label0 = test_pair_truth[0] label1 = test_pair_truth[1]
#!/usr/bin/env python3 # -*- coding: utf-8 -*- """ Created on Fri Dec 8 14:15:07 2017 @author: jyao """ from regularizer import Regularizer import main if __name__ == '__main__': print(Regularizer.PARAMETERS) p = 3 Regularizer.register(p) print(Regularizer.PARAMETERS) main.test(5) print(Regularizer.PARAMETERS)
def test_test(): assert main.test() == "Works!"
from main import training from main import test from main import load_mnist img_images, img_labels, tst_images, tst_labels = load_mnist() print(img_images.shape) clf = training(img_images, img_labels, 500) test_size = 100 num_correct = test(clf, tst_images, tst_labels, test_size) print ("Baseline classifier using an SVM.") print ("%s of %s values correct." % (num_correct, test_size))
def test_name(self): self.assertEqual(test('11'), 'Пашина Ксения Игоревна')
def test_surname(self): self.assertEqual(test('Павлова'), 10)
def __init__(self): super(HeavyPlayer, self).__init__() self.attack = 200 self.speed = 100 self.defense = 200 class LightPlayer(Player): def __init__(self): super(LightPlayer, self).__init__() self.attack = 100 self.speed = 200 self.defense = 100 if __name__ == "__main__": import main import weapon main.init() p = LightPlayer() wep1 = weapon.generate_weapon("Machine Gun") p.weapons.append(wep1) wep2 = weapon.generate_weapon("Missle Launcher") p.weapons.append(wep2) wep3 = weapon.generate_weapon("Laser Gun") p.weapons.append(wep3) p.equipped = p.weapons[0] print p.equipped p.speed = 400 main.test(p)