diff --git a/data analysis/analysis/__pycache__/analysis.cpython-36.pyc b/data analysis/analysis/__pycache__/analysis.cpython-36.pyc index cd6c08c5..ff380898 100644 Binary files a/data analysis/analysis/__pycache__/analysis.cpython-36.pyc and b/data analysis/analysis/__pycache__/analysis.cpython-36.pyc differ diff --git a/data analysis/analysis/__pycache__/analysis.cpython-37.pyc b/data analysis/analysis/__pycache__/analysis.cpython-37.pyc index 32ddefec..88adc4a7 100644 Binary files a/data analysis/analysis/__pycache__/analysis.cpython-37.pyc and b/data analysis/analysis/__pycache__/analysis.cpython-37.pyc differ diff --git a/data analysis/analysis/__pycache__/regression.cpython-37.pyc b/data analysis/analysis/__pycache__/regression.cpython-37.pyc index 02b8a04b..4f4afce7 100644 Binary files a/data analysis/analysis/__pycache__/regression.cpython-37.pyc and b/data analysis/analysis/__pycache__/regression.cpython-37.pyc differ diff --git a/data analysis/analysis/__pycache__/trueskill.cpython-37.pyc b/data analysis/analysis/__pycache__/trueskill.cpython-37.pyc new file mode 100644 index 00000000..47766ae6 Binary files /dev/null and b/data analysis/analysis/__pycache__/trueskill.cpython-37.pyc differ diff --git a/data analysis/analysis/analysis.py b/data analysis/analysis/analysis.py index 4ba96a6a..efe26686 100644 --- a/data analysis/analysis/analysis.py +++ b/data analysis/analysis/analysis.py @@ -7,10 +7,12 @@ # current benchmark of optimization: 1.33 times faster # setup: -__version__ = "1.1.3.002" +__version__ = "1.1.4.000" # changelog should be viewed using print(analysis.__changelog__) __changelog__ = """changelog: +1.1.4.000: + - added trueskill() 1.1.3.002: - renamed regression class to Regression, regression_engine() to regression gliko2_engine class to Gliko2 1.1.3.001: @@ -187,6 +189,10 @@ try: from analysis import regression except: pass +try: + from analysis import trueskill +except: + import trueskill from sklearn import metrics from sklearn import preprocessing import torch @@ -326,6 +332,24 @@ def gliko2(starting_score, starting_rd, starting_vol, opposing_scores, opposing_ return (player.rating, player.rd, player.vol) +@jit(forceobj=True) +def trueskill(teams_data, observations):#teams_data is array of array of tuples ie. [[(mu, sigma), (mu, sigma), (mu, sigma)], [(mu, sigma), (mu, sigma), (mu, sigma)]] + + team_ratings = [] + + for team in teams_data: + team_temp = [] + for player in team: + if player != None: + player = trueskill.Rating(player[0], player[1]) + team_temp.append(player) + else: + player = trueskill.Rating() + team_temp.append(player) + team_ratings.append(team_temp) + + return trueskill.rate(teams_data, observations) + @jit(forceobj=True) def r_squared(predictions, targets): # assumes equal size inputs diff --git a/data analysis/analysis/trueskill/__init__.py b/data analysis/analysis/trueskill.py similarity index 51% rename from data analysis/analysis/trueskill/__init__.py rename to data analysis/analysis/trueskill.py index ac5facd6..116357df 100644 --- a/data analysis/analysis/trueskill/__init__.py +++ b/data analysis/analysis/trueskill.py @@ -1,14 +1,3 @@ -# -*- coding: utf-8 -*- -""" - trueskill - ~~~~~~~~~ - - The video game rating system. - - :copyright: (c) 2012-2016 by Heungsub Lee - :license: BSD, see LICENSE for more details. - -""" from __future__ import absolute_import from itertools import chain @@ -16,28 +5,488 @@ import math from six import iteritems from six.moves import map, range, zip +from six import iterkeys -from .__about__ import __version__ # noqa -from .backends import choose_backend -from .factorgraph import (LikelihoodFactor, PriorFactor, SumFactor, - TruncateFactor, Variable) -from .mathematics import Gaussian, Matrix +import copy +try: + from numbers import Number +except ImportError: + Number = (int, long, float, complex) + +inf = float('inf') + +class Gaussian(object): + #: Precision, the inverse of the variance. + pi = 0 + #: Precision adjusted mean, the precision multiplied by the mean. + tau = 0 + + def __init__(self, mu=None, sigma=None, pi=0, tau=0): + if mu is not None: + if sigma is None: + raise TypeError('sigma argument is needed') + elif sigma == 0: + raise ValueError('sigma**2 should be greater than 0') + pi = sigma ** -2 + tau = pi * mu + self.pi = pi + self.tau = tau + + @property + def mu(self): + return self.pi and self.tau / self.pi + + @property + def sigma(self): + return math.sqrt(1 / self.pi) if self.pi else inf + + def __mul__(self, other): + pi, tau = self.pi + other.pi, self.tau + other.tau + return Gaussian(pi=pi, tau=tau) + + def __truediv__(self, other): + pi, tau = self.pi - other.pi, self.tau - other.tau + return Gaussian(pi=pi, tau=tau) + + __div__ = __truediv__ # for Python 2 + + def __eq__(self, other): + return self.pi == other.pi and self.tau == other.tau + + def __lt__(self, other): + return self.mu < other.mu + + def __le__(self, other): + return self.mu <= other.mu + + def __gt__(self, other): + return self.mu > other.mu + + def __ge__(self, other): + return self.mu >= other.mu + + def __repr__(self): + return 'N(mu={:.3f}, sigma={:.3f})'.format(self.mu, self.sigma) + + def _repr_latex_(self): + latex = r'\mathcal{{ N }}( {:.3f}, {:.3f}^2 )'.format(self.mu, self.sigma) + return '$%s$' % latex + +class Matrix(list): + def __init__(self, src, height=None, width=None): + if callable(src): + f, src = src, {} + size = [height, width] + if not height: + def set_height(height): + size[0] = height + size[0] = set_height + if not width: + def set_width(width): + size[1] = width + size[1] = set_width + try: + for (r, c), val in f(*size): + src[r, c] = val + except TypeError: + raise TypeError('A callable src must return an interable ' + 'which generates a tuple containing ' + 'coordinate and value') + height, width = tuple(size) + if height is None or width is None: + raise TypeError('A callable src must call set_height and ' + 'set_width if the size is non-deterministic') + if isinstance(src, list): + is_number = lambda x: isinstance(x, Number) + unique_col_sizes = set(map(len, src)) + everything_are_number = filter(is_number, sum(src, [])) + if len(unique_col_sizes) != 1 or not everything_are_number: + raise ValueError('src must be a rectangular array of numbers') + two_dimensional_array = src + elif isinstance(src, dict): + if not height or not width: + w = h = 0 + for r, c in iterkeys(src): + if not height: + h = max(h, r + 1) + if not width: + w = max(w, c + 1) + if not height: + height = h + if not width: + width = w + two_dimensional_array = [] + for r in range(height): + row = [] + two_dimensional_array.append(row) + for c in range(width): + row.append(src.get((r, c), 0)) + else: + raise TypeError('src must be a list or dict or callable') + super(Matrix, self).__init__(two_dimensional_array) + + @property + def height(self): + return len(self) + + @property + def width(self): + return len(self[0]) + + def transpose(self): + height, width = self.height, self.width + src = {} + for c in range(width): + for r in range(height): + src[c, r] = self[r][c] + return type(self)(src, height=width, width=height) + + def minor(self, row_n, col_n): + height, width = self.height, self.width + if not (0 <= row_n < height): + raise ValueError('row_n should be between 0 and %d' % height) + elif not (0 <= col_n < width): + raise ValueError('col_n should be between 0 and %d' % width) + two_dimensional_array = [] + for r in range(height): + if r == row_n: + continue + row = [] + two_dimensional_array.append(row) + for c in range(width): + if c == col_n: + continue + row.append(self[r][c]) + return type(self)(two_dimensional_array) + + def determinant(self): + height, width = self.height, self.width + if height != width: + raise ValueError('Only square matrix can calculate a determinant') + tmp, rv = copy.deepcopy(self), 1. + for c in range(width - 1, 0, -1): + pivot, r = max((abs(tmp[r][c]), r) for r in range(c + 1)) + pivot = tmp[r][c] + if not pivot: + return 0. + tmp[r], tmp[c] = tmp[c], tmp[r] + if r != c: + rv = -rv + rv *= pivot + fact = -1. / pivot + for r in range(c): + f = fact * tmp[r][c] + for x in range(c): + tmp[r][x] += f * tmp[c][x] + return rv * tmp[0][0] + + def adjugate(self): + height, width = self.height, self.width + if height != width: + raise ValueError('Only square matrix can be adjugated') + if height == 2: + a, b = self[0][0], self[0][1] + c, d = self[1][0], self[1][1] + return type(self)([[d, -b], [-c, a]]) + src = {} + for r in range(height): + for c in range(width): + sign = -1 if (r + c) % 2 else 1 + src[r, c] = self.minor(r, c).determinant() * sign + return type(self)(src, height, width) + + def inverse(self): + if self.height == self.width == 1: + return type(self)([[1. / self[0][0]]]) + return (1. / self.determinant()) * self.adjugate() + + def __add__(self, other): + height, width = self.height, self.width + if (height, width) != (other.height, other.width): + raise ValueError('Must be same size') + src = {} + for r in range(height): + for c in range(width): + src[r, c] = self[r][c] + other[r][c] + return type(self)(src, height, width) + + def __mul__(self, other): + if self.width != other.height: + raise ValueError('Bad size') + height, width = self.height, other.width + src = {} + for r in range(height): + for c in range(width): + src[r, c] = sum(self[r][x] * other[x][c] + for x in range(self.width)) + return type(self)(src, height, width) + + def __rmul__(self, other): + if not isinstance(other, Number): + raise TypeError('The operand should be a number') + height, width = self.height, self.width + src = {} + for r in range(height): + for c in range(width): + src[r, c] = other * self[r][c] + return type(self)(src, height, width) + + def __repr__(self): + return '{}({})'.format(type(self).__name__, super(Matrix, self).__repr__()) + + def _repr_latex_(self): + rows = [' && '.join(['%.3f' % cell for cell in row]) for row in self] + latex = r'\begin{matrix} %s \end{matrix}' % r'\\'.join(rows) + return '$%s$' % latex + +def _gen_erfcinv(erfc, math=math): + def erfcinv(y): + """The inverse function of erfc.""" + if y >= 2: + return -100. + elif y <= 0: + return 100. + zero_point = y < 1 + if not zero_point: + y = 2 - y + t = math.sqrt(-2 * math.log(y / 2.)) + x = -0.70711 * \ + ((2.30753 + t * 0.27061) / (1. + t * (0.99229 + t * 0.04481)) - t) + for i in range(2): + err = erfc(x) - y + x += err / (1.12837916709551257 * math.exp(-(x ** 2)) - x * err) + return x if zero_point else -x + return erfcinv + +def _gen_ppf(erfc, math=math): + erfcinv = _gen_erfcinv(erfc, math) + def ppf(x, mu=0, sigma=1): + return mu - sigma * math.sqrt(2) * erfcinv(2 * x) + return ppf + +def erfc(x): + z = abs(x) + t = 1. / (1. + z / 2.) + r = t * math.exp(-z * z - 1.26551223 + t * (1.00002368 + t * ( + 0.37409196 + t * (0.09678418 + t * (-0.18628806 + t * ( + 0.27886807 + t * (-1.13520398 + t * (1.48851587 + t * ( + -0.82215223 + t * 0.17087277 + ))) + ))) + ))) + return 2. - r if x < 0 else r + +def cdf(x, mu=0, sigma=1): + return 0.5 * erfc(-(x - mu) / (sigma * math.sqrt(2))) -__all__ = [ - # TrueSkill objects - 'TrueSkill', 'Rating', - # functions for the global environment - 'rate', 'quality', 'rate_1vs1', 'quality_1vs1', 'expose', 'setup', - 'global_env', - # default values - 'MU', 'SIGMA', 'BETA', 'TAU', 'DRAW_PROBABILITY', - # draw probability helpers - 'calc_draw_probability', 'calc_draw_margin', - # deprecated features - 'transform_ratings', 'match_quality', 'dynamic_draw_probability', -] +def pdf(x, mu=0, sigma=1): + return (1 / math.sqrt(2 * math.pi) * abs(sigma) * + math.exp(-(((x - mu) / abs(sigma)) ** 2 / 2))) +ppf = _gen_ppf(erfc) + +def choose_backend(backend): + if backend is None: # fallback + return cdf, pdf, ppf + elif backend == 'mpmath': + try: + import mpmath + except ImportError: + raise ImportError('Install "mpmath" to use this backend') + return mpmath.ncdf, mpmath.npdf, _gen_ppf(mpmath.erfc, math=mpmath) + elif backend == 'scipy': + try: + from scipy.stats import norm + except ImportError: + raise ImportError('Install "scipy" to use this backend') + return norm.cdf, norm.pdf, norm.ppf + raise ValueError('%r backend is not defined' % backend) + +def available_backends(): + backends = [None] + for backend in ['mpmath', 'scipy']: + try: + __import__(backend) + except ImportError: + continue + backends.append(backend) + return backends + +class Node(object): + + pass + +class Variable(Node, Gaussian): + + def __init__(self): + self.messages = {} + super(Variable, self).__init__() + + def set(self, val): + delta = self.delta(val) + self.pi, self.tau = val.pi, val.tau + return delta + + def delta(self, other): + pi_delta = abs(self.pi - other.pi) + if pi_delta == inf: + return 0. + return max(abs(self.tau - other.tau), math.sqrt(pi_delta)) + + def update_message(self, factor, pi=0, tau=0, message=None): + message = message or Gaussian(pi=pi, tau=tau) + old_message, self[factor] = self[factor], message + return self.set(self / old_message * message) + + def update_value(self, factor, pi=0, tau=0, value=None): + value = value or Gaussian(pi=pi, tau=tau) + old_message = self[factor] + self[factor] = value * old_message / self + return self.set(value) + + def __getitem__(self, factor): + return self.messages[factor] + + def __setitem__(self, factor, message): + self.messages[factor] = message + + def __repr__(self): + args = (type(self).__name__, super(Variable, self).__repr__(), + len(self.messages), '' if len(self.messages) == 1 else 's') + return '<%s %s with %d connection%s>' % args + + +class Factor(Node): + + def __init__(self, variables): + self.vars = variables + for var in variables: + var[self] = Gaussian() + + def down(self): + return 0 + + def up(self): + return 0 + + @property + def var(self): + assert len(self.vars) == 1 + return self.vars[0] + + def __repr__(self): + args = (type(self).__name__, len(self.vars), + '' if len(self.vars) == 1 else 's') + return '<%s with %d connection%s>' % args + + +class PriorFactor(Factor): + + def __init__(self, var, val, dynamic=0): + super(PriorFactor, self).__init__([var]) + self.val = val + self.dynamic = dynamic + + def down(self): + sigma = math.sqrt(self.val.sigma ** 2 + self.dynamic ** 2) + value = Gaussian(self.val.mu, sigma) + return self.var.update_value(self, value=value) + + +class LikelihoodFactor(Factor): + + def __init__(self, mean_var, value_var, variance): + super(LikelihoodFactor, self).__init__([mean_var, value_var]) + self.mean = mean_var + self.value = value_var + self.variance = variance + + def calc_a(self, var): + return 1. / (1. + self.variance * var.pi) + + def down(self): + # update value. + msg = self.mean / self.mean[self] + a = self.calc_a(msg) + return self.value.update_message(self, a * msg.pi, a * msg.tau) + + def up(self): + # update mean. + msg = self.value / self.value[self] + a = self.calc_a(msg) + return self.mean.update_message(self, a * msg.pi, a * msg.tau) + + +class SumFactor(Factor): + + def __init__(self, sum_var, term_vars, coeffs): + super(SumFactor, self).__init__([sum_var] + term_vars) + self.sum = sum_var + self.terms = term_vars + self.coeffs = coeffs + + def down(self): + vals = self.terms + msgs = [var[self] for var in vals] + return self.update(self.sum, vals, msgs, self.coeffs) + + def up(self, index=0): + coeff = self.coeffs[index] + coeffs = [] + for x, c in enumerate(self.coeffs): + try: + if x == index: + coeffs.append(1. / coeff) + else: + coeffs.append(-c / coeff) + except ZeroDivisionError: + coeffs.append(0.) + vals = self.terms[:] + vals[index] = self.sum + msgs = [var[self] for var in vals] + return self.update(self.terms[index], vals, msgs, coeffs) + + def update(self, var, vals, msgs, coeffs): + pi_inv = 0 + mu = 0 + for val, msg, coeff in zip(vals, msgs, coeffs): + div = val / msg + mu += coeff * div.mu + if pi_inv == inf: + continue + try: + # numpy.float64 handles floating-point error by different way. + # For example, it can just warn RuntimeWarning on n/0 problem + # instead of throwing ZeroDivisionError. So div.pi, the + # denominator has to be a built-in float. + pi_inv += coeff ** 2 / float(div.pi) + except ZeroDivisionError: + pi_inv = inf + pi = 1. / pi_inv + tau = pi * mu + return var.update_message(self, pi, tau) + + +class TruncateFactor(Factor): + + def __init__(self, var, v_func, w_func, draw_margin): + super(TruncateFactor, self).__init__([var]) + self.v_func = v_func + self.w_func = w_func + self.draw_margin = draw_margin + + def up(self): + val = self.var + msg = self.var[self] + div = val / msg + sqrt_pi = math.sqrt(div.pi) + args = (div.tau / sqrt_pi, self.draw_margin * sqrt_pi) + v = self.v_func(*args) + w = self.w_func(*args) + denom = (1. - w) + pi, tau = div.pi / denom, (div.tau + sqrt_pi * v) / denom + return val.update_value(self, pi, tau) #: Default initial mean of ratings. MU = 25. @@ -54,35 +503,18 @@ DELTA = 0.0001 def calc_draw_probability(draw_margin, size, env=None): - """Calculates a draw-probability from the given ``draw_margin``. - - :param draw_margin: the draw-margin. - :param size: the number of players in two comparing teams. - :param env: the :class:`TrueSkill` object. Defaults to the global - environment. - - """ if env is None: env = global_env() return 2 * env.cdf(draw_margin / (math.sqrt(size) * env.beta)) - 1 def calc_draw_margin(draw_probability, size, env=None): - """Calculates a draw-margin from the given ``draw_probability``. - - :param draw_probability: the draw-probability. - :param size: the number of players in two comparing teams. - :param env: the :class:`TrueSkill` object. Defaults to the global - environment. - - """ if env is None: env = global_env() return env.ppf((draw_probability + 1) / 2.) * math.sqrt(size) * env.beta def _team_sizes(rating_groups): - """Makes a size map of each teams.""" team_sizes = [0] for group in rating_groups: team_sizes.append(len(group) + team_sizes[-1]) @@ -99,17 +531,6 @@ def _floating_point_error(env): class Rating(Gaussian): - """Represents a player's skill as Gaussian distrubution. - - The default mu and sigma value follows the global environment's settings. - If you don't want to use the global, use :meth:`TrueSkill.create_rating` to - create the rating object. - - :param mu: the mean. - :param sigma: the standard deviation. - - """ - def __init__(self, mu=None, sigma=None): if isinstance(mu, tuple): mu, sigma = mu @@ -140,40 +561,6 @@ class Rating(Gaussian): class TrueSkill(object): - """Implements a TrueSkill environment. An environment could have - customized constants. Every games have not same design and may need to - customize TrueSkill constants. - - For example, 60% of matches in your game have finished as draw then you - should set ``draw_probability`` to 0.60:: - - env = TrueSkill(draw_probability=0.60) - - For more details of the constants, see `The Math Behind TrueSkill`_ by - Jeff Moser. - - .. _The Math Behind TrueSkill:: http://bit.ly/trueskill-math - - :param mu: the initial mean of ratings. - :param sigma: the initial standard deviation of ratings. The recommended - value is a third of ``mu``. - :param beta: the distance which guarantees about 76% chance of winning. - The recommended value is a half of ``sigma``. - :param tau: the dynamic factor which restrains a fixation of rating. The - recommended value is ``sigma`` per cent. - :param draw_probability: the draw probability between two teams. It can be - a ``float`` or function which returns a ``float`` - by the given two rating (team performance) - arguments and the beta value. If it is a - ``float``, the game has fixed draw probability. - Otherwise, the draw probability will be decided - dynamically per each match. - :param backend: the name of a backend which implements cdf, pdf, ppf. See - :mod:`trueskill.backends` for more details. Defaults to - ``None``. - - """ - def __init__(self, mu=MU, sigma=SIGMA, beta=BETA, tau=TAU, draw_probability=DRAW_PROBABILITY, backend=None): self.mu = mu @@ -188,14 +575,6 @@ class TrueSkill(object): self.cdf, self.pdf, self.ppf = choose_backend(backend) def create_rating(self, mu=None, sigma=None): - """Initializes new :class:`Rating` object, but it fixes default mu and - sigma to the environment's. - - >>> env = TrueSkill(mu=0, sigma=1) - >>> env.create_rating() - trueskill.Rating(mu=0.000, sigma=1.000) - - """ if mu is None: mu = self.mu if sigma is None: @@ -203,15 +582,11 @@ class TrueSkill(object): return Rating(mu, sigma) def v_win(self, diff, draw_margin): - """The non-draw version of "V" function. "V" calculates a variation of - a mean. - """ x = diff - draw_margin denom = self.cdf(x) return (self.pdf(x) / denom) if denom else -x def v_draw(self, diff, draw_margin): - """The draw version of "V" function.""" abs_diff = abs(diff) a, b = draw_margin - abs_diff, -draw_margin - abs_diff denom = self.cdf(a) - self.cdf(b) @@ -219,9 +594,6 @@ class TrueSkill(object): return ((numer / denom) if denom else a) * (-1 if diff < 0 else +1) def w_win(self, diff, draw_margin): - """The non-draw version of "W" function. "W" calculates a variation of - a standard deviation. - """ x = diff - draw_margin v = self.v_win(diff, draw_margin) w = v * (v + x) @@ -230,7 +602,6 @@ class TrueSkill(object): raise _floating_point_error(self) def w_draw(self, diff, draw_margin): - """The draw version of "W" function.""" abs_diff = abs(diff) a, b = draw_margin - abs_diff, -draw_margin - abs_diff denom = self.cdf(a) - self.cdf(b) @@ -240,27 +611,6 @@ class TrueSkill(object): return (v ** 2) + (a * self.pdf(a) - b * self.pdf(b)) / denom def validate_rating_groups(self, rating_groups): - """Validates a ``rating_groups`` argument. It should contain more than - 2 groups and all groups must not be empty. - - >>> env = TrueSkill() - >>> env.validate_rating_groups([]) - Traceback (most recent call last): - ... - ValueError: need multiple rating groups - >>> env.validate_rating_groups([(Rating(),)]) - Traceback (most recent call last): - ... - ValueError: need multiple rating groups - >>> env.validate_rating_groups([(Rating(),), ()]) - Traceback (most recent call last): - ... - ValueError: each group must contain multiple ratings - >>> env.validate_rating_groups([(Rating(),), (Rating(),)]) - ... #doctest: +ELLIPSIS - [(truekill.Rating(...),), (trueskill.Rating(...),)] - - """ # check group sizes if len(rating_groups) < 2: raise ValueError('Need multiple rating groups') @@ -304,25 +654,6 @@ class TrueSkill(object): return weights def factor_graph_builders(self, rating_groups, ranks, weights): - """Makes nodes for the TrueSkill factor graph. - - Here's an example of a TrueSkill factor graph when 1 vs 2 vs 1 match:: - - rating_layer: O O O O (PriorFactor) - | | | | - | | | | - perf_layer: O O O O (LikelihoodFactor) - | \ / | - | | | - team_perf_layer: O O O (SumFactor) - \ / \ / - | | - team_diff_layer: O O (SumFactor) - | | - | | - trunc_layer: O O (TruncateFactor) - - """ flatten_ratings = sum(map(tuple, rating_groups), ()) flatten_weights = sum(map(tuple, weights), ()) size = len(flatten_ratings) @@ -379,9 +710,6 @@ class TrueSkill(object): def run_schedule(self, build_rating_layer, build_perf_layer, build_team_perf_layer, build_team_diff_layer, build_trunc_layer, min_delta=DELTA): - """Sends messages within every nodes of the factor graph until the - result is reliable. - """ if min_delta <= 0: raise ValueError('min_delta must be greater than 0') layers = [] @@ -431,49 +759,6 @@ class TrueSkill(object): return layers def rate(self, rating_groups, ranks=None, weights=None, min_delta=DELTA): - """Recalculates ratings by the ranking table:: - - env = TrueSkill() # uses default settings - # create ratings - r1 = env.create_rating(42.222) - r2 = env.create_rating(89.999) - # calculate new ratings - rating_groups = [(r1,), (r2,)] - rated_rating_groups = env.rate(rating_groups, ranks=[0, 1]) - # save new ratings - (r1,), (r2,) = rated_rating_groups - - ``rating_groups`` is a list of rating tuples or dictionaries that - represents each team of the match. You will get a result as same - structure as this argument. Rating dictionaries for this may be useful - to choose specific player's new rating:: - - # load players from the database - p1 = load_player_from_database('Arpad Emrick Elo') - p2 = load_player_from_database('Mark Glickman') - p3 = load_player_from_database('Heungsub Lee') - # calculate new ratings - rating_groups = [{p1: p1.rating, p2: p2.rating}, {p3: p3.rating}] - rated_rating_groups = env.rate(rating_groups, ranks=[0, 1]) - # save new ratings - for player in [p1, p2, p3]: - player.rating = rated_rating_groups[player.team][player] - - :param rating_groups: a list of tuples or dictionaries containing - :class:`Rating` objects. - :param ranks: a ranking table. By default, it is same as the order of - the ``rating_groups``. - :param weights: weights of each players for "partial play". - :param min_delta: each loop checks a delta of changes and the loop - will stop if the delta is less then this argument. - :returns: recalculated ratings same structure as ``rating_groups``. - :raises: :exc:`FloatingPointError` occurs when winners have too lower - rating than losers. higher floating-point precision couls - solve this error. set the backend to "mpmath". - - .. versionadded:: 0.2 - - """ rating_groups, keys = self.validate_rating_groups(rating_groups) weights = self.validate_weights(weights, rating_groups, keys) group_size = len(rating_groups) @@ -513,20 +798,6 @@ class TrueSkill(object): return [dict(zip(keys[x], g)) for x, g in unsorting] def quality(self, rating_groups, weights=None): - """Calculates the match quality of the given rating groups. A result - is the draw probability in the association:: - - env = TrueSkill() - if env.quality([team1, team2, team3]) < 0.50: - print('This match seems to be not so fair') - - :param rating_groups: a list of tuples or dictionaries containing - :class:`Rating` objects. - :param weights: weights of each players for "partial play". - - .. versionadded:: 0.2 - - """ rating_groups, keys = self.validate_rating_groups(rating_groups) weights = self.validate_weights(weights, rating_groups, keys) flatten_ratings = sum(map(tuple, rating_groups), ()) @@ -568,31 +839,10 @@ class TrueSkill(object): return math.exp(e_arg) * math.sqrt(s_arg) def expose(self, rating): - """Returns the value of the rating exposure. It starts from 0 and - converges to the mean. Use this as a sort key in a leaderboard:: - - leaderboard = sorted(ratings, key=env.expose, reverse=True) - - .. versionadded:: 0.4 - - """ k = self.mu / self.sigma return rating.mu - k * rating.sigma def make_as_global(self): - """Registers the environment as the global environment. - - >>> env = TrueSkill(mu=50) - >>> Rating() - trueskill.Rating(mu=25.000, sigma=8.333) - >>> env.make_as_global() #doctest: +ELLIPSIS - trueskill.TrueSkill(mu=50.000, ...) - >>> Rating() - trueskill.Rating(mu=50.000, sigma=8.333) - - But if you need just one environment, :func:`setup` is better to use. - - """ return setup(env=self) def __repr__(self): @@ -615,24 +865,6 @@ class TrueSkill(object): def rate_1vs1(rating1, rating2, drawn=False, min_delta=DELTA, env=None): - """A shortcut to rate just 2 players in a head-to-head match:: - - alice, bob = Rating(25), Rating(30) - alice, bob = rate_1vs1(alice, bob) - alice, bob = rate_1vs1(alice, bob, drawn=True) - - :param rating1: the winner's rating if they didn't draw. - :param rating2: the loser's rating if they didn't draw. - :param drawn: if the players drew, set this to ``True``. Defaults to - ``False``. - :param min_delta: will be passed to :meth:`rate`. - :param env: the :class:`TrueSkill` object. Defaults to the global - environment. - :returns: a tuple containing recalculated 2 ratings. - - .. versionadded:: 0.2 - - """ if env is None: env = global_env() ranks = [0, 0 if drawn else 1] @@ -641,27 +873,12 @@ def rate_1vs1(rating1, rating2, drawn=False, min_delta=DELTA, env=None): def quality_1vs1(rating1, rating2, env=None): - """A shortcut to calculate the match quality between just 2 players in - a head-to-head match:: - - if quality_1vs1(alice, bob) < 0.50: - print('This match seems to be not so fair') - - :param rating1: the rating. - :param rating2: the another rating. - :param env: the :class:`TrueSkill` object. Defaults to the global - environment. - - .. versionadded:: 0.2 - - """ if env is None: env = global_env() return env.quality([(rating1,), (rating2,)]) def global_env(): - """Gets the :class:`TrueSkill` object which is the global environment.""" try: global_env.__trueskill__ except AttributeError: @@ -672,19 +889,6 @@ def global_env(): def setup(mu=MU, sigma=SIGMA, beta=BETA, tau=TAU, draw_probability=DRAW_PROBABILITY, backend=None, env=None): - """Setups the global environment. - - :param env: the specific :class:`TrueSkill` object to be the global - environment. It is optional. - - >>> Rating() - trueskill.Rating(mu=25.000, sigma=8.333) - >>> setup(mu=50) #doctest: +ELLIPSIS - trueskill.TrueSkill(mu=50.000, ...) - >>> Rating() - trueskill.Rating(mu=50.000, sigma=8.333) - - """ if env is None: env = TrueSkill(mu, sigma, beta, tau, draw_probability, backend) global_env.__trueskill__ = env @@ -692,35 +896,12 @@ def setup(mu=MU, sigma=SIGMA, beta=BETA, tau=TAU, def rate(rating_groups, ranks=None, weights=None, min_delta=DELTA): - """A proxy function for :meth:`TrueSkill.rate` of the global environment. - - .. versionadded:: 0.2 - - """ return global_env().rate(rating_groups, ranks, weights, min_delta) def quality(rating_groups, weights=None): - """A proxy function for :meth:`TrueSkill.quality` of the global - environment. - - .. versionadded:: 0.2 - - """ return global_env().quality(rating_groups, weights) def expose(rating): - """A proxy function for :meth:`TrueSkill.expose` of the global environment. - - .. versionadded:: 0.4 - - """ - return global_env().expose(rating) - - -# Append deprecated methods into :class:`TrueSkill` and :class:`Rating` -from . import deprecated # noqa -from .deprecated import ( # noqa - dynamic_draw_probability, match_quality, transform_ratings) -deprecated.ensure_backward_compatibility(TrueSkill, Rating) + return global_env().expose(rating) \ No newline at end of file diff --git a/data analysis/analysis/trueskill/__about__.py b/data analysis/analysis/trueskill/__about__.py deleted file mode 100644 index 8e5e3ee3..00000000 --- a/data analysis/analysis/trueskill/__about__.py +++ /dev/null @@ -1,11 +0,0 @@ -# -*- coding: utf-8 -*- -""" - trueskill.__about__ - ~~~~~~~~~~~~~~~~~~~ -""" -__version__ = '0.4.5' -__license__ = 'BSD' -__author__ = 'Heungsub Lee' -__author_email__ = 'sub@subl.ee' -__url__ = 'http://trueskill.org/' -__description__ = 'The video game rating system' diff --git a/data analysis/analysis/trueskill/__pycache__/__about__.cpython-37.pyc b/data analysis/analysis/trueskill/__pycache__/__about__.cpython-37.pyc deleted file mode 100644 index 711958bc..00000000 Binary files a/data analysis/analysis/trueskill/__pycache__/__about__.cpython-37.pyc and /dev/null differ diff --git a/data analysis/analysis/trueskill/__pycache__/__init__.cpython-37.pyc b/data analysis/analysis/trueskill/__pycache__/__init__.cpython-37.pyc deleted file mode 100644 index 96fe0095..00000000 Binary files a/data analysis/analysis/trueskill/__pycache__/__init__.cpython-37.pyc and /dev/null differ diff --git a/data analysis/analysis/trueskill/__pycache__/backends.cpython-37.pyc b/data analysis/analysis/trueskill/__pycache__/backends.cpython-37.pyc deleted file mode 100644 index 1fb6a2f2..00000000 Binary files a/data analysis/analysis/trueskill/__pycache__/backends.cpython-37.pyc and /dev/null differ diff --git a/data analysis/analysis/trueskill/__pycache__/deprecated.cpython-37.pyc b/data analysis/analysis/trueskill/__pycache__/deprecated.cpython-37.pyc deleted file mode 100644 index 39d950c4..00000000 Binary files a/data analysis/analysis/trueskill/__pycache__/deprecated.cpython-37.pyc and /dev/null differ diff --git a/data analysis/analysis/trueskill/__pycache__/factorgraph.cpython-37.pyc b/data analysis/analysis/trueskill/__pycache__/factorgraph.cpython-37.pyc deleted file mode 100644 index a6f1f55c..00000000 Binary files a/data analysis/analysis/trueskill/__pycache__/factorgraph.cpython-37.pyc and /dev/null differ diff --git a/data analysis/analysis/trueskill/__pycache__/mathematics.cpython-37.pyc b/data analysis/analysis/trueskill/__pycache__/mathematics.cpython-37.pyc deleted file mode 100644 index 2983b604..00000000 Binary files a/data analysis/analysis/trueskill/__pycache__/mathematics.cpython-37.pyc and /dev/null differ diff --git a/data analysis/analysis/trueskill/backends.py b/data analysis/analysis/trueskill/backends.py deleted file mode 100644 index 0fc03754..00000000 --- a/data analysis/analysis/trueskill/backends.py +++ /dev/null @@ -1,135 +0,0 @@ -# -*- coding: utf-8 -*- -""" - trueskill.backends - ~~~~~~~~~~~~~~~~~~ - - Provides mathematical statistics backend chooser. - - :copyright: (c) 2012-2016 by Heungsub Lee. - :license: BSD, see LICENSE for more details. - -""" -from __future__ import absolute_import - -import math - -from six.moves import range - - -__all__ = ['available_backends', 'choose_backend', 'cdf', 'pdf', 'ppf'] - - -def _gen_erfcinv(erfc, math=math): - """Generates the inverse function of erfc by the given erfc function and - math module. - """ - def erfcinv(y): - """The inverse function of erfc.""" - if y >= 2: - return -100. - elif y <= 0: - return 100. - zero_point = y < 1 - if not zero_point: - y = 2 - y - t = math.sqrt(-2 * math.log(y / 2.)) - x = -0.70711 * \ - ((2.30753 + t * 0.27061) / (1. + t * (0.99229 + t * 0.04481)) - t) - for i in range(2): - err = erfc(x) - y - x += err / (1.12837916709551257 * math.exp(-(x ** 2)) - x * err) - return x if zero_point else -x - return erfcinv - - -def _gen_ppf(erfc, math=math): - """ppf is the inverse function of cdf. This function generates cdf by the - given erfc and math module. - """ - erfcinv = _gen_erfcinv(erfc, math) - def ppf(x, mu=0, sigma=1): - """The inverse function of cdf.""" - return mu - sigma * math.sqrt(2) * erfcinv(2 * x) - return ppf - - -def erfc(x): - """Complementary error function (via `http://bit.ly/zOLqbc`_)""" - z = abs(x) - t = 1. / (1. + z / 2.) - r = t * math.exp(-z * z - 1.26551223 + t * (1.00002368 + t * ( - 0.37409196 + t * (0.09678418 + t * (-0.18628806 + t * ( - 0.27886807 + t * (-1.13520398 + t * (1.48851587 + t * ( - -0.82215223 + t * 0.17087277 - ))) - ))) - ))) - return 2. - r if x < 0 else r - - -def cdf(x, mu=0, sigma=1): - """Cumulative distribution function""" - return 0.5 * erfc(-(x - mu) / (sigma * math.sqrt(2))) - - -def pdf(x, mu=0, sigma=1): - """Probability density function""" - return (1 / math.sqrt(2 * math.pi) * abs(sigma) * - math.exp(-(((x - mu) / abs(sigma)) ** 2 / 2))) - - -ppf = _gen_ppf(erfc) - - -def choose_backend(backend): - """Returns a tuple containing cdf, pdf, ppf from the chosen backend. - - >>> cdf, pdf, ppf = choose_backend(None) - >>> cdf(-10) - 7.619853263532764e-24 - >>> cdf, pdf, ppf = choose_backend('mpmath') - >>> cdf(-10) - mpf('7.6198530241605255e-24') - - .. versionadded:: 0.3 - - """ - if backend is None: # fallback - return cdf, pdf, ppf - elif backend == 'mpmath': - try: - import mpmath - except ImportError: - raise ImportError('Install "mpmath" to use this backend') - return mpmath.ncdf, mpmath.npdf, _gen_ppf(mpmath.erfc, math=mpmath) - elif backend == 'scipy': - try: - from scipy.stats import norm - except ImportError: - raise ImportError('Install "scipy" to use this backend') - return norm.cdf, norm.pdf, norm.ppf - raise ValueError('%r backend is not defined' % backend) - - -def available_backends(): - """Detects list of available backends. All of defined backends are - ``None`` -- internal implementation, "mpmath", "scipy". - - You can check if the backend is available in the current environment with - this function:: - - if 'mpmath' in available_backends(): - # mpmath can be used in the current environment - setup(backend='mpmath') - - .. versionadded:: 0.3 - - """ - backends = [None] - for backend in ['mpmath', 'scipy']: - try: - __import__(backend) - except ImportError: - continue - backends.append(backend) - return backends diff --git a/data analysis/analysis/trueskill/deprecated.py b/data analysis/analysis/trueskill/deprecated.py deleted file mode 100644 index 6378f169..00000000 --- a/data analysis/analysis/trueskill/deprecated.py +++ /dev/null @@ -1,134 +0,0 @@ -# -*- coding: utf-8 -*- -""" - trueskill.deprecated - ~~~~~~~~~~~~~~~~~~~~ - - Deprecated features. - - :copyright: (c) 2012-2016 by Heungsub Lee - :license: BSD, see LICENSE for more details. - -""" -from __future__ import absolute_import - -import warnings - -from . import DELTA, expose, global_env, quality_1vs1, rate_1vs1, Rating - - -__all__ = ['transform_ratings', 'match_quality', 'dynamic_draw_probability', - 'ensure_backward_compatibility'] - - -# deprecated functions - - -def transform_ratings(rating_groups, ranks=None, min_delta=DELTA): - return global_env().transform_ratings(rating_groups, ranks, min_delta) - - -def match_quality(rating_groups): - return global_env().match_quality(rating_groups) - - -def dynamic_draw_probability(rating1, rating2, env=None): - """Deprecated. It was an approximation for :func:`quality_1vs1`. - - .. deprecated:: 0.4.1 - Use :func:`quality_1vs1` instead. - - """ - warnings.warn('Use quality_1vs1() instead', DeprecationWarning) - return quality_1vs1(rating1, rating2, env=env) - - -# deprecated methods - - -def addattr(obj, attr, value): - if hasattr(obj, attr): - raise AttributeError('The attribute already exists') - return setattr(obj, attr, value) - - -def ensure_backward_compatibility(TrueSkill, Rating): - addattr(TrueSkill, 'Rating', TrueSkill_Rating) - addattr(TrueSkill, 'transform_ratings', TrueSkill_transform_ratings) - addattr(TrueSkill, 'match_quality', TrueSkill_match_quality) - addattr(TrueSkill, 'rate_1vs1', TrueSkill_rate_1vs1) - addattr(TrueSkill, 'quality_1vs1', TrueSkill_quality_1vs1) - addattr(Rating, 'exposure', Rating_exposure) - - -def TrueSkill_Rating(self, mu=None, sigma=None): - """Deprecated. Used to create a :class:`Rating` object. - - .. deprecated:: 0.2 - Override :meth:`create_rating` instead. - - """ - warnings.warn('Use TrueSkill.create_rating() instead', DeprecationWarning) - return self.create_rating(mu, sigma) - - -def TrueSkill_transform_ratings(self, rating_groups, ranks=None, - min_delta=DELTA): - """Deprecated. Used to rate the given ratings. - - .. deprecated:: 0.2 - Override :meth:`rate` instead. - - """ - warnings.warn('Use TrueSkill.rate() instead', DeprecationWarning) - rating_groups = [(r,) if isinstance(r, Rating) else r - for r in rating_groups] - return self.rate(rating_groups, ranks, min_delta=min_delta) - - -def TrueSkill_match_quality(self, rating_groups): - """Deprecated. Used to calculate a match quality. - - .. deprecated:: 0.2 - Override :meth:`quality` instead. - - """ - warnings.warn('Use TrueSkill.quality() instead', DeprecationWarning) - rating_groups = [(r,) if isinstance(r, Rating) else r - for r in rating_groups] - return self.quality(rating_groups) - - -def TrueSkill_rate_1vs1(self, rating1, rating2, drawn=False, min_delta=DELTA): - """Deprecated. Used to rate just a head-to-haed match. - - .. deprecated:: 0.4 - Use :func:`rate_1vs1` instead. - - """ - warnings.warn('Use global function rate_1vs1() instead', - DeprecationWarning) - return rate_1vs1(rating1, rating2, drawn, min_delta, self) - - -def TrueSkill_quality_1vs1(self, rating1, rating2): - """Deprecated. Used to calculate a match quality for a head-to-haed match. - - .. deprecated:: 0.4 - Use :func:`quality_1vs1` instead. - - """ - warnings.warn('Use global function quality_1vs1() instead', - DeprecationWarning) - return quality_1vs1(rating1, rating2, self) - - -@property -def Rating_exposure(self): - """Deprecated. Used to get a value that will go up on the whole. - - .. deprecated:: 0.4 - Use :meth:`TrueSkill.expose` instead. - - """ - warnings.warn('Use TrueSkill.expose() instead', DeprecationWarning) - return expose(self) diff --git a/data analysis/analysis/trueskill/factorgraph.py b/data analysis/analysis/trueskill/factorgraph.py deleted file mode 100644 index 569d522c..00000000 --- a/data analysis/analysis/trueskill/factorgraph.py +++ /dev/null @@ -1,199 +0,0 @@ -# -*- coding: utf-8 -*- -""" - trueskill.factorgraph - ~~~~~~~~~~~~~~~~~~~~~ - - This module contains nodes for the factor graph of TrueSkill algorithm. - - :copyright: (c) 2012-2016 by Heungsub Lee. - :license: BSD, see LICENSE for more details. - -""" -from __future__ import absolute_import - -import math - -from six.moves import zip - -from .mathematics import Gaussian, inf - - -__all__ = ['Variable', 'PriorFactor', 'LikelihoodFactor', 'SumFactor', - 'TruncateFactor'] - - -class Node(object): - - pass - - -class Variable(Node, Gaussian): - - def __init__(self): - self.messages = {} - super(Variable, self).__init__() - - def set(self, val): - delta = self.delta(val) - self.pi, self.tau = val.pi, val.tau - return delta - - def delta(self, other): - pi_delta = abs(self.pi - other.pi) - if pi_delta == inf: - return 0. - return max(abs(self.tau - other.tau), math.sqrt(pi_delta)) - - def update_message(self, factor, pi=0, tau=0, message=None): - message = message or Gaussian(pi=pi, tau=tau) - old_message, self[factor] = self[factor], message - return self.set(self / old_message * message) - - def update_value(self, factor, pi=0, tau=0, value=None): - value = value or Gaussian(pi=pi, tau=tau) - old_message = self[factor] - self[factor] = value * old_message / self - return self.set(value) - - def __getitem__(self, factor): - return self.messages[factor] - - def __setitem__(self, factor, message): - self.messages[factor] = message - - def __repr__(self): - args = (type(self).__name__, super(Variable, self).__repr__(), - len(self.messages), '' if len(self.messages) == 1 else 's') - return '<%s %s with %d connection%s>' % args - - -class Factor(Node): - - def __init__(self, variables): - self.vars = variables - for var in variables: - var[self] = Gaussian() - - def down(self): - return 0 - - def up(self): - return 0 - - @property - def var(self): - assert len(self.vars) == 1 - return self.vars[0] - - def __repr__(self): - args = (type(self).__name__, len(self.vars), - '' if len(self.vars) == 1 else 's') - return '<%s with %d connection%s>' % args - - -class PriorFactor(Factor): - - def __init__(self, var, val, dynamic=0): - super(PriorFactor, self).__init__([var]) - self.val = val - self.dynamic = dynamic - - def down(self): - sigma = math.sqrt(self.val.sigma ** 2 + self.dynamic ** 2) - value = Gaussian(self.val.mu, sigma) - return self.var.update_value(self, value=value) - - -class LikelihoodFactor(Factor): - - def __init__(self, mean_var, value_var, variance): - super(LikelihoodFactor, self).__init__([mean_var, value_var]) - self.mean = mean_var - self.value = value_var - self.variance = variance - - def calc_a(self, var): - return 1. / (1. + self.variance * var.pi) - - def down(self): - # update value. - msg = self.mean / self.mean[self] - a = self.calc_a(msg) - return self.value.update_message(self, a * msg.pi, a * msg.tau) - - def up(self): - # update mean. - msg = self.value / self.value[self] - a = self.calc_a(msg) - return self.mean.update_message(self, a * msg.pi, a * msg.tau) - - -class SumFactor(Factor): - - def __init__(self, sum_var, term_vars, coeffs): - super(SumFactor, self).__init__([sum_var] + term_vars) - self.sum = sum_var - self.terms = term_vars - self.coeffs = coeffs - - def down(self): - vals = self.terms - msgs = [var[self] for var in vals] - return self.update(self.sum, vals, msgs, self.coeffs) - - def up(self, index=0): - coeff = self.coeffs[index] - coeffs = [] - for x, c in enumerate(self.coeffs): - try: - if x == index: - coeffs.append(1. / coeff) - else: - coeffs.append(-c / coeff) - except ZeroDivisionError: - coeffs.append(0.) - vals = self.terms[:] - vals[index] = self.sum - msgs = [var[self] for var in vals] - return self.update(self.terms[index], vals, msgs, coeffs) - - def update(self, var, vals, msgs, coeffs): - pi_inv = 0 - mu = 0 - for val, msg, coeff in zip(vals, msgs, coeffs): - div = val / msg - mu += coeff * div.mu - if pi_inv == inf: - continue - try: - # numpy.float64 handles floating-point error by different way. - # For example, it can just warn RuntimeWarning on n/0 problem - # instead of throwing ZeroDivisionError. So div.pi, the - # denominator has to be a built-in float. - pi_inv += coeff ** 2 / float(div.pi) - except ZeroDivisionError: - pi_inv = inf - pi = 1. / pi_inv - tau = pi * mu - return var.update_message(self, pi, tau) - - -class TruncateFactor(Factor): - - def __init__(self, var, v_func, w_func, draw_margin): - super(TruncateFactor, self).__init__([var]) - self.v_func = v_func - self.w_func = w_func - self.draw_margin = draw_margin - - def up(self): - val = self.var - msg = self.var[self] - div = val / msg - sqrt_pi = math.sqrt(div.pi) - args = (div.tau / sqrt_pi, self.draw_margin * sqrt_pi) - v = self.v_func(*args) - w = self.w_func(*args) - denom = (1. - w) - pi, tau = div.pi / denom, (div.tau + sqrt_pi * v) / denom - return val.update_value(self, pi, tau) diff --git a/data analysis/analysis/trueskill/mathematics.py b/data analysis/analysis/trueskill/mathematics.py deleted file mode 100644 index 61845137..00000000 --- a/data analysis/analysis/trueskill/mathematics.py +++ /dev/null @@ -1,260 +0,0 @@ -# -*- coding: utf-8 -*- -""" - trueskill.mathematics - ~~~~~~~~~~~~~~~~~~~~~ - - This module contains basic mathematics functions and objects for TrueSkill - algorithm. If you have not scipy, this module provides the fallback. - - :copyright: (c) 2012-2016 by Heungsub Lee. - :license: BSD, see LICENSE for more details. - -""" -from __future__ import absolute_import - -import copy -import math -try: - from numbers import Number -except ImportError: - Number = (int, long, float, complex) - -from six import iterkeys - - -__all__ = ['Gaussian', 'Matrix', 'inf'] - - -inf = float('inf') - - -class Gaussian(object): - """A model for the normal distribution.""" - - #: Precision, the inverse of the variance. - pi = 0 - #: Precision adjusted mean, the precision multiplied by the mean. - tau = 0 - - def __init__(self, mu=None, sigma=None, pi=0, tau=0): - if mu is not None: - if sigma is None: - raise TypeError('sigma argument is needed') - elif sigma == 0: - raise ValueError('sigma**2 should be greater than 0') - pi = sigma ** -2 - tau = pi * mu - self.pi = pi - self.tau = tau - - @property - def mu(self): - """A property which returns the mean.""" - return self.pi and self.tau / self.pi - - @property - def sigma(self): - """A property which returns the the square root of the variance.""" - return math.sqrt(1 / self.pi) if self.pi else inf - - def __mul__(self, other): - pi, tau = self.pi + other.pi, self.tau + other.tau - return Gaussian(pi=pi, tau=tau) - - def __truediv__(self, other): - pi, tau = self.pi - other.pi, self.tau - other.tau - return Gaussian(pi=pi, tau=tau) - - __div__ = __truediv__ # for Python 2 - - def __eq__(self, other): - return self.pi == other.pi and self.tau == other.tau - - def __lt__(self, other): - return self.mu < other.mu - - def __le__(self, other): - return self.mu <= other.mu - - def __gt__(self, other): - return self.mu > other.mu - - def __ge__(self, other): - return self.mu >= other.mu - - def __repr__(self): - return 'N(mu={:.3f}, sigma={:.3f})'.format(self.mu, self.sigma) - - def _repr_latex_(self): - latex = r'\mathcal{{ N }}( {:.3f}, {:.3f}^2 )'.format(self.mu, self.sigma) - return '$%s$' % latex - - -class Matrix(list): - """A model for matrix.""" - - def __init__(self, src, height=None, width=None): - if callable(src): - f, src = src, {} - size = [height, width] - if not height: - def set_height(height): - size[0] = height - size[0] = set_height - if not width: - def set_width(width): - size[1] = width - size[1] = set_width - try: - for (r, c), val in f(*size): - src[r, c] = val - except TypeError: - raise TypeError('A callable src must return an interable ' - 'which generates a tuple containing ' - 'coordinate and value') - height, width = tuple(size) - if height is None or width is None: - raise TypeError('A callable src must call set_height and ' - 'set_width if the size is non-deterministic') - if isinstance(src, list): - is_number = lambda x: isinstance(x, Number) - unique_col_sizes = set(map(len, src)) - everything_are_number = filter(is_number, sum(src, [])) - if len(unique_col_sizes) != 1 or not everything_are_number: - raise ValueError('src must be a rectangular array of numbers') - two_dimensional_array = src - elif isinstance(src, dict): - if not height or not width: - w = h = 0 - for r, c in iterkeys(src): - if not height: - h = max(h, r + 1) - if not width: - w = max(w, c + 1) - if not height: - height = h - if not width: - width = w - two_dimensional_array = [] - for r in range(height): - row = [] - two_dimensional_array.append(row) - for c in range(width): - row.append(src.get((r, c), 0)) - else: - raise TypeError('src must be a list or dict or callable') - super(Matrix, self).__init__(two_dimensional_array) - - @property - def height(self): - return len(self) - - @property - def width(self): - return len(self[0]) - - def transpose(self): - height, width = self.height, self.width - src = {} - for c in range(width): - for r in range(height): - src[c, r] = self[r][c] - return type(self)(src, height=width, width=height) - - def minor(self, row_n, col_n): - height, width = self.height, self.width - if not (0 <= row_n < height): - raise ValueError('row_n should be between 0 and %d' % height) - elif not (0 <= col_n < width): - raise ValueError('col_n should be between 0 and %d' % width) - two_dimensional_array = [] - for r in range(height): - if r == row_n: - continue - row = [] - two_dimensional_array.append(row) - for c in range(width): - if c == col_n: - continue - row.append(self[r][c]) - return type(self)(two_dimensional_array) - - def determinant(self): - height, width = self.height, self.width - if height != width: - raise ValueError('Only square matrix can calculate a determinant') - tmp, rv = copy.deepcopy(self), 1. - for c in range(width - 1, 0, -1): - pivot, r = max((abs(tmp[r][c]), r) for r in range(c + 1)) - pivot = tmp[r][c] - if not pivot: - return 0. - tmp[r], tmp[c] = tmp[c], tmp[r] - if r != c: - rv = -rv - rv *= pivot - fact = -1. / pivot - for r in range(c): - f = fact * tmp[r][c] - for x in range(c): - tmp[r][x] += f * tmp[c][x] - return rv * tmp[0][0] - - def adjugate(self): - height, width = self.height, self.width - if height != width: - raise ValueError('Only square matrix can be adjugated') - if height == 2: - a, b = self[0][0], self[0][1] - c, d = self[1][0], self[1][1] - return type(self)([[d, -b], [-c, a]]) - src = {} - for r in range(height): - for c in range(width): - sign = -1 if (r + c) % 2 else 1 - src[r, c] = self.minor(r, c).determinant() * sign - return type(self)(src, height, width) - - def inverse(self): - if self.height == self.width == 1: - return type(self)([[1. / self[0][0]]]) - return (1. / self.determinant()) * self.adjugate() - - def __add__(self, other): - height, width = self.height, self.width - if (height, width) != (other.height, other.width): - raise ValueError('Must be same size') - src = {} - for r in range(height): - for c in range(width): - src[r, c] = self[r][c] + other[r][c] - return type(self)(src, height, width) - - def __mul__(self, other): - if self.width != other.height: - raise ValueError('Bad size') - height, width = self.height, other.width - src = {} - for r in range(height): - for c in range(width): - src[r, c] = sum(self[r][x] * other[x][c] - for x in range(self.width)) - return type(self)(src, height, width) - - def __rmul__(self, other): - if not isinstance(other, Number): - raise TypeError('The operand should be a number') - height, width = self.height, self.width - src = {} - for r in range(height): - for c in range(width): - src[r, c] = other * self[r][c] - return type(self)(src, height, width) - - def __repr__(self): - return '{}({})'.format(type(self).__name__, super(Matrix, self).__repr__()) - - def _repr_latex_(self): - rows = [' && '.join(['%.3f' % cell for cell in row]) for row in self] - latex = r'\begin{matrix} %s \end{matrix}' % r'\\'.join(rows) - return '$%s$' % latex