def test_iteration(self): Constants.n = 10 Constants.tau = 0.1 t = 1.8 print "----------------------------------------------" print "pradedama nuo: " print "----------------------------------------------" u_now = Functions.u_exact_range(t) Helpers.pretty_print_complex(u_now) u_new_expected = Functions.u_exact_range(t + Constants.tau) u_new_actual = Algorithm._iteration_block(u_now, t) print "----------------------------------------------" print "lauktas rezultatas: " print "----------------------------------------------" Helpers.pretty_print_complex(u_new_expected) print "----------------------------------------------" print "gautas rezultatas: " print "----------------------------------------------" Helpers.pretty_print_complex(u_new_actual) print "Max netiktis: ", Functions.u_error(u_new_actual, t) self.assertTrue(True)
def plot(): plt.figure(figsize=(20, 10)) plt.subplot(221) loss = list(map(float, [i for i in Functions.read_points('loss').split('\n') if i])) all = plt.plot(loss, c='r') plt.legend(all, 'Loss') plt.title("Training Loss") plt.subplot(222) train_acc = list(map(float, [i for i in Functions.read_points('train_acc').split('\n') if i])) all1 = plt.plot(train_acc, c='g') plt.legend(all1, 'Training Accuracy') plt.title("Training Accuracy") plt.subplot(223) valid_acc = list(map(float, [i for i in Functions.read_points('valid_acc').split('\n') if i])) all2 = plt.plot(valid_acc, c='purple') plt.legend(all2, 'Validation accuracy') plt.title("Validation accuracy") plt.subplot(224) time = list(map(float, [i for i in Functions.read_points('time').split('\n') if i])) all3 = plt.plot(time, c='b') plt.legend(all3, 'time') plt.title("Time") plt.savefig(os.path.dirname(os.path.realpath( os.path.dirname(os.path.realpath(__file__)))) + '/graphs/plot.png') print('*** Image of plot saved successfully ***')
def test_f_prime(self): print "-------------------------------------" print "-- F testas" print "-------------------------------------" x, t = 0.7, 1.7 Constants.beta = 1 Constants.n = 5 # pradinis intervalu skaicius Constants.tau = 0.2 # pradinis laiko zingsnis error = [] # netiktys for i in range(0, 15): # tikrinamos reiksmes is tiksliu funkciju u_now0 = Functions.u_exact(x - Constants.h(), t) u_now1 = Functions.u_exact(x, t) u_now2 = Functions.u_exact(x + Constants.h(), t) u_next0 = Functions.u_exact(x - Constants.h(), t + Constants.tau) u_next1 = Functions.u_exact(x, t + Constants.tau) u_next2 = Functions.u_exact(x + Constants.h(), t + Constants.tau) f_now = Functions.f(x,t) f_next = Functions.f(x, t + Constants.tau) # print "F testo f_now, f_next:", f_now, f_next f_prime_val = Functions.f_prime(u_now0, u_now1, u_now2, u_next0, u_next1, u_next2, f_now, f_next) # print "F reiksme:", Constants.h(), f_prime_val result = u_now2 - (Constants.u_const() * u_now1) + u_now0 + f_prime_val error.append(abs(result)) # print "h, tau = ", Constants.h(), ",", Constants.tau # print result # print "-------------------------------------" Constants.n *= 2 Constants.tau /= 2.0 Helpers.pretty_print_complex(error) self.assertTrue(True)
def test_iteration_precision(self): t = 0.8 Constants.n = 10 Constants.tau = 1.0 errors = [] for i in range(0, 5): u_now = Functions.u_exact_range(t) # tikslios reiksmes dabartiniu laiko momentu u_next = Algorithm._iteration_block(u_now, t) # isskaiciuotos reikmes sekanciu laiko momentu errors.append(Functions.u_error(u_next, t + Constants.tau)) # netiktis Constants.n *= 3 Constants.tau /= 3 Helpers.pretty_print_complex(errors) self.assertTrue(True)
def test_algorithm(self): print "-------------------------------------" print "-- Viso algoritmo testas" print "-------------------------------------" Constants.n = 4 Constants.tau = 0.1 errors = [] for i in range(0, 5): u_initial = Functions.u_exact_range(0.0) # tikslios reiksmes pradiniu laiko momentu func_points, time_points = Algorithm.run(u_initial) max_error = Functions.u_error_total(func_points, time_points) errors.append(max_error) Constants.n *= 2 # Constants.tau /= 2 Helpers.pretty_print_complex(errors) self.assertTrue(True)
def test_solve(self): t = 2.7 # koks nors laiko momentas u = Functions.u_exact_range(t) # laukiamos tikslios reiksmes # sufabrikuotos desines lygybes puses reiksmes (F) fake_f_prime = [] for i in range(1, len(u) - 1): f = u[i+1] - (Constants.u_const() * u[i]) + u[i-1] # butinai reikia padauginti is -1, nes algoritmas tikisi F reiksmiu, bet desinese lygybiu pusese yra -F f *= -1 fake_f_prime.append(f) # testas actual = ThomasAlgorithm.solve(Constants.u_const(), fake_f_prime, Constants.kappa, Constants.gamma) equal = Helpers.almost_equal_complex(u, actual) self.assertTrue(equal)
def test_f(self): print "-------------------------------------" print "-- f(x,t) testas" print "-------------------------------------" x, t = 0.42, 0.8 Constants.beta = 3 Constants.n = 10 # pradinis intervalu skaicius Constants.tau = 0.1 # pradinis laiko zingsnis errors = [] for i in range(0, 7): print Constants.h(), Constants.tau # print x, t # tikrinamos reiksmes is tiksliu funkciju u_now0 = Functions.u_exact(x - Constants.h(), t) u_now1 = Functions.u_exact(x, t) u_now2 = Functions.u_exact(x + Constants.h(), t) u_next0 = Functions.u_exact(x - Constants.h(), t + Constants.tau) u_next1 = Functions.u_exact(x, t + Constants.tau) u_next2 = Functions.u_exact(x + Constants.h(), t + Constants.tau) f_now = Functions.f(x,t) f_next = Functions.f(x, t + Constants.tau) # kaire algoritmo lygybes puse left = (u_next1 - u_now1) / Constants.tau # desine algoritmo lygybes puse right11 = (u_next2 - 2.0 * u_next1 + u_next0) / pow(Constants.h(), 2) right12 = (u_now2 - 2.0 * u_now1 + u_now0) / pow(Constants.h(), 2) right1 = 1j * 0.5 * (right11 + right12) right21 = (pow(abs(u_next2), 2) * u_next2 - pow(abs(u_next0), 2) * u_next0) / (Constants.h() * 2.0) right22 = (pow(abs(u_now2), 2) * u_now2 - pow(abs(u_now0), 2) * u_now0) / (Constants.h() * 2.0) right2 = Constants.beta * 0.5 * (right21 + right22) right3 = (f_next + f_now) / 2.0 right = right1 + right2 + right3 errors.append(abs(left - right)) Constants.n *= 10 Constants.tau /= 10.0 Helpers.pretty_print_complex(errors) # self.assertTrue(Helpers.sequence_descending(errors)) self.assertTrue(True)
model_history_path = '../train_info/{}_{}_modelHis.dat'.format( data_name, epochs) history_path = '../train_info/{}_{}_his.jpg'.format(data_name, epochs) pred_path = '../train_info/{}_{}_pred.jpg'.format(data_name, epochs) target_size = (32, 32) classes = 10 num_pred = 30 batch_size = 32 gray = False load_existent_model = False # load train and test data print('loading data ...') # (x_train, y_train), (x_test, y_test) = Funcs.load_data(dirs, target_size, gray=gray, classes=classes) (x_train, y_train), (x_test, y_test) = load_data() (x_train, y_train) = Funcs.trans_data(x_train, y_train, classes) (x_test, y_test) = Funcs.trans_data(x_test, y_test, classes) print('loading data done') # define callbacks for models to render model performance better checkpoint = ModelCheckpoint(model_save_path, monitor='val_acc', save_best_only=True, verbose=0) lrschedual = LearningRateScheduler( lambda epoch: Funcs.lr_schedual(epoch, epochs=epochs), verbose=0) # whether load existent model if load_existent_model and os.path.exists(model_load_path): model = load_model(model_load_path) else:
model_load_path = '../models/{}_{}_{}.h5'.format(data_name, epochs, 9947) model_history_path = '../train_info/{}_{}_modelHis.dat'.format( data_name, epochs) history_path = '../train_info/{}_{}_his.jpg'.format(data_name, epochs) pred_path = '../train_info/{}_{}_pred.jpg'.format(data_name, epochs) target_size = (28, 28) classes = 10 num_pred = 30 batch_size = 32 gray = True load_existent_model = False # load train and test data print('loading data ...') (x_train, y_train), (x_test, y_test) = Funcs.load_data(dirs, target_size, gray=gray, classes=classes) print('loading data done') # define callbacks for models to render model performance better checkpoint = ModelCheckpoint(model_save_path, monitor='val_acc', save_best_only=True, verbose=1) lrschedual = LearningRateScheduler( lambda epoch: Funcs.lr_schedual(epoch, epochs=epochs), verbose=0) # whether load existent model if load_existent_model and os.path.exists(model_load_path): model = load_model(model_load_path) else:
Created on 08.03.2016 @author: cypher9 ''' from src.info import Info from src.functions import Functions from src.xml_func import write_xml from src.crypto import set_password,change_password from os.path import isfile if __name__ == '__main__': info = Info() info.start_text() function = Functions() if isfile('termine.enc'): function.xml_to_cal() else: set_password() write_xml("") options = {1 : function.add_event, 2 : info.submenu_search, 3 : info.submenu_view, 4 : info.submenu_delete, 5 : function.print_calendar, 6 : info.help, 7 : change_password,
''' Created on 08.03.2016 @author: cypher9 ''' from src.info import Info from src.functions import Functions from src.xml_func import write_xml from src.crypto import set_password, change_password from os.path import isfile if __name__ == '__main__': info = Info() info.start_text() function = Functions() if isfile('termine.enc'): function.xml_to_cal() else: set_password() write_xml("") options = { 1: function.add_event, 2: info.submenu_search, 3: info.submenu_view, 4: info.submenu_delete, 5: function.print_calendar, 6: info.help, 7: change_password, 0: function.quit }
def loader(self): _, (self.source_vocab_to_int, self.target_vocab_to_int), \ (self.source_int_to_vocab, self.target_int_to_vocab) = Main().load_process() self.load_path = Functions().load_params()
#!/usr/bin/python import sys from src.algorithm import Algorithm from src.constants import Constants from src.functions import Functions runs = int(sys.argv[1]) # skaiciavimai Constants.n = 5 Constants.tau = 0.1 # penkis kartus mazinami zingsniai for i in range(0, runs): u_initial = Functions.u_exact_range(0) func_points, time_points = Algorithm.run(u_initial) error_total = Functions.u_error_total(func_points, time_points) print "h = %.5f, tau = %.5f, netiktis: %.10f" % (Constants.h(), Constants.tau, error_total) Constants.n *= 2 Constants.tau /= 2.0
#!/usr/bin/python from src.functions import Functions from src.constants import Constants from src.algorithm import Algorithm from src.plot import Plot # testine animacija Constants.n = 10 Constants.tau = 0.01 u_initial = Functions.u_exact_range(0) func_points, time_points = Algorithm.run(u_initial) p = Plot() p.set_data(func_points, time_points) p.animate(5.0)
def train(self): epochs, batch_size, rnn_size, _, _, _, learning_rate, keep_probability = Params( ).get() train_source = self.source_int_text[batch_size:] train_target = self.target_int_text[batch_size:] valid_source = Functions().pad_sentence_batch( self.source_int_text[:batch_size]) valid_target = Functions().pad_sentence_batch( self.target_int_text[:batch_size]) with tf.Session(graph=self.train_graph) as sess: sess.run(tf.global_variables_initializer()) for epoch_i in range(epochs): for batch_i, (source_batch, target_batch) \ in enumerate(Functions().batch_data(train_source, train_target, batch_size)): start_time = time.time() _, loss = sess.run( [self.train_op, self.cost], { self.input_data: source_batch, self.targets: target_batch, self.lr: learning_rate, self.sequence_length: target_batch.shape[1], self.keep_prob: keep_probability }) batch_train_logits = sess.run(self.inference_logits, { self.input_data: source_batch, self.keep_prob: 1.0 }) batch_valid_logits = sess.run(self.inference_logits, { self.input_data: valid_source, self.keep_prob: 1.0 }) train_acc = self.get_accuracy(target_batch, batch_train_logits) valid_acc = self.get_accuracy(np.array(valid_target), batch_valid_logits) end_time = time.time() time_ = end_time - start_time sys.stdout.write( '\r epoch: {:>3} batch: {:>4}/{} - train_acc: {:>6.3f}, validation_acc: {:>6.3f}, Loss: {:>6.3f} time: {:>6.3f}s' .format(epoch_i, batch_i, len(self.source_int_text) // batch_size, train_acc, valid_acc, loss, time_)) Functions.save_points(loss, 'loss') Functions.save_points(train_acc, 'train_acc') Functions.save_points(valid_acc, 'valid_acc') Functions.save_points(time_, 'time') saver = tf.train.Saver() saver.save(sess, self.save_path) sys.stdout.write('\r Training finished, model saved....') Functions().save_params(self.save_path)
dirs = '../data/{}'.format(data_name) json_path = '{}/index.json'.format(dirs) model_save_path = '../models/{}_{}.h5'.format(data_name, epochs) model_load_path = '../models/{}_{}_{}.h5'.format(data_name, epochs, 10) model_history_path = '../train_info/{}_{}_modelHis.dat'.format(data_name, epochs) history_path = '../train_info/{}_{}_his.jpg'.format(data_name, epochs) pred_path = '../train_info/{}_{}_pred.jpg'.format(data_name, epochs) target_size = (224, 224) num_pred = 30 batch_size = 32 gray = False load_existent_model = False # load train and test data print('loading data ...') (images, labels, counts) = Funcs.read_images_from_directories(dirs, target_size, get_counts=True, init_json=True, shuffle=True) classes = len(counts) (x_train, y_train), (x_test, y_test) = Funcs.split_train_test(images, labels, counts) (x_train, y_train) = Funcs.trans_data(x_train, y_train, classes) (x_test, y_test) = Funcs.trans_data(x_test, y_test, classes) print('loading data done') # define callbacks for models to render model performance better checkpoint = ModelCheckpoint(model_save_path, monitor='val_acc', save_best_only=True, verbose=0) lrschedual = LearningRateScheduler(lambda epoch: Funcs.lr_schedual(epoch, epochs=epochs), verbose=0) # whether load existent model if load_existent_model and os.path.exists(model_load_path): model = load_model(model_load_path) else: model = model_design(x_train.shape[1:], classes)