Safe to demo (and awesome B)) Merge pull request #78 from ShaynAli/dev

The awesome update B)

Author: ShaynAli

src/activities/stock_prediction/stock_arena.py

@@ -1,11 +1,10 @@
 from arena.arena import MachineLearningArena
-from activities.stock_prediction.stock_prediction import FrankfurtStockPrediction
-from activities.stock_prediction.stock_prediction_models import RandomRangePredictor
+from activities.stock_prediction.stock_prediction_models import *
 import pprint
 
 if __name__ == '__main__':
 
-    arena = MachineLearningArena(model_pool=[RandomRangePredictor], activity=FrankfurtStockPrediction)
+    arena = MachineLearningArena(model_pool=[ShallowNeuralNetworkPredictor], activity=FrankfurtStockPrediction)
     printer = pprint.PrettyPrinter()
     for _ in range(10):
         arena.auto_compete()

src/activities/stock_prediction/stock_prediction.py

@@ -1,7 +1,5 @@
 from activities.activities import MachineLearningActivity
 import quandl
-from _datetime import date, timedelta
-import pdb
 import numpy as np
 from datetime import date
 from dateutil.relativedelta import relativedelta
@@ -196,6 +194,8 @@ class FrankfurtStockPrediction(MachineLearningActivity):
 
     default_guess_tickers = ['CON_X']
 
+    n_days = 20
+
     def __init__(self, tickers=default_tickers, guess_tickers=default_guess_tickers):
         quandl.ApiConfig.api_key = 'z3rsXS2rz9ZXCe76xozE'
         self.code = 'FSE'
@@ -204,11 +204,11 @@ def __init__(self, tickers=default_tickers, guess_tickers=default_guess_tickers)
 
     @property
     def x_shape(self):
-        return len(self.tickers), None
+        return FrankfurtStockPrediction.n_days, len(self.tickers)
 
     @property
     def y_shape(self):
-        return len(self.guess_tickers), None
+        return FrankfurtStockPrediction.n_days, len(self.guess_tickers)
 
     def next_data(self):
         from random import choice
@@ -237,13 +237,18 @@ def next_data(self):
         except ValueError:
             return self.next_data()
 
-        return tickers, guess_tickers
+        x = np.transpose(tickers)[:FrankfurtStockPrediction.n_days, :]
+        y = np.transpose(guess_tickers)[:FrankfurtStockPrediction.n_days, :]
+
+        return x, y
 
     def get_ticker(self, ticker, start_date, end_date, field='Open'):
         return quandl.get(f'{self.code}/{ticker}', returns='numpy', start_date=start_date, end_date=end_date)[field]
 
 
 if __name__ == '__main__':
     activity = FrankfurtStockPrediction()
-    data = [activity.next_data() for _ in range(3)]
-    pdb.set_trace()
+    while True:
+        x, y = activity.next_data()
+        from pdb import set_trace
+        set_trace()

src/activities/stock_prediction/stock_prediction_models.py

@@ -1,5 +1,8 @@
 from activities.stock_prediction.stock_prediction import FrankfurtStockPrediction
 import numpy as np
+from keras import Sequential
+from keras.layers import Dense, Activation
+from random import randint
 
 
 class RandomRangePredictor(FrankfurtStockPrediction.Model):
@@ -18,4 +21,88 @@ def predict(self, x):
 
     @staticmethod
     def description():
-        return '''Predicts within a range range, which is updated base on y data.'''
+        return '''Predicts within a random range. The max and min of the range are updated based on y data.'''
+
+
+class MeanPredictor(FrankfurtStockPrediction.Model):
+
+    def __init__(self, activity):
+        super().__init__(activity)
+
+    def train(self, x, y):
+        pass
+
+    def predict(self, x):
+        return np.full(shape=(self.y_shape[0], x.shape[1]), fill_value=np.mean(x))
+
+    @staticmethod
+    def description():
+        return '''Predicts that every stock will have the same mean price overall.'''
+
+
+class MeanRowPredictor(FrankfurtStockPrediction.Model):
+
+    def __init__(self, activity):
+        super().__init__(activity)
+
+    def train(self, x, y):
+        pass
+
+    def predict(self, x):
+        n_y_cols = self.y_shape[1]
+        prediction = np.empty(shape=self.y_shape)
+        for row_i in range(x.shape[0]):
+            row_mean = np.mean(x[row_i, :])
+            prediction[:, row_i] = [row_mean] * n_y_cols
+        return prediction
+
+    @staticmethod
+    def description():
+        return '''Predicts that every stock will have the same mean price at every time interval.'''
+
+
+class ShallowNeuralNetworkPredictor(FrankfurtStockPrediction.Model):
+
+    def __init__(self, activity):
+        super().__init__(activity)
+        self.neural_network = Sequential([
+            Dense(32, input_shape=(self.x_shape[1],)),
+            Dense(self.y_shape[1])
+        ])
+        self.neural_network.compile(
+            optimizer='nadam',
+            loss='mse'
+        )
+
+    def train(self, x, y):
+        self.neural_network.fit(x=x, y=y)
+
+    def predict(self, x):
+        return self.neural_network.predict(x)
+
+    @staticmethod
+    def description():
+        return '''Uses a shallow, wide neural network.'''
+
+
+class RandomDepthNeuralNetworkPredictor(FrankfurtStockPrediction.Model):
+
+    def __init__(self, activity):
+        super().__init__(activity)
+        self.neural_network = Sequential([Dense(8, input_shape=(self.x_shape[1],))] +
+                                         [Dense(8) for _ in range(randint(0, 8))] +
+                                         [Dense(self.y_shape[1])])
+        self.neural_network.compile(
+            optimizer='nadam',
+            loss='mse'
+        )
+
+    def train(self, x, y):
+        self.neural_network.fit(x=x, y=y)
+
+    def predict(self, x):
+        return self.neural_network.predict(x)
+
+    @staticmethod
+    def description():
+        return '''Creates a neural network of depth from 2-10.'''

