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()
