diff options
Diffstat (limited to 'classifier.py')
| -rw-r--r-- | classifier.py | 346 |
1 files changed, 346 insertions, 0 deletions
diff --git a/classifier.py b/classifier.py new file mode 100644 index 0000000..471c645 --- /dev/null +++ b/classifier.py @@ -0,0 +1,346 @@ +#!/usr/bin/python + +import os +import json +import itertools +import logging +import tensorflow as tf +import psycopg2 +import psycopg2.extras + + +class Classifier(object): + def __init__(self, name): + self._name = name + self.model = None + self.modeldir = os.path.realpath( + os.path.join(os.getcwd(), os.path.dirname(__file__))) + "/models/" + self._name + + self._conn = None + + # empty defaults + self._categories = [] + self._continuous = [] + self._classes = [] + + # learn configuration + self._steps = 0 # per batch + self._batchsize = 0 + self._max_batches = 0 # number of batches to train + self._dimension = 0 # embeddings dimension, log_2(num of unique features) + self._bucketsize = 0 # sparse column hash bucket size + self._hidden = [] # hidden layers http://stats.stackexchange.com/a/1097 + + # db SQL mappings + # TODO use cache + # override these + self._trainquery = "" + self._testquery = "" + self._insertquery = "" + self._label = "" + + # + self._binary = False + self._label_available = True # label is in data + + def connect(self, **args): + self._conn = psycopg2.connect(**args) + + def _model_setup(self): + """Sets up a model that takes the `num_features` features as input.""" + feature_columns = [ + tf.contrib.layers.sparse_column_with_hash_bucket(feat, self._bucketsize) + for feat in self._categories + ] + emb_columns = [ + tf.contrib.layers.embedding_column( + sparse_id_column=col, + dimension=self._dimension + ) + for col in feature_columns + ] + [ + tf.contrib.layers.real_valued_column(feat) + for feat in self._continuous + ] + + self.model = tf.contrib.learn.DNNClassifier( + feature_columns=emb_columns, + hidden_units=self._hidden, + n_classes=len(self._classes), + model_dir=self.modeldir, + config=tf.contrib.learn.RunConfig( + save_checkpoints_secs=2 + ) + ) + + def _get_sample(self, size=None, filter=None): + """Return a data set from the database. + :param size: (optional) The number of items to get. Defaults to `All`. + :type size: int or str + :param offset: (optional) The SQL OFFSET parameter. + :type offset: int or str + """ + cur = self._conn.cursor(cursor_factory=psycopg2.extras.DictCursor) + + assert (filter is None) ^ (size is None) + if filter is None: + cur.execute(self._trainquery, (size,)) + else: + cur.execute(self._testquery, (filter,)) + + ids = [] + data = {name: [] for name in self._continuous + [self._label]} + for rec in cur: + for key in data.keys(): + if key == self._label and not self._label_available: + val = self.guess_label(rec) + else: + val = rec[key] + data[key].append(val) + ids.append(rec["id"]) + cur.close() + return data, ids + + def guess_label(self, data): + """Return a label based on data.""" + # override + pass + + # TODO tf warning - dimensions are wrong + def _toinput(self, sample, train=True): + """Convert sample to Tensors. + :param sample: Data dictionary. + :type sample: dict + :param train: (optional) Whether to return labels too. + :type train: bool + :return: features, label + :rtype: tuple + """ + continuous = {k: tf.constant(sample[k]) + for k in self._continuous} + categories = {k: tf.SparseTensor( + indices=[[i, 0] for i in range(len(sample[k]))], + values=sample[k], + shape=[len(sample[k]), 1]) + for k in self._categories} + + features = {**continuous, **categories} + + if train: + label = tf.constant(sample[self._label]) + return features, label + else: + return features + + def _more(self): + """Fetches up to `limit` number of training items + from the database in batches.""" + # TODO maybe you can use an iterator? + sample = self._get_sample(size=self._batchsize)[0] + return self._toinput(sample, train=True) + + def train(self): + """Train a DNN on a static, algorithmic guess.""" + self._model_setup() + + if os.path.isdir(self.modeldir): + logging.warning("already trained, not training again") + return + + # get one batch of testing data + # TODO either terminate with `eval_steps` or with OutOfRangeError + validation_monitor = tf.contrib.learn.monitors.ValidationMonitor( + input_fn=lambda: self._toinput(self._get_sample(size=1000)[0], train=True), + eval_steps=1, + every_n_steps=10 + ) + + for _ in range(self._max_batches): + self.model.fit( + input_fn=lambda: self._more(), + steps=self._steps, + monitors=[validation_monitor] + ) + + def classify(self, sample): + """Classify a data set. + + :param only_best: (optional) Return the predicted result + instead of a dict of propabilities. + :type only_best: bool + :return: Prediction results. + :rtype: list of dict or list + """ + return self.model.predict_proba(input_fn=lambda: self._toinput(sample, train=False)) + + def windup(self): + pass + + def teardown(self, failed=False): + if failed: + pass + else: + self._conn.commit() + + def classify_db(self, objids): + """Classify all data in the data base and insert.""" + # split sample (with participant ids) into data and ids + # TODO use parameters + sample, ids = self._get_sample(filter=objids) + d = self.classify(sample) + cnt = 0 + cur = self._conn.cursor() + for l in itertools.islice(d, len(objids)): + # TODO use executemany? + cur.execute(self._insertquery, { + "id": ids[cnt], + self._label: json.dumps(l.tolist()) + }) + cnt += 1 + cur.close() + +class KDAClassifier(Classifier): + """A DNN that classifies loss/win based on KDA.""" + def __init__(self): + super().__init__("kda-win") + + # DNN configuration + self._continuous = ["kills", "deaths", "assists", "cs", "teamkills"] + self._classes = ["loss", "win"] + self._label = "win" + self._binary = True + + self._steps = 200 + self._batchsize = 500 + self._max_batches = 5 + + self._trainquery = """ + SELECT + participant.kills, + participant.deaths, + participant.assists, + participant.farm AS cs, + roster.hero_kills AS teamkills, + participant.winner AS win, + participant.api_id AS id + FROM participant + TABLESAMPLE BERNOULLI(5) + JOIN roster on participant.roster_api_id=roster.api_id + JOIN match on roster.match_api_id=match.api_id + LIMIT %s + """ + self._testquery = """ + SELECT + participant.kills, + participant.deaths, + participant.assists, + participant.farm AS cs, + roster.hero_kills AS teamkills, + participant.winner AS win, + participant.api_id AS id + FROM participant + JOIN roster on participant.roster_api_id=roster.api_id + JOIN match on roster.match_api_id=match.api_id + WHERE participant.api_id=ANY(%s) + """ + self._insertquery = """ + INSERT INTO participant_stats + (patch_version, participant_api_id, score) + VALUES(2.2, %(id)s, (%(win)s::json->>1)::float) + ON CONFLICT(participant_api_id) DO + UPDATE SET score=(%(win)s::json->>1)::float + """ + + self._dimension = 5 + self._bucketsize = 100 + self._hidden = [2] + + +class RoleClassifier(Classifier): + """A DNN that classifies participants into roles based on CS.""" + def __init__(self): + super().__init__("roles") + + # DNN configuration + self._continuous = ["lanefarm", "junglefarm"] + self._classes = ["carry", "jungler", "captain"] + self._label = "role" + self._binary = True + self._label_available = False + + self._steps = 200 + self._batchsize = 500 + self._max_batches = 5 + + self._trainquery = """ + SELECT + participant.hero AS hero, + participant.jungle_kills AS junglefarm, + (participant.minion_kills-participant.jungle_kills) AS lanefarm, + participant.api_id AS id + FROM participant + TABLESAMPLE BERNOULLI(5) + LIMIT %s + """ + self._testquery = """ + SELECT + participant.hero AS hero, + participant.jungle_kills AS junglefarm, + (participant.minion_kills-participant.jungle_kills) AS lanefarm, + participant.api_id AS id + FROM participant + WHERE participant.api_id=ANY(%s) + """ + self._insertquery = """ + INSERT INTO participant_stats + (patch_version, participant_api_id, role) + VALUES(2.2, %(id)s, %(role)s::json) + ON CONFLICT(participant_api_id) DO + UPDATE SET role=%(role)s::json + """ + + self._dimension = 5 + self._bucketsize = 100 + self._hidden = [3] + + def guess_label(self, data): + hero_map = { + '*Adagio*': 'captain', + '*Alpha*': 'jungler', + '*Ardan*': 'captain', + '*Baron*': 'carry', + '*Blackfeather*': 'jungler', + '*Catherine*': 'captain', + '*Celeste*': 'carry', + '*Flicker*': 'captain', + '*Fortress*': 'captain', + '*Glaive*': 'jungler', + '*Grumpjaw*': 'jungler', + '*Gwen*': 'carry', + '*Idris*': 'jungler', + '*Joule*': 'jungler', + '*Kestrel*': 'carry', + '*Koshka*': 'jungler', + '*Hero009*': 'jungler', + '*Lance*': 'captain', + '*Lyra*': 'captain', + '*Ozo*': 'jungler', + '*Petal*': 'jungler', + '*Phinn*': 'captain', + '*Reim*': 'jungler', + '*Ringo*': 'carry', + '*Hero016*': 'jungler', + '*Samuel*': 'carry', + '*SAW*': 'carry', + '*Hero010*': 'carry', + '*Sayoc*': 'jungler', + '*Skye*': 'carry', + '*Taka*': 'jungler', + '*Vox*': 'carry' + } + + score = {"carry": 0, "jungler": 0, "captain": 0} +# score["carry"] += data["lanefarm"] / 100 # TODO average lane cs +# score["jungler"] += data["junglefarm"] / 80 # TODO avg jungle cs + score[hero_map[data["hero"]]] += 1 + return self._classes.index(max(score, key=score.get)) |