refactor, write role classification model (wip)feature/actorclassify

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