def find_outdated(requirements): # Find specified versions in requirements.txt reqs = [ InstallRequirement.from_line(req) for req in requirements ] packages = [ req.name for req in reqs ] interact() # Determine latest versions from PyPi index jobs = [ gevent.spawn(lambda p: (p, find_versions(p)[0],), p) for p in packages ] gevent.joinall(jobs) available = [ job.value for job in jobs ] print available
def playaround(): import pip from pip.index import PackageFinder from pip.req import InstallRequirement, RequirementSet req = InstallRequirement.from_line("django-hoptoad", None) finder = PackageFinder(find_links=[], index_urls=["http://pypi.python.org/simple/"]) ret = finder.find_requirement(req, False) print ret print type(ret) interact()
def run(self): ret = interact.interact( self.bin.split(), self.code, self.timeout) ret = self.get_result(ret) self.check_expect(ret)
def fit_interact_cfs(self, X, y, mode='uc', threshold=0, backward=True, look_ahead=1, **kwargs): cols1 = interact(X, y, threshold) cols2 = cfs(X, y, backward, look_ahead, mode) cols_set = set(cols1) | set(cols2) cols = list(cols_set) cols.sort() self.cols_ = cols
def main(argv): if len(argv) == 1: print("""Usage: main start_date end_date where dates are in YYYY-MM-DD format""") else: cred = credentials.Certificate( '../../firebase_files/covid-spread-analyzer-firebase-adminsdk-hxchu-8c78edc7cd.json' ) initialize_app( cred, {'databaseURL': 'https://covid-spread-analyzer.firebaseio.com/'}) print("downloading from database") interact([None, "-d", argv[1], argv[2]]) print("\nenriching data from database") update([None, argv[1], argv[2]]) print("\nsaving data to database") interact([None, "-u"])
def run(self): code = self.code for name in self.modules: code = "[%s].\n" % name + code # load modules ret = interact.interact(self.bin.split(), code, self.timeout) ret = self.get_result(ret) self.check_expect(ret) for name in self.modules: os.remove("%s.pl" % name)
def run(self): code = self.code for name in self.modules: code = "[%s].\n" % name + code # load modules ret = interact.interact( self.bin.split(), code, self.timeout) ret = self.get_result(ret) self.check_expect(ret) for name in self.modules: os.remove("%s.pl" % name)
def train(nb_steps: int, env: Env, agent: Agent, start_obs: Arrayable): """Trains for one epoch. :args nb_steps: number of interaction steps :args env: environment :args agent: interacting agent :start_obs: starting observation :return: final observation """ agent.train() agent.reset() obs = start_obs for _ in range(nb_steps): # interact obs, _, _ = interact(env, agent, obs) return obs
def evaluate( dt: float, epoch: int, env: Env, agent: Agent, eval_gap: float, # noqa: C901 time_limit: Optional[float] = None, eval_return: bool = False, progress_bar: bool = False, video: bool = False, no_log: bool = False, test: bool = False, eval_policy: bool = True) -> Optional[float]: """Evaluate agent in environment. :args dt: time discretization :args epoch: index of the current epoch :args env: environment :args agent: interacting agent :args eval_gap: number of normalized epochs (epochs divided by dt) between training steps :args time_limit: maximal physical time (number of steps divided by dt) spent in the environment :args eval_return: do we only perform specific evaluation? :args progress_bar: use a progress bar? :args video: log a video of the interaction? :args no_log: do we log results :args test: log to a different test summary :args eval_policy: if the exploitation policy is noisy, remove the noise before evaluating :return: return evaluated, None if no return is evaluated """ log_gap = int(eval_gap / dt) agent.eval() if not eval_policy and isinstance(agent, OnlineAgent): agent.noisy_eval() agent.reset() R = None if eval_return: rewards, dones = [], [] imgs = [] time_limit = time_limit if time_limit else 10 nb_steps = int(time_limit / dt) info(f"eval> evaluating on a physical time {time_limit}" f" ({nb_steps} steps in total)") obs = env.reset() iter_range = tqdm(range(nb_steps)) if progress_bar else range(nb_steps) for _ in iter_range: obs, reward, done = interact(env, agent, obs) rewards.append(reward) dones.append(done) if video: imgs.append(env.render(mode='rgb_array')) R = compute_return(np.stack(rewards, axis=0), np.stack(dones, axis=0)) tag = "noisy" if not eval_policy else "" info(f"eval> At epoch {epoch}, {tag} return: {R}") if not no_log: if not eval_policy: log("Return_noisy", R, epoch) elif not video: # don't log when outputing video if not test: log("Return", R, epoch) else: log("Return_test", R, epoch) if video: log_video("demo", epoch, np.stack(imgs, axis=0)) if not no_log: specific_evaluation(epoch, log_gap, dt, env, agent) return R
def fit_interact(self, X, y, threshold=0): self.cols_ = interact(X, y, threshold)
clog = np.log10(p) cmin = np.log10(0.1) cmax = np.log10(5) if clog<cmin: clog = cmin if clog>cmax: clog = cmax cindex = (clog - cmin)/(cmax - cmin) color = cmap_borange(cindex) for ef, f in enumerate(f_array[:]): fsq = np.sqrt(f) finv = 1/f #fsqinv = np.sqrt(finv) if case==0: x1, x2, x3, v1, v2, v3 = interact.interact(f*M.si.value, fsq*B_.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, (x*0.5/np.sqrt(p)).si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) elif case==1: x1, x2, x3, v1, v2, v3 = interact.interact(M.si.value, fsq*B_.si.value, phi.rad, finv*V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) elif case==2: x1, x2, x3, v1, v2, v3 = interact.interact(f*M.si.value, B_.si.value, phi.rad, f*V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) elif case==3: x1, x2, x3, v1, v2, v3 = interact.interact(f*M.si.value, B_.si.value, phi.rad, V.si.value, theta.rad, finv*Tenc.si.value, finv*T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream = {} stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) plt.sca(ax[ep][ef]) plt.plot(stream['x'][0]/(fsq*B_), stream['x'][1]/(fsq*B_), '.', color=color, ms=3, alpha=0.02) plt.gca().set_aspect('equal')
# Richard Darst, May 2009 """If you do 'import fitz.interactnow', it will do a better code.interact() """ import interact interact.interact(stackLevel=2)
def phases(seed=8264): """""" # impact parameters M = 1e5*u.Msun B = 100*u.pc V = 100*u.km/u.s phi = coord.Angle(180*u.deg) #theta = coord.Angle(th*u.deg) Tenc = 1*u.Gyr T = 1*u.Gyr dt = 0.1*u.Myr rs = 0*u.pc # setup tube Nstar = 500 wx = 5*u.kpc wy = 2*u.pc wz = 2*u.pc sx = 0*u.km/u.s np.random.seed(seed) x = (np.random.rand(Nstar) - 0.5) * wx y = (np.random.randn(Nstar) - 0.5) * wy z = (np.random.randn(Nstar) - 0.5) * wz vx = (np.random.randn(Nstar) - 0.5) * sx vy = (np.random.randn(Nstar) - 0.5) * sx vz = (np.random.randn(Nstar) - 0.5) * sx angles = [5, 18, 90] times = [0.01] for th in angles: theta = coord.Angle(th*u.deg) T = B**2*V*np.abs(np.sin(theta.rad))/(2*G*M) times += [T.to(u.Gyr).value] times += [4] times = np.array(times) * u.Gyr cmap_navy = mpl.colors.LinearSegmentedColormap.from_list('cmap_navy', [(0,'#78aadd'), (1,'#00187f')], N=256) plt.close() fig, ax = plt.subplots(5, 3, figsize=(10,10), sharex=True) for et, T in enumerate(times): for ea, th in enumerate(angles): theta = coord.Angle(th*u.deg) p = (G*M*T/(B**2*V*np.abs(np.sin(theta.rad)))).decompose() print(et, T, p) x1, x2, x3, v1, v2, v3 = interact.interact(M.si.value, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream = {} stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) plt.sca(ax[et][ea]) clog = np.log10(p.value) cmin = np.log10(5e-2) cmax = np.log10(20) if clog<cmin: clog = cmin if clog>cmax: clog = cmax cindex = (clog - cmin)/(cmax - cmin) plt.plot(stream['x'][0], stream['x'][1], 'o', color=cmap_navy(cindex), ms=1.5, alpha=0.6) #plt.plot(stream['x'][0], stream['x'][1], 'o', color=cmap_navy(min(1.,p.value/7)), ms=1.5, alpha=0.6) txt = plt.text(0.9, 0.15, '$\psi$={:.2f}'.format(p), ha='right', va='center', transform=plt.gca().transAxes, fontsize='small') txt.set_bbox(dict(facecolor='w', alpha=0.7, ec='none')) if et==0: plt.title('$\\theta$ = {:.0f}$^\circ$'.format(th), fontsize='medium') if et==np.size(times)-1: plt.xlabel('x [pc]') if ea==0: plt.ylabel('y [pc]') if ea==np.size(angles)-1: plt.ylabel('T = {:.2f}'.format(T), labelpad=20, fontsize='small', rotation=270) plt.gca().yaxis.set_label_position('right') plt.tight_layout(h_pad=0.1, w_pad=0.15) plt.savefig('../plots/freespace_phases.png') plt.savefig('../plots/freespace_phases.pdf')
def scaling_norm(seed=473): """""" # impact parameters M = 1e5*u.Msun B = 100*u.pc V = 100*u.km/u.s phi = coord.Angle(180*u.deg) theta=coord.Angle(45*u.deg) Tenc = 1*u.Gyr T = 1*u.Gyr dt = 0.05*u.Myr rs = 0*u.pc # setup tube Nstar = 500 wx = 5*u.kpc wy = 2*u.pc wz = 0*u.pc sx = 0*u.km/u.s np.random.seed(seed) x = (np.random.rand(Nstar) - 0.5) * wx y = (np.random.randn(Nstar) - 0.5) * wy z = (np.random.randn(Nstar) - 0.5) * wz vx = np.zeros(Nstar)*u.km/u.s vy = np.zeros(Nstar)*u.km/u.s vz = np.zeros(Nstar)*u.km/u.s # nonscaled x1, x2, x3, v1, v2, v3 = interact.interact(M.si.value, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream0 = {} stream0['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream0['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) # scaling Nf = 10 f1_array = np.logspace(np.log10(0.2),np.log10(10),Nf) f2_array = np.logspace(np.log10(0.1),np.log10(5),Nf) f3_array = np.logspace(np.log10(np.sqrt(0.1)),np.log10(np.sqrt(5)),Nf) sigma_x_mt = np.zeros(Nf) sigma_v_mt = np.zeros(Nf) sigma_x_mv = np.zeros(Nf) sigma_v_mv = np.zeros(Nf) sigma_x_vt = np.zeros(Nf) sigma_v_vt = np.zeros(Nf) for e, f in enumerate(f1_array): finv = 1/f x1, x2, x3, v1, v2, v3 = interact.interact(f*M.si.value, B.si.value, phi.rad, V.si.value, theta.rad, finv*Tenc.si.value, finv*T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream = {} stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) sigma_x_mt[e] = np.linalg.norm(stream['x']-stream0['x'])/Nstar sigma_v_mt[e] = np.linalg.norm(stream['v']-stream0['v'])/Nstar f = f2_array[e] x1, x2, x3, v1, v2, v3 = interact.interact(f*M.si.value, B.si.value, phi.rad, f*V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream = {} stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) sigma_x_mv[e] = np.linalg.norm(stream['x']-stream0['x'])/Nstar sigma_v_mv[e] = np.linalg.norm(stream['v']-stream0['v'])/Nstar f = f3_array[e] x1, x2, x3, v1, v2, v3 = interact.interact(M.si.value, B.si.value, phi.rad, f*V.si.value, theta.rad, f*Tenc.si.value, f*T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream = {} stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) sigma_x_vt[e] = np.linalg.norm(stream['x']-stream0['x'])/Nstar sigma_v_vt[e] = np.linalg.norm(stream['v']-stream0['v'])/Nstar print(sigma_v_mt) print(sigma_v_mv) print(sigma_v_vt) dblue = mpl.cm.Blues(0.9) mblue = mpl.cm.Blues(0.7) lblue = mpl.cm.Blues(0.5) plt.close() fig, ax = plt.subplots(2,1,figsize=(8,8), sharex=True) plt.sca(ax[0]) plt.plot(1/f1_array, sigma_x_mt, '-', color=lblue, lw=6) plt.plot(f2_array, sigma_x_mv, '-', color=mblue, lw=4) plt.plot(f3_array**2, sigma_x_vt, color=dblue, lw=2) plt.ylabel('$\left< \Sigma_x\\right>$ [pc]') plt.sca(ax[1]) plt.plot(1/f1_array, sigma_v_mt, '-', color=lblue, lw=6) plt.plot(f2_array, sigma_v_mv, '-', color=mblue, lw=4) plt.plot(f3_array**2, sigma_v_vt, color=dblue, lw=2) #plt.xlabel('f') plt.gca().set_yscale('log') plt.xlabel('Fastness') plt.ylabel('$\left< \Sigma_v \\right>$ [km s$^{-1}$]') plt.tight_layout() plt.savefig('../plots/scaling_norm.png')
def scaling(seed=98, f=2): """""" # impact parameters M = 1e5*u.Msun B = 100*u.pc V = 100*u.km/u.s phi = coord.Angle(180*u.deg) theta=coord.Angle(45*u.deg) Tenc = 1*u.Gyr T = 10*u.Gyr dt = 0.1*u.Myr rs = 0*u.pc # setup tube Nstar = 500 wx = 5*u.kpc wy = 2*u.pc wz = 0*u.pc sx = 0*u.km/u.s np.random.seed(seed) x = (np.random.rand(Nstar) - 0.5) * wx y = (np.random.randn(Nstar) - 0.5) * wy z = (np.random.randn(Nstar) - 0.5) * wz vx = np.zeros(Nstar)*u.km/u.s vy = np.zeros(Nstar)*u.km/u.s vz = np.zeros(Nstar)*u.km/u.s # limits print('dense:{:.2g} << 1'.format(rs/B)) print('fast: {:.2g} << 1'.format((G*M/(V**2*B)).decompose()) ) print('thin: {:.2g} << 1'.format((np.sqrt(wy**2 + wz**2)/B).decompose()) ) print('long: {:.2g} >> 1'.format((wx/B).decompose()) ) print('cold: {:.2g} << 1'.format((sx/V).decompose()) ) x1, x2, x3, v1, v2, v3 = interact.interact(M.si.value, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream1 = {} stream1['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream1['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) finv = 1/f fsq = np.sqrt(f) x1, x2, x3, v1, v2, v3 = interact.interact(f*M.si.value, B.si.value, phi.rad, V.si.value, theta.rad, finv*Tenc.si.value, finv*T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream2 = {} stream2['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream2['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) x1, x2, x3, v1, v2, v3 = interact.interact(f*M.si.value, B.si.value, phi.rad, f*V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream3 = {} stream3['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream3['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) x1, x2, x3, v1, v2, v3 = interact.interact(M.si.value, B.si.value, phi.rad, f*V.si.value, theta.rad, f*Tenc.si.value, f*T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream4 = {} stream4['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream4['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) #x1, x2, x3, v1, v2, v3 = interact.interact(f*M.si.value, f*B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) #stream5 = {} #stream5['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) #stream5['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) dblue = mpl.cm.Blues(0.8) lblue = mpl.cm.Blues(0.5) ms = 2 streams = [stream1, stream2, stream3, stream4] labels = ['M,T,V', '{0:.1f}M,T/{0:.1f},V'.format(f), '{0:.1f}M,T,{0:.1f}V'.format(f),'M,{0:.1f}T,{0:.1f}V'.format(f), '{0:.1f}M,sqrt{0:.1f}B'.format(f)] plt.close() fig, ax = plt.subplots(1,2,figsize=(10,5)) for e, stream in enumerate(streams): color = mpl.cm.Blues(e/5+0.1) ms = 14 - 2*e plt.sca(ax[0]) plt.plot(stream['x'][0], stream['x'][1], 'o', color=color, ms=ms) plt.sca(ax[1]) plt.plot(stream['x'][0], stream['x'][2], 'o', color=color, ms=ms, label=labels[e]) plt.sca(ax[0]) plt.xlabel('x (pc)') plt.ylabel('y (pc)') plt.sca(ax[1]) plt.xlabel('x (pc)') plt.ylabel('z (pc)') plt.legend(fontsize='small', loc=1) plt.tight_layout() plt.savefig('../plots/scaling_{:.1f}.png'.format(f))
def atlas_freespace(th=90, seed=51835): """""" # impact parameters M = 1e5*u.Msun B = 100*u.pc V = 100*u.km/u.s phi = coord.Angle(180*u.deg) theta=coord.Angle(th*u.deg) Tenc = 1*u.Gyr T = 1*u.Gyr dt = 0.1*u.Myr rs = 0*u.pc # setup tube Nstar = 500 wx = 5*u.kpc wy = 0*u.pc wz = 0*u.pc sx = 0*u.km/u.s np.random.seed(seed) x = (np.random.rand(Nstar) - 0.5) * wx y = (np.random.randn(Nstar) - 0.5) * wy z = (np.random.randn(Nstar) - 0.5) * wz vx = (np.random.randn(Nstar) - 0.5) * sx vy = (np.random.randn(Nstar) - 0.5) * sx vz = (np.random.randn(Nstar) - 0.5) * sx x1, x2, x3, v1, v2, v3 = interact.interact(M.si.value, B.si.value, phi.rad, V.si.value, theta.rad, Tenc.si.value, T.si.value, dt.si.value, x.si.value, y.si.value, z.si.value, vx.si.value, vy.si.value, vz.si.value) stream = {} stream['x'] = (np.array([x1, x2, x3])*u.m).to(u.pc) stream['v'] = (np.array([v1, v2, v3])*u.m/u.s).to(u.km/u.s) ms = 8 alpha = 0.3 plt.close() fig, ax = plt.subplots(2,1,figsize=(8,8), sharex=True) plt.sca(ax[0]) plt.plot(stream['x'][0], stream['x'][1], 'o', ms=ms, alpha=alpha) plt.ylabel('y (pc)') plt.xlim(-3000,3000) plt.ylim(-1100,20) plt.title('$\\theta$ = {:3.0f}$^\circ$'.format(th), fontsize='medium') # circle phi_ = np.linspace(0,2*np.pi,100) r = 0.05 x0 = 0.3 y0 = 0.65 x = r*np.cos(phi_) + x0 y = r*np.sin(phi_) + y0 xp = r*np.cos(2*np.pi-theta.rad) + x0 yp = r*np.sin(2*np.pi-theta.rad) + y0 Ns = 9 xs = np.linspace(-1.5*r, 1.5*r, Ns) + x0 ys = np.zeros(Ns) + y0 plt.plot(x, y, '-', color='0.3', alpha=0.5, lw=2, transform=fig.transFigure) plt.plot(xp, yp, 'o', color='0.3', ms=10, transform=fig.transFigure) plt.plot(xs, ys, 'o', color='tab:blue', ms=5, alpha=0.5, transform=fig.transFigure) plt.sca(ax[1]) plt.plot(stream['x'][0], stream['x'][2], 'o', ms=ms, alpha=alpha) plt.ylabel('z (pc)') plt.xlabel('x (pc)') plt.xlim(-3000,3000) plt.ylim(-30,30) plt.tight_layout() plt.savefig('../plots/animations/angles/angles_{:03.0f}.png'.format(th/5))
self.content = f"""ves: {Console} ves.c_ves: {CVESClient}""" def __str__(self): return self.content def __repr__(self): return self.content def __call__(self, obj): return help(obj) import sys banner = '=' * 30 + ' ves client console ' + '=' * 30 banner += f""" Python {sys.version} on {sys.platform} Type "desc" for more information""" ves = Console() utils = Utils() desc = ConsoleDesc() main_load_cfg() print('entering ves console...') interact( banner=banner, exitmsg='exiting ves client console...', local=create_local(), )
from agents.DDPG import DDPG agent = DDPG(env, "continousStateAction") # continousStateAction imageStateContinuousAction if selectedAgent == 3: # Create DDPG network agent obsSpace = env.observation_space.shape print("env.observation_space: ", obsSpace) from agents.DDPG import DDPG agent = DDPG(env, "imageStateContinuousAction") # continousStateAction imageStateContinuousAction """ # run the simulation """ import interact as sim num_episodes=500 sim.interact(agent, env, num_episodes, mode='train', file_output=file_output_train, renderSkip=100) """ # Plot training scores obtained per episode """ from visuals import plot_q_table, plot_score_from_file plot_score_from_file(file_output_train, -300, 300, 1) if selectedAgent == 0 or selectedAgent == 1: plot_q_table(agent.q_table) """ # save model and architecture to single file # https://machinelearningmastery.com/save-load-keras-deep-learning-models/ """ if selectedAgent == 2 or selectedAgent == 3:
w = pickle.load(f) temp = None # prevent pickling mem leak cv = KFold(len(y), n_folds=5) """ Exhaustive Search """ params = params_lst[i_reduced] records = [] for discrete in params["discrete"]: # discrete? if discrete: Xt = Xd else: Xt = Xc for t, it in enumerate(params["interact_threshold"]): # INTERACT cols = interact(Xd, y, it) cols.sort() if len(cols) == 0: continue X = Xt[:, cols] xgmats = [] for train, valid in cv: Xcv = X[train] ycv = y[train] wcv = w[train] * float(test_size) / len(ycv) # ASM normalization xgmats.append(xgb.DMatrix(Xcv, label=ycv, weight=wcv)) for p, model_params in enumerate(ParameterGrid(params["param_grid"])): n_trees = model_params["n_trees"] pos_weight_ratio = model_params["pos_weight_ratio"] subparams = {}
y = pickle.load(f) w = pickle.load(f) temp = None # prevent pickling mem leak cv = KFold(len(y), n_folds=5) ''' Exhaustive Search ''' params = params_lst[i_reduced] records = [] for discrete in params["discrete"]: # discrete? if discrete: Xt = Xd else: Xt = Xc for t, it in enumerate(params["interact_threshold"]): # INTERACT cols = interact(Xd, y, it) cols.sort() if len(cols) == 0: continue X = Xt[:, cols] xgmats = [] for train, valid in cv: Xcv = X[train] ycv = y[train] wcv = w[train] * float(test_size) / len( ycv) # ASM normalization xgmats.append(xgb.DMatrix(Xcv, label=ycv, weight=wcv)) for p, model_params in enumerate( ParameterGrid(params["param_grid"])): n_trees = model_params["n_trees"] pos_weight_ratio = model_params["pos_weight_ratio"]