def entry_point(): """ External entry point which calls main() and if Stop is raised, calls sys.exit() """ try: main(items=[ (AlreadyMerged.NAME, AlreadyMerged), (CheckMilestone.NAME, CheckMilestone), (CheckStatus.NAME, CheckStatus), (Deploy.NAME, Deploy), (Label.NAME, Label), (Merge.NAME, Merge), (Rebase.NAME, Rebase), (Token.NAME, Token), (SetCommitStatus.NAME, SetCommitStatus), (TagRelease.NAME, TagRelease), (TravisMerge.NAME, TravisMerge), (Version.NAME, Version), (UnrebasedPRs.NAME, UnrebasedPRs), (UpdateSubmodules.NAME, UpdateSubmodules), ]) except Stop, stop: print stop, sys.exit(stop.rc)
def eval_defend_submissions(): parameters_filepath = "./helper_files/parameters_holdout.ini" evasion_methods = ['natural', 'rfgsm_k', 'topk', 'bca_k', 'grosse'] for model_filepath in glob.glob(os.path.join(DEFEND_DIR, '*.pt')): submission_name = re.search( "\[training:.*\|", model_filepath).group(0)[:-1].split(':')[-1] print("Evaluating {}'s submission".format(submission_name)) set_parameter(parameters_filepath, "general", "experiment_suffix", submission_name) set_parameter(parameters_filepath, "general", "training_method", submission_name) set_parameter(parameters_filepath, "general", "load_model_weights", "True") set_parameter(parameters_filepath, "general", "model_weights_path", model_filepath) set_parameter(parameters_filepath, "challenge", "eval", "True") set_parameter(parameters_filepath, "challenge", "defend", "True") set_parameter(parameters_filepath, "challenge", "attack", "False") for evasion_method in evasion_methods: set_parameter(parameters_filepath, "general", "evasion_method", evasion_method) main(config_file=parameters_filepath) create_tex_tables(filespath="./result_files")
def eval_attack_submssions(): parameters_filepath = "./helper_files/parameters_attack.ini" model_filepath = "./helper_files/[training:natural|evasion:dfgsm_k]_demo-model.pt" for attack_filepath in glob.glob(os.path.join(ATTACK_DIR, '*.npy')): if attack_filepath.split('/')[-1] == "aes.npy": continue submission_name = attack_filepath.split('/')[-1].split('_')[-1][:-4] print("Evaluating {}'s submission".format(submission_name)) copyfile(attack_filepath, os.path.join(ATTACK_DIR, 'aes.npy')) set_parameter(parameters_filepath, "general", "experiment_suffix", submission_name) set_parameter(parameters_filepath, "general", "training_method", "secret_model") set_parameter(parameters_filepath, "general", "load_model_weights", "True") set_parameter(parameters_filepath, "general", "model_weights_path", model_filepath) set_parameter(parameters_filepath, "challenge", "eval", "True") set_parameter(parameters_filepath, "challenge", "defend", "False") set_parameter(parameters_filepath, "challenge", "attack", "True") set_parameter(parameters_filepath, "general", "evasion_method", submission_name) set_parameter(parameters_filepath, "challenge", "adv_examples_path", ATTACK_DIR) main(config_file=parameters_filepath) create_tex_tables(filespath="./result_files") print("Check evasion latex table file in results_files")
def _frameworkstart(strqueue, keyqueue): try: global _running while _running: framework.main(strqueue, keyqueue) time.sleep(.01) except SystemExit: _running = False
def entry_point(): """ External entry point which calls main() and if Stop is raised, calls sys.exit() """ try: main(items=[ (UpgradeCommand.NAME, UpgradeCommand), (DownloadCommand.NAME, DownloadCommand), (Version.NAME, Version)]) except Stop, stop: print stop, sys.exit(stop.rc)
def entry_point(items=tuple()): """ External entry point which calls main() and if Stop is raised, calls sys.exit() """ try: if not items: from example import ExampleCommand from version import Version items = [(ExampleCommand.NAME, ExampleCommand), (Version.NAME, Version)] main("yaclifw", items=items) except Stop, stop: print stop, sys.exit(stop.rc)
config = neat.Config(neat.DefaultGenome, neat.DefaultReproduction, neat.DefaultSpeciesSet, neat.DefaultStagnation, config_path) with open(net_name, 'rb') as f: c = pickle.load(f) net = neat.nn.FeedForwardNetwork.create(c, config) from evolve_feedforward_box2d import NeuralNetworkController return NeuralNetworkController(net) if __name__ == "__main__": initial_position = 2.3 initial_rotation = 0.0 run_off_winner_neat = True if run_off_winner_neat: controller = load_winner_net_controller() # print(c) # node_names = {-1: 'x', -2: 'dx', -3: 'theta', -4: 'dtheta', 0: 'control'} #visualize.draw_net(config, c, view=True, node_names=node_names, # filename="winner-feedforward-enabled-pruned.gv", show_disabled=False, prune_unused=True) else: controller = TrivialProportionalController() main(CartPendulumDemo, controller, initial_position, initial_rotation)
@route("/josh/") class josh(bo.baseObject): def GET(self): self.data = '' for bit in self.env: self.data += ("%s : %s<br>" % (str(bit), str(self.env[bit]))) yield self.data yield self.endPolling() @route("/josh/(.*)/") class joshMember(bo.baseObject): def GET(self): self.data = '' for member in self.members: self.data += ("<h1>%s</h1>" % str(member)) for bit in self.env: self.data += ("%s : %s" % (str(bit), str(self.env[bit]))) yield self.data yield self.endPolling() if __name__ == '__main__': fw.main()
stat, ret = self.client_v1.review.get(self.review_id) ret = json.loads(ret) self.assertEqual(stat, status_code['OK']) self.assertTrue(isinstance(ret, dict)) self.assertTrue(self.review_id in ret['id']['$t']) # 针对 review_id 的获取特定评论异常测试函数 def test_get_reviews_exception_review_id_v1(self): invalid_review_id = 'BadUserId' # bad review id stat, ret = self.client_v1.review.get(invalid_review_id) self.assertEqual(stat, status_code['NOT_FOUND']) self.assertTrue(isinstance(ret, str)) self.assertEqual('wrong subject id:\'' + invalid_review_id + '\'', ret) invalid_review_id = '0000001' # wrong review id stat, ret = self.client_v1.review.get(invalid_review_id) self.assertEqual(stat, status_code['NOT_FOUND']) self.assertTrue(isinstance(ret, str)) self.assertEqual('wrong subject id:\'' + invalid_review_id + '\'', ret) invalid_review_id = '' # empty review id stat, ret = self.client_v1.review.get(invalid_review_id) self.assertEqual(stat, status_code['NOT_FOUND']) self.assertTrue(isinstance(ret, str)) self.assertEqual('wrong subject id:\'' + invalid_review_id + '\'', ret) if __name__ == '__main__': main(testRunner=test_runner())
from simulator import Simulator import framework import physicsSettings from learningSettings import learningSettings import cProfile def test(): simulator = Simulator(False) while (True): simulator.Step(physicsSettings.fwSettings) if (learningSettings.useGraphics): framework.main(Simulator) else: cProfile.runctx('test()', globals(), locals(), 'profileResults1.pstats')
plank = fixtureDef( shape=polygonShape(box=(0.6, 0.125)), density=20, friction=0.2, ) # Create one Chain (Only the left end is fixed) prevBody = ground y = 25 numPlanks = 30 for i in range(numPlanks): body = self.world.CreateDynamicBody( position=(0.5 + i, y), fixtures=plank, ) #You can try a WeldJoint for a slightly different effect. #self.world.CreateWeldJoint( self.world.CreateRevoluteJoint( bodyA=prevBody, bodyB=body, anchor=(i, y), ) prevBody = body if __name__ == "__main__": main(Chain)
# The ground ground = create_fixed_box(self.world, p_ll=b2Vec2(xlow, ylow), p_hr=b2Vec2(xhi, yhi)) # The bodies radius = 1 columnCount = 5 rowCount = 5 for j in range(columnCount): for i in range(rowCount): create_circle(self.world, (-10 + (2.1 * j + 1 + 0.01 * i) * radius, (2 * i + 1) * radius), radius) self.world.gravity = (0, -9.81) b_ix = -1 for b in self.world.bodies: b_ix += 1 b.userData.id = b_ix def Step(self, settings): super(Confined, self).Step(settings) if __name__ == "__main__": main(Confined)
self.assertEqual(None, ret) def test_read_doumail(self): ret = self.client.doumail.read(self.doumail_id) self.assertEqual('R', ret['status']) def test_reads_doumail(self): ret = self.client.doumail.reads(self.doumail_ids) self.assertTrue(isinstance(ret, dict)) self.assertTrue(isinstance(ret['mails'], list)) def test_delete_doumail(self): doumail = self.client.doumail.inbox() doumail_id = doumail['mails'][0]['id'] ret = self.client.doumail.delete(doumail_id) self.assertEqual({}, ret) def test_deletes_doumail(self): doumail = self.client.doumail.inbox() doumail_ids = [m['id'] for m in doumail['mails']][:2] ret = self.client.doumail.deletes(ids=doumail_ids) self.assertEqual({}, ret) if __name__ == '__main__': main()
from __future__ import print_function import os import sys sys.path.append(os.path.abspath("framework")) from benchmarks import CPUConvnets from benchmarks import CPULSTMBench from benchmarks import CPUNNBench from benchmarks import CUDALSTMBench from benchmarks import NumpyUnaryComparison from benchmarks import CPUUnaryBench from benchmarks import NumpyReduceComparison import framework if __name__ == "__main__": framework.main( sys.argv, [ CPUNNBench, CPUConvnets, # CPULSTMBench, CPUUnaryBench, CUDALSTMBench, # NumpyReduceComparison, # NumpyUnaryComparison, ], )
position=(-10.0, 0), fixtures=b2.Fixture(shape=b2.Circle(radius=1.0), density=1.0) ) controller.add_body(body) # And finally, some triangles for i in range(5): body = self.world.create_dynamic_body( position=(-10+3.0*i, 20), fixtures=b2.Fixture( shape=b2.Polygon( vertices=[(-0.5,0),(0,-0.5),(0.5, 0.0)]), density=1.0) ) controller.add_body(body) # And (really) finally this time, just something so we can be sure # edges work, too. edge = world.create_dynamic_body( fixtures=b2.Fixture(shape=b2.Edge((5, 0),(5, 3)), density=1.0) ) controller.add_body(edge) if __name__=="__main__": main(Buoyancy)
def main(): framework.main(Game)
ground.create_edge_fixture(vertices=[(50, 0), (50, 10)], friction=0.2) for i in range(2, 18, 2): body = self.world.create_dynamic_body(position=(-10.1, i)) body.create_polygon_fixture(box=(3.0, 1.0), density=3.0) self.blob_radius = 2 self.bodies, self.joints = create_blob( self.world, (-10, 50), self.blob_radius, circle_radius=0.5) def Keyboard(self, key): if key == Keys.K_w: self.jump = 10000 elif key == Keys.K_a: self.move = -500 elif key == Keys.K_d: self.move = 500 elif key == Keys.K_s: self.move = 0 self.jump = 100 def Step(self, settings): Framework.Step(self, settings) blob_step(self.world, self.bodies, self.blob_radius, self.jump, self.move) self.jump = 100 if __name__ == "__main__": main(GishTribute)
learningSettings.foodUses, learningSettings.foodEnergy) self.generationsElapsed += 1 self.groupsElapsed = 0 #What to do at the end of the experiment def afterExperiment(self, settings): Simulator.experimentCount += 1 self.population.saveToFile(self.fileHandler.popSaveName) if (Simulator.experimentCount >= learningSettings.numberOfExperiments): exit() else: self.__init__(False) #Find the agent currently driving this walker for this group def findAgentForWalker(self, walkerIndex, groupSize): agentIndex = self.groupsElapsed * groupSize + walkerIndex #If the walker wasn't actually being driven by anything, return None if (agentIndex >= self.population.size()): return None return self.population.agentList[agentIndex] def resetWalkers(self): #Reset all walkers for walker in self.walkerList: walker.resetPosition() if __name__ == "__main__": main(Simulator)
plank=fixtureDef( shape=polygonShape(box=(0.6,0.125)), density=20, friction=0.2, ) # Create one Chain (Only the left end is fixed) prevBody = ground y = 25 numPlanks = 30 for i in range(numPlanks): body = self.world.CreateDynamicBody( position=(0.5+i, y), fixtures=plank, ) #You can try a WeldJoint for a slightly different effect. #self.world.CreateWeldJoint( self.world.CreateRevoluteJoint( bodyA=prevBody, bodyB=body, anchor=(i, y), ) prevBody = body if __name__=="__main__": main(Chain)
# if self.cnt % 10 == 0: # self.cnt += 1 # #print ctrls for idx, joint in enumerate(self.joints): joint.motorEnabled = True joint.motorSpeed = ctrls[idx] * 10 joint.maxMotorTorque = 1000 com_pos = reduce(add, [x.mass * x.worldCenter for x in self.bodies]) com_vel = reduce(add, [x.mass * x.linearVelocity for x in self.bodies]) pos = [x.worldCenter for x in self.bodies] rot = [x.angle for x in self.bodies] linvel = [x.linearVelocity for x in self.bodies] angvel = [x.angularVelocity for x in self.bodies] # xpos = [x.position for x in self.bodies] # qpos = [ print com_pos, com_vel # for body in self.bodies: # print body.userData["name"], body.linearVelocity super(Hopper, self).Step(settings) if __name__ == "__main__": main(Hopper)
"graph":"STG", "content":"CIU", "time":"LDF", "trust":"IT", "delta":540, "beta":0.1, "t0":365, "k":10, "gamma":0.7, "alpha":0.9 } rs_list = [rs1_param, rs2_param] # list of configurated recsys # ----> Read data import csv linkstream = [] with open(input_dataset_file,'rb') as input_file: input_file = csv.reader(input_file, delimiter=separator_df) for line in input_file: if len(line) >= 5: t,u,i,c,r = int(line[pos_t]), line[pos_u], line[pos_i], line[pos_c], float(line[pos_r]) linkstream.append( (t, u, i, c, r) ) linkstream = sorted(linkstream, key=lambda tup: tup[0]) trust_network = [] if input_trust_network!=None or input_trust_network!="": with open(input_trust_network,'rb') as input_file: input_file = csv.reader(input_file, delimiter=separator_tn) for line in input_file: if len(line) >= 2: u,trusted = line[pos_user], line[pos_trusted] trust_network.append( (u, trusted) ) fw.main(rs_list, linkstream, trust_network, eval_metric, number_of_time_slices)
# delete review_id = ret['id'] stat, ret = self.client_v2.movie.review.delete(review_id) # 针对 review_id 的删除电影评论异常测试函数 def test_delete_review_exception_review_id_v2(self): invalid_review_id = "BadReviewId" # bad review id stat, ret = self.client_v2.movie.review.delete(invalid_review_id) self.assertEqual(stat, status_code['BAD_REQUEST']) self.assertTrue(isinstance(ret, dict)) self.assertEqual('invalid_request_uri', ret['msg']) self.assertEqual(107, ret['code']) invalid_review_id = '1000000000' # wrong review id stat, ret = self.client_v2.movie.review.delete(invalid_review_id) self.assertEqual(stat, status_code['NOT_FOUND']) self.assertTrue(isinstance(ret, dict)) self.assertEqual('review_not_found', ret['msg']) self.assertEqual(5006, ret['code']) invalid_review_id = '' # empty review id stat, ret = self.client_v2.movie.review.delete(invalid_review_id) self.assertEqual(stat, status_code['BAD_REQUEST']) self.assertTrue(isinstance(ret, dict)) self.assertEqual('invalid_request_uri', ret['msg']) self.assertEqual(107, ret['code']) if __name__ == '__main__': main(testRunner=test_runner())
# Reusing the fixture we previously defined above fixture.shape.box = (0.75, 0.75) self.payload = self.world.CreateDynamicBody( position=(0, 8), fixtures=fixture, ) def Keyboard(self, key): if key == Keys.K_d: self.platform.type = b2_dynamicBody elif key == Keys.K_s: self.platform.type = b2_staticBody elif key == Keys.K_k: self.platform.type = b2_kinematicBody self.platform.linearVelocity = (-self.speed, 0) self.platform.angularVelocity = 0 def Step(self, settings): super(BodyTypes, self).Step(settings) if self.platform.type == b2_kinematicBody: p = self.platform.transform.position v = self.platform.linearVelocity if ((p.x < -10 and v.x < 0) or (p.x > 10 and v.x > 0)): v.x = -v.x self.platform.linearVelocity = v if __name__ == "__main__": main(BodyTypes)
controller.add_body(body) # Create a bridge, and add it to the controller num_planks = 30 plank_bodies = create_bridge(self.world, ground, (1.0, 0.25), (-14.5, 5), num_planks, 0.2, 10) for body in plank_bodies: controller.add_body(body) # Create a circle underneath the bridge body = self.world.create_dynamic_body( position=(-10.0, 0), fixtures=b2.Fixture(shape=b2.Circle(radius=1.0), density=10.0) ) controller.add_body(body) # And finally, some triangles for i in range(5): body = self.world.create_dynamic_body( position=(-10+3.0*i, 20), fixtures=b2.Fixture(shape=b2.Polygon(vertices=[(-0.5,0),(0,-0.5),(0.5, 0.0)]), density=1.0) ) controller.add_body(body) if __name__=="__main__": main(Gravity)
self.laser_body = self.world.CreateDynamicBody( userData='laser', position=(0, 2), fixtures=b2FixtureDef(density=4.0, shape=b2PolygonShape(box=(LASER_HALF_WIDTH, 1)))) for i in range(2): self.world.CreateDynamicBody(userData=LASER_SPLIT_TAG, position=(3.0 + i * 6, 8), fixtures=b2FixtureDef( density=5.0, shape=b2PolygonShape(box=(3, 3)))) def Keyboard(self, key): if key == Keys.K_c: laser_cut(self.world, self.laser_body, laser_half_width=LASER_HALF_WIDTH) def Step(self, settings): Framework.Step(self, settings) laser_display(self.renderer, self.laser_body, laser_half_width=LASER_HALF_WIDTH) if __name__ == "__main__": main(BoxCutter)
for ind in pop: for i in range(len(ind)): if ind[i] > ubounds[i]: ind[i] = ubounds[i] elif ind[i] < lbounds[i]: ind[i] = lbounds[i] return pop return wrappper return decorator def init(benchmark): lbounds = tuple(benchmark.get_lbounds()) ubounds = tuple(benchmark.get_ubounds()) min_ = min(lbounds) max_ = max(ubounds) centroid = uniform(lbounds, ubounds) sigma = 0.3 * (max_ - min_) lambda_ = int(4 + 3 * log(benchmark.ndim)) strategy = cma.Strategy(centroid=centroid, sigma=sigma, lambda_=lambda_) toolbox = base.Toolbox() toolbox.register("generate", strategy.generate, creator.Individual) toolbox.register("update", strategy.update) toolbox.register("bounds", checkBounds(lbounds, ubounds)) toolbox.decorate("generate", toolbox.bounds) return toolbox if __name__ == "__main__": main(init)
# b.expects(:binary?).never # assert !b.indexable? def test_language(self): def _check_lang(sample): blob = self.blob(sample['path']) assert blob.language, 'No language for %s' % sample['path'] assert sample['language'] == blob.language.name, blob.name Samples.each(_check_lang) def test_lexer(self): assert find_lexer_class('Ruby') == self.blob("Ruby/foo.rb").lexer def test_colorize(self): assert colorize == self.blob("Ruby/foo.rb").colorize() def test_colorize_without_wrapper(self): assert colorize_without_wrapper == self.blob("Ruby/foo.rb").colorize_without_wrapper() def test_colorize_does_skip_minified_files(self): assert None == self.blob("JavaScript/jquery-1.6.1.min.js").colorize() # Pygments.rb was taking exceeding long on this particular file def test_colorize_doesnt_blow_up_with_files_with_high_ratio_of_long_lines(self): assert None == self.blob("JavaScript/steelseries-min.js").colorize() if __name__ == '__main__': main()