neural_network.ipynb

{
  "cells": [
    {
      "metadata": {
        "_uuid": "8f2839f25d086af736a60e9eeb907d3b93b6e0e5",
        "_cell_guid": "b1076dfc-b9ad-4769-8c92-a6c4dae69d19",
        "trusted": true
      },
      "cell_type": "code",
      "source": "# This Python 3 environment comes with many helpful analytics libraries installed\n# It is defined by the kaggle/python docker image: https://github.com/kaggle/docker-python\n# For example, here's several helpful packages to load in \n\nimport numpy as np # linear algebra\nimport pandas as pd # data processing, CSV file I/O (e.g. pd.read_csv)\n\n# Input data files are available in the \"../input/\" directory.\n# For example, running this (by clicking run or pressing Shift+Enter) will list the files in the input directory\n\nimport os\nimport time\nprint(os.listdir(\"../input\"))\n\nimport matplotlib.pyplot as plt\n\n#Machine Learning Imports\nfrom sklearn.metrics import accuracy_score, mean_squared_error\nfrom sklearn.model_selection import train_test_split\nfrom sklearn.preprocessing import StandardScaler\n\n#Ml Core Algo Libraries\nimport lightgbm as lgb\nimport sklearn\n\n#Deep Learning Imports\nfrom keras.models import Model\nfrom keras.layers import Input, Dense, Embedding, Concatenate, Flatten, BatchNormalization\nfrom keras.losses import binary_crossentropy, mse\nfrom keras.callbacks import EarlyStopping, ModelCheckpoint\n\n#Competition Starter Kit\nfrom kaggle.competitions import twosigmanews\n\n#Gen imports\nfrom itertools import chain",
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "text": "['marketdata_sample.csv', 'news_sample.csv']\n",
          "name": "stdout"
        },
        {
          "output_type": "stream",
          "text": "Using TensorFlow backend.\n",
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "_cell_guid": "79c7e3d0-c299-4dcb-8224-4455121ee9b0",
        "_uuid": "d629ff2d2480ee46fbb7e2d37f6b5fab8052498a",
        "trusted": true
      },
      "cell_type": "code",
      "source": "#Create the env and get the data\nenv = twosigmanews.make_env()\n(market_train, news_train) = env.get_training_data()",
      "execution_count": 2,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Loading the data... This could take a minute.\nDone!\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "38878f72bc98d6a788154db03b217f83b14e3028"
      },
      "cell_type": "code",
      "source": "#Define News Columns\nnews_cols_agg = {\n    'urgency': ['min', 'count'],\n    'takeSequence': ['max'],\n    'bodySize': ['min', 'max', 'mean', 'std'],\n    'wordCount': ['min', 'max', 'mean', 'std'],\n    'sentenceCount': ['min', 'max', 'mean', 'std'],\n    'companyCount': ['min', 'max', 'mean', 'std'],\n    'marketCommentary': ['min', 'max', 'mean', 'std'],\n    'relevance': ['min', 'max', 'mean', 'std'],\n    'sentimentNegative': ['min', 'max', 'mean', 'std'],\n    'sentimentNeutral': ['min', 'max', 'mean', 'std'],\n    'sentimentPositive': ['min', 'max', 'mean', 'std'],\n    'sentimentWordCount': ['min', 'max', 'mean', 'std'],\n    'noveltyCount12H': ['min', 'max', 'mean', 'std'],\n    'noveltyCount24H': ['min', 'max', 'mean', 'std'],\n    'noveltyCount3D': ['min', 'max', 'mean', 'std'],\n    'noveltyCount5D': ['min', 'max', 'mean', 'std'],\n    'noveltyCount7D': ['min', 'max', 'mean', 'std'],\n    'volumeCounts12H': ['min', 'max', 'mean', 'std'],\n    'volumeCounts24H': ['min', 'max', 'mean', 'std'],\n    'volumeCounts3D': ['min', 'max', 'mean', 'std'],\n    'volumeCounts5D': ['min', 'max', 'mean', 'std'],\n    'volumeCounts7D': ['min', 'max', 'mean', 'std']\n}\n",
      "execution_count": 3,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "645911907a1c114bd2e548cf5da127d7d2d1aeaf"
      },
      "cell_type": "code",
      "source": "#Define Join procedure for Market and News Data\ndef join_market_news(market_train_df, news_train_df):\n    # Fix asset codes (str -> list)\n    news_train_df['assetCodes'] = news_train_df['assetCodes'].str.findall(f\"'([\\w\\./]+)'\")    \n    \n    # Expand assetCodes\n    assetCodes_expanded = list(chain(*news_train_df['assetCodes']))\n    assetCodes_index = news_train_df.index.repeat( news_train_df['assetCodes'].apply(len) )\n\n    assert len(assetCodes_index) == len(assetCodes_expanded)\n    df_assetCodes = pd.DataFrame({'level_0': assetCodes_index, 'assetCode': assetCodes_expanded})\n\n    # Create expandaded news (will repeat every assetCodes' row)\n    news_cols = ['time', 'assetCodes'] + sorted(news_cols_agg.keys())\n    news_train_df_expanded = pd.merge(df_assetCodes, news_train_df[news_cols], left_on='level_0', right_index=True, suffixes=(['','_old']))\n\n    # Free memory\n    del news_train_df, df_assetCodes\n\n    # Aggregate numerical news features\n    news_train_df_aggregated = news_train_df_expanded.groupby(['time', 'assetCode']).agg(news_cols_agg)\n    \n    # Free memory\n    del news_train_df_expanded\n\n    # Convert to float32 to save memory\n    news_train_df_aggregated = news_train_df_aggregated.apply(np.float32)\n\n    # Flat columns\n    news_train_df_aggregated.columns = ['_'.join(col).strip() for col in news_train_df_aggregated.columns.values]\n\n    # Join with train\n    market_train_df = market_train_df.join(news_train_df_aggregated, on=['time', 'assetCode'])\n\n    # Free memory\n    del news_train_df_aggregated\n    \n    return market_train_df",
      "execution_count": 4,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "66792d862b17fa6ff6ebb788043d66bbb3d0d18e"
      },
      "cell_type": "code",
      "source": "#Splitting Data into X and Y and encoding the data\ndef get_xy(market_train_df, news_train_df, le=None):\n    x, le = get_x(market_train_df, news_train_df)\n    y = market_train_df['returnsOpenNextMktres10'].clip(-1, 1)\n    return x, y, le\n\ndef label_encode(series, min_count):\n    vc = series.value_counts()\n    le = {c:i for i, c in enumerate(vc.index[vc >= min_count])}\n    return le\n\ndef get_x(market_train_df, news_train_df, le=None):\n    # Split date into before and after 22h (the time used in train data)\n    # E.g: 2007-03-07 23:26:39+00:00 -> 2007-03-08 00:00:00+00:00 (next day)\n    #      2009-02-25 21:00:50+00:00 -> 2009-02-25 00:00:00+00:00 (current day)\n    news_train_df['time'] = (news_train_df['time'] - np.timedelta64(22,'h')).dt.ceil('1D')\n\n    # Round time of market_train_df to 0h of curret day\n    market_train_df['time'] = market_train_df['time'].dt.floor('1D')\n\n    # Join market and news\n    x = join_market_news(market_train_df, news_train_df)\n    \n    # If not label-encoder... encode assetCode\n    if le is None:\n        le_assetCode = label_encode(x['assetCode'], min_count=10)\n        le_assetName = label_encode(x['assetName'], min_count=5)\n    else:\n        #'unpack' label encoders\n        le_assetCode, le_assetName = le\n        \n    #x['assetCode'] = x['assetCode'].map(le_assetCode).fillna(-1).astype(int)\n    x['assetName'] = x['assetName'].map(le_assetName).fillna(-1).astype(int)\n    # Fix some mixed-type columns\n    for bogus_col in ['marketCommentary_min', 'marketCommentary_max']:\n        x[bogus_col] = x[bogus_col].astype(float)\n    \n    return x, (le_assetCode, le_assetName)",
      "execution_count": 5,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "9c8f80782670e83773c748ae7be03b2ab28fcf89"
      },
      "cell_type": "code",
      "source": "#Pick Data Sample - Try with 30k, 300k, 3M. Setting to 3M for final run.\nmerged_data, _ = get_x(market_train.tail(300000), news_train.tail(600000))\n#print (merged_data.shape)",
      "execution_count": 6,
      "outputs": [
        {
          "output_type": "stream",
          "text": "/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:16: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n  app.launch_new_instance()\n/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:19: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n/opt/conda/lib/python3.6/site-packages/ipykernel_launcher.py:4: SettingWithCopyWarning: \nA value is trying to be set on a copy of a slice from a DataFrame.\nTry using .loc[row_indexer,col_indexer] = value instead\n\nSee the caveats in the documentation: http://pandas.pydata.org/pandas-docs/stable/indexing.html#indexing-view-versus-copy\n  after removing the cwd from sys.path.\n",
          "name": "stderr"
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "a9390593c15c9f4288ba8d69596c8183e8b90a32"
      },
      "cell_type": "code",
      "source": "#Defining the categorical and numerical columns. Categorical Columns will be feeded separately into the NN through cat layers after encoding. \n#Numerical columns will be feeded directly.\n\ncat_cols = ['assetCode', 'assetName']\nnum_cols = ['volume', 'close', 'open', 'returnsClosePrevRaw1', 'returnsOpenPrevRaw1', 'returnsClosePrevMktres1',\n                    'returnsOpenPrevMktres1', 'returnsClosePrevRaw10', 'returnsOpenPrevRaw10', 'returnsClosePrevMktres10',\n                    'returnsOpenPrevMktres10']#, 'urgency_min', 'relevance_mean', 'sentimentNegative_mean', 'sentimentNeutral_mean',\n    #'sentimentPositive_mean', 'noveltyCount24H_mean', 'volumeCounts24H_mean']\n",
      "execution_count": 7,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "07315fb151d66fa3d0044dceea55366a00564668"
      },
      "cell_type": "code",
      "source": "market_train = merged_data\n\ntrain, validate, test = np.split(merged_data.sample(frac=1), [int(.6*len(merged_data)), int(.8*len(merged_data))])\n\n#Debug code\n#print (train)\n#print(validate)\n#print (test)\n\ntrain_indices = train.index.values\nval_indices = validate.index.values\ntest_indices = test.index.values",
      "execution_count": 8,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "567208286b8152229b707593e48c67254ffc24b2"
      },
      "cell_type": "code",
      "source": "#Categorical Columns Processing: Encoding of the categorical variables\n\ndef encode(encoder, x):\n    len_encoder = len(encoder)\n    try:\n        id = encoder[x]\n    except KeyError:\n        id = len_encoder\n    return id\n\nencoders = [{} for cat in cat_cols]\n\nfor i, cat in enumerate(cat_cols):\n    print('encoding %s ...' % cat, end=' ')\n    encoders[i] = {l: id for id, l in enumerate(market_train.loc[train_indices, cat].astype(str).unique())}\n    market_train[cat] = market_train[cat].astype(str).apply(lambda x: encode(encoders[i], x))\n    print('Done')\n\n#Handling the unknown assets: Using +1 for unknown\nembed_sizes = [len(encoder) + 1 for encoder in encoders]",
      "execution_count": 9,
      "outputs": [
        {
          "output_type": "stream",
          "text": "encoding assetCode ... Done\nencoding assetName ... Done\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "5a55a27b6a5e8f04d92291cd8185c9f8fcd3bb89"
      },
      "cell_type": "code",
      "source": "#Numerical Columns Processing: Scaling Numerical Columns\n#Inspired by the Baseline implementation by https://www.kaggle.com/christofhenkel/market-data-nn-baseline\nmarket_train[num_cols] = market_train[num_cols].fillna(0)\n\nscaler = StandardScaler()\nmarket_train[num_cols] = scaler.fit_transform(market_train[num_cols])",
      "execution_count": 10,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "facfbb44ca6c3a6e818c2b11cef42aa5fbcfed0b"
      },
      "cell_type": "code",
      "source": "#Defining the NN Architecture: Using the MSE as a Loss. tanh output activation since confidence is between -1.0 and 1.0\n\ncategorical_inputs = []\nfor cat in cat_cols:\n    categorical_inputs.append(Input(shape=[len(cat_cols)], name=cat))\n\ncategorical_embeddings = []\nfor i, cat in enumerate(cat_cols):\n    categorical_embeddings.append(Embedding(embed_sizes[i], 10)(categorical_inputs[i]))\n\n#categorical_logits = Concatenate()([Flatten()(cat_emb) for cat_emb in categorical_embeddings])\ncategorical_logits = Flatten()(categorical_embeddings[0])\ncategorical_logits = Dense(32,activation='relu')(categorical_logits)\n\nnumerical_inputs = Input(shape=(len(num_cols),), name='num')\nnumerical_logits = numerical_inputs\nnumerical_logits = BatchNormalization()(numerical_logits)\n\nnumerical_logits = Dense(128,activation='relu')(numerical_logits)\nnumerical_logits = Dense(64,activation='relu')(numerical_logits)\n\nlogits = Concatenate()([numerical_logits,categorical_logits])\nlogits = Dense(64,activation='relu')(logits)\nout = Dense(1, activation='tanh')(logits)\n\nmodel = Model(inputs = categorical_inputs + [numerical_inputs], outputs=out)\nmodel.compile(optimizer='adam',loss=mse)\n\n#model.summary()",
      "execution_count": 11,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "49732798c8156671e8dfc4316b0280e04c3a9e11"
      },
      "cell_type": "code",
      "source": "def get_input(market_train, indices):\n    X_num = market_train.loc[indices, num_cols].values\n    X = {'num':X_num}\n    for cat in cat_cols:\n        X[cat] = market_train.loc[indices, cat_cols].values\n    y = (market_train.loc[indices,'returnsOpenNextMktres10'] >= 0).values\n    r = market_train.loc[indices,'returnsOpenNextMktres10'].values\n    u = market_train.loc[indices, 'universe']\n    d = market_train.loc[indices, 'time'].dt.date\n    return X,y,r,u,d\n\n# r, u and d are used to calculate the scoring metric\nX_train,y_train,r_train,u_train,d_train = get_input(market_train, train_indices)\nX_valid,y_valid,r_valid,u_valid,d_valid = get_input(market_train, val_indices)\nX_test,y_test,r_test,u_test,d_test = get_input(market_train, test_indices)",
      "execution_count": 12,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "1fbd233b482d313067bb7704e059b5cb5f011bf5"
      },
      "cell_type": "code",
      "source": "check_point = ModelCheckpoint('model.hdf5',verbose=True, save_best_only=True)\nearly_stop = EarlyStopping(patience=5,verbose=True)\n\n#Regression type fitting\nmodel.fit(X_train,r_train,\n          validation_data=(X_valid,r_valid),\n          epochs=5,\n          verbose=True,\n          callbacks=[early_stop,check_point])",
      "execution_count": 13,
      "outputs": [
        {
          "output_type": "stream",
          "text": "Train on 180000 samples, validate on 60000 samples\nEpoch 1/5\n180000/180000 [==============================] - 11s 62us/step - loss: 0.0048 - val_loss: 0.0041\n\nEpoch 00001: val_loss improved from inf to 0.00410, saving model to model.hdf5\nEpoch 2/5\n180000/180000 [==============================] - 10s 58us/step - loss: 0.0045 - val_loss: 0.0041\n\nEpoch 00002: val_loss improved from 0.00410 to 0.00406, saving model to model.hdf5\nEpoch 3/5\n180000/180000 [==============================] - 10s 58us/step - loss: 0.0045 - val_loss: 0.0041\n\nEpoch 00003: val_loss did not improve from 0.00406\nEpoch 4/5\n180000/180000 [==============================] - 10s 58us/step - loss: 0.0044 - val_loss: 0.0041\n\nEpoch 00004: val_loss did not improve from 0.00406\nEpoch 5/5\n180000/180000 [==============================] - 11s 59us/step - loss: 0.0043 - val_loss: 0.0040\n\nEpoch 00005: val_loss improved from 0.00406 to 0.00397, saving model to model.hdf5\n",
          "name": "stdout"
        },
        {
          "output_type": "execute_result",
          "execution_count": 13,
          "data": {
            "text/plain": "<keras.callbacks.History at 0x7f17251f5940>"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "f2c5dd85e08bba1fbc5a99deb490c785ad6ca63e"
      },
      "cell_type": "code",
      "source": "#plot confidence interval\ny_pred = model.predict(X_test)[:,0]\nplt.hist(r_test, bins=np.linspace(-0.5,0.5,150), alpha=0.3)\nplt.hist(y_pred, bins=np.linspace(-0.5,0.5,150), alpha=0.3, color='darkorange')\nplt.legend(['Ground truth', 'Predicted'])\nplt.xlabel(\"Confidence\")\nplt.ylabel(\"Count\")\nplt.title(\"predicted confidence\")\nplt.show()",
      "execution_count": 14,
      "outputs": [
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 432x288 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "f53f13c06f05b90bb74afb307a591b03cc4f79eb"
      },
      "cell_type": "code",
      "source": "#Print Accuracies\nprint(accuracy_score(model.predict(X_train)[:,0]>0,y_train))\nprint(accuracy_score(model.predict(X_valid)[:,0]>0,y_valid))\nprint(accuracy_score(model.predict(X_test)[:,0]>0,y_test))",
      "execution_count": 15,
      "outputs": [
        {
          "output_type": "stream",
          "text": "0.5921277777777778\n0.5748166666666666\n0.5822333333333334\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "654d8c67bdd7bf2b9d46d5bb02734b0fb3aa1ac0"
      },
      "cell_type": "code",
      "source": "#Print MSEs\nprint(mean_squared_error(model.predict(X_train)[:,0],r_train))\nprint(mean_squared_error(model.predict(X_valid)[:,0],r_valid))\nprint(mean_squared_error(model.predict(X_test)[:,0],r_test))",
      "execution_count": 16,
      "outputs": [
        {
          "output_type": "stream",
          "text": "0.00431734470105933\n0.0039687078765746325\n0.004493260021211155\n",
          "name": "stdout"
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "700fcf5fed2d079828758b7454a8d1dac4a5a77b"
      },
      "cell_type": "code",
      "source": "def error_histogram(y_pred, y_true):\n    plt.style.use(\"seaborn-paper\")\n    error = np.subtract(np.array([float(y) for y in y_pred]), y_true)\n    print(np.std(error))\n    plt.hist(error, bins = np.linspace(-0.25, 0.25, 100), alpha=0.3, color='r')\n    plt.xlabel(\"Error in 10-day return\")\n    plt.ylabel(\"Frequency\")\n    plt.title(\"Error Histogram\")\n    plt.show()",
      "execution_count": 17,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "4c6bf7d93c0aa803a87c6147599742b37a6e8925"
      },
      "cell_type": "code",
      "source": "error_histogram(model.predict(X_test)[:,0],r_test)",
      "execution_count": 18,
      "outputs": [
        {
          "output_type": "stream",
          "text": "0.06700052699418939\n",
          "name": "stdout"
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": "<Figure size 460.8x316.8 with 1 Axes>",
            "image/png": "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\n"
          },
          "metadata": {}
        }
      ]
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "350cda749a634a2c1dd0d78b7e2a922a6d4152e8"
      },
      "cell_type": "code",
      "source": "#Competition Submission\ndays = env.get_prediction_days()",
      "execution_count": 19,
      "outputs": []
    },
    {
      "metadata": {
        "trusted": true,
        "_uuid": "e8fb84e079225a86b03cfec5d8996b261289a794"
      },
      "cell_type": "code",
      "source": "#Make predictions and save file\n\"\"\"\nn_days = 0\npredicted_confidences = np.array([])\nfor (market_obs_df, news_obs_df, predictions_template_df) in days:\n    n_days += 1\n    \n    market_obs_df_updated, _ = get_x(market_obs_df, news_obs_df)\n    \n    for i, cat in enumerate(cat_cols):\n        market_obs_df_updated[cat] = market_obs_df_updated[cat].astype(str).apply(lambda x: encode(encoders[i], x))\n    \n    market_obs_df_updated[num_cols] = market_obs_df_updated[num_cols].fillna(0)\n    market_obs_df_updated[num_cols] = scaler.transform(market_obs_df_updated[num_cols])\n    \n    X_num_test = market_obs_df_updated[num_cols].values\n    X_test = {'num':X_num_test}\n    for cat in cat_cols:\n        X_test[cat] = market_obs_df_updated[cat_cols].values    \n    \n    market_prediction = model.predict(X_test)[:,0]\n    \n    predicted_confidences = np.concatenate((predicted_confidences, market_prediction))\n    \n    preds = pd.DataFrame({'assetCode':market_obs_df['assetCode'],'confidence':market_prediction})\n    # insert predictions to template\n    predictions_template_df = predictions_template_df.merge(preds,how='left').drop('confidenceValue',axis=1).fillna(0).rename(columns={'confidence':'confidenceValue'})\n    predictions_template_df.confidence_value = market_prediction\n    env.predict(predictions_template_df)\n    \nenv.write_submission_file()\n\"\"\"",
      "execution_count": null,
      "outputs": []
    }
  ],
  "metadata": {
    "kernelspec": {
      "display_name": "Python 3",
      "language": "python",
      "name": "python3"
    },
    "language_info": {
      "name": "python",
      "version": "3.6.6",
      "mimetype": "text/x-python",
      "codemirror_mode": {
        "name": "ipython",
        "version": 3
      },
      "pygments_lexer": "ipython3",
      "nbconvert_exporter": "python",
      "file_extension": ".py"
    }
  },
  "nbformat": 4,
  "nbformat_minor": 1
}