def main():
print "Select Network Type"
print "1. MLP"
print "2. Radial Basis"
nn_type = raw_input()
nn = NeuralNetwork()
if nn_type == "1":
num_inputs = int(raw_input("Enter number inputs"))
num_hidden = int(raw_input("Enter number hidden layers"))
nn = MLPNN(num_inputs, num_hidden)
elif nn_type == "2":
num_inputs = int(raw_input("Enter number inputs"))
num_centers = int(raw_input("Enter number radial basis functions"))
nn = RBNN(num_inputs, num_centers)
trainer = Trainer(nn)
tester = Tester(nn)
if nn_type == "1":
trainer.trainMLP(str(num_inputs))
tester.test(str(num_inputs))
elif nn_type == "2":
trainer.trainRB(str(num_inputs))
tester.testRB(str(num_inputs))
def main():
state = WorkerState.READY
testers = []
for i in range(num_of_testers):
testers.append(Tester(i))
while True:
testers_state = []
for tester in testers:
if tester.is_ready():
print("tester {} is ready".format(tester.get_id()))
new_workload = db_client.pop_next_workload()
print("new workload is", new_workload)
if new_workload:
build = db_client.get_build(new_workload)
if build:
tester.start_test(new_workload, build,
test_done_callback)
else:
print("Waiting for new workload")
current_workload = tester.get_current_workload()
if current_workload:
testers_state.append({
"state":
tester.get_state(),
"current_workload":
current_workload.val(),
})
else:
testers_state.append({
"state": tester.get_state(),
"current_workload": None
})
db_client.update_worker_state(num_of_testers, testers_state)
time.sleep(120)
def main():
pp = Preprocessor()
print 'processing custom data, computing bows...'
tdpath = 'dataset/test/sms-data'
pp.process_custom_data(tdpath)
fm = FeatureModel()
print 'converting custom data to fvs...'
fm.compute_custom_fv_matrix('custom')
tdpath = 'bin_data/custom_fv.npy'
cpath = 'bin_data/mnb-classifier.npy'
data = np.load('bin_data/custom-data.npy').item()
tester = Tester(tdpath,cpath)
print 'predicting labels for custom data...'
results = tester.predict_labels_for_custom_data(data)
with open('output/results.txt','w') as textfile:
for msg in results:
line = '%s -> %s\n' % (msg,results[msg])
textfile.write(line)
textfile.close()
print 'Results written to results.txt'
def test_tester():
tester = Tester()
os.system("clear")
if not tester.setup():
return
if not tester.reveil():
return
if not tester.liberer_leds():
return
if not tester.switch_18():
return
if not tester.switch_5():
return
if not tester.switch_12():
return
if not tester.switch_9():
return
if not tester.charge_rapide():
return
if not tester.charge_normale():
return
if not tester.batterie_faible():
return
if not tester.batterie_min():
return
if not tester.batterie_max():
return
if not tester.jack_debranche():
return
pass
def schedule_tester(self, cycle=TEST_CYLE):
"""
定时测试代理
:param cycle:
:return:
"""
tester = Tester()
while True:
print("测试器开始运行")
tester.run()
time.sleep(cycle)
def schedule_tester(self,cycle=TESTER_CYCLE):
"""
定时测试代理
:param cycle:
:return:
"""
tester=Tester()
while True:
print('测试机器运行')
tester.run()
time.sleep(cycle)
def main():
ANDperceptron = SigmoidNeuron([random.randint(-2,2),random.randint(-2,2)],random.randint(-2,2),0.1)
train_set_sizes = range(1,1000,10)
presitions = []
tester = Tester()
#entrenar
for train_size in train_set_sizes:
for i in range(train_size):
trainAND(ANDperceptron)
presitions.append(tester.test(ANDperceptron,[[0,0],[0,1],[1,0],[1,1]],[0,0,0,1],ifhalf))
tester.plot(train_set_sizes,presitions, "Neurona Sigmoide entrenada con AND")
def main():
neuralNetwork = NeuralNetwork()
neuralNetwork.make(2, [3, 1], 0.5)
nbepoch = 5000
dataset = [[0, 0], [0, 1], [1, 0], [1, 1]]
outputs = [[0], [1], [1], [0]]
train_set_sizes = range(1, 5000, 10)
errors = neuralNetwork.train(dataset, outputs, nbepoch)
tester = Tester()
tester.plotError(range(5000), errors,
"Red neuronal entrenada con XOR, 5000 epocas")
def reset(self):
self.prog = bytearray()
self.progPtr = 0x000000
self.ops = {
0b00: self.add_op,
0b01: self.sub_op,
0b10: self.jmp_op,
0b11: self.prt_op
}
self.moves = ""
self.t = Tester()
self.numOfCycles = 0
def main_preparation(conn):
Create_tables.create_tables(conn)
Add = Adder(conn)
number_of_buildings = 5
Test = Tester(conn, number_of_buildings)
test_sets_list = Test.test_sets_list
for t_set in test_sets_list:
t_set_DB = t_set.split("|")
Add.add_detector(t_set_DB[0], t_set_DB[1], t_set_DB[2], t_set_DB[3], t_set_DB[4])
Test.all_dectors_dict = Test.get_all_detectors()
test_detector_dict = Test.all_dectors_dict
return test_detector_dict, Test
def main():
neuralNetwork = NeuralNetwork()
neuralNetwork.make(2,[3,1],0.1)
train_set_sizes = range(1,5000,10)
presitions = []
tester = Tester()
#entrenar
for train_size in train_set_sizes:
for i in range(train_size):
trainXORWithNetwork(neuralNetwork)
presitions.append(tester.testNetwork(neuralNetwork,[[0,0],[0,1],[1,0],[1,1]],[[0],[1],[1],[0]]))
tester.plot(train_set_sizes,presitions, "Red neuronal con 3 neuronas en c.o. y 1 salida, entrenada con XOR")
def main():
started = datetime.now()
tdpath = 'bin_data/testing_fv.npy'
cpath = 'bin_data/mnb-classifier.npy'
tester = Tester(tdpath, cpath)
tester.test_classifier()
finished = datetime.now()
print 'Started at: ', started
print 'Finished at: ', finished
print 'Time taken: ', (finished - started)
def __init__(self):
self.prog = bytearray()
self.progPtr = 0x000000
self.ops = {
0b00: self.add_op,
0b01: self.sub_op,
0b10: self.jmp_op,
0b11: self.prt_op
}
# self.mapa = mapa
self.moves = ""
self.t = Tester()
self.numOfCycles = 0
self.printCount = 0
def test(self):
if 'FZF_DEFAULT_OPTS' in self.yml['test'][0]:
app_env['FZF_DEFAULT_OPTS'] = self.yml['test'].pop(
0)['FZF_DEFAULT_OPTS']
else:
app_env['FZF_DEFAULT_OPTS'] = ''
tester = Tester(self.yml['test'])
result = self.tasks[0].execute(tester=tester)
while not self._is_job_end(result):
new_task = Task.clone(self.tasks[-1])
new_task.update(self.task_switch[result.key], result)
self.tasks.append(new_task)
result = self.tasks[-1].execute(tester=tester)
self.tasks[-1].output(result, tester=tester)
def main():
XORperceptron = Perceptron(
[random.randint(-2, 2), random.randint(-2, 2)], random.randint(-2,
2), 0.1)
train_set_sizes = range(1, 1000, 10)
presitions = []
tester = Tester()
#entrenar
for train_size in train_set_sizes:
for i in range(train_size):
trainXOR(XORperceptron)
presitions.append(
tester.test(XORperceptron, [[0, 0], [0, 1], [1, 0], [1, 1]],
[0, 1, 1, 0]))
tester.plot(train_set_sizes, presitions, "Perceptron entrenado con XOR")
def main():
parser = argparse.ArgumentParser(description="AerialSeg by PyTorch: test.py")
parser.add_argument('--eval_batch_size', type=int, default=1, help='batch size for validation')
parser.add_argument('--eval_list', type=str, default='Potsdam_val.txt', help='list file for validation')
parser.add_argument('--img_path', type=str, default='Potsdam/2_Ortho_RGB', help='path for images of dataset')
parser.add_argument('--gt_path', type=str, default='Potsdam/5_Labels_all', help='path for ground truth of dataset')
parser.add_argument('--num_of_class', type=int, default=6, help='number of classes')
parser.add_argument('--crop_size', type=int, default=512, help='crop size of input images')
parser.add_argument('--stride', type=int, default=256, help='stride to test tiles')
parser.add_argument('--checkpoint', type=str, default=None, help='checkpoint to test')
parser.add_argument('--cuda', type=bool, default=False, help='whether to use GPU')
args = parser.parse_args()
print(args)
my_tester = Tester(args)
my_tester.run()
def main():
logging.basicConfig(filename="result/log.txt",
filemode='w',
format='%(asctime)s,%(msecs)d %(name)s %(levelname)s %(message)s',
datefmt='%H:%M:%S',
level=logging.DEBUG)
logging.getLogger().setLevel(logging.INFO)
parser = argparse.ArgumentParser()
parser.add_argument('-n_clusters', type=int, default=5)
parser.add_argument('-n_points', type=int, default=100)
opt = parser.parse_args()
tester = Tester(n_gaussian_clusters=opt.n_clusters)
# Generate data from n 2d multivariate gaussian parameters
data, labels = tester.generate_2d_gaussian_points(
how_many_per_each_gaussian=opt.n_points)
logging.info(" Generated {} data points from {} different 2 dimensional "
"multivariate gaussian distributions. ({} data points for "
"each cluster.)".format(opt.n_clusters * opt.n_points,
opt.n_clusters, opt.n_points))
# Raw Data
utils.draw(data, labels, without_label_color=True, means=None,
title="Data", save="result/raw.png", show=False)
utils.draw(data, labels, without_label_color=False, means=tester.means,
title="Gaussian", save="result/gaussian.png", show=False)
# KMeans Prediction
kmeans = KMeans(n_cluster=opt.n_clusters)
prediction_lables, prediction_centers = kmeans.fit(data)
utils.draw(data, prediction_lables, without_label_color=False,
means=prediction_centers, title="KMeans",
save="result/kmeans.png", show=False)
# Concatenate results
png_list = ["result/raw.png", "result/gaussian.png", "result/kmeans.png"]
utils.concatenate_pngs(png_list, "result/final.png")
def main():
tester = Tester()
line = SimpleLine(1.5,10)
train_set = generateRandomPoints(1000)
valid_set = generateRandomPoints(1000)
results_valid_set = []
for (x,y) in valid_set:
results_valid_set.append(line.isUpperLine(x,y)>0.5)
train_set_sizes = range(1,1000,10) #[10,50,100,250,500,750,1000]
learning_rates = [0.1,0.5,1.5]
for lr in learning_rates:
precisions = []
for train_set_size in train_set_sizes:
perceptron = SigmoidNeuron([2,2],2,lr)
for index in range(train_set_size):
(x,y) = train_set[index]
perceptron.trainLonely([x,y],line.isUpperLine(x,y))
precisions.append(tester.test(perceptron,valid_set,results_valid_set,ifhalf))
tester.plot(train_set_sizes,precisions,"Presiciones por numero de muestras de entrenamiento, lr %.1f" % (lr))
def __init__(self,
what_to_grade: WhatToGrade = None,
who_to_grade: WhoToGrade = None,
getter: Getter = None,
tester: Tester = None,
recorder: Recorder = None):
if not what_to_grade:
what_to_grade = WhatToGrade()
if not who_to_grade:
who_to_grade = WhoToGrade()
if not getter:
getter = Getter(what_to_grade, who_to_grade)
if not tester:
tester = Tester(what_to_grade, who_to_grade)
if not recorder:
recorder = Recorder(what_to_grade, who_to_grade)
self.what_to_grade = what_to_grade
self.who_to_grade = who_to_grade
self.getter = getter
self.tester = tester
self.recorder = recorder
def runTest(self, trainingFilename, startIndex, endIndex):
a = Atomizer('learn')
e = FeaturesExtractor()
p = InputDataProcessor(a, e, (0.2, 0.8))
r = InputDataReader(p)
(X, y) = r.read_features(trainingFilename)
n = MLPClassifier(solver='lbfgs',
alpha=1e-5,
hidden_layer_sizes=(5, ),
random_state=1)
n.fit(X, y)
a = Atomizer('test')
e = FeaturesExtractor()
t = Tester(a, e, n, 0.99)
for i in range(startIndex, endIndex):
testFilename = "suspicious-document{:05d}".format(i)
test_file = r.get_file("dataSets/part{}/{}".format(
1, testFilename))
b = t.is_plagiarised(test_file)
if b == False:
continue
print('odpowiedz systemu: ' + str(b[0]))
print('stan rzeczywisty: ' + str(not not test_file['metadata']))
csv_file = open("wyniki.csv", 'a')
wr = csv.writer(csv_file)
list = [
trainingFilename, testFilename,
str(b[0]),
str(not not test_file['metadata'])
]
wr.writerows([list])
def __init__(self,
n=20,
chromLen=64,
generationStrategy=None,
selectionStragegy=None,
crossoverStrategy=None,
mutationStrategy=None):
self.numOfChrom = n
self.chromLen = chromLen
self.mutationChance = 7 # for now
self.population = []
# self.mapa = mapa
self.t = Tester()
self.heur = self.t.treasureCount
self.area = self.t.x + self.t.y
self.generator = GenerationStrategy.Heuristic
self.selection = SelectionStrategy.DoubleTrournamentSelection
self.cross = CrossoverStrategy.Take2Random
self.mutation = MutationStrategy.RandomResetting
self.generate()
def setupDevices(self):
# reading devices from parameters server
parameters = self.getParameters()
# creating testers for every device
self.devices_ = [Tester(device["name"], device["topic"], device["directory"],\
device["type"], device["frequency"]) for device in parameters]
"""
Running the class, generating output and plotting the output.
"""
from matplotlib import pyplot as plt
from SOM import SOM
import pandas as pd
import os
from Formatter import FormatCSVFile
from pathlib import Path
import Mapper as mapper
from Tester import Tester
formatter = FormatCSVFile()
tester = Tester()
if Path("huge_merged_csv_file.csv").is_file() is False:
formatter.format_csv_files()
formatter.generate_merged_huge_file()
if Path("Validation Data/validation_file.csv").is_file() is False:
formatter.format_validation_data()
formatter.generate_validation_file()
if Path("Test Data/test_file.csv").is_file() is False:
formatter.format_validation_data()
formatter.generate_validation_file()
# Train SOM, if there is no weights.
if Path("weights.txt").is_file() is False:
# Use pandas for loading data using dataframes.
if __name__ == "__main__":
# targets1 = use_DFS_hash()
# targets2 = use_DFS_marked()
# if len(targets1) != len(targets2):
# print ("discrepancy")
# for i in range (0, len(targets1)):
# if targets1[i] != targets2[i]:
# print ("discrepancy" + str(targets1[i]))
n = 10
k = 25
t = 5
max_target = k**3
trials = 1000
debug = False
tester = Tester(n, k)
test_cases = tester.gen_test_nums(n, k, trials)
target_numbers = tester.gen_target_nums(max_target, trials)
timeouts = [0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1]
for time in timeouts:
test_suite(tester, n, k, time, max_target, trials, debug, test_cases,
target_numbers, False)
max_target = k**4
for time in timeouts:
test_suite(tester, n, k, time, max_target, trials, debug, test_cases,
target_numbers, False)
def main():
tester = Tester(fitnessFunction, alphabeth, genSize, populationSize,
genSize)
tester.test()
print "vector original"
print real
import utils.util as util
from options import options
import os
from Tester import Tester
if __name__ == '__main__':
opt = options.parse()
util.mkdirs(os.path.join(opt.checkpoints_dir, opt.name))
logger = util.get_logger(
os.path.join(opt.checkpoints_dir, opt.name, 'logger.log'))
Tester(opt).test()
raise Exception(
'add continue_train flag to load pretrain embedding...')
trainer.model.save_embeddings()
exit(0)
if params.train_flag:
print('[begin training]')
trainer.run()
# '''
# test
# '''
if params.test_flag:
print('[begin testing]')
model_load_name = trainer.save_best_name
if torch.cuda.is_available():
model.load_state_dict(torch.load(model_load_name))
else:
model.load_state_dict(
torch.load(model_load_name, map_location=torch.device('cpu')))
# ttype = ['test', '1-1', '1-N', 'N-1', 'N-N']
ttype = ['test']
for tt in ttype:
# try:
test_data_loader = get_data_loader(params, tt)
ent_tot, rel_tot = dataset_param(params.data)
tester = Tester(params, ent_tot, rel_tot, model, test_data_loader)
tester.test_run(mode='test')
# except Exception as e:
# print('no test data {}...'.format(tt))
from __future__ import division # Python 2 users only
import nltk, re
from nltk import word_tokenize
from Trainer import Trainer
from Tester import Tester
if __name__ == "__main__":
testingFile = raw_input('Please enter the testing file: ')
test = Tester(testingFile)
test.execute_tests()
opts, args = getopt.getopt(
sys.argv[1:], "c:i:td",
["classifier-dir=", "img-dir=", "teach", "debug"])
except getopt.GetoptError:
print help()
sys.exit(2)
if len(sys.argv) < 3:
print help()
sys.exit(2)
for opt, arg in opts:
if opt in ('-h', '--help'):
print help()
sys.exit()
elif opt in ("-c", "--classifier-dir"):
classifier_dir = arg
elif opt in ("-i", "--img-dir"):
img_dir = arg
elif opt in ("-t", "--teach"):
teach = True
elif opt in ("-d", "--debug"):
debug = True
if teach:
teacher = Teacher(img_dir, classifier_dir, debug)
teacher.teach()
else:
tester = Tester(img_dir, classifier_dir, debug)
tester.test()
cnn_model=RESNET_V1(args.opt , args.use_bn , args.l2_weight_decay, args.logit_type , args.datatype ,args.batch_size, args.cropped_size,\
args.num_epoch ,args.init_lr, args.lr_decay_step, args.model_name ,args.aug_list)
elif 'vgg' in args.model_name:
cnn_model=VGG(args.opt , args.use_bn , args.l2_weight_decay, args.logit_type , args.datatype ,args.batch_size, args.cropped_size,\
args.num_epoch ,args.init_lr, args.lr_decay_step, args.model_name ,args.aug_list)
elif 'inception' in args.model_name:
pass
elif 'densenet' in args.model_name:
cnn_model=Densenet(args.opt , args.use_bn , args.l2_weight_decay, args.logit_type , args.datatype ,args.batch_size, args.cropped_size,\
args.num_epoch ,args.init_lr, args.lr_decay_step, args.model_name ,args.aug_list)
else:
raise NotImplementedError
recorder = Recorder(folder_name=args.model_name)
trainer = Trainer(recorder, train_iter=10)
tester = Tester(recorder)
# Reconstruct Test , Validation Data
test_imgs, test_labs, fnames = cnn_model.dataprovider.reconstruct_tfrecord_rawdata(
cnn_model.dataprovider.test_tfrecord_path, None)
test_labs = utils.cls2onehot(test_labs, cnn_model.n_classes)
val_imgs, val_labs, fnames = cnn_model.dataprovider.reconstruct_tfrecord_rawdata(
cnn_model.dataprovider.val_tfrecord_path, None)
val_labs = utils.cls2onehot(val_labs, cnn_model.n_classes)
if 'aug_clahe' in args.aug_list:
print "Clahe is applied , Validation images , Test Images "
test_imgs = aug.apply_clahe(test_imgs)
val_imgs = aug.apply_clahe(val_imgs)
