def __init__(self, state_size, action_size, seed, policy_lr=LR, critic_lr=LR): """Initialize an Agent object. Params ====== state_size (int): dimension of each state action_size (int): dimension of each action seed (int): random seed """ self.state_size = state_size self.action_size = action_size random.seed(seed) # Networks self.policy_local = Actor(self.state_size, self.action_size, seed) self.policy_target = Actor(self.state_size, self.action_size, seed) self.critic_local = Critic(self.state_size + self.action_size, self.action_size, seed) self.critic_target = Critic(self.state_size + self.action_size, self.action_size, seed) # initialize target networks weights for target_param, param in zip(self.policy_target.parameters(), self.policy_local.parameters()): target_param.data.copy_(param.data) for target_param, param in zip(self.critic_target.parameters(), self.critic_local.parameters()): target_param.data.copy_(param.data) # optimizer self.policy_optimizer = optim.Adam(self.policy_local.parameters(), lr=policy_lr) self.critic_optimizer = optim.Adam(self.critic_local.parameters(), lr=critic_lr) self.epsilon = EPSILON # Noise process self.noise = OUNoise(action_size, seed)
def post_actors(payload): data = request.json try: actor = Actor(name=data['name'], age=data['age'], gender=data['gender']) actor.insert() return jsonify({'success': True}) except Exception: db.session.rollback() abort(422)
def add_actor(payload): req = request.get_json() actor = Actor(name=req['name'], age=req['age'], gender=req['gender']) try: actor.insert() except Exception: abort(422) return jsonify({'id': actor.id, 'success': True})
def create_test_actor(data): """ Create a test actor record :param data: {"name": "Test Actor", "gender": "Male", "age": 55} :return: Created Actor instance """ actor = Actor(**data) actor.insert() return actor
def create_actor(payload): data = request.get_json() name = data.get('name') age = data.get('age') gender = data.get('gender') actor = Actor(name=name, age=age, gender=gender) db.session.add(actor) db.session.commit() return jsonify({'success': True, 'actors': actor.format()}), 201
def post_actor(payload): # try: age = request.get_json()['age'] gender = request.get_json()['gender'] name = request.get_json()['name'] newactor = Actor(age=age, gender=gender, name=name) newactor.insert() return jsonify({'success': True, 'actor': newactor.format()})
def create_actor(token): try: req = request.get_json() act = Actor(name=req['name'], gender=req['gender'], age=req['age']) act.insert() actors = Actor.query.all() return jsonify({"success": True, "actors": [d.format() for d in actors]}), 200 except: abort(404)
def test_get_actors(self): n_actor = Actor(name='fatima', age=30, gender='female', movieid=20) n_actor.insert() respo = self.client().get('/actors', headers={'Authorization': "Bearer " + TOKEN}) data = json.loads(respo.data) self.assertEqual(respo.status_code, 200) self.assertEqual(data['success'], True) self.assertTrue(len(data['actors']))
def test_403_delete_actor_casting_assistant(self): actor = Actor(name='Maha', age=10, gendar='Female') actor.insert() actorId = actor.id res = self.client().delete(f'/actors/{actor.id}', headers=self.casting_assistant) data = json.loads(res.data) self.assertEqual(res.status_code, 403) self.assertEqual(data['success'], False)
def create_actor(): try: data = request.get_json() actor = Actor(data.get('name'), data.get('age'), data.get('gender')) actor.create() return jsonify({'success': True, 'created': actor.id}), 201 except: print(sys.exc_info()) abort(422)
def test_casting_assistant_cannot_delete_an_actor(self): token = os.environ.get('ASSISTANT') headers = {"Authorization": f"Bearer {token}"} model = Actor(name="Badmus Ope", age=25, gender="male") model.insert() resp = self.client().delete(f'/actors/{model.id}', headers=headers) result = json.loads(resp.data) self.assertEqual(resp.status_code, 401) self.assertFalse(result['success'])
def test_drop_actor_casting_director(self): actor = Actor('Test abul', 24, 'M') actor.insert() res = self.client().delete('/actors/' + str(actor.id), headers=settingup_auth('casting_director')) data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True) self.assertEqual(int(data['delete']), actor.id)
def test_patch_actor(self): self.actor = Actor(name="test", age=1, gender="male") self.actor.insert() res = self.client().patch(f'/actors/{self.actor.id}', headers={'Authorization': f'Bearer {executive_producer}'}, json={"name": "test1"}) data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True) self.actor.delete()
def post_actor(token): data = request.get_json() new_actor = Actor(name=data['name'], age=data['age'], gender=data['gender']) new_actor.insert() return jsonify({'actor ': new_actor.format(), 'success': True})
def test_400_update_actor(self): actor = Actor(name='Maha', age=50, gendar='Female') actor.insert() actorId = actor.id res = self.client().patch(f'/actors/{actor.id}', headers=self.casting_director) data = json.loads(res.data) self.assertEqual(res.status_code, 400) self.assertEqual(data['success'], False)
def test_400_update_actor(self): actor = Actor(name='Elsa Montanha', age=21, gender='Female') actor.insert() actor_id = actor.id response = self.client() .patch('/actors/'+str(actor_id)+'', headers=self.director) data = json.loads(response.data) self.assertEqual(response.status_code, 422) self.assertEqual(data['success'], False)
def test_delete_actor(self): actor = Actor(name='Maha', age=10, gendar='Female') actor.insert() actorId = actor.id res = self.client().delete(f'/actors/{actor.id}', headers=self.executive_producer) data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True)
def __init__(self, state_dim, action_dim, max_action, device, memory_capacity=10000, discount=0.99, tau=0.005, sigma=0.2, theta=0.15, actor_lr=1e-4, critic_lr=1e-3, train_mode=True): self.train_mode = train_mode # whether the agent is in training or testing mode self.state_dim = state_dim # dimension of the state space self.action_dim = action_dim # dimension of the action space self.device = device # defines which cuda or cpu device is to be used to run the networks self.discount = discount # denoted a gamma in the equation for computation of the Q-value self.tau = tau # defines the factor used for Polyak averaging (i.e., soft updating of the target networks) self.max_action = max_action # the max value of the range in the action space (assumes a symmetric range in the action space) # create an instance of the replay buffer self.memory = ReplayMemory(memory_capacity) # create an instance of the noise generating process self.ou_noise = OrnsteinUhlenbeckNoise(mu=np.zeros(self.action_dim), sigma=sigma, theta=theta) # instances of the networks for the actor and the critic self.actor = Actor(state_dim, action_dim, max_action, actor_lr) self.critic = Critic(state_dim, action_dim, critic_lr) # instance of the target networks for the actor and the critic self.target_actor = Actor(state_dim, action_dim, max_action, actor_lr) self.target_critic = Critic(state_dim, action_dim, critic_lr) # initialise the targets to the same weight as their corresponding current networks self.target_actor.load_state_dict(self.actor.state_dict()) self.target_critic.load_state_dict(self.critic.state_dict()) # since we do not learn/train on the target networks self.target_actor.eval() self.target_critic.eval() # for test mode if not self.train_mode: self.actor.eval() self.critic.eval() self.ounoise = None self.actor.to(self.device) self.critic.to(self.device) self.target_actor.to(self.device) self.target_critic.to(self.device)
def test_fail_get_Actor(self): res = self.client().get( '/actor', headers={'Authorization': 'Bearer ' + ASS_TOKEN}) data = json.loads(res.data) actor = Actor(name='leen', age='12', gender='female') actor.insert() self.assertEqual(res.status_code, 404) self.assertEqual(data['success'], False) self.assertEqual(data['message'], 'Resource Not found')
def insert_data(self): """Seed test database with initial data""" actor1 = Actor(name="NIck JOnas", age=25, gender='m') actor2 = Actor(name="rock", age=22, gender='f') actor3 = Actor(name="Salman", age=32, gender='f') movie1 = Movie(title="Joker", release_date="02/01/2000") movie2 = Movie(title="Titanic", release_date="05/07/2015") movie3 = Movie(title="abcd", release_date="09/11/2029") self.db.session.add(actor1) self.db.session.add(actor2) self.db.session.add(actor3) self.db.session.add(movie1) self.db.session.add(movie2) self.db.session.add(movie3) self.db.session.commit() self.db.session.close()
def add_actors(): try: body = request.get_json() actor = Actor(name=body['name'], dob=body['DOB'], gender=body.get('gender')) actor.insert() return jsonify({'success': True, 'actor': actor.format()}) except Exception as e: abort(422)
def add_actor(jwt): body = request.get_json() req_name = body.get('name') req_age = body.get('age') req_gender = body.get('gender') if not req_name: abort(422) actor = Actor(name=req_name, age=req_age, gender=req_gender) actor.insert() return jsonify({'success': True, 'actors': actor.format()})
def test_get_actors(self): new_actor = Actor(name='test', age=12, gender=GenderEnum(1)) new_actor.save_to_db() res = self.client().get('/api/actors') data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True) self.assertGreater(len(data['actors']), 0)
def test_drop_actor_executive_producer(self): actor = Actor('abdul', 30, 'M') actor.insert() res = self.client().delete( '/actors/' + str(actor.id), headers=settingup_auth('executive_producer')) data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True) self.assertEqual(int(data['delete']), actor.id)
def test_update_actor_executive_producer(self): actor = Actor('Alex Tree', 77, 'M') actor.insert() res = self.client().patch('/actors/' + str(actor.id), json={'age': 77}, headers=settingup_auth('executive_producer')) data = json.loads(res.data) self.assertEqual(res.status_code, 200) self.assertEqual(data['success'], True) self.assertEqual(actor.age, 77)
def test_update_actor_casting_director(self): actor = Actor('Test Abu', 28, 'M') actor.insert() res = self.client().patch('/actors/13' + str(actor.id), json={'age': 28}, headers=settingup_auth('casting_director')) data = json.loads(res.data) self.assertEqual(res.status_code, 404) self.assertEqual(data['success'], False) self.assertEqual(actor.get_actor()['age'], 28)
def add_actor(payload): data = request.get_json() if any(x not in data for x in ['name', 'age', 'gender']): abort(422) actor = Actor(**data) actor.insert() return jsonify({'success': True, 'actor': actor.format()}), 200
def __init__(self, state_size, action_size, random_seed, hyper, num_agents, memory): self.action_size = action_size self.num_agents = num_agents # Actor Network (w/ Target Network) self.actor_local = Actor(state_size, action_size, random_seed).to(device) self.actor_target = Actor(state_size, action_size, random_seed).to(device) self.actor_optimizer = optim.Adam(self.actor_local.parameters(), lr=hyper['LR_ACTOR']) # Critic Network (w/ Target Network) self.critic_local = Critic(state_size, action_size, num_agents, random_seed).to(device) self.critic_target = Critic(state_size, action_size, num_agents, random_seed).to(device) self.critic_optimizer = optim.Adam(self.critic_local.parameters(), lr=hyper['LR_CRITIC']) #, weight_decay=hyper['WEIGHT_DECAY']) # Noise process self.noise = OUNoise(action_size, random_seed) self.t = 0 self.memory = memory
def __init__(self, state_dim, action_dim, max_action, args): self.actor = Actor(state_dim, action_dim, max_action).to(args.device) self.actor_target = Actor(state_dim, action_dim, max_action).to(args.device) self.actor_target.load_state_dict(self.actor.state_dict()) self.actor_optimizer = torch.optim.Adam(self.actor.parameters()) self.critic = Critic(state_dim, action_dim).to(args.device) self.critic_optimizer = torch.optim.Adam(self.critic.parameters()) self.target_critic = Critic(state_dim, action_dim).to(args.device) self.target_critic.load_state_dict(self.target_critic.state_dict()) self.max_action = max_action self.batch_size = args.batch_size self.discount = args.discount self.tau = args.tau self.policy_noise = args.policy_noise self.noise_clip = args.noise_clip self.policy_freq = args.policy_freq self.device = args.device self.step = 0
def insert_data(self): """Seed test database with initial data""" actor1 = Actor(name="Sam Jones", age=25, gender='m') actor2 = Actor(name="Cynthia Jones", age=22, gender='f') actor3 = Actor(name="Vanna White", age=32, gender='f') movie1 = Movie(title="The Movie", year=2015) movie2 = Movie(title="The Movie 2", year=2016) movie3 = Movie(title="The Movie 3", year=2017) self.db.session.add(actor1) self.db.session.add(actor2) self.db.session.add(actor3) self.db.session.add(movie1) self.db.session.add(movie2) self.db.session.add(movie3) self.db.session.commit() self.db.session.close()