def test_cli_route_prefix_table(): kern = kernel.Kernel(log=None, log_id="", table_name="main") if not kern.platform_supported: return # We assume that the main route table always has a default route, and we look for this: # +--------------------------+------------------+ # | Table | Main | # | Address Family | IPv4 | # | Destination | 0.0.0.0/0 | # | Type | Unicast | # | Protocol | Boot | << or Dhcp in some deployments # | Scope | Universe | # | Next-hops | eth0 172.17.0.1 | # | Priority | | # | Preference | | # | Preferred Source Address | | # | Source | | # | Flow | | # | Encapsulation Type | | # | Encapsulation | | # | Metrics | | # | Type of Service | 0 | # | Flags | 0 | # +--------------------------+------------------+ default_prefix = packet_common.make_ip_prefix("0.0.0.0/0") tab_str = kern.cli_route_prefix_table(254, default_prefix).to_string() pattern = (r"[|] Table +[|] Main +[|]\n" r"[|] Address Family +[|] IPv4 +[|]\n" r"[|] Destination +[|] 0\.0\.0\.0/0 +[|]\n" r"[|] Type +[|] Unicast +[|]\n" r"[|] Protocol +[|] (Boot|Dhcp) +[|]\n" r"[|] Scope +[|] Universe +[|]\n") assert re.search(pattern, tab_str) is not None
def test_gaussian_energy_matrix_values(self): kern = kernel.Kernel('gaussian', 1) expected_val = np.ones((10, 10)) * exp(-1) np.fill_diagonal(expected_val, 1) exp_eye = kern.kernel_mat(np.eye(10), np.eye(10)) self.assertTrue(np.array_equal(exp_eye, expected_val))
def testKernel(self): testfile_path = os.path.dirname(__file__) test_skeleton = skeleton.Skeleton() test_skeleton.Load( os.path.join(testfile_path, "simple_skeleton.pb.txt")) s1 = np.zeros((2, 4, 4, 2), dtype=np.float32) s1[0, :, :, 0] = [[1.0, 0, 1, 1], [1, 0, 1, 0], [1, 1, 1, 0], [1, 1, 1, 1]] s1[0, :, :, 1] = [[0.0, 1, 0, 0], [0, 1, 0, 1], [0, 0, 0, 1], [0, 0, 0, 0]] s1[1, :, :, 0] = np.ones((4, 4)) s2 = np.zeros((3, 4, 4, 2), dtype=np.float32) s2[0, :, :, 0] = [[1.0, 0, 1, 1], [1, 0, 1, 0], [1, 1, 1, 0], [1, 1, 1, 1]] s2[0, :, :, 1] = [[0.0, 1, 0, 0], [0, 1, 0, 1], [0, 0, 0, 1], [0, 0, 0, 0]] s2[1, :, :, 0] = np.ones((4, 4)) s2[2, :, :, 0] = np.ones((4, 4)) with tf.Graph().as_default(), tf.Session('') as sess: s1_tf = tf.constant(s1, dtype=tf.float32) s2_tf = tf.constant(s2, dtype=tf.float32) ker = tf.reshape(kernel.Kernel(test_skeleton, s1_tf, s2_tf), [s1.shape[0], s2.shape[0]]) kernel_tf = sess.run([ker])[0] print kernel_tf self.assertAlmostEqual(0.80775118, kernel_tf[0, 1]) self.assertAlmostEqual(0.80775118, kernel_tf[0, 2]) self.assertAlmostEqual(0.80775118, kernel_tf[1, 0]) self.assertAlmostEqual(1.0, kernel_tf[0, 0], 6) self.assertAlmostEqual(1.0, kernel_tf[1, 1], 6) self.assertAlmostEqual(1.0, kernel_tf[1, 2], 6)
def TrainRBFKernelServer(self, lmbda=.1, gamma=50., sampling_factor=1. / 1000.): """ Fit Kernelized RBF Ridge Regression to the current image on the server :param lmbda: :param gamma: gamma factor to build the kernel (https://en.wikipedia.org/wiki/Radial_basis_function_kernel) :param sampling_factor: percentage of pixels to sample to build the model :return: """ self._BuildDataSet(sampling_factor, normalize=True) inputs = self.inputs outputs = self.outputs labels_input = self.bands_modeling_estimation_input labels_output = self.bands_modeling_estimation_output # Train self.distance_krr = kernel.RBFDistance(kernel.RBFDistance(gamma)) self.gamma = gamma self.lmbda = lmbda self.kernel_rbf = kernel.Kernel(inputs, labels_input, self.distance_krr, weight_property="weight") outputs_eeArray = converters.eeFeatureCollectionToeeArray( outputs, labels_output) self.alpha = self.kernel_rbf.getAlphaeeArray(outputs_eeArray, lmbda)
def test_put_del_route_unreachable(): kern = kernel.Kernel(log=None, log_id="", table_name="main") if not kern.platform_supported: return # Add unreachable prefix in the kernel routing table (no next hops) prefix = packet_common.make_ip_prefix("99.99.99.99/32") nhops = [] rte = fib_route.FibRoute(prefix, nhops) assert kern.put_route(rte) tab_str = kern.cli_route_prefix_table(254, prefix).to_string() pattern = (r"[|] Table +[|] Main +[|]\n" r"[|] Address Family +[|] IPv4 +[|]\n" r"[|] Destination +[|] 99\.99\.99\.99/32 +[|]\n" r"[|] Type +[|] Unreachable +[|]\n" r"[|] Protocol +[|] RIFT +[|]\n" r"[|] Scope +[|] Universe +[|]\n" r"[|] Next-hops +[|] +[|]\n" r"[|] Priority +[|] 199 +[|]\n") assert re.search(pattern, tab_str) is not None # Replace unreachable route with a route containing one next hop new_nhops = [next_hop.NextHop("lo", packet_common.make_ip_address("127.0.0.1"))] rte = fib_route.FibRoute(prefix, new_nhops) assert kern.put_route(rte) tab_str = kern.cli_route_prefix_table(254, prefix).to_string() pattern = (r"[|] Table +[|] Main +[|]\n" r"[|] Address Family +[|] IPv4 +[|]\n" r"[|] Destination +[|] 99\.99\.99\.99/32 +[|]\n" r"[|] Type +[|] Unicast +[|]\n" r"[|] Protocol +[|] RIFT +[|]\n" r"[|] Scope +[|] Universe +[|]\n" r"[|] Next-hops +[|] lo 127.0.0.1 +[|]\n" r"[|] Priority +[|] 199 +[|]\n") assert re.search(pattern, tab_str) is not None # Delete next hops assert kern.del_route(prefix)
def malloc(size): address = kernel.Kernel().allocate_memory(size) if address is None: raise Exception("Couldn't allocate memory") LOG.debug("Allocated {} bytes at address {:04X}".format(size, address)) return address
def test_linear_cosistency(self): import json import copy import numpy as np import kernel import configuration import calibration # load teset data descriptors = np.loadtxt('test_data/c_lin_10.out') weights = np.loadtxt('test_data/w_lin_10.out') with open('test_data/lin_10.json', 'r') as u_conf: user_config = json.load(u_conf) # make a list of the allowed qs qs = np.arange(1, user_config['nr_modi']+1) * np.pi / user_config['cutoff'] # read in data and save parameters for calibration comparison (_, _, lat, configurations) = calibration.load_data(user_config) config = configurations[0] # load linear kernel kern = kernel.Kernel(*user_config['kernel']) # init descriptors of the test configuration config.init_nn(user_config['cutoff'], lat) config.init_descriptor(qs) # make perturbed configs and init them dx = 1e-4 config_plus = copy.deepcopy(config) config_minus = copy.deepcopy(config) config_plus.positions[0, 0] += dx config_minus.positions[0, 0] -= dx config_plus.init_nn(user_config['cutoff'], lat) config_plus.init_descriptor(qs) config_minus.init_nn(user_config['cutoff'], lat) config_minus.init_descriptor(qs) # build the perturbed matrix elements kplus = np.sum(kern.kernel_mat(config_plus.descriptors, descriptors), axis=0) kminus = np.sum(kern.kernel_mat(config_minus.descriptors, descriptors), axis=0) # make the finite difference values eplus = kplus @ weights eminus = kminus @ weights # calculate forces by finite differences Fx_finite = (eplus - eminus) / (2 * dx) # calculate forces by regression F_reg = kern.force_submat(qs, config, descriptors) @ weights print('\n', f'Linear difference: {Fx_finite - F_reg[0]}') self.assertAlmostEqual(Fx_finite, F_reg[0], 6)
def init(error_callback=None): global dummy global animManager global error animManager = anim.Manager() dummy = kernel.Kernel() dummy.Init() error = error_callback
def test_put_del_route_errors(): kern = kernel.Kernel(log=None, log_id="", table_name="main") if not kern.platform_supported: return # Attempt to add route with nonsense next-hop interface prefix = packet_common.make_ip_prefix("99.99.99.99/32") nhops = [next_hop.NextHop("nonsense", None)] rte = fib_route.FibRoute(prefix, nhops) assert not kern.put_route(rte)
def test_basics(self): """ Tests basic functionality. """ self.report('Testing basic functionality.') kern_1 = kernel.Kernel() kern_1.set_hyperparams(param_1=1, param_2=2, param_3=3) assert dicts_are_equal(kern_1.hyperparams, self.hyper_param_dict_1) kern_1.add_hyperparams(**self.hyper_param_dict_2) assert dicts_are_equal(kern_1.hyperparams, self.hyper_param_dict_3) kern_1.set_hyperparams(**self.hyper_param_dict_2) assert dicts_are_equal(kern_1.hyperparams, self.hyper_param_dict_2)
def main(config): logging.getLogger().setLevel(logging.DEBUG) server = kernel.Kernel(config) def sig_handler(sig, frame): server.stop() signal.signal(signal.SIGTERM, sig_handler) signal.signal(signal.SIGINT, sig_handler) server.loop()
def main(): """Функция найдет следующий вопрос и отправит в зарегистрированные группы телеграм""" app = kernel.Kernel() question_quiz = get_question_quiz( app=app, question_number=get_question_number(app=app)) correct_option_id = randomize_options(options=question_quiz.options) create_telegram_quiz( app=app, question=question_quiz.question, options=question_quiz.options, correct_option_id=correct_option_id, )
def __init__(self, stream, initial_clusters=1, kernelFunction=rbf.rbf, initial_points_m=2): self.stream = stream self.initial_clusters = initial_clusters self.kernelFunction = kernelFunction self.initial_points_m = initial_points_m self.kernel = kernel.Kernel(np.array([[1]], dtype=float), np.array([1], dtype=float), np.array([[1]], dtype=float)) self.clusters = [] for i in range(0, initial_clusters): self.clusters.append(Cluster())
def setUp(self): cosmo = cosmology.MultiEpoch(0.0, 5.0, cosmo_dict=c_dict) lens_dist = kernel.dNdzMagLim(z_min=0.0, z_max=2.0, a=2, z0=0.3, b=2) source_dist = kernel.dNdzGaussian(z_min=0.0, z_max=2.0, z0=1.0, sigma_z=0.2) lens_window = kernel.WindowFunctionGalaxy( lens_dist, cosmo_multi_epoch=cosmo) source_window = kernel.WindowFunctionConvergence( source_dist, cosmo_multi_epoch=cosmo) self.kern = kernel.Kernel(0.001*0.001*degToRad, 1.0*100.0*degToRad, window_function_a=lens_window, window_function_b=source_window, cosmo_multi_epoch=cosmo) self.ln_ktheta_array = numpy.linspace(-15, -1, 4)
def example(num_samples=10, num_features=784, grid_size=20, filename="svm.pdf"): samples = np.matrix( np.random.normal(size=num_samples * num_features).reshape( num_samples, num_features)) samples = train_x labels = 2 * (samples.sum(axis=1) > 0) - 1.0 labels = train_y - 2 print("sample variance :", np.var(samples)) trainer = svmpy.SVMTrainer(kernel.Kernel()._polykernel(120, 1), 0.1) predictor = trainer.train(samples, labels) predictAll(test_x, test_y, predictor)
def __init__(self, theta_min, theta_max, window_function_a, window_function_b, cosmo_dict=None, input_hod=None, halo_dict=None, powSpec=None, **kws): self.log_theta_min = numpy.log10(theta_min) self.log_theta_max = numpy.log10(theta_max) self.theta_array = numpy.logspace( self.log_theta_min, self.log_theta_max, defaults.default_precision["corr_npoints"]) if theta_min == theta_max: self.log_theta_min = numpy.log10(theta_min) self.log_theta_max = numpy.log10(theta_min) self.theta_array = numpy.array([theta_min]) self.wtheta_array = numpy.zeros(self.theta_array.size) # Hard coded, but we shouldn't expect halos outside of this range. self._k_min = 0.001 self._k_max = 100.0 if cosmo_dict == None: cosmo_dict = defaults.default_cosmo_dict self.cosmo_dict = cosmo_dict self.kernel = kernel.Kernel(self._k_min * theta_min, self._k_max * theta_max, window_function_a, window_function_b, cosmo_dict) self.D_z = self.kernel.cosmo.growth_factor(self.kernel.z_bar) if halo_dict is None: halo_dict = defaults.default_halo_dict self.halo = halo.Halo(self.kernel.z_bar, input_hod, cosmo_dict, halo_dict) if powSpec == None: powSpec = 'linear_power' try: self.power_spec = self.halo.__getattribute__(powSpec) except AttributeError or TypeError: print "WARNING: Invalid input for power spectra varriable," print "\t setting to linear_power" self.power_spec = self.halo.__getattribute__('linear_power')
def test_linear_energy_subrow(self): descr1 = np.eye(20, 10) descr2 = np.zeros((20, 10)) descr2[0, 0] = 1 kern = kernel.Kernel('linear') subrow = np.sum(kern.kernel_mat(descr1, descr2), axis=1) self.assertEqual(np.shape(subrow), (20, )) self.assertEqual(subrow[0], 1) self.assertTrue(np.array_equal(subrow[1:], np.zeros(19))) descr2 = np.eye(20, 10) subrow = np.sum(kern.kernel_mat(descr1, descr2), axis=1) self.assertTrue(np.array_equal(subrow[:10], np.ones(10))) self.assertTrue(np.array_equal(subrow[10:], np.zeros(10)))
def test_cli_addresses_table(): kern = kernel.Kernel(log=None, log_id="", table_name="main") if not kern.platform_supported: return # We assume the loopback interface (lo) is always there, and we look for something like this: # +-----------+------------+------------+----------------+---------+ # | Interface | Address | Local | Broadcast | Anycast | # | Name | | | | | # +-----------+------------+------------+----------------+---------+ # | lo | 127.0.0.1 | 127.0.0.1 | | | tab_str = kern.cli_addresses_table().to_string() pattern = (r"[|] Interface +[|] +Address +[|] +Local +[|] +Broadcast +[|] +Anycast +[|]\n" r"[|] Name +[|] +[|] +[|] +[|] +[|]\n" r"(.|[\n])*" r"[|] lo +[|] 127\.0\.0\.1 +[|] 127\.0\.0\.1 +[|] +[|] +[|]\n") assert re.search(pattern, tab_str) is not None
def test_linear_energy_matrix_element(self): kern = kernel.Kernel('linear') descr1 = np.eye(10, 10) zero_el = np.sum(kern.kernel_mat(descr1, np.zeros(10)), axis=0) self.assertEqual(type(zero_el), np.float64) self.assertEqual(zero_el, 0) one = np.array([1] + [0 for _ in range(9)]) one_el = np.sum(kern.kernel_mat(descr1, one), axis=0) self.assertEqual(one_el, 1) one = np.ones(10) ten_el = np.sum(kern.kernel_mat(descr1, one), axis=0) self.assertEqual(ten_el, 10) five = 5 * one fifty_el = np.sum(kern.kernel_mat(descr1, five), axis=0) self.assertEqual(fifty_el, 50)
def test_cli_routes_table(): packet_common.add_missing_methods_to_thrift() kern = kernel.Kernel(log=None, log_id="", table_name="main") if not kern.platform_supported: return # We assume that the main route table always has a default route, and we look for this: # +-------------+---------+--------------------+-------------+-----------+-----------+------------+--------+ # | Table | Address | Destination | Type | Protocol | Outgoing | Gateway | Weight | # | | Family | | | | Interface | | | # +-------------+---------+--------------------+-------------+-----------+-----------+------------+--------+ # ... # | Main | IPv4 | 0.0.0.0/0 | Unicast | Boot/Dhcp | eth0 | 172.17.0.1 | | # ... tab_str = kern.cli_routes_table(254).to_string() pattern = (r"[|] Table +[|] Address +[|] Destination +[|] Type +[|] Protocol +[|] Outgoing +[|] Gateway +[|] Weight +[|]\n" r"[|] +[|] Family +[|] +[|] +[|] +[|] Interface +[|] +[|] +[|]\n" r"(.|[\n])*" r"[|] Main +[|] IPv4 +[|] 0\.0\.0\.0/0 +[|] Unicast +[|]") assert re.search(pattern, tab_str) is not None
def test_cli_links_table(): kern = kernel.Kernel(log=None, log_id="", table_name="main") if not kern.platform_supported: return # We assume the loopback interface (lo) is always there, and we look for something like this: # +-----------+-----------+-------------------+-------------------+-----------+-------+-----------+ # | Interface | Interface | Hardware | Hardware | Link Type | MTU | Flags | # | Name | Index | Address | Broadcast | | | | # | | | | Address | | | | # +-----------+-----------+-------------------+-------------------+-----------+-------+-----------+ # | lo | 1 | 00:00:00:00:00:00 | 00:00:00:00:00:00 | | 65536 | UP | # ... tab_str = kern.cli_links_table().to_string() pattern = (r"[|] Interface +[|] +Interface +[|] +Hardware +[|] +Hardware +[|] +Link Type +[|] +MTU +[|] +Flags +[|]\n" r"[|] Name +[|] +Index +[|] +Address +[|] +Broadcast +[|] + +[|] + +[|] + +[|]\n" r"[|] +[|] + +[|] + +[|] +Address +[|] + +[|] + +[|] + +[|]\n" r"(.|[\n])*" r"[|] lo +[|] +[0-9]+ +[|] +[0-9:]+ +[|] +[0-9:]+ +[|] + +[|] +[0-9 ]+[|] +UP +[|]\n") assert re.search(pattern, tab_str) is not None
def _reCalculateKernel(self, point): matrix_old = np.copy(self.kernel.kernel_matrix) kernel_xt = self.kernelFunction(point, point, 1.5) # Calculate gamma # = Distances of point_xt to every point in stream gamma = np.array([[]], dtype=float) for i in range(0, len(self.stream)): gamma = np.hstack( (gamma, [[self.kernelFunction(point, self.stream[i], 1.5)]])) # Calculate gamma transposed gamma_transposed = np.transpose(gamma) # Generate new matrix K old_length = matrix_old.shape[0] matrix_size = old_length + 1 matrix_new = np.zeros((matrix_size, matrix_size)) # Copy old content for i in range(0, old_length): for j in range(0, old_length): matrix_new[i, j] = matrix_old[i, j] matrix_new[0:matrix_size - 1, old_length:matrix_size] = gamma_transposed matrix_new[old_length:matrix_size, 0:matrix_size - 1] = gamma matrix_new[matrix_size - 1, matrix_size - 1] = kernel_xt print(self.stream) print(matrix_new) print() # Calculate the eigenvalues and eigenvectors eigenvalues, eigenvectors = np.linalg.eig(matrix_new) print(eigenvalues) print(eigenvectors) # Save only the first C=cluster size eigenvectors and eigenvalues return kernel.Kernel(matrix_new, eigenvalues, eigenvectors)
def predict_linear(u_conf: dict, configurations, C: np.array, q) -> (np.array, np.array, np.array, np.array): ''' Loads the calibration data, initializes the kernel and then builds the linear system with the kernel matrices according to kernel ''' directory = u_conf['file_out'] C_cal = np.array(np.loadtxt(directory + '/calibration_C.out'), dtype=float) kern = kernel.Kernel(*u_conf['kernel']) n_conf = u_conf['N_conf'] n_ion = u_conf['N_ion'] nc_ni = np.shape(C_cal)[0] # will be the super vectors E = np.zeros(n_conf) # Holds forces flattened F = np.zeros(n_conf * n_ion * 3) T = np.zeros((n_conf * n_ion * 3, nc_ni)) # build the linear system t_0 = time() print('Building K ...', end='\r') descr_new = C.reshape(n_conf * n_ion, len(q)) # das erste Argument ist die aktuelle Konfiguration, das zweite die Referenz-Konfiguration # this holds the matrix-elements in the shape [sum_j K(C^beta_j, C^alpha_i)]^beta_(alpha, i) K = kern.kernel_mat(descr_new, C_cal) K = np.sum( K.reshape(n_conf, n_ion, nc_ni), axis=1 ) print(f'Building K: finished after {time()-t_0:.3} s') t_0 = time() for alpha in range(n_conf): print(f'Building T: {alpha+1}/{n_conf}', end='\r') E[alpha] = configurations[alpha].energy F[alpha*n_ion*3: (alpha+1)*n_ion*3] = configurations[alpha].forces.flatten() T[alpha*n_ion*3:(alpha+1)*n_ion*3] = kern.force_submat(q, configurations[alpha], C_cal) print(f'Building T: finished after {time()-t_0:.3} s') return (E, F, K, T)
def test_put_del_route(): kern = kernel.Kernel(log=None, log_id="", table_name="5") if not kern.platform_supported: return # Put route with one next-hop (with interface but no address) prefix = packet_common.make_ip_prefix("99.99.99.99/32") nhops = [next_hop.NextHop("lo", None)] rte = fib_route.FibRoute(prefix, nhops) assert kern.put_route(rte) # Delete route just added assert kern.del_route(prefix) # Put route with one next-hop (with interface and address) prefix = packet_common.make_ip_prefix("99.99.99.99/32") address = packet_common.make_ip_address("127.0.0.1") nhops = [next_hop.NextHop("lo", address)] rte = fib_route.FibRoute(prefix, nhops) assert kern.put_route(rte) # Delete route just added assert kern.del_route(prefix) # Put ECMP route with multiple next-hop (with interface and address) prefix = packet_common.make_ip_prefix("99.99.99.99/32") address1 = packet_common.make_ip_address("127.0.0.1") address2 = packet_common.make_ip_address("127.0.0.2") nhops = [next_hop.NextHop("lo", address1), next_hop.NextHop("lo", address2)] rte = fib_route.FibRoute(prefix, nhops) assert kern.put_route(rte) # Do we display the ECMP route properly? tab_str = kern.cli_route_prefix_table(5, prefix).to_string() pattern = (r"[|] Table +[|] 5 +[|]\n" r"[|] Address Family +[|] IPv4 +[|]\n" r"[|] Destination +[|] 99\.99\.99\.99/32 +[|]\n" r"[|] Type +[|] Unicast +[|]\n" r"[|] Protocol +[|] RIFT +[|]\n" r"[|] Scope +[|] Universe +[|]\n" r"[|] Next-hops +[|] lo 127\.0\.0\.1 1 +[|]\n" r"[|] +[|] lo 127\.0\.0\.2 1 +[|]\n") assert re.search(pattern, tab_str) is not None # Delete route just added assert kern.del_route(prefix)
def build_linear(u_conf: dict, configurations: list, C: np.array, q: np.array) -> (np.array, np.array, np.array, np.array): ''' Intializes the kernel and then builds the linear system with the kernel matrices according to kernel. Already normalizes the data to <E> = 0. ''' kern = kernel.Kernel(*u_conf['kernel']) n_conf = u_conf['N_conf'] n_ion = u_conf['N_ion'] nc_ni = n_conf * n_ion # will be the super vectors E = np.zeros(n_conf) # Holds forces flattened F = np.zeros(n_conf * n_ion * 3) # The Matrix that is used for fitting the forces T = np.zeros((n_conf * n_ion * 3, nc_ni)) # reshape descriptors descr = C.reshape(n_conf * n_ion, len(q)) t_0 = time() print('Building K:', end='\r') # das erste Argument ist die aktuelle Konfiguration, das zweite die Referenz-Konfiguration K = kern.kernel_mat(descr, descr) K = np.sum(K.reshape(n_conf, n_ion, nc_ni), axis=1) print(f'Building K: finished after {time()-t_0:.3} s') t_0 = time() for alpha in range(n_conf): print(f'Building [E, F, T]: {alpha+1}/{n_conf}', end='\r') E[alpha] = configurations[alpha].energy F[alpha * n_ion * 3:(alpha + 1) * n_ion * 3] = configurations[alpha].forces.flatten() T[alpha * n_ion * 3:(alpha + 1) * n_ion * 3] = kern.force_submat( q, configurations[alpha], descr) print(f'Building [E, F, T]: finished after {time()-t_0:.3} s') return (E, F, K, T)
def setUp(self): cosmo_multi = cosmology.MultiEpoch(0.0, 5.0, cosmo_dict=c_dict) lens_dist = kernel.dNdzMagLim(z_min=0.0, z_max=2.0, a=2, z0=0.3, b=2) source_dist = kernel.dNdzGaussian(z_min=0.0, z_max=2.0, z0=1.0, sigma_z=0.2) lens_window = kernel.WindowFunctionGalaxy( lens_dist, cosmo_multi_epoch=cosmo_multi) source_window = kernel.WindowFunctionConvergence( source_dist, cosmo_multi_epoch=cosmo_multi) kern = kernel.Kernel(0.001*0.001*deg_to_rad, 1.0*100.0*deg_to_rad, window_function_a=lens_window, window_function_b=source_window, cosmo_multi_epoch=cosmo_multi) zheng = hod.HODZheng(hod_dict) cosmo_single = cosmology.SingleEpoch(0.0, cosmo_dict=c_dict) h = halo.Halo(input_hod=zheng, cosmo_single_epoch=cosmo_single) self.corr = correlation.Correlation(0.001, 1.0, input_kernel=kern, input_halo=h, power_spec='power_mm') self.theta_array = numpy.logspace(-3, 0, 4)*deg_to_rad
import asyncio import kernel import filesystem import threading async def periodic(): while True: await asyncio.sleep(0.2) def asyncThread(k, loop): """ Asyncio thread calls into kernel, runs event loop forever, breaks on Ctrl-C (for win). """ try: asyncio.set_event_loop(loop) k.asyncThreadEntry(loop) loop.create_task(periodic()) loop.run_forever() except KeyboardInterrupt: k.asyncThreadExit() raise if __name__ == "__main__": """ Instantiates kernel in main thread, and passes instance to asyncio thread. """ k = kernel.Kernel() loop = asyncio.get_event_loop() threading.Thread(target=asyncThread, args=(k, loop)).start() k.workThreadEntry()
import numpy as np import kernel import pandas as pd import math import scipy.misc as sc from PIL import Image np.set_printoptions(threshold=np.nan) imagepath = "./images/wedding.png" kernel = kernel.Kernel(2) scalar = 32 sensitivity = 190 #image = np.array(pd.read_csv("./watch.txt", delimiter="\t")) #orig = Image.open("peptide5.jpg") #orig.show() image = np.asarray(Image.open(imagepath).convert('L')) newRange = 1 oldRange = np.amax(image) - np.amin(image) image = scalar * (newRange / oldRange) * (image - np.amin(image)) entropyArray = np.zeros((len(image) - 1, len(image[0]) - 1)) img_len = len(image) - 1 for i in range(img_len): if i % 100 == 0: print("computing ", i, " of", img_len) for j in range(len(image[0]) - 1): subArray = np.array([[image[i][j], image[i][j + 1]],[image[i + 1][j], image[i + 1][j + 1]]]) ent = kernel.entropic_val(subArray) entropyArray[i][j] = ent
kB = 1.38 * 10**(-33) # A^2 kg fs^-2 K^-1 eV = 1.602177 * 10**(-19) # J/eV a = 10.546640000 # lattice constant in A mass = m_Si # We have Silicon mass_ev = mass * 10**(2 * 15 - 2 * 10) / eV # eV fs^2 A^-2 with open('user_config.json', 'r') as user_conf: u_conf = json.load(user_conf) directory = u_conf['file_out'] q = np.arange(1, u_conf['nr_modi'] + 1) * np.pi / u_conf['cutoff'] C_cal = np.array(np.loadtxt(directory + '/calibration_C.out'), dtype=float) w_cal = np.array(np.loadtxt(directory + '/calibration_w.out'), dtype=float) E_ave, _ = np.array(np.loadtxt(directory + '/calibration_E.out'), dtype=float) kern = kernel.Kernel(*u_conf['kernel']) # predicts the forces using the available machine-learned calibration def predict_forces(config: Configuration): config.init_nn(u_conf['cutoff'], u_conf['lattice_vectors']) config.init_descriptor(q) N_ion, dim = np.shape(config.positions) # build the linear system # The first argument is the current configuration, the second one is the reference configuration K = kern.kernel_mat(config.descriptors, C_cal) K = np.sum(K, axis=0)[np.newaxis, :] T = kern.force_submat(q, config, C_cal) # solve the linear system
def test_create_kernel(): _kernel_1 = kernel.Kernel(log=None, log_id="", table_name="main") _kernel_2 = kernel.Kernel(log=None, log_id="", table_name=3)