src/arena/arena.py

@@ -1,13 +1,13 @@
-""" arena.py - Where ML and AI bots go to face off """
 import evaluation
 from random import choice
-
+from pandas import isnull
 
 class MachineLearningArena:
 
-    def __init__(self, model_pool, activity, generation_size=10):
+    def __init__(self, model_pool, activity, score_function=evaluation.DEFAULT_SCORE_FUNCTION, generation_size=10):
         self.model_pool = model_pool
         self.activity = activity()
+        self.score_function = score_function
         self.models = list(self.new_models(n_models=generation_size))
         self.score_history = []
 
@@ -17,8 +17,8 @@ def new_model(self):
     def new_models(self, n_models):
         return (self.new_model() for _ in range(n_models))
 
-    def compete(self, x, y, live_ratio=0.5, score_function=evaluation.DEFAULT_SCORE_FUNCTION):
-        model_score = {m: evaluation.score(m, x, y, score_function=score_function) for m in self.models}
+    def compete(self, x, y, live_ratio=0.5):
+        model_score = {m: evaluation.score(m, x, y, score_function=self.score_function) for m in self.models}
         self.score_history.append(model_score)
         score_ranking = sorted(model_score.keys(), key=lambda model: model_score[model], reverse=True)
         from utilities import partition_indices
@@ -27,5 +27,6 @@ def compete(self, x, y, live_ratio=0.5, score_function=evaluation.DEFAULT_SCORE_
 
     def auto_compete(self, live_ratio=0.5):
         x, y = self.activity.next_data()
-        self.compete(x=x, y=y, live_ratio=live_ratio, score_function=evaluation.DEFAULT_SCORE_FUNCTION)
-
+        while isnull(x).any() or isnull(y).any():
+            x, y = self.activity.next_data()
+        self.compete(x=x, y=y, live_ratio=live_ratio)

src/data_utils/visualization.py

@@ -1,9 +1,20 @@
 import bokeh
 from bokeh.plotting import figure, output_file, show
-import pdb
+from random import choice
 
 plot_dimensions = (1225, 600)
 
+colors = {}
+
+
+def random_color(k):
+    if k in colors:
+        return colors[k]
+    digits = ['0', '1', '2', '3', '4', '5', '6', '7', '8', '9', 'A', 'B', 'C', 'D', 'E', 'F']
+    new_color = f'#{choice(digits)}{choice(digits)}{choice(digits)}{choice(digits)}{choice(digits)}{choice(digits)}'
+    colors[k] = new_color
+    return new_color
+
 
 def plot_line(data_class, x_label, y_label):
     # Use hover tool
@@ -60,19 +71,19 @@ def multi_line(data, x_label="X", y_label="Y"):
     for k, v in data.items():
         generations = [e[0] for e in v]
         scores = [e[1] for e in v]
-        p.line(generations, scores, line_width=2, legend=k[:8])
+        p.line(generations, scores, line_width=2, legend=k, line_color=random_color(k))
         p.legend.click_policy = "hide"
 
     p.plot_width, p.plot_height = plot_dimensions
     p.toolbar.logo = "grey"
     p.toolbar.autohide = True
+    p.legend.location = "top_left"
     p.background_fill_color = "#dddddd"
     p.hover.tooltips = [
         (x_label, "@x"),
         (y_label, "@y")
     ]
 
-    # Return the plot for display purposes
     return p
 
 

src/evaluation.py

@@ -70,7 +70,7 @@ def complement_mean_pct_error(predicted, actual):
 
 # region Model scoring
 
-DEFAULT_SCORE_FUNCTION = inv_norm_err
+DEFAULT_SCORE_FUNCTION = complement_mean_pct_error
 DEFAULT_ERROR_FUNCTION = rms_error
 DEFAULT_TRACK_FUNCTION = rms_error
 

src/requirements.txt

@@ -1,5 +1,8 @@
-numpy
+numpy==1.16
+flask
 bokeh
-quandl
 scikit-learn
-flask
+keras
+tensorflow
+quandl
+pandas

src/server/assets/favicon.ico

@@ -89,6 +89,14 @@ table tr:nth-child(even) {
     background: #23283C;
 }
 
+#leader-board table td {
+    font-size: 90%;
+}
+
+option {
+    font-size: 120%;
+}
+
 .preview {
     background-color: #23283C;
     font-family: 'Ubuntu Mono', monospace;