len(traj_1.timestamps)\n traj_long = copy.deepcopy(traj_2) if snd_longer else copy.deepcopy(traj_1)\n traj_short = copy.deepcopy(traj_1) if snd_longer else copy.deepcopy(traj_2)\n max_pairs = len(traj_long.timestamps)\n\n # First, match the timestamps of the shorter trajectory to the longer one.\n matching_indices = matching_time_indices(\n traj_short.timestamps, traj_long.timestamps,\n max_diff, offset_2 if snd_longer else -offset_2)\n traj_long.reduce_to_ids(matching_indices)\n\n # Next, reversely match the reduced long trajectory to the shorter one.\n matching_indices = matching_time_indices(\n traj_long.timestamps, traj_short.timestamps,\n max_diff, -offset_2 if snd_longer else offset_2)\n traj_short.reduce_to_ids(matching_indices)\n\n traj_1 = traj_short if snd_longer else traj_long\n traj_2 = traj_long if snd_longer else traj_short\n\n if len(matching_indices) == 0:\n raise SyncException(\n \"found no matching timestamps between {} and {} with max. time \"\n \"diff {} (s) and time offset {} (s)\".format(\n first_name, snd_name, max_diff, offset_2))\n\n logger.debug(\n \"Found {} of max. {} possible matching timestamps between...\\n\"\n \"\\t{}\\nand:\\t{}\\n..with max. time diff.: {} (s) \"\n \"and time offset: {} (s).\".format(\n len(matching_indices), max_pairs, first_name,\n snd_name, max_diff, offset_2))\n\n return traj_1, traj_2","def prepare_lists(dist1, dist2):\n\tx_dist = []\n\ty_dist = []\n\tfor i, freq in dist1.items():\n\t\tif i not in dist2:\n\t\t\tcontinue\n\t\tx_dist.append(freq)\n\t\ty_dist.append(dist2[i])\n\tx_dist=np.array(x_dist)\n\ty_dist=np.array(y_dist)\n\treturn x_dist, y_dist","def terning2(antal_kast): #Definere en funktion der tager 1 argument\n import random # importere random pakken til at generere tal\n values = []\n for i in range(antal_kast): #kører et loop de antal gange specificeret i argumentet\n x = random.random()# generere et tal mellem 0 og 1 (er inde i parrentesen for at hver kast bliver forskelligt)\n if x < 1/6:\n values.append(1)\n elif x < 2/6:\n values.append(2)\n elif x < 3/6:\n values.append(3)\n elif x < 4/6:\n values.append(4)\n elif x < 5/6:\n values.append(5)\n else:\n values.append(6)\n return(values)","def __init__(self, anneal_start, anneal_time, beta_start):\n self.anneal_start = anneal_start\n self.anneal_time = anneal_time\n self.beta = beta_start","def kendall_tau_brute_force(ranking1, ranking2):\n distance = 0\n\n for i, j in itertools.combinations(range(len(ranking1)), 2):\n a = ranking1[i] - ranking1[j]\n b = ranking2[i] - ranking2[j]\n\n # If discordant (different signs)\n if a * b < 0:\n distance += 1\n\n return distance","def test(output_seq,M1,M2,M3,obs_file):\n predicted = []\n mus_c = 0\n mod_c = 0\n arn_c = 0\n next = 0\n t = 0.000\n d=dict()\n d[\"other\"]=0\n d[\"modi\"]=0\n d[\"arnab\"]=0\n print(obs_file+\":\")\n for obs in output_seq:\n p1 = M1.forward(obs)\n p2 = M2.forward(obs)\n p3 = M3.forward(obs)\n\n\n if(p1 > p2 and p1 > p3):\n predicted.append(\"Other\")\n mus_c+=1\n d[\"other\"]+=1\n elif(p2 > p3 and p2 > p1):\n predicted.append(\"Modi\")\n mod_c+=1\n d[\"modi\"]+=1\n else:\n predicted.append(\"Arnab\")\n arn_c+=1\n d[\"arnab\"]+=1\n t+=0.05\n next+=1\n\n if(next % 20 == 0):\n p_other = d[\"other\"]/20.0\n p_modi = d[\"modi\"]/20.0\n p_arnab = d[\"arnab\"]/20.0\n #print(\"{0} : Modi = {1}, Arnab = {2}, Other = {3}\".format(t,p_modi,p_arnab,p_other))\n if p_other>p_modi and p_other>p_arnab:\n print \"{0} : Speech : Other\".format(t)\n elif p_modi>p_other and p_modi>p_arnab:\n print \"{0} : Speech : Modi\".format(t)\n else:\n print \"{0} : Speech : Arnab\".format(t)\n d[\"other\"]=0\n d[\"modi\"]=0\n d[\"arnab\"]=0\n\n time = 0.000\n with open(\"op_\"+obs_file,\"w\") as g:\n for val in predicted:\n g.write(str(time)+\" :\\t\"+val+\"\\n\")\n time+=0.005\n\n return predicted","def multiple_simulated_annealing(scores):\n\n\tplt.plot(range(0, len(scores[0])), scores[0], label = \"geman\")\n\tplt.plot(range(0, len(scores[1])), scores[1], label = \"linear\")\n\tplt.plot(range(0, len(scores[2])), scores[2], label = \"sigmoidal\")\n\tplt.plot(range(0, len(scores[3])), scores[3], label = \"exponential\")\n\tplt.ylabel(\"Score\")\n\tplt.xlabel(\"Runs\")\n\tplt.title(\"Simulated annealing\")\n\tplt.legend()\n\tplt.show()","def et(obs_time, *whatevers):\n obs_time = np.asarray(obs_time)\n n_time = obs_time.size\n n_obs = np.amax([w.size for w in whatevers])\n if n_obs > n_time:\n delta_t = obs_time[-1] - obs_time[-2]\n shortfall = n_obs-n_time\n obs_time = np.concatenate((\n obs_time,\n np.linspace(\n obs_time[-1] + delta_t,\n obs_time[-1] + delta_t * shortfall,\n shortfall,\n endpoint=True\n ),\n ))\n\n return tuple((obs_time,) + whatevers)","def ps_arrival_times(distance, depth, init_sec):\n\n # use taup to get the theoretical arrival times for P & S\n TauPy_model = TauPyModel('iasp91')\n tt = TauPy_model.get_travel_times(\n distance_in_degree=0.001 * distance / 111.11, source_depth_in_km=depth)\n tiemp = []\n tiems = []\n # from all possible P arrivals select the earliest one\n for i2 in xrange(0, len(tt)):\n if tt.__getitem__(i2).__dict__['name'] == 'P' or \\\n tt.__getitem__(i2).__dict__['name'] == 'p' or \\\n tt.__getitem__(i2).__dict__['name'] == 'Pdiff' or \\\n tt.__getitem__(i2).__dict__['name'] == 'PKiKP' or\\\n tt.__getitem__(i2).__dict__['name'] == 'PKIKP' or \\\n tt.__getitem__(i2).__dict__['name'] == 'PP' or \\\n tt.__getitem__(i2).__dict__['name'] == 'Pb' or \\\n tt.__getitem__(i2).__dict__['name'] == 'Pn' or \\\n tt.__getitem__(i2).__dict__['name'] == 'Pg':\n tiem_p = tt.__getitem__(i2).__dict__['time']\n tiemp.append(tiem_p)\n arriv_p = np.floor(init_sec + min(tiemp))\n\n # from all possible S arrivals select the earliest one\n for i3 in xrange(0, len(tt)):\n if tt.__getitem__(i3).__dict__['name'] == 'S' or \\\n tt.__getitem__(i3).__dict__['name'] == 's' or \\\n tt.__getitem__(i3).__dict__['name'] == 'Sdiff' or \\\n tt.__getitem__(i3).__dict__['name'] == 'SKiKS' or \\\n tt.__getitem__(i3).__dict__['name'] == 'SKIKS' or \\\n tt.__getitem__(i3).__dict__['name'] == 'SS' or \\\n tt.__getitem__(i3).__dict__['name'] == 'Sb' or \\\n tt.__getitem__(i3).__dict__['name'] == 'Sn' or \\\n tt.__getitem__(i3).__dict__['name'] == 'Sg':\n tiem_s = tt.__getitem__(i3).__dict__['time']\n tiems.append(tiem_s)\n arriv_s = np.floor(init_sec + min(tiems))\n return arriv_p, arriv_s","def test_mc_t_two_sample(self):\r\n # Verified against R's t.test() and Deducer::perm.t.test().\r\n\r\n # With numpy array as input.\r\n exp = (-0.11858541225631833, 0.90756579317867436)\r\n I = array([7.2, 7.1, 9.1, 7.2, 7.3, 7.2, 7.5])\r\n II = array([8.8, 7.5, 7.7, 7.6, 7.4, 6.7, 7.2])\r\n obs = mc_t_two_sample(I, II)\r\n self.assertFloatEqual(obs[:2], exp)\r\n self.assertEqual(len(obs[2]), 999)\r\n self.assertCorrectPValue(0.8, 0.9, mc_t_two_sample, [I, II],\r\n p_val_idx=3)\r\n\r\n # With python list as input.\r\n exp = (-0.11858541225631833, 0.90756579317867436)\r\n I = [7.2, 7.1, 9.1, 7.2, 7.3, 7.2, 7.5]\r\n II = [8.8, 7.5, 7.7, 7.6, 7.4, 6.7, 7.2]\r\n obs = mc_t_two_sample(I, II)\r\n self.assertFloatEqual(obs[:2], exp)\r\n self.assertEqual(len(obs[2]), 999)\r\n self.assertCorrectPValue(0.8, 0.9, mc_t_two_sample, [I, II],\r\n p_val_idx=3)\r\n\r\n exp = (-0.11858541225631833, 0.45378289658933718)\r\n obs = mc_t_two_sample(I, II, tails='low')\r\n self.assertFloatEqual(obs[:2], exp)\r\n self.assertEqual(len(obs[2]), 999)\r\n self.assertCorrectPValue(0.4, 0.47, mc_t_two_sample, [I, II],\r\n {'tails': 'low'}, p_val_idx=3)\r\n\r\n exp = (-0.11858541225631833, 0.54621710341066287)\r\n obs = mc_t_two_sample(I, II, tails='high', permutations=99)\r\n self.assertFloatEqual(obs[:2], exp)\r\n self.assertEqual(len(obs[2]), 99)\r\n self.assertCorrectPValue(0.4, 0.62, mc_t_two_sample, [I, II],\r\n {'tails': 'high', 'permutations': 99}, p_val_idx=3)\r\n\r\n exp = (-2.8855783649036986, 0.99315596652421401)\r\n obs = mc_t_two_sample(I, II, tails='high', permutations=99, exp_diff=1)\r\n self.assertFloatEqual(obs[:2], exp)\r\n self.assertEqual(len(obs[2]), 99)\r\n self.assertCorrectPValue(0.55, 0.99, mc_t_two_sample, [I, II],\r\n {'tails': 'high', 'permutations': 99, 'exp_diff': 1}, p_val_idx=3)","def t_paired(a, b, tails=None, exp_diff=0):\r\n n = len(a)\r\n if n != len(b):\r\n raise ValueError('Unequal length lists in ttest_paired.')\r\n try:\r\n diffs = array(a) - array(b)\r\n return t_one_sample(diffs, popmean=exp_diff, tails=tails)\r\n except (ZeroDivisionError, ValueError, AttributeError, TypeError,\r\n FloatingPointError):\r\n return (nan, nan)","def adjustableDelay(delay, ants) :\n antlist = helpers.makeList(ants)\n s.adjustableDelay(delay, antlist)","def _probseg_fast2bids(inlist):\n return (inlist[1], inlist[2], inlist[0])","def gen_trains(interval_lengths, rates, num_trials, num_repetitions):\n return [[gen_single_trial(interval_lengths, rates)\n for j in xrange(num_trials)] for i in xrange(num_repetitions)]","def form_agents(n, r, a, b, agents):\n for a_ind, b_ind in izip(a, b):\n #util_fn = random.choice([util.Linear, util.CES, util.CobbDouglas])\n #util_fn = util_fn.rand(p, n)\n #util_fn = util.Linear.rand(n, r, a_ind)\n\n agent = Agent.rand(util.Linear, n, r, a_ind, b_ind)\n agents.add(agent)","def test_of_agreement(self): \n \n pop_t = world.pop_t \n pop_sub = world.pop_sub \n \n \n Ns = world.subtime.length\n \n dt = world.time.step\n ds = world.subtime.step\n N = round(ds/dt)\n for i in range(Ns):\n numpy.testing.assert_allclose(pop_sub[:,i],pop_t[i*N,:])","def UTC_times(times, \n trace, \n diff_thres = 30.0):\n # set times values to seconds\n \n #AUTOMATE THIS SECTION!\n #CHECK THAT THIS IS CORRECT\n times = times / trace.stats.sampling_rate\n #remove unwanted parts of times numpy array \n times = times[:,0]\n \n #remove the first instance of time because it is \n #somehow always of the wrong format!\n #times = np.delete(times, 0) \n \n event_times = []\n event = [times[0]]\n \n start_time = trace.stats.starttime\n \n #for item in times:\n # print start_time + item\n\n for i in range(1, len(times)):\n \n # check if two events in times array have a difference < diff_thres, \n #if not, run average of those times, if so append that events to a \n #new events_times list\n \n #time_diff = times[i + 1] - times[i]\n \n time_diff = times[i] - times[i-1]\n\n #save info until events are far enough apart! \n if time_diff < diff_thres:\n\n event.append(times[i])\n \n \n #raise conditional for if events are far enough apart! \n else:\n\n event_start = event[0] - 2 #minus 5 seconds\n event_end = max(event) + 2 #add 5 seconds\n\n event_times.append([event_start, event_end])\n \n event = [] \n \n event.append(times[i])\n\n #if event still contains something for any reason, add it to event times\n if len(event) > 0: \n event_start = event[0] - 2 #minus 5 seconds\n event_end = max(event) + 2 #add 5 seconds\n event_times.append([event_start, event_end])\n event = [] \n \n\n\n #if len(event_times) == 0 and len(event) > 0 or time_diff > diff_thres and len(event) > 0:\n \n #event_times.append(sum(event) / len(event))\n \n # event_start = event[0] - 2 #minus 5 seconds\n # event_end = event[-1] + 2 #add 5 seconds\n \n # event_times.append([event_start, event_end])\n \n # event = []\n \n #event_times.append(times[i])\n \n # else:\n # event.append(times[i])\n \n\n UTC_events = []\n\n #earthquake length threshold is 10 seconds and above!\n eq_len = 0#5.0\n\n for i in event_times:\n estart = start_time + i[0]\n eend = start_time + i[1]\n \n if eend - estart > eq_len:\n UTC_events.append([estart, eend])\n \n #UTC_events = np.unique(np.asarray(UTC_events))\n\n \n return UTC_events","def simulationTwoDrugsDelayedTreatment(numTrials):\n \n numViruses = 100\n maxPop = 1000\n maxBirthProb = 0.1\n clearProb = 0.05\n resistances = {'guttagonol': False, 'grimpex': False}\n mutProb = 0.005\n delays = [300, 150, 75, 0]\n f, axarr = pylab.subplots(2, 2)\n x_plot = []\n\n for delay in delays:\n FinalPopSize = [0.0 for x in range(numTrials)]\n for trial in range(numTrials):\n viruses = [ResistantVirus(maxBirthProb, clearProb, resistances, mutProb) for n in range(numViruses)]\n patient = TreatedPatient(viruses, maxPop)\n for i in range(150):\n patient.update()\n patient.addPrescription('guttagonol')\n for j in range(150, 150+delay):\n patient.update()\n patient.addPrescription('grimpex')\n for k in range(150+delay, 300+delay):\n patient.update()\n FinalPopSize[trial] = patient.getTotalPop()\n x_plot.append(FinalPopSize)\n\n axarr[0, 0].hist(x_plot[0])\n axarr[0, 1].hist(x_plot[1])\n axarr[1, 0].hist(x_plot[2])\n axarr[1, 1].hist(x_plot[3])\n pylab.show()\n return x_plot","def __call__(self,time):\n \n fname = []\n tind =[]\n for t in time:\n flag=1\n for f in self.timelookup.keys():\n\n if t >= self.timelookup[f][0] and t<=self.timelookup[f][-1]:\n# print 'Found tstep %s'%datetime.strptime(t,'%Y-%m-%d %H:%M:%S')\n tind.append(othertime.findNearest(t,self.timelookup[f][:]))\n fname.append(f)\n flag=0\n\n# if flag:\n# print 'Warning - could not find matching file for time:%s'%datetime.strptime(t,'%Y-%m-%d %H:%M:%S')\n# tind.append(-1)\n# fname.append(-1)\n \n return tind, fname","def test_returns_concurrent_meeting_time(self):\n result = meeting_planner([[10, 50], [60, 120], [140, 210]], [[0, 15], [60, 70]], 8)\n self.assertEqual(result, [60, 68])","def task_2():\n\n # To store the list of speeds to plot\n list_of_speeds = []\n list_of_times = []\n list_of_time_difference = [0]\n\n # To go from 1 through 80\n for i in range(LOW_SPEED, HIGH_SPEED + 1, 5):\n list_of_speeds.append(i)\n list_of_times.append(((DISTANCE / i) * 60))\n\n for i in range(1, len(list_of_times)):\n list_of_time_difference.append(list_of_times[i-1] - list_of_times[i])\n\n plt.plot(list_of_speeds, list_of_time_difference)\n plt.xlabel(\"Speed (in mph)\")\n plt.ylabel(\"Time saved (in minutes)\")\n plt.show()","def smart_T1_delays(T1_int=90e3, QPT1=1.5e6, half_decay_point=1e6, eff_T1_delay=800.0, probe_point=0.5, meas_per_QPinj=30, meas_per_reptime=5):\r\n# rep_time = 1.0e9/fg.get_frequency()\r\n# T1_QPref = 1/(np.log(2)/eff_T1_delay-1/T1_int) # T1 at half decay point = effective readout delay/ln(2), excluding intrinsic part giving the T1 due to quasiparticles\r\n# n_delayless = int(half_decay_point/rep_time) # Number of points with T1_delay = 0\r\n#\r\n## QP_times_s = np.linspace(rep_time, half_decay_point, n_delayless)\r\n# T1_delays_s = np.linspace(0, 0, n_delayless)\r\n# QP_times_l = np.linspace(half_decay_point+rep_time, meas_per_QPinj*rep_time, meas_per_QPinj-n_delayless)\r\n# T1_delays_l = np.log(2)/(1/T1_int+1/T1_QPref*np.exp(-(QP_times_l-half_decay_point)/QPT1))-eff_T1_delay\r\n## QP_times = np.concatenate((QP_times_s, QP_times_l))\r\n# T1_delays = np.concatenate((T1_delays_s, T1_delays_l))\r\n\r\n rep_time = 1.0e9/fg.get_frequency()\r\n n_points = meas_per_QPinj * meas_per_reptime\r\n step_time = rep_time / meas_per_reptime\r\n T1_QPref = 1/(np.log(2)/eff_T1_delay-1/T1_int) # T1 at half decay point = effective readout delay/ln(2), excluding intrinsic part giving the T1 due to quasiparticles\r\n\r\n QP_times = np.linspace(0, (n_points-1)*step_time, n_points)\r\n T1_est = 1/(1/T1_int+1/T1_QPref*np.exp(-(QP_times-half_decay_point)/QPT1))\r\n T1_delays = -np.log(probe_point)*T1_est-eff_T1_delay\r\n for j, delay in enumerate(T1_delays):\r\n if delay < 0:\r\n T1_delays[j]=0.0\r\n return T1_delays","def predict_event2(rule,event):\n if event[0]==rule[1][1][0]:\n min_t=event[1]+rule[1][0][0]\n max_t=event[1]+rule[1][0][1]\n next_event=rule[1][1][1]\n else:\n min_t=event[1]-rule[1][0][1]\n max_t=event[1]-rule[1][0][0] \n next_event=rule[1][1][0] \n return [next_event,[min_t,max_t],rule[2],rule]","def make_feedback(self,shift_register, feedback_taps):\n feedback_list = []\n for tap in feedback_taps:\n feedback_list.append(shift_register[tap])\n return sum(feedback_list) % 2","def run():\n trials = 100\n\n multipliers = [0.25, 0.3, 0.35, 0.5, 0.75, 1, 1.25, 1.45, 1.5, 1.55, 1.6] # Coefficients for learning rate\n\n mean_penalty = []\n median_penalty = []\n std_penalty = []\n\n mean_trial_time = []\n median_trial_time = []\n std_trial_time = []\n\n mean_success_rate = []\n median_success_rate = []\n std_success_rate = []\n\n for m in multipliers:\n all_penalties = [] # All penalties from trail sets\n all_average_trial_time = []\n all_success_rates = []\n\n for i in range(0, 20):\n # print \"Trial set:\", i\n # Set up environment and agent\n e = Environment() # create environment (also adds some dummy traffic)\n agent = e.create_agent(LearnerAgent) # create agent\n agent.mult = m\n e.set_primary_agent(agent, enforce_deadline=True) # specify agent to track\n\n # Now simulate it\n sim = Simulator(e, update_delay=0.0, display=False) # create simulator (uses pygame when display=True, if available)\n\n sim.run(n_trials=trials) # run for a specified number of trials\n\n all_penalties.append(agent.all_trails_penalties)\n all_average_trial_time.append(agent.time/float(trials))\n all_success_rates.append(float(trials-agent.aborted_trials)/trials)\n\n mean_penalty.append(np.mean(all_penalties))\n median_penalty.append(np.median(all_penalties))\n std_penalty.append(np.std(all_penalties))\n\n mean_trial_time.append(np.mean(all_average_trial_time))\n median_trial_time.append(np.median(all_average_trial_time))\n std_trial_time.append(np.std(all_average_trial_time))\n\n mean_success_rate.append(np.mean(all_success_rates))\n median_success_rate.append(np.median(all_success_rates))\n std_success_rate.append(np.std(all_success_rates))\n\n for i in range(0, len(multipliers)):\n print \"\"\n print \"Multiplier:\", multipliers[i]\n print \"\"\n print \"Mean penalty per {} trials:\".format(trials), mean_penalty[i]\n print \"Median penalty per {} trials:\".format(trials), median_penalty[i]\n print \"Std.Dev. penalty per {} trials:\".format(trials), std_penalty[i]\n\n print \"\"\n print \"Mean trial time:\", mean_trial_time[i]\n print \"Median trial time:\", median_trial_time[i]\n print \"Std.Dev. trial time:\", std_trial_time[i]\n\n print \"\"\n print \"Mean success rate per {} trials:\".format(trials), mean_success_rate[i]\n print \"Median success rate per {} trials:\".format(trials), median_success_rate[i]\n print \"Std.Dev. success rate per {} trials:\".format(trials), std_success_rate[i]","def ablation_times(self):\n ats = {}\n for n in np.arange(self.n) + 1:\n t = self.Time[self.ns == n]\n ats[n - 1] = t.max() - t.min()\n return ats","def test_simulation(walk_length_array, number_of_simulations, walker_class_type):\n for walk_length in walk_length_array:\n _distances_ = simulate_walks(walk_length, number_of_simulations, walker_class_type)\n print(walker_class_type.__name__, \" random walk of {} steps\".format(walk_length), \" After {} simulations\".format(number_of_simulations))\n print(\" Mean= {}\".format(round(sum(_distances_)/len(_distances_),4)))\n print(\" Max= {}\".format(round(max(_distances_), 4)))\n print(\" Min= {}\".format(round(min(_distances_),4)))","def question05(input):\r\n n_threat = input[0] # number of threats\r\n threats = [(input[i * 2 + 1], input[i * 2 + 2]) for i in range(n_threat)] # list of threats in (t, f) format\r\n threats.sort(key=lambda thr: thr[0]) # sort the list of threats by t\r\n instances = [{'t': threats[0][0], 'f': threats[0][1]}] # initial list of instances in {'t': t, 'f': f} format\r\n for threat in threats:\r\n counter = False\r\n instances.sort(key=lambda inst: inst['t'], reverse=True) # sort the list of instances by t in reverse order\r\n for instance in instances:\r\n if abs(instance['f'] - threat[1]) <= threat[0] - instance['t']: # can counter\r\n counter = True\r\n instance['t'] = threat[0] # update the instance's current t\r\n instance['f'] = threat[1] # update the instance's current f\r\n break\r\n if not counter: # cannot counter\r\n instances.append({'t': threat[0], 'f': threat[1]}) # add a new instance\r\n return len(instances)","def queryDelay(ants=0) :\n antlist=makeAntList(ants)\n print \"Current delays\"\n for a in antlist :\n mp = \"Control.Antenna%d.delayOffset3mmRx\" %a\n try :\n print \"delay(%7.3f, %2d)\" %(queryDouble(mp, retries=0), a)\n except Exception: \n print \"C%d\" %a, \"does not have a value or is invalid\"","def two_opt_annealing(T, scheme, route, adjacency_matrix, max_chain_length, c):\n best = route.copy()\n cost_list, T_list = [], []\n accept_list = [[],[]]\n\n chains, iterations = 0, 0\n T_0 = T\n iterations = 0\n\n while T > 0:\n for i in range(1, len(route) - 2):\n # test\n # Adjust temperature\n if scheme == \"exp\":\n T = T*c\n if scheme == \"log\":\n alpha = 50\n T = T_0/(1+alpha*np.log(1+iterations))\n # if scheme == \"std\":\n # delta = .01\n # T = T / (1 + ((np.log(1+delta)* T) / (3 * sd0)))\n if scheme == \"quad\":\n alpha = 1\n T = T_0/(1+alpha*iterations**2)\n\n iterations += 1\n \n for j in range(i + 1, len(route)):\n chains += 1\n\n if j - i == 1: continue\n\n cost_list.append(calculate_cost(best,adjacency_matrix)[1])\n T_list.append(T)\n\n if cost_change(adjacency_matrix, best[i - 1], best[i], \\\n best[j - 1], best[j]) < 0:\n best[i:j] = best[j - 1:i - 1:-1]\n else:\n temp = best.copy()\n sd0, cost0 = calculate_cost(temp,adjacency_matrix)\n temp[i:j] = temp[j - 1:i - 1:-1]\n _, cost1 = calculate_cost(temp,adjacency_matrix)\n\n U = rs.uniform()\n Z = np.exp((cost0-cost1)/T)\n\n if U < Z:\n accept_list[1].append(Z)\n accept_list[0].insert(0,T)\n\n best[i:j] = best[j - 1:i - 1:-1]\n\n if chains > max_chain_length:\n print(\"End by chainlength: \",chains,\"T =\",T,\"Cost:\",cost0)\n print(\"route\",best)\n return best, cost_list, accept_list\n\n route = best.copy()\n print(\"End by T: \",T,\"Chains: \",chains,\"Cost:\",cost0)\n print(\"route\",best)\n return best, cost_list, accept_list","def _print_tisserand_lists(self, Trajectory=[]):\n\t\n\timport numpy as np\n\t\n\tn = len(Trajectory);\n\trpl = [];\n\tral = [];\n\tpl = [];\n\tvinfl = [];\n\tfor i in range(n):\n\t\tral.append(Trajectory[i][6]);\n\t\trpl.append(Trajectory[i][5]);\n\t\tpl.append(Trajectory[i][7]);\n\t\tvinfl.append(Trajectory[i][8]);\n\t\n\tprint 'list_ra_python = [',\n\tn = len(ral);\n\tfor i in range(n-1):\n\t\tprint '%f, ' % ral[i],\n\tprint '%f];' % ral[n-1];\n\t\n\tprint 'list_rp_python = [',\n\tn = len(rpl);\n\tfor i in range(n-1):\n\t\tprint '%f, ' % rpl[i],\n\tprint '%f];' % rpl[n-1];\n\t\n\tprint 'list_period_python = [',\n\tn = len(pl);\n\tfor i in range(n-1):\n\t\tprint '%f, ' % pl[i],\n\tprint '%f];' % pl[n-1];\n\t\n\tprint 'list_vinf_python = [',\n\tn = len(vinfl);\n\tfor i in range(n-1):\n\t\tif(vinfl[i] != []):\n\t\t\tprint '%f, ' % np.linalg.norm(vinfl[i]),\n\t\telse:\n\t\t\tprint '0, ',\n\tprint '%f];' % np.linalg.norm(vinfl[n-1]);\n\t\n\tprint 'list_vinf_python_x = [',\n\tn = len(vinfl);\n\tfor i in range(n-1):\n\t\tif(vinfl[i] != []):\n\t\t\tprint '%f, ' % vinfl[i][0],\n\t\telse:\n\t\t\tprint '0, ',\n\tprint '%f];' % vinfl[n-1][0];\n\t\n\tprint 'list_vinf_python_y = [',\n\tn = len(vinfl);\n\tfor i in range(n-1):\n\t\tif(vinfl[i] != []):\n\t\t\tprint '%f, ' % vinfl[i][1],\n\t\telse:\n\t\t\tprint '0, ',\n\tprint '%f];' % vinfl[n-1][1];\n\t\n\tprint 'list_vinf_python_z = [',\n\tn = len(vinfl);\n\tfor i in range(n-1):\n\t\tif(vinfl[i] != []):\n\t\t\tprint '%f, ' % vinfl[i][2],\n\t\telse:\n\t\t\tprint '0, ',\n\tprint '%f];' % vinfl[n-1][2];","async def get_interference_from_directional_beams( # noqa: C901\n im_data: Dict,\n network_name: str,\n n_days: int,\n use_real_links: bool,\n is_n_day_avg: bool,\n) -> List[Dict]:\n result: List = []\n network_name = im_data[\"network_name\"]\n tx_node = im_data[\"tx_node\"]\n logging.info(f\"Analyzing interference for {tx_node}\")\n rx_responses = (\n im_data[\"n_day_avg_rx_responses\"]\n if is_n_day_avg\n else im_data[\"current_avg_rx_responses\"]\n )\n\n tx_infos = await get_latest_stats(\n network_name, tx_node, [\"mcs\", \"tx_beam_idx\", \"tx_power\"]\n )\n\n coros = []\n rx_nodes = []\n for rx_node in rx_responses:\n # Skip if they are the same\n if tx_node == rx_node:\n continue\n\n # Skip if they map to the same site\n tx_site_name = Topology.wlan_mac_to_site_name.get(network_name, {}).get(tx_node)\n rx_site_name = Topology.wlan_mac_to_site_name.get(network_name, {}).get(rx_node)\n if tx_site_name is not None and rx_site_name is not None:\n if tx_site_name == rx_site_name:\n logging.debug(\n f\"{tx_node} and {rx_node} are radios on the same site.\"\n \"Skipping interference analysis.\"\n )\n continue\n else:\n logging.debug(f\"Ignoring missing site name for {tx_node} &/or {rx_node}.\")\n\n # Skip if they are the same polarity\n tx_polarity = Topology.node_polarity.get(network_name, {}).get(tx_node)\n rx_polarity = Topology.node_polarity.get(network_name, {}).get(rx_node)\n if tx_polarity is not None and rx_polarity is not None:\n if tx_polarity == rx_polarity:\n logging.debug(\n f\"{tx_node} and {rx_node} have the same polarity.\"\n \"Skipping interference analysis.\"\n )\n continue\n else:\n logging.debug(\n f\"Ignoring missing polarity info for {tx_node} &/or {rx_node}.\"\n )\n\n logging.info(f\"Analyzing interference from {tx_node} to {rx_node}\")\n rx_nodes.append(rx_node)\n coros.append(get_latest_stats(network_name, rx_node, [\"rx_beam_idx\"]))\n\n for rx_node, rx_infos in zip(rx_nodes, await asyncio.gather(*coros)):\n # Loop through tx_beam and rx_beam combinations\n for tx_to_node, tx_info in tx_infos.items():\n # Skip if it's an actual link\n if rx_node == tx_to_node and not use_real_links:\n continue\n\n tx_beam = tx_info.get(\"tx_beam_idx\")\n if tx_beam is None:\n continue\n\n curr_power_idx = tx_info.get(\"tx_power\")\n if curr_power_idx is not None:\n curr_power_idx = int(curr_power_idx)\n for rx_from_node, rx_info in rx_infos.items():\n # Skip if it's an actual link\n if rx_from_node == tx_node and not use_real_links:\n continue\n\n rx_beam = rx_info.get(\"rx_beam_idx\")\n if rx_beam is None:\n continue\n\n logging.debug(\n f\"TX to {tx_to_node} from {tx_node} uses tx_beam {tx_beam} and \"\n f\"tx_power {curr_power_idx}\"\n )\n logging.debug(\n f\"RX for {rx_node} from {rx_from_node} uses rx_beam {rx_beam}\"\n )\n\n inr = get_interference_data(\n rx_responses[rx_node], int(tx_beam), int(rx_beam)\n )\n if inr is None:\n continue\n\n tx_channel = Topology.node_channel.get(network_name, {}).get(tx_node)\n if tx_channel is not None:\n tx_channel = str(tx_channel)\n\n inr_curr_power = {}\n if curr_power_idx is not None:\n curr_inr_offset = HardwareConfig.get_pwr_offset(\n target_pwr_idx=curr_power_idx,\n channel=tx_channel,\n mcs=tx_info.get(\"mcs\"),\n )\n inr_curr_power = {\"snr_avg\": inr[\"snr_avg\"] + curr_inr_offset}\n\n result.append(\n {\n \"group_id\": im_data.get(\"group_id\"),\n \"token\": im_data.get(\"token\"),\n \"tx_node\": tx_node,\n \"tx_to_node\": tx_to_node,\n \"tx_power_idx\": curr_power_idx,\n \"rx_node\": rx_node,\n \"rx_from_node\": rx_from_node,\n \"inr_curr_power\": inr_curr_power,\n \"inr_max_power\": {\"snr_avg\": inr[\"snr_avg\"]},\n \"is_n_day_avg\": is_n_day_avg,\n }\n )\n logging.info(\n (\n f\"{tx_node} caused interference to {len(result)} other nodes \"\n f\"over scans from last {n_days} days.\"\n )\n if is_n_day_avg\n else (\n f\"{tx_node} caused interference to {len(result)} other nodes \"\n \"in the current scan.\"\n )\n )\n\n return result"],"string":"[\n \"def spin_adapted_t2(creation_list, annihilation_list):\\n _check_int_list(creation_list, \\\"creation operators\\\")\\n _check_int_list(annihilation_list, \\\"annihilation operators\\\")\\n\\n if len(creation_list) != 2 or len(annihilation_list) != 2:\\n raise ValueError(f\\\"T2 excitations take exactly 2 indices for both \\\\\\ncreation and annihilation operators, \\\\\\nbut get {len(creation_list)} and {len(annihilation_list)} indices.\\\")\\n\\n p = creation_list[0]\\n r = annihilation_list[0]\\n q = creation_list[1]\\n s = annihilation_list[1]\\n tpqrs1 = _pij_dagger(p, q) * _pij(r, s)\\n tpqrs2 = _qij_vec_inner(p, q, r, s)\\n tpqrs_list = [tpqrs1, tpqrs2]\\n return tpqrs_list\",\n \"def simulationTwoDrugsDelayedTreatment(numTrials):\\n # TODO\",\n \"def changetype(atms,t1,t2, nt2):\\n\\n # find total number of atoms\\n ntotal = len(atms)\\n t1ids = []\\n nt1 = 0;\\n \\n # find total number of t1 atoms and their ids\\n for ia in range(ntotal):\\n if atms[ia][3] == t1:\\n t1ids.append(ia)\\n nt1 +=1\\n \\n nt2 = int(nt2)\\n if nt2 < 1:\\n print \\\"$$$ ERROR: not enough atoms of type ## \\\" + str(t1) + \\\" ## \\\" + str(nt1) + \\\" are available to alloy $$$\\\"\\n return\\n\\n np.random.shuffle(t1ids)\\n rnd = t1ids[:nt2]\\n for zombie in rnd:\\n atms[zombie][3] = t2\\n\\n return (atms,rnd)\",\n \"def example2():\\n arrive_time=rand_arr_time.rand_arr_time(6,100000,1000) # Get packet arrive time, with option 2, 100000 packets, expected in 1000 seconds.\\n return arrive_time\",\n \"def get_both_times(individuals):\\n ambulance_patients_times = []\\n other_patients_times = []\\n patients_still_in_system = []\\n\\n for ind in individuals:\\n if ind.data_records[0].node == 1 and len(ind.data_records) == 2:\\n ambulance_patients_times.append(\\n ind.data_records[0].time_blocked\\n + ind.data_records[1].time_blocked\\n + ind.data_records[0].waiting_time\\n + ind.data_records[1].waiting_time\\n )\\n elif ind.data_records[0].node == 2 and len(ind.data_records) == 1:\\n other_patients_times.append(\\n ind.data_records[0].waiting_time + ind.data_records[0].time_blocked\\n )\\n else:\\n patients_still_in_system.append(ind)\\n return [ambulance_patients_times, other_patients_times, patients_still_in_system]\",\n \"def inter_arrival_times(self):\\n # this function returns arrival times between two subsequent tuples in ms\\n # task mean_inter_arrival_time std_inter_arrival_time\\n if self.inter_arrival_time is None:\\n if self.tuple_arrival is None:\\n self.tuple_arrivals()\\n self.inter_arrival_time = convert_throughput_to_inter_arr_times(self.tuple_arrival)\\n\\n return self.inter_arrival_time\",\n \"def tlln(sessions):\\n # key = ap, value = list of [start, end] two-pairs\\n ap_times = defaultdict(list)\\n AP_IDX, START_IDX, END_IDX = 3, 1, 2\\n for s in sessions:\\n ap, start, end = s[AP_IDX], s[START_IDX], s[END_IDX]\\n ap_times[ap].append([start, end])\\n for k in ap_times.keys():\\n times = ap_times[k]\\n random.shuffle(times)\\n ap_times[k] = times\\n out = []\\n for s in sessions:\\n ap = s[AP_IDX]\\n new_start, new_end = ap_times[ap].pop()\\n out.append([s[0], new_start, new_end, s[3]])\\n return out\",\n \"def M_D_1(arrival_time,max_time,service_time=1/90):\\n #conversion in seconds\\n max_seconds = max_time*60*60\\n sim_time = 0.0 # simulation time\\n t_1 = 0.0 # time for next event (arrival)\\n t_2 = max_seconds # time for next event (departure)\\n t_n = 0.0 #last event time--> tempo dell'ultimo avvenimento generico\\n t_b = 0.0 # last start of busy time--> tempo in cui la queue inizia ad essere non vuota per l'ultima volta\\n c = 0 # numero di servizi completati\\n queue_aircraft = [] # number of aircraft in the queue\\n aircraft = 0\\n arrival = [] # time of arrival\\n attesa = [] # attesa per gli aerei-->NON SICURO CHE SI CALCOLI COSI'\\n # simulation loop\\n while(sim_time < max_seconds):\\n if(t_1<t_2): #event1:arrival\\n sim_time = t_1\\n arrival.append(t_1)\\n aircraft += 1\\n queue_aircraft.append(aircraft)\\n t_n = sim_time\\n t_1 = sim_time + rm.expovariate(arrival_time)\\n if(aircraft==1):\\n t_b = sim_time\\n t_2 = sim_time + 1/service_time\\n else:\\n sim_time = t_2\\n aircraft = aircraft -1\\n queue_aircraft.append(aircraft)\\n t_n = sim_time\\n attesa.append( t_2 - arrival[c])\\n c+=1\\n if(aircraft>0):\\n t_2=sim_time + 1/service_time\\n else:\\n t_2 = max_seconds\\n\\n\\n\\n\\n return queue_aircraft,arrival,attesa\",\n \"def simulationTwoDrugsDelayedTreatment():\\n\\n # TODO\",\n \"def update_hospitals_lists(\\n hospital_times_1, hospital_times_2, times_1, times_2, measurement_type\\n):\\n if measurement_type == \\\"w\\\":\\n hospital_times_1.append(\\n np.nanmean([np.nanmean(w.waiting_times) for w in times_1])\\n )\\n hospital_times_2.append(\\n np.nanmean([np.nanmean(w.waiting_times) for w in times_2])\\n )\\n else:\\n hospital_times_1.append(\\n np.nanmean([np.nanmean(b.blocking_times) for b in times_1])\\n )\\n hospital_times_2.append(\\n np.nanmean([np.nanmean(b.blocking_times) for b in times_2])\\n )\\n return hospital_times_1, hospital_times_2\",\n \"def hit_time(tmat,start_list,targ_list,ntraj = 1000, cutoff=1000):\\n \\n # get state names\\n nstates = tmat.shape[0]\\n states = array([ii for ii in range(nstates)])\\n \\n times = list()\\n \\n for ii in range(ntraj):\\n curr = choice(start_list)\\n tm = 0\\n while curr not in targ_list:\\n weights = copy(tmat[curr, :])\\n curr = discrete_dist(states, weights, nn=1)\\n tm += 1\\n if tm==cutoff:\\n tm = nan\\n break\\n \\n times.append(tm)\\n\\n return array(times)\",\n \"def sources_over_time(ant1, ant2, list_sources=None,\\n start=0, end=2/3*np.pi, interval=np.pi/72, nu=151e6):\\n if list_sources is None:\\n # make a copy to ensure write safety\\n list_sources = catalog.obj_catalog.copy()\\n\\n # If the user has entered a single source directly,\\n # we can automatically standardize the formatting\\n # by placing it by itself in a list\\n if type(list_sources) != list:\\n list_sources = [list_sources]\\n \\n list_visibilities = []\\n lst = start\\n while lst <= end:\\n next_vista = np.array([0j, 0j, 0j, 0j])\\n for source in list_sources:\\n next_vista += visibility(ant1, ant2, source, nu=nu, time=lst)\\n\\n list_visibilities.append(np.array([lst, next_vista]))\\n lst += interval\\n # perhaps not necessary. Better safe than sorry:\\n return np.array(list_visibilities)\",\n \"def find_time_beats(dw1, dw2, dw3, dw4, dw5, dw6, p1, p2, p3, p4, p5, p6):\\n time_beats = numpy.concatenate((dw1[p1, 0], dw2[p2, 0],\\n dw3[p3, 0], dw4[p4, 0],\\n dw5[p5, 0], dw6[p6, 0]))\\n\\n time_beats = numpy.ndarray.tolist(time_beats)\\n\\n logging.info('Calculated time of beats: %s', time_beats)\\n return time_beats\",\n \"def new_sources_over_time(ant1, ant2,\\n list_sources=None,\\n start=0, end=2/3*np.pi, interval=np.pi/72,\\n nu=151e6, interpolator=None):\\n if interpolator is None:\\n raise NotImplementedError(\\\"We are\\\" + \\\\\\n \\\" currently hard-coding interpolators.\\\")\\n \\n if list_sources is None:\\n # make a copy to ensure write safety\\n list_sources = catalog.obj_catalog.copy()\\n\\n # If the user has entered a single source directly,\\n # we can automatically standardize the formatting\\n # by placing it by itself in a list\\n if type(list_sources) != list:\\n list_sources = [list_sources]\\n\\n list_lst = []\\n lst = start\\n while lst <= end:\\n list_lst.append(lst)\\n lst += interval\\n list_lst = np.array(list_lst)\\n\\n list_visibilities = np.zeros(\\n (len(list_lst), 4),\\n dtype=np.complex128)\\n\\n for source in list_sources:\\n # establish values common to all visibility calculations\\n I = get_I(source, nu)\\n s = np.array([complex(I), 0, 0, 0])\\n ra = np.radians(source.ra_angle)\\n dec = np.radians(source.dec_angle)\\n\\n for k in range(len(list_lst)):\\n curr_lst = list_lst[k]\\n\\n # no input for latitude. Code is no longer general :(\\n # no input for radians either. We have to rely on the user\\n # to provide a radian-based interpolator.\\n az, alt = rot.eq_to_topo(\\n ra, dec, lst=curr_lst, radians=True)\\n A = interpolator(az, alt)\\n\\n r = rot.radec2lm(ra, dec, ra0=curr_lst)\\n phi = ant.phase_factor(ant1, ant2, r, nu)\\n\\n malformed_result = np.dot(np.dot(A, s), phi)\\n\\n list_visibilities[k] += malformed_result\\n \\n # perhaps not necessary. Better safe than sorry:\\n return list_lst, np.array(list_visibilities)\",\n \"def illegal_direct_motion(a_list, b_list):\\n illegal_direct_intervals = ['5', '1']\\n illegal_direct_motions = []\\n direct_motions = direct_motion(a_list, b_list)\\n\\n for x in direct_motions:\\n (interval, octaves), time = x\\n\\n if interval in illegal_direct_intervals:\\n illegal_direct_motions.append(x)\\n\\n return illegal_direct_motions\",\n \"def annealing(nodes, distances, maxTime, ans):\\n\\n #edge cases\\n if len(nodes) == 0:\\n ans[\\\"path\\\"] = []\\n ans[\\\"cost\\\"] = 0\\n return\\n if len(nodes) == 1:\\n ans[\\\"path\\\"] = nodes\\n ans[\\\"cost\\\"] = 0\\n return\\n if len(nodes) == 2:\\n ans[\\\"path\\\"] = nodes\\n ans[\\\"cost\\\"] = totalDist(nodes, distances)\\n return\\n\\n #Picking a starting tour\\n currPath = generateStartingTour(nodes, distances)\\n currCost = totalDist(currPath, distances)\\n\\n startingAnnealingTime = time.time()\\n maxTemperature = maxTime - startingAnnealingTime + 0.05\\n avg = 0\\n while True:\\n #check if time is up\\n t = time.time()\\n if t > maxTime:\\n break\\n \\n #check if current path is best path\\n if currCost < ans[\\\"cost\\\"]:\\n ans[\\\"path\\\"] = currPath\\n ans[\\\"cost\\\"] = currCost\\n #print(ans[\\\"cost\\\"])\\n\\n #try a neighbor\\n skel = randomNeighborSkeleton(currPath, currCost, distances)\\n if skel[0] == 1:\\n i = skel[1]\\n j = skel[2]\\n newCost = skel[3]\\n else:\\n i = skel[1]\\n newCost = skel[2]\\n\\n currTemperature = maxTemperature - (t - startingAnnealingTime)\\n\\n avg = (avg * 1000 + abs(currCost-newCost)) / 1001\\n\\n #move to neighbor with some probability\\n if random.random() < chance(currCost, newCost, currTemperature, maxTemperature, avg):\\n if skel[0] == 1:\\n contiguousFlip(currPath, i, j)\\n else:\\n consecutiveFlip(currPath, i)\\n currCost = newCost\",\n \"def predict_event(rule, event1, event2):\\n max_t=float('inf')\\n min_t=float('-inf')\\n if event1[0] > event2[0] :\\n aux=event1\\n event1=event2\\n event2=aux\\n for p in rule[1][2:] :\\n if p[1]!=(event1[0],event2[0]) :\\n if p[1][0]==event1[0] :\\n min_t = max(min_t,event1[1]+p[0][0])\\n max_t = min(max_t,event1[1]+p[0][1])\\n if p[1][1]==event1[0] :\\n min_t = max(min_t,event1[1]-p[0][1])\\n max_t = min(max_t,event1[1]-p[0][0])\\n if p[1][0]==event2[0] :\\n min_t = max(min_t,event2[1]+p[0][0])\\n max_t = min(max_t,event2[1]+p[0][1])\\n if p[1][1]==event2[0] :\\n min_t = max(min_t,event2[1]-p[0][1])\\n max_t = min(max_t,event2[1]-p[0][0])\\n for e in rule[1][0]:\\n if e!=event1[0] and e!=event2[0] :\\n next_event=e\\n return [next_event,[min_t,max_t],rule[2],rule]\",\n \"def tt(obs_time, *whatevers):\\n n = whatevers[0].size\\n return tuple(\\n [obs_time[:n], ] +\\n list(whatevers)\\n )\",\n \"def time_signatures():\\n # numerators = [[2, 2, 3], [2, 4], [3, 4, 5]]\\n # numerators = baca.sequence.helianthate(numerators, -1, -1)\\n pairs = [[(2, 4), (2, 4), (6, 4)], [(3, 4), (4, 4)], [(6, 8), (4, 4), (5, 4)]]\\n pairs = baca.sequence.helianthate(pairs, -1, -1)\\n pairs = abjad.sequence.flatten(pairs)\\n time_signatures_ = [abjad.TimeSignature(_) for _ in pairs]\\n time_signatures = abjad.CyclicTuple(time_signatures_)\\n return time_signatures\",\n \"def generate_input_and_target(dict_keys_time, seq_len=50):\\n # Get the start time and end time\\n start_time, end_time = list(dict_keys_time.keys())[0], list(dict_keys_time.keys())[-1]\\n list_training, list_target = [], []\\n for index_enum, time in enumerate(range(start_time, end_time)):\\n list_append_training, list_append_target = [], []\\n start_iterate = 0\\n flag_target_append = False # flag to append the test list\\n if index_enum < seq_len:\\n start_iterate = seq_len - index_enum - 1\\n for i in range(start_iterate): # add 'e' to the seq list. \\n list_append_training.append('e')\\n flag_target_append = True\\n\\n for i in range(start_iterate,seq_len):\\n index_enum = time - (seq_len - i - 1)\\n if index_enum in dict_keys_time:\\n list_append_training.append(','.join(str(x) for x in dict_keys_time[index_enum])) \\n else:\\n list_append_training.append('e')\\n\\n # add time + 1 to the list_append_target\\n if time+1 in dict_keys_time:\\n list_append_target.append(','.join(str(x) for x in dict_keys_time[time+1]))\\n else:\\n list_append_target.append('e')\\n list_training.append(list_append_training)\\n list_target.append(list_append_target)\\n return list_training, list_target\",\n \"def smooth_time_constraints(list_constraints):\\n\\n for constraint_one in list_constraints:\\n for constraint_two in list_constraints:\\n if check_simultaneity(constraint_one, constraint_two):\\n merge_time_constraints(list_constraints, constraint_one, constraint_two)\\n return list_constraints\",\n \"def lessthan_5(num_list):\",\n \"def simulationTwoDrugsDelayedTreatment(numTrials):\\n results = []\\n gutresults = []\\n \\n for a in range(375):\\n results.append([])\\n gutresults.append([])\\n \\n for b in range(numTrials):\\n viruses = []\\n for c in range(100):\\n resistances = {'guttagonol': False, 'grimpex': False}\\n vir = ResistantVirus(.1, .05, resistances, .02)\\n viruses.append(vir)\\n \\n Mark = TreatedPatient(viruses, 1000)\\n \\n for d in range(150):\\n pop = Mark.update()\\n results[d].append(pop)\\n gutpop = Mark.getResistPop(['guttagonol'])\\n gutresults[d].append(gutpop)\\n \\n Mark.addPrescription('guttagonol')\\n \\n for e in range(150, 225):\\n newpop = Mark.update()\\n results[e].append(newpop)\\n newgutpop = Mark.getResistPop(['guttagonol'])\\n gutresults[e].append(newgutpop)\\n \\n Mark.addPrescription('grimpex')\\n \\n for f in range(225, 375):\\n newpop = Mark.update()\\n results[f].append(newpop)\\n \\n \\n FinalResults = results[374]\\n print len(FinalResults)\\n \\n \\n pylab.figure(6)\\n pylab.hist(FinalResults, bins = 10)\\n pylab.title('300 day delay')\\n pylab.xlabel('Virus Population')\\n pylab.ylabel('Number of Trials with Population') \\n pylab.show()\",\n \"def test_tuple_synapses(self):\\n # reproducible arbitrariness\\n np.random.seed(5003)\\n\\n self.conductor.out_step = np.random.randn(self.Nc)\\n self.tutor.out_step = np.random.randn(self.Ns)\\n\\n self.rule.alpha = 1.0\\n self.rule.beta = 1.5\\n\\n tmax = 10*self.dt\\n\\n W0 = np.copy(self.syns.W)\\n\\n sim1 = simulation.Simulation(self.conductor, self.student, self.tutor,\\n self.syns, self.rule, dt=self.dt)\\n sim1.run(tmax)\\n\\n final1 = np.copy(self.syns.W)\\n\\n self.syns.W = np.copy(W0)\\n\\n rule2 = TwoExponentialsPlasticity(\\n (self.syns.source, self.syns.target, self.syns.W),\\n self.tutor, constrain_positive=False, rate=1-6)\\n rule2.alpha = 1.0\\n rule2.beta = 1.5\\n\\n sim2 = simulation.Simulation(self.conductor, self.student, self.tutor,\\n self.syns, rule2, dt=self.dt)\\n sim2.run(tmax)\\n\\n final2 = np.copy(self.syns.W)\\n\\n self.assertTrue(np.allclose(final1, final2))\",\n \"def simulationTwoDrugsDelayedTreatment(numTrials):\\n # TODO\\n pop_list = {}\\n resistant_pop_list = {}\\n init_step_list = [300, 150, 75, 0]\\n for index, init_step in enumerate(init_step_list):\\n pop_list[init_step] = get_pop_list(init_step, numTrials)\\n pylab.subplot(2, 2, index + 1)\\n pylab.hist(pop_list[init_step])\\n pylab.title('histogram of init step ' + str(init_step))\\n pylab.xlabel('bin')\\n pylab.ylabel('frequency')\\n pylab.show()\\n return pop_list\",\n \"def get_blocking_times(individuals):\\n ambulance_patients_times = []\\n other_patients_times = []\\n patients_still_in_system = []\\n\\n for ind in individuals:\\n if ind.data_records[0].node == 1 and len(ind.data_records) == 2:\\n ambulance_patients_times.append(\\n ind.data_records[0].time_blocked + ind.data_records[1].time_blocked\\n )\\n elif ind.data_records[0].node == 2 and len(ind.data_records) == 1:\\n other_patients_times.append(ind.data_records[0].time_blocked)\\n else:\\n patients_still_in_system.append(ind)\\n return [ambulance_patients_times, other_patients_times, patients_still_in_system]\",\n \"def test_tuple_synapses(self):\\n # reproducible arbitrariness\\n np.random.seed(5003)\\n\\n self.conductor.out_step = np.random.randn(self.Nc)\\n self.tutor.out_step = np.random.randn(self.Ns)\\n\\n self.rule.alpha = 1.0\\n self.rule.beta = 1.5\\n\\n tmax = 10*self.dt\\n\\n W0 = np.copy(self.syns.W)\\n\\n sim1 = simulation.Simulation(self.conductor, self.student, self.tutor,\\n self.syns, self.rule, dt=self.dt)\\n sim1.run(tmax)\\n\\n final1 = np.copy(self.syns.W)\\n\\n self.syns.W = np.copy(W0)\\n\\n rule2 = SuperExponentialPlasticity(\\n (self.syns.source, self.syns.target, self.syns.W),\\n self.tutor, constrain_positive=False, rate=1-6)\\n rule2.alpha = 1.0\\n rule2.beta = 1.5\\n\\n sim2 = simulation.Simulation(self.conductor, self.student, self.tutor,\\n self.syns, rule2, dt=self.dt)\\n sim2.run(tmax)\\n\\n final2 = np.copy(self.syns.W)\\n\\n self.assertTrue(np.allclose(final1, final2))\",\n \"def get_waiting_times(individuals):\\n ambulance_patients_times = []\\n other_patients_times = []\\n patients_still_in_system = []\\n\\n for ind in individuals:\\n if ind.data_records[0].node == 1 and len(ind.data_records) == 2:\\n ambulance_patients_times.append(\\n ind.data_records[0].waiting_time + ind.data_records[1].waiting_time\\n )\\n elif ind.data_records[0].node == 2 and len(ind.data_records) == 1:\\n other_patients_times.append(ind.data_records[0].waiting_time)\\n else:\\n patients_still_in_system.append(ind)\\n return [ambulance_patients_times, other_patients_times, patients_still_in_system]\",\n \"def GetBonds(Bonds):\\n b = sorted([(min(x), max(x)) for x in Bonds])\\n Bonds13, Bonds14 = [], []\\n for (a1,b1) in b:\\n #check for bonds with a1 at the center of a 1-3 interaction,\\n #letting b1 be the higher number of the two flanking\\n clist = [b2 for (a2,b2) in b if a2 == a1 and b2 < b1] + \\\\\\n [a2 for (a2,b2) in b if b2 == a1 and a2 < b1]\\n Bonds13.extend([(min(c,b1), max(c,b1)) for c in clist])\\n #check for bonds with b1 at the center of a 1-3 interaction,\\n #letting a1 be the higher number of the two flanking\\n clist = [b2 for (a2,b2) in b if a2 == b1 and b2 < a1] + \\\\\\n [a2 for (a2,b2) in b if b2 == b1 and a2 < a1]\\n Bonds13.extend([(min(c,a1), max(c,a1)) for c in clist])\\n #find atoms connected to a1\\n clist = [b2 for (a2,b2) in b if a1==a2 and not b1==b2] +\\\\\\n [a2 for (a2,b2) in b if a1==b2 and not b1==a2]\\n #find atoms connected to b1\\n dlist = [a2 for (a2,b2) in b if b1==b2 and not a1==a2] +\\\\\\n [b2 for (a2,b2) in b if b1==a2 and not a1==b2]\\n Bonds14.extend([(min(c,d), max(c,d)) for c in clist for d in dlist])\\n Bonds1213 = b + Bonds13\\n #sort\\n Bonds1213.sort()\\n Bonds14.sort()\\n #get unique values in case of loops\\n Bonds1213 = [x for (i,x) in enumerate(Bonds1213) if i == 0 or x != Bonds1213[i-1]]\\n Bonds14 = [x for (i,x) in enumerate(Bonds14) if i == 0 or x != Bonds14[i-1]]\\n #convert to arrays \\n Bonds1213 = array(Bonds1213, int)\\n Bonds14 = array(Bonds14, int)\\n return Bonds1213, Bonds14\",\n \"def two_temps(L, n_cycles, temp):\\n\\n E = np.zeros((2, len(temp), n_cycles))\\n Mag = np.zeros((2, len(temp), n_cycles))\\n MagAbs = np.zeros((2, len(temp), n_cycles))\\n SH = np.zeros((2, len(temp), n_cycles))\\n Suscept = np.zeros((2, len(temp), n_cycles))\\n\\n Naccept = np.zeros((2, len(temp), n_cycles))\\n\\n ground_spin_mat = np.ones((L, L), np.int8) # initial state (ground state)\\n\\n for m in range(2):\\n for t in range(len(temp)):\\n\\n #m=0 is ground state, all spin-up\\n #m=1 is random state\\n if m==0:\\n spin_matrix = ground_spin_mat\\n else:\\n s_mat_random = np.ones((L, L), np.int8) # spin matrix of ones\\n #random indices switched to -1\\n for sw in range(len(s_mat_random)):\\n for sl in range(len(s_mat_random)):\\n rint = np.random.randint(-1,1)\\n if rint == -1:\\n s_mat_random[sw,sl] *= -1\\n spin_matrix = s_mat_random\\n\\n\\n print(\\\"hi\\\")#; sys.exit(1)\\n Energy, Magnetization, MagnetizationAbs, SpecificHeat, Susceptibility, Nacc \\\\\\n = numerical_solution(spin_matrix, n_cycles, temp[t], L, abs=False)\\n\\n\\n E[m,t,:] = Energy\\n Mag[m,t,:] = Magnetization\\n MagAbs[m,t,:] = MagnetizationAbs\\n SH[m,t,:] = SpecificHeat\\n Suscept[m,t,:] = Susceptibility\\n\\n Naccept[m,t,:] = Nacc\\n\\n return E, Mag, MagAbs, SH, Suscept, Naccept\",\n \"def initialize_output_times_from_tunables():\\n duration = (\\n h_to_s(SimulationDuration.value)\\n if SimulationDuration.value > 0\\n else float('inf')\\n )\\n\\n output_interval = h_to_s(SimulationOutputInterval.value)\\n\\n if not SimulationOutputFirstState.value:\\n last_output = 0.0\\n else:\\n last_output = -(h_to_s(SimulationOutputInterval.value) + sys.float_info.epsilon)\\n\\n return duration, output_interval, last_output\",\n \"def target(self, time, points, dt, num_way):\\n start_index = min(int(time / dt), num_way - 1)\\n end_index = min(start_index + 1, num_way - 1)\\n start_point = points[start_index]\\n end_point = points[end_index]\\n fraction = float(time % dt) / dt\\n return linear_interpolation_two_points(start_point, end_point, fraction).reshape(3)\",\n \"def simulationDelayedTreatment(numTrials):\\n\\n delays = [300,150,75,0]\\n results = [[],[],[],[]]\\n for place in range(0, 4):\\n for trial in range(numTrials):\\n viruses = []\\n for num in range(100):\\n viruses.append(ResistantVirus(0.1,0.05, {'guttagonol': False}, 0.005))\\n patient = TreatedPatient(viruses, 1000)\\n for delay in range(delays[place]):\\n patient.update()\\n patient.addPrescription(\\\"guttagonol\\\") \\n for l in range(150):\\n patient.update()\\n results[place].append(patient.getTotalPop())\\n pylab.hist(results[0])\\n pylab.hist(results[1])\\n pylab.hist(results[2])\\n pylab.hist(results[3])\\n pylab.show()\\n for x in range(0, 10):\",\n \"def _combine_relational(self, r0, t0, r1, t1, now):\\n # logger.debug(\\\"combine_relational t0 {0} now {1}\\\".format(t0, now))\\n assert(t0<=now)\\n assert(t1 is None or t1<=now)\\n\\n x0, y0=r0\\n x1, y1=r1\\n\\n # Special case where global detection hasn't happened yet.\\n if t1 is None:\\n t1=t0\\n x1=[t0]\\n y1=[y1[0]]\\n\\n absx=[(x+t0, 0, i) for (i, x) in enumerate(x0)]\\n absx.extend([(x+t1, 1, i) for (i, x) in enumerate(x1)])\\n y=[y0, y1]\\n\\n xx=list()\\n yy=list()\\n hazards=[0.0, 0.0]\\n for t, j, i in sorted(absx, key=lambda x: x[0]):\\n if not xx or t!=xx[-1]:\\n xx.append(t)\\n hazards[j]=y[j][i]\\n yy.append(hazards[0]*hazards[1])\\n else:\\n hazards[j]=y[j][i]\\n yy[-1]=(hazards[0]*hazards[1])\\n\\n xl=[x for x in xx if x<=now]\\n xend=len(xl)-1\\n xx=xx[xend:]\\n yy=yy[xend:]\\n xx[0]=now\\n\\n return ([x-now for x in xx], yy)\",\n \"def Kendalls_Tau2(xlist, ylist):\\n\\tif len(xlist) != len(ylist):\\n\\t\\traise StatsError(\\\"Data sets have different lengths.\\\")\\n\\txdata = xlist\\n\\tydata = ylist\\n\\t#for i in range(len(xlist)):\\n\\t#\\tif xlist[i] != None and ylist[i] != None:\\n\\t#\\t\\txdata.append(xlist[i])\\n\\t#\\t\\tydata.append(ylist[i])\\n\\tassert len(xdata) == len(ydata)\\n\\t#assert len(xdata) <= len(xlist) - xlist.count(None)\\n\\t#assert len(ydata) <= len(ylist) - ylist.count(None)\\n\\t#assert len(ydata) >= len(ylist) - xlist.count(None) - ylist.count(None)\\n\\tif len(xdata) == 0:\\n\\t\\traise StatsError(\\\"No valid data entries.\\\")\\n\\tn = len(xdata)\\n\\t# compute the number of concordant and discordant pairs\\n\\tconc = disc = 0.0 # concordant and discordant pairs\\n\\tnx = ny = 0.0\\n\\tupdown = 0\\n\\tfor i in range(n): # loop over all pairs\\n\\t\\txi = xdata[i]\\n\\t\\tyi = ydata[i]\\n\\t\\tif xi and yi:\\n\\t\\t\\tfor j in range(i + 1, n):\\n\\t\\t\\t\\tif xdata[j] and ydata[j]:\\n\\t\\t\\t\\t\\txd = xi - xdata[j]\\n\\t\\t\\t\\t\\tyd = yi - ydata[j]\\n\\t\\t\\t\\t\\tprod = xd * yd\\n\\t\\t\\t\\t\\tif prod != 0:\\n\\t\\t\\t\\t\\t\\tnx += 1\\n\\t\\t\\t\\t\\t\\tny += 1\\n\\t\\t\\t\\t\\t\\tif prod > 0:\\n\\t\\t\\t\\t\\t\\t\\tupdown += 1\\n\\t\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\t\\tupdown -= 1\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tif xd != 0:\\n\\t\\t\\t\\t\\t\\t\\tnx += 1\\n\\t\\t\\t\\t\\t\\tif yd != 0:\\n\\t\\t\\t\\t\\t\\t\\tny += 1\\n\\t# Compute tau\\n\\tn = float(n)\\n\\tdenom = math.sqrt(nx*ny)\\n\\ttry:\\n\\t\\ttau = float(updown) / denom\\n\\texcept ZeroDivisionError:\\n\\t\\traise StatsError(\\\"Too few entries: {:d}\\\".format(n))\\n\\t# Compute P-value\\n\\tz = 3.0 * tau * math.sqrt(n * (n - 1.0)) / math.sqrt(2.0 * (2.0 * n + 5.0))\\n\\tprob = Prob_Z(z)\\n\\treturn (tau, prob, int(n))\",\n \"def get_times_for_patients(\\n lambda_2,\\n lambda_1,\\n mu,\\n num_of_servers,\\n threshold,\\n seed_num,\\n measurement_type,\\n runtime,\\n):\\n individuals = simulate_model(\\n lambda_2, lambda_1, mu, num_of_servers, threshold, seed_num, runtime\\n ).get_all_individuals()\\n\\n if measurement_type == \\\"w\\\":\\n times = get_waiting_times(individuals)\\n elif measurement_type == \\\"b\\\":\\n times = get_blocking_times(individuals)\\n else:\\n times = get_both_times(individuals)\\n\\n return [times[0], times[1], times[2]]\",\n \"def postprocessing(net, initial_marking, final_marking, A, B, pairs, loop_one_list):\\n label_transition_dict = {}\\n for label in loop_one_list:\\n label_transition_dict[label] = PetriNet.Transition(label, label)\\n net.transitions.add(label_transition_dict[label])\\n\\n # F L1L\\n # Key is specific loop element\\n for key, value in A.items():\\n if key in B:\\n A_without_B = value - B[key]\\n B_without_A = B[key] - value\\n pair = (A_without_B, B_without_A)\\n for pair_try in pairs:\\n in_part = pair_try[0]\\n out_part = pair_try[1]\\n if pair[0].issubset(in_part) and pair[1].issubset(out_part):\\n pair_try_place = PetriNet.Place(str(pair_try))\\n add_arc_from_to(label_transition_dict[key], pair_try_place, net)\\n add_arc_from_to(pair_try_place, label_transition_dict[key], net)\\n return net, initial_marking, final_marking\",\n \"def make_plot_two_hospitals_arrival_split(\\n lambda_2,\\n lambda_1_1,\\n lambda_1_2,\\n mu_1,\\n mu_2,\\n num_of_servers_1,\\n num_of_servers_2,\\n threshold_1,\\n threshold_2,\\n measurement_type=\\\"b\\\",\\n seed_num_1=None,\\n seed_num_2=None,\\n warm_up_time=100,\\n trials=1,\\n accuracy=10,\\n runtime=1440,\\n):\\n hospital_times_1 = []\\n hospital_times_2 = []\\n all_arrival_rates = np.linspace(0, lambda_2, accuracy + 1)\\n for arrival_rate_1 in all_arrival_rates[1:-1]:\\n arrival_rate_2 = lambda_2 - arrival_rate_1\\n times_1 = get_multiple_runs_results(\\n arrival_rate_1,\\n lambda_1_1,\\n mu_1,\\n num_of_servers_1,\\n threshold_1,\\n seed_num_1,\\n warm_up_time,\\n trials,\\n runtime,\\n )\\n times_2 = get_multiple_runs_results(\\n arrival_rate_2,\\n lambda_1_2,\\n mu_2,\\n num_of_servers_2,\\n threshold_2,\\n seed_num_2,\\n warm_up_time,\\n trials,\\n runtime,\\n )\\n hospital_times_1, hospital_times_2 = update_hospitals_lists(\\n hospital_times_1, hospital_times_2, times_1, times_2, measurement_type\\n )\\n\\n x_axis_label, y_axis_label, title = get_two_hospital_plot_labels(measurement_type)\\n x_labels = all_arrival_rates[1:-1] / all_arrival_rates[-1]\\n plt.figure(figsize=(23, 10))\\n waiting_time_plot = plt.plot(x_labels, hospital_times_1, ls=\\\"solid\\\", lw=1.5)\\n plt.plot(x_labels, hospital_times_2, ls=\\\"solid\\\", lw=1.5)\\n plt.legend([\\\"Hospital 1\\\", \\\"Hospital 2\\\"], fontsize=\\\"x-large\\\")\\n plt.title(title, fontsize=18)\\n plt.xlabel(x_axis_label, fontsize=15, fontweight=\\\"bold\\\")\\n plt.ylabel(y_axis_label, fontsize=15, fontweight=\\\"bold\\\")\\n\\n return waiting_time_plot\",\n \"def syns(alpha=0.1, rate=10, delay=0, dur=50, amp=1.0, dt=0.020, N=1, mindur = 120, makewave=True):\\n deadtime = 0.7\\n if dur + delay < mindur:\\n tvec = np.arange(0.0, mindur , dt)\\n else:\\n tvec = np.arange(0.0, dur+delay , dt)\\n npts = len(tvec)\\n ta = np.arange(0.0, 20.0, dt)\\n aw = ta * alpha* np.exp(-ta/alpha)/alpha # alpha waveform time course\\n spt = [[]]*N # list of spike times\\n wave = np.array([]) # waveform\\n sptime=[]\\n for j in range(0,N):\\n done = False\\n t=0.0\\n nsp = 0\\n while not done:\\n a = np.random.sample(1)\\n if t < delay:\\n t = delay\\n continue\\n if t >= delay and t <= (delay+dur):\\n ti = -np.log(a)/(rate/1000.0) # convert to exponential distribution with rate\\n if ti < deadtime:\\n continue\\n t = t + ti # running time\\n if t > delay+dur:\\n done = True\\n continue\\n if nsp is 0:\\n sptime = t\\n nsp = nsp+1\\n else:\\n sptime = np.append(sptime, t)\\n nsp = nsp+1\\n if j is 0:\\n wavej = np.zeros(len(tvec))\\n for i in range(0,len(sptime)):\\n st = int(sptime[i]/dt)\\n wavej[st] = wavej[st] + 1\\n spt[j] = sptime\\n\\n if makewave:\\n w = np.convolve(wavej, aw/max(aw))*amp\\n if len(w) < npts:\\n w = np.append(w, np.zeros(npts-len(w)))\\n if len(w) > npts:\\n w = w[0:npts]\\n if j is 0:\\n wave = w\\n else:\\n wave = wave + w\\n return (spt, wave, tvec, N)\",\n \"def setupDistribution(tournamentsWon1):\\n timesWon = np.sort(np.unique(tournamentsWon1))\\n numberTimesWon = np.zeros_like(timesWon)\\n for i in range (len(timesWon)):\\n numberTimesWon[i] = count(tournamentsWon1, timesWon[i])\\n return timesWon, numberTimesWon\",\n \"def get_times(level, ns, nt, no, ne, nf):\\r\\n\\r\\n automaton = search_automaton(ns, nt, no, ne, nf, level, method3_2)\\r\\n if type(automaton) is str:\\r\\n print automaton\\r\\n exit(-1)\\r\\n times = list()\\r\\n for method in (method1, method2, method3_1, method3_2):\\r\\n start = time.clock()\\r\\n method(automaton, level)\\r\\n stop = time.clock()\\r\\n times.append(stop - start)\\r\\n return times\",\n \"def generate_weight(time_arr, imp_arr, cost_arr, time=0, imp=0, cost=0):\\n return [sum(x) for x in zip(np.multiply(time_arr, time),\\n np.multiply(imp_arr, imp),\\n np.multiply(cost_arr, cost)\\n )]\",\n \"def two_step_test(ind_obs, delaytype):\\n # 1. Estimate\\n error, theta = experiment(ind_obs, delaytype, display=True)\\n # 2. Compute the optimal toll pricing using the estimated latency function\\n tolls, tolls_collected, so_costs, costs, ue_costs = test_toll_pricing(theta, True, [1e-6])\\n # 3. Compute the real effect of the toll pricing on the true model\\n tolls_collected2, so_costs2, costs2, ue_costs2 = [], [], [], []\\n if delaytype == 'Hyperbolic': g1, g2, g3, g4 = los_angeles((3.5, 3.0), 'Hyperbolic')\\n if delaytype == 'Polynomial': g1, g2, g3, g4 = los_angeles(matrix([0.0, 0.0, 0.0, 0.15]), 'Polynomial')\\n for toll, graph in zip(tolls, [g2,g3,g4]):\\n Aeq, beq, ffdelays, pm, type = ue.get_data(graph)\\n data = (Aeq, beq, ffdelays, pm, type)\\n cost, x = tp.compute_cost(data, toll)\\n costs2.append(cost) # tolled equilibrium\\n tolls_collected2.append((toll.T*x)[0])\\n ue_costs2.append(tp.compute_cost(data)[0]) # ue equilibrium\\n so_costs2.append(tp.compute_cost(data, 0.0, True)[0]) # so equilibrium\\n print 'toll collected:', tolls_collected, tolls_collected2\\n print 'SO total travel time:', so_costs, so_costs2\\n print 'tolled total travel time:', costs, costs2\\n print 'UE total travel time:', ue_costs, ue_costs2\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def getTimes():\",\n \"def match(data, template, dt):\\n \\n ii = 0\\n time_slides = []\\n M = []\\n \\n while len(data[ii:]) >= len(template):\\n time_slides.append(ii*dt)\\n \\n #M.append(np.sum((data[ii: len(template) + ii] * template)))\\n M.append(np.sum((data[ii: len(template) + ii] * template) / (1 + ((data[ii:len(template) + ii] - template) ** 2))))\\n ii += 1\\n \\n return(time_slides, M)\",\n \"def observe_differences(seq1, seq2):\\n i, j = 0, 0\\n observations = []\\n while i < len(seq1) and j < len(seq2):\\n if seq1[i] == seq2[j]:\\n observations.append('I')\\n else:\\n observations.append('D')\\n i += 1\\n j += 1\\n\\n # process tails\\n while i < len(seq1):\\n observations.append('D')\\n i += 1\\n while j < len(seq2):\\n observations.append('D')\\n j += 1\\n\\n return observations\",\n \"def set_takeoff_time(input_list):\\n print(\\\"========================Start of set_takeoff_time() Method *\\\")\\n if len(input_list) > 0: # if list is not empty\\n input_list[0].set_actualStart(max(int(input_list[0].get_actualStart()), int(input_list[0].get_reqStart())))\\n\\n for i in range(1, len(input_list)): # from 2nd item onwards\\n wait_period = input_list[i - 1].get_actualStart() + (int(input_list[i - 1].get_reqDuration()))\\n input_list[i].set_actualStart(wait_period)\\n \\n for j in range(len(input_list)):\\n input_list[j].set_actualEnd(\\n (int(input_list[j].get_reqDuration())+int(input_list[j].get_actualStart())))\\n \\n print(\\\"========================finished calc take-off times *\\\")\\n # Testing if we have adjusted actual takeoff start and end times for each flight\\n Airport_Driver.display_contents(input_list)\\n print(\\\"========================End of set_takeoff_time() Method *\\\")\\n return input_list\",\n \"def överlapp(tp1, tp2):\\r\\n\\t# Dålig implementation, bryter mot abstraktionen. -- Fixed\\r\\n\\tdt1 = senaste_klockslag(start_klockslag(tp1), slut_klockslag(tp1))\\r\\n\\tdt2 = tidigaste_klockslag(slut_klockslag(tp2), slut_klockslag(tp2))\\r\\n\\treturn ('tidsperiod', (dt1, dt2)) # \\\"lite\\\" fräschare\\r\",\n \"def part_two():\\n tasks = {}\\n current_time = 0\\n while G.nodes():\\n # noinspection PyCallingNonCallable\\n candidate_next_tasks = [task for task in G.nodes()\\n if task not in tasks.keys() and G.in_degree(task) == 0]\\n if candidate_next_tasks and len(tasks) < 5:\\n next_task = sorted(candidate_next_tasks)[0]\\n tasks[next_task] = ord(next_task) - 4\\n else:\\n min_task_time = min(tasks.values())\\n current_time += min_task_time\\n completed_task = dict(zip(tasks.values(), tasks.keys()))[min_task_time]\\n tasks = {k: v - min_task_time for k, v in tasks.items() if k != completed_task}\\n G.remove_node(completed_task)\\n return current_time\",\n \"def t_test(dataType):\\n\\n\\t# read the data\\n\\tparser = ExperimentUtils()\\n\\tdata = parser.parse_data(dataType)\\n\\n\\tN = len(data.keys()) # number participants\\n\\n\\t# - for trial 1 and trial 2:\\n\\t# \\tL2 norm over each timestep, then sum all the values together\\n\\t# - average over two trials for each participant \\n\\ttask_avgs = {}\\n\\n\\t# participant ID can take values 0 - 9\\n\\tfor ID in data.keys():\\n\\t\\tfor task in data[ID]:\\n\\t\\t\\t# dont include the familiarization task (task can take values 1,2,3)\\n\\t\\t\\tif task != 0:\\n\\t\\t\\t\\tif task not in task_avgs:\\n\\t\\t\\t\\t\\ttask_avgs[task] = {}\\n\\t\\t\\t\\t\\ttask_avgs[task][\\\"A\\\"] = np.array([0.0]*N)\\n\\t\\t\\t\\t\\ttask_avgs[task][\\\"B\\\"] = np.array([0.0]*N)\\n\\n\\t\\t\\t\\ttrialAsum = [0.0,0.0]\\n\\t\\t\\t\\ttrialBsum = [0.0,0.0]\\n\\t\\t\\t\\t# trial can take values 1 or 2\\n\\t\\t\\t\\tfor trial in data[ID][task]:\\n\\t\\t\\t\\t\\t# only compute metrics over data, not timestamps\\n\\t\\t\\t\\t\\tAdata = data[ID][task][trial]['A'][1:8]\\n\\t\\t\\t\\t\\tBdata = data[ID][task][trial]['B'][1:8]\\n\\t\\t\\t\\n\\t\\t\\t\\t\\t#print str(ID)+str(task)+str(trial)+\\\"A\\\"\\n\\t\\t\\t\\t\\t#print \\\"Adata: \\\" + str(Adata)\\n\\t\\t\\t\\t\\t#print str(ID)+str(task)+str(trial)+\\\"B\\\"\\n\\t\\t\\t\\t\\t#print \\\"Bdata: \\\" + str(Bdata)\\n\\n\\t\\t\\t\\t\\t(h, w) = np.shape(Adata)\\n\\t\\t\\t\\t\\tfor i in range(w):\\n\\t\\t\\t\\t\\t\\ttrialAsum[trial-1] += np.linalg.norm(Adata[:,i])\\n\\t\\t\\t\\t\\t(h, w) = np.shape(Bdata)\\n\\t\\t\\t\\t\\tfor i in range(w):\\n\\t\\t\\t\\t\\t\\ttrialBsum[trial-1] += np.linalg.norm(Bdata[:,i])\\n\\t\\t\\t\\tavg_methodA = (trialAsum[0]+trialAsum[1])/2.0\\n\\t\\t\\t\\tavg_methodB = (trialBsum[0]+trialBsum[1])/2.0\\n\\n\\t\\t\\t\\ttask_avgs[task][\\\"A\\\"][ID] = avg_methodA\\n\\t\\t\\t\\ttask_avgs[task][\\\"B\\\"][ID] = avg_methodB\\n\\n\\t# comput independent two-sample t-test \\n\\t# NOTE: we can assume that the two sample sizes are the same, and \\n\\t#\\t\\tthat the two distributions have the same variance\\n\\tfor task in range(1,4):\\n\\t\\ttaskA = task_avgs[task][\\\"A\\\"]\\n\\t\\ttaskB = task_avgs[task][\\\"B\\\"]\\n\\n\\t\\tmeanA = np.mean(taskA)\\n\\t\\tmeanB = np.mean(taskB)\\n\\t\\tprint \\\"meanA: \\\" + str(meanA)\\n\\t\\tprint \\\"meanB: \\\" + str(meanB)\\n\\t\\tdiff = meanA - meanB\\n\\t\\tprint \\\"diff: \\\" + str(diff)\\n\\n\\t\\t(statistic, pvalue) = stats.ttest_ind(a=taskA, b=taskB, equal_var=True)\\n\\n\\t\\tprint \\\"\\\\n\\\"\\n\\t\\tprint \\\"task\\\"+str(task)+\\\" statistic: \\\" + str(statistic)\\n\\t\\tprint \\\"task\\\"+str(task)+\\\" pvalue: \\\" + str(pvalue)\",\n \"def legal_dissonances(a_list, b_list):\\n def interval_is_step(x):\\n return get_semitones(x) <= 2\\n\\n def approached_and_left_by_step(interval):\\n i, t = interval\\n a_note = a_list.get(*t)\\n b_note = b_list.get(*t)\\n\\n if a_note is not None and b_note is not None:\\n # both voices moved at the same time to get into the dissonance.\\n # that means neither is cf, so both must leave by step\\n a_approach = get_interval(a_note, a_note.prev)\\n b_approach = get_interval(b_note, b_note.prev)\\n a_depart = get_interval(a_note, a_note.next)\\n b_depart = get_interval(b_note, b_note.next)\\n\\n movements = [a_approach, b_approach, a_depart, b_depart]\\n else:\\n # one of the notes was already playing, (probably the c.f.)\\n # that note can do whatever it wants.\\n # just make sure c_note was approached and left by step\\n if a_note is not None:\\n c_note = a_note\\n elif b_note is not None:\\n c_note = b_note\\n c_approach = get_interval(c_note, c_note.prev)\\n c_depart = get_interval(c_note, c_note.next)\\n\\n movements = [c_approach, c_depart]\\n\\n return all(map(\\n interval_is_step,\\n movements\\n ))\\n\\n allowed_intervals = ['1', 'b3', '3', '4', '5', 'b6', '6']\\n pairs = vertical_intervals(a_list, b_list)\\n weak_intervals = [(i, t) for i, t in pairs if t[1] == 0.5]\\n weak_dissonances = [(i, t) for i, t in weak_intervals if i[0] not in allowed_intervals]\\n safe_dissonances = [\\n x for x in weak_dissonances\\n if approached_and_left_by_step(x)\\n ]\\n return safe_dissonances\",\n \"def sources_over_frequency(ant1, ant2, list_sources=None,\\n start=76e6, end=227e6, interval=1e6, time=None):\\n if list_sources is None:\\n # make a copy to ensure write safety\\n list_sources = catalog.obj_catalog.copy()\\n if time is None:\\n time = rot.get_lst(radians=True)\\n\\n # If the user has entered a single source directly,\\n # we can automatically standardize the formatting\\n # by placing it by itself in a list\\n if type(list_sources) != list:\\n list_sources = [list_sources]\\n \\n list_visibilities = []\\n lfreq = start\\n while lfreq <= end:\\n next_vista = np.array([0j, 0j, 0j, 0j])\\n for source in list_sources:\\n next_vista += visibility(ant1, ant2, source, nu=lfreq, time=time)\\n\\n list_visibilities.append(np.array([lfreq, next_vista]))\\n lfreq += interval\\n # perhaps not necessary. Better safe than sorry:\\n return np.array(list_visibilities)\",\n \"def test_TimeArray_init_list():\\r\\n for t in [0.001, ts.TimeArray(0.001, time_unit='s')]:\\r\\n tl = [t]\\r\\n ta = ts.TimeArray(t, time_unit='s')\\r\\n tla = ts.TimeArray(tl, time_unit='s')\\r\\n nt.assert_equal(ta, tla)\",\n \"def eeg_twosample_ttest(array1,array2):\\t\\n\\tfrom scipy.stats import ttest_rel\\n\\ts1 = array1.shape\\n\\tp = np.zeros(s1[1])\\n\\tt = np.zeros(s1[1])\\n\\tfor i in range(s1[1]):\\n\\t\\ttval,pval = ttest_rel(array1[:,i],array2[:,i])\\n\\t\\tp[i]=pval\\n\\t\\tt[i]=tval\\n\\t\\t\\n\\treturn t,p\",\n \"def __set_time_elements(*args):\\n args[0].TimeState.delay_elements = args[1]\\n args[0].TimeState.set_delay_elements()\",\n \"def combine(schedules,agent_order_list,highest_timestep):\\r\\n action=[]\\r\\n for timestep in range(highest_timestep-1):\\r\\n current_action = dict()\\r\\n index = 0\\r\\n for agent in agent_order_list:\\r\\n if timestep < len(schedules[index]):\\r\\n current_action[agent] = schedules[index][timestep][agent]\\r\\n else:\\r\\n current_action[agent] = 4\\r\\n index += 1\\r\\n action.append(current_action)\\r\\n return action\",\n \"def make_times(self, start, end, delta):\\n assert type(start) is float or type(start) is int, \\\\\\n 'Start time not specified with float'\\n assert type(end) is float or type(end) is int, \\\\\\n 'End time not specified with a number'\\n assert type(delta) is float or type(delta) is int, \\\\\\n 'Time increment not specified with a number'\\n assert end >= start, 'End time is before start time'\\n self.target_times = []\\n step = start\\n while step <= end:\\n self.target_times.append(step)\\n step += delta\",\n \"def restoreDelayDiff(ants) :\\n failedAnts = []\\n \\n for ant in ants:\\n try:\\n mp = \\\"Control.Antenna%d.rxDelay3mmPol2\\\"%ant \\n delay = queryDouble(mp)\\n # print \\\"Ant %d, 3mm Pol2 = %f\\\"% (ant,delay)\\n s.delayDifference(delay, ant, RX3MM, POL2)\\n\\n mp = \\\"Control.Antenna%d.rxDelay1mmPol1\\\"%ant \\n delay = queryDouble(mp)\\n # print \\\"Ant %d, 1mm Pol1 = %f\\\"% (ant,delay)\\n s.delayDifference(delay, ant, RX1MM, POL1)\\n\\n mp = \\\"Control.Antenna%d.rxDelay1mmPol2\\\"%ant \\n delay = queryDouble(mp)\\n # print \\\"Ant %d, 1mm Pol2 = %f\\\"% (ant,delay)\\n s.delayDifference(delay, ant, RX1MM, POL2)\\n\\n mp = \\\"Control.Antenna%d.rxDelay1cmPol1\\\"%ant \\n delay = queryDouble(mp)\\n # print \\\"Ant %d, 1cm Pol1 = %f\\\"% (ant,delay)\\n s.delayDifference(delay, ant, RX1CM, POL1)\\n\\n mp = \\\"Control.Antenna%d.rxDelay1cmPol2\\\"%ant \\n delay = queryDouble(mp)\\n # print \\\"Ant %d, 1cm Pol2 = %f\\\"% (ant,delay)\\n s.delayDifference(delay, ant, RX1CM, POL2)\\n except carma.util.UserException, ue:\\n printError( ue.errorMsg )\\n failedAnts.append( ant )\\n except:\\n errmsg = \\\"Unable to restore delay differences on ant# %d \\\"%(ant)\\n printError( errmsg )\\n failedAnts.append( ant )\\n\\n for failed in failedAnts:\\n ants.remove( failed )\",\n \"def example3():\\n arrive_time=example2() # Get packets arrive time using example1\\n time_series.plot_time_series(arrive_time) # Plot time series using packets arrive time\",\n \"def get_steps_by_times(times,chosen_times):\\n\\n time_steps = []\\n chosen_index = 0\\n for i in range(len(times)):\\n if times[i] >= chosen_times[chosen_index]:\\n time_steps.append(i)\\n chosen_index += 1\\n if chosen_index == len(chosen_times): #We're done\\n return time_steps\\n if chosen_index != len(chosen_times): #In case the last chosen time(s) is past the end of times. \\n time_steps.append(i)\\n return time_steps\",\n \"def processPhaseHeight(self, phasesInRing1, phasesInRing2):\\n P11, P12, P21, P22 = ([] for i in range(4))\\n phaseHeightDictionary = {}\\n\\n [P11.append(index+1)for index, value in enumerate(self.phaseDurationList)\\n if value > 0.0 and index < 2]\\n [P12.append(index+1)for index, value in enumerate(self.phaseDurationList)\\n if value > 0.0 and index >= 2 and index < 4]\\n [P21.append(index+1)for index, value in enumerate(self.phaseDurationList)\\n if value > 0.0 and index >= 4 and index < 6]\\n [P22.append(index+1)for index, value in enumerate(self.phaseDurationList)\\n if value > 0.0 and index >= 6 and index < 8]\\n\\n if (len(P11) == len(P21)):\\n for index in range(len(P11)):\\n if len(P11) > 0:\\n phaseHeightDictionary[str(P11[index])] = 10\\n\\n for index in range(len(P21)):\\n if len(P21) > 0:\\n phaseHeightDictionary[str(P21[index])] = 10\\n\\n elif (len(P11) < len(P21)):\\n for index in range(len(P11)):\\n if len(P11) > 0:\\n phaseHeightDictionary[str(P11[index])] = 20\\n\\n for index in range(len(P21)):\\n if len(P21) > 0:\\n phaseHeightDictionary[str(P21[index])] = 10\\n\\n elif (len(P11) > len(P21)):\\n for index in range(len(P11)):\\n if len(P11) > 0:\\n phaseHeightDictionary[str(P11[index])] = 10\\n\\n for index in range(len(P21)):\\n if len(P21) > 0:\\n phaseHeightDictionary[str(P21[index])] = 20\\n\\n if (len(P12) == len(P22)):\\n for index in range(len(P12)):\\n if len(P12) > 0:\\n phaseHeightDictionary[str(P12[index])] = 10\\n\\n for index in range(len(P22)):\\n if len(P22) > 0:\\n phaseHeightDictionary[str(P22[index])] = 10\\n\\n elif (len(P12) < len(P22)):\\n for index in range(len(P12)):\\n if len(P12) > 0:\\n phaseHeightDictionary[str(P12[index])] = 20\\n for index in range(len(P22)):\\n if len(P22) > 0:\\n phaseHeightDictionary[str(P22[index])] = 10\\n\\n elif (len(P12) > len(P22)):\\n for index in range(len(P12)):\\n if len(P12) > 0:\\n phaseHeightDictionary[str(P12[index])] = 10\\n for index in range(len(P22)):\\n if len(P22) > 0:\\n phaseHeightDictionary[str(P22[index])] = 20\\n\\n for phase in phasesInRing1:\\n for key, value in phaseHeightDictionary.items():\\n if int(key) == phase:\\n self.phaseHeightInRing1.append(value)\\n\\n for phase in phasesInRing2:\\n for key, value in phaseHeightDictionary.items():\\n if int(key) == phase:\\n self.phaseHeightInRing2.append(value)\",\n \"def _travel_times(self, trip_list, index=0):\\n\\n def distance_in_travel_time(dep_secs, arr_secs):\\n t_dist = arr_secs - dep_secs\\n if t_dist < 0:\\n t_dist = self._DUMMY_SEPARATOR # min separation\\n return t_dist\\n\\n if not trip_list:\\n return []\\n\\n if 0 < index < len(trip_list):\\n trip = trip_list[index]\\n else:\\n trip = trip_list[0]\\n\\n t_dists2 = [distance_in_travel_time(stop[3], tail[2]) for (stop, tail)\\n in zip(trip.get_time_stops(), trip.get_time_stops()[1:])]\\n return t_dists2\",\n \"def inBoth(from_files):\\n t_nof1 = []\\n f_nof1 = []\\n array_of_times = []\\n for file in from_files:\\n item = file.replace('_COMPLETE', '')\\n if item in to_files:\\n to = os.path.join('/ToNof1/archive', item)\\n from_nof1 = os.path.join('/FromNof1', file)\\n t_nof1.append(to)\\n f_nof1.append(from_nof1)\\n\\n\\n\\n with open(\\\"TAT_From_Nof1.tsv\\\", 'w') as f:\\n i = 0\\n myHeader = \\\"Completed File\\\\tCompleted Time\\\\tSent File\\\\tSent Time\\\\tDelta\\\\n\\\"\\n f.write(myHeader)\\n while i < len(to_files):\\n today = datetime.today()\\n\\n fName = os.path.basename(f_nof1[i])\\n tName = os.path.basename(t_nof1[i])\\n\\n fTime = getDate(f_nof1[i])\\n tTime = getDate(t_nof1[i])\\n\\n duration = (today - fTime)\\n if duration.days < 90:\\n delta = fTime - tTime\\n seconds = (delta.total_seconds())\\n minutes = seconds / 60.0\\n hours = minutes / 60.0\\n array_of_times.append(hours)\\n delta = str(delta)\\n fTime = str(fTime)\\n tTime = str(tTime)\\n myString = (fName + \\\"\\\\t\\\" + fTime + \\\"\\\\t\\\" + tName + \\\"\\\\t\\\" + tTime + \\\"\\\\t\\\" + delta + \\\"\\\\n\\\")\\n f.write(myString)\",\n \"def rxn_to_constraints_samples_v2(player_list, action_list, samps):\\n allele_rxns_constraint_dict = {}\\n for all_player in player_list:\\n allele_rxns_constraint_dict[all_player] = {}\\n for react in all_player.cobra_reactions.keys():\\n allele_rxns_constraint_dict[all_player][react] = {}\\n max_flux, min_flux = max(samps[react]), min(samps[react])\\n mean_flux = np.mean(samps[react])\\n \\n action_to_constraints_dict = {}\\n # for reactions that can't have any change, keep their bounds at a single value.\\n if max_flux == min_flux: \\n for a in action_list:\\n action_to_constraints_dict.update({a: max_flux})\\n else:\\n left_bound_distance = mean_flux - min_flux\\n\\n gradient_steps = int(len(action_list)/2)\\n # min_to_mean_grad = np.arange(min_flux, mean_flux, (mean_flux-min_flux)/gradient_steps)\\n # max_to_mean_grad = np.arange(mean_flux, max_flux, (max_flux-mean_flux)/gradient_steps)\\n min_to_mean_grad = np.arange(min_flux, mean_flux, (mean_flux-min_flux)/(gradient_steps+1))[-gradient_steps:]\\n max_to_mean_grad = np.arange(mean_flux, max_flux, (max_flux-mean_flux)/(gradient_steps+1))[-gradient_steps:]\\n\\n for a in action_list:\\n if a == \\\"no_change\\\":\\n action_to_constraints_dict.update({a: 0})\\n else:\\n dec_or_inc = a.split(\\\"_\\\")[0]\\n grad_dist = int(a.split(\\\"_\\\")[1])\\n\\n # It doesn't matter if mean_flux is less than or greater than 0.\\n\\n if dec_or_inc == \\\"lb\\\": # Change upper_bound\\n action_to_constraints_dict.update({a: min_to_mean_grad[grad_dist]})\\n elif dec_or_inc == \\\"ub\\\": # Change lower_bound\\n action_to_constraints_dict.update({a: max_to_mean_grad[grad_dist]})\\n allele_rxns_constraint_dict[all_player][react].update(action_to_constraints_dict)\\n \\n return allele_rxns_constraint_dict\",\n \"def simulationTwoDrugsDelayedTreatment(numTrials):\\n #Initialization\\n delayList = [300, 150, 75, 0]\\n #delayList = [150]\\n #Patient init variables\\n numViruses = 100\\n maxPop = 1000\\n #Virus init variables\\n maxBirthProb = 0.1\\n clearProb = 0.05\\n #clearProb = 0.10\\n resistances = { 'guttagonol': False, 'grimpex' : False }\\n #mutProb = 0.005\\n mutProb = 0.010\\n \\n results = {}\\n \\n for n in delayList:\\n cured = 0\\n popList = []\\n print \\\"Running trials for delay %(delay)d\\\" % {'delay' : n}\\n for i in range(numTrials):\\n #print \\\"Trial: \\\" + str(i)\\n pop = runTrialTwoDrugs(n, numViruses, maxPop, maxBirthProb, clearProb, resistances, mutProb)\\n popList.append(pop)\\n if pop < 50:\\n cured +=1\\n results[n] = popList\\n #print popList\\n print \\\"Delay : %(delay)d Percentage cured %(percent)2f\\\" % {\\\"delay\\\" : n, \\\"percent\\\" : cured/float(numTrials) }\\n \\n\\n drawHist(results, numTrials)\",\n \"def condense_meeting_times_2(arr):\\n\\n # sort the meeting times by start time (this will be O(lg(n)), at least)\\n # without sorting by start times, the random order will make this O(n^2)\\n arr.sort()\\n\\n # make a list to store output\\n output = [arr[0]]\\n\\n # iterate over all the time blocks and check for merges\\n for time_block in arr[1:]:\\n # get the times to compare against from the latest block in output\\n first_start, first_stop = output[-1]\\n # unpack the current time block being assessed for overlap\\n second_start, second_stop = time_block\\n # if the current time block overlaps with most recent, condense the two\\n # by updating the entire tuple in the output list with latest time\\n if second_start <= first_stop:\\n output[-1] = (first_start, max(first_stop, second_stop))\\n # else, there was no overlap. Add current to output and continue loop\\n else:\\n output.append((second_start, second_stop))\\n\\n return output\",\n \"def pairwise(spiketrains, start, end, nsamples):\\n # remove empty spike trains\\n spiketrains = [sp for sp in spiketrains if len(sp)]\\n d = np.zeros((nsamples,))\\n n_trains = len(spiketrains)\\n t = 0\\n for i, t1 in enumerate(spiketrains[:-1]):\\n for t2 in spiketrains[i+1:]:\\n tij, dij = distance(t1, t2, start, end, nsamples)\\n if(i == 0):\\n t = tij # The times are only dependent on ti, te, and N\\n d = d + dij\\n d = d / float(n_trains * (n_trains-1) /2)\\n return t,d\",\n \"def associate_trajectories(traj_1, traj_2,\\n max_diff=0.01, offset_2=0.0,\\n first_name=\\\"first trajectory\\\", snd_name=\\\"second trajectory\\\"):\\n if not isinstance(traj_1, PoseTrajectory3D) \\\\\\n or not isinstance(traj_2, PoseTrajectory3D):\\n raise SyncException(\\\"trajectories must be PoseTrajectory3D objects\\\")\\n\\n snd_longer = len(traj_2.timestamps) > len(traj_1.timestamps)\\n traj_long = copy.deepcopy(traj_2) if snd_longer else copy.deepcopy(traj_1)\\n traj_short = copy.deepcopy(traj_1) if snd_longer else copy.deepcopy(traj_2)\\n max_pairs = len(traj_long.timestamps)\\n\\n # First, match the timestamps of the shorter trajectory to the longer one.\\n matching_indices = matching_time_indices(\\n traj_short.timestamps, traj_long.timestamps,\\n max_diff, offset_2 if snd_longer else -offset_2)\\n traj_long.reduce_to_ids(matching_indices)\\n\\n # Next, reversely match the reduced long trajectory to the shorter one.\\n matching_indices = matching_time_indices(\\n traj_long.timestamps, traj_short.timestamps,\\n max_diff, -offset_2 if snd_longer else offset_2)\\n traj_short.reduce_to_ids(matching_indices)\\n\\n traj_1 = traj_short if snd_longer else traj_long\\n traj_2 = traj_long if snd_longer else traj_short\\n\\n if len(matching_indices) == 0:\\n raise SyncException(\\n \\\"found no matching timestamps between {} and {} with max. time \\\"\\n \\\"diff {} (s) and time offset {} (s)\\\".format(\\n first_name, snd_name, max_diff, offset_2))\\n\\n logger.debug(\\n \\\"Found {} of max. {} possible matching timestamps between...\\\\n\\\"\\n \\\"\\\\t{}\\\\nand:\\\\t{}\\\\n..with max. time diff.: {} (s) \\\"\\n \\\"and time offset: {} (s).\\\".format(\\n len(matching_indices), max_pairs, first_name,\\n snd_name, max_diff, offset_2))\\n\\n return traj_1, traj_2\",\n \"def prepare_lists(dist1, dist2):\\n\\tx_dist = []\\n\\ty_dist = []\\n\\tfor i, freq in dist1.items():\\n\\t\\tif i not in dist2:\\n\\t\\t\\tcontinue\\n\\t\\tx_dist.append(freq)\\n\\t\\ty_dist.append(dist2[i])\\n\\tx_dist=np.array(x_dist)\\n\\ty_dist=np.array(y_dist)\\n\\treturn x_dist, y_dist\",\n \"def terning2(antal_kast): #Definere en funktion der tager 1 argument\\n import random # importere random pakken til at generere tal\\n values = []\\n for i in range(antal_kast): #kører et loop de antal gange specificeret i argumentet\\n x = random.random()# generere et tal mellem 0 og 1 (er inde i parrentesen for at hver kast bliver forskelligt)\\n if x < 1/6:\\n values.append(1)\\n elif x < 2/6:\\n values.append(2)\\n elif x < 3/6:\\n values.append(3)\\n elif x < 4/6:\\n values.append(4)\\n elif x < 5/6:\\n values.append(5)\\n else:\\n values.append(6)\\n return(values)\",\n \"def __init__(self, anneal_start, anneal_time, beta_start):\\n self.anneal_start = anneal_start\\n self.anneal_time = anneal_time\\n self.beta = beta_start\",\n \"def kendall_tau_brute_force(ranking1, ranking2):\\n distance = 0\\n\\n for i, j in itertools.combinations(range(len(ranking1)), 2):\\n a = ranking1[i] - ranking1[j]\\n b = ranking2[i] - ranking2[j]\\n\\n # If discordant (different signs)\\n if a * b < 0:\\n distance += 1\\n\\n return distance\",\n \"def test(output_seq,M1,M2,M3,obs_file):\\n predicted = []\\n mus_c = 0\\n mod_c = 0\\n arn_c = 0\\n next = 0\\n t = 0.000\\n d=dict()\\n d[\\\"other\\\"]=0\\n d[\\\"modi\\\"]=0\\n d[\\\"arnab\\\"]=0\\n print(obs_file+\\\":\\\")\\n for obs in output_seq:\\n p1 = M1.forward(obs)\\n p2 = M2.forward(obs)\\n p3 = M3.forward(obs)\\n\\n\\n if(p1 > p2 and p1 > p3):\\n predicted.append(\\\"Other\\\")\\n mus_c+=1\\n d[\\\"other\\\"]+=1\\n elif(p2 > p3 and p2 > p1):\\n predicted.append(\\\"Modi\\\")\\n mod_c+=1\\n d[\\\"modi\\\"]+=1\\n else:\\n predicted.append(\\\"Arnab\\\")\\n arn_c+=1\\n d[\\\"arnab\\\"]+=1\\n t+=0.05\\n next+=1\\n\\n if(next % 20 == 0):\\n p_other = d[\\\"other\\\"]/20.0\\n p_modi = d[\\\"modi\\\"]/20.0\\n p_arnab = d[\\\"arnab\\\"]/20.0\\n #print(\\\"{0} : Modi = {1}, Arnab = {2}, Other = {3}\\\".format(t,p_modi,p_arnab,p_other))\\n if p_other>p_modi and p_other>p_arnab:\\n print \\\"{0} : Speech : Other\\\".format(t)\\n elif p_modi>p_other and p_modi>p_arnab:\\n print \\\"{0} : Speech : Modi\\\".format(t)\\n else:\\n print \\\"{0} : Speech : Arnab\\\".format(t)\\n d[\\\"other\\\"]=0\\n d[\\\"modi\\\"]=0\\n d[\\\"arnab\\\"]=0\\n\\n time = 0.000\\n with open(\\\"op_\\\"+obs_file,\\\"w\\\") as g:\\n for val in predicted:\\n g.write(str(time)+\\\" :\\\\t\\\"+val+\\\"\\\\n\\\")\\n time+=0.005\\n\\n return predicted\",\n \"def multiple_simulated_annealing(scores):\\n\\n\\tplt.plot(range(0, len(scores[0])), scores[0], label = \\\"geman\\\")\\n\\tplt.plot(range(0, len(scores[1])), scores[1], label = \\\"linear\\\")\\n\\tplt.plot(range(0, len(scores[2])), scores[2], label = \\\"sigmoidal\\\")\\n\\tplt.plot(range(0, len(scores[3])), scores[3], label = \\\"exponential\\\")\\n\\tplt.ylabel(\\\"Score\\\")\\n\\tplt.xlabel(\\\"Runs\\\")\\n\\tplt.title(\\\"Simulated annealing\\\")\\n\\tplt.legend()\\n\\tplt.show()\",\n \"def et(obs_time, *whatevers):\\n obs_time = np.asarray(obs_time)\\n n_time = obs_time.size\\n n_obs = np.amax([w.size for w in whatevers])\\n if n_obs > n_time:\\n delta_t = obs_time[-1] - obs_time[-2]\\n shortfall = n_obs-n_time\\n obs_time = np.concatenate((\\n obs_time,\\n np.linspace(\\n obs_time[-1] + delta_t,\\n obs_time[-1] + delta_t * shortfall,\\n shortfall,\\n endpoint=True\\n ),\\n ))\\n\\n return tuple((obs_time,) + whatevers)\",\n \"def ps_arrival_times(distance, depth, init_sec):\\n\\n # use taup to get the theoretical arrival times for P & S\\n TauPy_model = TauPyModel('iasp91')\\n tt = TauPy_model.get_travel_times(\\n distance_in_degree=0.001 * distance / 111.11, source_depth_in_km=depth)\\n tiemp = []\\n tiems = []\\n # from all possible P arrivals select the earliest one\\n for i2 in xrange(0, len(tt)):\\n if tt.__getitem__(i2).__dict__['name'] == 'P' or \\\\\\n tt.__getitem__(i2).__dict__['name'] == 'p' or \\\\\\n tt.__getitem__(i2).__dict__['name'] == 'Pdiff' or \\\\\\n tt.__getitem__(i2).__dict__['name'] == 'PKiKP' or\\\\\\n tt.__getitem__(i2).__dict__['name'] == 'PKIKP' or \\\\\\n tt.__getitem__(i2).__dict__['name'] == 'PP' or \\\\\\n tt.__getitem__(i2).__dict__['name'] == 'Pb' or \\\\\\n tt.__getitem__(i2).__dict__['name'] == 'Pn' or \\\\\\n tt.__getitem__(i2).__dict__['name'] == 'Pg':\\n tiem_p = tt.__getitem__(i2).__dict__['time']\\n tiemp.append(tiem_p)\\n arriv_p = np.floor(init_sec + min(tiemp))\\n\\n # from all possible S arrivals select the earliest one\\n for i3 in xrange(0, len(tt)):\\n if tt.__getitem__(i3).__dict__['name'] == 'S' or \\\\\\n tt.__getitem__(i3).__dict__['name'] == 's' or \\\\\\n tt.__getitem__(i3).__dict__['name'] == 'Sdiff' or \\\\\\n tt.__getitem__(i3).__dict__['name'] == 'SKiKS' or \\\\\\n tt.__getitem__(i3).__dict__['name'] == 'SKIKS' or \\\\\\n tt.__getitem__(i3).__dict__['name'] == 'SS' or \\\\\\n tt.__getitem__(i3).__dict__['name'] == 'Sb' or \\\\\\n tt.__getitem__(i3).__dict__['name'] == 'Sn' or \\\\\\n tt.__getitem__(i3).__dict__['name'] == 'Sg':\\n tiem_s = tt.__getitem__(i3).__dict__['time']\\n tiems.append(tiem_s)\\n arriv_s = np.floor(init_sec + min(tiems))\\n return arriv_p, arriv_s\",\n \"def test_mc_t_two_sample(self):\\r\\n # Verified against R's t.test() and Deducer::perm.t.test().\\r\\n\\r\\n # With numpy array as input.\\r\\n exp = (-0.11858541225631833, 0.90756579317867436)\\r\\n I = array([7.2, 7.1, 9.1, 7.2, 7.3, 7.2, 7.5])\\r\\n II = array([8.8, 7.5, 7.7, 7.6, 7.4, 6.7, 7.2])\\r\\n obs = mc_t_two_sample(I, II)\\r\\n self.assertFloatEqual(obs[:2], exp)\\r\\n self.assertEqual(len(obs[2]), 999)\\r\\n self.assertCorrectPValue(0.8, 0.9, mc_t_two_sample, [I, II],\\r\\n p_val_idx=3)\\r\\n\\r\\n # With python list as input.\\r\\n exp = (-0.11858541225631833, 0.90756579317867436)\\r\\n I = [7.2, 7.1, 9.1, 7.2, 7.3, 7.2, 7.5]\\r\\n II = [8.8, 7.5, 7.7, 7.6, 7.4, 6.7, 7.2]\\r\\n obs = mc_t_two_sample(I, II)\\r\\n self.assertFloatEqual(obs[:2], exp)\\r\\n self.assertEqual(len(obs[2]), 999)\\r\\n self.assertCorrectPValue(0.8, 0.9, mc_t_two_sample, [I, II],\\r\\n p_val_idx=3)\\r\\n\\r\\n exp = (-0.11858541225631833, 0.45378289658933718)\\r\\n obs = mc_t_two_sample(I, II, tails='low')\\r\\n self.assertFloatEqual(obs[:2], exp)\\r\\n self.assertEqual(len(obs[2]), 999)\\r\\n self.assertCorrectPValue(0.4, 0.47, mc_t_two_sample, [I, II],\\r\\n {'tails': 'low'}, p_val_idx=3)\\r\\n\\r\\n exp = (-0.11858541225631833, 0.54621710341066287)\\r\\n obs = mc_t_two_sample(I, II, tails='high', permutations=99)\\r\\n self.assertFloatEqual(obs[:2], exp)\\r\\n self.assertEqual(len(obs[2]), 99)\\r\\n self.assertCorrectPValue(0.4, 0.62, mc_t_two_sample, [I, II],\\r\\n {'tails': 'high', 'permutations': 99}, p_val_idx=3)\\r\\n\\r\\n exp = (-2.8855783649036986, 0.99315596652421401)\\r\\n obs = mc_t_two_sample(I, II, tails='high', permutations=99, exp_diff=1)\\r\\n self.assertFloatEqual(obs[:2], exp)\\r\\n self.assertEqual(len(obs[2]), 99)\\r\\n self.assertCorrectPValue(0.55, 0.99, mc_t_two_sample, [I, II],\\r\\n {'tails': 'high', 'permutations': 99, 'exp_diff': 1}, p_val_idx=3)\",\n \"def t_paired(a, b, tails=None, exp_diff=0):\\r\\n n = len(a)\\r\\n if n != len(b):\\r\\n raise ValueError('Unequal length lists in ttest_paired.')\\r\\n try:\\r\\n diffs = array(a) - array(b)\\r\\n return t_one_sample(diffs, popmean=exp_diff, tails=tails)\\r\\n except (ZeroDivisionError, ValueError, AttributeError, TypeError,\\r\\n FloatingPointError):\\r\\n return (nan, nan)\",\n \"def adjustableDelay(delay, ants) :\\n antlist = helpers.makeList(ants)\\n s.adjustableDelay(delay, antlist)\",\n \"def _probseg_fast2bids(inlist):\\n return (inlist[1], inlist[2], inlist[0])\",\n \"def gen_trains(interval_lengths, rates, num_trials, num_repetitions):\\n return [[gen_single_trial(interval_lengths, rates)\\n for j in xrange(num_trials)] for i in xrange(num_repetitions)]\",\n \"def form_agents(n, r, a, b, agents):\\n for a_ind, b_ind in izip(a, b):\\n #util_fn = random.choice([util.Linear, util.CES, util.CobbDouglas])\\n #util_fn = util_fn.rand(p, n)\\n #util_fn = util.Linear.rand(n, r, a_ind)\\n\\n agent = Agent.rand(util.Linear, n, r, a_ind, b_ind)\\n agents.add(agent)\",\n \"def test_of_agreement(self): \\n \\n pop_t = world.pop_t \\n pop_sub = world.pop_sub \\n \\n \\n Ns = world.subtime.length\\n \\n dt = world.time.step\\n ds = world.subtime.step\\n N = round(ds/dt)\\n for i in range(Ns):\\n numpy.testing.assert_allclose(pop_sub[:,i],pop_t[i*N,:])\",\n \"def UTC_times(times, \\n trace, \\n diff_thres = 30.0):\\n # set times values to seconds\\n \\n #AUTOMATE THIS SECTION!\\n #CHECK THAT THIS IS CORRECT\\n times = times / trace.stats.sampling_rate\\n #remove unwanted parts of times numpy array \\n times = times[:,0]\\n \\n #remove the first instance of time because it is \\n #somehow always of the wrong format!\\n #times = np.delete(times, 0) \\n \\n event_times = []\\n event = [times[0]]\\n \\n start_time = trace.stats.starttime\\n \\n #for item in times:\\n # print start_time + item\\n\\n for i in range(1, len(times)):\\n \\n # check if two events in times array have a difference < diff_thres, \\n #if not, run average of those times, if so append that events to a \\n #new events_times list\\n \\n #time_diff = times[i + 1] - times[i]\\n \\n time_diff = times[i] - times[i-1]\\n\\n #save info until events are far enough apart! \\n if time_diff < diff_thres:\\n\\n event.append(times[i])\\n \\n \\n #raise conditional for if events are far enough apart! \\n else:\\n\\n event_start = event[0] - 2 #minus 5 seconds\\n event_end = max(event) + 2 #add 5 seconds\\n\\n event_times.append([event_start, event_end])\\n \\n event = [] \\n \\n event.append(times[i])\\n\\n #if event still contains something for any reason, add it to event times\\n if len(event) > 0: \\n event_start = event[0] - 2 #minus 5 seconds\\n event_end = max(event) + 2 #add 5 seconds\\n event_times.append([event_start, event_end])\\n event = [] \\n \\n\\n\\n #if len(event_times) == 0 and len(event) > 0 or time_diff > diff_thres and len(event) > 0:\\n \\n #event_times.append(sum(event) / len(event))\\n \\n # event_start = event[0] - 2 #minus 5 seconds\\n # event_end = event[-1] + 2 #add 5 seconds\\n \\n # event_times.append([event_start, event_end])\\n \\n # event = []\\n \\n #event_times.append(times[i])\\n \\n # else:\\n # event.append(times[i])\\n \\n\\n UTC_events = []\\n\\n #earthquake length threshold is 10 seconds and above!\\n eq_len = 0#5.0\\n\\n for i in event_times:\\n estart = start_time + i[0]\\n eend = start_time + i[1]\\n \\n if eend - estart > eq_len:\\n UTC_events.append([estart, eend])\\n \\n #UTC_events = np.unique(np.asarray(UTC_events))\\n\\n \\n return UTC_events\",\n \"def simulationTwoDrugsDelayedTreatment(numTrials):\\n \\n numViruses = 100\\n maxPop = 1000\\n maxBirthProb = 0.1\\n clearProb = 0.05\\n resistances = {'guttagonol': False, 'grimpex': False}\\n mutProb = 0.005\\n delays = [300, 150, 75, 0]\\n f, axarr = pylab.subplots(2, 2)\\n x_plot = []\\n\\n for delay in delays:\\n FinalPopSize = [0.0 for x in range(numTrials)]\\n for trial in range(numTrials):\\n viruses = [ResistantVirus(maxBirthProb, clearProb, resistances, mutProb) for n in range(numViruses)]\\n patient = TreatedPatient(viruses, maxPop)\\n for i in range(150):\\n patient.update()\\n patient.addPrescription('guttagonol')\\n for j in range(150, 150+delay):\\n patient.update()\\n patient.addPrescription('grimpex')\\n for k in range(150+delay, 300+delay):\\n patient.update()\\n FinalPopSize[trial] = patient.getTotalPop()\\n x_plot.append(FinalPopSize)\\n\\n axarr[0, 0].hist(x_plot[0])\\n axarr[0, 1].hist(x_plot[1])\\n axarr[1, 0].hist(x_plot[2])\\n axarr[1, 1].hist(x_plot[3])\\n pylab.show()\\n return x_plot\",\n \"def __call__(self,time):\\n \\n fname = []\\n tind =[]\\n for t in time:\\n flag=1\\n for f in self.timelookup.keys():\\n\\n if t >= self.timelookup[f][0] and t<=self.timelookup[f][-1]:\\n# print 'Found tstep %s'%datetime.strptime(t,'%Y-%m-%d %H:%M:%S')\\n tind.append(othertime.findNearest(t,self.timelookup[f][:]))\\n fname.append(f)\\n flag=0\\n\\n# if flag:\\n# print 'Warning - could not find matching file for time:%s'%datetime.strptime(t,'%Y-%m-%d %H:%M:%S')\\n# tind.append(-1)\\n# fname.append(-1)\\n \\n return tind, fname\",\n \"def test_returns_concurrent_meeting_time(self):\\n result = meeting_planner([[10, 50], [60, 120], [140, 210]], [[0, 15], [60, 70]], 8)\\n self.assertEqual(result, [60, 68])\",\n \"def task_2():\\n\\n # To store the list of speeds to plot\\n list_of_speeds = []\\n list_of_times = []\\n list_of_time_difference = [0]\\n\\n # To go from 1 through 80\\n for i in range(LOW_SPEED, HIGH_SPEED + 1, 5):\\n list_of_speeds.append(i)\\n list_of_times.append(((DISTANCE / i) * 60))\\n\\n for i in range(1, len(list_of_times)):\\n list_of_time_difference.append(list_of_times[i-1] - list_of_times[i])\\n\\n plt.plot(list_of_speeds, list_of_time_difference)\\n plt.xlabel(\\\"Speed (in mph)\\\")\\n plt.ylabel(\\\"Time saved (in minutes)\\\")\\n plt.show()\",\n \"def smart_T1_delays(T1_int=90e3, QPT1=1.5e6, half_decay_point=1e6, eff_T1_delay=800.0, probe_point=0.5, meas_per_QPinj=30, meas_per_reptime=5):\\r\\n# rep_time = 1.0e9/fg.get_frequency()\\r\\n# T1_QPref = 1/(np.log(2)/eff_T1_delay-1/T1_int) # T1 at half decay point = effective readout delay/ln(2), excluding intrinsic part giving the T1 due to quasiparticles\\r\\n# n_delayless = int(half_decay_point/rep_time) # Number of points with T1_delay = 0\\r\\n#\\r\\n## QP_times_s = np.linspace(rep_time, half_decay_point, n_delayless)\\r\\n# T1_delays_s = np.linspace(0, 0, n_delayless)\\r\\n# QP_times_l = np.linspace(half_decay_point+rep_time, meas_per_QPinj*rep_time, meas_per_QPinj-n_delayless)\\r\\n# T1_delays_l = np.log(2)/(1/T1_int+1/T1_QPref*np.exp(-(QP_times_l-half_decay_point)/QPT1))-eff_T1_delay\\r\\n## QP_times = np.concatenate((QP_times_s, QP_times_l))\\r\\n# T1_delays = np.concatenate((T1_delays_s, T1_delays_l))\\r\\n\\r\\n rep_time = 1.0e9/fg.get_frequency()\\r\\n n_points = meas_per_QPinj * meas_per_reptime\\r\\n step_time = rep_time / meas_per_reptime\\r\\n T1_QPref = 1/(np.log(2)/eff_T1_delay-1/T1_int) # T1 at half decay point = effective readout delay/ln(2), excluding intrinsic part giving the T1 due to quasiparticles\\r\\n\\r\\n QP_times = np.linspace(0, (n_points-1)*step_time, n_points)\\r\\n T1_est = 1/(1/T1_int+1/T1_QPref*np.exp(-(QP_times-half_decay_point)/QPT1))\\r\\n T1_delays = -np.log(probe_point)*T1_est-eff_T1_delay\\r\\n for j, delay in enumerate(T1_delays):\\r\\n if delay < 0:\\r\\n T1_delays[j]=0.0\\r\\n return T1_delays\",\n \"def predict_event2(rule,event):\\n if event[0]==rule[1][1][0]:\\n min_t=event[1]+rule[1][0][0]\\n max_t=event[1]+rule[1][0][1]\\n next_event=rule[1][1][1]\\n else:\\n min_t=event[1]-rule[1][0][1]\\n max_t=event[1]-rule[1][0][0] \\n next_event=rule[1][1][0] \\n return [next_event,[min_t,max_t],rule[2],rule]\",\n \"def make_feedback(self,shift_register, feedback_taps):\\n feedback_list = []\\n for tap in feedback_taps:\\n feedback_list.append(shift_register[tap])\\n return sum(feedback_list) % 2\",\n \"def run():\\n trials = 100\\n\\n multipliers = [0.25, 0.3, 0.35, 0.5, 0.75, 1, 1.25, 1.45, 1.5, 1.55, 1.6] # Coefficients for learning rate\\n\\n mean_penalty = []\\n median_penalty = []\\n std_penalty = []\\n\\n mean_trial_time = []\\n median_trial_time = []\\n std_trial_time = []\\n\\n mean_success_rate = []\\n median_success_rate = []\\n std_success_rate = []\\n\\n for m in multipliers:\\n all_penalties = [] # All penalties from trail sets\\n all_average_trial_time = []\\n all_success_rates = []\\n\\n for i in range(0, 20):\\n # print \\\"Trial set:\\\", i\\n # Set up environment and agent\\n e = Environment() # create environment (also adds some dummy traffic)\\n agent = e.create_agent(LearnerAgent) # create agent\\n agent.mult = m\\n e.set_primary_agent(agent, enforce_deadline=True) # specify agent to track\\n\\n # Now simulate it\\n sim = Simulator(e, update_delay=0.0, display=False) # create simulator (uses pygame when display=True, if available)\\n\\n sim.run(n_trials=trials) # run for a specified number of trials\\n\\n all_penalties.append(agent.all_trails_penalties)\\n all_average_trial_time.append(agent.time/float(trials))\\n all_success_rates.append(float(trials-agent.aborted_trials)/trials)\\n\\n mean_penalty.append(np.mean(all_penalties))\\n median_penalty.append(np.median(all_penalties))\\n std_penalty.append(np.std(all_penalties))\\n\\n mean_trial_time.append(np.mean(all_average_trial_time))\\n median_trial_time.append(np.median(all_average_trial_time))\\n std_trial_time.append(np.std(all_average_trial_time))\\n\\n mean_success_rate.append(np.mean(all_success_rates))\\n median_success_rate.append(np.median(all_success_rates))\\n std_success_rate.append(np.std(all_success_rates))\\n\\n for i in range(0, len(multipliers)):\\n print \\\"\\\"\\n print \\\"Multiplier:\\\", multipliers[i]\\n print \\\"\\\"\\n print \\\"Mean penalty per {} trials:\\\".format(trials), mean_penalty[i]\\n print \\\"Median penalty per {} trials:\\\".format(trials), median_penalty[i]\\n print \\\"Std.Dev. penalty per {} trials:\\\".format(trials), std_penalty[i]\\n\\n print \\\"\\\"\\n print \\\"Mean trial time:\\\", mean_trial_time[i]\\n print \\\"Median trial time:\\\", median_trial_time[i]\\n print \\\"Std.Dev. trial time:\\\", std_trial_time[i]\\n\\n print \\\"\\\"\\n print \\\"Mean success rate per {} trials:\\\".format(trials), mean_success_rate[i]\\n print \\\"Median success rate per {} trials:\\\".format(trials), median_success_rate[i]\\n print \\\"Std.Dev. success rate per {} trials:\\\".format(trials), std_success_rate[i]\",\n \"def ablation_times(self):\\n ats = {}\\n for n in np.arange(self.n) + 1:\\n t = self.Time[self.ns == n]\\n ats[n - 1] = t.max() - t.min()\\n return ats\",\n \"def test_simulation(walk_length_array, number_of_simulations, walker_class_type):\\n for walk_length in walk_length_array:\\n _distances_ = simulate_walks(walk_length, number_of_simulations, walker_class_type)\\n print(walker_class_type.__name__, \\\" random walk of {} steps\\\".format(walk_length), \\\" After {} simulations\\\".format(number_of_simulations))\\n print(\\\" Mean= {}\\\".format(round(sum(_distances_)/len(_distances_),4)))\\n print(\\\" Max= {}\\\".format(round(max(_distances_), 4)))\\n print(\\\" Min= {}\\\".format(round(min(_distances_),4)))\",\n \"def question05(input):\\r\\n n_threat = input[0] # number of threats\\r\\n threats = [(input[i * 2 + 1], input[i * 2 + 2]) for i in range(n_threat)] # list of threats in (t, f) format\\r\\n threats.sort(key=lambda thr: thr[0]) # sort the list of threats by t\\r\\n instances = [{'t': threats[0][0], 'f': threats[0][1]}] # initial list of instances in {'t': t, 'f': f} format\\r\\n for threat in threats:\\r\\n counter = False\\r\\n instances.sort(key=lambda inst: inst['t'], reverse=True) # sort the list of instances by t in reverse order\\r\\n for instance in instances:\\r\\n if abs(instance['f'] - threat[1]) <= threat[0] - instance['t']: # can counter\\r\\n counter = True\\r\\n instance['t'] = threat[0] # update the instance's current t\\r\\n instance['f'] = threat[1] # update the instance's current f\\r\\n break\\r\\n if not counter: # cannot counter\\r\\n instances.append({'t': threat[0], 'f': threat[1]}) # add a new instance\\r\\n return len(instances)\",\n \"def queryDelay(ants=0) :\\n antlist=makeAntList(ants)\\n print \\\"Current delays\\\"\\n for a in antlist :\\n mp = \\\"Control.Antenna%d.delayOffset3mmRx\\\" %a\\n try :\\n print \\\"delay(%7.3f, %2d)\\\" %(queryDouble(mp, retries=0), a)\\n except Exception: \\n print \\\"C%d\\\" %a, \\\"does not have a value or is invalid\\\"\",\n \"def two_opt_annealing(T, scheme, route, adjacency_matrix, max_chain_length, c):\\n best = route.copy()\\n cost_list, T_list = [], []\\n accept_list = [[],[]]\\n\\n chains, iterations = 0, 0\\n T_0 = T\\n iterations = 0\\n\\n while T > 0:\\n for i in range(1, len(route) - 2):\\n # test\\n # Adjust temperature\\n if scheme == \\\"exp\\\":\\n T = T*c\\n if scheme == \\\"log\\\":\\n alpha = 50\\n T = T_0/(1+alpha*np.log(1+iterations))\\n # if scheme == \\\"std\\\":\\n # delta = .01\\n # T = T / (1 + ((np.log(1+delta)* T) / (3 * sd0)))\\n if scheme == \\\"quad\\\":\\n alpha = 1\\n T = T_0/(1+alpha*iterations**2)\\n\\n iterations += 1\\n \\n for j in range(i + 1, len(route)):\\n chains += 1\\n\\n if j - i == 1: continue\\n\\n cost_list.append(calculate_cost(best,adjacency_matrix)[1])\\n T_list.append(T)\\n\\n if cost_change(adjacency_matrix, best[i - 1], best[i], \\\\\\n best[j - 1], best[j]) < 0:\\n best[i:j] = best[j - 1:i - 1:-1]\\n else:\\n temp = best.copy()\\n sd0, cost0 = calculate_cost(temp,adjacency_matrix)\\n temp[i:j] = temp[j - 1:i - 1:-1]\\n _, cost1 = calculate_cost(temp,adjacency_matrix)\\n\\n U = rs.uniform()\\n Z = np.exp((cost0-cost1)/T)\\n\\n if U < Z:\\n accept_list[1].append(Z)\\n accept_list[0].insert(0,T)\\n\\n best[i:j] = best[j - 1:i - 1:-1]\\n\\n if chains > max_chain_length:\\n print(\\\"End by chainlength: \\\",chains,\\\"T =\\\",T,\\\"Cost:\\\",cost0)\\n print(\\\"route\\\",best)\\n return best, cost_list, accept_list\\n\\n route = best.copy()\\n print(\\\"End by T: \\\",T,\\\"Chains: \\\",chains,\\\"Cost:\\\",cost0)\\n print(\\\"route\\\",best)\\n return best, cost_list, accept_list\",\n \"def _print_tisserand_lists(self, Trajectory=[]):\\n\\t\\n\\timport numpy as np\\n\\t\\n\\tn = len(Trajectory);\\n\\trpl = [];\\n\\tral = [];\\n\\tpl = [];\\n\\tvinfl = [];\\n\\tfor i in range(n):\\n\\t\\tral.append(Trajectory[i][6]);\\n\\t\\trpl.append(Trajectory[i][5]);\\n\\t\\tpl.append(Trajectory[i][7]);\\n\\t\\tvinfl.append(Trajectory[i][8]);\\n\\t\\n\\tprint 'list_ra_python = [',\\n\\tn = len(ral);\\n\\tfor i in range(n-1):\\n\\t\\tprint '%f, ' % ral[i],\\n\\tprint '%f];' % ral[n-1];\\n\\t\\n\\tprint 'list_rp_python = [',\\n\\tn = len(rpl);\\n\\tfor i in range(n-1):\\n\\t\\tprint '%f, ' % rpl[i],\\n\\tprint '%f];' % rpl[n-1];\\n\\t\\n\\tprint 'list_period_python = [',\\n\\tn = len(pl);\\n\\tfor i in range(n-1):\\n\\t\\tprint '%f, ' % pl[i],\\n\\tprint '%f];' % pl[n-1];\\n\\t\\n\\tprint 'list_vinf_python = [',\\n\\tn = len(vinfl);\\n\\tfor i in range(n-1):\\n\\t\\tif(vinfl[i] != []):\\n\\t\\t\\tprint '%f, ' % np.linalg.norm(vinfl[i]),\\n\\t\\telse:\\n\\t\\t\\tprint '0, ',\\n\\tprint '%f];' % np.linalg.norm(vinfl[n-1]);\\n\\t\\n\\tprint 'list_vinf_python_x = [',\\n\\tn = len(vinfl);\\n\\tfor i in range(n-1):\\n\\t\\tif(vinfl[i] != []):\\n\\t\\t\\tprint '%f, ' % vinfl[i][0],\\n\\t\\telse:\\n\\t\\t\\tprint '0, ',\\n\\tprint '%f];' % vinfl[n-1][0];\\n\\t\\n\\tprint 'list_vinf_python_y = [',\\n\\tn = len(vinfl);\\n\\tfor i in range(n-1):\\n\\t\\tif(vinfl[i] != []):\\n\\t\\t\\tprint '%f, ' % vinfl[i][1],\\n\\t\\telse:\\n\\t\\t\\tprint '0, ',\\n\\tprint '%f];' % vinfl[n-1][1];\\n\\t\\n\\tprint 'list_vinf_python_z = [',\\n\\tn = len(vinfl);\\n\\tfor i in range(n-1):\\n\\t\\tif(vinfl[i] != []):\\n\\t\\t\\tprint '%f, ' % vinfl[i][2],\\n\\t\\telse:\\n\\t\\t\\tprint '0, ',\\n\\tprint '%f];' % vinfl[n-1][2];\",\n \"async def get_interference_from_directional_beams( # noqa: C901\\n im_data: Dict,\\n network_name: str,\\n n_days: int,\\n use_real_links: bool,\\n is_n_day_avg: bool,\\n) -> List[Dict]:\\n result: List = []\\n network_name = im_data[\\\"network_name\\\"]\\n tx_node = im_data[\\\"tx_node\\\"]\\n logging.info(f\\\"Analyzing interference for {tx_node}\\\")\\n rx_responses = (\\n im_data[\\\"n_day_avg_rx_responses\\\"]\\n if is_n_day_avg\\n else im_data[\\\"current_avg_rx_responses\\\"]\\n )\\n\\n tx_infos = await get_latest_stats(\\n network_name, tx_node, [\\\"mcs\\\", \\\"tx_beam_idx\\\", \\\"tx_power\\\"]\\n )\\n\\n coros = []\\n rx_nodes = []\\n for rx_node in rx_responses:\\n # Skip if they are the same\\n if tx_node == rx_node:\\n continue\\n\\n # Skip if they map to the same site\\n tx_site_name = Topology.wlan_mac_to_site_name.get(network_name, {}).get(tx_node)\\n rx_site_name = Topology.wlan_mac_to_site_name.get(network_name, {}).get(rx_node)\\n if tx_site_name is not None and rx_site_name is not None:\\n if tx_site_name == rx_site_name:\\n logging.debug(\\n f\\\"{tx_node} and {rx_node} are radios on the same site.\\\"\\n \\\"Skipping interference analysis.\\\"\\n )\\n continue\\n else:\\n logging.debug(f\\\"Ignoring missing site name for {tx_node} &/or {rx_node}.\\\")\\n\\n # Skip if they are the same polarity\\n tx_polarity = Topology.node_polarity.get(network_name, {}).get(tx_node)\\n rx_polarity = Topology.node_polarity.get(network_name, {}).get(rx_node)\\n if tx_polarity is not None and rx_polarity is not None:\\n if tx_polarity == rx_polarity:\\n logging.debug(\\n f\\\"{tx_node} and {rx_node} have the same polarity.\\\"\\n \\\"Skipping interference analysis.\\\"\\n )\\n continue\\n else:\\n logging.debug(\\n f\\\"Ignoring missing polarity info for {tx_node} &/or {rx_node}.\\\"\\n )\\n\\n logging.info(f\\\"Analyzing interference from {tx_node} to {rx_node}\\\")\\n rx_nodes.append(rx_node)\\n coros.append(get_latest_stats(network_name, rx_node, [\\\"rx_beam_idx\\\"]))\\n\\n for rx_node, rx_infos in zip(rx_nodes, await asyncio.gather(*coros)):\\n # Loop through tx_beam and rx_beam combinations\\n for tx_to_node, tx_info in tx_infos.items():\\n # Skip if it's an actual link\\n if rx_node == tx_to_node and not use_real_links:\\n continue\\n\\n tx_beam = tx_info.get(\\\"tx_beam_idx\\\")\\n if tx_beam is None:\\n continue\\n\\n curr_power_idx = tx_info.get(\\\"tx_power\\\")\\n if curr_power_idx is not None:\\n curr_power_idx = int(curr_power_idx)\\n for rx_from_node, rx_info in rx_infos.items():\\n # Skip if it's an actual link\\n if rx_from_node == tx_node and not use_real_links:\\n continue\\n\\n rx_beam = rx_info.get(\\\"rx_beam_idx\\\")\\n if rx_beam is None:\\n continue\\n\\n logging.debug(\\n f\\\"TX to {tx_to_node} from {tx_node} uses tx_beam {tx_beam} and \\\"\\n f\\\"tx_power {curr_power_idx}\\\"\\n )\\n logging.debug(\\n f\\\"RX for {rx_node} from {rx_from_node} uses rx_beam {rx_beam}\\\"\\n )\\n\\n inr = get_interference_data(\\n rx_responses[rx_node], int(tx_beam), int(rx_beam)\\n )\\n if inr is None:\\n continue\\n\\n tx_channel = Topology.node_channel.get(network_name, {}).get(tx_node)\\n if tx_channel is not None:\\n tx_channel = str(tx_channel)\\n\\n inr_curr_power = {}\\n if curr_power_idx is not None:\\n curr_inr_offset = HardwareConfig.get_pwr_offset(\\n target_pwr_idx=curr_power_idx,\\n channel=tx_channel,\\n mcs=tx_info.get(\\\"mcs\\\"),\\n )\\n inr_curr_power = {\\\"snr_avg\\\": inr[\\\"snr_avg\\\"] + curr_inr_offset}\\n\\n result.append(\\n {\\n \\\"group_id\\\": im_data.get(\\\"group_id\\\"),\\n \\\"token\\\": im_data.get(\\\"token\\\"),\\n \\\"tx_node\\\": tx_node,\\n \\\"tx_to_node\\\": tx_to_node,\\n \\\"tx_power_idx\\\": curr_power_idx,\\n \\\"rx_node\\\": rx_node,\\n \\\"rx_from_node\\\": rx_from_node,\\n \\\"inr_curr_power\\\": inr_curr_power,\\n \\\"inr_max_power\\\": {\\\"snr_avg\\\": inr[\\\"snr_avg\\\"]},\\n \\\"is_n_day_avg\\\": is_n_day_avg,\\n }\\n )\\n logging.info(\\n (\\n f\\\"{tx_node} caused interference to {len(result)} other nodes \\\"\\n f\\\"over scans from last {n_days} days.\\\"\\n )\\n if is_n_day_avg\\n else (\\n f\\\"{tx_node} caused interference to {len(result)} other nodes \\\"\\n \\\"in the current scan.\\\"\\n )\\n )\\n\\n return result\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.59733194","0.583341","0.5753424","0.57403886","0.56659484","0.56205523","0.5589108","0.55861825","0.5484096","0.5454451","0.54484034","0.54357857","0.5422951","0.5390583","0.53496975","0.53313315","0.52978075","0.5269319","0.52431566","0.5222972","0.5152985","0.51302236","0.5121965","0.5115938","0.50893843","0.50765765","0.5055707","0.50548255","0.50514054","0.50405794","0.5030696","0.5026417","0.50255364","0.5022796","0.49949825","0.4994628","0.49917412","0.49835056","0.49819297","0.49749798","0.4966155","0.49640226","0.4953771","0.49530855","0.49530855","0.49530855","0.49370223","0.49344775","0.49317804","0.49287847","0.49247357","0.49247092","0.49221522","0.49151593","0.4914275","0.49027964","0.48946482","0.48917586","0.4891556","0.48913106","0.48879623","0.48766008","0.48759416","0.48755342","0.48751143","0.4869825","0.4864829","0.48580173","0.48553804","0.48515725","0.48404562","0.48390326","0.48359048","0.48348176","0.4832748","0.48321074","0.48317486","0.48233852","0.48203033","0.48185837","0.4817349","0.48041144","0.479505","0.47941795","0.47938144","0.47926286","0.47884732","0.47787917","0.47762746","0.47712547","0.4770246","0.47683483","0.47657016","0.47625008","0.47606096","0.47598913","0.4752894","0.47518453","0.4744763","0.4744756","0.4742072"],"string":"[\n \"0.59733194\",\n \"0.583341\",\n \"0.5753424\",\n \"0.57403886\",\n \"0.56659484\",\n \"0.56205523\",\n \"0.5589108\",\n \"0.55861825\",\n \"0.5484096\",\n \"0.5454451\",\n \"0.54484034\",\n \"0.54357857\",\n \"0.5422951\",\n \"0.5390583\",\n \"0.53496975\",\n \"0.53313315\",\n \"0.52978075\",\n \"0.5269319\",\n \"0.52431566\",\n \"0.5222972\",\n \"0.5152985\",\n \"0.51302236\",\n \"0.5121965\",\n \"0.5115938\",\n \"0.50893843\",\n \"0.50765765\",\n \"0.5055707\",\n \"0.50548255\",\n \"0.50514054\",\n \"0.50405794\",\n \"0.5030696\",\n \"0.5026417\",\n \"0.50255364\",\n \"0.5022796\",\n \"0.49949825\",\n \"0.4994628\",\n \"0.49917412\",\n \"0.49835056\",\n \"0.49819297\",\n \"0.49749798\",\n \"0.4966155\",\n \"0.49640226\",\n \"0.4953771\",\n \"0.49530855\",\n \"0.49530855\",\n \"0.49530855\",\n \"0.49370223\",\n \"0.49344775\",\n \"0.49317804\",\n \"0.49287847\",\n \"0.49247357\",\n \"0.49247092\",\n \"0.49221522\",\n \"0.49151593\",\n \"0.4914275\",\n \"0.49027964\",\n \"0.48946482\",\n \"0.48917586\",\n \"0.4891556\",\n \"0.48913106\",\n \"0.48879623\",\n \"0.48766008\",\n \"0.48759416\",\n \"0.48755342\",\n \"0.48751143\",\n \"0.4869825\",\n \"0.4864829\",\n \"0.48580173\",\n \"0.48553804\",\n \"0.48515725\",\n \"0.48404562\",\n \"0.48390326\",\n \"0.48359048\",\n \"0.48348176\",\n \"0.4832748\",\n \"0.48321074\",\n \"0.48317486\",\n \"0.48233852\",\n \"0.48203033\",\n \"0.48185837\",\n \"0.4817349\",\n \"0.48041144\",\n \"0.479505\",\n \"0.47941795\",\n \"0.47938144\",\n \"0.47926286\",\n \"0.47884732\",\n \"0.47787917\",\n \"0.47762746\",\n \"0.47712547\",\n \"0.4770246\",\n \"0.47683483\",\n \"0.47657016\",\n \"0.47625008\",\n \"0.47606096\",\n \"0.47598913\",\n \"0.4752894\",\n \"0.47518453\",\n \"0.4744763\",\n \"0.4744756\",\n \"0.4742072\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":81698,"cells":{"query":{"kind":"string","value":"This function read a log file obtained from simulated tempering and returns a numpy array of shape (number of time points, number of states, 2) The first axis of the array refears to each output on the log file. The second axis refears to the temperature states And the last one to the counts and value of the corresponded weights E.g., if we would like to know the value of the weight on the second output of the log file for the temperature state 5. >>> from palmiche.simutemp import weights >>> time, info_weights = weights.get_weights_from_log('tempering.log') >>> info_weights[1,4,1] 387.69299"},"document":{"kind":"string","value":"def get_weights_from_log(log, plot = False):\n with open(log, 'r') as f:\n log_file = f.readlines()\n\n i = 0\n time = []\n weights_info = []\n weights_0 = []\n while i < len(log_file):\n if 'init-lambda-weights[' in log_file[i]:\n weights_0.append(float(log_file[i].split('=')[-1]))\n\n if 'MC-lambda information' in log_file[i]:\n # Finding the time\n for j in range(i,0,-1):\n if log_file[j].startswith(' Step Time'):\n j += 1\n time.append(float(log_file[j].split()[-1]))\n break\n # Finding the weight\n weights_info_tmp = []\n i += 3\n while log_file[i] != '\\n':\n split = log_file[i].split()\n count = int(split[2])\n weight = float(split[3])\n weights_info_tmp.append((count, weight))\n i += 1\n weights_info.append(weights_info_tmp)\n i += 1\n # Add weights at t = 0, because the counts are all 0 and I delate the entrances with total count 0 in next lines,\n # What i could do is put 1 in the initial temperature\n time.insert(0,0)\n weights_info.insert(0,list(zip([1] + (len(weights_0) - 1)*[0], weights_0)))\n\n #Converting to array\n time = np.array(time)\n weights_info = np.array(weights_info)\n # Some times (I don't know why) GROMACS reset all the weights and all the counts are 0. We need to eliminate those points\n sum_of_weights = weights_info[:,:,0].sum(axis = 1)\n time = time[sum_of_weights != 0]\n weights_info = weights_info[sum_of_weights != 0]\n sum_of_weights = sum_of_weights[sum_of_weights != 0]\n\n\n if plot:\n dir = os.path.dirname(log)\n fig, axes = plt.subplots(2, figsize = (16,9), sharex=True)\n NUM_COLORS = weights_info.shape[1]\n cm = plt.get_cmap('viridis')#gist_rainbow viridis\n for axe in axes:\n axe.set_prop_cycle('color', [cm(1.*j/NUM_COLORS) for j in range(NUM_COLORS)])\n\n probability = weights_info[:,:,0] / sum_of_weights[:,np.newaxis]\n for j in range(weights_info.shape[1]):\n #axes[0].plot(time, weights_info[:,j,0], label = str(j))\n axes[0].plot(time, probability[:,j], label = str(j))\n axes[1].plot(time, weights_info[:,j,1])\n\n fig.legend(loc = 'lower center', ncol = int(weights_info.shape[1] / 2))\n axes[0].set(\n xlim = (time.min(), time.max()),\n ylim = (0,1),\n ylabel = 'Probability',\n )\n axes[1].set(\n xlabel = 'Time [ps]',\n ylabel = 'Weight values'\n )\n #plt.show()\n fig.savefig(os.path.join(dir,'weights_progression.svg'), bbox_inches=\"tight\")\n\n # Plotting the violin plot of the weights\n df = pd.DataFrame()\n for j in range(weights_info.shape[1]):\n #df[temperatures[j]] = weights_info[:,j,1]\n df[j] = weights_info[:,j,1]\n # Set up the matplotlib figure\n sns.set_theme(style=\"whitegrid\")\n fig, ax = plt.subplots(figsize=(25, 25))\n\n # Draw a violinplot with a narrower bandwidth than the default\n sns.violinplot(data=df, palette=\"Set3\", bw=.2, cut=1, linewidth=1)\n # The plot is not over the actual temperatures, the temperatures ara only labels\n ax.plot(range(len(weights_info[0,:,1])), weights_info[0,:,1], '-o', label = 'Initial weights')\n ax.set(\n title = 'Weights per state over the entire simulation',\n xlabel = 'Sate',\n ylabel = 'Weight',\n )\n plt.legend()\n sns.despine(left=True, bottom=True)\n #plt.show()\n fig.savefig(os.path.join(dir,'weights_per_state.svg'), bbox_inches=\"tight\")\n sns.reset_defaults()\n\n return time, weights_info"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def getWeights(self, format='list'):\n timer = None\n if conf.config.getboolean(\"Reports\", \"outputTimesForSections\"):\n timer = Timer()\n timer.start_timing()\n synapse_list = self._get_synaptic_data()\n if conf.config.getboolean(\"Reports\", \"outputTimesForSections\"):\n timer.take_sample()\n \n if format == 'list':\n weights = list()\n for row in synapse_list.get_rows():\n weights.extend(row.weights)\n return weights \n elif format == 'array':\n weights = numpy.zeros((self.projection_edge.prevertex.atoms, \n self.projection_edge.postvertex.atoms))\n rows = synapse_list.get_rows()\n for pre_atom, row in enumerate(rows):\n for post_atom, weight in zip(row.target_indices, row.weights):\n weights[pre_atom][post_atom] = weight\n return weights","def take_log_weights(self, data):\n\n n_row = data[:, 0].size\n log_data = np.zeros(data.shape)\n for i in xrange(data.shape[0]):\n idx_nonzero = (data[i, :] > 0).nonzero()[0]\n log_data[i, idx_nonzero] = np.log(data[i, idx_nonzero])\n return log_data","def _parse_weights(self):\n\n # Initialize weights matrix\n weights = [[-1 for _ in range(self.specification['DIMENSION'])]\n for _ in range(self.specification['DIMENSION'])]\n\n # Cell coordinates iterator\n cells = self._cells()\n\n while True:\n for value in self._lines.current.split():\n try:\n weight = int(value)\n row, col = next(cells)\n weights[row][col] = weight\n except (ValueError, StopIteration):\n return weights\n\n try:\n next(self._lines)\n except StopIteration:\n break\n\n return weights","def read_fermi_energy_from_log(log_file):\n with open(log_file, \"r\") as f:\n content = f.readlines()\n ferimiValues = EFermi_Pattern.findall(\"\".join(content))\n return list([float(item.split()[1]) for item in ferimiValues])","def load_weights(self, weights):\n weight = np.load(weights)\n return weight","def readWaveform(self):\n # prepare data holder\n y = [ 0 for j in range(4) ]\n # in case of previous errors\n self.flushInput()\n for ch in self.chs:\n # mostly for TDS\n self.setCh(ch)\n # calibration factor we will need soon\n (vmult, voff) = self.calibV()\n # read and calibrate data\n data = (numpy.array(self.readData()) - voff) * vmult\n # This is from the formula in TDS manual, without the\n # \"vzero\" in it---I couldn't figure out when that wouldn't\n # be exactly zero.\n y[ch-1]=data[:]\n\n (hstep, hoff) = self.calibH()\n # initialize time array\n t = numpy.array(range(len(y[0])))\n t = (t * hstep) + hoff\n\n # update the sequence number (... for isUpdated())\n self.seq = self.readSeq()\n\n return (t, y)","def read_filter(filter_file):\n\n fd = open(filter_file, \"r\")\n lines = fd.readlines()\n fd.close()\n\n wavelengths = []\n weights = []\n for line in lines:\n line = line.strip()\n words = line.split()\n wavelengths.append(float(words[0]))\n weights.append(float(words[1]))\n\n return (wavelengths, weights)","def _read_log(self):\n\n line_regex = compile(r\"\\[I\\]\\s*\\(\\d+ms\\)[^\\d]+(?P<counter>\\d+)\"\n r\"[^\\d]+(?P<timestamp>\\d+(\\.\\d+)?)[^\\d]+\"\n r\"(?P<acceleration>\\d+);\")\n values = []\n with open(self.filepath) as file:\n for line in file:\n match = line_regex.match(line)\n if match:\n values.append({\n 'counter':\n int(match['counter']),\n 'timestamp':\n int(float(match['timestamp']) * 1000),\n 'acceleration':\n int(match['acceleration'])\n })\n\n self.values = values","def log_extract(log_info):\n \n #Handle file names, strings and open file-like objects equivalently\n with uber_open_rmode(log_info) as log_info:\n \n headers = []\n footers = []\n i = 0\n \n #for all lines in file/output\n for line in log_info:\n \n #skip blank lines\n if len(line.split()) == 0:\n continue\n \n #This is listed before both run and minimize simulations \n if 'Memory usage per processor =' in line:\n headers.append(i+1)\n \n #This follows both run and minimize simulations\n elif 'Loop time of' in line:\n footers.append(i-1)\n \n i += 1\n \n #Add last line to footers for incomplete logs\n footers.append(i)\n \n log_info.seek(0)\n \n #Create DataModelDict root\n log_dict = DM()\n log_dict['LAMMPS-log-thermo-data'] = DM()\n \n #for all lines in file/output\n for header, footer in zip(headers, footers):\n\n #Read thermo data\n df = pd.read_csv(log_info, header=header, nrows=footer-header, sep='\\s+', engine='python', skip_blank_lines=True)\n log_info.seek(0) \n\n #Convert to DataModelDict\n thermo = DM()\n for j in df:\n thermo[str(j)] = df[j].values.tolist()\n \n #Append simulation results to DataModelDict root\n simulation = DM([('thermo', thermo)])\n log_dict['LAMMPS-log-thermo-data'].append('simulation', simulation)\n \n return log_dict","def readLogAmat(path): \n # Open file\n f = open(path, 'r')\n # initialize variables\n out = {}\n lines = f.readlines()\n\n # Read input image path pattern\n out[TrackingAnalysis.IMAGE_PATH_KEY] = lines[4].split('=')[1][:-1] + '.tif'\n # Read Z-Anisotrpy of the image\n out[TrackingAnalysis.ANISOTROPY_KEY] = float(lines[20].split('=')[1][:-1])\n times = lines[1].strip().split()\n out[TrackingAnalysis.TIME_INI_KEY] = int(times[-2])\n out[TrackingAnalysis.TIME_END_KEY] = int(times[-1])\n\n # close file\n f.close()\n\n return out","def weights(self):\n return np.array(self.intensity[self.idx])","def load_SCF_wealth_weights():\n with open(DATASETS + \"SCFwealthDataReduced.txt\") as f:\n SCF_reader = csv.reader(f, delimiter=\"\\t\")\n SCF_raw = list(SCF_reader)\n SCF_wealth = np.zeros(len(SCF_raw)) + np.nan\n SCF_weights = deepcopy(SCF_wealth)\n for j in range(len(SCF_raw)):\n SCF_wealth[j] = float(SCF_raw[j][0])\n SCF_weights[j] = float(SCF_raw[j][1])\n return SCF_wealth, SCF_weights","def load_hrpsys_log_rstate(rstate_path, angle_unit=\"deg\"):\n\n rstate = np.loadtxt(rstate_path, comments=\"%\")\n if rstate.shape[1] != 100:\n sys.exit([rstate_path, \" is not a valid \" \"*-rstate.log\" \" file\"])\n\n m = rstate.shape[0]\n dt = \"f4\"\n r = np.zeros(\n m,\n dtype=[\n (\"enc\", dt, 40),\n (\"jvelocity\", dt, 40),\n (\"acc\", dt, 3),\n (\"zmp\", dt, 3),\n (\"waist_p\", dt, 3),\n (\"waist_rot\", dt, 9),\n (\"time\", dt, 1),\n (\"controltimev2\", dt, 1),\n (\"type\", \"a6\"),\n (\"ang_type\", \"a3\"),\n ],\n )\n r[\"enc\"] = rstate[:, 0:40]\n # JA0-JA39\n r[\"jvelocity\"] = rstate[:, 40:80]\n #\n r[\"acc\"] = rstate[:, 80:83]\n #\n r[\"zmp\"] = rstate[:, 83:86]\n #\n r[\"waist_p\"] = rstate[:, 86:89]\n # waistPX-waistPZ\n r[\"waist_rot\"] = rstate[:, 89:98]\n # waistQX-waistQW (rot matrix)\n r[\"time\"] = rstate[:, 98]\n # clockv2\n r[\"controltimev2\"] = rstate[:, 99]\n # ControlTimeV2\n\n r[\"type\"] = \"rstate\"\n r[\"ang_type\"] = \"rad\"\n\n if angle_unit == \"deg\":\n r[\"enc\"] = 180 / np.pi * r[\"enc\"]\n # Joint angles in degrees\n r[\"ang_type\"] = \"deg\"\n print(\"Warning: joint angles (astate) in degrees!\")\n\n return r","def read_w_matrix(filepath, hnodes=400, epochs=5):\n \n filename_wih = filepath + f\"hn{hnodes}_wih_epoch_{epochs}.csv\"\n filename_who = filepath + f\"hn{hnodes}_who_epoch_{epochs}.csv\"\n wih = numpy.loadtxt(filename_wih)\n who = numpy.loadtxt(filename_who)\n\n return wih, who","def read_file(log_file):\n\t\tfile = open(log_file, 'r')\n\t\tresult = []\n\t\twhile 1:\n\t\t\tcontent = file.readline()\n\t\t\tif not content:\n\t\t\t\tbreak\n\t\t\telse:\n\t\t\t\tdata = content.split(\"\\003\")\n\t\t\t\tif len(data) == 13:\n\t\t\t\t\ttrack = {\n\t\t\t\t\t\t\t 'device_no' : long(data[0][3:]), 'sim' : data[1], 'type':int(data[2]), 'gps_time' : MongoTrack.time_trans(data[3]),\n\t\t\t\t\t\t\t 'valid' : data[4], 'loc':{'long' : float(data[5]), 'lat' : float(data[6]) }, 'altitude' : float(data[7]),\n\t\t\t\t\t\t\t 'speed' : float(data[8]), 'course' : float(data[9]), 'km' : float(data[10]), 'para' : float(data[11]),\n\t\t\t\t\t\t\t 'rtime' : MongoTrack.time_trans(data[12].strip())\n\t\t\t\t\t\t\t}\n\t\t\t\t\tresult.append(track)\n\t\tfile.close()\n\t\treturn result","def read_trajectory(filename, n_parameters=3):\r\n\r\n with open(filename) as f:\r\n n_cols = len(f.readline().split(' '))\r\n\r\n trajectories = np.loadtxt(filename, dtype=float, delimiter=' ', usecols=range(1, n_cols))\r\n\r\n n_birds = int((n_cols - 1) / n_parameters)\r\n n_time_steps = np.shape(trajectories)[0]\r\n\r\n trajectories = trajectories.flatten(order='F') # Need to be flattened in this way to format correctly\r\n trajectories = np.reshape(trajectories, (n_birds, n_parameters, n_time_steps))\r\n\r\n return trajectories","def parseBowtieLog(fileName):\n if not os.path.isfile(fileName):\n print \"WARNING: \" +fileName+\" does not exist.\"\n return 0,0,0,0 \n\n processed,aligned,unaligned,ambig=0,0,0,0\n with open(fileName,'rb') as bowtieLogFile:\n for line in bowtieLogFile.readlines():\n if 'reads processed' in line:\n processed=line.split(':')[1].strip()\n elif 'reads with at least one reported alignment' in line:\n aligned=line.split(':')[1].split(' ')[1]\n elif 'reads that failed to align' in line:\n unaligned=line.split(':')[1].split(' ')[1]\n elif 'reads with alignments suppressed' in line:\n ambig=line.split(':')[1].split(' ')[1]\n\n return int(processed),int(aligned),int(unaligned),int(ambig)","def readtxt(obslog):\n\n logger = log.getLogger('obslog.readtxt')\n\n if not os.path.exists(obslog):\n logger.error('Cannot access %s', obslog)\n raise SystemExit\n\n logger.info('Reading %s', obslog)\n\n with open(obslog) as f: # Since we will have to go through the data twice, read the whole file at once.\n data = f.readlines()\n\n header = ['Observation ID', 'Data Labels', 'File Numbers', 'Dataset UT', 'Target Name', 'Filters', 'Slit',\n 'Grating/Wavelength', 'Camera/Prism', 'ExpTime/LNR/Coadds', 'ACQ']\n\n pattern = dict() # Enforce formatting rules to avoid parsing comments as data:\n pattern['Observation ID'] = re.compile(r'^G[NS]-[0-9]{4}[AB]-([CQ]|DD|FT|LP|SV)-[0-9]{0,3}-[0-9]+$')\n pattern['Data Labels'] = re.compile(r'[0-9]+-*[0-9]*') # 1, 2-3, 45-67, 890-1234\n pattern['File Numbers'] = re.compile(r'[0-9]+-*[0-9]*') # 1, 2-3, 45-67, 890-1234\n pattern['Dataset UT'] = re.compile(r'^[0-9]{2}:[0-9]{2}:[0-9]{2}$') # 09:58:15\n pattern['Target Name'] = re.compile(r'[a-zA-Z0-9_-]+') # Match any string\n pattern['Filters'] = re.compile(r'[A-Z0-9\\-]+') # H, XD, H2, X, J, H\n pattern['Slit'] = re.compile(r'[a-zA-Z0-9]+') # 0.675, ACQ, LgPin\n pattern['Grating/Wavelength'] = re.compile(r'[0-9]{2,3}/[0-9]\\.[0-9]{2}') # 32/1.65, 111/1.68\n pattern['Camera/Prism'] = re.compile(r'[A-Z]{2}/[A-Z]{3}') # LB/MIR, SB/SXD\n pattern['ExpTime/LNR/Coadds'] = re.compile(r'[0-9]+\\.[0-9]/[0-9]+/[0-9]+') # 0.2/1/25, 300.0/32/1\n pattern['ACQ'] = re.compile(r'^Y*$') # Y or ''\n\n indx = {}\n for line in data:\n if 'Electronic Observing Log' in line:\n date = line.split()[-1][7:]\n logger.debug('Log date: %s', date)\n if line[0:14] == 'Observation ID': # This defines the start of the header row\n for h in header:\n indx[h] = line.find(h) # Find where each column starts\n break # No need to go farther\n\n width = {} # Find the width of each row\n for i in range(len(header) - 1): # This requires that 'header' be an ordered array (not a dictionary)\n width[header[i]] = indx[header[i + 1]] - indx[header[i]]\n width[header[i+1]] = 1 # The ACQ field is either 'Y' or blank\n\n val = {}\n match = {}\n info = {}\n for line in data:\n logger.debug('\\n%s', line)\n files = []\n for h in header:\n val[h] = line[indx[h]: indx[h] + width[h]].strip()\n match[h] = re.match(pattern[h], val[h])\n logger.debug('%s: \"%s\" %s' % (h, val[h], match[h]))\n\n # Maybe throw a warning if only match 1 fails; indicating a likely bad pattern specification?\n\n if None in match.values():\n logger.debug('Failed to match all patterns -> This is a comment')\n continue\n\n if '-' in val['File Numbers']:\n start, stop = val['File Numbers'].split('-')\n for i in range(int(start), int(stop)+1):\n files.append(i)\n else:\n files.append(int(val['File Numbers']))\n\n for filenum in files:\n f = 'N%sS%04d.fits' % (date, filenum)\n logger.debug('File: %s', f)\n info[f] = {}\n for h in [header[0]] + header[3:]: # Skip 'Data Labels' and \"File Numbers'\n info[f][h] = val[h]\n\n logger.debug('info: %s', info)\n return info","def get_data_sample(log_path, num_samples):\n\n img_list = []\n\n log_list = read_driving_log(log_path)\n\n log_list_sample = log_list[:num_samples]\n\n for row in log_list_sample:\n image_path = row['center']\n\n if not os.path.isabs(image_path):\n image_path = os.path.join(IMAGE_DIR, image_path)\n\n image = load_image(image_path, IMAGE_SIZE)\n img_list.append(image)\n\n features_sample = np.array(img_list).astype('float32')\n\n steering_angle = np.array([float(log['steering']) for log in log_list_sample])\n\n labels_sample = steering_angle\n\n return features_sample, labels_sample","def loadatran(filename, wl=True, verbose=False):\n # 2008-08-21 09:42 IJC: Created to save myself a bit of time\n # 2008-08-25 10:08 IJC: Read in all lines at once; should go\n # faster with sufficient memory\n # 2008-09-09 13:56 IJC: Only convert the wavelength and flux\n # columns(#1 & #2) -- speed up slightly.\n if filename.__class__==list:\n returnlist = []\n for element in filename:\n returnlist.append(loadatran(element, wl=wl))\n return returnlist\n \n f = open(filename, 'r')\n dat = f.readlines()\n f.close()\n if verbose:\n print dat[0]\n print dat[0].split()\n print dat[0].split()[1:3]\n print dat[0].split()[2]\n \n if wl:\n data = array([map(float, line.split()[1:3]) for line in dat])\n else:\n data = array([float(line.split()[2]) for line in dat])\n\n return data","def process_log(log_file):\n result_list = []\n file_root = get_fname_root(log_file)\n\n with open(log_file) as l_file:\n reading_steps = False\n result_dict = {}\n for line in l_file:\n line = line.strip()\n if STEP_PAT.match(line):\n reading_steps = True\n result_dict[FILE_NAME] = file_root\n result_dict[TIMESTEP] = int(line.split()[2])\n elif reading_steps:\n if len(line) == 0:\n break\n s_line = line.split()\n if s_line[0] == TOTENG:\n for key_id, key in enumerate([TOTENG, KINENG, TEMP]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n elif s_line[0] == POTENG:\n for key_id, key in enumerate([POTENG, E_BOND, E_ANGL]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n elif s_line[0] == E_DIHED:\n for key_id, key in enumerate([E_DIHED, E_IMPRO, E_VDWL]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n elif s_line[0] == E_COUL:\n for key_id, key in enumerate([E_COUL, E_LONG, PRESS]):\n result_dict[key] = float(s_line[2 + key_id * 3])\n result_list.append(dict(result_dict))\n else:\n # when stop matching, done reading file (either by normal or abnormal termination)\n break\n\n return result_list","def log_weights(self):\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\n\n return self._prob_inverse_transform(m - u)","def read_stats_in_log(model_tarfile):\n # log file is YYYY0101.fms.out\n log_filename = os.path.basename(model_tarfile).replace(\"ascii_out.tar\", \"fms.out\")\n year = int(os.path.basename(model_tarfile).replace(\"0101.ascii_out.tar\", \"\"))\n\n if not log_filename.startswith('./'):\n log_filename = './' + log_filename\n\n with tarfile.open(model_tarfile, \"r:\") as f:\n logdump = f.extractfile(log_filename).read().decode('utf-8')\n\n lines = logdump.split(sep='\\n')\n\n linestart_stats = [lines.index(line) for line in lines if line.find('Total runtime') != -1 ][-1]\n lineend_stats = [lines.index(line) for line in lines if line.find('high water mark') != -1 ][-1]\n\n raw_stats = lines[linestart_stats-1:lineend_stats]\n\n # infer the number of data columns\n columns = raw_stats[0].split()\n ncol_data = len(columns)\n # add a column for model component\n columns = ['model'] + columns\n formatted_lines = []\n for line in raw_stats[1:]:\n data = line.split()[-ncol_data:]\n data_num = []\n for item in data:\n data_num.append(float(item))\n line = line.replace(item, '')\n modelname = line.strip()\n formatted_line = [modelname] + data_num\n formatted_lines.append(formatted_line)\n\n df = pd.DataFrame(formatted_lines, columns = columns)\n df['year'] = year\n\n return df","def log_weights_statistics(self):\n for weight_name, weight_parameter in self._weights.items():\n for statistic_function in self._statistics_functions:\n self._weights_statistics[statistic_function.__name__][\n weight_name\n ].append(float(statistic_function(weight_parameter)))","def read(self, w):\n\n self.assert_valid_weights(w)\n\n return w.dot(self.memory)","def logistic_predict(weights, data):\n \n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\n f_e = data * t\n z_sums = np.sum(f_e, axis=1) \n \n x = -z_sums - weights[-1]\n y = sigmoid(z_sums + weights[-1])\n\n return np.reshape(y, (len(y), 1))","def get_thermo(self, structure):\n dir = IO(dir=os.path.join(self.loc, structure))\n values = dir.get_values(\n structure, \"freq.log\", self.freqvalid, self.thermo_vals)\n \n return values","def _read_data(filename):\n file = open(filename, \"r\")\n timestamps = []\n edges = []\n for line in file:\n # source target weight timestamp\n if line.startswith(\"%\"):\n continue\n spl = line.split()\n if len(spl) == 4:\n # store that stuff in triples (source, target, weight, timestamp)\n edges.append((int(spl[0]), int(spl[1]), int(spl[2]), int(spl[3])))\n timestamps.append(int(spl[3]))\n return edges, sorted(timestamps)","def logistic_predict(weights, data):\n\n # TODO: Finish this function\n\n return y","def weights_(self):\n return self.get_tensor_value('logistic_regression/weights:0')","def all_modes(self):\n\n with open(f'gj_{self.molecule.name}.log', 'r') as gj_log_file:\n\n lines = gj_log_file.readlines()\n freqs = []\n\n # Stores indices of rows which will be used\n freq_positions = []\n for count, line in enumerate(lines):\n if line.startswith(' Frequencies'):\n freq_positions.append(count)\n\n for pos in freq_positions:\n freqs.extend(float(num) for num in lines[pos].split()[2:])\n\n return array(freqs)","def load_log(filename):\n\tlogfile = open(directory + filename, \"r\")\n\tlog = logfile.read().splitlines()\n\tlog = [float(i) for i in log]\n\tlogfile.close()\n\treturn log","def logistic(weights, data, targets, hyperparameters):\n \n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\n f_e = data * t\n z_sums = np.sum(f_e, axis=1)\n y = sigmoid(z_sums +weights[-1])\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\n df = np.reshape(df, ((len(df), 1)))\n\n return f, df, np.reshape(y, (len(y), 1))","def read(dir, fname, maxtime):\n solution = [0, maxtime, 0, 'UNK', 0, 'unknown', 'CHU', 0]\n try:\n logfile = open(os.path.join(dir, fname + '+CHU.log'), 'r', encoding='utf8')\n except FileNotFoundError:\n return solution\n sndlast = \"\"\n last = \"\"\n rstat = \"\"\n nbsol=0\n for line in logfile:\n if re.search(ropt, line):\n sndlast = last\n last = line\n if re.search(status, line):\n rstat = line\n # get the last solution, there should be at least one\n # line = line.replace(',', '')\n\n last = last.replace('s', '')\n parts = last.split()\n sndlast = sndlast.replace('s', '')\n sndparts = sndlast.split()\n\n if len(parts) > 0:\n if len(sndparts) > 0 and parts[1] == sndparts[1]:\n parts = sndparts\n solution[0] = int(parts[2]) # nb solutions\n solution[1] = float(parts[5][:-1]) # time\n solution[2] = int(parts[6]) # nodes\n solution[3] = 'MIN' # res. policy\n solution[4] = int(parts[1][:-1]) # obj. value\n if rstat == \"\":\n solution[5] = ' ' # res. status\n elif rstat == comp or rstat == unsa:\n solution[5] = 'proof' # res. status\n elif rstat == unbo:\n solution[5] = 'unbounded' # res. status\n\n return solution","def get_weights(self, index):\n weight = self._weights[index]\n if isinstance(weight, dict):\n return list(weight.items())\n else:\n return [(Term(\"t\"), weight)]","def read_data(self, path):\n if self.data_format == 'twenty': \n length = 20\n else: raise ValueError(\"self.data_format = '%s' unknown.\" % \n self.data_format)\n data = []\n with open(path,'r') as f:\n for line in f:\n data.append([float(line[k:(k + length)]) for k in range(\n 0, len(line.strip('\\n')),length)])\n return np.array(data)","def read_state_matrices():\r\n drum_mats = glob.glob('./Melody_Bass_Data/*_bass.txt')\r\n melody_mats = glob.glob('./Melody_Bass_Data/*_melody.txt')\r\n \r\n drum_states = []\r\n melody_states = []\r\n\r\n for drum_mat,melody_mat in zip(drum_mats[:20],melody_mats[:20]):\r\n temp= np.genfromtxt(drum_mat)\r\n drum_states.append(temp)\r\n temp= np.genfromtxt(melody_mat)\t\r\n melody_states.append(temp)\r\n \r\n return drum_states,melody_states","def _get_weights_and_simpoints_from_file(\n self,\n ) -> Tuple[List[int], List[int]]:\n simpoint_weight_pair = []\n with open(self.get_simpoint_file()) as simpoint_file, open(\n self.get_weight_file()\n ) as weight_file:\n while True:\n line = simpoint_file.readline()\n if not line:\n break\n interval = int(line.split(\" \", 1)[0])\n line = weight_file.readline()\n if not line:\n fatal(\"not engough weights\")\n weight = float(line.split(\" \", 1)[0])\n simpoint_weight_pair.append((interval, weight))\n simpoint_weight_pair.sort(key=lambda obj: obj[0])\n # use simpoint to sort\n\n weight_list = []\n simpoint_list = []\n for simpoint, weight in simpoint_weight_pair:\n simpoint_list.append(simpoint)\n weight_list.append(weight)\n return simpoint_list, weight_list","def read_weight(self, stream):\r\n \r\n return self.data_to_weight(self.read_postvalue(stream))","def log_ess(log_weight):\n dim = 1 if log_weight.ndimension() == 2 else 0\n\n return 2 * torch.logsumexp(log_weight, dim=dim) - \\\n torch.logsumexp(2 * log_weight, dim=dim)","def read_linelog():","def _extract_weights(self,W):\n wl1_size = self._D*self._hidden_layer_size\n bl1_size = self._hidden_layer_size\n \n wl2_size = self._hidden_layer_size*self._output_size\n bl2_size = self._output_size\n\n \n weights_L1 = W[0:wl1_size].reshape((self._D,self._hidden_layer_size))\n bias_L1 = W[wl1_size:wl1_size+bl1_size]\n \n start_l2 = wl1_size+bl1_size\n\n weights_L2 = W[start_l2: start_l2 + wl2_size].reshape((self._hidden_layer_size,self._output_size))\n bias_L2 = W[start_l2 + wl2_size : start_l2 + wl2_size + bl2_size]\n \n \n \n return weights_L1,bias_L1,weights_L2,bias_L2","def parse_log(path_to_log):\n regex_iteration = re.compile('Iteration (\\d+), loss = ([\\.\\deE+-]+)')\n regex_train_output = re.compile('Train net output #(\\d+): (\\S+) = ([\\.\\deE+-]+)')\n regex_learning_rate = re.compile('lr = ([\\.\\deE+-]+)')\n regex_test_output = re.compile('Test net output #(\\d+): detection_eval = ([\\.\\deE+-]+)')\n\n\n # Pick out lines of interest\n iteration = 0\n loss = -1\n learning_rate = 0.001\n train_dict_list = []\n train_row = None\n test_score=0.0\n\n logfile_year = extract_seconds.get_log_created_year(path_to_log)\n with open(path_to_log) as f:\n start_time = extract_seconds.get_start_time(f, logfile_year)\n last_time = start_time\n\n for line in f:\n iteration_match = regex_iteration.search(line)\n if iteration_match:\n iteration = float(iteration_match.group(1))\n loss = float(iteration_match.group(2))\n try:\n time = extract_seconds.extract_datetime_from_line(line,\n logfile_year)\n except:\n # Skip lines with bad formatting, for example when resuming solver\n continue\n\n # if it's another year\n if time.month < last_time.month:\n logfile_year += 1\n time = extract_seconds.extract_datetime_from_line(line, logfile_year)\n last_time = time\n\n seconds = (time - start_time).total_seconds()\n\n learning_rate_match = regex_learning_rate.search(line)\n\n if learning_rate_match:\n learning_rate = float(learning_rate_match.group(1))\n\n test_score_match = regex_test_output.search(line)\n if test_score_match:\n test_score = float(test_score_match.group(2))\n\n train_dict_list, train_row = parse_line_for_net_output(\n regex_train_output, train_row, train_dict_list,\n line, iteration, seconds, learning_rate,loss,test_score\n )\n\n\n return train_dict_list","def read_log_payload(ac_id, filename):\n f = open(filename, 'r')\n pattern = re.compile(\"(\\S+) \"+ac_id+\" PAYLOAD_FLOAT (\\S+),(\\S+),(\\S+),(\\S+)\")\n list_meas = []\n while True:\n line = f.readline().strip()\n if line == '':\n break\n m = re.match(pattern, line)\n if m:\n list_meas.append([float(m.group(1)), float(m.group(2)), float(m.group(3)), float(m.group(4)), float(m.group(5))])\n return np.array(list_meas)","def logistic_predict(weights, data):\n #####################################################################\n # TODO: #\n # Given the weights and bias, compute the probabilities predicted #\n # by the logistic classifier. #\n #####################################################################\n \n y = None\n N = len(data)\n M = len(weights) - 1\n temp = np.ones([N, M + 1])\n temp[: N, : M] = np.array(data)\n data = temp\n\n\n\n # print(np.matmul(data, weights).shape)\n z = np.matmul(data, weights)\n y = sigmoid(z)\n #####################################################################\n # END OF YOUR CODE #\n #####################################################################\n return y","def get_weights(self):\n return self.weights\n #print(W)","def read(filename):\n\n fileName, fileExtension = os.path.splitext(filename)\n wav_filename = filename\n rate, data = scipy.io.wavfile.read(str(wav_filename)) # the data is read in its native format\n if data.dtype =='int16':\n data = numpy.cast['float'](data)\n return [rate,data]","def data_from_tracecomp_file():\n data = '' # assume file will have more thant [MAX_DIFF_LINE] lines\n with open(TRACECOMP_OUT_FILE) as f:\n for i, line in enumerate(f):\n if i == LOGLIK_LINE:\n data = line\n\n parsed_data = re.sub(r'\\s+', ' ', data).split(' ')\n loglik_effsize = int(parsed_data[1])\n loglik_rel_diff = float(parsed_data[2])\n return loglik_effsize, loglik_rel_diff","def read_wavetxt(path):\n with open(path) as f:\n for line in f.readlines():\n line = line.strip()\n if 'SampleFrequence' in line:\n freq = int(line[16:])\n elif 'DataInput' in line:\n series = np.array(line[10:].split(',')).astype(np.float64)\n return (freq, series)","def get_weight_matrix(self):\n\n\t\treturn self.weights.get_value(borrow=True)","def readMcmcLog(fname, par):\n\t# find params that varied\n\tfor line in open(fname):\n\t\tif line.startswith('##'):\n\t\t\tlabels = line.split()[1:]\n\t\t\tlabels = np.array(labels, dtype=str)\n\t\t\tbreak\n\t#read data and select the desired parameter\n\tdata = np.loadtxt(fname)\n\toi = data[:, (labels==par)]\n\tif len(oi) == 0:\n\t\tprint \"!!ERROR finding that parameter in log file!!\"\n\tprint \"Read %d points from %s\"%(len(oi),fname)\n\treturn oi","def ExtractRequestsFromLog(log_path):\n requests = []\n wpr_http_netloc = None\n with open(log_path) as log_file:\n for line in log_file.readlines():\n # Extract WPR's HTTP proxy's listening network location.\n match = _PARSE_WPR_DOMAIN_REGEX.match(line)\n if match:\n wpr_http_netloc = match.group('netloc')\n assert wpr_http_netloc.startswith('127.0.0.1:')\n continue\n # Extract the WPR requested URLs.\n match = _PARSE_WPR_URL_REGEX.match(line)\n if match:\n parsed_url = urlparse(match.group('url'))\n # Ignore strange URL requests such as http://ousvtzkizg/\n # TODO(gabadie): Find and terminate the location where they are queried.\n if '.' not in parsed_url.netloc and ':' not in parsed_url.netloc:\n continue\n assert wpr_http_netloc\n request = WprRequest(is_served=(match.group('level') == 'DEBUG'),\n method=match.group('method'), url=match.group('url'),\n is_wpr_host=parsed_url.netloc == wpr_http_netloc)\n requests.append(request)\n return requests","def read_feature_weights(fwfile, xvals):\n\n # If no file was specified, skip this step.\n if fwfile == '': # default\n return []\n\n if not os.path.exists(fwfile):\n printt(' Could not find feature weight file %s, skipping.' % fwfile)\n return []\n\n printt('Treating feature-weight argument as a file name (%s).' % fwfile)\n # Read in the feature-weight file\n f = open(fwfile)\n lines = f.readlines()\n if len(lines) != len(xvals):\n raise ValueError('Looking for %d weights, but got %d.' % (len(xvals), len(lines)))\n\n wolf = [-1] * len(xvals)\n for (i,line) in enumerate(lines):\n values = line.split()\n\n # Sanity check that we have one of two cases:\n # 1. One weight per line\n if len(values) == 1:\n wolf[i] = float(values[0])\n\n # 2. Two values per line (feature - matches xvals, weight)\n elif len(values) == 2:\n values = list(map(float, values))\n feat_ind = np.where(xvals == values[0])[0]\n if len(feat_ind) == 0:\n raise ValueError('Could not find feature %s.' % values[0])\n wolf[feat_ind[0]] = values[1]\n\n # Check that feature weights are valid\n for weight in wolf:\n if weight < 0 or weight > 1:\n raise ValueError(\"Weights must be between 0 and 1.\")\n \n return wolf","def get_csv_data(log_file):\r\n image_names, steering_angles = [], []\r\n # Steering offset used for left and right images\r\n steering_offset = 0.275\r\n with open(log_file, 'r') as f:\r\n reader = csv.reader(f)\r\n next(reader, None)\r\n for center_img, left_img, right_img, angle, _, _, _ in reader:\r\n angle = float(angle)\r\n image_names.append([center_img.strip(), left_img.strip(), right_img.strip()])\r\n steering_angles.append([angle, angle + steering_offset, angle - steering_offset])\r\n\r\n return image_names, steering_angles","def load(fname):\r\n try:\r\n with open(fname, 'r') as f:\r\n V, H = (int(a) for a in next(f).split())\r\n W, i2w, w2i = np.zeros((V, H)), [], {}\r\n for i, line in enumerate(f):\r\n parts = line.split()\r\n word = parts[0].strip()\r\n w2i[word] = i\r\n W[i] = list(map(float, parts[1:]))\r\n i2w.append(word)\r\n return W, i2w, w2i, V, H\r\n except:\r\n print(\"Error: failing to load the model to the file\")","def read_rationals(self, count=1, location=None):\n return_vals = []\n if self._tiff is not None:\n off = self._offset\n if location is not None:\n off = location\n for c in range(count):\n num = int.from_bytes(self._tiff[off:off + 4], byteorder=self._byteorder)\n denom = int.from_bytes(self._tiff[off+4:off + 8], byteorder=self._byteorder)\n return_vals.append((num, denom))\n off += 8\n if location is None:\n self._offset += (count * 8)\n return return_vals","def _get_weight(self, weight):\n if isinstance(weight, pd.DataFrame):\n pass\n elif isinstance(weight, str):\n if weight.endswith(\"gctx\"):\n from cmapPy.pandasGEXpress.parse import parse\n weight = parse(weight).data_df\n elif weight.endswith(\"csv\"):\n weight = pd.read_csv(weight)\n else:\n weight = pd.read_table(weight)\n else:\n raise Exception(\"Unsupported file format\")\n\n assert weight.shape[1] == 979 # first column is offset\n\n return weight","def get_weights(model) -> Weights:\n return [val.cpu().numpy() for _, val in model.state_dict().items()]","def _get_temp_raw(self):\n try: \n f = open(self.device_file, 'r')\n lines = f.readlines()\n f.close()\n return lines\n\n except: \n print(\"ERROR: w1_slave file could not be opened (temp sensor)\")","def get_weights(self):","def logistic(weights, data, targets, hyperparameters):\n y = logistic_predict(weights, data)\n\n #####################################################################\n # TODO: #\n # Given weights and data, return the averaged loss over all data #\n # points, gradient of parameters, and the probabilities given by #\n # logistic regression. #\n #####################################################################\n f = None\n df = None\n\n f = evaluate(targets, y)[0]\n\n N = len(data)\n M = len(weights) - 1 \n temp = np.ones([N, M + 1])\n temp[: N, : M] = np.array(data)\n\n\n df = np.zeros([M+1, 1])\n\n df[:, 0] = np.array([[np.mean([(y.flatten()[i] - targets.flatten()[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\n\n # df = np.matrix([[np.mean([(y[i] - targets[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\n\n #####################################################################\n # END OF YOUR CODE #\n #####################################################################\n return f, df, y","def get_weights(self, var_id: int, batch_no: int) -> ndarray:\n pass","def readlogfile(file_name):\n F = open(file_name, \"r\")\n M = F.readlines()\n F.close()\n x = []\n y = []\n \n for i in range(len(M)):\n if find(M[i], \"#\") <0:\n # Since the x,y are recorded as, e.g., '[398:402,300:304]'\n x.append(float(M[i].split('[')[1].split(':')[0]) + 2.0)\n y.append(float(M[i].split(',')[1].split(':')[0]) + 2.0)\n \n # Notice this function allows multiple stars to be chosen. For our purposes here,\n # we need pick only one, and so return the first values in the list.\n return x[0], y[0]","def weights_for_doc(self, doc_path: str) -> np.ndarray:\n weights = np.zeros(shape=self.num_terms)\n with open(doc_path, 'r') as f:\n text = f.readline()\n terms = set(text.split())\n for term in terms:\n index = self.vector_mapping[term]\n weights[index] = self.tf_idf_weight(term, doc_path)\n\n return weights","def find_old_log(weight_path):\n pardir = os.path.dirname(weight_path)\n event_paths = glob.glob(os.path.join(pardir, \"event*\"))\n if len(event_paths) == 0:\n return None\n else:\n return event_paths[0]","def load_weights(self, weights_path):\n\n # Open the weights file\n fp = open(weights_path, \"rb\")\n header = np.fromfile(fp, dtype=np.int32, count=5) # First five are header values\n\n # Needed to write header when saving weights\n self.header_info = header\n\n self.seen = header[3]\n weights = np.fromfile(fp, dtype=np.float32) # The rest are weights\n fp.close()\n\n ptr = 0\n for i, (module_def, module) in enumerate(zip(self.module_defs, self.module_list)):\n if module_def[\"type\"] == \"convolutional\":\n conv_layer = module[0]\n if module_def[\"batch_normalize\"]:\n # Load BN bias, weights, running mean and running variance\n bn_layer = module[1]\n num_b = bn_layer.bias.numel() # Number of biases\n # Bias\n bn_b = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.bias)\n bn_layer.bias.data.copy_(bn_b)\n ptr += num_b\n # Weight\n bn_w = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.weight)\n bn_layer.weight.data.copy_(bn_w)\n ptr += num_b\n # Running Mean\n bn_rm = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.running_mean)\n bn_layer.running_mean.data.copy_(bn_rm)\n ptr += num_b\n # Running Var\n bn_rv = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.running_var)\n bn_layer.running_var.data.copy_(bn_rv)\n ptr += num_b\n else:\n # Load conv. bias\n num_b = conv_layer.bias.numel()\n conv_b = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(conv_layer.bias)\n conv_layer.bias.data.copy_(conv_b)\n ptr += num_b\n # Load conv. weights\n num_w = conv_layer.weight.numel()\n conv_w = torch.from_numpy(weights[ptr : ptr + num_w]).view_as(conv_layer.weight)\n conv_layer.weight.data.copy_(conv_w)\n ptr += num_w","def getLog():\n logPath = getLogPath()\n \n with open(logPath) as f:\n log = f.readlines()\n\n cleanedLog = []\n \n for line in log:\n drink = line[0:8]\n cleanedLog.append(drink)\n \n return cleanedLog","def testLogRegres(weights, dev_x, dev_y):\n predict_y = []\n numSamples, numFeatures = np.shape(dev_x)\n for i in range(numSamples):\n if sigmoid(dev_x[i, :] * weights) > 0.5:\n label = 1\n else:\n label = 0\n predict_y.append(label)\n print('Congratulations, testing complete!')\n return predict_y","def get_data_from_state(state):\n data = []\n for column in range(aes.NB):\n for row in range(aes.R):\n data.append(state[row][column])\n return data","def get_data_with_weights(self):\n weights = np.zeros((self.contexts.shape[0], self.num_actions))\n a_ind = np.array([(i, val) for i, val in enumerate(self.actions)])\n weights[a_ind[:, 0], a_ind[:, 1]] = 1.0\n return self.contexts, self.rewards, weights","def logistic_pen(weights, data, targets, hyperparameters):\n\n wr = hyperparameters['weight_regularization']\n \n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\n f_e = data * t\n z_sums = np.sum(f_e, axis=1)\n y = sigmoid(z_sums +weights[-1])\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\n\n f += np.dot(weights[:-1].transpose()[0], weights[:-1].transpose()[0]) * wr / 2\n df = np.reshape(df, ((len(df), 1)))\n df += np.reshape(np.append(weights[:-1] * wr, 0), (len(weights), 1))\n\n f += (weights[-1, 0] ** 2) * wr / 2\n df[-1] += weights[-1,0] * wr \n\n return f, df, np.reshape(y, (len(y), 1))","def WeightFromPro(infile='PROCAR', lsorbit=False):\n\n assert os.path.isfile(infile), '%s cannot be found!' % infile\n FileContents = [line for line in open(infile) if line.strip()]\n\n # when the band number is too large, there will be no space between \";\" and\n # the actual band number. A bug found by Homlee Guo.\n # Here, #kpts, #bands and #ions are all integers\n nkpts, nbands, nions = [int(xx) for xx in re.sub(\n '[^0-9]', ' ', FileContents[1]).split()]\n\n # Weights = np.asarray([line.split()[-1] for line in FileContents\n # if not re.search('[a-zA-Z]', line)], dtype=float)\n Weights = np.asarray([line.split()[1:-1] for line in FileContents\n if not re.search('[a-zA-Z]', line)], dtype=float)\n\n kpt_weight = np.asarray(\n [line.split()[-1] for line in FileContents if 'weight' in line], dtype=float)\n\n energies = np.asarray([line.split()[-4] for line in FileContents\n if 'occ.' in line], dtype=float)\n\n nlmax = Weights.shape[-1]\n nspin = Weights.shape[0] // (nkpts * nbands * nions)\n nspin //= 4 if lsorbit else 1\n\n if lsorbit:\n Weights.resize(nspin, nkpts, nbands, 4, nions, nlmax)\n Weights = Weights[:, :, :, 0, :, :]\n else:\n Weights.resize(nspin, nkpts, nbands, nions, nlmax)\n\n kpt_weight.resize(nspin, nkpts)\n energies.resize(nspin, nkpts, nbands)\n\n return energies, kpt_weight, Weights","def logistic_predict(weights, data):\n\n # TODO: Finish this function\n data = mod_data(data)\n z_array = get_z_array(weights, data)\n return sigmoid(z_array)","def read(filepath, keep=None):\n with open(filepath, 'r') as file:\n lines = file.read().split('\\n')\n\n # Clean the not logs lines\n logs = []\n for line in lines:\n if not line:\n continue\n\n if line[0] != '[' or line[-1] != ']':\n continue\n\n if keep is not None and not keep(line):\n continue\n\n line = line[1:-1] # Remove the first '[' and the last ']'\n pairs = line.split('] [') # Get the key-value pairs\n current = {} # Current log dict\n for pair in pairs:\n key, *values = pair.split(' ')\n current[key] = ' '.join(values)\n logs.append(current)\n\n return logs","def logistic(self, data, weights, biases):\n\n state_weight_prods = np.dot(data, weights)\n print(-state_weight_prods - biases)\n activations = 1.0 / (1 + np.exp(-state_weight_prods - biases))\n plt.plot(state_weight_prods, activations)\n plt.show()\n return activations","def initial_state(self):\n r = np.full((self.xlen, 2), self.log0, dtype=np.float32)\n r[0, 1] = self.log_probs[0, self.blank]\n for i in range(1, self.xlen):\n r[i, 1] = r[i - 1, 1] + self.log_probs[i, self.blank]\n return r","def readData(path): \n try:\n open(path)\n dataset = np.loadtxt(path)\n # arms played by uniformly-random policy as recorded in dataset\n arms = dataset[:, 0].astype(int) \n # rewards received by playing arms using a uniformly-random policy as \n # recorded in dataset \n rewards = dataset[:, 1] \n # context vector \n contexts = dataset[:, 2:] \n except FileNotFoundError: \n raise \n return(arms, rewards, contexts)","def compute_importance_weights(behavior_logits, target_logits, actions):\n logrho = compute_unclipped_logrho(behavior_logits, target_logits, actions)\n print(\"logrho:\", logrho) if debug else None\n print(\"logrho.shape:\", logrho.shape) if debug else None\n\n # change to pytorch version\n return torch.clamp(torch.exp(logrho), max=1.)","def logistic(weights, data, targets, hyperparameters):\n\n # TODO: Finish this function\n\n return f, df, y","def read_b2_transport_inputfile(infileloc, carbon=True):\n with open(infileloc, 'r') as f:\n lines = f.readlines()\n\n ndata = int(\n lines[1].strip().split()[5]) # This is the same for every array in our write routine\n\n rn = np.zeros(ndata)\n dn = np.zeros(ndata)\n ke = np.zeros(ndata)\n ki = np.zeros(ndata)\n if carbon:\n vrc = np.zeros(ndata)\n dc = np.zeros(ndata)\n\n for line_full in lines[2:]:\n line = line_full.strip().split()\n if len(line) < 4: continue\n\n if line[2][0] == '1' and line[3][0] == '1':\n rn[int(line[1][:-1]) - 1] = np.float(line[5])\n dn[int(line[1][:-1]) - 1] = np.float(line[-2])\n\n elif line[2][0] == '3' and line[3][0] == '1':\n ki[int(line[1][:-1]) - 1] = np.float(line[-2])\n\n elif line[2][0] == '4' and line[3][0] == '1':\n ke[int(line[1][:-1]) - 1] = np.float(line[-2])\n\n elif carbon:\n\n if line[2][0] == '1' and line[3][0] == '4':\n dc[int(line[1][:-1]) - 1] = np.float(line[-2])\n\n elif line[2][0] == '6' and line[3][0] == '3':\n vrc[int(line[1][:-1]) - 1] = np.float(line[-2])\n\n if carbon:\n return {'rn': rn, 'dn': dn, 'ki': ki, 'ke': ke, 'dc': dc, 'vrc': vrc}\n else:\n return {'rn': rn, 'dn': dn, 'ki': ki, 'ke': ke}","def read_history (filename) :\n \n col_names = ['i', 't', 'M', 'log_L', 'log_R', 'log_T_s', \n 'log_T_c', 'log_rho_c', 'log_P_c', 'Psi_c', \n 'X_c', 'Y_c', 'X_Cc', 'X_Nc', 'X_Oc', \n 'tau_dyn', 'tau_KH', 'tau_nuc', 'L_PP',\n 'L_CNO', 'L_3a', 'L_Z', 'L_nu', 'M_He',\n 'M_C', 'M_O', 'R_He', 'R_C', 'R_O']\n\n return read_ez_zip(filename, 'summary.txt', col_names)","def read_orderlog(orderlog_path: str) -> list:\n\n order_log = []\n\n reader = csv.DictReader(open(orderlog_path))\n for row in reader:\n order_log.append(row)\n\n return order_log","def read_log_airdata(ac_id, filename):\n f = open(filename, 'r')\n pattern = re.compile(\"(\\S+) \"+ac_id+\" AIR_DATA (\\S+) (\\S+) (\\S+) (\\S+) (\\S+) (\\S+) (\\S+)\")\n list_meas = []\n while True:\n line = f.readline().strip()\n if line == '':\n break\n m = re.match(pattern, line)\n if m:\n list_meas.append([float(m.group(1)), float(m.group(2)), float(m.group(3)), float(m.group(4)), float(m.group(5)), float(m.group(6)), \n float(m.group(7)), float(m.group(8))])\n return np.array(list_meas)","def _read_filter_data(filename):\n gains = []\n freqs = []\n freq_scale = 0\n with open(filename) as f:\n for line in f:\n words = line.split()\n if line.startswith('Freq'):\n _, scale = words[0].split(\"(\")\n scale = scale.rstrip(\")\")\n if scale==\"Hz\":\n freq_scale = 1\n elif scale==\"kHz\":\n freq_scale = 1e3\n elif scale==\"MHz\":\n freq_scale = 1e6\n elif scale==\"GHz\":\n freq_scale = 1e9\n else:\n raise ValueError(\"Cannot parse line: '\"+line+\"'\")\n elif len(words)==3 and words[0]!=\"Total\":\n f, g, p = line.split(\",\")\n freq = float(f) * freq_scale\n gain = float(g)\n phase = float(p)\n freqs.append(freq)\n gains.append(gain * np.exp(1j*phase))\n\n return np.array(gains), np.array(freqs)","def get_hash_log_curr(self):\n if not os.path.exists(self.log_path):\n os.makedirs(self.log_path)\n try:\n log = open(self.log_path + r'\\hash_log.txt', 'U')\n #first line is header, skip\n log.readline()\n for line in log:\n try:\n line = line.replace('\\n','')\n # log maintenance. only keep number of days designated\n line = line.split('|')\n if len(line) != 6:\n raise Exception\n if line[4] > self.log_cut_off_date:\n self.hash_log_curr[line[2]] = line\n except:\n self.print_to_log('Bad log Line: ' + str(line))\n self.print_to_log('Hash Log read Successfully')\n except IOError:\n self.print_to_log('No log found')\n self.hash_log_curr = None\n except IndexError:\n self.print_to_log('Bad Log File')\n raise\n except:\n self.print_to_log('Unknown Error, Exiting ')\n raise","def _get_bps(self, data, weights=None):\n # learn rate is probably redundant for this, since it's effectively a change in nu0 (and alpha0?)\n ndata = data.shape\n ws = np.full(ndata, self.lr)\n if weights is not None: ws *= weights\n mus = [self.mu0]\n nus = [self.nu0]\n alphas = [self.alpha0]\n betas = [self.beta0]\n runCount = 0\n runSum = 0\n runSumSq = 0\n for d,w in zip(data[:-1],ws):\n wp = self.mem # weight for previous data\n runCount = wp*runCount + w\n runSum = wp*runSum + w*d\n runSumSq = wp*runSumSq + w*d**2\n runMean = runSum/runCount\n nup = wp*nus[-1] + w\n # the beta term is a bit difficult. with w.g. 0.5 memory, the variance blows up.\n # this may just be how it works -- w/ less information the variance should explode\n betap = wp*self.beta0 + 0.5*(runSumSq - runCount*runMean**2) + \\\n 0.5*runCount*self.nu0/nup*(runMean - self.mu0)**2 # not sure how to handle these mu0/nu0 w/ forgetting...\n mus.append( (wp*nus[-1]*mus[-1] + w*d)/nup )\n nus.append(nup)\n alphas.append(wp*alphas[-1] + 0.5*w)\n betas.append(betap)\n return np.array(mus),np.array(nus),np.array(alphas),np.array(betas)","def weights(self):\n return [x.numpy() for x in self.core.w]","def forward(self, logits, temperature):\n flat = logits.view(logits.shape[:-2] + (-1,))\n weights = F.softmax(flat / temperature, dim=-1).view_as(logits)\n\n x = (weights.sum(-2) * torch.linspace(-1, 1, logits.shape[-1]).type_as(logits)).sum(-1)\n y = (weights.sum(-1) * torch.linspace(-1, 1, logits.shape[-2]).type_as(logits)).sum(-1)\n\n return torch.stack((x, y), -1), weights","def weights(self, algo):\n weights = np.zeros(\n (self.n_pop, self.states.size(), algo.n_turbines), dtype=FC.DTYPE\n )\n weights[:] = self.states.weights(algo)[None, :, :] / self.n_pop\n return weights.reshape(self.size(), algo.n_turbines)","def _load_wt_file(self, x): \n if type(x) == str:\n # Load file\n x = np.loadtxt(x)\n \n W = x[:self.dimY*self.dimX].reshape(self.dimY,self.dimX)\n W = W.transpose() # convention\n T = x[self.dimY*self.dimX:].reshape(self.dimY,self.dimY) # no need to transpose\n return W, T","def init_e_traces(dim_weights):\n z_trace = np.zeros((dim_weights))\n return z_trace","def read_wave(f):\n # w will be an object of type wave.Wav_read.\n file = file_utils.open_or_fd(f, encoding=None)\n wav = wavio.read(file)\n # see https://github.com/WarrenWeckesser/wavio/blob/master/wavio.py for\n # format of `wav`\n\n # we want data as (num_channels, num_samples).. this is the\n # format that seems most compatible with convolutional code and\n # resampling.\n data = wav.data.swapaxes(0, 1)\n if data.dtype == np.int16:\n data = data.astype(np.float32) * (1.0 / 2**15)\n elif data.dtype == np.int24:\n data = data.astype(np.float32) * (1.0 / 2**23)\n else:\n if data.dtype != np.float32:\n raise RuntimeError(\"Array returned from wavio.read had \"\n \"unexpected dtype \".format(data.dtype))\n return (data, float(wav.rate))","def read_action(path):\n print(\"Reading action data from file \", path)\n\n df = pd.read_csv(path, sep=' ', header=None, engine='python')\n max_state = int(df[0].max())\n min_state = int(df[0].min())\n a_mat = np.zeros((max_state, max_state), dtype='float16')\n\n # for s in np.arange(min_state, max_state + 1):\n for s in np.arange(min_state, max_state + 1):\n df_s = df[df[0] == s]\n for _, row in df_s.iterrows():\n _s = int(row[1])\n p = row[2]\n a_mat[s - 1][_s - 1] = p\n print(\"Finished \", path, \"!\")\n\n return a_mat","def get_weights(self, returns):\n omega = self._get_omega(returns)\n x0 = np.ones([returns.shape[1], 1])/returns.shape[1]\n y0 = np.append(x0, self.newt_lambda0).reshape(-1, 1)\n y = y0 - (np.linalg.pinv(self._get_J(omega, y0)) @ self._get_F(omega, y0))\n error = np.linalg.norm(y-y0, ord=2)\n while error > self.tol:\n y_last = y\n y = y_last - (np.linalg.pinv(self._get_J(omega, y_last)) @ self._get_F(omega, y_last))\n error = np.linalg.norm(y-y_last, ord=2)\n return y[:-1]","def get_weights(self):\n params = self.weights\n return K.batch_get_value(params)","def read_mo_coef(self, path_rwfdump, fn_rwf):\n os.system(path_rwfdump + f\" {fn_rwf} mo_coef.dat 524R\")\n\n with open('mo_coef.dat', \"r\") as f:\n log = f.read()\n\n tmp = re.findall('[-]?\\d+\\.\\d+D[+-]\\d\\d', log)\n tmp = np.array([x.replace('D','e') for x in tmp], dtype=np.float)\n\n tmp_mo = tmp.reshape(self.nbasis, self.nbasis)\n\n return tmp_mo[self.nfc:self.nbasis]","def __initialize_weights__(num_neurons: int) -> np.ndarray:\n\n weights = np.zeros((num_neurons, num_neurons))\n\n return weights","def ReadTinker():\n # Total Potential Energy : {f} Kcal/mole\n total_line = \" Total Potential Energy :\"\n with open('LICHM_TINKEREnergy_0.log') as f:\n for line in f:\n if line.startswith(total_line):\n # print(line)\n TinkE = re.findall(r'\\-\\d+\\.*\\d*', line)\n TinkE = float(TinkE[0])\n # if AMOEBA == True:\n # if line.startswith(\"Polarization\"):\n # Epol = re.findall(r'\\-\\d+\\.*\\d*', line)\n # Epol = float(Epol[0])\n # elif line.startswith(\"Implicit Solvation\")\n # Esolv = re.findall(r'\\-\\d+\\.*\\d*', line)\n # Esolv = float(Esolv[0])\n f.close()\n # if AMOEBA == True:\n # TINKERPolForces = EPol + ESolv\n # TinkE += TINKERPolForces\n #\n TinkE *= kcal2ev\n return TinkE","def weights(self) -> List[float]:","def read_weights(F_DIST):\n global F_DIST_w1, w, num_features, N_IDEN_PROB, MORE_THAN_1_W\n\n # read weights file first line, get json information into a dict\n with open(WEIGHTS_FNAME, \"r\") as f:\n WEIGHTS_FDATA = json.loads(f.readline())\n # has keys LAYERS, J, NUM_FEATURES\n\n # get and verify data from the weights file\n N_IDEN_PROB = WEIGHTS_FDATA['LAYERS']\n MORE_THAN_1_W = (N_IDEN_PROB > 2) # more than 2 layers === more than 1 weight\n if J > WEIGHTS_FDATA['J']:\n raise RuntimeError(\"J in weights file is less than J provided to the \"\n \"script; former >= latter\")\n if WEIGHTS_FDATA['NUM_FEATURES'] != num_features:\n raise RuntimeError(\"num_features in weights file is not the same as \"\n \"num_features provided to this script\")\n\n # read weights file\n # no. of weights is 1 less than no. of layers in weights file\n list_of_w = ad.read_weights_file(\n WEIGHTS_FNAME, N_IDEN_PROB-1, WEIGHTS_FDATA['J'], J, num_features\n )\n list_of_w[-1] = np.expand_dims(list_of_w[-1], axis=2)\n\n # split w[0]; multiply the F_DIST portion of w[0] with F_DIST\n w1_for_fdist, w1_for_r = np.split(list_of_w[0], [num_features-1], axis=1)\n F_DIST_w1 = F_DIST.bmm(torch.from_numpy(w1_for_fdist))\n\n w['first_for_r'] = torch.from_numpy(w1_for_r)\n w['except_first'] = [torch.from_numpy(wi) for wi in list_of_w[1:]]"],"string":"[\n \"def getWeights(self, format='list'):\\n timer = None\\n if conf.config.getboolean(\\\"Reports\\\", \\\"outputTimesForSections\\\"):\\n timer = Timer()\\n timer.start_timing()\\n synapse_list = self._get_synaptic_data()\\n if conf.config.getboolean(\\\"Reports\\\", \\\"outputTimesForSections\\\"):\\n timer.take_sample()\\n \\n if format == 'list':\\n weights = list()\\n for row in synapse_list.get_rows():\\n weights.extend(row.weights)\\n return weights \\n elif format == 'array':\\n weights = numpy.zeros((self.projection_edge.prevertex.atoms, \\n self.projection_edge.postvertex.atoms))\\n rows = synapse_list.get_rows()\\n for pre_atom, row in enumerate(rows):\\n for post_atom, weight in zip(row.target_indices, row.weights):\\n weights[pre_atom][post_atom] = weight\\n return weights\",\n \"def take_log_weights(self, data):\\n\\n n_row = data[:, 0].size\\n log_data = np.zeros(data.shape)\\n for i in xrange(data.shape[0]):\\n idx_nonzero = (data[i, :] > 0).nonzero()[0]\\n log_data[i, idx_nonzero] = np.log(data[i, idx_nonzero])\\n return log_data\",\n \"def _parse_weights(self):\\n\\n # Initialize weights matrix\\n weights = [[-1 for _ in range(self.specification['DIMENSION'])]\\n for _ in range(self.specification['DIMENSION'])]\\n\\n # Cell coordinates iterator\\n cells = self._cells()\\n\\n while True:\\n for value in self._lines.current.split():\\n try:\\n weight = int(value)\\n row, col = next(cells)\\n weights[row][col] = weight\\n except (ValueError, StopIteration):\\n return weights\\n\\n try:\\n next(self._lines)\\n except StopIteration:\\n break\\n\\n return weights\",\n \"def read_fermi_energy_from_log(log_file):\\n with open(log_file, \\\"r\\\") as f:\\n content = f.readlines()\\n ferimiValues = EFermi_Pattern.findall(\\\"\\\".join(content))\\n return list([float(item.split()[1]) for item in ferimiValues])\",\n \"def load_weights(self, weights):\\n weight = np.load(weights)\\n return weight\",\n \"def readWaveform(self):\\n # prepare data holder\\n y = [ 0 for j in range(4) ]\\n # in case of previous errors\\n self.flushInput()\\n for ch in self.chs:\\n # mostly for TDS\\n self.setCh(ch)\\n # calibration factor we will need soon\\n (vmult, voff) = self.calibV()\\n # read and calibrate data\\n data = (numpy.array(self.readData()) - voff) * vmult\\n # This is from the formula in TDS manual, without the\\n # \\\"vzero\\\" in it---I couldn't figure out when that wouldn't\\n # be exactly zero.\\n y[ch-1]=data[:]\\n\\n (hstep, hoff) = self.calibH()\\n # initialize time array\\n t = numpy.array(range(len(y[0])))\\n t = (t * hstep) + hoff\\n\\n # update the sequence number (... for isUpdated())\\n self.seq = self.readSeq()\\n\\n return (t, y)\",\n \"def read_filter(filter_file):\\n\\n fd = open(filter_file, \\\"r\\\")\\n lines = fd.readlines()\\n fd.close()\\n\\n wavelengths = []\\n weights = []\\n for line in lines:\\n line = line.strip()\\n words = line.split()\\n wavelengths.append(float(words[0]))\\n weights.append(float(words[1]))\\n\\n return (wavelengths, weights)\",\n \"def _read_log(self):\\n\\n line_regex = compile(r\\\"\\\\[I\\\\]\\\\s*\\\\(\\\\d+ms\\\\)[^\\\\d]+(?P<counter>\\\\d+)\\\"\\n r\\\"[^\\\\d]+(?P<timestamp>\\\\d+(\\\\.\\\\d+)?)[^\\\\d]+\\\"\\n r\\\"(?P<acceleration>\\\\d+);\\\")\\n values = []\\n with open(self.filepath) as file:\\n for line in file:\\n match = line_regex.match(line)\\n if match:\\n values.append({\\n 'counter':\\n int(match['counter']),\\n 'timestamp':\\n int(float(match['timestamp']) * 1000),\\n 'acceleration':\\n int(match['acceleration'])\\n })\\n\\n self.values = values\",\n \"def log_extract(log_info):\\n \\n #Handle file names, strings and open file-like objects equivalently\\n with uber_open_rmode(log_info) as log_info:\\n \\n headers = []\\n footers = []\\n i = 0\\n \\n #for all lines in file/output\\n for line in log_info:\\n \\n #skip blank lines\\n if len(line.split()) == 0:\\n continue\\n \\n #This is listed before both run and minimize simulations \\n if 'Memory usage per processor =' in line:\\n headers.append(i+1)\\n \\n #This follows both run and minimize simulations\\n elif 'Loop time of' in line:\\n footers.append(i-1)\\n \\n i += 1\\n \\n #Add last line to footers for incomplete logs\\n footers.append(i)\\n \\n log_info.seek(0)\\n \\n #Create DataModelDict root\\n log_dict = DM()\\n log_dict['LAMMPS-log-thermo-data'] = DM()\\n \\n #for all lines in file/output\\n for header, footer in zip(headers, footers):\\n\\n #Read thermo data\\n df = pd.read_csv(log_info, header=header, nrows=footer-header, sep='\\\\s+', engine='python', skip_blank_lines=True)\\n log_info.seek(0) \\n\\n #Convert to DataModelDict\\n thermo = DM()\\n for j in df:\\n thermo[str(j)] = df[j].values.tolist()\\n \\n #Append simulation results to DataModelDict root\\n simulation = DM([('thermo', thermo)])\\n log_dict['LAMMPS-log-thermo-data'].append('simulation', simulation)\\n \\n return log_dict\",\n \"def readLogAmat(path): \\n # Open file\\n f = open(path, 'r')\\n # initialize variables\\n out = {}\\n lines = f.readlines()\\n\\n # Read input image path pattern\\n out[TrackingAnalysis.IMAGE_PATH_KEY] = lines[4].split('=')[1][:-1] + '.tif'\\n # Read Z-Anisotrpy of the image\\n out[TrackingAnalysis.ANISOTROPY_KEY] = float(lines[20].split('=')[1][:-1])\\n times = lines[1].strip().split()\\n out[TrackingAnalysis.TIME_INI_KEY] = int(times[-2])\\n out[TrackingAnalysis.TIME_END_KEY] = int(times[-1])\\n\\n # close file\\n f.close()\\n\\n return out\",\n \"def weights(self):\\n return np.array(self.intensity[self.idx])\",\n \"def load_SCF_wealth_weights():\\n with open(DATASETS + \\\"SCFwealthDataReduced.txt\\\") as f:\\n SCF_reader = csv.reader(f, delimiter=\\\"\\\\t\\\")\\n SCF_raw = list(SCF_reader)\\n SCF_wealth = np.zeros(len(SCF_raw)) + np.nan\\n SCF_weights = deepcopy(SCF_wealth)\\n for j in range(len(SCF_raw)):\\n SCF_wealth[j] = float(SCF_raw[j][0])\\n SCF_weights[j] = float(SCF_raw[j][1])\\n return SCF_wealth, SCF_weights\",\n \"def load_hrpsys_log_rstate(rstate_path, angle_unit=\\\"deg\\\"):\\n\\n rstate = np.loadtxt(rstate_path, comments=\\\"%\\\")\\n if rstate.shape[1] != 100:\\n sys.exit([rstate_path, \\\" is not a valid \\\" \\\"*-rstate.log\\\" \\\" file\\\"])\\n\\n m = rstate.shape[0]\\n dt = \\\"f4\\\"\\n r = np.zeros(\\n m,\\n dtype=[\\n (\\\"enc\\\", dt, 40),\\n (\\\"jvelocity\\\", dt, 40),\\n (\\\"acc\\\", dt, 3),\\n (\\\"zmp\\\", dt, 3),\\n (\\\"waist_p\\\", dt, 3),\\n (\\\"waist_rot\\\", dt, 9),\\n (\\\"time\\\", dt, 1),\\n (\\\"controltimev2\\\", dt, 1),\\n (\\\"type\\\", \\\"a6\\\"),\\n (\\\"ang_type\\\", \\\"a3\\\"),\\n ],\\n )\\n r[\\\"enc\\\"] = rstate[:, 0:40]\\n # JA0-JA39\\n r[\\\"jvelocity\\\"] = rstate[:, 40:80]\\n #\\n r[\\\"acc\\\"] = rstate[:, 80:83]\\n #\\n r[\\\"zmp\\\"] = rstate[:, 83:86]\\n #\\n r[\\\"waist_p\\\"] = rstate[:, 86:89]\\n # waistPX-waistPZ\\n r[\\\"waist_rot\\\"] = rstate[:, 89:98]\\n # waistQX-waistQW (rot matrix)\\n r[\\\"time\\\"] = rstate[:, 98]\\n # clockv2\\n r[\\\"controltimev2\\\"] = rstate[:, 99]\\n # ControlTimeV2\\n\\n r[\\\"type\\\"] = \\\"rstate\\\"\\n r[\\\"ang_type\\\"] = \\\"rad\\\"\\n\\n if angle_unit == \\\"deg\\\":\\n r[\\\"enc\\\"] = 180 / np.pi * r[\\\"enc\\\"]\\n # Joint angles in degrees\\n r[\\\"ang_type\\\"] = \\\"deg\\\"\\n print(\\\"Warning: joint angles (astate) in degrees!\\\")\\n\\n return r\",\n \"def read_w_matrix(filepath, hnodes=400, epochs=5):\\n \\n filename_wih = filepath + f\\\"hn{hnodes}_wih_epoch_{epochs}.csv\\\"\\n filename_who = filepath + f\\\"hn{hnodes}_who_epoch_{epochs}.csv\\\"\\n wih = numpy.loadtxt(filename_wih)\\n who = numpy.loadtxt(filename_who)\\n\\n return wih, who\",\n \"def read_file(log_file):\\n\\t\\tfile = open(log_file, 'r')\\n\\t\\tresult = []\\n\\t\\twhile 1:\\n\\t\\t\\tcontent = file.readline()\\n\\t\\t\\tif not content:\\n\\t\\t\\t\\tbreak\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdata = content.split(\\\"\\\\003\\\")\\n\\t\\t\\t\\tif len(data) == 13:\\n\\t\\t\\t\\t\\ttrack = {\\n\\t\\t\\t\\t\\t\\t\\t 'device_no' : long(data[0][3:]), 'sim' : data[1], 'type':int(data[2]), 'gps_time' : MongoTrack.time_trans(data[3]),\\n\\t\\t\\t\\t\\t\\t\\t 'valid' : data[4], 'loc':{'long' : float(data[5]), 'lat' : float(data[6]) }, 'altitude' : float(data[7]),\\n\\t\\t\\t\\t\\t\\t\\t 'speed' : float(data[8]), 'course' : float(data[9]), 'km' : float(data[10]), 'para' : float(data[11]),\\n\\t\\t\\t\\t\\t\\t\\t 'rtime' : MongoTrack.time_trans(data[12].strip())\\n\\t\\t\\t\\t\\t\\t\\t}\\n\\t\\t\\t\\t\\tresult.append(track)\\n\\t\\tfile.close()\\n\\t\\treturn result\",\n \"def read_trajectory(filename, n_parameters=3):\\r\\n\\r\\n with open(filename) as f:\\r\\n n_cols = len(f.readline().split(' '))\\r\\n\\r\\n trajectories = np.loadtxt(filename, dtype=float, delimiter=' ', usecols=range(1, n_cols))\\r\\n\\r\\n n_birds = int((n_cols - 1) / n_parameters)\\r\\n n_time_steps = np.shape(trajectories)[0]\\r\\n\\r\\n trajectories = trajectories.flatten(order='F') # Need to be flattened in this way to format correctly\\r\\n trajectories = np.reshape(trajectories, (n_birds, n_parameters, n_time_steps))\\r\\n\\r\\n return trajectories\",\n \"def parseBowtieLog(fileName):\\n if not os.path.isfile(fileName):\\n print \\\"WARNING: \\\" +fileName+\\\" does not exist.\\\"\\n return 0,0,0,0 \\n\\n processed,aligned,unaligned,ambig=0,0,0,0\\n with open(fileName,'rb') as bowtieLogFile:\\n for line in bowtieLogFile.readlines():\\n if 'reads processed' in line:\\n processed=line.split(':')[1].strip()\\n elif 'reads with at least one reported alignment' in line:\\n aligned=line.split(':')[1].split(' ')[1]\\n elif 'reads that failed to align' in line:\\n unaligned=line.split(':')[1].split(' ')[1]\\n elif 'reads with alignments suppressed' in line:\\n ambig=line.split(':')[1].split(' ')[1]\\n\\n return int(processed),int(aligned),int(unaligned),int(ambig)\",\n \"def readtxt(obslog):\\n\\n logger = log.getLogger('obslog.readtxt')\\n\\n if not os.path.exists(obslog):\\n logger.error('Cannot access %s', obslog)\\n raise SystemExit\\n\\n logger.info('Reading %s', obslog)\\n\\n with open(obslog) as f: # Since we will have to go through the data twice, read the whole file at once.\\n data = f.readlines()\\n\\n header = ['Observation ID', 'Data Labels', 'File Numbers', 'Dataset UT', 'Target Name', 'Filters', 'Slit',\\n 'Grating/Wavelength', 'Camera/Prism', 'ExpTime/LNR/Coadds', 'ACQ']\\n\\n pattern = dict() # Enforce formatting rules to avoid parsing comments as data:\\n pattern['Observation ID'] = re.compile(r'^G[NS]-[0-9]{4}[AB]-([CQ]|DD|FT|LP|SV)-[0-9]{0,3}-[0-9]+$')\\n pattern['Data Labels'] = re.compile(r'[0-9]+-*[0-9]*') # 1, 2-3, 45-67, 890-1234\\n pattern['File Numbers'] = re.compile(r'[0-9]+-*[0-9]*') # 1, 2-3, 45-67, 890-1234\\n pattern['Dataset UT'] = re.compile(r'^[0-9]{2}:[0-9]{2}:[0-9]{2}$') # 09:58:15\\n pattern['Target Name'] = re.compile(r'[a-zA-Z0-9_-]+') # Match any string\\n pattern['Filters'] = re.compile(r'[A-Z0-9\\\\-]+') # H, XD, H2, X, J, H\\n pattern['Slit'] = re.compile(r'[a-zA-Z0-9]+') # 0.675, ACQ, LgPin\\n pattern['Grating/Wavelength'] = re.compile(r'[0-9]{2,3}/[0-9]\\\\.[0-9]{2}') # 32/1.65, 111/1.68\\n pattern['Camera/Prism'] = re.compile(r'[A-Z]{2}/[A-Z]{3}') # LB/MIR, SB/SXD\\n pattern['ExpTime/LNR/Coadds'] = re.compile(r'[0-9]+\\\\.[0-9]/[0-9]+/[0-9]+') # 0.2/1/25, 300.0/32/1\\n pattern['ACQ'] = re.compile(r'^Y*$') # Y or ''\\n\\n indx = {}\\n for line in data:\\n if 'Electronic Observing Log' in line:\\n date = line.split()[-1][7:]\\n logger.debug('Log date: %s', date)\\n if line[0:14] == 'Observation ID': # This defines the start of the header row\\n for h in header:\\n indx[h] = line.find(h) # Find where each column starts\\n break # No need to go farther\\n\\n width = {} # Find the width of each row\\n for i in range(len(header) - 1): # This requires that 'header' be an ordered array (not a dictionary)\\n width[header[i]] = indx[header[i + 1]] - indx[header[i]]\\n width[header[i+1]] = 1 # The ACQ field is either 'Y' or blank\\n\\n val = {}\\n match = {}\\n info = {}\\n for line in data:\\n logger.debug('\\\\n%s', line)\\n files = []\\n for h in header:\\n val[h] = line[indx[h]: indx[h] + width[h]].strip()\\n match[h] = re.match(pattern[h], val[h])\\n logger.debug('%s: \\\"%s\\\" %s' % (h, val[h], match[h]))\\n\\n # Maybe throw a warning if only match 1 fails; indicating a likely bad pattern specification?\\n\\n if None in match.values():\\n logger.debug('Failed to match all patterns -> This is a comment')\\n continue\\n\\n if '-' in val['File Numbers']:\\n start, stop = val['File Numbers'].split('-')\\n for i in range(int(start), int(stop)+1):\\n files.append(i)\\n else:\\n files.append(int(val['File Numbers']))\\n\\n for filenum in files:\\n f = 'N%sS%04d.fits' % (date, filenum)\\n logger.debug('File: %s', f)\\n info[f] = {}\\n for h in [header[0]] + header[3:]: # Skip 'Data Labels' and \\\"File Numbers'\\n info[f][h] = val[h]\\n\\n logger.debug('info: %s', info)\\n return info\",\n \"def get_data_sample(log_path, num_samples):\\n\\n img_list = []\\n\\n log_list = read_driving_log(log_path)\\n\\n log_list_sample = log_list[:num_samples]\\n\\n for row in log_list_sample:\\n image_path = row['center']\\n\\n if not os.path.isabs(image_path):\\n image_path = os.path.join(IMAGE_DIR, image_path)\\n\\n image = load_image(image_path, IMAGE_SIZE)\\n img_list.append(image)\\n\\n features_sample = np.array(img_list).astype('float32')\\n\\n steering_angle = np.array([float(log['steering']) for log in log_list_sample])\\n\\n labels_sample = steering_angle\\n\\n return features_sample, labels_sample\",\n \"def loadatran(filename, wl=True, verbose=False):\\n # 2008-08-21 09:42 IJC: Created to save myself a bit of time\\n # 2008-08-25 10:08 IJC: Read in all lines at once; should go\\n # faster with sufficient memory\\n # 2008-09-09 13:56 IJC: Only convert the wavelength and flux\\n # columns(#1 & #2) -- speed up slightly.\\n if filename.__class__==list:\\n returnlist = []\\n for element in filename:\\n returnlist.append(loadatran(element, wl=wl))\\n return returnlist\\n \\n f = open(filename, 'r')\\n dat = f.readlines()\\n f.close()\\n if verbose:\\n print dat[0]\\n print dat[0].split()\\n print dat[0].split()[1:3]\\n print dat[0].split()[2]\\n \\n if wl:\\n data = array([map(float, line.split()[1:3]) for line in dat])\\n else:\\n data = array([float(line.split()[2]) for line in dat])\\n\\n return data\",\n \"def process_log(log_file):\\n result_list = []\\n file_root = get_fname_root(log_file)\\n\\n with open(log_file) as l_file:\\n reading_steps = False\\n result_dict = {}\\n for line in l_file:\\n line = line.strip()\\n if STEP_PAT.match(line):\\n reading_steps = True\\n result_dict[FILE_NAME] = file_root\\n result_dict[TIMESTEP] = int(line.split()[2])\\n elif reading_steps:\\n if len(line) == 0:\\n break\\n s_line = line.split()\\n if s_line[0] == TOTENG:\\n for key_id, key in enumerate([TOTENG, KINENG, TEMP]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n elif s_line[0] == POTENG:\\n for key_id, key in enumerate([POTENG, E_BOND, E_ANGL]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n elif s_line[0] == E_DIHED:\\n for key_id, key in enumerate([E_DIHED, E_IMPRO, E_VDWL]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n elif s_line[0] == E_COUL:\\n for key_id, key in enumerate([E_COUL, E_LONG, PRESS]):\\n result_dict[key] = float(s_line[2 + key_id * 3])\\n result_list.append(dict(result_dict))\\n else:\\n # when stop matching, done reading file (either by normal or abnormal termination)\\n break\\n\\n return result_list\",\n \"def log_weights(self):\\n m = self.kernel.feature_log_prob_[self._match_class_pos()]\\n u = self.kernel.feature_log_prob_[self._nonmatch_class_pos()]\\n\\n return self._prob_inverse_transform(m - u)\",\n \"def read_stats_in_log(model_tarfile):\\n # log file is YYYY0101.fms.out\\n log_filename = os.path.basename(model_tarfile).replace(\\\"ascii_out.tar\\\", \\\"fms.out\\\")\\n year = int(os.path.basename(model_tarfile).replace(\\\"0101.ascii_out.tar\\\", \\\"\\\"))\\n\\n if not log_filename.startswith('./'):\\n log_filename = './' + log_filename\\n\\n with tarfile.open(model_tarfile, \\\"r:\\\") as f:\\n logdump = f.extractfile(log_filename).read().decode('utf-8')\\n\\n lines = logdump.split(sep='\\\\n')\\n\\n linestart_stats = [lines.index(line) for line in lines if line.find('Total runtime') != -1 ][-1]\\n lineend_stats = [lines.index(line) for line in lines if line.find('high water mark') != -1 ][-1]\\n\\n raw_stats = lines[linestart_stats-1:lineend_stats]\\n\\n # infer the number of data columns\\n columns = raw_stats[0].split()\\n ncol_data = len(columns)\\n # add a column for model component\\n columns = ['model'] + columns\\n formatted_lines = []\\n for line in raw_stats[1:]:\\n data = line.split()[-ncol_data:]\\n data_num = []\\n for item in data:\\n data_num.append(float(item))\\n line = line.replace(item, '')\\n modelname = line.strip()\\n formatted_line = [modelname] + data_num\\n formatted_lines.append(formatted_line)\\n\\n df = pd.DataFrame(formatted_lines, columns = columns)\\n df['year'] = year\\n\\n return df\",\n \"def log_weights_statistics(self):\\n for weight_name, weight_parameter in self._weights.items():\\n for statistic_function in self._statistics_functions:\\n self._weights_statistics[statistic_function.__name__][\\n weight_name\\n ].append(float(statistic_function(weight_parameter)))\",\n \"def read(self, w):\\n\\n self.assert_valid_weights(w)\\n\\n return w.dot(self.memory)\",\n \"def logistic_predict(weights, data):\\n \\n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\\n f_e = data * t\\n z_sums = np.sum(f_e, axis=1) \\n \\n x = -z_sums - weights[-1]\\n y = sigmoid(z_sums + weights[-1])\\n\\n return np.reshape(y, (len(y), 1))\",\n \"def get_thermo(self, structure):\\n dir = IO(dir=os.path.join(self.loc, structure))\\n values = dir.get_values(\\n structure, \\\"freq.log\\\", self.freqvalid, self.thermo_vals)\\n \\n return values\",\n \"def _read_data(filename):\\n file = open(filename, \\\"r\\\")\\n timestamps = []\\n edges = []\\n for line in file:\\n # source target weight timestamp\\n if line.startswith(\\\"%\\\"):\\n continue\\n spl = line.split()\\n if len(spl) == 4:\\n # store that stuff in triples (source, target, weight, timestamp)\\n edges.append((int(spl[0]), int(spl[1]), int(spl[2]), int(spl[3])))\\n timestamps.append(int(spl[3]))\\n return edges, sorted(timestamps)\",\n \"def logistic_predict(weights, data):\\n\\n # TODO: Finish this function\\n\\n return y\",\n \"def weights_(self):\\n return self.get_tensor_value('logistic_regression/weights:0')\",\n \"def all_modes(self):\\n\\n with open(f'gj_{self.molecule.name}.log', 'r') as gj_log_file:\\n\\n lines = gj_log_file.readlines()\\n freqs = []\\n\\n # Stores indices of rows which will be used\\n freq_positions = []\\n for count, line in enumerate(lines):\\n if line.startswith(' Frequencies'):\\n freq_positions.append(count)\\n\\n for pos in freq_positions:\\n freqs.extend(float(num) for num in lines[pos].split()[2:])\\n\\n return array(freqs)\",\n \"def load_log(filename):\\n\\tlogfile = open(directory + filename, \\\"r\\\")\\n\\tlog = logfile.read().splitlines()\\n\\tlog = [float(i) for i in log]\\n\\tlogfile.close()\\n\\treturn log\",\n \"def logistic(weights, data, targets, hyperparameters):\\n \\n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\\n f_e = data * t\\n z_sums = np.sum(f_e, axis=1)\\n y = sigmoid(z_sums +weights[-1])\\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\\n df = np.reshape(df, ((len(df), 1)))\\n\\n return f, df, np.reshape(y, (len(y), 1))\",\n \"def read(dir, fname, maxtime):\\n solution = [0, maxtime, 0, 'UNK', 0, 'unknown', 'CHU', 0]\\n try:\\n logfile = open(os.path.join(dir, fname + '+CHU.log'), 'r', encoding='utf8')\\n except FileNotFoundError:\\n return solution\\n sndlast = \\\"\\\"\\n last = \\\"\\\"\\n rstat = \\\"\\\"\\n nbsol=0\\n for line in logfile:\\n if re.search(ropt, line):\\n sndlast = last\\n last = line\\n if re.search(status, line):\\n rstat = line\\n # get the last solution, there should be at least one\\n # line = line.replace(',', '')\\n\\n last = last.replace('s', '')\\n parts = last.split()\\n sndlast = sndlast.replace('s', '')\\n sndparts = sndlast.split()\\n\\n if len(parts) > 0:\\n if len(sndparts) > 0 and parts[1] == sndparts[1]:\\n parts = sndparts\\n solution[0] = int(parts[2]) # nb solutions\\n solution[1] = float(parts[5][:-1]) # time\\n solution[2] = int(parts[6]) # nodes\\n solution[3] = 'MIN' # res. policy\\n solution[4] = int(parts[1][:-1]) # obj. value\\n if rstat == \\\"\\\":\\n solution[5] = ' ' # res. status\\n elif rstat == comp or rstat == unsa:\\n solution[5] = 'proof' # res. status\\n elif rstat == unbo:\\n solution[5] = 'unbounded' # res. status\\n\\n return solution\",\n \"def get_weights(self, index):\\n weight = self._weights[index]\\n if isinstance(weight, dict):\\n return list(weight.items())\\n else:\\n return [(Term(\\\"t\\\"), weight)]\",\n \"def read_data(self, path):\\n if self.data_format == 'twenty': \\n length = 20\\n else: raise ValueError(\\\"self.data_format = '%s' unknown.\\\" % \\n self.data_format)\\n data = []\\n with open(path,'r') as f:\\n for line in f:\\n data.append([float(line[k:(k + length)]) for k in range(\\n 0, len(line.strip('\\\\n')),length)])\\n return np.array(data)\",\n \"def read_state_matrices():\\r\\n drum_mats = glob.glob('./Melody_Bass_Data/*_bass.txt')\\r\\n melody_mats = glob.glob('./Melody_Bass_Data/*_melody.txt')\\r\\n \\r\\n drum_states = []\\r\\n melody_states = []\\r\\n\\r\\n for drum_mat,melody_mat in zip(drum_mats[:20],melody_mats[:20]):\\r\\n temp= np.genfromtxt(drum_mat)\\r\\n drum_states.append(temp)\\r\\n temp= np.genfromtxt(melody_mat)\\t\\r\\n melody_states.append(temp)\\r\\n \\r\\n return drum_states,melody_states\",\n \"def _get_weights_and_simpoints_from_file(\\n self,\\n ) -> Tuple[List[int], List[int]]:\\n simpoint_weight_pair = []\\n with open(self.get_simpoint_file()) as simpoint_file, open(\\n self.get_weight_file()\\n ) as weight_file:\\n while True:\\n line = simpoint_file.readline()\\n if not line:\\n break\\n interval = int(line.split(\\\" \\\", 1)[0])\\n line = weight_file.readline()\\n if not line:\\n fatal(\\\"not engough weights\\\")\\n weight = float(line.split(\\\" \\\", 1)[0])\\n simpoint_weight_pair.append((interval, weight))\\n simpoint_weight_pair.sort(key=lambda obj: obj[0])\\n # use simpoint to sort\\n\\n weight_list = []\\n simpoint_list = []\\n for simpoint, weight in simpoint_weight_pair:\\n simpoint_list.append(simpoint)\\n weight_list.append(weight)\\n return simpoint_list, weight_list\",\n \"def read_weight(self, stream):\\r\\n \\r\\n return self.data_to_weight(self.read_postvalue(stream))\",\n \"def log_ess(log_weight):\\n dim = 1 if log_weight.ndimension() == 2 else 0\\n\\n return 2 * torch.logsumexp(log_weight, dim=dim) - \\\\\\n torch.logsumexp(2 * log_weight, dim=dim)\",\n \"def read_linelog():\",\n \"def _extract_weights(self,W):\\n wl1_size = self._D*self._hidden_layer_size\\n bl1_size = self._hidden_layer_size\\n \\n wl2_size = self._hidden_layer_size*self._output_size\\n bl2_size = self._output_size\\n\\n \\n weights_L1 = W[0:wl1_size].reshape((self._D,self._hidden_layer_size))\\n bias_L1 = W[wl1_size:wl1_size+bl1_size]\\n \\n start_l2 = wl1_size+bl1_size\\n\\n weights_L2 = W[start_l2: start_l2 + wl2_size].reshape((self._hidden_layer_size,self._output_size))\\n bias_L2 = W[start_l2 + wl2_size : start_l2 + wl2_size + bl2_size]\\n \\n \\n \\n return weights_L1,bias_L1,weights_L2,bias_L2\",\n \"def parse_log(path_to_log):\\n regex_iteration = re.compile('Iteration (\\\\d+), loss = ([\\\\.\\\\deE+-]+)')\\n regex_train_output = re.compile('Train net output #(\\\\d+): (\\\\S+) = ([\\\\.\\\\deE+-]+)')\\n regex_learning_rate = re.compile('lr = ([\\\\.\\\\deE+-]+)')\\n regex_test_output = re.compile('Test net output #(\\\\d+): detection_eval = ([\\\\.\\\\deE+-]+)')\\n\\n\\n # Pick out lines of interest\\n iteration = 0\\n loss = -1\\n learning_rate = 0.001\\n train_dict_list = []\\n train_row = None\\n test_score=0.0\\n\\n logfile_year = extract_seconds.get_log_created_year(path_to_log)\\n with open(path_to_log) as f:\\n start_time = extract_seconds.get_start_time(f, logfile_year)\\n last_time = start_time\\n\\n for line in f:\\n iteration_match = regex_iteration.search(line)\\n if iteration_match:\\n iteration = float(iteration_match.group(1))\\n loss = float(iteration_match.group(2))\\n try:\\n time = extract_seconds.extract_datetime_from_line(line,\\n logfile_year)\\n except:\\n # Skip lines with bad formatting, for example when resuming solver\\n continue\\n\\n # if it's another year\\n if time.month < last_time.month:\\n logfile_year += 1\\n time = extract_seconds.extract_datetime_from_line(line, logfile_year)\\n last_time = time\\n\\n seconds = (time - start_time).total_seconds()\\n\\n learning_rate_match = regex_learning_rate.search(line)\\n\\n if learning_rate_match:\\n learning_rate = float(learning_rate_match.group(1))\\n\\n test_score_match = regex_test_output.search(line)\\n if test_score_match:\\n test_score = float(test_score_match.group(2))\\n\\n train_dict_list, train_row = parse_line_for_net_output(\\n regex_train_output, train_row, train_dict_list,\\n line, iteration, seconds, learning_rate,loss,test_score\\n )\\n\\n\\n return train_dict_list\",\n \"def read_log_payload(ac_id, filename):\\n f = open(filename, 'r')\\n pattern = re.compile(\\\"(\\\\S+) \\\"+ac_id+\\\" PAYLOAD_FLOAT (\\\\S+),(\\\\S+),(\\\\S+),(\\\\S+)\\\")\\n list_meas = []\\n while True:\\n line = f.readline().strip()\\n if line == '':\\n break\\n m = re.match(pattern, line)\\n if m:\\n list_meas.append([float(m.group(1)), float(m.group(2)), float(m.group(3)), float(m.group(4)), float(m.group(5))])\\n return np.array(list_meas)\",\n \"def logistic_predict(weights, data):\\n #####################################################################\\n # TODO: #\\n # Given the weights and bias, compute the probabilities predicted #\\n # by the logistic classifier. #\\n #####################################################################\\n \\n y = None\\n N = len(data)\\n M = len(weights) - 1\\n temp = np.ones([N, M + 1])\\n temp[: N, : M] = np.array(data)\\n data = temp\\n\\n\\n\\n # print(np.matmul(data, weights).shape)\\n z = np.matmul(data, weights)\\n y = sigmoid(z)\\n #####################################################################\\n # END OF YOUR CODE #\\n #####################################################################\\n return y\",\n \"def get_weights(self):\\n return self.weights\\n #print(W)\",\n \"def read(filename):\\n\\n fileName, fileExtension = os.path.splitext(filename)\\n wav_filename = filename\\n rate, data = scipy.io.wavfile.read(str(wav_filename)) # the data is read in its native format\\n if data.dtype =='int16':\\n data = numpy.cast['float'](data)\\n return [rate,data]\",\n \"def data_from_tracecomp_file():\\n data = '' # assume file will have more thant [MAX_DIFF_LINE] lines\\n with open(TRACECOMP_OUT_FILE) as f:\\n for i, line in enumerate(f):\\n if i == LOGLIK_LINE:\\n data = line\\n\\n parsed_data = re.sub(r'\\\\s+', ' ', data).split(' ')\\n loglik_effsize = int(parsed_data[1])\\n loglik_rel_diff = float(parsed_data[2])\\n return loglik_effsize, loglik_rel_diff\",\n \"def read_wavetxt(path):\\n with open(path) as f:\\n for line in f.readlines():\\n line = line.strip()\\n if 'SampleFrequence' in line:\\n freq = int(line[16:])\\n elif 'DataInput' in line:\\n series = np.array(line[10:].split(',')).astype(np.float64)\\n return (freq, series)\",\n \"def get_weight_matrix(self):\\n\\n\\t\\treturn self.weights.get_value(borrow=True)\",\n \"def readMcmcLog(fname, par):\\n\\t# find params that varied\\n\\tfor line in open(fname):\\n\\t\\tif line.startswith('##'):\\n\\t\\t\\tlabels = line.split()[1:]\\n\\t\\t\\tlabels = np.array(labels, dtype=str)\\n\\t\\t\\tbreak\\n\\t#read data and select the desired parameter\\n\\tdata = np.loadtxt(fname)\\n\\toi = data[:, (labels==par)]\\n\\tif len(oi) == 0:\\n\\t\\tprint \\\"!!ERROR finding that parameter in log file!!\\\"\\n\\tprint \\\"Read %d points from %s\\\"%(len(oi),fname)\\n\\treturn oi\",\n \"def ExtractRequestsFromLog(log_path):\\n requests = []\\n wpr_http_netloc = None\\n with open(log_path) as log_file:\\n for line in log_file.readlines():\\n # Extract WPR's HTTP proxy's listening network location.\\n match = _PARSE_WPR_DOMAIN_REGEX.match(line)\\n if match:\\n wpr_http_netloc = match.group('netloc')\\n assert wpr_http_netloc.startswith('127.0.0.1:')\\n continue\\n # Extract the WPR requested URLs.\\n match = _PARSE_WPR_URL_REGEX.match(line)\\n if match:\\n parsed_url = urlparse(match.group('url'))\\n # Ignore strange URL requests such as http://ousvtzkizg/\\n # TODO(gabadie): Find and terminate the location where they are queried.\\n if '.' not in parsed_url.netloc and ':' not in parsed_url.netloc:\\n continue\\n assert wpr_http_netloc\\n request = WprRequest(is_served=(match.group('level') == 'DEBUG'),\\n method=match.group('method'), url=match.group('url'),\\n is_wpr_host=parsed_url.netloc == wpr_http_netloc)\\n requests.append(request)\\n return requests\",\n \"def read_feature_weights(fwfile, xvals):\\n\\n # If no file was specified, skip this step.\\n if fwfile == '': # default\\n return []\\n\\n if not os.path.exists(fwfile):\\n printt(' Could not find feature weight file %s, skipping.' % fwfile)\\n return []\\n\\n printt('Treating feature-weight argument as a file name (%s).' % fwfile)\\n # Read in the feature-weight file\\n f = open(fwfile)\\n lines = f.readlines()\\n if len(lines) != len(xvals):\\n raise ValueError('Looking for %d weights, but got %d.' % (len(xvals), len(lines)))\\n\\n wolf = [-1] * len(xvals)\\n for (i,line) in enumerate(lines):\\n values = line.split()\\n\\n # Sanity check that we have one of two cases:\\n # 1. One weight per line\\n if len(values) == 1:\\n wolf[i] = float(values[0])\\n\\n # 2. Two values per line (feature - matches xvals, weight)\\n elif len(values) == 2:\\n values = list(map(float, values))\\n feat_ind = np.where(xvals == values[0])[0]\\n if len(feat_ind) == 0:\\n raise ValueError('Could not find feature %s.' % values[0])\\n wolf[feat_ind[0]] = values[1]\\n\\n # Check that feature weights are valid\\n for weight in wolf:\\n if weight < 0 or weight > 1:\\n raise ValueError(\\\"Weights must be between 0 and 1.\\\")\\n \\n return wolf\",\n \"def get_csv_data(log_file):\\r\\n image_names, steering_angles = [], []\\r\\n # Steering offset used for left and right images\\r\\n steering_offset = 0.275\\r\\n with open(log_file, 'r') as f:\\r\\n reader = csv.reader(f)\\r\\n next(reader, None)\\r\\n for center_img, left_img, right_img, angle, _, _, _ in reader:\\r\\n angle = float(angle)\\r\\n image_names.append([center_img.strip(), left_img.strip(), right_img.strip()])\\r\\n steering_angles.append([angle, angle + steering_offset, angle - steering_offset])\\r\\n\\r\\n return image_names, steering_angles\",\n \"def load(fname):\\r\\n try:\\r\\n with open(fname, 'r') as f:\\r\\n V, H = (int(a) for a in next(f).split())\\r\\n W, i2w, w2i = np.zeros((V, H)), [], {}\\r\\n for i, line in enumerate(f):\\r\\n parts = line.split()\\r\\n word = parts[0].strip()\\r\\n w2i[word] = i\\r\\n W[i] = list(map(float, parts[1:]))\\r\\n i2w.append(word)\\r\\n return W, i2w, w2i, V, H\\r\\n except:\\r\\n print(\\\"Error: failing to load the model to the file\\\")\",\n \"def read_rationals(self, count=1, location=None):\\n return_vals = []\\n if self._tiff is not None:\\n off = self._offset\\n if location is not None:\\n off = location\\n for c in range(count):\\n num = int.from_bytes(self._tiff[off:off + 4], byteorder=self._byteorder)\\n denom = int.from_bytes(self._tiff[off+4:off + 8], byteorder=self._byteorder)\\n return_vals.append((num, denom))\\n off += 8\\n if location is None:\\n self._offset += (count * 8)\\n return return_vals\",\n \"def _get_weight(self, weight):\\n if isinstance(weight, pd.DataFrame):\\n pass\\n elif isinstance(weight, str):\\n if weight.endswith(\\\"gctx\\\"):\\n from cmapPy.pandasGEXpress.parse import parse\\n weight = parse(weight).data_df\\n elif weight.endswith(\\\"csv\\\"):\\n weight = pd.read_csv(weight)\\n else:\\n weight = pd.read_table(weight)\\n else:\\n raise Exception(\\\"Unsupported file format\\\")\\n\\n assert weight.shape[1] == 979 # first column is offset\\n\\n return weight\",\n \"def get_weights(model) -> Weights:\\n return [val.cpu().numpy() for _, val in model.state_dict().items()]\",\n \"def _get_temp_raw(self):\\n try: \\n f = open(self.device_file, 'r')\\n lines = f.readlines()\\n f.close()\\n return lines\\n\\n except: \\n print(\\\"ERROR: w1_slave file could not be opened (temp sensor)\\\")\",\n \"def get_weights(self):\",\n \"def logistic(weights, data, targets, hyperparameters):\\n y = logistic_predict(weights, data)\\n\\n #####################################################################\\n # TODO: #\\n # Given weights and data, return the averaged loss over all data #\\n # points, gradient of parameters, and the probabilities given by #\\n # logistic regression. #\\n #####################################################################\\n f = None\\n df = None\\n\\n f = evaluate(targets, y)[0]\\n\\n N = len(data)\\n M = len(weights) - 1 \\n temp = np.ones([N, M + 1])\\n temp[: N, : M] = np.array(data)\\n\\n\\n df = np.zeros([M+1, 1])\\n\\n df[:, 0] = np.array([[np.mean([(y.flatten()[i] - targets.flatten()[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\\n\\n # df = np.matrix([[np.mean([(y[i] - targets[i]) * temp[i][j] for i in range(0, N)]) for j in range(0, M + 1)],])\\n\\n #####################################################################\\n # END OF YOUR CODE #\\n #####################################################################\\n return f, df, y\",\n \"def get_weights(self, var_id: int, batch_no: int) -> ndarray:\\n pass\",\n \"def readlogfile(file_name):\\n F = open(file_name, \\\"r\\\")\\n M = F.readlines()\\n F.close()\\n x = []\\n y = []\\n \\n for i in range(len(M)):\\n if find(M[i], \\\"#\\\") <0:\\n # Since the x,y are recorded as, e.g., '[398:402,300:304]'\\n x.append(float(M[i].split('[')[1].split(':')[0]) + 2.0)\\n y.append(float(M[i].split(',')[1].split(':')[0]) + 2.0)\\n \\n # Notice this function allows multiple stars to be chosen. For our purposes here,\\n # we need pick only one, and so return the first values in the list.\\n return x[0], y[0]\",\n \"def weights_for_doc(self, doc_path: str) -> np.ndarray:\\n weights = np.zeros(shape=self.num_terms)\\n with open(doc_path, 'r') as f:\\n text = f.readline()\\n terms = set(text.split())\\n for term in terms:\\n index = self.vector_mapping[term]\\n weights[index] = self.tf_idf_weight(term, doc_path)\\n\\n return weights\",\n \"def find_old_log(weight_path):\\n pardir = os.path.dirname(weight_path)\\n event_paths = glob.glob(os.path.join(pardir, \\\"event*\\\"))\\n if len(event_paths) == 0:\\n return None\\n else:\\n return event_paths[0]\",\n \"def load_weights(self, weights_path):\\n\\n # Open the weights file\\n fp = open(weights_path, \\\"rb\\\")\\n header = np.fromfile(fp, dtype=np.int32, count=5) # First five are header values\\n\\n # Needed to write header when saving weights\\n self.header_info = header\\n\\n self.seen = header[3]\\n weights = np.fromfile(fp, dtype=np.float32) # The rest are weights\\n fp.close()\\n\\n ptr = 0\\n for i, (module_def, module) in enumerate(zip(self.module_defs, self.module_list)):\\n if module_def[\\\"type\\\"] == \\\"convolutional\\\":\\n conv_layer = module[0]\\n if module_def[\\\"batch_normalize\\\"]:\\n # Load BN bias, weights, running mean and running variance\\n bn_layer = module[1]\\n num_b = bn_layer.bias.numel() # Number of biases\\n # Bias\\n bn_b = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.bias)\\n bn_layer.bias.data.copy_(bn_b)\\n ptr += num_b\\n # Weight\\n bn_w = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.weight)\\n bn_layer.weight.data.copy_(bn_w)\\n ptr += num_b\\n # Running Mean\\n bn_rm = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.running_mean)\\n bn_layer.running_mean.data.copy_(bn_rm)\\n ptr += num_b\\n # Running Var\\n bn_rv = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(bn_layer.running_var)\\n bn_layer.running_var.data.copy_(bn_rv)\\n ptr += num_b\\n else:\\n # Load conv. bias\\n num_b = conv_layer.bias.numel()\\n conv_b = torch.from_numpy(weights[ptr : ptr + num_b]).view_as(conv_layer.bias)\\n conv_layer.bias.data.copy_(conv_b)\\n ptr += num_b\\n # Load conv. weights\\n num_w = conv_layer.weight.numel()\\n conv_w = torch.from_numpy(weights[ptr : ptr + num_w]).view_as(conv_layer.weight)\\n conv_layer.weight.data.copy_(conv_w)\\n ptr += num_w\",\n \"def getLog():\\n logPath = getLogPath()\\n \\n with open(logPath) as f:\\n log = f.readlines()\\n\\n cleanedLog = []\\n \\n for line in log:\\n drink = line[0:8]\\n cleanedLog.append(drink)\\n \\n return cleanedLog\",\n \"def testLogRegres(weights, dev_x, dev_y):\\n predict_y = []\\n numSamples, numFeatures = np.shape(dev_x)\\n for i in range(numSamples):\\n if sigmoid(dev_x[i, :] * weights) > 0.5:\\n label = 1\\n else:\\n label = 0\\n predict_y.append(label)\\n print('Congratulations, testing complete!')\\n return predict_y\",\n \"def get_data_from_state(state):\\n data = []\\n for column in range(aes.NB):\\n for row in range(aes.R):\\n data.append(state[row][column])\\n return data\",\n \"def get_data_with_weights(self):\\n weights = np.zeros((self.contexts.shape[0], self.num_actions))\\n a_ind = np.array([(i, val) for i, val in enumerate(self.actions)])\\n weights[a_ind[:, 0], a_ind[:, 1]] = 1.0\\n return self.contexts, self.rewards, weights\",\n \"def logistic_pen(weights, data, targets, hyperparameters):\\n\\n wr = hyperparameters['weight_regularization']\\n \\n t = np.transpose(np.repeat(np.reshape(weights[:-1], (len(weights)-1, 1)), len(data), axis = 1))\\n f_e = data * t\\n z_sums = np.sum(f_e, axis=1)\\n y = sigmoid(z_sums +weights[-1])\\n f = np.sum(np.log(1 + np.exp(-z_sums - weights[-1])) + (1 - np.transpose(targets)) * (z_sums + weights[-1]))\\n df = np.sum(data * np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0)\\n df = np.append(df, np.sum(np.transpose(((-np.exp(-z_sums - weights[-1]) / (1 + np.exp(-z_sums - weights[-1]))) + (1 - np.transpose(targets)))), axis = 0))\\n\\n f += np.dot(weights[:-1].transpose()[0], weights[:-1].transpose()[0]) * wr / 2\\n df = np.reshape(df, ((len(df), 1)))\\n df += np.reshape(np.append(weights[:-1] * wr, 0), (len(weights), 1))\\n\\n f += (weights[-1, 0] ** 2) * wr / 2\\n df[-1] += weights[-1,0] * wr \\n\\n return f, df, np.reshape(y, (len(y), 1))\",\n \"def WeightFromPro(infile='PROCAR', lsorbit=False):\\n\\n assert os.path.isfile(infile), '%s cannot be found!' % infile\\n FileContents = [line for line in open(infile) if line.strip()]\\n\\n # when the band number is too large, there will be no space between \\\";\\\" and\\n # the actual band number. A bug found by Homlee Guo.\\n # Here, #kpts, #bands and #ions are all integers\\n nkpts, nbands, nions = [int(xx) for xx in re.sub(\\n '[^0-9]', ' ', FileContents[1]).split()]\\n\\n # Weights = np.asarray([line.split()[-1] for line in FileContents\\n # if not re.search('[a-zA-Z]', line)], dtype=float)\\n Weights = np.asarray([line.split()[1:-1] for line in FileContents\\n if not re.search('[a-zA-Z]', line)], dtype=float)\\n\\n kpt_weight = np.asarray(\\n [line.split()[-1] for line in FileContents if 'weight' in line], dtype=float)\\n\\n energies = np.asarray([line.split()[-4] for line in FileContents\\n if 'occ.' in line], dtype=float)\\n\\n nlmax = Weights.shape[-1]\\n nspin = Weights.shape[0] // (nkpts * nbands * nions)\\n nspin //= 4 if lsorbit else 1\\n\\n if lsorbit:\\n Weights.resize(nspin, nkpts, nbands, 4, nions, nlmax)\\n Weights = Weights[:, :, :, 0, :, :]\\n else:\\n Weights.resize(nspin, nkpts, nbands, nions, nlmax)\\n\\n kpt_weight.resize(nspin, nkpts)\\n energies.resize(nspin, nkpts, nbands)\\n\\n return energies, kpt_weight, Weights\",\n \"def logistic_predict(weights, data):\\n\\n # TODO: Finish this function\\n data = mod_data(data)\\n z_array = get_z_array(weights, data)\\n return sigmoid(z_array)\",\n \"def read(filepath, keep=None):\\n with open(filepath, 'r') as file:\\n lines = file.read().split('\\\\n')\\n\\n # Clean the not logs lines\\n logs = []\\n for line in lines:\\n if not line:\\n continue\\n\\n if line[0] != '[' or line[-1] != ']':\\n continue\\n\\n if keep is not None and not keep(line):\\n continue\\n\\n line = line[1:-1] # Remove the first '[' and the last ']'\\n pairs = line.split('] [') # Get the key-value pairs\\n current = {} # Current log dict\\n for pair in pairs:\\n key, *values = pair.split(' ')\\n current[key] = ' '.join(values)\\n logs.append(current)\\n\\n return logs\",\n \"def logistic(self, data, weights, biases):\\n\\n state_weight_prods = np.dot(data, weights)\\n print(-state_weight_prods - biases)\\n activations = 1.0 / (1 + np.exp(-state_weight_prods - biases))\\n plt.plot(state_weight_prods, activations)\\n plt.show()\\n return activations\",\n \"def initial_state(self):\\n r = np.full((self.xlen, 2), self.log0, dtype=np.float32)\\n r[0, 1] = self.log_probs[0, self.blank]\\n for i in range(1, self.xlen):\\n r[i, 1] = r[i - 1, 1] + self.log_probs[i, self.blank]\\n return r\",\n \"def readData(path): \\n try:\\n open(path)\\n dataset = np.loadtxt(path)\\n # arms played by uniformly-random policy as recorded in dataset\\n arms = dataset[:, 0].astype(int) \\n # rewards received by playing arms using a uniformly-random policy as \\n # recorded in dataset \\n rewards = dataset[:, 1] \\n # context vector \\n contexts = dataset[:, 2:] \\n except FileNotFoundError: \\n raise \\n return(arms, rewards, contexts)\",\n \"def compute_importance_weights(behavior_logits, target_logits, actions):\\n logrho = compute_unclipped_logrho(behavior_logits, target_logits, actions)\\n print(\\\"logrho:\\\", logrho) if debug else None\\n print(\\\"logrho.shape:\\\", logrho.shape) if debug else None\\n\\n # change to pytorch version\\n return torch.clamp(torch.exp(logrho), max=1.)\",\n \"def logistic(weights, data, targets, hyperparameters):\\n\\n # TODO: Finish this function\\n\\n return f, df, y\",\n \"def read_b2_transport_inputfile(infileloc, carbon=True):\\n with open(infileloc, 'r') as f:\\n lines = f.readlines()\\n\\n ndata = int(\\n lines[1].strip().split()[5]) # This is the same for every array in our write routine\\n\\n rn = np.zeros(ndata)\\n dn = np.zeros(ndata)\\n ke = np.zeros(ndata)\\n ki = np.zeros(ndata)\\n if carbon:\\n vrc = np.zeros(ndata)\\n dc = np.zeros(ndata)\\n\\n for line_full in lines[2:]:\\n line = line_full.strip().split()\\n if len(line) < 4: continue\\n\\n if line[2][0] == '1' and line[3][0] == '1':\\n rn[int(line[1][:-1]) - 1] = np.float(line[5])\\n dn[int(line[1][:-1]) - 1] = np.float(line[-2])\\n\\n elif line[2][0] == '3' and line[3][0] == '1':\\n ki[int(line[1][:-1]) - 1] = np.float(line[-2])\\n\\n elif line[2][0] == '4' and line[3][0] == '1':\\n ke[int(line[1][:-1]) - 1] = np.float(line[-2])\\n\\n elif carbon:\\n\\n if line[2][0] == '1' and line[3][0] == '4':\\n dc[int(line[1][:-1]) - 1] = np.float(line[-2])\\n\\n elif line[2][0] == '6' and line[3][0] == '3':\\n vrc[int(line[1][:-1]) - 1] = np.float(line[-2])\\n\\n if carbon:\\n return {'rn': rn, 'dn': dn, 'ki': ki, 'ke': ke, 'dc': dc, 'vrc': vrc}\\n else:\\n return {'rn': rn, 'dn': dn, 'ki': ki, 'ke': ke}\",\n \"def read_history (filename) :\\n \\n col_names = ['i', 't', 'M', 'log_L', 'log_R', 'log_T_s', \\n 'log_T_c', 'log_rho_c', 'log_P_c', 'Psi_c', \\n 'X_c', 'Y_c', 'X_Cc', 'X_Nc', 'X_Oc', \\n 'tau_dyn', 'tau_KH', 'tau_nuc', 'L_PP',\\n 'L_CNO', 'L_3a', 'L_Z', 'L_nu', 'M_He',\\n 'M_C', 'M_O', 'R_He', 'R_C', 'R_O']\\n\\n return read_ez_zip(filename, 'summary.txt', col_names)\",\n \"def read_orderlog(orderlog_path: str) -> list:\\n\\n order_log = []\\n\\n reader = csv.DictReader(open(orderlog_path))\\n for row in reader:\\n order_log.append(row)\\n\\n return order_log\",\n \"def read_log_airdata(ac_id, filename):\\n f = open(filename, 'r')\\n pattern = re.compile(\\\"(\\\\S+) \\\"+ac_id+\\\" AIR_DATA (\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+) (\\\\S+)\\\")\\n list_meas = []\\n while True:\\n line = f.readline().strip()\\n if line == '':\\n break\\n m = re.match(pattern, line)\\n if m:\\n list_meas.append([float(m.group(1)), float(m.group(2)), float(m.group(3)), float(m.group(4)), float(m.group(5)), float(m.group(6)), \\n float(m.group(7)), float(m.group(8))])\\n return np.array(list_meas)\",\n \"def _read_filter_data(filename):\\n gains = []\\n freqs = []\\n freq_scale = 0\\n with open(filename) as f:\\n for line in f:\\n words = line.split()\\n if line.startswith('Freq'):\\n _, scale = words[0].split(\\\"(\\\")\\n scale = scale.rstrip(\\\")\\\")\\n if scale==\\\"Hz\\\":\\n freq_scale = 1\\n elif scale==\\\"kHz\\\":\\n freq_scale = 1e3\\n elif scale==\\\"MHz\\\":\\n freq_scale = 1e6\\n elif scale==\\\"GHz\\\":\\n freq_scale = 1e9\\n else:\\n raise ValueError(\\\"Cannot parse line: '\\\"+line+\\\"'\\\")\\n elif len(words)==3 and words[0]!=\\\"Total\\\":\\n f, g, p = line.split(\\\",\\\")\\n freq = float(f) * freq_scale\\n gain = float(g)\\n phase = float(p)\\n freqs.append(freq)\\n gains.append(gain * np.exp(1j*phase))\\n\\n return np.array(gains), np.array(freqs)\",\n \"def get_hash_log_curr(self):\\n if not os.path.exists(self.log_path):\\n os.makedirs(self.log_path)\\n try:\\n log = open(self.log_path + r'\\\\hash_log.txt', 'U')\\n #first line is header, skip\\n log.readline()\\n for line in log:\\n try:\\n line = line.replace('\\\\n','')\\n # log maintenance. only keep number of days designated\\n line = line.split('|')\\n if len(line) != 6:\\n raise Exception\\n if line[4] > self.log_cut_off_date:\\n self.hash_log_curr[line[2]] = line\\n except:\\n self.print_to_log('Bad log Line: ' + str(line))\\n self.print_to_log('Hash Log read Successfully')\\n except IOError:\\n self.print_to_log('No log found')\\n self.hash_log_curr = None\\n except IndexError:\\n self.print_to_log('Bad Log File')\\n raise\\n except:\\n self.print_to_log('Unknown Error, Exiting ')\\n raise\",\n \"def _get_bps(self, data, weights=None):\\n # learn rate is probably redundant for this, since it's effectively a change in nu0 (and alpha0?)\\n ndata = data.shape\\n ws = np.full(ndata, self.lr)\\n if weights is not None: ws *= weights\\n mus = [self.mu0]\\n nus = [self.nu0]\\n alphas = [self.alpha0]\\n betas = [self.beta0]\\n runCount = 0\\n runSum = 0\\n runSumSq = 0\\n for d,w in zip(data[:-1],ws):\\n wp = self.mem # weight for previous data\\n runCount = wp*runCount + w\\n runSum = wp*runSum + w*d\\n runSumSq = wp*runSumSq + w*d**2\\n runMean = runSum/runCount\\n nup = wp*nus[-1] + w\\n # the beta term is a bit difficult. with w.g. 0.5 memory, the variance blows up.\\n # this may just be how it works -- w/ less information the variance should explode\\n betap = wp*self.beta0 + 0.5*(runSumSq - runCount*runMean**2) + \\\\\\n 0.5*runCount*self.nu0/nup*(runMean - self.mu0)**2 # not sure how to handle these mu0/nu0 w/ forgetting...\\n mus.append( (wp*nus[-1]*mus[-1] + w*d)/nup )\\n nus.append(nup)\\n alphas.append(wp*alphas[-1] + 0.5*w)\\n betas.append(betap)\\n return np.array(mus),np.array(nus),np.array(alphas),np.array(betas)\",\n \"def weights(self):\\n return [x.numpy() for x in self.core.w]\",\n \"def forward(self, logits, temperature):\\n flat = logits.view(logits.shape[:-2] + (-1,))\\n weights = F.softmax(flat / temperature, dim=-1).view_as(logits)\\n\\n x = (weights.sum(-2) * torch.linspace(-1, 1, logits.shape[-1]).type_as(logits)).sum(-1)\\n y = (weights.sum(-1) * torch.linspace(-1, 1, logits.shape[-2]).type_as(logits)).sum(-1)\\n\\n return torch.stack((x, y), -1), weights\",\n \"def weights(self, algo):\\n weights = np.zeros(\\n (self.n_pop, self.states.size(), algo.n_turbines), dtype=FC.DTYPE\\n )\\n weights[:] = self.states.weights(algo)[None, :, :] / self.n_pop\\n return weights.reshape(self.size(), algo.n_turbines)\",\n \"def _load_wt_file(self, x): \\n if type(x) == str:\\n # Load file\\n x = np.loadtxt(x)\\n \\n W = x[:self.dimY*self.dimX].reshape(self.dimY,self.dimX)\\n W = W.transpose() # convention\\n T = x[self.dimY*self.dimX:].reshape(self.dimY,self.dimY) # no need to transpose\\n return W, T\",\n \"def init_e_traces(dim_weights):\\n z_trace = np.zeros((dim_weights))\\n return z_trace\",\n \"def read_wave(f):\\n # w will be an object of type wave.Wav_read.\\n file = file_utils.open_or_fd(f, encoding=None)\\n wav = wavio.read(file)\\n # see https://github.com/WarrenWeckesser/wavio/blob/master/wavio.py for\\n # format of `wav`\\n\\n # we want data as (num_channels, num_samples).. this is the\\n # format that seems most compatible with convolutional code and\\n # resampling.\\n data = wav.data.swapaxes(0, 1)\\n if data.dtype == np.int16:\\n data = data.astype(np.float32) * (1.0 / 2**15)\\n elif data.dtype == np.int24:\\n data = data.astype(np.float32) * (1.0 / 2**23)\\n else:\\n if data.dtype != np.float32:\\n raise RuntimeError(\\\"Array returned from wavio.read had \\\"\\n \\\"unexpected dtype \\\".format(data.dtype))\\n return (data, float(wav.rate))\",\n \"def read_action(path):\\n print(\\\"Reading action data from file \\\", path)\\n\\n df = pd.read_csv(path, sep=' ', header=None, engine='python')\\n max_state = int(df[0].max())\\n min_state = int(df[0].min())\\n a_mat = np.zeros((max_state, max_state), dtype='float16')\\n\\n # for s in np.arange(min_state, max_state + 1):\\n for s in np.arange(min_state, max_state + 1):\\n df_s = df[df[0] == s]\\n for _, row in df_s.iterrows():\\n _s = int(row[1])\\n p = row[2]\\n a_mat[s - 1][_s - 1] = p\\n print(\\\"Finished \\\", path, \\\"!\\\")\\n\\n return a_mat\",\n \"def get_weights(self, returns):\\n omega = self._get_omega(returns)\\n x0 = np.ones([returns.shape[1], 1])/returns.shape[1]\\n y0 = np.append(x0, self.newt_lambda0).reshape(-1, 1)\\n y = y0 - (np.linalg.pinv(self._get_J(omega, y0)) @ self._get_F(omega, y0))\\n error = np.linalg.norm(y-y0, ord=2)\\n while error > self.tol:\\n y_last = y\\n y = y_last - (np.linalg.pinv(self._get_J(omega, y_last)) @ self._get_F(omega, y_last))\\n error = np.linalg.norm(y-y_last, ord=2)\\n return y[:-1]\",\n \"def get_weights(self):\\n params = self.weights\\n return K.batch_get_value(params)\",\n \"def read_mo_coef(self, path_rwfdump, fn_rwf):\\n os.system(path_rwfdump + f\\\" {fn_rwf} mo_coef.dat 524R\\\")\\n\\n with open('mo_coef.dat', \\\"r\\\") as f:\\n log = f.read()\\n\\n tmp = re.findall('[-]?\\\\d+\\\\.\\\\d+D[+-]\\\\d\\\\d', log)\\n tmp = np.array([x.replace('D','e') for x in tmp], dtype=np.float)\\n\\n tmp_mo = tmp.reshape(self.nbasis, self.nbasis)\\n\\n return tmp_mo[self.nfc:self.nbasis]\",\n \"def __initialize_weights__(num_neurons: int) -> np.ndarray:\\n\\n weights = np.zeros((num_neurons, num_neurons))\\n\\n return weights\",\n \"def ReadTinker():\\n # Total Potential Energy : {f} Kcal/mole\\n total_line = \\\" Total Potential Energy :\\\"\\n with open('LICHM_TINKEREnergy_0.log') as f:\\n for line in f:\\n if line.startswith(total_line):\\n # print(line)\\n TinkE = re.findall(r'\\\\-\\\\d+\\\\.*\\\\d*', line)\\n TinkE = float(TinkE[0])\\n # if AMOEBA == True:\\n # if line.startswith(\\\"Polarization\\\"):\\n # Epol = re.findall(r'\\\\-\\\\d+\\\\.*\\\\d*', line)\\n # Epol = float(Epol[0])\\n # elif line.startswith(\\\"Implicit Solvation\\\")\\n # Esolv = re.findall(r'\\\\-\\\\d+\\\\.*\\\\d*', line)\\n # Esolv = float(Esolv[0])\\n f.close()\\n # if AMOEBA == True:\\n # TINKERPolForces = EPol + ESolv\\n # TinkE += TINKERPolForces\\n #\\n TinkE *= kcal2ev\\n return TinkE\",\n \"def weights(self) -> List[float]:\",\n \"def read_weights(F_DIST):\\n global F_DIST_w1, w, num_features, N_IDEN_PROB, MORE_THAN_1_W\\n\\n # read weights file first line, get json information into a dict\\n with open(WEIGHTS_FNAME, \\\"r\\\") as f:\\n WEIGHTS_FDATA = json.loads(f.readline())\\n # has keys LAYERS, J, NUM_FEATURES\\n\\n # get and verify data from the weights file\\n N_IDEN_PROB = WEIGHTS_FDATA['LAYERS']\\n MORE_THAN_1_W = (N_IDEN_PROB > 2) # more than 2 layers === more than 1 weight\\n if J > WEIGHTS_FDATA['J']:\\n raise RuntimeError(\\\"J in weights file is less than J provided to the \\\"\\n \\\"script; former >= latter\\\")\\n if WEIGHTS_FDATA['NUM_FEATURES'] != num_features:\\n raise RuntimeError(\\\"num_features in weights file is not the same as \\\"\\n \\\"num_features provided to this script\\\")\\n\\n # read weights file\\n # no. of weights is 1 less than no. of layers in weights file\\n list_of_w = ad.read_weights_file(\\n WEIGHTS_FNAME, N_IDEN_PROB-1, WEIGHTS_FDATA['J'], J, num_features\\n )\\n list_of_w[-1] = np.expand_dims(list_of_w[-1], axis=2)\\n\\n # split w[0]; multiply the F_DIST portion of w[0] with F_DIST\\n w1_for_fdist, w1_for_r = np.split(list_of_w[0], [num_features-1], axis=1)\\n F_DIST_w1 = F_DIST.bmm(torch.from_numpy(w1_for_fdist))\\n\\n w['first_for_r'] = torch.from_numpy(w1_for_r)\\n w['except_first'] = [torch.from_numpy(wi) for wi in list_of_w[1:]]\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5679781","0.5495576","0.5362034","0.527573","0.5247644","0.51613903","0.51452","0.51238173","0.5120641","0.5115963","0.50911295","0.50866115","0.49406517","0.4936814","0.4911786","0.48889357","0.486517","0.48642686","0.4859323","0.48575228","0.4830234","0.48041993","0.47989208","0.4785614","0.47682205","0.47625086","0.47616592","0.4757473","0.4752521","0.4741014","0.4738589","0.47289276","0.47167906","0.4696811","0.46888483","0.4659889","0.46505928","0.46498823","0.4647697","0.46340597","0.46294177","0.46267238","0.46238536","0.46202424","0.46074843","0.46070498","0.46069664","0.4593653","0.45914423","0.4586221","0.4571937","0.45663458","0.45644557","0.45509446","0.45499602","0.45497087","0.45428202","0.45380247","0.45362923","0.45321196","0.45314792","0.45299822","0.45266205","0.45262387","0.4521643","0.45212728","0.45166767","0.45028502","0.44999444","0.44966146","0.449453","0.44920203","0.4491455","0.4491411","0.44881397","0.44794688","0.4474362","0.44706523","0.4461733","0.4460918","0.44605577","0.4459628","0.44524503","0.44464722","0.44463745","0.4436011","0.44357723","0.4426191","0.44198665","0.4418249","0.44092214","0.4399746","0.43941578","0.43926924","0.43924224","0.43915755","0.43906185","0.4383687","0.4383219","0.4381958"],"string":"[\n \"0.5679781\",\n \"0.5495576\",\n \"0.5362034\",\n \"0.527573\",\n \"0.5247644\",\n \"0.51613903\",\n \"0.51452\",\n \"0.51238173\",\n \"0.5120641\",\n \"0.5115963\",\n \"0.50911295\",\n \"0.50866115\",\n \"0.49406517\",\n \"0.4936814\",\n \"0.4911786\",\n \"0.48889357\",\n \"0.486517\",\n \"0.48642686\",\n \"0.4859323\",\n \"0.48575228\",\n \"0.4830234\",\n \"0.48041993\",\n \"0.47989208\",\n \"0.4785614\",\n \"0.47682205\",\n \"0.47625086\",\n \"0.47616592\",\n \"0.4757473\",\n \"0.4752521\",\n \"0.4741014\",\n \"0.4738589\",\n \"0.47289276\",\n \"0.47167906\",\n \"0.4696811\",\n \"0.46888483\",\n \"0.4659889\",\n \"0.46505928\",\n \"0.46498823\",\n \"0.4647697\",\n \"0.46340597\",\n \"0.46294177\",\n \"0.46267238\",\n \"0.46238536\",\n \"0.46202424\",\n \"0.46074843\",\n \"0.46070498\",\n \"0.46069664\",\n \"0.4593653\",\n \"0.45914423\",\n \"0.4586221\",\n \"0.4571937\",\n \"0.45663458\",\n \"0.45644557\",\n \"0.45509446\",\n \"0.45499602\",\n \"0.45497087\",\n \"0.45428202\",\n \"0.45380247\",\n \"0.45362923\",\n \"0.45321196\",\n \"0.45314792\",\n \"0.45299822\",\n \"0.45266205\",\n \"0.45262387\",\n \"0.4521643\",\n \"0.45212728\",\n \"0.45166767\",\n \"0.45028502\",\n \"0.44999444\",\n \"0.44966146\",\n \"0.449453\",\n \"0.44920203\",\n \"0.4491455\",\n \"0.4491411\",\n \"0.44881397\",\n \"0.44794688\",\n \"0.4474362\",\n \"0.44706523\",\n \"0.4461733\",\n \"0.4460918\",\n \"0.44605577\",\n \"0.4459628\",\n \"0.44524503\",\n \"0.44464722\",\n \"0.44463745\",\n \"0.4436011\",\n \"0.44357723\",\n \"0.4426191\",\n \"0.44198665\",\n \"0.4418249\",\n \"0.44092214\",\n \"0.4399746\",\n \"0.43941578\",\n \"0.43926924\",\n \"0.43924224\",\n \"0.43915755\",\n \"0.43906185\",\n \"0.4383687\",\n \"0.4383219\",\n \"0.4381958\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.7046495"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":81699,"cells":{"query":{"kind":"string","value":"Load a COBRApy Model object into the GEMPRO project."},"document":{"kind":"string","value":"def load_cobra_model(self, model):\n self.model = ModelPro(model)\n for g in self.model.genes:\n if self.genes_dir:\n g.root_dir = self.genes_dir\n g.protein.pdb_file_type = self.pdb_file_type\n self.genes = self.model.genes\n\n log.info('{}: loaded model'.format(model.id))\n log.info('{}: number of reactions'.format(len(self.model.reactions)))\n log.info('{}: number of reactions linked to a gene'.format(ssbio.core.modelpro.true_num_reactions(self.model)))\n log.info('{}: number of genes (excluding spontaneous)'.format(ssbio.core.modelpro.true_num_genes(self.model,\n custom_spont_id=self.custom_spont_id)))\n log.info('{}: number of metabolites'.format(len(self.model.metabolites)))\n log.warning('IMPORTANT: All Gene objects have been transformed into GenePro '\n 'objects, and will be for any new ones')"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def load_model(self) -> Any:","def load(path_to_model):\n pass","def load_model(self):\n pass","def load_model(self, model_path: str):","def _load_model(self):\n with open(self.filepath, 'rb') as file:\n self.cmodel = pickle.load(file)","def load_model(self, path):\n pass","def load_model() -> None:\n global model\n\n if app.testing:\n current_dir = os.path.dirname(__file__)\n model_path = os.path.join(current_dir, \"models/model.pkl\")\n else:\n model_path = os.getenv(\"PATH_TO_MODEL\")\n\n if model_path is None:\n err = f\"PATH_TO_MODEL {model_path} is None\"\n raise RuntimeError(err)\n\n with open(model_path, \"rb\") as model_file:\n model = pickle.load(model_file)","def __load_model(self):\n loaded = load(self.__file_name)\n self.__model = loaded['model']\n self.__meta_data = loaded['metadata']\n self.__is_ready = True","def load(\n self,\n modelLoadPath\n ):\n pass","def load_model(self, filename):\r\n pass","def load_model():\n\n # find location of model\n\n file_path = '/Users/davidodwyer/Desktop' # to the directory\n file_name = 'original_mlr.joblib' \n the_file = os.path.join(file_path, file_name)\n\n # load model\n\n model = load(the_file)\n\n return model","def load(self, path):\n load_model(path, self)","def load_model(self, file=None):\n return None","def load_model(model_name):\r\n model = joblib.load(model_name)\r\n return model","def load_model(self, fname):\n if self._Booster is None:\n self._Booster = Booster({'nthread': self.n_jobs})\n self._Booster.load_model(fname)","def load_model():\n with open(MODEL_SAVE_JSON, 'r') as fp:\n json_string = fp.read()\n model = model_from_json(json_string)\n return model","def load_model(self) -> None:\n\n try:\n model_class = MODEL_TYPES[self.model_type]\n except KeyError:\n raise KeyError(f\"model type: {self.model_type} not supported\")\n\n if (\n os.path.exists(self.resources_path)\n and len(os.listdir(self.resources_path)) > 0\n ):\n model_name_or_path = self.resources_path\n else:\n model_name_or_path = self.model_name\n\n if self.model_type == \"stable_diffusion\":\n self.model = model_class.from_pretrained(\n model_name_or_path,\n use_auth_token=self.auth_token,\n )\n else:\n self.model = model_class.from_pretrained(model_name_or_path)\n\n self.model.to(self.device)","def load_model():\n with open(MODEL_FILENAME, \"rb\") as file:\n model = pickle.load(file)\n return model","def load_model(self):\r\n try:\r\n self.model = CRNN_STN(self.crnn_cfg())\r\n self.model.load_weights(config.CRNN_Model_Path)\r\n except:\r\n print('Error in method {0} in module {1}'.format('load_model', 'crnn_bridge.py'))","def load_model():\n global columns\n global data\n \n model = pickle.load(open('MedCostModel.pkl', 'rb'))\n data = pd.read_csv('MedCosts.csv')\n data = data.drop(columns=['charges'])\n columns = data.columns\n return(model)","def load_model_from_file(path, as_builder=False):\n module = load_model_module(path)\n model = module.model\n if not as_builder:\n model = model()\n del sys.path_importer_cache[os.path.dirname(module.__file__)]\n del sys.modules[module.__name__]\n return model","def load_model(model_path: str) -> object:\n model = torch.load(model_path)\n model.eval()\n return model","def load_model(self):\n # Load the model\n print('Loading model:', self.model_path)\n t0 = time.time()\n model = load_model(self.model_path)\n t1 = time.time()\n print('Loaded in:', t1 - t0)\n return model","def load_model():\n with open('../model/regressor.pickle', 'rb') as f:\n model = pickle.load(f)\n return model","def initialize(self) -> None:\n self.model = load(self.path)","def load_model(self, path_model: Optional[PathLike]) -> None:\n raise NotImplementedError","def _get_model():\n with open('models/catapp_gp_model.pickle', 'rb') as modelfile:\n model = pickle.load(modelfile)\n return model","def load_model():\n global model_tok, model_mlm, model, model_cls\n if model is None:\n model_name_or_path = os.getenv('TRANSFORMER_MODEL', default='distilbert-base-multilingual-cased')\n # 'bert-base-multilingual-cased'\n model_tok = AutoTokenizer.from_pretrained(model_name_or_path)\n model_mlm = AutoModelForMaskedLM.from_pretrained(model_name_or_path)\n model_mlm.eval()\n model = model_mlm.base_model\n\n if isinstance(model_mlm, BertPreTrainedModel):\n model_cls = model_mlm.cls\n elif isinstance(model_mlm, DistilBertPreTrainedModel):\n model_cls = nn.Sequential(\n model_mlm.vocab_transform,\n nn.GELU(),\n model_mlm.vocab_layer_norm,\n model_mlm.vocab_projector\n )\n else:\n raise ValueError(f'{model_name_or_path} is not supported yet. try one of '\n f'{\", \".join(list(AvailableModels.__members__.keys()))}')\n model.to(device)\n model_mlm.to(device)\n # model_tok.to(device)\n model_cls.to(device)","def _get_model():\n freezing = os.environ.get('NAUCSE_FREEZE', not app.config['DEBUG'])\n initialize = True\n\n try:\n g.model = app.config['NAUCSE_MODEL']\n except KeyError:\n g.model = init_model()\n app.config['NAUCSE_MODEL'] = g.model\n else:\n if freezing:\n # Model already initialized; don't look for changes\n return\n\n # (Re-)initialize model\n\n g.model.load_licenses(Path(app.root_path).parent / 'licenses')\n g.model.load_local_courses(Path(app.root_path).parent)\n\n if freezing:\n g.model.freeze()","def load_model(self):\n Thread(target=self.__load_model).start()","def load_model(app: FastAPI) -> None:\n\n logging.info(\"Starting up the application\")\n model_path = DATA_MODEL_PATH\n\n if model_path.exists():\n model = FraudDetection(model_path)\n app.state.model = model\n logging.info(f\"Loaded model {model_path}\")\n else:\n app.state.model = FraudDetection()\n logging.warning(f\"No existing model found in {model_path}\")","def load_model():\n with open(paths.model('model.pkl'), 'rb') as stream:\n return pickle.load(stream)","def model() -> Any:\n with open(\"airbnb_regressor.pickle\",\"rb\") as f:\n model = pickle.load(f)\n return model","async def load_model(\n self,\n model_name: str,\n headers: dict[str, t.Any] = ...,\n config: str = ...,\n files: dict[str, str] = ...,\n ) -> None:","def load_model(self, tmp_dir):\n pass","def load_model(self, fname):\n cxnlib.CXNNetLoadModel(self.handle, fname)","def load_model():\n logger.info('load_model called')\n return 1","def test_load_model():\n model = BERTopic(language=\"Dutch\", embedding_model=None, n_components=12)\n model.save(\"test\")\n loaded_model = BERTopic.load(\"test\")\n assert type(model) == type(loaded_model)\n assert model.language == loaded_model.language\n assert model.embedding_model == loaded_model.embedding_model\n assert model.top_n_words == loaded_model.top_n_words\n assert model.n_neighbors == loaded_model.n_neighbors\n assert model.n_components == loaded_model.n_components","def importModel(model_name):\n module_path = os.path.join(path, \"models\")\n module_path = os.path.join(module_path, model_name + \".py\")\n model = importClass(model_name, model_name, module_path)\n return model","def load(self):\n print(\"==> Loading model from\", self.model_dir)\n self.model = tf.keras.models.load_model(self.model_dir)","def load_model(self, filename):\n filename = path.join(self.root_path, f'models/{filename}.pkl')\n self.model = pickle.load(open(filename, \"rb\"))\n print('Successfully loaded model from '+filename)","def load(self, file_path):\n self.model = load_model(file_path)","def load(self, file_path):\n self.model = load_model(file_path)","def load(self, file_path):\n self.model = load_model(file_path)","def load_model():\n return \"None\"","def load_model(cls) -> Classifier:\n if cls.model is None:\n cls.model = Classifier.load(model_path)\n return cls.model","def load_model(self, folder_name):\n raise NotImplementedError()","def load_model(self):\n try:\n self.model = Word2Vec.load(self.config[\"model_path\"])\n self.model.init_sims(replace=True)\n except Exception as e:\n print(e)\n print(\"error in model loading!\")","def load_model(self, sess, pb_model_path):\n\n logging.info(\"Import yolo model from pb start .......\")\n\n with sess.as_default():\n with sess.graph.as_default():\n with tf.gfile.FastGFile(pb_model_path, 'rb') as f_handle:\n logging.info(\"ParseFromString start .......\")\n graph_def = tf.GraphDef()\n graph_def.ParseFromString(f_handle.read())\n logging.info(\"ParseFromString end .......\")\n\n tf.import_graph_def(graph_def, name='')\n logging.info(\"Import_graph_def end .......\")\n\n logging.info(\"Import yolo model from pb end .......\")","def load_seq_model():\n model = joblib.load(os.path.join(os.path.dirname(__file__), 'RuleSet3.pkl'))\n return model","def load_model(bento_model: str | Tag | Model) -> ModelType: # noqa\n if not isinstance(bento_model, Model):\n bento_model = get(bento_model)\n\n if bento_model.info.module not in (MODULE_NAME, __name__):\n raise NotFound(\n f\"Model {bento_model.tag} was saved with module {bento_model.info.module}, not loading with {MODULE_NAME}.\"\n )\n\n model_file = bento_model.path_of(f\"{SAVE_NAMESPACE}{PKL_EXT}\")\n\n with open(model_file, \"rb\") as f:\n # The protocol version used is detected automatically, so we do not\n # have to specify it.\n return cloudpickle.load(f)","def load_model(fname: os.PathLike) -> Model:\n return Model.load(fname)","def load_model():\n prepro = Prepro(PATH_STOPSWORD, PATH_ACRONYM)\n vectorizer = joblib.load(PATH_TFIDF)\n label_encoder = joblib.load(PATH_ENCODER)\n model_svm = joblib.load(PATH_SVM)\n model_nb = joblib.load(PATH_NB)\n model_lr = joblib.load(PATH_LR)\n return prepro, vectorizer, label_encoder, model_svm, model_nb, model_lr","def _load_model(self):\n super()._load_model()\n\n # Adjust base pose(s) accordingly\n if self.env_configuration == \"bimanual\":\n xpos = self.robots[0].robot_model.base_xpos_offset[\"table\"](self.table_full_size[0])\n self.robots[0].robot_model.set_base_xpos(xpos)\n else:\n if self.env_configuration == \"single-arm-opposed\":\n # Set up robots facing towards each other by rotating them from their default position\n for robot, rotation in zip(self.robots, (np.pi/2, -np.pi/2)):\n xpos = robot.robot_model.base_xpos_offset[\"table\"](self.table_full_size[0])\n rot = np.array((0, 0, rotation))\n xpos = T.euler2mat(rot) @ np.array(xpos)\n robot.robot_model.set_base_xpos(xpos)\n robot.robot_model.set_base_ori(rot)\n else: # \"single-arm-parallel\" configuration setting\n # Set up robots parallel to each other but offset from the center\n for robot, offset in zip(self.robots, (-0.25, 0.25)):\n xpos = robot.robot_model.base_xpos_offset[\"table\"](self.table_full_size[0])\n xpos = np.array(xpos) + np.array((0, offset, 0))\n robot.robot_model.set_base_xpos(xpos)\n\n # load model for table top workspace\n self.mujoco_arena = TableArena(\n table_full_size=self.table_full_size, table_friction=self.table_friction\n )\n if self.use_indicator_object:\n self.mujoco_arena.add_pos_indicator()\n\n # Arena always gets set to zero origin\n self.mujoco_arena.set_origin([0, 0, 0])\n\n # initialize objects of interest\n self.pot = PotWithHandlesObject()\n self.mujoco_objects = OrderedDict([(\"pot\", self.pot)])\n\n # task includes arena, robot, and objects of interest\n self.model = TableTopTask(\n self.mujoco_arena,\n [robot.robot_model for robot in self.robots],\n self.mujoco_objects,\n initializer=self.placement_initializer,\n )\n self.model.place_objects()","def load_model(self, **params):\n \t# file_name = params['name']\n # return pickle.load(gzip.open(file_name, 'rb'))","def load_model(self, model_as_bytes: bytes) -> None:\n\n self.model = deserialize_from_zippy(model_as_bytes)","def import_model(model_name, clear=True):\n file_name = os.path.join(settings.GAME_DIR, settings.WORLD_DATA_FOLDER, model_name)\n import_file(file_name, model_name, widecard=True, clear=clear)","def load_model(filename):\n return Model.load_savefile(filename)","def import_model(path=None):\n path = get_model_path() if path is None else path\n return torch.jit.load(path)","def _load_model(self):\n self._load_scaler('scaler.save')\n self._load_encoder('encoder0.save', 0)\n self._load_encoder('encoder1.save', 1)\n self._load_neural_network('model.json', 'model.h5')\n return","def load_model(self, model_path):\n\n\t\tmodel_path = osp.abspath(model_path)\n\t\tmodel_weights_path = osp.splitext(model_path)[0] + \".bin\"\n\n\t\tself.Helpers.logger.info(\"Loading the model from '%s'\" % (model_path))\n\t\tmodel = self.context.ie_core.read_network(model_path, model_weights_path)\n\t\tself.Helpers.logger.info(\"Model loaded\")\n\n\t\treturn model","def read_model( path ):\n path = os.path.join(models_folder,path + '.pck' )\n with open( path , 'r') as f:\n model = pickle.load(f)\n return model","def load_model(self):\n return joblib.load(self.MODEL_PATH)","def load(model_file):\n return pickle.load(open(model_file))","def make_model():\n m = model_class(*argv[2:-1])\n modelobj[\"model\"] = m","def load_model(self):\n if self.save_path is not None:\n if isfile(self.save_path):\n self.model.load_state_dict(load(self.save_path))\n else:\n raise ValueError(\"Cannot find model save file: \" + self.save_path)","def loadModel(self):\n#FLAG: still waiting on boost image\n\t\tself.form = loader.loadModel(\"models/panda-model\")\n\t\tself.form.setScape(.005)\n\t\tself.form.reparentTo(render)","def load_model(self, filename):\n model_object = self.s3_resource.Object(self.bucket_name, self.models_path + str(filename)).get()['Body'].read()\n model = pickle.loads(model_object)\n return model","def load_model(self):\n if os.stat('code/lr-model.pt').st_size == 0:\n return\n params = torch.load('code/lr-model.pt')\n self.set_params(params)","def LoadModel(self):\n\t\tself.form = loader.loadModel(\"models/lampExport\")\n\t\t#self.form.setScale(.007)\n\t\tself.form.reparentTo(render)\n\t\tself.form.setPos(self.xpos, self.ypos, -30)","def import_model(file):\n file = os.path.expanduser(file)\n obj = IsolationForest()\n metadata = obj._cpp_obj.deserialize_obj(file)\n metadata = json.loads(metadata)\n obj._take_metadata(metadata)\n return obj","def load_model(model_name, MODEL_DIR):\n model_def_path = os.path.join(MODEL_DIR, model_name + '.py')\n weights_path = os.path.join(MODEL_DIR, model_name + '.pth')\n mod = load_module_2or3(model_name, model_def_path)\n func = getattr(mod, model_name)\n net = func(weights_path=weights_path)\n return net","def load_model(self, model_path, load_ae=True, map_location='cpu'):\n assert load_ae and (self.ae_net is not None), 'The trainer has not been initialized with an Autoencoder. It can thus not be loaded.'\n model_dict = torch.load(model_path, map_location=map_location)\n self.c = model_dict['c']\n self.net.load_state_dict(model_dict['net_dict'])\n\n if load_ae and (self.ae_net is not None):\n self.ae_net.load_state_dict(model_dict['ae_net_dict'])","def load_model(self, path):\n try:\n self.model = joblib.load(path)\n except Exception as e:\n print(e)\n print(\"Couldn't load scikit learn model on path {}!\".format(path))","def load_model(self):\n self._logger.debug(f\"Loading Spacy Data Model : {self._model}... Could take time.\")\n self._nlp = spacy.load(self._model)\n self._logger.debug(\"Successfully loaded Spacy Data !\")\n\n # === Load entities ===\n if PIPE_ENTITY not in self._nlp.pipe_names:\n self._nlp.add_pipe(PIPE_ENTITY, last=True)\n\n entity_pipe = self._nlp.get_pipe(PIPE_ENTITY)\n for entity in self._entities:\n entity_pipe.add_label(entity)\n\n # === Load categories ===\n if PIPE_INTENT not in self._nlp.pipe_names:\n self._nlp.add_pipe(PIPE_INTENT, last=True)\n\n intent_pipe = self._nlp.get_pipe(PIPE_INTENT)\n for intent in self._intents:\n intent_pipe.add_label(intent)","def loadModel(self, model_file):\n with open(model_file) as f:\n self.q_table = json.load(f)","def load_model(self, path):\n self._model = keras_load_model(path)","def load_model(self, name: str):\n\n # Loading config\n self.cM = ConfigManager(name + \".cfg\")\n\n # Loading Vocabs\n out_voc = pickle.load(open(name + \".out_voc\", \"rb\"))\n in_voc = pickle.load(open(name + \".in_voc\", \"rb\"))\n\n self.output_field.vocab = out_voc\n self.input_field.vocab = in_voc\n\n num_classes = len(self.output_field.vocab)\n embed = nn.Embedding.from_pretrained(self.input_field.vocab.vectors)\n self.network = FrameIDNetwork(self.cM, embed, num_classes)\n\n self.network.load_model(name + \".ph\")","def load_model():\r\n model = MobileNetV2(weights=\"imagenet\")\r\n print(\"Model loaded\")\r\n return model","def build_model():","def loadModel(file_name):\n with open(SAVE_PATH + file_name, \"rb\") as in_file:\n model = pickle.load(in_file, encoding = \"uft-8\")\n print(\"{} loaded\".format(file_name))\n return model","def load_model(self):\n self.__model = tf.keras.models.load_model(\n os.path.join(self.model_path, \"model.h5\")\n )\n print(\"[INFO] Model loaded!\")\n\n tok_pth = os.path.join(self.model_path, \"tokenizer.json\")\n with open(tok_pth, \"r\") as f:\n self.__tokenizer = tf.keras\\\n .preprocessing\\\n .text\\\n .tokenizer_from_json(f.read())\n print(\"[INFO] Tokenizer loaded!\")\n\n meta_pth = os.path.join(self.model_path, \"meta.json\")\n with open(meta_pth, \"r\") as f:\n meta = json.load(f)\n self.__title_len = meta[\"title_pad_length\"]\n self.__body_len = meta[\"body_pad_length\"]\n\n self.load_explainer()\n print(\"[INFO] Explainer loaded!\")","def create_model(self):\n try:\n self.model = PPO2.load(self.save_path)\n self.model.set_env(self.env)\n print(\"Loading of the latest model successful!\")\n except:\n print(\"Creating new model...\")\n self.model = PPO2(CnnPolicy, self.env, verbose=1)","def __load(self, model_name):\n\n print(\"Loading model.\")\n tstart = datetime.now()\n\n # Temporary directory to extract the zipped information\n with tempfile.TemporaryDirectory() as dirpath:\n\n # Unzip the directory that contains the saved model(s)\n with zipfile.ZipFile(model_name + \".zip\", \"r\") as zip_ref:\n zip_ref.extractall(dirpath)\n\n # Load metadata\n metadata = pickle.load(open(dirpath + \"/metadata.pickle\", \"rb\"))\n\n # Re-load metadata\n self.__dict__.update(metadata)\n\n # Load all sub-models\n try:\n self.__mol_to_latent_model = load_model(\n dirpath + \"/mol_to_latent_model.h5\"\n )\n except:\n print(\"'mol_to_latent_model' not found, setting to None.\")\n self.__mol_to_latent_model = None\n\n self.__latent_to_states_model = load_model(\n dirpath + \"/latent_to_states_model.h5\"\n )\n self.__batch_model = load_model(dirpath + \"/batch_model.h5\")\n \n # Build sample_model out of the trained batch_model\n self.__build_sample_model(batch_input_length=1) # Single-output model\n self.__build_sample_model(\n batch_input_length=256 # could also be self.batch_size\n ) # Multi-output model\n\n print(\"Loading finished in %i seconds.\" % ((datetime.now() - tstart).seconds))","def load_model():\n\t# Load model options\n\tprint ('Loading model parameters...')\n\twith open('%s.pkl'%path_to_umodel, 'rb') as f:\n\t\tuoptions = pkl.load(f)\n\twith open('%s.pkl'%path_to_bmodel, 'rb') as f:\n\t\tboptions = pkl.load(f)\n\n\t# Load parameters\n\tuparams = init_params(uoptions)\n\tuparams = load_params(path_to_umodel, uparams)\n\tutparams = init_tparams(uparams)\n\tbparams = init_params_bi(boptions)\n\tbparams = load_params(path_to_bmodel, bparams)\n\tbtparams = init_tparams(bparams)\n\n\t# Extractor functions\n\tprint ('Compiling encoders...')\n\tembedding, x_mask, ctxw2v = build_encoder(utparams, uoptions)\n\tf_w2v = theano.function([embedding, x_mask], ctxw2v, name='f_w2v')\n\tembedding, x_mask, ctxw2v = build_encoder_bi(btparams, boptions)\n\tf_w2v2 = theano.function([embedding, x_mask], ctxw2v, name='f_w2v2')\n\n\t# Tables\n\tprint ('Loading tables...')\n\tutable, btable = load_tables()\n\n\t# Store everything we need in a dictionary\n\tprint ('Packing up...')\n\tmodel = {}\n\tmodel['uoptions'] = uoptions\n\tmodel['boptions'] = boptions\n\tmodel['utable'] = utable\n\tmodel['btable'] = btable\n\tmodel['f_w2v'] = f_w2v\n\tmodel['f_w2v2'] = f_w2v2\n\n\treturn model","def load_model(name):\n\tmodel = joblib.load(\"data/{}/{}.model\".format(name, name))\n\t# Setting n_jobs to 1 in case it was set to a higher number while training the model seems to makes predictions of single samples much faster.\n\tmodel.n_jobs = 1\n\treturn model","def load_model(PATH):\n model = torch.load(PATH)\n model.eval()\n return model","def load(model_path: str):\n model = torch.load(model_path)\n model.eval()\n return model","def load_model(self, model_path):\n # Check the model file exists\n if not os.path.isfile(model_path):\n raise ValueError(f\"The model file `{model_path}` is not exists or broken!\")\n\n checkpoint = torch.load(model_path)\n self.model_type = checkpoint['model_type']\n self.label2idx = checkpoint['label2idx']\n self.idx2label = checkpoint['idx2label']\n self.model.load_state_dict(checkpoint['model_state_dict'])\n self.model.to(self.device)","def load_model(path):\n # for example -> f\"{os.getcwd()}/trained_models\"\n return spacy.load(path)","def load_model(model_path):\n nlp = spacy.blank('en') \n if 'ner' not in nlp.pipe_names:\n ner = nlp.create_pipe('ner')\n nlp.add_pipe(ner)\n #load pretrained model from the path\n ner = nlp.from_disk(model_path)\n return ner","def load_model():\n global obj\n obj = NutritionTableDetector()\n print(\"Weights Loaded!\")","def MakeModel(self):\n pass","def loadModel(self):\n self._model.load_weights('my_model')\n return None","def loadAdjustedModel(self):\r\n # Load model in GUI\r\n addModel(self.trcFilePath.replace('.trc','.osim'))","def load(self, model_name_or_path):\n return BertMLM(model_name_or_path, self.top_k)","def load(self):\n if self.model is None:\n raise Exception(\"Build the model first.\")\n\n print(\"Loading model checkpoint {} ...\\n\".format(self.config[\"model\"][\"restore_model\"]))\n self.model.load_weights(self.config[\"model\"][\"restore_model\"])\n print(\"Model loaded!\")","def load(self):\n if self.model is None:\n raise Exception(\"Build the model first.\")\n\n print(\"Loading model checkpoint {} ...\\n\".format(self.config[\"model\"][\"restore_model\"]))\n self.model.load_weights(self.config[\"model\"][\"restore_model\"])\n print(\"Model loaded!\")","def get_model():\n global model\n if model is None:\n model = AppModel()\n model.load_resources()\n return model","def load_model(\n model_path=filepath + \"/trained_models/hi2en/\", model_file_name=\"model.h5\"\n):\n model_path = (\n filepath + \"/trained_models/{}/\".format(model_path)\n if model_path in [\"en2hi\", \"hi2en\"]\n else model_path\n )\n config = SConfig(configuration_file=model_path + \"config.pkl\")\n s2s = Seq2Seq(config)\n s2s.load_model(path_to_model=model_path, model_file_name=model_file_name)\n return s2s"],"string":"[\n \"def load_model(self) -> Any:\",\n \"def load(path_to_model):\\n pass\",\n \"def load_model(self):\\n pass\",\n \"def load_model(self, model_path: str):\",\n \"def _load_model(self):\\n with open(self.filepath, 'rb') as file:\\n self.cmodel = pickle.load(file)\",\n \"def load_model(self, path):\\n pass\",\n \"def load_model() -> None:\\n global model\\n\\n if app.testing:\\n current_dir = os.path.dirname(__file__)\\n model_path = os.path.join(current_dir, \\\"models/model.pkl\\\")\\n else:\\n model_path = os.getenv(\\\"PATH_TO_MODEL\\\")\\n\\n if model_path is None:\\n err = f\\\"PATH_TO_MODEL {model_path} is None\\\"\\n raise RuntimeError(err)\\n\\n with open(model_path, \\\"rb\\\") as model_file:\\n model = pickle.load(model_file)\",\n \"def __load_model(self):\\n loaded = load(self.__file_name)\\n self.__model = loaded['model']\\n self.__meta_data = loaded['metadata']\\n self.__is_ready = True\",\n \"def load(\\n self,\\n modelLoadPath\\n ):\\n pass\",\n \"def load_model(self, filename):\\r\\n pass\",\n \"def load_model():\\n\\n # find location of model\\n\\n file_path = '/Users/davidodwyer/Desktop' # to the directory\\n file_name = 'original_mlr.joblib' \\n the_file = os.path.join(file_path, file_name)\\n\\n # load model\\n\\n model = load(the_file)\\n\\n return model\",\n \"def load(self, path):\\n load_model(path, self)\",\n \"def load_model(self, file=None):\\n return None\",\n \"def load_model(model_name):\\r\\n model = joblib.load(model_name)\\r\\n return model\",\n \"def load_model(self, fname):\\n if self._Booster is None:\\n self._Booster = Booster({'nthread': self.n_jobs})\\n self._Booster.load_model(fname)\",\n \"def load_model():\\n with open(MODEL_SAVE_JSON, 'r') as fp:\\n json_string = fp.read()\\n model = model_from_json(json_string)\\n return model\",\n \"def load_model(self) -> None:\\n\\n try:\\n model_class = MODEL_TYPES[self.model_type]\\n except KeyError:\\n raise KeyError(f\\\"model type: {self.model_type} not supported\\\")\\n\\n if (\\n os.path.exists(self.resources_path)\\n and len(os.listdir(self.resources_path)) > 0\\n ):\\n model_name_or_path = self.resources_path\\n else:\\n model_name_or_path = self.model_name\\n\\n if self.model_type == \\\"stable_diffusion\\\":\\n self.model = model_class.from_pretrained(\\n model_name_or_path,\\n use_auth_token=self.auth_token,\\n )\\n else:\\n self.model = model_class.from_pretrained(model_name_or_path)\\n\\n self.model.to(self.device)\",\n \"def load_model():\\n with open(MODEL_FILENAME, \\\"rb\\\") as file:\\n model = pickle.load(file)\\n return model\",\n \"def load_model(self):\\r\\n try:\\r\\n self.model = CRNN_STN(self.crnn_cfg())\\r\\n self.model.load_weights(config.CRNN_Model_Path)\\r\\n except:\\r\\n print('Error in method {0} in module {1}'.format('load_model', 'crnn_bridge.py'))\",\n \"def load_model():\\n global columns\\n global data\\n \\n model = pickle.load(open('MedCostModel.pkl', 'rb'))\\n data = pd.read_csv('MedCosts.csv')\\n data = data.drop(columns=['charges'])\\n columns = data.columns\\n return(model)\",\n \"def load_model_from_file(path, as_builder=False):\\n module = load_model_module(path)\\n model = module.model\\n if not as_builder:\\n model = model()\\n del sys.path_importer_cache[os.path.dirname(module.__file__)]\\n del sys.modules[module.__name__]\\n return model\",\n \"def load_model(model_path: str) -> object:\\n model = torch.load(model_path)\\n model.eval()\\n return model\",\n \"def load_model(self):\\n # Load the model\\n print('Loading model:', self.model_path)\\n t0 = time.time()\\n model = load_model(self.model_path)\\n t1 = time.time()\\n print('Loaded in:', t1 - t0)\\n return model\",\n \"def load_model():\\n with open('../model/regressor.pickle', 'rb') as f:\\n model = pickle.load(f)\\n return model\",\n \"def initialize(self) -> None:\\n self.model = load(self.path)\",\n \"def load_model(self, path_model: Optional[PathLike]) -> None:\\n raise NotImplementedError\",\n \"def _get_model():\\n with open('models/catapp_gp_model.pickle', 'rb') as modelfile:\\n model = pickle.load(modelfile)\\n return model\",\n \"def load_model():\\n global model_tok, model_mlm, model, model_cls\\n if model is None:\\n model_name_or_path = os.getenv('TRANSFORMER_MODEL', default='distilbert-base-multilingual-cased')\\n # 'bert-base-multilingual-cased'\\n model_tok = AutoTokenizer.from_pretrained(model_name_or_path)\\n model_mlm = AutoModelForMaskedLM.from_pretrained(model_name_or_path)\\n model_mlm.eval()\\n model = model_mlm.base_model\\n\\n if isinstance(model_mlm, BertPreTrainedModel):\\n model_cls = model_mlm.cls\\n elif isinstance(model_mlm, DistilBertPreTrainedModel):\\n model_cls = nn.Sequential(\\n model_mlm.vocab_transform,\\n nn.GELU(),\\n model_mlm.vocab_layer_norm,\\n model_mlm.vocab_projector\\n )\\n else:\\n raise ValueError(f'{model_name_or_path} is not supported yet. try one of '\\n f'{\\\", \\\".join(list(AvailableModels.__members__.keys()))}')\\n model.to(device)\\n model_mlm.to(device)\\n # model_tok.to(device)\\n model_cls.to(device)\",\n \"def _get_model():\\n freezing = os.environ.get('NAUCSE_FREEZE', not app.config['DEBUG'])\\n initialize = True\\n\\n try:\\n g.model = app.config['NAUCSE_MODEL']\\n except KeyError:\\n g.model = init_model()\\n app.config['NAUCSE_MODEL'] = g.model\\n else:\\n if freezing:\\n # Model already initialized; don't look for changes\\n return\\n\\n # (Re-)initialize model\\n\\n g.model.load_licenses(Path(app.root_path).parent / 'licenses')\\n g.model.load_local_courses(Path(app.root_path).parent)\\n\\n if freezing:\\n g.model.freeze()\",\n \"def load_model(self):\\n Thread(target=self.__load_model).start()\",\n \"def load_model(app: FastAPI) -> None:\\n\\n logging.info(\\\"Starting up the application\\\")\\n model_path = DATA_MODEL_PATH\\n\\n if model_path.exists():\\n model = FraudDetection(model_path)\\n app.state.model = model\\n logging.info(f\\\"Loaded model {model_path}\\\")\\n else:\\n app.state.model = FraudDetection()\\n logging.warning(f\\\"No existing model found in {model_path}\\\")\",\n \"def load_model():\\n with open(paths.model('model.pkl'), 'rb') as stream:\\n return pickle.load(stream)\",\n \"def model() -> Any:\\n with open(\\\"airbnb_regressor.pickle\\\",\\\"rb\\\") as f:\\n model = pickle.load(f)\\n return model\",\n \"async def load_model(\\n self,\\n model_name: str,\\n headers: dict[str, t.Any] = ...,\\n config: str = ...,\\n files: dict[str, str] = ...,\\n ) -> None:\",\n \"def load_model(self, tmp_dir):\\n pass\",\n \"def load_model(self, fname):\\n cxnlib.CXNNetLoadModel(self.handle, fname)\",\n \"def load_model():\\n logger.info('load_model called')\\n return 1\",\n \"def test_load_model():\\n model = BERTopic(language=\\\"Dutch\\\", embedding_model=None, n_components=12)\\n model.save(\\\"test\\\")\\n loaded_model = BERTopic.load(\\\"test\\\")\\n assert type(model) == type(loaded_model)\\n assert model.language == loaded_model.language\\n assert model.embedding_model == loaded_model.embedding_model\\n assert model.top_n_words == loaded_model.top_n_words\\n assert model.n_neighbors == loaded_model.n_neighbors\\n assert model.n_components == loaded_model.n_components\",\n \"def importModel(model_name):\\n module_path = os.path.join(path, \\\"models\\\")\\n module_path = os.path.join(module_path, model_name + \\\".py\\\")\\n model = importClass(model_name, model_name, module_path)\\n return model\",\n \"def load(self):\\n print(\\\"==> Loading model from\\\", self.model_dir)\\n self.model = tf.keras.models.load_model(self.model_dir)\",\n \"def load_model(self, filename):\\n filename = path.join(self.root_path, f'models/{filename}.pkl')\\n self.model = pickle.load(open(filename, \\\"rb\\\"))\\n print('Successfully loaded model from '+filename)\",\n \"def load(self, file_path):\\n self.model = load_model(file_path)\",\n \"def load(self, file_path):\\n self.model = load_model(file_path)\",\n \"def load(self, file_path):\\n self.model = load_model(file_path)\",\n \"def load_model():\\n return \\\"None\\\"\",\n \"def load_model(cls) -> Classifier:\\n if cls.model is None:\\n cls.model = Classifier.load(model_path)\\n return cls.model\",\n \"def load_model(self, folder_name):\\n raise NotImplementedError()\",\n \"def load_model(self):\\n try:\\n self.model = Word2Vec.load(self.config[\\\"model_path\\\"])\\n self.model.init_sims(replace=True)\\n except Exception as e:\\n print(e)\\n print(\\\"error in model loading!\\\")\",\n \"def load_model(self, sess, pb_model_path):\\n\\n logging.info(\\\"Import yolo model from pb start .......\\\")\\n\\n with sess.as_default():\\n with sess.graph.as_default():\\n with tf.gfile.FastGFile(pb_model_path, 'rb') as f_handle:\\n logging.info(\\\"ParseFromString start .......\\\")\\n graph_def = tf.GraphDef()\\n graph_def.ParseFromString(f_handle.read())\\n logging.info(\\\"ParseFromString end .......\\\")\\n\\n tf.import_graph_def(graph_def, name='')\\n logging.info(\\\"Import_graph_def end .......\\\")\\n\\n logging.info(\\\"Import yolo model from pb end .......\\\")\",\n \"def load_seq_model():\\n model = joblib.load(os.path.join(os.path.dirname(__file__), 'RuleSet3.pkl'))\\n return model\",\n \"def load_model(bento_model: str | Tag | Model) -> ModelType: # noqa\\n if not isinstance(bento_model, Model):\\n bento_model = get(bento_model)\\n\\n if bento_model.info.module not in (MODULE_NAME, __name__):\\n raise NotFound(\\n f\\\"Model {bento_model.tag} was saved with module {bento_model.info.module}, not loading with {MODULE_NAME}.\\\"\\n )\\n\\n model_file = bento_model.path_of(f\\\"{SAVE_NAMESPACE}{PKL_EXT}\\\")\\n\\n with open(model_file, \\\"rb\\\") as f:\\n # The protocol version used is detected automatically, so we do not\\n # have to specify it.\\n return cloudpickle.load(f)\",\n \"def load_model(fname: os.PathLike) -> Model:\\n return Model.load(fname)\",\n \"def load_model():\\n prepro = Prepro(PATH_STOPSWORD, PATH_ACRONYM)\\n vectorizer = joblib.load(PATH_TFIDF)\\n label_encoder = joblib.load(PATH_ENCODER)\\n model_svm = joblib.load(PATH_SVM)\\n model_nb = joblib.load(PATH_NB)\\n model_lr = joblib.load(PATH_LR)\\n return prepro, vectorizer, label_encoder, model_svm, model_nb, model_lr\",\n \"def _load_model(self):\\n super()._load_model()\\n\\n # Adjust base pose(s) accordingly\\n if self.env_configuration == \\\"bimanual\\\":\\n xpos = self.robots[0].robot_model.base_xpos_offset[\\\"table\\\"](self.table_full_size[0])\\n self.robots[0].robot_model.set_base_xpos(xpos)\\n else:\\n if self.env_configuration == \\\"single-arm-opposed\\\":\\n # Set up robots facing towards each other by rotating them from their default position\\n for robot, rotation in zip(self.robots, (np.pi/2, -np.pi/2)):\\n xpos = robot.robot_model.base_xpos_offset[\\\"table\\\"](self.table_full_size[0])\\n rot = np.array((0, 0, rotation))\\n xpos = T.euler2mat(rot) @ np.array(xpos)\\n robot.robot_model.set_base_xpos(xpos)\\n robot.robot_model.set_base_ori(rot)\\n else: # \\\"single-arm-parallel\\\" configuration setting\\n # Set up robots parallel to each other but offset from the center\\n for robot, offset in zip(self.robots, (-0.25, 0.25)):\\n xpos = robot.robot_model.base_xpos_offset[\\\"table\\\"](self.table_full_size[0])\\n xpos = np.array(xpos) + np.array((0, offset, 0))\\n robot.robot_model.set_base_xpos(xpos)\\n\\n # load model for table top workspace\\n self.mujoco_arena = TableArena(\\n table_full_size=self.table_full_size, table_friction=self.table_friction\\n )\\n if self.use_indicator_object:\\n self.mujoco_arena.add_pos_indicator()\\n\\n # Arena always gets set to zero origin\\n self.mujoco_arena.set_origin([0, 0, 0])\\n\\n # initialize objects of interest\\n self.pot = PotWithHandlesObject()\\n self.mujoco_objects = OrderedDict([(\\\"pot\\\", self.pot)])\\n\\n # task includes arena, robot, and objects of interest\\n self.model = TableTopTask(\\n self.mujoco_arena,\\n [robot.robot_model for robot in self.robots],\\n self.mujoco_objects,\\n initializer=self.placement_initializer,\\n )\\n self.model.place_objects()\",\n \"def load_model(self, **params):\\n \\t# file_name = params['name']\\n # return pickle.load(gzip.open(file_name, 'rb'))\",\n \"def load_model(self, model_as_bytes: bytes) -> None:\\n\\n self.model = deserialize_from_zippy(model_as_bytes)\",\n \"def import_model(model_name, clear=True):\\n file_name = os.path.join(settings.GAME_DIR, settings.WORLD_DATA_FOLDER, model_name)\\n import_file(file_name, model_name, widecard=True, clear=clear)\",\n \"def load_model(filename):\\n return Model.load_savefile(filename)\",\n \"def import_model(path=None):\\n path = get_model_path() if path is None else path\\n return torch.jit.load(path)\",\n \"def _load_model(self):\\n self._load_scaler('scaler.save')\\n self._load_encoder('encoder0.save', 0)\\n self._load_encoder('encoder1.save', 1)\\n self._load_neural_network('model.json', 'model.h5')\\n return\",\n \"def load_model(self, model_path):\\n\\n\\t\\tmodel_path = osp.abspath(model_path)\\n\\t\\tmodel_weights_path = osp.splitext(model_path)[0] + \\\".bin\\\"\\n\\n\\t\\tself.Helpers.logger.info(\\\"Loading the model from '%s'\\\" % (model_path))\\n\\t\\tmodel = self.context.ie_core.read_network(model_path, model_weights_path)\\n\\t\\tself.Helpers.logger.info(\\\"Model loaded\\\")\\n\\n\\t\\treturn model\",\n \"def read_model( path ):\\n path = os.path.join(models_folder,path + '.pck' )\\n with open( path , 'r') as f:\\n model = pickle.load(f)\\n return model\",\n \"def load_model(self):\\n return joblib.load(self.MODEL_PATH)\",\n \"def load(model_file):\\n return pickle.load(open(model_file))\",\n \"def make_model():\\n m = model_class(*argv[2:-1])\\n modelobj[\\\"model\\\"] = m\",\n \"def load_model(self):\\n if self.save_path is not None:\\n if isfile(self.save_path):\\n self.model.load_state_dict(load(self.save_path))\\n else:\\n raise ValueError(\\\"Cannot find model save file: \\\" + self.save_path)\",\n \"def loadModel(self):\\n#FLAG: still waiting on boost image\\n\\t\\tself.form = loader.loadModel(\\\"models/panda-model\\\")\\n\\t\\tself.form.setScape(.005)\\n\\t\\tself.form.reparentTo(render)\",\n \"def load_model(self, filename):\\n model_object = self.s3_resource.Object(self.bucket_name, self.models_path + str(filename)).get()['Body'].read()\\n model = pickle.loads(model_object)\\n return model\",\n \"def load_model(self):\\n if os.stat('code/lr-model.pt').st_size == 0:\\n return\\n params = torch.load('code/lr-model.pt')\\n self.set_params(params)\",\n \"def LoadModel(self):\\n\\t\\tself.form = loader.loadModel(\\\"models/lampExport\\\")\\n\\t\\t#self.form.setScale(.007)\\n\\t\\tself.form.reparentTo(render)\\n\\t\\tself.form.setPos(self.xpos, self.ypos, -30)\",\n \"def import_model(file):\\n file = os.path.expanduser(file)\\n obj = IsolationForest()\\n metadata = obj._cpp_obj.deserialize_obj(file)\\n metadata = json.loads(metadata)\\n obj._take_metadata(metadata)\\n return obj\",\n \"def load_model(model_name, MODEL_DIR):\\n model_def_path = os.path.join(MODEL_DIR, model_name + '.py')\\n weights_path = os.path.join(MODEL_DIR, model_name + '.pth')\\n mod = load_module_2or3(model_name, model_def_path)\\n func = getattr(mod, model_name)\\n net = func(weights_path=weights_path)\\n return net\",\n \"def load_model(self, model_path, load_ae=True, map_location='cpu'):\\n assert load_ae and (self.ae_net is not None), 'The trainer has not been initialized with an Autoencoder. It can thus not be loaded.'\\n model_dict = torch.load(model_path, map_location=map_location)\\n self.c = model_dict['c']\\n self.net.load_state_dict(model_dict['net_dict'])\\n\\n if load_ae and (self.ae_net is not None):\\n self.ae_net.load_state_dict(model_dict['ae_net_dict'])\",\n \"def load_model(self, path):\\n try:\\n self.model = joblib.load(path)\\n except Exception as e:\\n print(e)\\n print(\\\"Couldn't load scikit learn model on path {}!\\\".format(path))\",\n \"def load_model(self):\\n self._logger.debug(f\\\"Loading Spacy Data Model : {self._model}... Could take time.\\\")\\n self._nlp = spacy.load(self._model)\\n self._logger.debug(\\\"Successfully loaded Spacy Data !\\\")\\n\\n # === Load entities ===\\n if PIPE_ENTITY not in self._nlp.pipe_names:\\n self._nlp.add_pipe(PIPE_ENTITY, last=True)\\n\\n entity_pipe = self._nlp.get_pipe(PIPE_ENTITY)\\n for entity in self._entities:\\n entity_pipe.add_label(entity)\\n\\n # === Load categories ===\\n if PIPE_INTENT not in self._nlp.pipe_names:\\n self._nlp.add_pipe(PIPE_INTENT, last=True)\\n\\n intent_pipe = self._nlp.get_pipe(PIPE_INTENT)\\n for intent in self._intents:\\n intent_pipe.add_label(intent)\",\n \"def loadModel(self, model_file):\\n with open(model_file) as f:\\n self.q_table = json.load(f)\",\n \"def load_model(self, path):\\n self._model = keras_load_model(path)\",\n \"def load_model(self, name: str):\\n\\n # Loading config\\n self.cM = ConfigManager(name + \\\".cfg\\\")\\n\\n # Loading Vocabs\\n out_voc = pickle.load(open(name + \\\".out_voc\\\", \\\"rb\\\"))\\n in_voc = pickle.load(open(name + \\\".in_voc\\\", \\\"rb\\\"))\\n\\n self.output_field.vocab = out_voc\\n self.input_field.vocab = in_voc\\n\\n num_classes = len(self.output_field.vocab)\\n embed = nn.Embedding.from_pretrained(self.input_field.vocab.vectors)\\n self.network = FrameIDNetwork(self.cM, embed, num_classes)\\n\\n self.network.load_model(name + \\\".ph\\\")\",\n \"def load_model():\\r\\n model = MobileNetV2(weights=\\\"imagenet\\\")\\r\\n print(\\\"Model loaded\\\")\\r\\n return model\",\n \"def build_model():\",\n \"def loadModel(file_name):\\n with open(SAVE_PATH + file_name, \\\"rb\\\") as in_file:\\n model = pickle.load(in_file, encoding = \\\"uft-8\\\")\\n print(\\\"{} loaded\\\".format(file_name))\\n return model\",\n \"def load_model(self):\\n self.__model = tf.keras.models.load_model(\\n os.path.join(self.model_path, \\\"model.h5\\\")\\n )\\n print(\\\"[INFO] Model loaded!\\\")\\n\\n tok_pth = os.path.join(self.model_path, \\\"tokenizer.json\\\")\\n with open(tok_pth, \\\"r\\\") as f:\\n self.__tokenizer = tf.keras\\\\\\n .preprocessing\\\\\\n .text\\\\\\n .tokenizer_from_json(f.read())\\n print(\\\"[INFO] Tokenizer loaded!\\\")\\n\\n meta_pth = os.path.join(self.model_path, \\\"meta.json\\\")\\n with open(meta_pth, \\\"r\\\") as f:\\n meta = json.load(f)\\n self.__title_len = meta[\\\"title_pad_length\\\"]\\n self.__body_len = meta[\\\"body_pad_length\\\"]\\n\\n self.load_explainer()\\n print(\\\"[INFO] Explainer loaded!\\\")\",\n \"def create_model(self):\\n try:\\n self.model = PPO2.load(self.save_path)\\n self.model.set_env(self.env)\\n print(\\\"Loading of the latest model successful!\\\")\\n except:\\n print(\\\"Creating new model...\\\")\\n self.model = PPO2(CnnPolicy, self.env, verbose=1)\",\n \"def __load(self, model_name):\\n\\n print(\\\"Loading model.\\\")\\n tstart = datetime.now()\\n\\n # Temporary directory to extract the zipped information\\n with tempfile.TemporaryDirectory() as dirpath:\\n\\n # Unzip the directory that contains the saved model(s)\\n with zipfile.ZipFile(model_name + \\\".zip\\\", \\\"r\\\") as zip_ref:\\n zip_ref.extractall(dirpath)\\n\\n # Load metadata\\n metadata = pickle.load(open(dirpath + \\\"/metadata.pickle\\\", \\\"rb\\\"))\\n\\n # Re-load metadata\\n self.__dict__.update(metadata)\\n\\n # Load all sub-models\\n try:\\n self.__mol_to_latent_model = load_model(\\n dirpath + \\\"/mol_to_latent_model.h5\\\"\\n )\\n except:\\n print(\\\"'mol_to_latent_model' not found, setting to None.\\\")\\n self.__mol_to_latent_model = None\\n\\n self.__latent_to_states_model = load_model(\\n dirpath + \\\"/latent_to_states_model.h5\\\"\\n )\\n self.__batch_model = load_model(dirpath + \\\"/batch_model.h5\\\")\\n \\n # Build sample_model out of the trained batch_model\\n self.__build_sample_model(batch_input_length=1) # Single-output model\\n self.__build_sample_model(\\n batch_input_length=256 # could also be self.batch_size\\n ) # Multi-output model\\n\\n print(\\\"Loading finished in %i seconds.\\\" % ((datetime.now() - tstart).seconds))\",\n \"def load_model():\\n\\t# Load model options\\n\\tprint ('Loading model parameters...')\\n\\twith open('%s.pkl'%path_to_umodel, 'rb') as f:\\n\\t\\tuoptions = pkl.load(f)\\n\\twith open('%s.pkl'%path_to_bmodel, 'rb') as f:\\n\\t\\tboptions = pkl.load(f)\\n\\n\\t# Load parameters\\n\\tuparams = init_params(uoptions)\\n\\tuparams = load_params(path_to_umodel, uparams)\\n\\tutparams = init_tparams(uparams)\\n\\tbparams = init_params_bi(boptions)\\n\\tbparams = load_params(path_to_bmodel, bparams)\\n\\tbtparams = init_tparams(bparams)\\n\\n\\t# Extractor functions\\n\\tprint ('Compiling encoders...')\\n\\tembedding, x_mask, ctxw2v = build_encoder(utparams, uoptions)\\n\\tf_w2v = theano.function([embedding, x_mask], ctxw2v, name='f_w2v')\\n\\tembedding, x_mask, ctxw2v = build_encoder_bi(btparams, boptions)\\n\\tf_w2v2 = theano.function([embedding, x_mask], ctxw2v, name='f_w2v2')\\n\\n\\t# Tables\\n\\tprint ('Loading tables...')\\n\\tutable, btable = load_tables()\\n\\n\\t# Store everything we need in a dictionary\\n\\tprint ('Packing up...')\\n\\tmodel = {}\\n\\tmodel['uoptions'] = uoptions\\n\\tmodel['boptions'] = boptions\\n\\tmodel['utable'] = utable\\n\\tmodel['btable'] = btable\\n\\tmodel['f_w2v'] = f_w2v\\n\\tmodel['f_w2v2'] = f_w2v2\\n\\n\\treturn model\",\n \"def load_model(name):\\n\\tmodel = joblib.load(\\\"data/{}/{}.model\\\".format(name, name))\\n\\t# Setting n_jobs to 1 in case it was set to a higher number while training the model seems to makes predictions of single samples much faster.\\n\\tmodel.n_jobs = 1\\n\\treturn model\",\n \"def load_model(PATH):\\n model = torch.load(PATH)\\n model.eval()\\n return model\",\n \"def load(model_path: str):\\n model = torch.load(model_path)\\n model.eval()\\n return model\",\n \"def load_model(self, model_path):\\n # Check the model file exists\\n if not os.path.isfile(model_path):\\n raise ValueError(f\\\"The model file `{model_path}` is not exists or broken!\\\")\\n\\n checkpoint = torch.load(model_path)\\n self.model_type = checkpoint['model_type']\\n self.label2idx = checkpoint['label2idx']\\n self.idx2label = checkpoint['idx2label']\\n self.model.load_state_dict(checkpoint['model_state_dict'])\\n self.model.to(self.device)\",\n \"def load_model(path):\\n # for example -> f\\\"{os.getcwd()}/trained_models\\\"\\n return spacy.load(path)\",\n \"def load_model(model_path):\\n nlp = spacy.blank('en') \\n if 'ner' not in nlp.pipe_names:\\n ner = nlp.create_pipe('ner')\\n nlp.add_pipe(ner)\\n #load pretrained model from the path\\n ner = nlp.from_disk(model_path)\\n return ner\",\n \"def load_model():\\n global obj\\n obj = NutritionTableDetector()\\n print(\\\"Weights Loaded!\\\")\",\n \"def MakeModel(self):\\n pass\",\n \"def loadModel(self):\\n self._model.load_weights('my_model')\\n return None\",\n \"def loadAdjustedModel(self):\\r\\n # Load model in GUI\\r\\n addModel(self.trcFilePath.replace('.trc','.osim'))\",\n \"def load(self, model_name_or_path):\\n return BertMLM(model_name_or_path, self.top_k)\",\n \"def load(self):\\n if self.model is None:\\n raise Exception(\\\"Build the model first.\\\")\\n\\n print(\\\"Loading model checkpoint {} ...\\\\n\\\".format(self.config[\\\"model\\\"][\\\"restore_model\\\"]))\\n self.model.load_weights(self.config[\\\"model\\\"][\\\"restore_model\\\"])\\n print(\\\"Model loaded!\\\")\",\n \"def load(self):\\n if self.model is None:\\n raise Exception(\\\"Build the model first.\\\")\\n\\n print(\\\"Loading model checkpoint {} ...\\\\n\\\".format(self.config[\\\"model\\\"][\\\"restore_model\\\"]))\\n self.model.load_weights(self.config[\\\"model\\\"][\\\"restore_model\\\"])\\n print(\\\"Model loaded!\\\")\",\n \"def get_model():\\n global model\\n if model is None:\\n model = AppModel()\\n model.load_resources()\\n return model\",\n \"def load_model(\\n model_path=filepath + \\\"/trained_models/hi2en/\\\", model_file_name=\\\"model.h5\\\"\\n):\\n model_path = (\\n filepath + \\\"/trained_models/{}/\\\".format(model_path)\\n if model_path in [\\\"en2hi\\\", \\\"hi2en\\\"]\\n else model_path\\n )\\n config = SConfig(configuration_file=model_path + \\\"config.pkl\\\")\\n s2s = Seq2Seq(config)\\n s2s.load_model(path_to_model=model_path, model_file_name=model_file_name)\\n return s2s\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75577265","0.74616426","0.7443691","0.72105366","0.71995646","0.71612245","0.70299786","0.697022","0.6902634","0.68662226","0.66627985","0.66133004","0.6587798","0.65446216","0.6522303","0.6507763","0.64993095","0.64980847","0.6494972","0.6485254","0.64752454","0.64730054","0.6469352","0.6450105","0.64420164","0.64325947","0.6416777","0.64118385","0.6409179","0.6396938","0.6392324","0.63864785","0.6348153","0.6333881","0.6300645","0.6294058","0.62667114","0.6266276","0.62614936","0.6255885","0.6251951","0.6251749","0.6251749","0.6251749","0.623155","0.6200654","0.6187163","0.61787146","0.61773074","0.6163758","0.61491567","0.61484337","0.61460644","0.6134452","0.6117104","0.6112158","0.6095836","0.6091198","0.608517","0.60796976","0.60743546","0.6070618","0.6065973","0.6063698","0.60636383","0.6056774","0.60415316","0.6022964","0.6018481","0.60058886","0.6005483","0.59933066","0.598904","0.5986746","0.5979698","0.5976873","0.5975668","0.5965815","0.59620947","0.595866","0.59510136","0.59478337","0.5941467","0.5940821","0.5935083","0.593477","0.5927292","0.5927211","0.59193295","0.59158117","0.5911485","0.59036595","0.59007776","0.5898306","0.5895827","0.5895532","0.5884994","0.5884994","0.58843416","0.58810186"],"string":"[\n \"0.75577265\",\n \"0.74616426\",\n \"0.7443691\",\n \"0.72105366\",\n \"0.71995646\",\n \"0.71612245\",\n \"0.70299786\",\n \"0.697022\",\n \"0.6902634\",\n \"0.68662226\",\n \"0.66627985\",\n \"0.66133004\",\n \"0.6587798\",\n \"0.65446216\",\n \"0.6522303\",\n \"0.6507763\",\n \"0.64993095\",\n \"0.64980847\",\n \"0.6494972\",\n \"0.6485254\",\n \"0.64752454\",\n \"0.64730054\",\n \"0.6469352\",\n \"0.6450105\",\n \"0.64420164\",\n \"0.64325947\",\n \"0.6416777\",\n \"0.64118385\",\n \"0.6409179\",\n \"0.6396938\",\n \"0.6392324\",\n \"0.63864785\",\n \"0.6348153\",\n \"0.6333881\",\n \"0.6300645\",\n \"0.6294058\",\n \"0.62667114\",\n \"0.6266276\",\n \"0.62614936\",\n \"0.6255885\",\n \"0.6251951\",\n \"0.6251749\",\n \"0.6251749\",\n \"0.6251749\",\n \"0.623155\",\n \"0.6200654\",\n \"0.6187163\",\n \"0.61787146\",\n \"0.61773074\",\n \"0.6163758\",\n \"0.61491567\",\n \"0.61484337\",\n \"0.61460644\",\n \"0.6134452\",\n \"0.6117104\",\n \"0.6112158\",\n \"0.6095836\",\n \"0.6091198\",\n \"0.608517\",\n \"0.60796976\",\n \"0.60743546\",\n \"0.6070618\",\n \"0.6065973\",\n \"0.6063698\",\n \"0.60636383\",\n \"0.6056774\",\n \"0.60415316\",\n \"0.6022964\",\n \"0.6018481\",\n \"0.60058886\",\n \"0.6005483\",\n \"0.59933066\",\n \"0.598904\",\n \"0.5986746\",\n \"0.5979698\",\n \"0.5976873\",\n \"0.5975668\",\n \"0.5965815\",\n \"0.59620947\",\n \"0.595866\",\n \"0.59510136\",\n \"0.59478337\",\n \"0.5941467\",\n \"0.5940821\",\n \"0.5935083\",\n \"0.593477\",\n \"0.5927292\",\n \"0.5927211\",\n \"0.59193295\",\n \"0.59158117\",\n \"0.5911485\",\n \"0.59036595\",\n \"0.59007776\",\n \"0.5898306\",\n \"0.5895827\",\n \"0.5895532\",\n \"0.5884994\",\n \"0.5884994\",\n \"0.58843416\",\n \"0.58810186\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.6683296"},"document_rank":{"kind":"string","value":"10"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":816,"numItemsPerPage":100,"numTotalItems":95772,"offset":81600,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjE1MzM5NCwianRpIjoiMGYxZGUyOWEtNDRkZS00MjdjLWEwY2EtOTIxZTc0MzljYzY1Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYxNTY5OTQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.BqABnYsf1pzZlEmjLhyIjkqQwxSnUweEH_1adi_xIfOFz-bfZNtBOhbYkjhT8mFO3vJ0bFWt5Dgytpz9Zdb0CQ","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Return a property setter/getter pair, either from a "real" property get/set pair, or a "virtual" property like "red_enabled" or "cyan_intensity". | def _get_getter_setter(self, prop):
if hasattr(self, 'set_'+prop):
return getattr(self, 'get_'+prop), getattr(self, 'set_'+prop)
else:
lamp_name, lamp_prop = prop.rsplit('_', 1)
if lamp_name not in self._available_lamps:
raise ValueError('Invalid lamp ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def Property(name):\n\n attr_name = \"__\" + name\n\n def get(self):\n try:\n return self.__dict__[attr_name]\n except KeyError:\n raise AttributeError, name\n\n def set(self, value):\n if attr_name not in self.__dict__ \\\n or self.__dict__[attr_name] ... | [
"0.6777496",
"0.6488281",
"0.6468719",
"0.6371053",
"0.62944317",
"0.62325764",
"0.61520195",
"0.6063008",
"0.605303",
"0.5963396",
"0.5923303",
"0.5914463",
"0.5900428",
"0.5866823",
"0.58495504",
"0.58495504",
"0.57912683",
"0.5725679",
"0.5702438",
"0.56925863",
"0.568346"... | 0.661035 | 1 |
Set a number of parameters at once using keyword arguments, while saving the old values of those parameters. (See lamps() for a description of valid parameters.) pop_state() will restore those previous values. push_state/pop_state pairs can be nested arbitrarily. | def push_state(self, **lamp_parameters):
# Also note that we do not filter out identical states from being pushed.
# Since the enabled state can be fiddled with IOTool, there is good reason
# for pushing an enabled state identical to the current one, so that it
# will be restored after a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __setstate__(self, state):\n if len(state) != 1:\n raise TypeError('Invalid state length, expected 1; received %i' %\n len(state))\n kwargs = state[0]\n if not isinstance(kwargs, dict):\n raise TypeError('Key accepts a dict of keyword arguments as state; '\n ... | [
"0.6715735",
"0.6636853",
"0.6192533",
"0.59777206",
"0.5968728",
"0.58457434",
"0.5819592",
"0.56664634",
"0.5593973",
"0.5544398",
"0.5472484",
"0.54617786",
"0.54078764",
"0.54078764",
"0.53941566",
"0.5388684",
"0.53712696",
"0.53363043",
"0.5308082",
"0.5276086",
"0.5271... | 0.61743826 | 3 |
Produce a command that switches the green/yellow paddle to the green filter position. | def _iotool_enable_green_command(self):
return self._iotool.commands.set_high(self._spconfig.IOTOOL_GREEN_YELLOW_SWITCH_PIN) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_green(self,command):\n if \"on\" in command:\n print 'Green ON'\n GPIO.output(22,GPIO.HIGH)\n elif \"off\" in command:\n print 'Green OFF'\n GPIO.output(22,GPIO.LOW)\n elif \"flash\" in command:\n print 'Flashing green'\n FlashPin(pin=22,count=5,delay=0.1)\n else:\n... | [
"0.6667252",
"0.6028988",
"0.6024907",
"0.5635577",
"0.539456",
"0.5389388",
"0.52197635",
"0.5214792",
"0.5152538",
"0.51346695",
"0.50763196",
"0.5059358",
"0.50518",
"0.50459635",
"0.50299966",
"0.5006441",
"0.5004159",
"0.49799615",
"0.4970993",
"0.4952227",
"0.49450052",... | 0.6651339 | 1 |
Produce a command that switches the green/yellow paddle to the yellow filter position. | def _iotool_enable_yellow_command(self):
return self._iotool.commands.set_low(self._spconfig.IOTOOL_GREEN_YELLOW_SWITCH_PIN) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _iotool_enable_green_command(self):\n return self._iotool.commands.set_high(self._spconfig.IOTOOL_GREEN_YELLOW_SWITCH_PIN)",
"def do_green(self,command):\n if \"on\" in command:\n print 'Green ON'\n GPIO.output(22,GPIO.HIGH)\n elif \"off\" in command:\n print 'Green OFF'\n GP... | [
"0.66017234",
"0.6463711",
"0.6408746",
"0.576167",
"0.5699568",
"0.5610469",
"0.52996385",
"0.528892",
"0.52802473",
"0.52086544",
"0.5200548",
"0.5187345",
"0.5174531",
"0.51482487",
"0.5146435",
"0.51361644",
"0.5129312",
"0.50764745",
"0.50689256",
"0.5049614",
"0.5039266... | 0.6588561 | 1 |
'position' should be either 'green' or 'yellow' to insert the corresponding excitation filter into the green/yellow beam. | def set_green_yellow_filter(self, position):
if position not in {'green', 'yellow'}:
raise ValueError('"position" parameter must be either "green" or "yellow"')
if position == 'green':
self._iotool.execute(self._iotool_enable_green_command())
else:
self._iotoo... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_synthetic_more_positions():\n background = Image.new('RGB', (100, 50))\n patch = Image.new('RGB', (10, 10))\n positions = [\n [5, 5],\n [9, 5]\n ]\n\n parameters = {\n 'data': [background, patch],\n 'positions': positions\n }\n\n images.synthetic(parameters... | [
"0.53531677",
"0.5220632",
"0.5194332",
"0.5193839",
"0.51745796",
"0.4996859",
"0.48552203",
"0.48219103",
"0.48006073",
"0.47713152",
"0.4769842",
"0.47544366",
"0.47400308",
"0.4717013",
"0.47052014",
"0.4670778",
"0.4665777",
"0.46621022",
"0.46432894",
"0.46413597",
"0.4... | 0.63949525 | 0 |
Returns set of TTL signals the Spectra III is receiving | def get_ttls_active(self):
values = self.send_command('GET MULCHTTL')
return {lamp: bool(int(value)) for lamp, value in zip(self._LAMP_NAMES, values)} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parseTTL(self):\n rep = ''\n lastChannels = numpy.zeros(self.channelTotal)\n powerArray = 2**numpy.arange(self.channelTotal, dtype = numpy.uint64)\n for key,newChannels in sorted(self.switchingTimes.iteritems()):\n channels = lastChannels + newChannels #computes the actio... | [
"0.56724197",
"0.5434014",
"0.53288895",
"0.5321144",
"0.5158706",
"0.511819",
"0.5099043",
"0.5087247",
"0.5086027",
"0.5086027",
"0.5086027",
"0.50801307",
"0.5051268",
"0.5042244",
"0.50406134",
"0.50191116",
"0.5014939",
"0.5000203",
"0.49590626",
"0.49178615",
"0.4903553... | 0.5032503 | 15 |
Determine if the input year is a leapyear. A leapyear has an extra day in February. | def isLeapYear(year):
if (year % 4 == 0):
if (str(year)[-2:] == "00" and year % 400 != 0):
return False
return True
else:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_leap_year():",
"def leapyear(year):\n\n # Return the answer\n return bool(calendar.isleap(year))",
"def is_leap_year(year):\n mod = divider(year)\n return mod(4) and not mod(100) or mod(400)",
"def is_leap(year):\n\n\n\n\n\n\n\n\n\n\n\treturn year % 4 == 0 and (year % 100 != 0 or year % 40... | [
"0.86802614",
"0.8505601",
"0.85016274",
"0.84771603",
"0.84755814",
"0.8445686",
"0.844222",
"0.8434306",
"0.84282297",
"0.8419743",
"0.8396667",
"0.83965",
"0.8393182",
"0.8387692",
"0.8384335",
"0.8384335",
"0.8368348",
"0.8365362",
"0.83563066",
"0.8354779",
"0.8353698",
... | 0.79595786 | 56 |
Initializer method Raises exception if date is invalid. This may be due to the day exceeding the maximum number of days in the given month, or February 29 is specified on a nonLeap Year, etc. | def __init__(self, year=1900, month=1, day=1):
# ensure the inputs are parsed into integers
year = int(year)
month = int(month)
day = int(day)
# if the year is not from 0000 to 9999
if not (0 <= year and year <= 9999):
raise Exception("Year must be between 000... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _validate(year, month, day):\n if day is not None and month is None:\n raise ValueError(\"Day without month\")\n if day is None:\n day = 1\n if month is None:\n month = 1\n if year is None:\n year = 2000\n # actual validation happen... | [
"0.76030535",
"0.7002074",
"0.6673425",
"0.6647609",
"0.65993536",
"0.63706475",
"0.6331436",
"0.6283567",
"0.62462884",
"0.6236522",
"0.6227877",
"0.6186614",
"0.6181855",
"0.6148485",
"0.6121073",
"0.6105989",
"0.6061786",
"0.60375345",
"0.6025827",
"0.59781796",
"0.5962233... | 0.72118706 | 1 |
Return string representation of the date in the format YYYYMMDD. | def __str__(self):
# year, formatted unambiguously as YYYY, padded with zeros if not
# four-digit
yearString = "0" * (4 - len(str(self.get_year()))
) + str(self.get_year())
# month, formatted unambiguously as MM, padded with zeros if not
# two-digit
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def date_string(date):\n day = date.day\n month = date.month\n year = date.year\n formatted_string = str(month) + \"/\"\n formatted_string += str(day) + \"/\"\n formatted_string += str(year)\n return formatted_string",
"def date_to_final_str(date_obj: datetime) -> str:\n return date_o... | [
"0.7660189",
"0.75144106",
"0.74433655",
"0.742128",
"0.7315453",
"0.7315453",
"0.7257465",
"0.7158602",
"0.7029121",
"0.7015154",
"0.6990911",
"0.6990911",
"0.6988908",
"0.69664764",
"0.696561",
"0.6931559",
"0.68857795",
"0.6883072",
"0.6860537",
"0.6855554",
"0.68550855",
... | 0.7288755 | 6 |
Find the weekday of a given date in the format YYYYMMDD. Based on the fact that 19000101 (January 1st, 1900) is a Monday. | def get_weekday(self):
originDate = Date(1900, 1, 1)
return WEEKDAYS[originDate.days_since(self) % 7] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def date_to_day_of_week(date):\n return date.weekday()",
"def date_day_of_week(date):\n day_of_week = date.strftime('%A')\n return day_of_week",
"def get_weekday_number(date):\n return date.strftime('%w')",
"def weekday(day):\n return (day % 7) - 1",
"def date_to_dow(y, m, d):\r\n # Pytho... | [
"0.79289037",
"0.7525783",
"0.7473712",
"0.7228356",
"0.71577805",
"0.71342295",
"0.69331586",
"0.69233423",
"0.68961066",
"0.6864791",
"0.6850744",
"0.68353283",
"0.6816991",
"0.674595",
"0.66628045",
"0.66424584",
"0.655923",
"0.65518755",
"0.65094805",
"0.64937097",
"0.647... | 0.65215534 | 18 |
Given another date, find out how many days passed since this date. | def days_since(self, otherDate):
# initialize days passed
days = 0
# time difference of the year
yearDiff = otherDate.get_year() - self.get_year()
days += yearDiff * 365
# if other date is in the future, traverse forwards otherwise go
# backwards
if yearDi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def datediff_today(date):\n today = datetime.date.today()\n datediff = (today - date).days\n return datediff",
"def diff_dates(date1, date2):\n\n return abs(date2 - date1).days",
"def _get_number_of_days(self, date_from, date_to):\n\n DATETIME_FORMAT = \"%Y-%m-%d %H:%M:%S\"\n from_dt ... | [
"0.7271025",
"0.71568805",
"0.69931793",
"0.687202",
"0.6865785",
"0.68303543",
"0.6826376",
"0.68105143",
"0.6737072",
"0.67137754",
"0.6684774",
"0.6589549",
"0.6587052",
"0.6512795",
"0.65027285",
"0.647871",
"0.64774734",
"0.6458868",
"0.64533335",
"0.6426467",
"0.6415163... | 0.7558373 | 0 |
Add lib as primary libraries directory | def setSysPath():
c = os.path.abspath(os.path.dirname(__file__))
add = [
['lib'],
]
for item in add:
p = os.path.join(c, *item)
if not p in sys.path:
sys.path[1:1] = [p]
remove = ['django', 'simplejson']
# Remove unwanted paths
for item in sys.path:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def initLibPath():\n libHash = {\n 'Framework': 1,\n 'UserControlleLib': 1,\n 'CaseLib': 1\n }\n\n binPath = os.path.split(os.path.realpath(__file__))[0]\n\n for key in libHash:\n sys.path.append(os.path.join(__getLibAbsPath(binPath, libHash[key]), key))",
"def library_dir... | [
"0.7499683",
"0.7174301",
"0.7161401",
"0.7056918",
"0.6999705",
"0.67080486",
"0.6683748",
"0.6609897",
"0.6544341",
"0.64465064",
"0.64386153",
"0.6435282",
"0.633057",
"0.6327534",
"0.6266964",
"0.623527",
"0.62077504",
"0.6189101",
"0.61389035",
"0.61296844",
"0.6102648",... | 0.6204175 | 17 |
Cache this on the request object | def getEngine(conn_string=None, conn_parameters=None, req=None):
global engine
if engine is None:
registry = getUtility(IRegistry)
if conn_string is None:
conn_string = config.get("audit-connection-string", None)
if conn_string is None:
conn_string = registry[
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request_cache(self):\n return self._request_cache",
"def __request__(self) -> requests.Request:\n return self._self_response.request",
"def __init__(self, request=None, *args, **kwargs):\n self.request = request\n self.user_cache = None\n super().__init__(*args, **kwargs)... | [
"0.7034484",
"0.6443492",
"0.64108914",
"0.6362529",
"0.6360164",
"0.6225441",
"0.6192814",
"0.6139834",
"0.61016804",
"0.60933745",
"0.6093151",
"0.60927874",
"0.60853124",
"0.6077038",
"0.60122645",
"0.6001718",
"0.59988225",
"0.5992933",
"0.5987393",
"0.59583753",
"0.59519... | 0.0 | -1 |
same, cache on request object | def getSession(conn_string=None, req=None):
global engine, session_factory
if engine is None:
engine = getEngine(conn_string)
if session_factory is None:
session_factory = scoped_session(sessionmaker(bind=engine))
session = session_factory()
return session | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def request_cache(self):\n return self._request_cache",
"def _stash_request_info(request, subject_id, method, version):\n request.environ['api.cache.subject_id'] = subject_id\n request.environ['api.cache.method'] = method\n request.environ['api.cache.version'] = version",
"def _get_... | [
"0.6987318",
"0.677164",
"0.67064637",
"0.66762996",
"0.648721",
"0.6465159",
"0.6436197",
"0.63755465",
"0.6334696",
"0.63250595",
"0.63072246",
"0.6266479",
"0.619506",
"0.61946285",
"0.61839366",
"0.61677",
"0.6158422",
"0.6149883",
"0.61326545",
"0.6113767",
"0.6089935",
... | 0.0 | -1 |
Test basic ``host_str`` parsing; no surprises | def test_parse_host_str(self,
host_str,
expected,
expected_tls_dict,
):
out = client_kwargs_from_config(host_str)
out_tls = out.pop('tls', {})
try:
out_tls = out_tls.__dic... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_get_host(self):\n pass",
"def test_parse_url_lowercase_host() -> None:\n assert indieauth._parse_url(\"http://ex.com/hello\").path == \"/hello\"\n assert indieauth._parse_url(\"http://EX.COM/hello\").hostname == \"ex.com\"\n\n parts = indieauth._parse_url(\"http://EX.COM:123/HELLO\")\n ... | [
"0.71296555",
"0.7004411",
"0.6710971",
"0.6688106",
"0.6684157",
"0.66836333",
"0.66433156",
"0.65940166",
"0.6588238",
"0.65803725",
"0.65153784",
"0.64709073",
"0.6464598",
"0.6449479",
"0.6441863",
"0.6395573",
"0.63726616",
"0.63305074",
"0.6261786",
"0.6249969",
"0.6230... | 0.7255004 | 0 |
Test setting all certificates | def test_parse_host_str_certs(self, tmpdir):
tmpdir.join('cert.pem').ensure()
tmpdir.join('key.pem').ensure()
tmpdir.join('ca.pem').ensure()
out = client_kwargs_from_config(
'http://l cert_path=%s' % tmpdir.strpath
)
assert out['tls'].cert == (
t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cert(self):\n\n try:\n client = SSLClient(host=FQDN, ip=APPLIANCE, usercert=CERT, sslverifyhost=True, cabundle=CABUNDLE)\n self.assertTrue(1==1, \"SSLClient connects with cabundle\")\n except Exception as exception:\n print(exception)\n self.fail(\... | [
"0.68454224",
"0.6839459",
"0.6586251",
"0.64487875",
"0.6388208",
"0.63583905",
"0.6348918",
"0.6329575",
"0.63064253",
"0.62972486",
"0.6227047",
"0.6139929",
"0.60513175",
"0.60480106",
"0.6001762",
"0.5997378",
"0.5941374",
"0.5921711",
"0.588131",
"0.5851199",
"0.5820473... | 0.5487967 | 50 |
Test that ``verify=no`` overrides ``cert_path`` | def test_no_verify_no_ca(self, host_str_fs, tmpdir):
tmpdir.join('cert.pem').ensure()
tmpdir.join('key.pem').ensure()
tmpdir.join('ca.pem').ensure()
out = client_kwargs_from_config(
host_str_fs.format(cert_path=tmpdir.strpath),
)
assert out['tls'].cert == (
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_fallback_default_verify_paths(self, monkeypatch):\n context = Context(SSLv23_METHOD)\n monkeypatch.setattr(\n _lib, \"SSL_CTX_set_default_verify_paths\", lambda x: 1\n )\n monkeypatch.setattr(\n SSL,\n \"_CRYPTOGRAPHY_MANYLINUX_CA_FILE\",\n ... | [
"0.75012845",
"0.72467285",
"0.70869243",
"0.6916627",
"0.6636409",
"0.66044754",
"0.6463585",
"0.63147724",
"0.62792575",
"0.6222937",
"0.6192983",
"0.61852807",
"0.6139677",
"0.61195046",
"0.60851365",
"0.6025279",
"0.60072756",
"0.59979486",
"0.5995647",
"0.59738326",
"0.5... | 0.7373964 | 1 |
Test raising ``TLSParameterError`` when certs don't exist | def test_certs_error(self, tmpdir):
with pytest.raises(docker.errors.TLSParameterError):
client_kwargs_from_config(
'http://l cert_path=%s' % tmpdir.strpath
) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_use_certificate_wrong_args(self, ctx_or_conn):\n with pytest.raises(TypeError):\n ctx_or_conn.use_certificate(\"hello, world\")",
"def test_use_certificate_uninitialized(self, ctx_or_conn):\n with pytest.raises(Error):\n ctx_or_conn.use_certificate(X509())",
"def te... | [
"0.72817093",
"0.70087916",
"0.6903538",
"0.6889311",
"0.6868677",
"0.68513125",
"0.68279433",
"0.6764401",
"0.6663912",
"0.66038126",
"0.6587073",
"0.6454101",
"0.6369873",
"0.6354723",
"0.6334118",
"0.63293386",
"0.6291678",
"0.6207184",
"0.6188143",
"0.61739486",
"0.616070... | 0.7826428 | 0 |
Ensure that when client cert/key exists, but the CA doesn't, cert params are set without verify | def test_no_ca_no_error(self, tmpdir):
tmpdir.join('cert.pem').ensure()
tmpdir.join('key.pem').ensure()
out = client_kwargs_from_config(
'http://l cert_path=%s' % tmpdir.strpath
)
assert out['tls'].cert == (
tmpdir.join('cert.pem').strpath,
t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_no_verify_no_ca(self, host_str_fs, tmpdir):\n tmpdir.join('cert.pem').ensure()\n tmpdir.join('key.pem').ensure()\n tmpdir.join('ca.pem').ensure()\n\n out = client_kwargs_from_config(\n host_str_fs.format(cert_path=tmpdir.strpath),\n )\n\n assert out['tl... | [
"0.7238679",
"0.6843561",
"0.66534835",
"0.6623861",
"0.65620136",
"0.65516835",
"0.65445775",
"0.6510549",
"0.6388831",
"0.6363554",
"0.6320691",
"0.6276618",
"0.62438065",
"0.6237401",
"0.62106156",
"0.6189989",
"0.61834127",
"0.61439455",
"0.6106423",
"0.6105602",
"0.60965... | 0.7384116 | 0 |
Test getting ref name when single commit on master | def test_master(self, tmpgitdir, branch):
with tmpgitdir.join('file_a.txt').open('w') as handle:
handle.write('first file')
subprocess.check_call(['git', 'checkout', '-b', branch])
subprocess.check_call(['git', 'add', '.'])
subprocess.check_call(['git', 'commit', '-m', 'firs... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_branch_name_get(repository: Repository) -> None:\n branch = repository.branch(repository.head.name)\n assert repository.head.name == branch.name",
"def test_head_name(repository: Repository) -> None:\n head = repository._repository.references[\"HEAD\"]\n name = head.target.removeprefix(\"ref... | [
"0.7019529",
"0.67915136",
"0.6760462",
"0.6728467",
"0.6610641",
"0.656851",
"0.6391419",
"0.63680166",
"0.6335848",
"0.6233286",
"0.62091017",
"0.6200208",
"0.6198456",
"0.6154646",
"0.61292136",
"0.61259127",
"0.6123044",
"0.6099713",
"0.6078296",
"0.60608035",
"0.59980595... | 0.60457766 | 20 |
Test when branch is not master | def test_multiple_branches(self, tmpgitdir):
with tmpgitdir.join('file_a.txt').open('w') as handle:
handle.write('first file')
subprocess.check_call(['git', 'add', '.'])
subprocess.check_call(['git', 'commit', '-m', 'first'])
subprocess.check_call(['git', 'checkout', '-b', ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_default_repo_branch(self):\n # network may be unavailable, but we are not interested anyway,\n # so we ignore the exitcode\n output = self.run_command(\"selfupdate --check\", exitcode=None)\n self.assertIn(\"Target: ywangd:master\", output)\n self.assertNotIn(\"Target: y... | [
"0.74963045",
"0.7121406",
"0.68485004",
"0.68422204",
"0.6797293",
"0.67708224",
"0.66588646",
"0.65996534",
"0.65641767",
"0.6491489",
"0.6479997",
"0.64630324",
"0.636714",
"0.6359062",
"0.63192993",
"0.63192993",
"0.6304544",
"0.62983483",
"0.6282403",
"0.6232887",
"0.622... | 0.0 | -1 |
Test when a git commit is made, tagged, then described by it's tag | def test_tagged(self, tmpgitdir, branch):
with tmpgitdir.join('file_a.txt').open('w') as handle:
handle.write('first file')
subprocess.check_call(['git', 'checkout', '-b', branch])
subprocess.check_call(['git', 'add', '.'])
subprocess.check_call(['git', 'commit', '-m', 'firs... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_git_commits(self):\n event_id = dog.Event.create(title=\"Testing git commits\", text=\"\"\"$$$\n eac54655 * Merge pull request #2 from DataDog/alq-add-arg-validation (alq@datadoghq.com)\n |\\\n 760735ef | * origin/alq-add-arg-validation Simple typecheck between me... | [
"0.71023124",
"0.68768877",
"0.66216725",
"0.65907145",
"0.6243646",
"0.62270266",
"0.6220564",
"0.6176081",
"0.6136612",
"0.61345124",
"0.61071676",
"0.6001234",
"0.5948178",
"0.5940225",
"0.59256774",
"0.5903266",
"0.58939385",
"0.5875933",
"0.5875386",
"0.5869599",
"0.5838... | 0.69506216 | 1 |
Test when in a detached head state | def test_detached_head(self, tmpgitdir, branch):
with tmpgitdir.join('file_a.txt').open('w') as handle:
handle.write('first file')
subprocess.check_call(['git', 'checkout', '-b', branch])
subprocess.check_call(['git', 'add', '.'])
subprocess.check_call(['git', 'commit', '-m'... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_head_detached(repository: Repository) -> None:\n repository._repository.set_head(repository.head.commit.id)\n with pytest.raises(ValueError):\n repository.head",
"def on_detached(reason, crash):\n print(\"on_detached()\")\n print(\"reason:\", reason)\n print... | [
"0.62961733",
"0.5902365",
"0.588763",
"0.581806",
"0.57294714",
"0.5610439",
"0.5524324",
"0.5491706",
"0.548161",
"0.54555845",
"0.5435171",
"0.53663003",
"0.53559685",
"0.5302321",
"0.5245934",
"0.5240968",
"0.52279854",
"0.5223066",
"0.52176344",
"0.5216953",
"0.52143174"... | 0.6109551 | 1 |
Test when in a detached head state, where the commit is tagged | def test_tagged_detached_head(self, tmpgitdir, branch):
with tmpgitdir.join('file_a.txt').open('w') as handle:
handle.write('first file')
subprocess.check_call(['git', 'checkout', '-b', branch])
subprocess.check_call(['git', 'add', '.'])
subprocess.check_call(['git', 'commit... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_detached_head(tmpdir):\n repo = Repo.init(path=tmpdir)\n tmppath = pathlib.Path(tmpdir)\n\n index = repo.index\n author = Actor(\"An author\", \"author@example.com\")\n committer = Actor(\"A committer\", \"committer@example.com\")\n\n # First commit\n with open(tmppath / \"test.py\", ... | [
"0.7025714",
"0.6931008",
"0.69243526",
"0.66605234",
"0.652574",
"0.6475694",
"0.6046414",
"0.6031785",
"0.5926672",
"0.5866686",
"0.58500826",
"0.58421004",
"0.5838575",
"0.5799745",
"0.57833153",
"0.5764867",
"0.57611847",
"0.56860304",
"0.5668869",
"0.5654756",
"0.5649913... | 0.7445173 | 0 |
Ensure that a commit directly before another is correctly identified as an ancestor, and that the child is identified as not an ancestor | def test_two_commits(self, tmpgitdir):
with tmpgitdir.join('file_a.txt').open('w') as handle:
handle.write('first file')
subprocess.check_call(['git', 'add', '.'])
subprocess.check_call(['git', 'commit', '-m', 'first'])
first_hash = subprocess.check_output(
['git... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lint_commit_base(commit):\n success = True\n # Merge commits have two parents, we maintain a linear history.\n if len(commit.parents) > 1:\n error(\n \"Please resolve merges by re-basing. Merge commits are not allowed.\",\n commit)\n success = False\n\n return su... | [
"0.64292395",
"0.6359155",
"0.63076717",
"0.6198901",
"0.61818206",
"0.6159696",
"0.61231625",
"0.6046435",
"0.59505606",
"0.5904542",
"0.58570373",
"0.5819268",
"0.5811302",
"0.5809034",
"0.57591075",
"0.57033724",
"0.5699567",
"0.56659716",
"0.5589706",
"0.5573943",
"0.5563... | 0.5652296 | 18 |
This is a method. Methods always set at least one parameter of self to access the instance of the object it is called on. | def x_plus_five(self):
# We use "self" to print a given instance's value of x + 5.
print(f"x_plus_five called: {self.x + 5}") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _self(self, _self):\n\n self.__self = _self",
"def _self(self, _self):\n\n self.__self = _self",
"def __call__( self ):\n pass",
"def __call__(self):\n return self",
"def __call__(self, *args, **kwargs):\n return self",
"def on(self, o_self):\r\n self.o_self ... | [
"0.746999",
"0.746999",
"0.726812",
"0.7142138",
"0.7049129",
"0.6931898",
"0.6913924",
"0.68489844",
"0.68489844",
"0.6752757",
"0.66931313",
"0.66902745",
"0.66819245",
"0.6673",
"0.6662391",
"0.6662391",
"0.6618171",
"0.6583335",
"0.65659183",
"0.65659183",
"0.65603673",
... | 0.0 | -1 |
Using the syntax "self.var", where "var" is a given parameter, we can set attributes of a given instantiation of a class during its creation. | def __init__(self, name, color):
self.name = name
self.color = color | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.some_att = 42",
"def __init__(self, **kwargs):\n # loop over the given kwargs\n for key, value in kwargs.items():\n # treat them like attribute assignments\n setattr(self, key, value)",
"def __init__(self, **attributes):\n self.set(**... | [
"0.6430677",
"0.6402646",
"0.6395173",
"0.63498294",
"0.6280769",
"0.62556434",
"0.6242347",
"0.6198639",
"0.61928385",
"0.6163288",
"0.60201716",
"0.60201716",
"0.60201716",
"0.60201716",
"0.60201716",
"0.60201716",
"0.60201716",
"0.60201716",
"0.60201716",
"0.60201716",
"0.... | 0.0 | -1 |
The 'super()' function is a builtin Python function that allows programmers to access the functionality of a parent class. In this case, the 'super()' function is used to inherit the attributes defined in the 'Person' class. | def __init__(self, first_name, last_name, grad_year):
super().__init__(first_name, last_name)
self.grad_year = grad_year # The attribute "grad_year" is specific to the "Student" class. | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, \n # - Arguments from Person\n given_name=None, initials=None, family_name=None, \n email_address=None,\n # - Other staff-specific arguments\n department=None\n ):\n # - We can use super() to call the parent class' __init__ \n # because there... | [
"0.6255224",
"0.6236259",
"0.6073607",
"0.6003976",
"0.59831387",
"0.5904791",
"0.5902348",
"0.5843934",
"0.58347756",
"0.5777662",
"0.57635736",
"0.5706435",
"0.5704878",
"0.56416774",
"0.5620114",
"0.5605605",
"0.55657464",
"0.5556208",
"0.5552142",
"0.55266005",
"0.5485164... | 0.59525096 | 5 |
Calls hdevtools with the given arguments. Shows a sublime error message if hdevtools is not available. | def call_hdevtools_and_wait(arg_list, filename = None, cabal = None):
if not hdevtools_enabled():
log("call_hdevtools_and_wait: hdevtools disabled")
return None
ghc_opts_args = get_ghc_opts_args(filename, cabal = cabal)
hdevtools_socket = get_setting_async('hdevtools_socket')
source_dir... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def hdevtools_check(filename, cabal = None):\n return call_hdevtools_and_wait(['check', filename], filename = filename, cabal = cabal)",
"def hxladd():\n run_script(hxladd_main)",
"def load_devtools(self):\n pass",
"def run():\n if len(sys.argv)<2:\n sys.argv.append(\"-h\")\n plac.c... | [
"0.63388383",
"0.63170105",
"0.6034037",
"0.5807966",
"0.57696307",
"0.5757621",
"0.5680612",
"0.5641825",
"0.5575785",
"0.55453885",
"0.54091835",
"0.540879",
"0.5359283",
"0.5338525",
"0.5321896",
"0.5259705",
"0.52513844",
"0.5241204",
"0.5224239",
"0.52062774",
"0.5172954... | 0.60009664 | 3 |
Uses hdevtools info filename symbol_name to get symbol info | def hdevtools_info(filename, symbol_name, cabal = None):
contents = call_hdevtools_and_wait(['info', filename, symbol_name], filename = filename, cabal = cabal)
return parse_info(symbol_name, contents) if contents else None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def nm(filename):\n binary = parse(filename) # Build an abstract binary\n symbols = binary.symbols\n\n if len(symbols) > 0:\n for symbol in symbols:\n print(symbol)\n else:\n print(\"No symbols found\")",
"def symbols_details(self):\n pass",
"def get_symbols(doc, li... | [
"0.68157065",
"0.6396066",
"0.61771023",
"0.6132515",
"0.6047057",
"0.5982517",
"0.5970701",
"0.59500575",
"0.585406",
"0.58314234",
"0.5776864",
"0.5761884",
"0.57422334",
"0.5717828",
"0.56954217",
"0.56462055",
"0.5640362",
"0.56306994",
"0.5626244",
"0.5619888",
"0.561891... | 0.80114484 | 0 |
Uses hdevtools to check file | def hdevtools_check(filename, cabal = None):
return call_hdevtools_and_wait(['check', filename], filename = filename, cabal = cabal) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_and_analyze(self, domain_path, php_info_filename):\n php_info_url = domain_path.url_join(php_info_filename)\n\n response = self._uri_opener.GET(php_info_url,\n cache=True,\n grep=False)\n\n if is_404(respo... | [
"0.5883917",
"0.5862428",
"0.58590376",
"0.5857866",
"0.58339536",
"0.58069247",
"0.578893",
"0.57692254",
"0.57237095",
"0.57019496",
"0.5681064",
"0.5659866",
"0.5608667",
"0.5608043",
"0.56055325",
"0.5588865",
"0.55619746",
"0.55446285",
"0.55349016",
"0.55287385",
"0.551... | 0.7422176 | 0 |
Uses hdevtools to infer type | def hdevtools_type(filename, line, column, cabal = None):
return call_hdevtools_and_wait(['type', filename, str(line), str(column)], filename = filename, cabal = cabal) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def infer(self):\n # Update ext_type.symtab\n self.type_infer_init_method()\n\n # Type infer the rest of the methods (with fixed attribute table!)\n self.type_infer_methods()",
"def test_get_types(self):\n pass",
"def get_check_types():",
"def _propagate_types(self):\n p... | [
"0.58407456",
"0.58132976",
"0.5809135",
"0.5733886",
"0.57151115",
"0.5673977",
"0.5669237",
"0.56227255",
"0.561683",
"0.5489797",
"0.5477508",
"0.54729587",
"0.54698926",
"0.54627055",
"0.5419648",
"0.54010326",
"0.53666264",
"0.5364339",
"0.5355661",
"0.5355128",
"0.53074... | 0.5939715 | 0 |
Construct a WorldfileMultiple command. | def __init__(self, projectDir, configFile=None, outfp=sys.stdout):
super(WorldfileMultiple, self).__init__(projectDir, configFile, outfp) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def construct_phyla_plots_cmds(sample_ids, cmd_format, cmd_args):\n commands = []\n for chunk in chunk_list(sample_ids):\n args = cmd_args.copy()\n args['samples'] = ','.join(chunk)\n commands.append(cmd_format % args)\n return commands",
"def multi(self, *argv, **kwargs):\n ... | [
"0.5461225",
"0.5446993",
"0.5372413",
"0.5307399",
"0.5222449",
"0.5203311",
"0.5134721",
"0.50966644",
"0.50889033",
"0.5069162",
"0.50483453",
"0.5005254",
"0.50007635",
"0.49818003",
"0.49678537",
"0.49677798",
"0.4950114",
"0.49232692",
"0.49096394",
"0.48966783",
"0.488... | 0.56983197 | 0 |
Check to make sure the project directory has the necessary metadata to run this command. | def checkMetadata(self):
super(WorldfileMultiple, self).checkMetadata()
# Check for necessary information in metadata
if not 'basin_rast' in self.grassMetadata:
raise MetadataException("Metadata in project directory %s does not contain a basin raster in a GRASS mapset" % (se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _check_before_run(self):\n\t\tif not osp.exists(self.dataset_dir):\n\t\t\traise RuntimeError(\"'{}' is not available\".format(self.dataset_dir))\n\t\tif not osp.exists(self.train_dir):\n\t\t\traise RuntimeError(\"'{}' is not available\".format(self.train_dir))\n\t\tif not osp.exists(self.query_dir):\n\t\t\trai... | [
"0.65591425",
"0.64942133",
"0.64942133",
"0.64942133",
"0.64942133",
"0.64942133",
"0.64942133",
"0.64942133",
"0.6445897",
"0.6438879",
"0.6355895",
"0.6309706",
"0.6302053",
"0.62225735",
"0.6220267",
"0.61737317",
"0.61436486",
"0.61220795",
"0.61055565",
"0.6033032",
"0.... | 0.63320154 | 11 |
Multiple worldfiles, one worldfile for each subbasin delineated. | def run(self, *args, **kwargs):
verbose = kwargs.get('verbose', False)
self.checkMetadata()
rhessysDir = self.metadata['rhessys_dir']
self.paths = RHESSysPaths(self.context.projectDir, rhessysDir)
templateFilename = os.path.basename(self.metadata['templ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, projectDir, configFile=None, outfp=sys.stdout):\n super(WorldfileMultiple, self).__init__(projectDir, configFile, outfp)",
"def createWorlds(worldArray, objArray=None):\n if objArray is None:objArray=pm.ls(sl=1)\n\n worldReturn=[]\n for obj in objArray:\n worldNulls=[]\n... | [
"0.588202",
"0.58733183",
"0.5627406",
"0.55745405",
"0.5551754",
"0.5435319",
"0.537596",
"0.53621614",
"0.53334093",
"0.53283215",
"0.53046286",
"0.52487224",
"0.52483416",
"0.52061886",
"0.5153927",
"0.51413894",
"0.5065567",
"0.50595194",
"0.5052889",
"0.5024386",
"0.5019... | 0.0 | -1 |
clean away the 10% of points that have the largest residual errors (different between the prediction and the actual net worth) return a list of tuples named cleaned_data where each tuple is of the form (age, net_worth, error) | def outlierCleaner(predictions, ages, net_worths):
cleaned_data = []
### your code goes here
temp = abs(predictions-net_worths)
for k in range(len(ages)):
cleaned_data.append((ages[k][0],net_worths[k][0],temp[k][0]))
cleaned_data = sorted(cleaned_data, key=lambda data:data[2])
prin... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def outlierCleaner(predictions, ages, net_worths):\n\n #cleaned_data = []\n # construct a data list with age, net_worth in place plus one extra param for square error\n data = [(age, net_worth, pred - net_worth) for age, net_worth, pred in zip (ages, net_worths, predictions)]\n sorted_data = sorted(dat... | [
"0.78619015",
"0.7675518",
"0.7572094",
"0.75443864",
"0.75393873",
"0.75158566",
"0.74956214",
"0.7415158",
"0.73935616",
"0.73925316",
"0.7362416",
"0.7359262",
"0.73373353",
"0.72750604",
"0.72525215",
"0.7202793",
"0.7199136",
"0.71755993",
"0.71162784",
"0.7111074",
"0.6... | 0.71157753 | 19 |
read_symbols(filename) > SymbolTable read from the binary file | def read_symbols(filename):
filename = as_str(filename)
cdef ifstream* fstream = new ifstream(filename)
cdef SymbolTable table = SymbolTable.__new__(SymbolTable)
table.table = sym.SymbolTableRead(fstream[0], filename)
del fstream
return table | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_symbols(symbols_file_path):\n return np.genfromtxt(symbols_file_path, delimiter=',', dtype=np.str)",
"def read_opcode_info(filename):\r\n \r\n # Open file and read it into a list of lines.\r\n fin = open(filename, \"r\")\r\n lines = fin.readlines()\r\n fin.close()\r\n \r\n # We'll ... | [
"0.70136464",
"0.6443618",
"0.62608534",
"0.60250115",
"0.59742904",
"0.59548825",
"0.5942269",
"0.59381986",
"0.5802325",
"0.57955843",
"0.57708764",
"0.5745995",
"0.57382387",
"0.56561285",
"0.5611826",
"0.56110764",
"0.55889505",
"0.5569072",
"0.5523966",
"0.55123675",
"0.... | 0.83470607 | 0 |
SymbolTable() > new symbol table with \u03b5 0 SymbolTable(epsilon) > new symbol table with epsilon 0 | def __init__(self, epsilon=EPSILON):
cdef bytes name = 'SymbolTable<{0}>'.format(id(self)).encode('ascii')
self.table = new sym.SymbolTable(<string> name)
assert (self[epsilon] == EPSILON_ID) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\r\n self.s_table = SymbolTable.preSymbols",
"def symbol_table(self, value: str):\n self._symbol_table = value",
"def getSymbolTable(self) -> ghidra.app.util.bin.format.pe.debug.DebugCodeViewSymbolTable:\n ...",
"def symbols(self):\n pass",
"def _create_symbol... | [
"0.6887349",
"0.60825706",
"0.59769744",
"0.59410924",
"0.59129506",
"0.5899086",
"0.58946913",
"0.58743674",
"0.57885927",
"0.5715725",
"0.5517328",
"0.5511564",
"0.5511564",
"0.549144",
"0.5476111",
"0.5462763",
"0.53864384",
"0.53756225",
"0.5362634",
"0.5319834",
"0.53064... | 0.782774 | 0 |
table.copy() > copy of the symbol table | def copy(self):
cdef SymbolTable result = SymbolTable.__new__(SymbolTable)
result.table = new sym.SymbolTable(self.table[0])
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_table(self):\n return copy.deepcopy(self._table)",
"def Copy(self, copy):\n return _table.Table_Copy(self, copy)",
"def copy(self):\n table = Table()\n for label in self.column_labels:\n self._add_column_and_format(table, label, np.copy(self[label]))\n retu... | [
"0.6492269",
"0.6435444",
"0.6395961",
"0.63327885",
"0.6277186",
"0.6192845",
"0.61332405",
"0.613064",
"0.59814733",
"0.5872732",
"0.5858917",
"0.58048284",
"0.5763351",
"0.5747134",
"0.5696706",
"0.5637006",
"0.5603323",
"0.5565166",
"0.5478365",
"0.54699296",
"0.54500276"... | 0.8015655 | 0 |
table.find(int value) > decoded symbol if any symbol maps to this value table.find(str symbol) > encoded value if this symbol is in the table | def find(self, key):
if isinstance(key, (int, long)):
result = self.table.Find(<long> key).decode('utf8')
if result == u'':
raise KeyError(key)
return result
else:
key = as_str(key)
result = self.table.Find(<char*>key)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def lookup(c):\r\n if c not in chars:\r\n return ValueError\r\n p = chars.index(c)\r\n return vals[p]",
"def decode_symbol(self, bits):\n return self.bits_to_symbol.get(bits)",
"def read_symbol(table, index, br):\n x_bits = br.read_bits(16, 0) # The C reference version assumes 15 is ... | [
"0.5967776",
"0.59297276",
"0.579121",
"0.5785204",
"0.57709646",
"0.5715084",
"0.56764424",
"0.56462324",
"0.56342566",
"0.5632784",
"0.55733097",
"0.5572284",
"0.5543737",
"0.553452",
"0.5524773",
"0.5490346",
"0.54811615",
"0.5480724",
"0.54718745",
"0.5465133",
"0.5456967... | 0.5317585 | 33 |
table.items() > iterator over (symbol, value) pairs | def items(self):
cdef sym.SymbolTableIterator* it = new sym.SymbolTableIterator(self.table[0])
try:
while not it.Done():
yield (it.Symbol().decode('utf8'), it.Value())
it.Next()
finally:
del it | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self) -> Iterator[Tuple[K, List[V]]]:\n return (entry for entry in self._table.items())",
"def __iter__(self):\r\n for column, value in self.items():\r\n # this uses __getitem__, using the name (rather than the accessor)\r\n # is correct – it's what __getitem__ ex... | [
"0.6874724",
"0.68101335",
"0.65793943",
"0.6564461",
"0.65016985",
"0.64539164",
"0.637112",
"0.6238372",
"0.61545885",
"0.614661",
"0.61349154",
"0.60843146",
"0.6063622",
"0.6063622",
"0.6025974",
"0.60004103",
"0.59667796",
"0.59623426",
"0.59541434",
"0.59279233",
"0.591... | 0.7380278 | 0 |
Merge tables `syms1` and `syms2` into `merged` if they are compatible. Tables are compatible if all common symbol/values map identically. | def _merge_tables(SymbolTable syms1, SymbolTable syms2, SymbolTable merged):
for symbol, value in syms1.items():
try:
other_symbol = syms2.find(value)
if other_symbol != symbol:
raise ValueError('incompatible symbol tables')
except KeyError:
pass
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_fs(fs1,fs2):\n # This function merges fs2 into fs1, changing fs1 in-place\n # It's a cheaper and faster alternative of unify(), which will check\n # all the similarities and differences between fs1 and fs2. But this one\n # just assumes that fs2 and fs1 does not have any entries in common\n ... | [
"0.601715",
"0.5610678",
"0.5535604",
"0.5451038",
"0.5331601",
"0.53010577",
"0.5196176",
"0.51377356",
"0.5095105",
"0.5080329",
"0.5064888",
"0.50560766",
"0.50427425",
"0.50423485",
"0.50400716",
"0.49894622",
"0.49616647",
"0.49493426",
"0.49420464",
"0.4935286",
"0.4889... | 0.8205983 | 0 |
TropicalWeight(value) > tropical weight initialized with the given value | def __init__(self, value):
if value is True or value is None:
self.weight = new openfst.TropicalWeight(openfst.TropicalWeightOne())
elif value is False:
self.weight = new openfst.TropicalWeight(openfst.TropicalWeightZero())
else:
self.weight = new openfst.Trop... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def gen_tb_tb_weights(weight=1.):\r\n W = np.zeros([8, 8])\r\n sinusoid = -(np.cos(np.linspace(0, 2 * np.pi, 8, endpoint=False)) - 1) / 2\r\n for i in range(8):\r\n values = np.roll(sinusoid, i)\r\n W[i, :] = values\r\n return weight * W",
"def get_weight(self):\n pass",
"def g... | [
"0.65349126",
"0.6164336",
"0.6164336",
"0.6140293",
"0.6139442",
"0.61315674",
"0.61213374",
"0.6033982",
"0.6022765",
"0.60090303",
"0.59763247",
"0.59763247",
"0.59679335",
"0.5965371",
"0.59355384",
"0.59238636",
"0.5918259",
"0.5911267",
"0.58945274",
"0.58842987",
"0.58... | 0.6796364 | 0 |
A StdVectorFst arc (with a tropical weight) | def __init__(self):
raise NotImplementedError('cannot create independent arc') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def GetArc(arc):\r\n pass",
"def arc(r, mv_direction):\n \n vert_amount = 80\n arc_vert_amount = int(vert_amount / 2);\n edge = 2 * r * math.sin(math.radians(360 / (2 * vert_amount)))\n polygon_angle = (vert_amount - 2) / vert_amount * 180\n angle = 180 - polygon_angle\n \n for i i... | [
"0.59507215",
"0.56464434",
"0.5621576",
"0.5582629",
"0.55555063",
"0.5539467",
"0.5521051",
"0.55084366",
"0.5399608",
"0.5391588",
"0.53687686",
"0.5368456",
"0.53506905",
"0.5302483",
"0.529153",
"0.52848893",
"0.52689445",
"0.52663344",
"0.5260531",
"0.5239022",
"0.52300... | 0.5459789 | 8 |
A StdVectorFst state (with StdArc arcs) | def __init__(self):
raise NotImplementedError('cannot create independent state') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self):\n cdef StdVectorFst result = StdVectorFst.__new__(StdVectorFst)\n if self.isyms is not None:\n result.isyms = self.isyms.copy()\n if self.osyms is not None:\n result.osyms = (result.isyms if (self.isyms is self.osyms)\n else self.osyms.copy(... | [
"0.6104697",
"0.5815882",
"0.5764689",
"0.5555627",
"0.54482514",
"0.5442319",
"0.5415849",
"0.54098356",
"0.539673",
"0.5251519",
"0.51693547",
"0.5139526",
"0.5108899",
"0.50206167",
"0.5016088",
"0.50008273",
"0.49826655",
"0.49693358",
"0.49244115",
"0.49211946",
"0.49189... | 0.0 | -1 |
StdVectorFst(isyms=None, osyms=None) > empty finitestate transducer StdVectorFst(source) > copy of the source transducer | def __init__(self, source=None, isyms=None, osyms=None):
if isinstance(source, StdVectorFst):
self.fst = <openfst.StdVectorFst*> self.fst.Copy()
else:
self.fst = new openfst.StdVectorFst()
# todo: implement LogVectorFst.
#if isinstance(source, LogVectorFst... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self):\n cdef StdVectorFst result = StdVectorFst.__new__(StdVectorFst)\n if self.isyms is not None:\n result.isyms = self.isyms.copy()\n if self.osyms is not None:\n result.osyms = (result.isyms if (self.isyms is self.osyms)\n else self.osyms.copy(... | [
"0.6920192",
"0.62388426",
"0.5871237",
"0.57356966",
"0.5718539",
"0.5653314",
"0.5335162",
"0.5119913",
"0.5045772",
"0.49676844",
"0.47438803",
"0.47279066",
"0.46557736",
"0.46314356",
"0.46143156",
"0.4575382",
"0.4566534",
"0.45189705",
"0.44923723",
"0.44423857",
"0.44... | 0.69025594 | 1 |
fst.num_arcs() > total number of arcs in the transducer | def num_arcs(self):
return sum(len(state) for state in self) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def num_arcs(self):\n return len(self.arcs)",
"def get_num_arcs(self):\n num_arcs = 0\n for node in self._nodes.values(): num_arcs += node._deg\n return (num_arcs / 2) + 1",
"def get_num_arcs(self):\n num_arcs = 0\n for node in self._nodes.values(): num_arcs += node._d... | [
"0.6503137",
"0.5390219",
"0.5390219",
"0.5311139",
"0.53066105",
"0.52582544",
"0.51249367",
"0.51127076",
"0.5084829",
"0.50745136",
"0.50736403",
"0.5000744",
"0.5000361",
"0.49896824",
"0.49630937",
"0.49618727",
"0.48941165",
"0.4880546",
"0.4877309",
"0.48604143",
"0.48... | 0.6417278 | 1 |
fst.copy() > a copy of the transducer | def copy(self):
cdef StdVectorFst result = StdVectorFst.__new__(StdVectorFst)
if self.isyms is not None:
result.isyms = self.isyms.copy()
if self.osyms is not None:
result.osyms = (result.isyms if (self.isyms is self.osyms)
else self.osyms.copy())
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def copy(self):\n return SparseN(self)",
"def copy(self):",
"def copy(tensor):\n raise NotImplementedError",
"def copy_previous_sample(self):\n self.context[self.iter] = self.context[self.iter-1]\n self.beta[self.iter] = self.beta[self.iter-1]",
"def _use_copy(self):\n se... | [
"0.5807821",
"0.57013446",
"0.5697668",
"0.5683617",
"0.5560055",
"0.5510678",
"0.54720306",
"0.54429615",
"0.5433057",
"0.5402452",
"0.5401653",
"0.5347488",
"0.53439814",
"0.53389823",
"0.53324836",
"0.5322118",
"0.5313025",
"0.53110033",
"0.530622",
"0.5291283",
"0.5290641... | 0.56956756 | 3 |
fst.add_arc(int source, int dest, int ilabel, int olabel, weight=None) | def add_arc(self, int source, int dest, int ilabel, int olabel, weight=None):
if source > self.fst.NumStates()-1:
raise ValueError('invalid source state id ({0} > {1})'.format(source,
self.fst.NumStates()-1))
if dest > self.fst.NumStates()-1:
raise ValueError('inv... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_arc(rule_fst, index, token, nonterminal_coverages, weight=None):\n\n # Add arc of the form epsilon:token\n\n # Nonterminal symbol\n if token in nonterminal_coverages:\n rule_fst.add_arc(index, index + 1, 0, int(nonterminal_coverages[token]))\n\n elif int(token) == Ope... | [
"0.69422287",
"0.6696642",
"0.64102465",
"0.6044187",
"0.585226",
"0.58391315",
"0.57758266",
"0.5771317",
"0.57682467",
"0.57481164",
"0.56878084",
"0.56331134",
"0.5566571",
"0.5551789",
"0.5551048",
"0.552699",
"0.55259097",
"0.5471207",
"0.54608434",
"0.5456122",
"0.54319... | 0.8584377 | 0 |
fst.add_state() > new state | def add_state(self):
return self.fst.AddState() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def put(cls, new_state: TState) -> \"State[Tuple, TState]\":\n return State(lambda state: (Unit, new_state))",
"def set_state(self, new_state):\n if self.state_size != len(new_state):\n raise()\n \n self.index = 0\n self.mt = [0] * self.state_size\n \n ... | [
"0.72844535",
"0.6810779",
"0.66312695",
"0.65882593",
"0.6583458",
"0.6462981",
"0.64470166",
"0.64100325",
"0.63604087",
"0.63312083",
"0.6286474",
"0.62414885",
"0.62280333",
"0.6183359",
"0.6148567",
"0.614787",
"0.613842",
"0.6137333",
"0.61278456",
"0.61263424",
"0.6094... | 0.8028894 | 0 |
fst.determinize() > determinized transducer | def determinize(self):
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
openfst.Determinize(self.fst[0], result.fst)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def determinize(A):\n A = epsilon_remove(A)\n subset2state = {frozenset({0}): 0}\n state2subset = {0: frozenset({0})}\n\n alphabet = A.alphabet\n\n B = Automaton(1, set())\n\n if 0 in A.accepting:\n B.accepting.add(0)\n \n frontier = {0}\n while len(frontier) > 0:\n new_fro... | [
"0.5419944",
"0.53823406",
"0.53585374",
"0.5134222",
"0.5114933",
"0.5071433",
"0.5023954",
"0.5011669",
"0.49769273",
"0.49137333",
"0.48699903",
"0.48521927",
"0.48403203",
"0.48399127",
"0.4822672",
"0.48219958",
"0.481958",
"0.48166376",
"0.481023",
"0.480491",
"0.480353... | 0.63501775 | 0 |
fst.compose(StdVectorFst other) > composed transducer | def compose(self, StdVectorFst other):
if (self.osyms or other.isyms) and (self.osyms != other.isyms):
raise ValueError('transducer symbol tables are not compatible for composition')
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=other.osyms)
openfst.Compose(self.fst... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def into(target, xducer, coll):\n return transduce(xducer, append, target, coll)",
"def compose(a,b,shape_factor=None):\n\tif isinstance(a,Dense.denseAD) and (isinstance(b,Sparse.spAD) or all(isinstance(e,Sparse.spAD) for e in b)):\n\t\telem = None\n\t\tsize_factor = np.prod(shape_factor)\n\t\tif shape_factor... | [
"0.5957253",
"0.5651029",
"0.564393",
"0.56030774",
"0.5564454",
"0.5412876",
"0.5410412",
"0.53948104",
"0.53605056",
"0.53134406",
"0.5311556",
"0.5243856",
"0.5236318",
"0.5185403",
"0.5152642",
"0.5138685",
"0.5131285",
"0.513073",
"0.50922656",
"0.5081686",
"0.50802356",... | 0.76929843 | 0 |
fst.intersect(StdVectorFst other) > intersection of the two acceptors | def intersect(self, StdVectorFst other):
if not (self.acceptor and other.acceptor):
raise ValueError('both transducers need to be acceptors for intersection')
# TODO check and merge symbol tables (intersection)
if self.isyms and (self.isyms != other.isyms):
raise ValueErr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def intersection(st, ave):\n return (st+ave)*(st+ave+1)//2 + ave",
"def intersection(st, ave):\n return (st+ave)*(st+ave+1)//2 + ave",
"def intersection(st, ave):\n return (st+ave)*(st+ave+1)//2 + ave",
"def intersection(st, ave):\n return (st+ave)*(st+ave+1)//2 + ave",
"def intersection(st, av... | [
"0.7009266",
"0.7009266",
"0.7009266",
"0.7009266",
"0.7009266",
"0.7006973",
"0.6933211",
"0.66707516",
"0.6646042",
"0.66373456",
"0.66121304",
"0.6597997",
"0.65473455",
"0.65094155",
"0.64364016",
"0.63134086",
"0.63125205",
"0.6276214",
"0.6265396",
"0.6218907",
"0.62164... | 0.7845703 | 0 |
fst.union(StdVectorFst other) > union of the two transducers | def union(self, StdVectorFst other):
cdef StdVectorFst result = self.copy()
result.set_union(other)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def union(set1, set2):",
"def _union(cls, s1, s2):\n return s1.union(s2)",
"def intersect(self, StdVectorFst other):\n if not (self.acceptor and other.acceptor):\n raise ValueError('both transducers need to be acceptors for intersection')\n # TODO check and merge symbol tables (... | [
"0.6959548",
"0.6676238",
"0.655247",
"0.65170395",
"0.64780825",
"0.64126706",
"0.63926506",
"0.63912684",
"0.6372273",
"0.63648283",
"0.6319378",
"0.6300179",
"0.6287052",
"0.62588483",
"0.625192",
"0.62286276",
"0.616206",
"0.6152447",
"0.6104714",
"0.6100579",
"0.6093492"... | 0.77419794 | 0 |
fst.concatenation(StdVectorFst other) > concatenation of the two transducers | def concatenation(self, StdVectorFst other):
cdef StdVectorFst result = self.copy()
result.concatenate(other)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compose(self, StdVectorFst other):\n if (self.osyms or other.isyms) and (self.osyms != other.isyms):\n raise ValueError('transducer symbol tables are not compatible for composition')\n cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=other.osyms)\n openfst.Compose... | [
"0.69481677",
"0.64964294",
"0.62441736",
"0.61367065",
"0.60064864",
"0.5919863",
"0.58268344",
"0.58133394",
"0.5789787",
"0.5779817",
"0.5777069",
"0.5752967",
"0.5726033",
"0.57251793",
"0.5657184",
"0.5645212",
"0.5640987",
"0.5640987",
"0.5624115",
"0.56046396",
"0.5593... | 0.74791336 | 0 |
fst.difference(StdVectorFst other) > difference of the two transducers | def difference(self, StdVectorFst other):
# TODO merge symbol tables (union)
if self.isyms and (self.isyms != other.isyms):
raise ValueError('transducers must use shared input symbol table')
if self.osyms and (self.osyms != other.osyms):
raise ValueError('transducers must... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sub(first, other):\n if isinstance(first,FreeCAD.Vector) and isinstance(other,FreeCAD.Vector):\n return FreeCAD.Vector(first.x-other.x, first.y-other.y, first.z-other.z)",
"def reverse_difference():",
"def intersect(self, StdVectorFst other):\n if not (self.acceptor and other.acceptor):\n ... | [
"0.6086411",
"0.6045616",
"0.5977697",
"0.59613603",
"0.59549946",
"0.5882719",
"0.58611953",
"0.57981336",
"0.57964694",
"0.57882184",
"0.5762597",
"0.5756364",
"0.57557607",
"0.5750434",
"0.57060045",
"0.5683181",
"0.56800276",
"0.5673425",
"0.5637026",
"0.5625878",
"0.5625... | 0.7712873 | 0 |
fst.closure() > Kleene closure of the transducer | def closure(self):
cdef StdVectorFst result = self.copy()
result.set_closure()
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _gen_closure(fnc,arg):\n return lambda s: fnc(arg)",
"def propagate_state(s,t0,tf):\n\n return rk4(s,t0,tf)",
"def closure(self, t):\n raise NotImplementedError",
"def get_closure(self) -> \"CFG\":\n start_temp = Variable(\"#STARTCLOS#\")\n temp_1 = Terminal(\"#1CLOS#\"... | [
"0.5346936",
"0.51668394",
"0.5160571",
"0.5095912",
"0.506746",
"0.50425196",
"0.5014229",
"0.49508715",
"0.4922638",
"0.4895189",
"0.4888894",
"0.487788",
"0.48519778",
"0.48373258",
"0.47945848",
"0.4771413",
"0.47454786",
"0.47433",
"0.47428703",
"0.47249597",
"0.47178677... | 0.5114269 | 3 |
fst.closure_plus() > Kleen plus closure (X+ = XX) of the transducer | def closure_plus(self):
cdef StdVectorFst result = self.copy()
result.set_closure(plus=True)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addition(self):\n\t\treturn lambda anything: self.__class__(\n\t\t\t(self[:], disj, checked_proposition(anything)[:])\n\t\t)",
"def zzX_add_term(f, c, k=0):\n if poly_univariate_p(f):\n return zzx_add_term(f, c, k)\n\n if zzX_zero_p(c):\n return f\n\n n = len(f)\n m = n-k-1\n\n i... | [
"0.50570345",
"0.5037606",
"0.5026509",
"0.49782056",
"0.49160352",
"0.49004078",
"0.48918864",
"0.48902607",
"0.4848267",
"0.4829272",
"0.48242396",
"0.47120345",
"0.47120014",
"0.47120014",
"0.47050413",
"0.46969607",
"0.46718997",
"0.46661776",
"0.46263248",
"0.4610262",
"... | 0.5831245 | 0 |
fst.inverse() > inverse of the transducer | def inverse(self):
cdef StdVectorFst result = self.copy()
result.invert()
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def inverse(self):\n return self.invert()",
"def __invert__(self):\n return self.inverse()",
"def inverse(self):\n return self._inverse",
"def inverse_transform(self, Xt):\n return self.transformer.inverse_transform(Xt)",
"def inverse(self: T) -> T:",
"def Inverse(self, freedo... | [
"0.67072284",
"0.6670148",
"0.663043",
"0.65568477",
"0.6543811",
"0.64910984",
"0.64910984",
"0.6382784",
"0.6382784",
"0.6382784",
"0.6382784",
"0.6382784",
"0.63146925",
"0.6312613",
"0.6309569",
"0.62849003",
"0.6252534",
"0.6231935",
"0.61974066",
"0.6177345",
"0.6133786... | 0.6426065 | 7 |
fst.reverse() > reversed transducer | def reverse(self):
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
openfst.Reverse(self.fst[0], result.fst)
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reverse(seq):\n return seq[::-1]",
"def reverse(seq):\n return seq[::-1]",
"def reverse_this(seq):\n r_seq = seq[::-1]\n return r_seq",
"def reverse_elements(seq):\n seq_copy = seq [::-1]\n return seq_copy",
"def uninferable(seq):\n return reversed(seq)",
"def rev(self):\n ... | [
"0.65589255",
"0.65589255",
"0.6322597",
"0.62404",
"0.61557543",
"0.6151756",
"0.6123157",
"0.6069002",
"0.6058933",
"0.6027868",
"0.60132813",
"0.59784895",
"0.5960527",
"0.5904797",
"0.59039223",
"0.5903171",
"0.58870864",
"0.5848986",
"0.582349",
"0.5799277",
"0.5793437",... | 0.66294193 | 0 |
fst.shortest_distance(bool reverse=False) > length of the shortest path | def shortest_distance(self, bint reverse=False):
cdef vector[openfst.TropicalWeight] distances
openfst.ShortestDistance(self.fst[0], &distances, reverse)
cdef unsigned i
dist = [TropicalWeight(distances[i].Value()) for i in range(distances.size())]
return dist | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shortestPathLength(self, graph):\n # binary representation of a state of which nodes visited.\n ans = (1 << len(graph)) - 1\n\n # typical template for bfs; initil\n qe = []\n visited = set()\n for i in range(len(graph)):\n qe.append((i, 1 << i))\n ... | [
"0.6468428",
"0.6400149",
"0.62307173",
"0.6181717",
"0.6119881",
"0.61102235",
"0.60731053",
"0.6039813",
"0.59823483",
"0.5925195",
"0.5919849",
"0.5901156",
"0.58949405",
"0.58628094",
"0.5846925",
"0.58374566",
"0.5829668",
"0.5780163",
"0.57778525",
"0.5777451",
"0.57663... | 0.67651814 | 0 |
fst.shortest_path(int n=1) > transducer containing the n shortest paths | def shortest_path(self, unsigned n=1):
if not isinstance(self, StdVectorFst):
raise TypeError('Weight needs to have the path property and be right distributive')
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
openfst.ShortestPath(self.fst[0], result.fst, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def shortest_path(N, a_0, a_1=None):\n path = HJ_path(a_1*N, a_0*N)\n path = [c/d/N for c, d in path]\n return path",
"def find_shortest_path(g, n, s, e):\n dist, prev = lazy_dijkstra(g, n, s)\n path = []\n if (dist[e] == inf):\n return path\n # loop backwards from the end vertex\n ... | [
"0.72574353",
"0.6779499",
"0.6626936",
"0.65902966",
"0.657986",
"0.64826405",
"0.6330357",
"0.6329434",
"0.6324753",
"0.6273223",
"0.62089425",
"0.6148668",
"0.61475307",
"0.6145802",
"0.61132425",
"0.60910463",
"0.60695976",
"0.6064646",
"0.6057583",
"0.6035212",
"0.603401... | 0.723889 | 1 |
fst.push(final=False, weights=False, labels=False) > transducer with weights or/and labels pushed to initial (default) or final state | def push(self, final=False, weights=False, labels=False):
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
cdef int ptype = 0
if weights: ptype |= openfst.kPushWeights
if labels: ptype |= openfst.kPushLabels
if final:
openfst.StdArcPushFinal... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push_weights(self, final=False):\n return self.push(final, weights=True)",
"def push(self, transition, *args, **kwargs):\n raise NotImplementedError",
"def push_transition(self, s_tp1):\n self.states[self.pointer + 1] = s_tp1\n self.pointer += 1",
"def push(self, state, action... | [
"0.6277243",
"0.5895588",
"0.5667142",
"0.55976665",
"0.559007",
"0.5564427",
"0.5254385",
"0.5218644",
"0.52134675",
"0.5156183",
"0.5109405",
"0.5109405",
"0.51072586",
"0.5081782",
"0.5081119",
"0.5075794",
"0.505604",
"0.50500065",
"0.5024904",
"0.5011437",
"0.50001043",
... | 0.6876669 | 0 |
fst.push_weights(final=False) > transducer with weights pushed to initial (default) or final state | def push_weights(self, final=False):
return self.push(final, weights=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push(self, final=False, weights=False, labels=False):\n cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)\n cdef int ptype = 0\n if weights: ptype |= openfst.kPushWeights\n if labels: ptype |= openfst.kPushLabels\n if final:\n openfst.StdA... | [
"0.5956245",
"0.56888956",
"0.56398916",
"0.56398916",
"0.54933304",
"0.54659986",
"0.54577655",
"0.5434372",
"0.54123586",
"0.54071677",
"0.5347842",
"0.5316553",
"0.53136283",
"0.530291",
"0.5295784",
"0.52882373",
"0.52612233",
"0.52612233",
"0.52612233",
"0.5259971",
"0.5... | 0.75353676 | 0 |
fst.push_labels(final=False) > transducer with labels pushed to initial (default) or final state | def push_labels(self, final=False):
return self.push(final, labels=True) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def push(self, final=False, weights=False, labels=False):\n cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)\n cdef int ptype = 0\n if weights: ptype |= openfst.kPushWeights\n if labels: ptype |= openfst.kPushLabels\n if final:\n openfst.StdA... | [
"0.5967105",
"0.5179531",
"0.51263374",
"0.5107814",
"0.51046795",
"0.506244",
"0.5060464",
"0.50451463",
"0.5039498",
"0.5032216",
"0.5010942",
"0.5009389",
"0.5004121",
"0.49748337",
"0.49653673",
"0.49534157",
"0.49496177",
"0.49412832",
"0.49258912",
"0.4917706",
"0.49072... | 0.7259111 | 0 |
fst.plus_map(value) > transducer with weights equal to the original weights plus the given value | def plus_map(self, value):
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
if not isinstance(value, TropicalWeight):
value = TropicalWeight(value)
openfst.ArcMap(self.fst[0], result.fst,
openfst.PlusStdArcMapper((<TropicalWeight> value).weight[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weight_expr(self, t, w_plus, z, value):\n pass",
"def add_weight(self, from_neuron, to_neuron, value):\n index = (to_neuron * self.neuron_count) + from_neuron\n if index >= len(self.weights):\n raise IndexError(\"Out of range: from_neuron: {}, to_neuron: {}\".format(from_neuro... | [
"0.621839",
"0.6114559",
"0.600115",
"0.5804063",
"0.5722751",
"0.5693648",
"0.5687755",
"0.5559211",
"0.55528057",
"0.5552691",
"0.5549615",
"0.5522629",
"0.5510024",
"0.5501206",
"0.54631764",
"0.54226154",
"0.5411739",
"0.53821194",
"0.5376813",
"0.53541845",
"0.5352328",
... | 0.71642935 | 0 |
fst.times_map(value) > transducer with weights equal to the original weights times the given value | def times_map(self, value):
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
if not isinstance(value, TropicalWeight):
value = TropicalWeight(value)
openfst.ArcMap(self.fst[0], result.fst,
openfst.TimesStdArcMapper((<TropicalWeight> value).weigh... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weighting(wb, m, a):\n s = control.tf([1, 0], [1])\n return (s/m + wb) / (s + wb*a)",
"def comprehensive_transition_matrix(v, weight, n_bits):\n assert len(v) == n_parameters(weight, n_bits), \"v is the wrong dimension\"\n\n n_w = n_parameters_per_matrix(weight, n_bits)\n n_a = n_matrices_per_... | [
"0.58155817",
"0.5608829",
"0.54855907",
"0.5482287",
"0.54707223",
"0.5318477",
"0.5318477",
"0.52631176",
"0.52570164",
"0.5213809",
"0.5201124",
"0.5189139",
"0.51564693",
"0.5148534",
"0.5133489",
"0.5125699",
"0.51220584",
"0.51186234",
"0.51099324",
"0.5065519",
"0.5058... | 0.68501806 | 0 |
fst.remove_weights() > transducer with weights removed | def remove_weights(self):
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
openfst.ArcMap(self.fst[0], result.fst, openfst.RmTropicalWeightMapper())
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def RemoveWeights(frame, zero_nans=False):\n if \"Wpol\" not in frame and \"Wunpol\" not in frame:\n return\n\n if not frame[\"T\"].weighted:\n return frame\n ValidateMaps(frame)\n\n tmap = frame.pop(\"T\")\n\n if \"Wpol\" in frame:\n wmap = frame[\"Wpol\"]\n qmap = frame... | [
"0.62990224",
"0.60294455",
"0.59813094",
"0.5881217",
"0.57514244",
"0.5749189",
"0.5739195",
"0.57177734",
"0.56974894",
"0.56974894",
"0.5688978",
"0.5655647",
"0.5633824",
"0.5622353",
"0.55966955",
"0.55897725",
"0.555529",
"0.55475813",
"0.5521228",
"0.5521228",
"0.5496... | 0.6814973 | 0 |
fst.invert_weights() > transducer with inverted weights | def invert_weights(self):
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
openfst.ArcMap(self.fst[0], result.fst, openfst.InvertTropicalWeightMapper())
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def normalizeWeights(self):\n for wt in self.weights:\n wt[wt>1] = 1\n wt[wt<-1] = -1\n for bs in self.bias:\n bs[bs>1] = 1\n bs[bs<-1] = -1",
"def __invert__(self):\n return self.fam.c_unop('invert', self)",
"def invert(self):\n self.vert... | [
"0.6245089",
"0.6137868",
"0.5967409",
"0.5943088",
"0.5874188",
"0.57992786",
"0.579553",
"0.57924",
"0.5773543",
"0.5705209",
"0.566515",
"0.56568927",
"0.5629463",
"0.5623858",
"0.5580975",
"0.55782956",
"0.55737484",
"0.55570453",
"0.5556228",
"0.55188745",
"0.5512776",
... | 0.7489498 | 0 |
fst.replace(label_fst_map, epsilon=False) > transducer with nonterminals replaced | def replace(self, label_fst_map, epsilon=False):
assert self.osyms # used to encode labels
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
cdef vector[pair[int, openfst.ConstStdVectorFstPtr]] label_fst_pairs
cdef StdVectorFst fst
label_fst_map['__ROOT_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def addReplaceGraph(self, index_graph, index_namespace, *temp_namespaces):\n\n existing_indexes = list(set(index_graph.matchNamespace(index_namespace))) # target prefix?\n lp = len(index_namespace)\n suffixes = [int(u[lp:]) for u in existing_indexes]\n start = max(suffixes) + 1 if suf... | [
"0.55535024",
"0.54823536",
"0.54716563",
"0.54646164",
"0.53058475",
"0.5207826",
"0.5121671",
"0.50306106",
"0.5001328",
"0.4949655",
"0.49229786",
"0.4922424",
"0.49219033",
"0.4906215",
"0.489468",
"0.487425",
"0.48597205",
"0.4857501",
"0.48156703",
"0.4814905",
"0.48079... | 0.7282194 | 0 |
fst.logprob_generate(n_path=1) > n_path random paths sampled according to weights assumed to encode log probabilities | def logprob_generate(self, n_path=1, max_len=None, weighted=False):
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
cdef int seed = random.randint(0, INT_MAX)
cdef openfst.LogProbStdArcSelector* selector = new openfst.LogProbStdArcSelector(seed)
cdef int maxle... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_prob(self):",
"def pathProb(self, path):\n # Establish initial state distribution.\n estState = []\n for s in range(self.P):\n estState.append(self.initial(path[0][0], s))\n logProb = 0\n for step in range(1, len(path)):\n # Calculate a softmax pro... | [
"0.6375611",
"0.63293356",
"0.6045664",
"0.60323983",
"0.6031593",
"0.60283834",
"0.59639466",
"0.5921264",
"0.59190476",
"0.58894104",
"0.58496875",
"0.5776257",
"0.5764778",
"0.5742772",
"0.5704037",
"0.569994",
"0.5676815",
"0.5650656",
"0.5642329",
"0.5637369",
"0.5636269... | 0.744798 | 0 |
fst.uniform_generate(n_path=1) > n_path random paths sampled uniformly | def uniform_generate(self, n_path=1, max_len=None, weighted=False):
cdef StdVectorFst result = StdVectorFst(isyms=self.isyms, osyms=self.osyms)
cdef int seed = random.randint(0, INT_MAX)
cdef openfst.UniformStdArcSelector* selector = new openfst.UniformStdArcSelector(seed)
cdef int maxle... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sample_paths(S0, N, u, d, q, M):\n value = S0*np.ones((M,1)) # M sample paths at once\n paths = np.zeros((M, N+1))\n paths[:,0] = value[:,0]\n for i in np.arange(1, N+1,1): # time steps\n random_values = bernoulli.rvs(size=(M,1),p=q)\n up_moves = random_values*u\n down_moves = ... | [
"0.6734564",
"0.66847974",
"0.6530481",
"0.63904864",
"0.6371103",
"0.6327131",
"0.61868405",
"0.6162359",
"0.6098373",
"0.6078128",
"0.60059524",
"0.5981484",
"0.5946395",
"0.59069365",
"0.58888686",
"0.5843871",
"0.5840873",
"0.5838358",
"0.58005655",
"0.5798319",
"0.579669... | 0.653004 | 3 |
fst.paths() > iterator over all the paths in the transducer | def paths(self):
return self._visit(self.start) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __iter__(self):\n for path in self._paths: yield autopaths.Path(path.complete_path)",
"def current_paths(self) -> Iterator[List[Path]]:\n yield self._target_paths",
"def __iter__(self):\n for (_,_,path) in self.frontierpq:\n yield path",
"def paths(self, return_indices=Fal... | [
"0.68167454",
"0.67005354",
"0.6637809",
"0.64093363",
"0.6367687",
"0.63561803",
"0.63452667",
"0.62497",
"0.6217988",
"0.62091696",
"0.62034774",
"0.59500223",
"0.59325933",
"0.59298396",
"0.59014124",
"0.5900734",
"0.5889191",
"0.5886623",
"0.5873378",
"0.5854071",
"0.5852... | 0.6516347 | 3 |
Method to remove samples with missing views PARAMETERS | def removeIncompleteSamples(data):
print("Removing incomplete samples...")
M = len(data)
N = data[0].shape[0]
samples_to_remove = []
for n in range(N):
for m in range(M):
if pd.isnull(data[m].iloc[n][0]):
samples_to_remove.append(n)
break
if ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_intent_classifier_del_training_samples_all(self):\n pass",
"def test_intent_classifier_del_training_samples(self):\n pass",
"def test_other_study_not_in_queryset(self):\n # Delete all but five source traits, so that there are 5 from each study.\n study2 = factories.StudyFac... | [
"0.5974973",
"0.5966185",
"0.58715934",
"0.58715934",
"0.5855055",
"0.58248854",
"0.5814161",
"0.5801252",
"0.57774687",
"0.5772661",
"0.57554215",
"0.5704306",
"0.56977016",
"0.5693439",
"0.5690832",
"0.56738245",
"0.5666975",
"0.5666975",
"0.5666975",
"0.5644226",
"0.563809... | 0.6024295 | 0 |
Method to mask values of the data, It is mainly to test missing values and to evaluate imputation PARAMETERS | def maskData(data, data_opts):
print("Masking data with the following options:")
print("at random:")
print(data_opts['maskAtRandom'])
print("full cases:")
print(data_opts['maskNSamples'])
for m in range(len(data)):
# Mask values at random
D = data[m].shape[1]
N = data[m... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def applymask(self,mask):\n self.spec[mask==0]=np.nan",
"def mask(self, data):\n masking_conditions = self.config.get('mask', None)\n if masking_conditions is not None:\n mask = np.isnan(data)\n masking_conditions = to_list(masking_conditions)\n for condition... | [
"0.71636206",
"0.69299334",
"0.6656439",
"0.6598178",
"0.65833426",
"0.6500745",
"0.6235333",
"0.62148505",
"0.6189413",
"0.6060201",
"0.6054242",
"0.60385114",
"0.6024093",
"0.60088813",
"0.5998645",
"0.59780157",
"0.596528",
"0.5955262",
"0.5953874",
"0.5943176",
"0.5916484... | 0.65955365 | 4 |
Method to load the data PARAMETERS | def loadData(data_opts, verbose=True):
print ("\n")
print ("#"*18)
print ("## Loading data ##")
print ("#"*18)
print ("\n")
sleep(1)
M = len(data_opts['input_files'])
Y = [None]*M
for m in range(M):
# Read file
file = data_opts['input_files'][m]
Y[m] ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _load_parameter(self):",
"def load_data(self):",
"def load_data(self) -> None:",
"def load_parameters(self):\n json_data = open(\"param.json\")\n data = json.load(json_data)\n self.items = data[\"items\"]\n self.pollInterval = self.items[0]['poll_interval']",
"def load_param... | [
"0.7619791",
"0.7215906",
"0.7184702",
"0.7089878",
"0.70850396",
"0.6927192",
"0.68864596",
"0.67514884",
"0.67035496",
"0.6678682",
"0.66307455",
"0.6583257",
"0.65438026",
"0.65285",
"0.65189654",
"0.65092236",
"0.64984846",
"0.6477738",
"0.64763254",
"0.6449944",
"0.64173... | 0.0 | -1 |
Method to create an array filled with missing values | def nans(shape, dtype=float):
a = np.empty(shape, dtype)
a.fill(np.nan)
return a | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def data_missing():\n return RaggedArray([[], [-1, 0, 1]], dtype='int16')",
"def data_missing_for_sorting():\n return RaggedArray([[1, 0], [], [0, 0]])",
"def get_fixed_array():\n return np.array([[[np.nan, np.nan],\n [np.nan, np.nan],\n [np.nan, np.nan]],\n\n... | [
"0.75115675",
"0.68511885",
"0.683553",
"0.66644394",
"0.6584856",
"0.65045017",
"0.6430179",
"0.63518476",
"0.6322441",
"0.6280949",
"0.62538046",
"0.6221733",
"0.6131918",
"0.611479",
"0.6114637",
"0.6104368",
"0.6098019",
"0.6086872",
"0.60868573",
"0.6044928",
"0.6027729"... | 0.62669516 | 10 |
Method to efficiently compute correlation coefficients between two matrices PARMETERS | def corr(A,B):
# Rowwise mean of input arrays & subtract from input arrays themeselves
A_mA = A - A.mean(1)[:,None]
B_mB = B - B.mean(1)[:,None]
# Sum of squares across rows
ssA = (A_mA**2).sum(1);
ssB = (B_mB**2).sum(1);
# Finally get corr coeff
return np.dot(A_mA,B_mB.T)/np.sqrt(np.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def coupling_coef_corrs(fits_path, dataset1, dataset2):\n fits = h5py.File(fits_path, 'r')\n coefs1 = np.median(fits[dataset1]['coupling_coefs'][:], axis=0)\n coefs2 = np.median(fits[dataset2]['coupling_coefs'][:], axis=0)\n\n n_neurons = coefs1.shape[0]\n corrs = np.zeros(n_neurons)\n\n for neur... | [
"0.69910353",
"0.68758065",
"0.672521",
"0.67033434",
"0.6432826",
"0.64027905",
"0.63520557",
"0.63299096",
"0.6239334",
"0.616585",
"0.61632824",
"0.61550903",
"0.6148199",
"0.61245817",
"0.59955454",
"0.599502",
"0.5986781",
"0.5969329",
"0.595005",
"0.59464985",
"0.591657... | 0.65618134 | 4 |
Multiply a full matrix by a diagonal matrix. This function should always be faster than dot. | def ddot(d, mtx, left=True):
if left:
return (d*mtx.T).T
else:
return d*mtx | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def r_diag_dot_sparse(mat, diag):\n return mat @ sp.diags(diag)",
"def mult_diag(d, mtx, left=True):\n if left:\n return (d*mtx.T).T\n else:\n return d*mtx",
"def mult_diag(d, mtx, left=True):\n if left:\n return (d*mtx.T).T\n else:\n return d*mtx",
"def l_diag_dot_... | [
"0.7025872",
"0.6932095",
"0.6932095",
"0.67525864",
"0.6566778",
"0.641041",
"0.6377108",
"0.6349031",
"0.6344702",
"0.6274619",
"0.62428904",
"0.61872375",
"0.61565834",
"0.61009675",
"0.60421216",
"0.60006547",
"0.6000634",
"0.5992185",
"0.59488285",
"0.59419817",
"0.59356... | 0.5908293 | 26 |
Method to save the parameters of the model in an hdf5 file PARAMETERS | def saveParameters(model, hdf5, view_names=None):
# Get nodes from the model
nodes = model.getNodes()
# Create groups
param_grp = hdf5.create_group("parameters")
# Iterate over nodes
for node in nodes:
# Collect node parameters
parameters = nodes[node].getParameters()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_h5(self, filename):\n try:\n shutil.copyfile(filename, '{0}_bak'.format(filename))\n except IOError:\n print 'could not make backup of trainer param file (which is \\\n normal if we haven\\'t saved one until now)'\n paramfile = tables.openFile(... | [
"0.7547686",
"0.73266137",
"0.7147719",
"0.7146818",
"0.6927567",
"0.6904685",
"0.68432915",
"0.68017304",
"0.67344093",
"0.6733551",
"0.672723",
"0.66911286",
"0.6661018",
"0.6638081",
"0.66352516",
"0.66027856",
"0.6602723",
"0.6579461",
"0.6574098",
"0.65592694",
"0.655190... | 0.70732796 | 4 |
Method to save the expectations of the model in an hdf5 file PARAMETERS | def saveExpectations(model, hdf5, view_names=None):
# Get nodes from the model
nodes = model.getNodes()
exp_grp = hdf5.create_group("expectations")
# Iterate over nodes
for node in nodes:
# Collect node expectations
expectations = nodes[node].getExpectations()
# Multi-vi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_as_hdf5(self, filename):",
"def save_to_hd5(out_file, x_train, y_train, x_val, y_val, x_test, y_test):\n data = h5py.File(out_file, \"w\")\n train_data = data.create_group(\"train_data\")\n train_data.create_dataset(\"x_train\", data=x_train)\n train_data.create_dataset(\"y_train\", data=y_t... | [
"0.7144187",
"0.70023483",
"0.69948673",
"0.68017226",
"0.67596805",
"0.6758356",
"0.6758035",
"0.6658788",
"0.6644143",
"0.66394436",
"0.661126",
"0.66050243",
"0.6585072",
"0.64933044",
"0.6485472",
"0.6483811",
"0.64647233",
"0.6452282",
"0.64113677",
"0.6400059",
"0.63887... | 0.6884746 | 3 |
Method to save the training statistics in an hdf5 file PARAMETERS | def saveTrainingStats(model, hdf5):
stats = model.getTrainingStats()
stats_grp = hdf5.create_group("training_stats")
stats_grp.create_dataset("activeK", data=stats["activeK"])
stats_grp.create_dataset("elbo", data=stats["elbo"])
stats_grp.create_dataset("elbo_terms", data=stats["elbo_terms"].T)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_as_hdf5(self, filename):",
"def save_h5(self, filename):\n try:\n shutil.copyfile(filename, '{0}_bak'.format(filename))\n except IOError:\n print 'could not make backup of trainer param file (which is \\\n normal if we haven\\'t saved one until now)... | [
"0.76186526",
"0.74484",
"0.7302508",
"0.7036124",
"0.68702656",
"0.68636805",
"0.6862404",
"0.6836825",
"0.6830172",
"0.6630677",
"0.6627013",
"0.66142386",
"0.65550214",
"0.64987785",
"0.64877",
"0.64374703",
"0.6429999",
"0.64238906",
"0.64071083",
"0.64017457",
"0.6395792... | 0.79240113 | 0 |
Method to save the training options in an hdf5 file PARAMETERS | def saveTrainingOpts(opts, hdf5):
# Remove dictionaries from the options
for k,v in opts.copy().items():
if type(v)==dict:
for k1,v1 in v.items():
opts[str(k)+"_"+str(k1)] = v1
opts.pop(k)
# Create HDF5 data set
hdf5.create_dataset("training_opts", data=n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_h5(self, filename):\n try:\n shutil.copyfile(filename, '{0}_bak'.format(filename))\n except IOError:\n print 'could not make backup of trainer param file (which is \\\n normal if we haven\\'t saved one until now)'\n paramfile = tables.openFile(... | [
"0.7541448",
"0.71382374",
"0.6994086",
"0.6971694",
"0.6970202",
"0.692363",
"0.6838004",
"0.68295485",
"0.66984445",
"0.6564147",
"0.64481384",
"0.64433485",
"0.63179415",
"0.6317367",
"0.6292988",
"0.6272117",
"0.6240768",
"0.62215",
"0.6210662",
"0.61986285",
"0.6158499",... | 0.757535 | 0 |
Method to save the model options in an hdf5 file PARAMETERS | def saveModelOpts(opts, hdf5):
opts_interest = ["learnIntercept","schedule","likelihood","sparsity"]
opts = dict((k, opts[k]) for k in opts_interest)
grp = hdf5.create_group('model_opts')
for k,v in opts.items():
grp.create_dataset(k, data=np.asarray(v).astype('S'))
grp[k].attrs['names'] = n... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_h5(self, filename):\n try:\n shutil.copyfile(filename, '{0}_bak'.format(filename))\n except IOError:\n print 'could not make backup of trainer param file (which is \\\n normal if we haven\\'t saved one until now)'\n paramfile = tables.openFile(... | [
"0.71215373",
"0.69332534",
"0.6906875",
"0.68623835",
"0.6848984",
"0.6801983",
"0.6710405",
"0.6583333",
"0.65404475",
"0.6526262",
"0.6478722",
"0.64776677",
"0.64507914",
"0.64346147",
"0.6415686",
"0.6334888",
"0.6334126",
"0.63304484",
"0.6325904",
"0.6320708",
"0.63110... | 0.76416385 | 0 |
Method to save the training data in an hdf5 file PARAMETERS | def saveTrainingData(model, hdf5, view_names=None, sample_names=None, feature_names=None, likelihoods=None):
data = model.getTrainingData()
data_grp = hdf5.create_group("data")
featuredata_grp = hdf5.create_group("features")
hdf5.create_dataset("samples", data=np.array(sample_names, dtype='S50'))
i... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_to_hd5(out_file, x_train, y_train, x_val, y_val, x_test, y_test):\n data = h5py.File(out_file, \"w\")\n train_data = data.create_group(\"train_data\")\n train_data.create_dataset(\"x_train\", data=x_train)\n train_data.create_dataset(\"y_train\", data=y_train)\n if x_val is not None:\n ... | [
"0.7822894",
"0.7725884",
"0.7424584",
"0.7117243",
"0.70354587",
"0.6928284",
"0.6915982",
"0.690596",
"0.6839403",
"0.6725721",
"0.66865355",
"0.66797966",
"0.667506",
"0.6665772",
"0.666074",
"0.6606604",
"0.65744895",
"0.65569764",
"0.6539012",
"0.6525144",
"0.64931834",
... | 0.722142 | 3 |
Method to save the model in an hdf5 file PARAMETERS TOFILL.... | def saveModel(model, outfile, train_opts, model_opts, view_names=None, sample_names=None, feature_names=None):
# QC checks
assert model.trained == True, "Model is not trained yet"
assert len(np.unique(view_names)) == len(view_names), 'View names must be unique'
assert len(np.unique(sample_names)) == le... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_as_hdf5(self, filename):",
"def save_model(model):\n\n # model.save(os.path.join(output))\n # model.save(output)\n\n # key = \"{}/{}/examples\".format(prefix,data_partition_name)\n # url = 's3://{}/{}'.format(bucket, key)\n # boto3.Session().resource('s3').Bucket(bucket).Object(key).uploa... | [
"0.73960996",
"0.731551",
"0.7309908",
"0.72724366",
"0.7142838",
"0.7141108",
"0.7065175",
"0.7059794",
"0.70176214",
"0.691764",
"0.6897659",
"0.68805915",
"0.6796363",
"0.6791728",
"0.67818874",
"0.67726684",
"0.6762847",
"0.6758171",
"0.67317086",
"0.6717588",
"0.6701124"... | 0.6544464 | 31 |
Log in method using Flask Session or JWT Tokens | def log_in(jwt):
return current_app.library_registry.admin_controller.log_in(jwt) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def login():\n\n\n params = request.get_json()\n username = params.get('username', None)\n password = params.get('password', None)\n\n if not username:\n return jsonify({\"msg\": \"Missing username parameter\"}), Status.HTTP_BAD_REQUEST\n if not password:\n return jsonify({\"msg\": \"M... | [
"0.7737604",
"0.7585224",
"0.7482271",
"0.7449282",
"0.726527",
"0.72297525",
"0.72285867",
"0.722037",
"0.7208943",
"0.71985704",
"0.7189562",
"0.718633",
"0.71839875",
"0.71826035",
"0.71805346",
"0.71698403",
"0.71253777",
"0.71253777",
"0.71122885",
"0.71045136",
"0.70843... | 0.74313056 | 4 |
Refresh JWT access token method | def refresh_token():
return current_app.library_registry.admin_controller.refresh_token() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def refresh():\n print(\"refresh request\")\n old_token = request.get_data()\n new_token = guard.refresh_jwt_token(old_token)\n ret = {'access_token': new_token}\n return ret, 200",
"def refresh():\n current_user = get_jwt_identity()\n ret = {\n 'access_token': create_access_token(ide... | [
"0.8614901",
"0.84700114",
"0.837138",
"0.81414944",
"0.8075031",
"0.7895597",
"0.78880507",
"0.7861867",
"0.7860082",
"0.7757345",
"0.77382714",
"0.76169086",
"0.75803554",
"0.7454972",
"0.7405347",
"0.7377548",
"0.7362062",
"0.73072666",
"0.72705334",
"0.7247686",
"0.717756... | 0.6679031 | 47 |
! Searches output string | def get_testcase_summary(output):
print("Inside Test Summary")
re_tc_summary = re.compile(r"^\[(\d+\.\d+)\][^\]+\{\{(__testcase_summary);(\d+);(\d+)\}\}")
#re_tc_summary = re.compile(r"^\[(\d+\.\d+)\][^\{]+\{\{(__testcase_summary);(\d+);(\d+)\}\}")
print("re_tc_summary =",re_tc_summary.pattern)
#pri... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def output_found(text, data=None):\n if conf.eval_output:\n info_dict = {'type':'found', 'text' : text}\n info_dict.update(data or {})\n output_result_eval(info_dict)\n else:\n output_result('[FOUND] ' + text)",
"def search(self, word):",
"def check_output_contains(context, te... | [
"0.65649",
"0.65356344",
"0.646662",
"0.64281803",
"0.62923485",
"0.614656",
"0.60025",
"0.5984303",
"0.59813017",
"0.59785056",
"0.59713686",
"0.5938507",
"0.5930746",
"0.5929708",
"0.5922938",
"0.5891811",
"0.58884245",
"0.5881193",
"0.5878786",
"0.58357304",
"0.58278275",
... | 0.0 | -1 |
Initialize exceptions for the Subaru Starlink API. | def __init__(self, message, *args, **kwargs):
self.message = message
super().__init__(*args, **kwargs) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, error_msg):\n super(ConnectionException, self).__init__(error_msg)",
"def __init__(self, error_msg):\n super(SdkException, self).__init__()\n self.error_msg = error_msg",
"def __init__(self, exception, message=\"Invalid requests parse!\"):\n self.message = message... | [
"0.6374355",
"0.62550896",
"0.62483984",
"0.5911717",
"0.5911717",
"0.5911717",
"0.58959407",
"0.5885883",
"0.5797883",
"0.5780054",
"0.5775571",
"0.57683134",
"0.5766834",
"0.5758749",
"0.575373",
"0.57343733",
"0.57154894",
"0.5673905",
"0.5631225",
"0.5631225",
"0.5619317"... | 0.0 | -1 |
Execute only if run as a script. | def main():
if '-h' in sys.argv or '--help' in sys.argv:
print_help()
arguments = map_arguments()
sys.stdout.write('Converting from standard input (use -h for help) ...\n')
pool = Pool()
src_files = pool.map(convert_files, enumerate(sys.stdin.readlines()))
pool.close()
pool.join()... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run(self, _):\n ida_kernwin.warning(\"IDACpp cannot be run as a script\")\n return False",
"def run_script(self):\n pass",
"def execute(self, args=\"\"):\r\n return super(PythonScript, self).execute(_EXECUTABLE, args)",
"def run_if_interactive(self):\n pass",
"def scr... | [
"0.6625024",
"0.66240704",
"0.64144194",
"0.6329798",
"0.6242908",
"0.6166826",
"0.6162134",
"0.61572427",
"0.6137846",
"0.60983455",
"0.5957475",
"0.59561884",
"0.5948326",
"0.5938682",
"0.59291065",
"0.59132427",
"0.59085315",
"0.589553",
"0.58948565",
"0.58764416",
"0.5855... | 0.0 | -1 |
Maps the sys.argv to a dictionary and returns it. Omits sys.argv[0]. You may also look at OptionParser. | def map_arguments():
arguments = {
'-c': 'ogg',
'-d': 'no',
'-q': '4'
}
args = sys.argv[:]
args.pop(0)
while len(args) > 1:
if args[0] == '-c' and re.search('^mp3$|^ogg$', args[1]) or \
args[0] == '-d' and re.search('^y(es)?$', args[1]) or \
ar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def retrieve_args_dict():\n process_args = sys.argv[1:]\n dictionary = dict()\n for process_arg in process_args:\n splitted = process_arg.split(\":\")\n if len(splitted) > 1:\n key = splitted[0]\n value = \"\".join(splitted[1:])\n dictionary[key] = value\n ... | [
"0.7385237",
"0.7118634",
"0.6816529",
"0.67994505",
"0.65655065",
"0.6522211",
"0.6495122",
"0.6454298",
"0.6454298",
"0.6422819",
"0.6410535",
"0.63859236",
"0.6361472",
"0.63351923",
"0.63333267",
"0.6328651",
"0.62523013",
"0.62460315",
"0.62011284",
"0.6116458",
"0.61064... | 0.64495105 | 9 |
Returns the right file extension, codec and audio quality based on the command line arguments. | def audio_codec():
arguments = map_arguments()
if arguments['-c'] == 'ogg':
return '.ogg', 'libvorbis', arguments['-q']
elif arguments['-c'] == 'mp3':
return '.mp3', 'libmp3lame', arguments['-q'] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n songs = []\n first_line = sys.stdin.readline().split(' ', 1)\n songs_on_album, songs_to_select = int(first_line[0]), int(first_line[1])\n for i in range(songs_on_album):\n line = sys.stdin.readline().split(' ', 1)\n song = Song(line[1], int(line[0]), i+1)\n songs.append(song)\n\n print_... | [
"0.56709796",
"0.5644258",
"0.55935603",
"0.55931133",
"0.5572692",
"0.54806256",
"0.5473442",
"0.54529715",
"0.5429261",
"0.5399557",
"0.53953904",
"0.53751093",
"0.5370239",
"0.53674275",
"0.5362373",
"0.5354838",
"0.5344439",
"0.5343309",
"0.5330692",
"0.5306567",
"0.52950... | 0.7217277 | 0 |
Uses multiprocessin to convert multiple files at once. Returns the converted source file (used in delete_files function). | def convert_files(enumerated_src_file):
i, src_file = enumerated_src_file
src_file = src_file.strip()
file_extension, acodec, quality = audio_codec()
dst_file = '.'.join(src_file.split('.')[:-1]) + file_extension
sys.stdout.write(str(i + 1) + ': ' + src_file + ' -> ' + dst_file + '\n')
subproce... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_files_parallel(self) -> None:\n file_paths = []\n for file in os.listdir(self.audios_dir):\n if file.endswith(self.input_format):\n file_paths.append(os.path.join(\n self.audios_dir, file))\n with Pool(cpu_count()) as p:\n p.m... | [
"0.7930838",
"0.67868215",
"0.6713706",
"0.66260254",
"0.6605663",
"0.6512112",
"0.64368165",
"0.63372135",
"0.6322044",
"0.6287195",
"0.62597674",
"0.6028215",
"0.60169154",
"0.60037804",
"0.5979012",
"0.5960334",
"0.5936236",
"0.5925249",
"0.59102845",
"0.58939767",
"0.5880... | 0.608454 | 11 |
Deletes the source files when d yes is used as an argument to the console. | def delete_files(src_files):
for i, src_file in enumerate(src_files):
sys.stdout.write(str(i + 1) + ': ' + src_file + '\n')
subprocess.call(['rm', src_file]) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def scrub():\n\n\tlocal(\"rm -fr dist build\")\n\tlocal(\"find . -name \\\"*.pyc\\\" -exec rm '{}' ';'\")",
"def clean():\n for dirpath, dirnames, filenames in os.walk('.'):\n for filename in filenames:\n if filename.endswith('.pyc') or filename.endswith('.pyo'):\n full_pathna... | [
"0.64925873",
"0.6472665",
"0.64230376",
"0.6391575",
"0.637083",
"0.63624465",
"0.6295995",
"0.6258228",
"0.62149173",
"0.6147259",
"0.6144624",
"0.6119391",
"0.60543656",
"0.60124403",
"0.59782493",
"0.59513044",
"0.59416646",
"0.59151274",
"0.5907112",
"0.58845353",
"0.588... | 0.635088 | 6 |
Prints help when the h or help argument is used in the command line. | def print_help():
sys.stdout.write(
'Use: find [ARGUMENTS] ... | mediatoaudio.py [ARGUMENTS] ...\n'
' or: ls [ARGUMENTS] ... | mediatoaudio.py [ARGUMENTS] ...\n'
'mediatoaudio.py uses standard input to convert files with ffmpeg.\n'
'\nArguments:\n' \
' -c\taudio codec\t\togg... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_cli_help(self):\n output = self.update_command('-h')",
"def printhelp():",
"def _help(self):\n self.onecmd('help')",
"def show_help():\n pass",
"def print_help():\n\tprint(\"Help text\")",
"def help():\n print(UI.HELP)",
"def ShortHelp(doexit=True):\n print(parser.de... | [
"0.80226815",
"0.7880057",
"0.7862627",
"0.78081363",
"0.7797057",
"0.7785448",
"0.77128595",
"0.7686523",
"0.76731783",
"0.76218337",
"0.75972503",
"0.7589725",
"0.75646996",
"0.7560763",
"0.7560303",
"0.7546299",
"0.74988663",
"0.7487726",
"0.7486519",
"0.74784267",
"0.7468... | 0.68655795 | 88 |
Here explain the definition of the gromacs weight | def AleWeights(temperatures, internal_energies, target_temperatures, integrator = 'trapezoid', alpha = None, weight_GROMACS_format = True):
# Selecting the integrator method
if integrator == 'trapezoid':
integrator = integrate.trapz
elif integrator == 'trapz':
integrator = np.trapz
elif... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def weight(self):",
"def getWeight(self) -> float:\n ...",
"def get_weights(self):",
"def get_weight(self):\n pass",
"def get_weight(self):\n pass",
"def gated_weighting(g, w_content, w_previous):\n\n return g * w_content + (1-g) * w_previous",
"def weights(self):\r\n\t\tret... | [
"0.72532266",
"0.69395727",
"0.6821024",
"0.6741765",
"0.6741765",
"0.66126347",
"0.6605744",
"0.65307605",
"0.6522943",
"0.64295447",
"0.6369714",
"0.6369714",
"0.6369714",
"0.6369714",
"0.6369714",
"0.6369714",
"0.6369714",
"0.6369714",
"0.63524663",
"0.6337981",
"0.6276387... | 0.0 | -1 |
The two input is a list that could be obtained from mdp.annealing3 The structure is the following annealing_times = [t1, t2, t3, t4, t5, t6] | def get_energy(edr, annealing_times, energy_type = 'Potential', out_fig = 'energy_distribution.svg'): # Could be Total-Energy
fig, ax = plt.subplots(figsize = (16,9))
data = pd.DataFrame()
xvg_tmp_file = tempfile.NamedTemporaryFile(suffix='.xvg')
energy = []
iterator = range(0, len(annealing_times)-... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def spin_adapted_t2(creation_list, annihilation_list):\n _check_int_list(creation_list, \"creation operators\")\n _check_int_list(annihilation_list, \"annihilation operators\")\n\n if len(creation_list) != 2 or len(annihilation_list) != 2:\n raise ValueError(f\"T2 excitations take exactly 2 indices... | [
"0.59733194",
"0.583341",
"0.5753424",
"0.57403886",
"0.56659484",
"0.56205523",
"0.5589108",
"0.55861825",
"0.5484096",
"0.5454451",
"0.54484034",
"0.54357857",
"0.5422951",
"0.5390583",
"0.53496975",
"0.53313315",
"0.52978075",
"0.5269319",
"0.52431566",
"0.5222972",
"0.515... | 0.0 | -1 |
This function read a log file obtained from simulated tempering and returns a numpy array of shape (number of time points, number of states, 2) The first axis of the array refears to each output on the log file. The second axis refears to the temperature states And the last one to the counts and value of the correspond... | def get_weights_from_log(log, plot = False):
with open(log, 'r') as f:
log_file = f.readlines()
i = 0
time = []
weights_info = []
weights_0 = []
while i < len(log_file):
if 'init-lambda-weights[' in log_file[i]:
weights_0.append(float(log_file[i].split('=')[-1]))
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def getWeights(self, format='list'):\n timer = None\n if conf.config.getboolean(\"Reports\", \"outputTimesForSections\"):\n timer = Timer()\n timer.start_timing()\n synapse_list = self._get_synaptic_data()\n if conf.config.getboolean(\"Reports\", \"outputTimesForSe... | [
"0.5679781",
"0.5495576",
"0.5362034",
"0.527573",
"0.5247644",
"0.51613903",
"0.51452",
"0.51238173",
"0.5120641",
"0.5115963",
"0.50911295",
"0.50866115",
"0.49406517",
"0.4936814",
"0.4911786",
"0.48889357",
"0.486517",
"0.48642686",
"0.4859323",
"0.48575228",
"0.4830234",... | 0.7046495 | 0 |
Load a COBRApy Model object into the GEMPRO project. | def load_cobra_model(self, model):
self.model = ModelPro(model)
for g in self.model.genes:
if self.genes_dir:
g.root_dir = self.genes_dir
g.protein.pdb_file_type = self.pdb_file_type
self.genes = self.model.genes
log.info('{}: loaded model'.format... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_model(self) -> Any:",
"def load(path_to_model):\n pass",
"def load_model(self):\n pass",
"def load_model(self, model_path: str):",
"def _load_model(self):\n with open(self.filepath, 'rb') as file:\n self.cmodel = pickle.load(file)",
"def load_model(self, path):\n ... | [
"0.75577265",
"0.74616426",
"0.7443691",
"0.72105366",
"0.71995646",
"0.71612245",
"0.70299786",
"0.697022",
"0.6902634",
"0.68662226",
"0.66627985",
"0.66133004",
"0.6587798",
"0.65446216",
"0.6522303",
"0.6507763",
"0.64993095",
"0.64980847",
"0.6494972",
"0.6485254",
"0.64... | 0.6683296 | 10 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.