def main():
player_manager = PlayerManager("Los Angeles Lakers", "file.txt")
player1 = Forward(23, "Lebron", "James", 201, 81, 2003, "forward", 1028,
690)
player2 = Center(12, "Dwight", "Howard", 210, 90, 2002, "center", 1054,
"Aggresive")
player3 = Guard(10, "Rajon", "Rondo", 190, 76, 2004, "guard", 909, 1203)
player_manager.add_player(player1)
player_manager.add_player(player2)
player_manager.add_player(player3)
print_report(player_manager)
player_manager.delete_player(12)
player_manager.delete_player(10)
print_report(player_manager)
player1 = Forward(23, "Yeet", "James", 69, 81, 2003, "forward", 1028, 690)
player_manager.update_player(player1)
print_report(player_manager)
print(player_manager.get_player(23))
def test_init(self):
# new blank instance
new_blank = Forward()
self.assertEquals(new_blank.targets, [])
self.assertEquals(new_blank.instances, {})
self.assertTrue(isinstance(new_blank, Forward))
# new success instance
new_success = Forward(targets=[[
'192.168.1.1', 'vlb', 'admin', 'admin_pw', {
'port': 22,
'timeout': 30
}
], ['192.168.1.1', 'vlb', 'admin', 'admin_pw']])
self.assertEquals(new_success.targets, [[
'192.168.1.1', 'vlb', 'admin', 'admin_pw', {
'port': 22,
'timeout': 30
}
], ['192.168.1.1', 'vlb', 'admin', 'admin_pw']])
self.assertTrue(isinstance(new_success, Forward))
# new fail instance
with self.assertRaises(ForwardError):
new_fail = Forward(targets=[['192.168.1.1', 'vlb', 'admin', 234]])
def setUp(self):
""" Sets up data and calls logPoint """
self.logPoint()
self.player_manager = PlayerManager("Los Angeles Lakers", "file.txt")
self.player1 = Forward(1, "Lebron", "James", 201, 81, 2003, "forward",
1028, 690)
self.player_manager.add_player(self.player1)
self.assertIsNotNone(self.player_manager)
def scaled_estimate(self, x, T):
self.__init_storage(T)
for t in range(T):
fw, bw = Forward(self.A, self.B,
self.rho), Backward(self.A, self.B, self.rho)
P, _ = fw.scaled_evaluate(x), bw.scaled_evaluate(x, fw.C)
self.__scaled_update(fw.alpha, bw.beta, fw.C, x)
self.__store(np.log(fw.C).sum(), t)
def estimate(self, x, T):
self.__init_storage(T)
for t in range(T):
fw, bw = Forward(self.A, self.B,
self.rho), Backward(self.A, self.B, self.rho)
P, _ = fw.evaluate(x), bw.evaluate(x)
self.__update(fw.alpha, bw.beta, x)
self.__store(np.log(P), t)
def main():
para_cfg_obj = ParaCfg('../config/appConfig.cfg')
logger_obj = Logger(para_cfg_obj.LOGFILE_PATH)
track_logger = logger_obj.get_logger()
para_cfg_obj.to_log(track_logger)
forward_obj = Forward(track_logger, para_cfg_obj)
forward_obj.run()
def setUp(self):
""" Sets up data and calls logPoint """
self.logPoint()
self.player_manager = PlayerManager("Los Angeles Lakers")
self.player1 = Forward(1, "Lebron", "James", 201, 81, 2003, 1028, 690)
self.player2 = Center(2, "Dwight", "Howard", 210, 90, 2002, 1054,
"Aggresive")
self.player3 = Guard(3, "Rajon", "Rondo", 190, 76, 2004, 909, 1203)
self.player_manager.add_player(self.player1)
self.player_manager.add_player(self.player2)
self.player_manager.add_player(self.player3)
self.assertIsNotNone(self.player_manager)
def add_player():
""" Adds a player to the player manager """
content = request.json
try:
if content["player_type"] == "center":
center = Center(content["player_id"], content["first_name"],
content["last_name"], content["height"],
content["weight"], content["year_drafted"],
content["player_type"], content["num_rebounds"],
content["play_type"])
player_manager.add_player(center)
elif content["player_type"] == "forward":
forward = Forward(content["player_id"], content["first_name"],
content["last_name"], content["height"],
content["weight"], content["year_drafted"],
content["player_type"],
content["num_shots_took"],
content["num_shots_made"])
player_manager.add_player(forward)
elif content["player_type"] == "guard":
guard = Guard(content["player_id"], content["first_name"],
content["last_name"], content["height"],
content["weight"], content["year_drafted"],
content["player_type"], content["num_steals"],
content["num_assists"])
player_manager.add_player(guard)
response = app.response_class(status=200, )
except ValueError as e:
response = app.response_class(response=str(e), status=400)
return response
def main(_):
graph = tf.Graph()
model_params = ModelParams()
model_params.update()
with graph.as_default():
model = Forward(model_params)
with tf.Session(graph=graph, config=config) as sess:
train(sess, model)
def compute_initial_embedding(db, dim, batch_size, epochs):
samples = get_samples(db, args.num_samples, partition=0)
row_idx = {
r: i
for i, (_, r,
_) in enumerate(db.iter_rows(db.predict_rel, partition=0))
}
scheme_idx = {s: i for i, s in enumerate(samples.keys())}
model = Forward(dim, len(samples), row_idx, scheme_idx)
loader = preproc_data(samples, model, batch_size)
train(model, loader, epochs)
embedding = model.get_embedding()
embedding = {r: embedding[i] for r, i in row_idx.items()}
return embedding, model
def test_get_instances(self):
new_blank = Forward()
new_blank.addTargets(['192.168.113.123'],
'bclinux7',
'north_king',
'wolf_spirit',
timeout=40,
port=25)
new_blank.addTargets(['192.168.113.124-192.168.113.126'], 'vlb',
'south_king', 'fish_spirit')
instances = new_blank.getInstances(preLogin=False)
node123 = instances['192.168.113.123']
node124 = instances['192.168.113.124']
node125 = instances['192.168.113.125']
node126 = instances['192.168.113.126']
self.assertTrue(
isinstance(
node123,
getattr(
importlib.import_module('forward.devclass.%s' %
'bclinux7'), 'BCLINUX7')))
self.assertTrue(
isinstance(
node125,
getattr(importlib.import_module('forward.devclass.%s' % 'vlb'),
'VLB')))
def setUp(self):
engine = create_engine('sqlite:///test_players.sqlite')
# Create all the tables
Base.metadata.create_all(engine)
Base.metadata.bind = engine
""" Sets up data and calls logPoint """
self.logPoint()
self.player_manager = PlayerManager("test_players.sqlite")
self.player1 = Forward(1, "Lebron", "James", 201, 81, 2003, "forward",
1028, 690)
self.player2 = Center(2, "Dwight", "Howard", 210, 90, 2002, "guard",
1054, "Aggresive")
self.player3 = Guard(3, "Rajon", "Rondo", 190, 76, 2004, "center", 909,
1203)
self.player_manager.add_player(self.player1)
self.player_manager.add_player(self.player2)
self.player_manager.add_player(self.player3)
self.assertIsNotNone(self.player_manager)
def test_get_instances(self):
new_blank = Forward()
new_blank.addTargets(
['192.168.113.123'],
'bclinux7',
'north_king',
'wolf_spirit',
timeout=40,
port=25
)
new_blank.addTargets(
['192.168.113.124-192.168.113.126'],
'vlb',
'south_king',
'fish_spirit'
)
instances = new_blank.getInstances(preLogin=False)
node123 = instances['192.168.113.123']
node124 = instances['192.168.113.124']
node125 = instances['192.168.113.125']
node126 = instances['192.168.113.126']
self.assertTrue(isinstance(node123, getattr(
importlib.import_module('forward.devclass.%s' % 'bclinux7'),
'BCLINUX7'
)))
self.assertTrue(isinstance(node125, getattr(
importlib.import_module('forward.devclass.%s' % 'vlb'),
'VLB'
)))
def on_accept(self):
forward = Forward().start(self.fwd[0], self.fwd[1])
clientsock, clientaddr = self.pserver.accept()
if forward:
print clientaddr, "has connected"
self.input_list.append(clientsock)
self.input_list.append(forward)
self.channel[clientsock] = forward
self.channel[forward] = clientsock
else:
print "Can't establish connection with remote server.",
print "Closing connection with client side", clientaddr
clientsock.close()
def test_add_targets(self):
new_blank = Forward()
new_blank.addTargets(
['192.168.113.123'],
'bclinux7',
'north_king',
'wolf_spirit',
timeout=40,
port=25
)
new_blank.addTargets(
['192.168.113.124-192.168.113.126'],
'vlb',
'south_king',
'fish_spirit'
)
self.assertEquals(new_blank.targets, [
['192.168.113.123', 'bclinux7', 'north_king', 'wolf_spirit', {'timeout': 40, 'port': 25}],
['192.168.113.124', 'vlb', 'south_king', 'fish_spirit', {}],
['192.168.113.125', 'vlb', 'south_king', 'fish_spirit', {}],
['192.168.113.126', 'vlb', 'south_king', 'fish_spirit', {}]
])
def __init__(self, K, table_dices, player_dice):
"""Initialize the viterbi algorithm. K is the number of tables,
table_dices is a list of length K composed by couple (d,d'):
d is the dice of the table not primed, d' is the dice of the primed
table, player_dice is the dice used by the player"""
self.K = K
self.table_dices = table_dices
if (len(table_dices) != K):
raise ValueError('A list of K couple of dices should be provided '
'for the parameter table_dices')
self.player_dice = player_dice
#initialize forward algorithm for later use
self.forward_alg = Forward(K, table_dices, player_dice)
def _read_players_from_file(self):
""" Reads players from file """
with open(self._filepath, 'r') as input_file:
players = json.load(input_file)
for json_data in players:
type = json_data["player_type"]
if type == "center":
player_id = json_data["player_id"]
first_name = json_data["first_name"]
last_name = json_data["last_name"]
height = json_data["height"]
weight = json_data["weight"]
year_drafted = json_data["year_drafted"]
player_type = json_data["player_type"]
num_rebounds = json_data["num_rebounds"]
play_type = json_data["play_type"]
player = Center(player_id, first_name, last_name, height,
weight, year_drafted, player_type,
num_rebounds, play_type)
elif type == "forward":
player_id = json_data["player_id"]
first_name = json_data["first_name"]
last_name = json_data["last_name"]
height = json_data["height"]
weight = json_data["weight"]
year_drafted = json_data["year_drafted"]
player_type = json_data["player_type"]
num_shots_took = json_data["num_shots_took"]
num_shots_made = json_data["num_shots_made"]
player = Forward(player_id, first_name, last_name, height,
weight, year_drafted, player_type,
num_shots_took, num_shots_made)
elif type == "guard":
player_id = json_data["player_id"]
first_name = json_data["first_name"]
last_name = json_data["last_name"]
height = json_data["height"]
weight = json_data["weight"]
year_drafted = json_data["year_drafted"]
player_type = json_data["player_type"]
num_steals = json_data["num_steals"]
num_assists = json_data["num_assists"]
player = Guard(player_id, first_name, last_name, height,
weight, year_drafted, player_type,
num_steals, num_assists)
self._players.append(player)
return self._players
def test(opt):
# cuDNN auto-tuning.
if opt.autotune:
torch.backends.cudnn.benchmark = True
# Create model.
net = InferenceNet(opt)
if opt.chkpt_num > 0:
net = load_chkpt(net, opt)
net = net.cuda()
if not opt.no_eval:
net.eval()
# Forward scan.
fwd = Forward(net, opt)
for data_name in opt.data_names:
print(data_name)
scanner = make_forward_scanner(data_name, opt)
output = fwd(scanner)
save_output(data_name, output, opt)
def update_player(player_id):
""" Updates an existing player"""
content = request.json
player = player_manager.get_player(player_id)
if player == None:
response = app.response_class(status=404)
try:
if content["player_type"] == "center":
center = Center(content["player_id"], content["first_name"],
content["last_name"], content["height"],
content["weight"], content["year_drafted"],
content["player_type"], content["num_rebounds"],
content["play_type"])
player_manager.update_player(center)
elif content["player_type"] == "forward":
forward = Forward(content["player_id"], content["first_name"],
content["last_name"], content["height"],
content["weight"], content["year_drafted"],
content["player_type"],
content["num_shots_took"],
content["num_shots_made"])
player_manager.update_player(forward)
elif content["player_type"] == "guard":
guard = Guard(content["player_id"], content["first_name"],
content["last_name"], content["height"],
content["weight"], content["year_drafted"],
content["player_type"], content["num_steals"],
content["num_assists"])
player_manager.update_player(guard)
response = app.response_class(status=200)
except ValueError as e:
response = app.response_class(response=str(e), status=404)
return response
def test_add_targets(self):
new_blank = Forward()
new_blank.addTargets(['192.168.113.123'],
'bclinux7',
'north_king',
'wolf_spirit',
timeout=40,
port=25)
new_blank.addTargets(['192.168.113.124-192.168.113.126'], 'vlb',
'south_king', 'fish_spirit')
self.assertEquals(
new_blank.targets,
[[
'192.168.113.123', 'bclinux7', 'north_king', 'wolf_spirit', {
'timeout': 40,
'port': 25
}
], ['192.168.113.124', 'vlb', 'south_king', 'fish_spirit', {}],
['192.168.113.125', 'vlb', 'south_king', 'fish_spirit', {}],
['192.168.113.126', 'vlb', 'south_king', 'fish_spirit', {}]])
class TestPlayer(TestCase):
""" Unit tests for the Player Class """
def setUp(self):
engine = create_engine('sqlite:///test_players.sqlite')
# Create all the tables
Base.metadata.create_all(engine)
Base.metadata.bind = engine
""" Sets up data and calls logPoint """
self.logPoint()
self.player_manager = PlayerManager("test_players.sqlite")
self.player1 = Forward(1, "Lebron", "James", 201, 81, 2003, "forward",
1028, 690)
self.player2 = Center(2, "Dwight", "Howard", 210, 90, 2002, "guard",
1054, "Aggresive")
self.player3 = Guard(3, "Rajon", "Rondo", 190, 76, 2004, "center", 909,
1203)
self.player_manager.add_player(self.player1)
self.player_manager.add_player(self.player2)
self.player_manager.add_player(self.player3)
self.assertIsNotNone(self.player_manager)
def tearDown(self):
""" Destroys data and sets up logPoint """
os.remove("test_players.sqlite")
self.logPoint()
def logPoint(self):
currentTest = self.id().split('.')[-1]
callingFunction = inspect.stack()[1][3]
print('in %s - %s()' % (currentTest, callingFunction))
def test_constructor_valid_input(self):
""" Tests the constructor with valid inputs """
self.assertEqual(1, self.player1.get_player_id(),
"Player number should be number 1")
self.assertEqual(2, self.player2.get_player_id(),
"Player number should be number 2")
self.assertEqual(3, self.player3.get_player_id(),
"Player number should be number 3")
self.assertEqual("Los Angeles Lakers",
self.player_manager.get_team_name(),
"Team Name should be Los Angeles Lakers")
def test_constructor_invalid_input(self):
""" Tests the constructor with invalid inputs """
self.assertRaisesRegex(ValueError,
"Player number should be an integer value",
Forward, "STRING", "Lebron", "James", 201, 81,
2003, 1028, 690)
self.assertRaisesRegex(ValueError,
"Number of shots took should be positive",
Forward, 12, "Lebron", "James", 201, 81, 2003,
-1028, 690)
self.assertRaisesRegex(ValueError,
"Number of shots made should be positive",
Forward, 12, "Lebron", "James", 201, 81, 2003,
1028, -690)
self.assertRaisesRegex(ValueError,
"Player number should be an integer value",
Guard, "STRING", "Lebron", "James", 201, 81,
2003, 1028, 690)
self.assertRaisesRegex(ValueError,
"Number of steals made should be positive",
Guard, 12, "Lebron", "James", 201, 81, 2003,
-1028, 690)
self.assertRaisesRegex(ValueError,
"Number of assists should be positive", Guard,
12, "Lebron", "James", 201, 81, 2003, 1028,
-690)
self.assertRaisesRegex(ValueError,
"Player number should be an integer value",
Center, "STRING", "Lebron", "James", 201, 81,
2003, 1028, 690)
self.assertRaisesRegex(ValueError,
"Number of rebounds should be positive", Center,
12, "Lebron", "James", 201, 81, 2003, -1028,
690)
self.assertRaisesRegex(ValueError, "Play-type should be a string",
Center, 12, "Lebron", "James", 201, 81, 2003,
1028, -690)
def test_get_player(self):
""" Tests the get_player method """
player23 = self.player_manager.get_player(3)
self.assertEqual(3, player23.get_player_id(),
"Player should be number 23")
def test_get_all(self):
""" Tests the get_all method """
self.assertEqual(3, len(self.player_manager.get_all()),
"Team should have 3 players")
def test_get_player_stats(self):
""" Tests the get_player_stats method """
stats = self.player_manager.get_players_stats()
self.assertEqual(3, stats.get_total_num_players(),
"Team should have 3 players")
self.assertEqual(1, stats.get_num_guards(), "Team should have 1 guard")
self.assertEqual(1, stats.get_num_forwards(),
"Team should have 1 forward")
self.assertEqual(1, stats.get_num_centers(),
"Team should have 1 center")
def test_add_player_valid_input(self):
""" Tests the add_player method with valid inputs """
self.assertEqual(
3,
self.player_manager.get_players_stats().get_total_num_players(),
"Team should have 3 players")
player4 = Guard(7, "June", "Ka", 190, 76, 2004, 909, 1203)
self.player_manager.add_player(player4)
self.assertEqual(
4,
self.player_manager.get_players_stats().get_total_num_players(),
"Team should have 4 players")
def test_add_player_invalid_input(self):
""" Tests the add_player method with invalid inputs """
self.assertRaisesRegex(ValueError,
"Player number should be an integer value",
Forward, "STRING", "Lebron", "James", 201, 81,
2003, "forward", 1028, 690)
self.assertRaisesRegex(ValueError,
"Number of shots took should be positive",
Forward, 12, "Lebron", "James", 201, 81, 2003,
"forward", -1028, 690)
self.assertRaisesRegex(ValueError,
"Number of shots made should be positive",
Forward, 12, "Lebron", "James", 201, 81, 2003,
"forward", 1028, -690)
self.assertRaisesRegex(ValueError,
"Player number should be an integer value",
Guard, "STRING", "Lebron", "James", 201, 81,
2003, "forward", 1028, 690)
self.assertRaisesRegex(ValueError,
"Number of steals made should be positive",
Guard, 12, "Lebron", "James", 201, 81, 2003,
"forward", -1028, 690)
self.assertRaisesRegex(ValueError,
"Number of assists should be positive", Guard,
12, "Lebron", "James", 201, 81, 2003, "forward",
1028, -690)
self.assertRaisesRegex(ValueError,
"Player number should be an integer value",
Center, "STRING", "Lebron", "James", 201, 81,
2003, "forward", 1028, 690)
self.assertRaisesRegex(ValueError,
"Number of rebounds should be positive", Center,
12, "Lebron", "James", 201, 81, 2003, "forward",
-1028, 690)
self.assertRaisesRegex(ValueError, "Play-type should be a string",
Center, 12, "Lebron", "James", 201, 81, 2003,
"forward", 1028, -690)
def test_delete_player_valid_input(self):
""" Tests the delete_player with valid inputs """
self.assertEqual(
3,
self.player_manager.get_player_stats().get_total_num_players(),
"Team should have 3 players")
player4 = Guard(4, "June", "Ka", 190, 76, 2004, 909, 1203)
self.player_manager.add_player(player4)
self.assertEqual(
4,
self.player_manager.get_player_stats().get_total_num_players(),
"Team should have 4 players")
self.player_manager.delete_player(4)
self.assertEqual(
3,
self.player_manager.get_player_stats().get_total_num_players(),
"Team should have 3 players")
def test_delete_player_invalid_input(self):
""" Tests the delete_player with invalid inputs """
self.assertEqual("Player ID should be an integer value",
self.player_manager.delete_player("STRING"),
"Input should be an integer value")
def test_get_team_name(self):
""" Tests the get_team_name method """
self.assertEqual("Los Angeles Lakers",
self.player_manager.get_team_name(),
"Team name should be Los Angeles Lakers")
def test_update_valid_input(self):
""" Tests the update method with valid inputs """
string = "3: Rajon Rondo is 190.00 cm tall, weighs 76.00 kg, drafted on 2004, has 909 steals and 1203 assists"
self.assertEqual(string, self.player3.get_description(),
"These two strings should be equal")
self.player3 = Guard(3, "June", "Ka", 180, 81, 2019, 0, 0)
self.player_manager.update_player(self.player3)
string2 = "3: June Ka is 180.00 cm tall, weighs 81.00 kg, drafted on 2019, has 0 steals and 0 assists"
self.assertEqual(string2, self.player3.get_description(),
"These two strings should be equal")
def test_get_all_by_type(self):
""" Tests get_all_by_type method """
string = self.player_manager.get_all_by_type()
self.assertEqual(string, self.player_manager.get_all_by_type(),
"These two strings should be equal")
def test_update_invalid_input(self):
""" Tests update method with invalid inputs """
self.assertRaisesRegex(ValueError,
"Player number should be an integer value",
Forward, "STRING", "Lebron", "James", 201, 81,
2003, 1028, 690)
self.assertRaisesRegex(ValueError,
"Number of shots took should be positive",
Forward, 12, "Lebron", "James", 201, 81, 2003,
-1028, 690)
self.assertRaisesRegex(ValueError,
"Number of shots made should be positive",
Forward, 12, "Lebron", "James", 201, 81, 2003,
1028, -690)
self.assertRaisesRegex(ValueError,
"Player number should be an integer value",
Guard, "STRING", "Lebron", "James", 201, 81,
2003, 1028, 690)
self.assertRaisesRegex(ValueError,
"Number of steals made should be positive",
Guard, 12, "Lebron", "James", 201, 81, 2003,
-1028, 690)
self.assertRaisesRegex(ValueError,
"Number of assists should be positive", Guard,
12, "Lebron", "James", 201, 81, 2003, 1028,
-690)
self.assertRaisesRegex(ValueError,
"Player number should be an integer value",
Center, "STRING", "Lebron", "James", 201, 81,
2003, 1028, 690)
self.assertRaisesRegex(ValueError,
"Number of rebounds should be positive", Center,
12, "Lebron", "James", 201, 81, 2003, -1028,
690)
self.assertRaisesRegex(ValueError, "Play-type should be a string",
Center, 12, "Lebron", "James", 201, 81, 2003,
1028, -690)
from forward import HMM, Forward
from backward import Backward
from math import log
from logsum import log_sum
f = Forward("dev.txt", "hmm-trans.txt", "hmm-emit.txt", "hmm-prior.txt")
b = Backward("dev.txt", "hmm-trans.txt", "hmm-emit.txt", "hmm-prior.txt")
dev_file = "dev.txt"
with open(dev_file, 'r') as file:
for line in file:
words = line.rstrip('\n\r').split(" ")
dev_a = list()
dev_b = list()
# calculate conditional probability
for i in range(len(words)):
t = i + 1
if t == 1:
f.initialize_alpha(words[0], dev_a)
else:
f.calculate_alpha(words[i], t, dev_a)
T = len(words)
t = T
for i in range(len(words)):
if t == T:
beta_T = [log(1) for x in range(b.hmm.N)]
dev_b.append(beta_T)
else:
b.calculate_beta(dev_b, words[t], t - 1, T - 1)
t -= 1
from create_dataset import Create_Xor
from activation import Activation
from forward import Forward
from backward import Backward
myDataset = Create_Xor()
#myDataset.print_shape()
#myDataset.print_XY()
#recuperation X,Y
X = myDataset.get_X()
Y = myDataset.get_Y()
#creation d'un objet 'annForward'en definissant mes layers
annForward = Forward([2,3,1])
#start loop iterations
learning_rate = 0.0075
num_iterations = 2
np.random.seed(1)
#track the cost
costs = []
print_cost = True
#boucle de 0 à nombre d'iterations:
for i in range (0,num_iterations):
#forward propagation l layers
annForward.forward_layers(X)
I = cv2.imread(img, 1)
_, fname = os.path.split(img)
gt = int(fname.split('_')[4])
score = self.predictor(I)
if (score >= 0.5 and gt == 1) or (gt < 0.5 and gt == 0):
accu += 1
with open(opj(self.perf_dir, 'result.csv'), 'w') as f:
f.write('{}\n'.format(accu/len(images)))
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('src')
parser.add_argument("perf_dir")
parser.add_argument("--model_path")
parser.add_argument("--model_cfg")
args = parser.parse_args()
predictor = Forward(args.model_path, args.model_cfg)
perf = Perf(predictor, args.src, args.perf_dir, err_save=False)
perf.proc()
class TestCenter(TestCase):
""" Unit tests for the Center class """
def setUp(self):
""" Sets up data and calls logPoint """
self.logPoint()
self.player_manager = PlayerManager("Los Angeles Lakers", "file.txt")
self.player1 = Forward(1, "Lebron", "James", 201, 81, 2003, "forward",
1028, 690)
self.player_manager.add_player(self.player1)
self.assertIsNotNone(self.player_manager)
def tearDown(self):
""" Destroys data and sets up logPoint """
self.logPoint()
def logPoint(self):
currentTest = self.id().split('.')[-1]
callingFunction = inspect.stack()[1][3]
print('in %s - %s()' % (currentTest, callingFunction))
def test_constructor_valid_input(self):
""" Tests the constructor with valid inputs """
self.assertEqual(1, self.player1.get_player_id(),
"Player number should be number 1")
self.assertEqual("Los Angeles Lakers",
self.player_manager.get_team_name(),
"Team Name should be Los Angeles Lakers")
def test_constructor_invalid_input(self):
""" Tests the constructor with invalid inputs """
self.assertRaisesRegex(ValueError,
"Player number should be an integer value",
Forward, "STRING", "Lebron", "James", 201, 81,
2003, 1028, 690)
self.assertRaisesRegex(ValueError,
"Number of shots took should be positive",
Forward, 12, "Lebron", "James", 201, 81, 2003,
-1028, 690)
self.assertRaisesRegex(ValueError,
"Number of shots made should be positive",
Forward, 12, "Lebron", "James", 201, 81, 2003,
1028, -690)
def test_get_description(self):
""" Tests the get_description method """
string = "1: Lebron James is 201.00 cm tall, weighs 81.00 kg, drafted on 2003, took 1028 shots and made 690"
self.assertEqual(string, self.player1.get_description(),
"These two strings should be equal")
def test_get_num_shots_took(self):
""" Tests the get_num_shots_took method """
self.assertEqual(1028, self.player1.get_num_shots_took(),
"These two values should be equal")
def test_get_num_shots_made(self):
""" Tests thge get_num_shots_made method """
self.assertEqual(690, self.player1.get_num_shots_made(),
"These two values should be equal")
def test_get_type(self):
""" Tests the get_type method """
self.assertEqual("FORWARD", self.player1.get_type(),
"These two strings should be equal")
import telebot
import logging
from config import TOKEN, CHAT, admins_id
from log import log
from variables import *
from forward import Forward
hidden_forward = Forward(False)
for_ban = []
def initial_bot(use_logging=True, level_name='DEBUG'):
bot = telebot.TeleBot(TOKEN)
logger = log('bot', 'bot.log', 'INFO')
working = {'disable': False}
@bot.message_handler(commands=['start'])
def start_handler(message: telebot.types.Message):
bot.send_message(message.from_user.id, start_mess)
logger.info(f"It's start handler. Message from {message.from_user.id}")
@bot.message_handler(commands=['help'])
def help_handler(message: telebot.types.Message):
bot.send_message(message.from_user.id, help_mess)
logger.info(f"It's help handler. Message from {message.from_user.id}")
@bot.message_handler(commands=['disable'])
def toggle_handler(message: telebot.types.Message):
logger.info(
f"It's disable handler. Message from {message.from_user.id}. Hidden_forward is {hidden_forward}"
)
os.makedirs(perf_dir, exist_ok=True)
self.predictor, self.imgsrc, self.perf_dir = predictor, imgsrc, perf_dir
self.err_save = err_save
def proc(self):
accu = 0
images = get_spec_files(self.imgsrc, ext=IMG_EXT, oswalk=True)
for i, img in enumerate(images):
print('{}/{}'.format(i, len(images)))
I = cv2.imread(img, 1)
_, fname = os.path.split(img)
gt = int(fname.split('_')[4])
score = self.predictor(I)
if (score >= 0.5 and gt == 1) or (gt < 0.5 and gt == 0):
accu += 1
with open(opj(self.perf_dir, 'result.csv'), 'w') as f:
f.write('{}\n'.format(accu / len(images)))
if __name__ == '__main__':
import argparse
parser = argparse.ArgumentParser()
parser.add_argument('src')
parser.add_argument("perf_dir")
args = parser.parse_args()
predictor = Forward()
perf = Perf(predictor, args.src, args.perf_dir, err_save=False)
perf.proc()
class Viterbi(object):
def __init__(self, K, table_dices, player_dice):
"""Initialize the viterbi algorithm. K is the number of tables,
table_dices is a list of length K composed by couple (d,d'):
d is the dice of the table not primed, d' is the dice of the primed
table, player_dice is the dice used by the player"""
self.K = K
self.table_dices = table_dices
if (len(table_dices) != K):
raise ValueError('A list of K couple of dices should be provided '
'for the parameter table_dices')
self.player_dice = player_dice
#initialize forward algorithm for later use
self.forward_alg = Forward(K, table_dices, player_dice)
def run(self, observations):
"""Takes a list of observations S1:K and returns the path through
the states x1:K which is most likely:
argmax{x1:K} (p(x1:K | S1:K))"""
#memoization variable to store dp results.
#Maps (table,result) to (probability, previous_result)
self.memoization = {}
#computes range of possible values for last table given last observed
observed = observations[-1]
lower_bound = max(observed-6,1)
upper_bound = min(observed-1,6)
max_found = 0
max_result = 0
for result in range(lower_bound,upper_bound+1):
viterbi_var = self.viterbi_variable(self.K, result, observations)
if viterbi_var > max_found:
max_found = viterbi_var
max_result = result
if max_found < EPS:
print 'The observations given cannot be produced with given dices'
return []
return self.reconstruct_path(self.K, max_result)
def viterbi_variable(self, table, result, observations):
"""Computes the probability of the dice in table=table k of being equal
to result=result c, when the most probable path fron 1 to k-1 is taken.
The probability returned is actually the joint with the probability
of the path x1:k-1 taken and of the observations up to k.
Table is the index table, from 1 to K. Result is the result of the
table's dice, from 1 to 6. Observations are the list of the observed
sum from table 1 to k.
max{x1:k-1} (p(x1:k-1, Xk=c, S1:k) )
"""
assert table>0 and table<=self.K
assert result>=1 and result<=6
assert len(observations)==table
#sum observed at table k
observed = observations[table-1]
#base case
if (table == 1):
#probability of table 1 giving result
result_probability = self.transition_probability(1, result, [])
#probability of observing the sum given the result
emission_probability = self.emission_probability(1,
result,
observed)
return result_probability * emission_probability
if ((table,result) not in self.memoization):
#computes range of possible values for previous result based
#on previous observation
previous_observation = observations[table-2]
lower_bound = max(previous_observation-6,1)
upper_bound = min(previous_observation-1,6)
max_prob = 0
max_previous_result = 0
for previous_result in range(lower_bound,upper_bound+1):
viterbi_var = self.viterbi_variable(table-1,
previous_result,
observations[:-1])
if (viterbi_var < EPS):
#this previous result is impossible, try the others
continue
previous_results = self.reconstruct_path(table-1,
previous_result)
#probability of table k giving result
result_probability = self.transition_probability(
table,
result,
previous_results)
#probability of observing the sum given the result
emission_probability = self.emission_probability(table,
result,
observed)
prob = viterbi_var * result_probability * emission_probability
if prob > max_prob:
max_prob = prob
max_previous_result = previous_result
self.memoization[(table,result)] = (max_prob, max_previous_result)
return self.memoization[(table,result)][0]
def reconstruct_path(self, table, result):
"""Returns the most probable path across the states found by the viterbi
algorithm from table=table giving result=result
"""
if table==1:
return [result,]
previous_result = self.memoization[(table, result)][1]
previous_results = self.reconstruct_path(table-1, previous_result)
previous_results.append(result)
return previous_results
def emission_probability(self, table, result, observed):
"""Returns the probability of table=table k, with dice result=result c,
emitting an observed sum=observed v
P(Sk=v | Xk=c)
"""
assert table>0 and table<=self.K
assert result>=1 and result<=6
assert observed>=2 and observed<=12
return self.player_dice[observed-result]
def transition_probability(self, table, result, previous_results):
"""Computes the probability of the dice at table=table k being equal
to result=result c given the results of the table's dices from 1 to
k-1.
P(Xk=c | x1:k-1)
"""
assert table>0 and table<=self.K
assert result>=1 and result<=6
assert len(previous_results) == table-1
#probability of table k being primed
primed = self.probability_state(table, 1, previous_results)
#probability of emitting result if the table is primed
emission_primed = self.table_dices[table-1][1][result]
#probability of table k being not primed
not_primed = self.probability_state(table, 0, previous_results)
#probability of emitting result if the table is not primed
emission_not_primed = self.table_dices[table-1][0][result]
if primed + not_primed < EPS:
#Table k dice cannot be equal result
return 0.0
assert abs((primed + not_primed) - 1.0) < 10 ** -10
return not_primed * emission_not_primed + primed * emission_primed
def probability_state(self, table, state, dice_results):
"""Computes the probability of being in state=state h at table=table k,
given the dice results for tables from 1 to k-1
P(Zk=h | x1:k-1)"""
assert table>0 and table<=self.K
assert state==0 or state==1
assert len(dice_results) == table-1
#probability of previous table being equal state h
previous_state = self.forward_alg.run(table-1,
state,
dice_results)
#probability of previous table being not equal state h
previous_not_state = self.forward_alg.run(table-1,
(state+1)%2,
dice_results)
if previous_state + previous_not_state < EPS:
#the dice_results sequence is not possible
return 0.0
assert abs((previous_state+previous_not_state) - 1.0) < 10 ** -10
return 1/4.0 * previous_state + 3/4.0 * previous_not_state
