def setUp(self):
self.virtual_player = VirtualPlayer(1, 0.1, model=Qlearning(),
game_skeleton=pd.DataFrame({'StimulusLeft': [5, 4, 1],
'StimulusRight': [6, 3, 2],
'LeftReward': [1, -1, 1],
'BetterStimulus': [1, 1, 1],
'RightReward': [1, 1, -1]}))
def make_plot(dir):
model = Qlearning()
rp = RealPlayer(dir, model=model)
game = GameSession()
player = VirtualPlayer(10,
0.1,
game_skeleton=game.game_skeleton,
model=model)
game.play(player=player)
game._create_result()
fig = plt.figure()
ax = fig.add_subplot(111, projection='3d')
T = np.arange(-1, 1, 0.1)
print(T.shape)
alpha = np.arange(0, 1, 0.05)
print(alpha.shape)
X, Y = np.meshgrid(T, alpha)
zs = np.array([
rp.log_likelihood_function(list(x))
for x in zip(np.ravel(X), np.ravel(Y))
])
Z = zs.reshape(X.shape)
ax.plot_surface(X, Y, Z)
ax.set_xlabel('T')
ax.set_ylabel('alpha')
ax.set_zlabel('log likelihood')
def test_get_optimized_parameters_for_q_learning(self):
# given
self.real_player.model = Qlearning()
# when
actual = self.real_player.get_optimized_parameters()
# then
self.assertIsInstance(actual, np.ndarray)
self.assertEqual(len(actual), 2)
def test_log_likelihood_function_q_learning(self):
# given
self.real_player.model = Qlearning()
parameters = np.array([1, 0.1])
expected = -1 * (3 * np.log(1 / 2))
# when
actual = self.real_player.log_likelihood_function(params=parameters)
# then
self.assertEqual(actual, expected)
def test_q_table_values_q_learning(self):
# given
self.real_player.model = Qlearning()
parameters = np.array([1, 0.1])
expected = [-0.1, 0, 0.1, 0, 0.1, 0]
# when
self.real_player.log_likelihood_function(params=parameters)
actual = self.real_player.model.Q_table
# then
self.assertEqual(actual, expected)
def test_max_log_likelihood_with_default_starting_points(
self, mock_minimize):
# given
default_start_points = np.array([1, 0.1])
self.real_player.model = Qlearning()
# when
self.real_player.max_log_likelihood()
# then
mock_minimize.assert_called_once()
assert_array_equal(mock_minimize.call_args[1]['x0'],
default_start_points)
def test_max_log_likelihood(self, mock_minimize):
# given
start_points = [3, 0.2]
self.real_player.model = Qlearning()
# when
self.real_player.max_log_likelihood(start_points=start_points)
# then
mock_minimize.assert_called_once_with(
self.real_player.log_likelihood_function,
x0=start_points,
method='Nelder-Mead')
from scripts.game_session import GameSession
from scripts.models import Qlearning
from scripts.player import VirtualPlayer
if __name__ == '__main__':
game = GameSession()
model = Qlearning()
player = VirtualPlayer(2,
0.1,
game_skeleton=game.game_skeleton,
model=model)
game.play(player=player)
game.save_results()
def test_get_default_optimization_start_points_for_Q_learning(self):
real_player = RealPlayer(TEST_DATA_PATH, model=Qlearning())
assert_array_equal(real_player.start_points, np.array([1, 0.1]))
def get_model(model):
if isinstance(model, RescorlaWagner):
model = RescorlaWagner()
else:
model = Qlearning()
return model