Code files added

Author: Donald2017

Lesson02/activity_3/Activity_3_Exploring_Bitcoin_Dataset.ipynb

@@ -0,0 +1,86 @@
+"""
+Series of normalization functions useful
+for normalizing time-series data.
+
+Author: Luis Capelo
+"""
+def z_score(series):
+    """
+    Computes the normalized value using the Z-score
+    technique. The Z-score is a technique used for
+    normalizing Gaussian distributions representing
+    each observation in relation to the distribution's
+    mean and standard deviation. For precise definitions,
+    see the Wikipedia article:
+    
+        https://en.wikipedia.org/wiki/Standard_score
+    
+    Parameters
+    ----------
+    serie: list
+        List with sequential values to use.
+    
+    Returns
+    -------
+    result: list
+        List with the normalized results.
+    """
+    result = (series - series.mean()) / series.std(ddof=0)
+    return result
+
+def point_relative_normalization(series):
+    """
+    Computes the normalized value for the values of a
+    given series by using the first element of the serie as p_0
+    as a reference for each p_i.
+    
+    This technique comes from Siraj Raval's YouTube video
+    "How to Predict Stock Prices Easily - Intro to Deep Learning #7",
+    available at:
+    
+        https://www.youtube.com/watch?v=ftMq5ps503w
+    
+    Parameters
+    ----------
+    serie: list
+        List with sequential values to use.
+    
+    Returns
+    -------
+    result: list
+        List with the normalized results.
+    """
+    result = (series / series.values[0]) - 1
+    return result
+
+def maximum_and_minimum_normalization(series, boundary=(0, 1)):
+    """
+    Computes the normalized value for the values of a
+    given serie by using that series maximum and minimum
+    values.
+    
+    This technique is a direct implementation from 
+    scikit-learn, available at:
+    
+        http://scikit-learn.org/stable/modules/generated/\
+            sklearn.preprocessing.MinMaxScaler.html
+    
+    Parameters
+    ----------
+    serie: list
+        List with sequential values to use.
+    
+    boundary: set
+        Maximum and minimum values used to
+        scale the series.
+        
+    Returns
+    -------
+    result: list
+        List with the normalized results.
+    """
+    range_min, range_max = boundary
+    standard_deviation = (series - series.min(axis=0)) / (series.max(axis=0) - series.min(axis=0))
+    result = standard_deviation * (range_max - range_min) + range_min
+
+    return result

Lesson02/activity_3/data/bitcoin_historical_prices.csv

@@ -0,0 +1,173 @@
+{
+ "cells": [
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "# Activity 4: Creating a TensorFlow Model using Keras\n",
+    "In this notebook we design and compile a deep learning model using Keras as an interface to TensorFlow. We will continue to modify this model in our next lessons and activities by experimenting with different optimization techniques. However, the essential components of the model are entirely designed in this notebook."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 1,
+   "metadata": {},
+   "outputs": [
+    {
+     "name": "stderr",
+     "output_type": "stream",
+     "text": [
+      "Using TensorFlow backend.\n",
+      "/usr/local/Cellar/python3/3.6.3/Frameworks/Python.framework/Versions/3.6/lib/python3.6/importlib/_bootstrap.py:219: RuntimeWarning: compiletime version 3.5 of module 'tensorflow.python.framework.fast_tensor_util' does not match runtime version 3.6\n",
+      "  return f(*args, **kwds)\n"
+     ]
+    }
+   ],
+   "source": [
+    "from keras.models import Sequential\n",
+    "from keras.layers.recurrent import LSTM\n",
+    "from keras.layers.core import Dense, Activation"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Building a Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "Our dataset contains daily observations and each observation influences a future observation. Also, we are interested in predicting a week--that is, seven days--of Bitcoin prices in the future. For those reasons, we chose the parameters `period_length` and `number_of_observations` as follows:\n",
+    "\n",
+    "* `period_length`: the size of the period to use as training input. Our periods are organized in distinct weeks. We will be using a 7-day period to predict a week in the future.\n",
+    "* `number_of_observations`: how many distinct periods does our dataset has? We hvae 77 weeks available in our dataset, given that we will be using the very last week to test the LSTM network on every epoch, we will use 77 - 1 = 76 periods for training it."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 2,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "period_length = 7\n",
+    "number_of_periods = 76"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We now build our LSTM model. "
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 3,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "def build_model(period_length, number_of_periods, batch_size=1):\n",
+    "    \"\"\"\n",
+    "    Builds an LSTM model using Keras. This function\n",
+    "    works as a simple wrapper for a manually created\n",
+    "    model.\n",
+    "    \n",
+    "    Parameters\n",
+    "    ----------\n",
+    "    period_length: int\n",
+    "        The size of each observation used as input.\n",
+    "    \n",
+    "    number_of_periods: int\n",
+    "        The number of periods available in the \n",
+    "        dataset.\n",
+    "    \n",
+    "    batch_size: int\n",
+    "        The size of the batch used in each training\n",
+    "        period.\n",
+    "    \n",
+    "    Returns\n",
+    "    -------\n",
+    "    model: Keras model\n",
+    "        Compiled Keras model that can be trained\n",
+    "        and stored in disk.\n",
+    "    \"\"\"\n",
+    "    model = Sequential()\n",
+    "    model.add(LSTM(\n",
+    "        units=period_length,\n",
+    "        batch_input_shape=(batch_size, number_of_periods, period_length),\n",
+    "        input_shape=(number_of_periods, period_length),\n",
+    "        return_sequences=False, stateful=False))\n",
+    "\n",
+    "    model.add(Dense(units=period_length))\n",
+    "    model.add(Activation(\"linear\"))\n",
+    "\n",
+    "    model.compile(loss=\"mse\", optimizer=\"rmsprop\")\n",
+    "\n",
+    "    return model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "### Saving Model"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "We can use the function `build_model()` as a starting point for building our model. That function will be refactored when building our Flask application for making it easier to train the network and use it for predictions. For now, let's store the model output on disk."
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 4,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model = build_model(period_length=period_length, number_of_periods=number_of_periods)"
+   ]
+  },
+  {
+   "cell_type": "code",
+   "execution_count": 6,
+   "metadata": {},
+   "outputs": [],
+   "source": [
+    "model.save('bitcoin_lstm_v0.h5')"
+   ]
+  },
+  {
+   "cell_type": "markdown",
+   "metadata": {},
+   "source": [
+    "The steps above compile the LSTM model as TensorFlow computation graph. We can now train that model using our train and evaluate its results with our test set."
+   ]
+  }
+ ],
+ "metadata": {
+  "kernelspec": {
+   "display_name": "Python 3",
+   "language": "python",
+   "name": "python3"
+  },
+  "language_info": {
+   "codemirror_mode": {
+    "name": "ipython",
+    "version": 3
+   },
+   "file_extension": ".py",
+   "mimetype": "text/x-python",
+   "name": "python",
+   "nbconvert_exporter": "python",
+   "pygments_lexer": "ipython3",
+   "version": "3.6.3"
+  }
+ },
+ "nbformat": 4,
+ "nbformat_minor": 2
+}