def llh_time(): ret, x0, val_llh = garch_data() ret = np.array(ret) x0 = np.array(x0) t = benchmark(lambda: garchLLH(ret, x0), args.n, val_llh) return t
def llh_time(): ret, x0, val_llh = garch_data() ret = cp.array(ret, dtype='float32') x0 = cp.array(x0, dtype='float32') t = benchmark(lambda: garchLLH(ret, x0), args.n, val_llh) print('time:', t) return t
def run_models(modelpath, run_sat=False, run_maxsat_one=False, run_maxsat_all=False, run_maxsat_part=False, run_maxsat_part_auto=False, timeout=180, repeat=5): models = filter(lambda x: x.startswith("sat") and x.endswith(".als"), os.listdir(modelpath)) problems = [] table_files = [] tag_files = [] sat_files = [] for m in models: problems.append(m[len("sat_"):-len(".als")]) sat_files.append(path.join(modelpath, m)) table_files.append(path.join(modelpath, m.replace("sat", "table"))) tag_files.append(path.join(modelpath, m.replace("sat", "tag"))) if run_sat: benchmark(problems, sat_files, timeout=timeout, repeat=repeat) # print("====================\nTable-based\n====================") benchmark(problems, None, table_files, run_maxsat_one, run_maxsat_all, run_maxsat_part, run_maxsat_part_auto, timeout, repeat)
def main(): # TBD use sys.argv[0] for num_iter or dataset print("loading..") dfs = unix_time(load)["return"] print("name,real,user,sys") print("------------------") benchmark(analytics, init_pd, dfs, num_iter=3) benchmark(search, init_pd, dfs, num_iter=3) benchmark(search_concat, init_pd, dfs, num_iter=3) benchmark(discovery, init_pd, dfs, num_iter=3)
def run(outpath, run_sat=False, run_maxsat_one=False, run_maxsat_all=False, run_maxsat_part=False, run_maxsat_part_auto=False, timeout=180, repeat=5): params = [ (7, 28, 6), (7, 30, 6), (8, 30, 7), (8, 32, 7), # (9, 34, 8), ] min_p = 3 max_p = 7 problems = [] table_files = [] tag_files = [] sat_files = [] for tag, p, tab in params: problem = f"{tag}_{p}_{tag}_{tab}_{min_p}_{max_p}" problems.append(problem) sat, table_based, tag_based = generate(tag, p, tag, tab, min_p, max_p) sat_filename = path.join(outpath, f"sat_{problem}.als") sat_files.append(sat_filename) with open(sat_filename, "w") as f: f.write(sat) table_filename = path.join(outpath, f"table_{problem}.als") table_files.append(table_filename) with open(table_filename, "w") as f: f.write(table_based) tag_filename = path.join(outpath, f"tag_{problem}.als") tag_files.append(tag_filename) with open(tag_filename, "w") as f: f.write(tag_based) if run_sat: benchmark(problems, sat_files, timeout=timeout, repeat=repeat) # print("====================\nTable-based\n====================") benchmark(problems, None, table_files, run_maxsat_one, run_maxsat_all, run_maxsat_part, run_maxsat_part_auto, timeout, repeat)
def run(outpath, run_sat=False, run_maxsat_one=False, run_maxsat_all=False, run_maxsat_part=False, run_maxsat_part_auto=False, timeout=180, repeat=5): params = [ # (30, 20, 6, 3, 3, 2), (34, 20, 6, 3, 3, 2), (38, 20, 6, 3, 3, 2), (42, 20, 6, 3, 3, 2), (46, 20, 6, 3, 3, 2), (50, 20, 6, 3, 3, 2), (52, 20, 6, 3, 3, 2), ] problems = [] maxsat_files = [] sat_files = [] for num_tasks, max_deadline, max_process_time, max_frags, max_slack, max_dep in params: problem = f"{num_tasks}_{max_deadline}_{max_process_time}_{max_frags}_{max_slack}_{max_dep}" problems.append(problem) sat, maxsat = generate(num_tasks, max_deadline, max_process_time, max_frags, max_slack, max_dep) sat_filename = path.join(outpath, f"sat_{problem}.als") sat_files.append(sat_filename) with open(sat_filename, "w") as f: f.write(sat) maxsat_filename = path.join(outpath, f"maxsat_{problem}.als") maxsat_files.append(maxsat_filename) with open(maxsat_filename, "w") as f: f.write(maxsat) sat_files = sat_files if run_sat else None benchmark(problems, sat_files, maxsat_files, run_maxsat_one, run_maxsat_all, run_maxsat_part, run_maxsat_part_auto, timeout, repeat)
def select_features(data, strategy: Strategy, num_features_to_select: int, iterations: int, plot_step: int, true_relevances: List[float] = None, alpha=.001) -> Tuple[List[str], List[float]]: with benchmark(strategy.name): features_with_target = data.columns.values # type:List[str] features = list(filter(lambda i: i != 'target', features_with_target)) hics = HiCS(data, alpha=alpha, iterations=1, categorical_features=features_with_target) relevance_by_feature = dict([ (feature, RandomVariableSamples()) for feature in features ]) # type:Dict[str, RandomVariableSamples] if true_relevances is None: true_relevances = [0] * len(features) true_relevance_by_feature = dict([ (feature, true_relevances[int(feature)]) for feature in features ]) selected_relevant_feature_shares = [] for iteration in range(iterations): items = Items(relevance_by_feature=relevance_by_feature, num_features_to_select=num_features_to_select, iteration=iteration, true_relevance_by_feature=true_relevance_by_feature, name=strategy.name) selected_relevant_feature_shares.append( items.share_selected_relevant_features) feature, value = strategy.choose(items) relevance_by_feature[feature].append( hics.calculate_contrast([feature], 'target')) if iteration % plot_step == plot_step - 1: items.save_plot() print( f"Iteration {iteration}, share of relevant features selected: {items.share_selected_relevant_features}" ) return items.selected_features, selected_relevant_feature_shares
def run_models(modelpath, run_sat=False, run_maxsat_one=False, run_maxsat_all=False, run_maxsat_part=False, run_maxsat_part_auto=False, timeout=180, repeat=5): models = filter(lambda x: x.startswith("maxsat") and x.endswith(".als"), os.listdir(modelpath)) problems = [] maxsat_files = [] sat_files = [] for m in models: problems.append(m[len("maxsat_"):-len(".als")]) maxsat_files.append(path.join(modelpath, m)) sat_files.append(path.join(modelpath, m.replace("maxsat", "sat"))) sat_files = sat_files if run_sat else None benchmark(problems, sat_files, maxsat_files, run_maxsat_one, run_maxsat_all, run_maxsat_part, run_maxsat_part_auto, timeout, repeat)
def run(outpath, run_sat=False, run_maxsat_one=False, run_maxsat_all=False, run_maxsat_part=False, run_maxsat_part_auto=False, timeout=180, repeat=5): max_core = 3 max_interests = 6 params = [(30, 40), (40, 50), (50, 60), (60, 70), (70, 80), (80, 90), (90, 100)] problems = [] maxsat_files = [] sat_files = [] for num_courses, num_stu in params: problem = f"{num_courses}_{num_stu}_{max_core}_{max_interests}" problems.append(problem) sat, maxsat = generate(num_courses, num_stu, max_core, max_interests) sat_filename = path.join(outpath, f"sat_{problem}.als") sat_files.append(sat_filename) with open(sat_filename, "w") as f: f.write(sat) maxsat_filename = path.join(outpath, f"maxsat_{problem}.als") maxsat_files.append(maxsat_filename) with open(maxsat_filename, "w") as f: f.write(maxsat) sat_files = sat_files if run_sat else None benchmark(problems, sat_files, maxsat_files, run_maxsat_one, run_maxsat_all, run_maxsat_part, run_maxsat_part_auto, timeout, repeat)
import subprocess import os from os import path import shutil import signal import sys sys.path.append(path.dirname(path.dirname(path.abspath(__file__)))) from util import benchmark, options if __name__ == "__main__": run_sat, run_maxsat_one, run_maxsat_all, run_maxsat_part, run_maxsat_part_auto, timeout, repeat, model, from_file = options( ) problems = ["10_2_1", "20_3_1", "26_2_1", "26_2_2"] sat_files = None maxsat_files = list(map(lambda x: "maxsat_" + x + ".als", problems)) benchmark(problems, sat_files, maxsat_files, run_maxsat_one, run_maxsat_all, run_maxsat_part, run_maxsat_part_auto, timeout, repeat, from_file)
return ( -0.5 * (tf.cast(y.shape[0], tf.float32) - 1) * tf.math.log(2 * np.pi) - 0.5 * tf.reduce_sum(tf.math.log(hts) + tf.square(y / tf.sqrt(hts)))) @tf.function def llh_unroll(y, params): def garch(ht, y): return params[0] + params[1] * y + params[2] * ht y2 = tf.square(y) ht0 = tf.reduce_mean(y2) h = ht0 hts = [] for t in range(len(y2) - 1): h = garch(h, y2[t]) hts.append(h) # hts0 = [h := garch_like(h, y2[t]) for t in range(len(y2)-1)] hts = tf.concat(([ht0], tf.stack(hts)), 0) return ( -0.5 * (tf.cast(y.shape[0], tf.float32) - 1) * tf.math.log(2 * np.pi) - 0.5 * tf.reduce_sum(tf.math.log(hts) + tf.square(y / tf.sqrt(hts)))) t = benchmark(lambda: llh(ret, x0).numpy(), args.n, val_llh) out['tensorflow-' + args.mode] = t t = benchmark(lambda: llh_unroll(ret, x0).numpy(), args.n, val_llh) out['tensorflow-' + args.mode + '-unroll'] = t print(json.dumps(out))
def paths(S, tau, r, q, v, M, N): """Generate GBM price paths""" dt = tau / M g1 = (r - q - v / 2) * dt g2 = tf.sqrt(v * dt) return tf.exp(tf.log(S) + tf.cumsum(g1 + g2 * tf.random_normal((M, N)))) def barrier(S0, K, B, tau, r, q, v, M, N): """Price a barrier option""" S = paths(S0, tau, r, q, v, M, N) l = tf.to_float(tf.greater(tf.reduce_min(S, 0), B)) payoffs = l * tf.maximum(S[-1, :] - K, 0) return tf.exp(-r * tau) * tf.reduce_mean(payoffs) config = tf.ConfigProto() if args.mode == 'cpu': config = tf.ConfigProto(device_count={'GPU': 0}, allow_soft_placement=True) with tf.Session(config=config) as sess: data = barrier_data() barr = barrier(data['price'], data['strike'], data['barrier'], data['tau'], data['rate'], data['dy'], data['vol'], data['time_steps'], data['n_rep']) t = benchmark(lambda: sess.run(barr), data['val'], tol=data['tol']) out['tensorflow-v1-' + args.mode] = t print(json.dumps(out))
return params[0] + params[1] * y + params[2] * ht y2 = T.square(y) hts, updates = theano.scan(fn=garch_like, sequences=[y2], n_steps=y2.size - 1, outputs_info=ht0) hts = T.concatenate(([ht0], hts)) tllh = (-0.5 * (y.size - 1) * T.log(2 * np.pi) - 0.5 * T.sum(T.log(hts) + T.square(y / T.sqrt(hts)))) gllh = T.grad(tllh, wrt=params) llh = theano.function(inputs=[y, params], outputs=tllh) t = benchmark(lambda: llh(ret, x0), args.n, val_llh) out['theano-' + args.mode] = t def unroll(tx, th0, n): th = th0 th_tmp = [] for t in range(n): th = garch_like(tx[t], th) th_tmp.append(th) return T.stack(th_tmp) t_unroll0 = unroll(y2, ht0, len(ret) - 1) t_unroll = T.concatenate(([ht0], t_unroll0)) t_unroll_out = (-0.5 * (y.size - 1) * T.log(2 * np.pi) -
hermite = np.polynomial.hermite.hermgauss(M) hermite_e = np.polynomial.hermite_e.hermegauss(M) # coordinate-space delta shell = l/(2mu) sin(k'b)sin(kb)/(k'k) # alpha a l: strength b:displacement alpha*delta(r-a) LECs = [[1.5, 10], 1] grids = [[textbookgaussgrid, LECs, 'Gauss'], [legendre, LECs, 'Legendre'], [hermite, LECs, 'Hermite'], [cheb, LECs, 'Chebyshev'], [laguerre, LECs, 'Laguerre'], [hermite_e, LECs, 'Hermite_e']] # visualization of the Gauss mesh as a function of the number # of points on it; lim_m->inf(<p>)=inf *BUT* lim_m->inf(median[p])<inf #plot_grids([gauss(m, 2, 0., midpoint)[0] for m in range(10, 500, 15)]) with benchmark("Matrix inversion on Gaussian grid:"): # calculate phase shifts for each quadrature polynomial, i.e., momentum grid for grd in grids[:2]: k, w = grd[0][0], grd[0][1] pot = V_grid_k0(k, k0range, grd[1]) tmpres = [] kstep = 0 for k0 in k0range: k[-1] = k0 # D matrix '=' (free propagator)*k^2 for i in range(M - 1):
"""Generate GBM price paths""" dt = tau / M g1 = (r - q - v / 2) * dt g2 = tf.sqrt(v * dt) return tf.exp( tf.math.log(S) + tf.cumsum(g1 + g2 * tf.random.normal((M, N)))) @tf.function def barrier(S0, K, B, tau, r, q, v, M, N): """Price a barrier option""" S = paths(S0, tau, r, q, v, M, N) l = tf.cast(tf.greater(tf.reduce_min(S, 0), B), dtype=tf.float32) payoffs = l * tf.maximum(S[-1, :] - K, 0) return tf.exp(-r * tau) * tf.reduce_mean(payoffs) data = barrier_data() def barrier_fun(): return barrier(data['price'], data['strike'], data['barrier'], data['tau'], data['rate'], data['dy'], data['vol'], data['time_steps'], data['n_rep']) t = benchmark(barrier_fun, data['val'], tol=data['tol']) out['tensorflow-' + args.mode] = t print(json.dumps(out))
# processor n fills rows [mpi_row_offset , mpi_row_offset + mpi_nbrrows] mpi_row_offset = mpi_rank * int(dv / (mpi_size - 1)) # calculate only the Nev lowest eigenvalues Nev = 4 # initialization of the two components of the Hamiltonian: # H = mkinetic + mpotential mpotential = np.zeros((dv, dv)) mkinetic = np.zeros((dv, dv)) mhamilton = np.zeros((dv, dv)) # writing of the Hamilton matrix contains two basic loops # column index b and row index a; e.g.:2 particles: a=(x1,y1,z1,x2,y2,y3) and # b=(x1',y1',z1',x2',y2',y3') with benchmark("cpu%d: Matrix filling" % mpi_rank): # column index <<<<<<< HEAD colidx = mpi_row_offset print('cpu%d: rows %d -> %d' % (mpi_rank, mpi_row_offset, mpi_row_offset + mpi_nbrrows)) # row loop; each grid point specifies <spacedims> coordinates per particle for a in list( product(np.arange(1, N), repeat=spacedims * partnbr))[mpi_row_offset:mpi_row_offset + mpi_nbrrows]: ======= colidx = 0 # row loop; each grid point specifies <SPACEDIMS> coordinates per particle for a in product(np.arange(1, N), repeat=SPACEDIMS * PARTNBR): >>>>>>> 925e980509de94dc4a8879b8eefe0800f1d175b7 # row index
def test_benchmark(): with benchmark('foo'): time.sleep(0.1)
help='') args = parser.parse_args() out = {} def pricepaths(S, tau, r, q, v, M, N): dt = tau / M g1 = (r - q - v / 2) * dt g2 = math.sqrt(v * dt) aux = math.log(S) + cp.cumsum( g1 + g2 * cp.random.randn(M, N, dtype=cp.float32), 0) return cp.exp(aux) def barrier(S0, K, B, tau, r, q, v, M, N): S = pricepaths(S0, tau, r, q, v, M, N) l = cp.min(S, 0) > B payoffs = l * cp.maximum(S[-1, :] - K, 0) return (math.exp(-r * tau) * cp.mean(payoffs)).get().flatten() data = barrier_data() t = benchmark(lambda: barrier(data['price'], data['strike'], data[ 'barrier'], data['tau'], data['rate'], data['dy'], data['vol'], data[ 'time_steps'], data['n_rep'])[0], data['val'], tol=data['tol']) out['cupy'] = t print(json.dumps(out))
h = np.zeros_like(ret2) h[0] = np.mean(ret2) for i in range(1, len(ret)): h[i] = p[0] + p[1] * ret2[i - 1] + p[2] * h[i - 1] return h def garchLLH(y, par): h = garchSim(np.square(y), par) t = len(y) return -0.5 * (t - 1) * np.log( 2 * math.pi) - 0.5 * np.sum(np.log(h) + (y / np.sqrt(h))**2) if args.mode == 'numba': garchSim = jit(garchSim) garchLLH = jit(garchLLH) out = {} ret, x0, val_llh = garch_data() if args.mode == 'c++': import cppimport cpp_llh = cppimport.imp('cppllh') out['c++'] = benchmark(lambda: cpp_llh.garchLLH(ret, x0), args.n, val_llh) print('c++ time:', out['c++']) else: out['numpy-' + args.mode] = benchmark(lambda: garchLLH(ret, x0), args.n, val_llh) print(json.dumps(out))
"city": data['informacion_general']['entidad_federativa_nacimiento'] ['nom_agee'], "state_code": str(data['informacion_general'] ['entidad_federativa_nacimiento']['cve_agee']) } # CURP and RFC Fix data['informacion_general']['curp'] = generate.GenerateCURP( **kwargs).data # RFC data['informacion_general']['rfc'] = generate.GenerateRFC( **kwargs).data return data with benchmark('data faker'): document_samples = Seed( name='samples', props={'s': number_of_samples * years}, state={'count1': 0}, next_state=lambda seed: {'count1': seed.state.count + 1}, initial_value=lambda seed, node: number_of_samples * years, next_value=lambda seed, node: seed.value if seed.state.count1 % seed.props.s != 0 else seed.reset(node)) personal_info = Seed( name='informacion_personal', props={'y': years + 1}, state={'count2': 1}, next_state=lambda seed: {'count2': seed.state.count2 + 1},
# STATUS: the potential matrix is assumed to be diagonal (future: OPE+B => potential has non-zero offdiagonal elements) mpotential = np.diag( calc_potential(n_part, dim_space, spec_pot, coordOP_evSYS)) mhamilton = (mkinetic + mpotential) return mhamilton """ main section of the program 1. set up the Hamiltonian 2. full Diagonalization 3. approximate Diagonalization (extract only the N_EIGENV lowest EV's) """ ham = [] with benchmark("Matrix filling"): ham = calc_mhamilton(PARTNBR, SPACEDIMS, BASIS_DIM, BASIS_SINE, POT_HO_INTER) sparsimonius = True # False '=' full matrix diagonalization; True '=' approximate determination of the lowest <N_EIGEN> eigenvalues if sparsimonius: with benchmark("Diagonalization -- sparse matrix structure (DVR)"): # calculate the lowest N eigensystem of the matrix in sparse format evals_small, evecs_small = eigsh(coo_matrix(ham), N_EIGENV, which='SA', maxiter=5000) print( 'Hamilton ( %d X %d ) matrix: %d/%d = %3.2f%% non-zero entries\n' % (np.shape(ham)[0], np.shape(ham)[1], coo_matrix(ham).nnz,