109 |
110 |
111 |
--------------------------------------------------------------------------------
/Mercari_0_3875_CV.py:
--------------------------------------------------------------------------------
1 | import os; os.environ['OMP_NUM_THREADS'] = '1'
2 | from contextlib import contextmanager
3 | from functools import partial
4 | from operator import itemgetter
5 | from multiprocessing.pool import ThreadPool
6 | import time
7 | from typing import List, Dict
8 |
9 | import keras as ks
10 | import pandas as pd
11 | import numpy as np
12 | import tensorflow as tf
13 | from sklearn.feature_extraction import DictVectorizer
14 | from sklearn.feature_extraction.text import TfidfVectorizer as Tfidf
15 | from sklearn.pipeline import make_pipeline, make_union, Pipeline
16 | from sklearn.preprocessing import FunctionTransformer, StandardScaler
17 | from sklearn.metrics import mean_squared_log_error
18 | from sklearn.model_selection import KFold
19 |
20 | @contextmanager
21 | def timer(name):
22 | t0 = time.time()
23 | yield
24 | print(f'[{name}] done in {time.time() - t0:.0f} s')
25 |
26 | def preprocess(df: pd.DataFrame) -> pd.DataFrame:
27 | df['name'] = df['name'].fillna('') + ' ' + df['brand_name'].fillna('')
28 | df['text'] = (df['item_description'].fillna('') + ' ' + df['name'] + ' ' + df['category_name'].fillna(''))
29 | return df[['name', 'text', 'shipping', 'item_condition_id']]
30 |
31 | def on_field(f: str, *vec) -> Pipeline:
32 | return make_pipeline(FunctionTransformer(itemgetter(f), validate=False), *vec)
33 |
34 | def to_records(df: pd.DataFrame) -> List[Dict]:
35 | return df.to_dict(orient='records')
36 |
37 | def fit_predict(xs, y_train) -> np.ndarray:
38 | X_train, X_test = xs
39 | config = tf.ConfigProto(
40 | intra_op_parallelism_threads=1, use_per_session_threads=1, inter_op_parallelism_threads=1)
41 | with tf.Session(graph=tf.Graph(), config=config) as sess, timer('fit_predict'):
42 | ks.backend.set_session(sess)
43 | model_in = ks.Input(shape=(X_train.shape[1],), dtype='float32', sparse=True)
44 | out = ks.layers.Dense(192, activation='relu')(model_in)
45 | out = ks.layers.Dense(64, activation='relu')(out)
46 | out = ks.layers.Dense(64, activation='relu')(out)
47 | out = ks.layers.Dense(1)(out)
48 | model = ks.Model(model_in, out)
49 | model.compile(loss='mean_squared_error', optimizer=ks.optimizers.Adam(lr=3e-3))
50 | for i in range(3):
51 | with timer(f'epoch {i + 1}'):
52 | model.fit(x=X_train, y=y_train, batch_size=2**(11 + i), epochs=1, verbose=0)
53 | return model.predict(X_test)[:, 0]
54 |
55 | def main():
56 | vectorizer = make_union(
57 | on_field('name', Tfidf(max_features=100000, token_pattern='\w+')),
58 | on_field('text', Tfidf(max_features=100000, token_pattern='\w+', ngram_range=(1, 2))),
59 | on_field(['shipping', 'item_condition_id'],
60 | FunctionTransformer(to_records, validate=False), DictVectorizer()),
61 | n_jobs=4)
62 | y_scaler = StandardScaler()
63 | with timer('process train'):
64 | train = pd.read_table('../input/train.tsv')
65 | train = train[train['price'] > 0].reset_index(drop=True)
66 | cv = KFold(n_splits=20, shuffle=True, random_state=42)
67 | train_ids, valid_ids = next(cv.split(train))
68 | train, valid = train.iloc[train_ids], train.iloc[valid_ids]
69 | y_train = y_scaler.fit_transform(np.log1p(train['price'].values.reshape(-1, 1)))
70 | X_train = vectorizer.fit_transform(preprocess(train)).astype(np.float32)
71 | print(f'X_train: {X_train.shape} of {X_train.dtype}')
72 | del train
73 | with timer('process valid'):
74 | X_valid = vectorizer.transform(preprocess(valid)).astype(np.float32)
75 | with ThreadPool(processes=4) as pool:
76 | Xb_train, Xb_valid = [x.astype(np.bool).astype(np.float32) for x in [X_train, X_valid]]
77 | xs = [[Xb_train, Xb_valid], [X_train, X_valid]] * 2
78 | y_pred = np.mean(pool.map(partial(fit_predict, y_train=y_train), xs), axis=0)
79 | y_pred = np.expm1(y_scaler.inverse_transform(y_pred.reshape(-1, 1))[:, 0])
80 | print('Valid RMSLE: {:.4f}'.format(np.sqrt(mean_squared_log_error(valid['price'], y_pred))))
81 |
82 | if __name__ == '__main__':
83 | main()
84 |
--------------------------------------------------------------------------------
/similiar_pictures/instructions.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# How to Deploy Keras Models to Production\n",
8 | "\n",
9 | "## Our demo steps\n",
10 | "We'll build a simple Flask app to predict the character that you've drawn in the browser!\n",
11 | "\n",
12 | "- Step 1 - Train our model with Keras\n",
13 | "- Step 2 - Save our model \n",
14 | "- Step 3 - Write our Flask backend to serve our saved model (then look at dep classes (load.py, index.js, index.html)\n",
15 | "- Step 4 - Deploy our code to Google Cloud\n",
16 | "\n",
17 | "![alt text](http://i.imgur.com/UNHn2Xf.png \"Logo Title Text 1\")\n",
18 | "\n",
19 | "## Whats our stack look like\n",
20 | "\n",
21 | "- We use Keras with a Tensorflow backend to train a small 8 layer Convolutional Network to \n",
22 | "recognize handwritten character digits\n",
23 | "- We use Flask as our backend for serving these pretrained models. You could also use Node.js, or any number of JS web frameworks but i wouldn't want to write a complex backend in JS. I <3 python\n",
24 | "\n",
25 | "![alt text](https://image.slidesharecdn.com/flaskpython-130201154928-phpapp01/95/flask-python-10-638.jpg?cb=1359733858 \"Logo Title Text 1\")\n",
26 | "\n",
27 | "## What else is out there? Why use this?\n",
28 | "\n",
29 | "- Because doing this natively is dead simple. However, if you want GPU accelerated inference, these libraries are good options\n",
30 | "- Keras.js https://github.com/transcranial/keras-js Run Keras models in the browser (python backend, JS front-end) with GPU support. Only performs forward-pass inference (so no training in the browser). Uss ndarray (like js version of numpY) and weblas (GPU acceleration) to perform matrix ops\n",
31 | "- WebDNN https://github.com/mil-tokyo/webdnn (but converting the model to its required format requires OS X (Specifically the xcode dependency 'metal' for running GPU operations). Not everyone uses OS X! Although Francois Chollet is a fan and its also faster than this. But this has more examples.\n",
32 | "- NeoCortex https://github.com/scienceai/neocortex the interactive demos are pretty cool but not actively maintained"
33 | ]
34 | },
35 | {
36 | "cell_type": "markdown",
37 | "metadata": {},
38 | "source": [
39 | "## Once our model is trained + saved with train.py, we've written our flask app, use these steps to deploy to google cloud\n",
40 | "\n",
41 | "We can Deploy our app to App Engine using the \n",
42 | "\n",
43 | "`gcloud app deploy`\n",
44 | "\n",
45 | "command. This command automatically builds a container image by using the Container Builder service and then deploys that image to the App Engine flexible environment. The container will include any local modifications that you've made to the runtime image.\n",
46 | "\n",
47 | "Launch your browser and view the app at http://YOUR_PROJECT_ID.appspot.com, by running the following command:\n",
48 | "\n",
49 | "`gcloud app browse`\n",
50 | "\n",
51 | "\n",
52 | "More info here https://cloud.google.com/appengine/docs/flexible/python/quickstart\n",
53 | "\n",
54 | "and this guy has a different and detailed tutorial as well \n",
55 | "\n",
56 | "https://medium.com/google-cloud/keras-inception-v3-on-google-compute-engine-a54918b0058\n",
57 | "\n",
58 | "\n"
59 | ]
60 | },
61 | {
62 | "cell_type": "code",
63 | "execution_count": null,
64 | "metadata": {
65 | "collapsed": true
66 | },
67 | "outputs": [],
68 | "source": []
69 | }
70 | ],
71 | "metadata": {
72 | "kernelspec": {
73 | "display_name": "Python 2",
74 | "language": "python",
75 | "name": "python2"
76 | },
77 | "language_info": {
78 | "codemirror_mode": {
79 | "name": "ipython",
80 | "version": 2
81 | },
82 | "file_extension": ".py",
83 | "mimetype": "text/x-python",
84 | "name": "python",
85 | "nbconvert_exporter": "python",
86 | "pygments_lexer": "ipython2",
87 | "version": "2.7.12"
88 | }
89 | },
90 | "nbformat": 4,
91 | "nbformat_minor": 2
92 | }
93 |
--------------------------------------------------------------------------------
/mercari/Mercari_0_3875_CV.py:
--------------------------------------------------------------------------------
1 | import os; os.environ['OMP_NUM_THREADS'] = '1'
2 | from contextlib import contextmanager
3 | from functools import partial
4 | from operator import itemgetter
5 | from multiprocessing.pool import ThreadPool
6 | import time
7 | from typing import List, Dict
8 |
9 | import keras as ks
10 | import pandas as pd
11 | import numpy as np
12 | import tensorflow as tf
13 | from sklearn.feature_extraction import DictVectorizer
14 | from sklearn.feature_extraction.text import TfidfVectorizer as Tfidf
15 | from sklearn.pipeline import make_pipeline, make_union, Pipeline
16 | from sklearn.preprocessing import FunctionTransformer, StandardScaler
17 | from sklearn.metrics import mean_squared_log_error
18 | from sklearn.model_selection import KFold
19 |
20 | @contextmanager
21 | def timer(name):
22 | t0 = time.time()
23 | yield
24 | print(f'[{name}] done in {time.time() - t0:.0f} s')
25 |
26 | def preprocess(df: pd.DataFrame) -> pd.DataFrame:
27 | df['name'] = df['name'].fillna('') + ' ' + df['brand_name'].fillna('')
28 | df['text'] = (df['item_description'].fillna('') + ' ' + df['name'] + ' ' + df['category_name'].fillna(''))
29 | return df[['name', 'text', 'shipping', 'item_condition_id']]
30 |
31 | def on_field(f: str, *vec) -> Pipeline:
32 | return make_pipeline(FunctionTransformer(itemgetter(f), validate=False), *vec)
33 |
34 | def to_records(df: pd.DataFrame) -> List[Dict]:
35 | return df.to_dict(orient='records')
36 |
37 | def fit_predict(xs, y_train) -> np.ndarray:
38 | X_train, X_test = xs
39 | config = tf.ConfigProto(
40 | intra_op_parallelism_threads=1, use_per_session_threads=1, inter_op_parallelism_threads=1)
41 | with tf.Session(graph=tf.Graph(), config=config) as sess, timer('fit_predict'):
42 | ks.backend.set_session(sess)
43 | model_in = ks.Input(shape=(X_train.shape[1],), dtype='float32', sparse=True)
44 | out = ks.layers.Dense(192, activation='relu')(model_in)
45 | out = ks.layers.Dense(64, activation='relu')(out)
46 | out = ks.layers.Dense(64, activation='relu')(out)
47 | out = ks.layers.Dense(1)(out)
48 | model = ks.Model(model_in, out)
49 | model.compile(loss='mean_squared_error', optimizer=ks.optimizers.Adam(lr=3e-3))
50 | for i in range(3):
51 | with timer(f'epoch {i + 1}'):
52 | model.fit(x=X_train, y=y_train, batch_size=2**(11 + i), epochs=1, verbose=0)
53 | return model.predict(X_test)[:, 0]
54 |
55 | def main():
56 | vectorizer = make_union(
57 | on_field('name', Tfidf(max_features=100000, token_pattern='\w+')),
58 | on_field('text', Tfidf(max_features=100000, token_pattern='\w+', ngram_range=(1, 2))),
59 | on_field(['shipping', 'item_condition_id'],
60 | FunctionTransformer(to_records, validate=False), DictVectorizer()),
61 | n_jobs=4)
62 | y_scaler = StandardScaler()
63 | with timer('process train'):
64 | train = pd.read_table('../input/train.tsv')
65 | train = train[train['price'] > 0].reset_index(drop=True)
66 | cv = KFold(n_splits=20, shuffle=True, random_state=42)
67 | train_ids, valid_ids = next(cv.split(train))
68 | train, valid = train.iloc[train_ids], train.iloc[valid_ids]
69 | y_train = y_scaler.fit_transform(np.log1p(train['price'].values.reshape(-1, 1)))
70 | X_train = vectorizer.fit_transform(preprocess(train)).astype(np.float32)
71 | print(f'X_train: {X_train.shape} of {X_train.dtype}')
72 | del train
73 | with timer('process valid'):
74 | X_valid = vectorizer.transform(preprocess(valid)).astype(np.float32)
75 | with ThreadPool(processes=4) as pool:
76 | Xb_train, Xb_valid = [x.astype(np.bool).astype(np.float32) for x in [X_train, X_valid]]
77 | xs = [[Xb_train, Xb_valid], [X_train, X_valid]] * 2
78 | y_pred = np.mean(pool.map(partial(fit_predict, y_train=y_train), xs), axis=0)
79 | y_pred = np.expm1(y_scaler.inverse_transform(y_pred.reshape(-1, 1))[:, 0])
80 | print('Valid RMSLE: {:.4f}'.format(np.sqrt(mean_squared_log_error(valid['price'], y_pred))))
81 |
82 | if __name__ == '__main__':
83 | main()
84 |
--------------------------------------------------------------------------------
/tips_tricks/5_1_Validation dataset tuning.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {
7 | "collapsed": true
8 | },
9 | "outputs": [],
10 | "source": [
11 | "import pandas as pd\n",
12 | "import numpy as np\n",
13 | "from itertools import combinations\n",
14 | "from catboost import CatBoostClassifier\n",
15 | "from sklearn.model_selection import train_test_split, KFold\n",
16 | "from sklearn.metrics import roc_auc_score\n",
17 | "import warnings\n",
18 | "warnings.filterwarnings(\"ignore\")\n",
19 | "np.random.seed(42)"
20 | ]
21 | },
22 | {
23 | "cell_type": "code",
24 | "execution_count": 2,
25 | "metadata": {
26 | "collapsed": true
27 | },
28 | "outputs": [],
29 | "source": [
30 | "df = pd.read_csv('train.csv')\n",
31 | "y = df.target\n",
32 | "\n",
33 | "df.drop(['ID', 'target'], axis=1, inplace=True)\n",
34 | "df.fillna(-9999, inplace=True)\n",
35 | "cat_features_ids = np.where(df.apply(pd.Series.nunique) < 30000)[0].tolist()"
36 | ]
37 | },
38 | {
39 | "cell_type": "code",
40 | "execution_count": 3,
41 | "metadata": {
42 | "collapsed": true
43 | },
44 | "outputs": [],
45 | "source": [
46 | "train, test, y_train, y_test = train_test_split(df, y, test_size = 0.1,random_state = 42)\n",
47 | "train, val, y_train, y_val = train_test_split(train, y_train, test_size = 0.25)"
48 | ]
49 | },
50 | {
51 | "cell_type": "code",
52 | "execution_count": 4,
53 | "metadata": {
54 | "scrolled": false
55 | },
56 | "outputs": [
57 | {
58 | "name": "stdout",
59 | "output_type": "stream",
60 | "text": [
61 | "Roc-auc score with Catboost: 0.7841281938499387\n"
62 | ]
63 | }
64 | ],
65 | "source": [
66 | "clf = CatBoostClassifier(learning_rate=0.1, iterations=100, random_seed=42, eval_metric='AUC', logging_level='Silent')\n",
67 | "clf.fit(train, y_train, cat_features=cat_features_ids, eval_set=(val, y_val))\n",
68 | "prediction = clf.predict_proba(test)\n",
69 | "print('Roc-auc score with Catboost:',roc_auc_score(y_test, prediction[:, 1]))"
70 | ]
71 | },
72 | {
73 | "cell_type": "code",
74 | "execution_count": 5,
75 | "metadata": {},
76 | "outputs": [
77 | {
78 | "name": "stdout",
79 | "output_type": "stream",
80 | "text": [
81 | "Roc-auc score with Catboost: 0.7930162585925847\n"
82 | ]
83 | }
84 | ],
85 | "source": [
86 | "kfold = KFold(n_splits=10)\n",
87 | "pred = []\n",
88 | "train, test, y_train, y_test = train_test_split(df, y, test_size = 0.1,random_state = 42)\n",
89 | "for train_ind, test_ind in kfold.split(train):\n",
90 | " train_val, test_val, y_train_val, y_test_val = train.iloc[train_ind, :], train.iloc[test_ind, :],\\\n",
91 | " y_train.iloc[train_ind], y_train.iloc[test_ind]\n",
92 | " clf.fit(train_val, y_train_val, cat_features=cat_features_ids, eval_set=(test_val, y_test_val))\n",
93 | " prediction = clf.predict_proba(test)\n",
94 | " pred.append(\n",
95 | " prediction[:, 1]\n",
96 | " )\n",
97 | " \n",
98 | "\n",
99 | "print('Roc-auc score with Catboost:',roc_auc_score(y_test, np.mean(pred, axis = 0)))"
100 | ]
101 | },
102 | {
103 | "cell_type": "code",
104 | "execution_count": null,
105 | "metadata": {
106 | "collapsed": true
107 | },
108 | "outputs": [],
109 | "source": []
110 | }
111 | ],
112 | "metadata": {
113 | "kernelspec": {
114 | "display_name": "Python 3",
115 | "language": "python",
116 | "name": "python3"
117 | },
118 | "language_info": {
119 | "codemirror_mode": {
120 | "name": "ipython",
121 | "version": 3
122 | },
123 | "file_extension": ".py",
124 | "mimetype": "text/x-python",
125 | "name": "python",
126 | "nbconvert_exporter": "python",
127 | "pygments_lexer": "ipython3",
128 | "version": "3.6.1"
129 | }
130 | },
131 | "nbformat": 4,
132 | "nbformat_minor": 2
133 | }
134 |
--------------------------------------------------------------------------------
/Hands-on Reinforcement Learning with Python, Second Edition_new chapters/01. Fundamentals of Reinforcement Learning/1.05. How RL differs from other ML paradigms?.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# How RL differs from other ML paradigms?\n",
8 | "Machine Learning (ML) can be categorized into three types:\n",
9 | "\n",
10 | "* Supervised Learning\n",
11 | "* Unsupervised Learning\n",
12 | "* Reinforcement Learning\n",
13 | "\n",
14 | "In supervised learning, the machine learns from the training data. The training data consists of labeled pair of inputs and outputs. So, we train the model (agent) using the given training data in such a way that the model can generalize its learning to new unseen data. It is called supervised learning because training data acts as a supervisor since it has a labeled pair of input and outputs and it guides the model in learning the given task.\n",
15 | "\n",
16 | "Now, let's understand the difference between supervised and reinforcement learning with an example. Consider the dog analogy we discussed earlier in the chapter, in supervised learning, to teach the dog to catch a ball, we will teach it explicitly by specifying turn left, go right, move forward seven steps, catch the ball, and so on in the form of training data. But in RL we just throw a ball, and every time the dog catches the ball, we give it a cookie (reward). So the dog will learn to catch the ball while trying to maximize the cookie (reward) it can get. \n",
17 | "\n",
18 | "Let's consider one more example. Say, we want to train the model to play the chess game using supervised learning. In that case, we will have training data which includes all the moves that can be played by the player in each state along with the labels indicating whether it is a good move or not. Then, we will train the model to learn from this training data. Whereas in the case of reinforcement learning, our agent will not be given any sort of training data, instead we just give a reward to the agent for each action it performs. Then the agent will learn by interacting with the environment and based on the reward it gets. \n",
19 | "\n",
20 | "Similar to supervised learning, in unsupervised learning, we train the model (agent) based on the training data. But in the case of unsupervised learning, the training data does not contain any labels, that is, it consists of only inputs and not output. The goal of unsupervised learning is to determine the hidden pattern in the input. There is a common misconception that reinforcement learning is a kind of unsupervised learning but it is not. In unsupervised learning, the model learns the hidden structure whereas in reinforcement learning the model learns by maximizing the reward.\n",
21 | "\n",
22 | "For instance, consider we are building a movie recommendation system and say we want to recommend a new movie to the user, then in the case of unsupervised learning, we can analyse the similar movies related to the movies the user has viewed before and recommend the new movies to the user, whereas, in case of reinforcement learning, the agent constantly receives feedback from the user based on the reward, understand his movie preferences, and builds a knowledge base on top of it and suggests new movies to the user.\n",
23 | "\n",
24 | "Thus, we can say that in both supervised and unsupervised learning the model (agent) learns based on the given training dataset whereas in reinforcement learning agent learns by directly interacting with the environment. Thus reinforcement learning is essentially an interaction between the agent and its environment. "
25 | ]
26 | }
27 | ],
28 | "metadata": {
29 | "kernelspec": {
30 | "display_name": "Python 3",
31 | "language": "python",
32 | "name": "python3"
33 | },
34 | "language_info": {
35 | "codemirror_mode": {
36 | "name": "ipython",
37 | "version": 3
38 | },
39 | "file_extension": ".py",
40 | "mimetype": "text/x-python",
41 | "name": "python",
42 | "nbconvert_exporter": "python",
43 | "pygments_lexer": "ipython3",
44 | "version": "3.6.9"
45 | }
46 | },
47 | "nbformat": 4,
48 | "nbformat_minor": 2
49 | }
50 |
--------------------------------------------------------------------------------
/big_data_for_engineers/spark_shortest_path.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "code",
5 | "execution_count": 1,
6 | "metadata": {
7 | "collapsed": true
8 | },
9 | "outputs": [],
10 | "source": [
11 | "from pyspark import SparkConf, SparkContext\n",
12 | "sc = SparkContext(conf=SparkConf().setAppName(\"MyApp\").setMaster(\"local[8]\"))"
13 | ]
14 | },
15 | {
16 | "cell_type": "code",
17 | "execution_count": 2,
18 | "metadata": {
19 | "collapsed": true
20 | },
21 | "outputs": [],
22 | "source": [
23 | "def parse_edge(s):\n",
24 | " u, f = s.split(\"\\t\")\n",
25 | " return (int(u), int(f))\n",
26 | "\n",
27 | "def step(i): \n",
28 | " pv, pd, nv = i[0], i[1][0], i[1][1] \n",
29 | " return (nv, pd + 1)\n",
30 | "\n",
31 | "def complete(item): \n",
32 | " v, od, nd = item[0], item[1][0], item[1][1]\n",
33 | " return (v, od if od is not None else nd)\n",
34 | "\n",
35 | "def update_path(x):\n",
36 | " v, (old_path, (dist, new_v)) = x\n",
37 | " return new_v, old_path + (new_v,)"
38 | ]
39 | },
40 | {
41 | "cell_type": "code",
42 | "execution_count": 3,
43 | "metadata": {
44 | "collapsed": true
45 | },
46 | "outputs": [],
47 | "source": [
48 | "def shortest_path(v_from, v_to, dataset_path, numPartitions=10):\n",
49 | " edges = sc.textFile(dataset_path, numPartitions).map(parse_edge).cache()\n",
50 | " forward_edges = edges.map(lambda e: (e[1], e[0])).partitionBy(numPartitions).cache()\n",
51 | " \n",
52 | " d = 0\n",
53 | " distances = sc.parallelize([(v_from, d)]).partitionBy(numPartitions)\n",
54 | " paths = sc.parallelize([(v_from, (v_from,))])\n",
55 | " \n",
56 | " while True:\n",
57 | " candidates = distances.join(forward_edges, numPartitions).map(step)\n",
58 | " paths = paths.join(forward_edges).map(lambda x: (x[1][1], x[1][0] + (x[1][1],))).union(paths).distinct().cache()\n",
59 | " new_distances = distances.fullOuterJoin(candidates).map(complete).distinct().cache()\n",
60 | " count = new_distances.filter(lambda i: i[1] == d + 1).count() \n",
61 | " if count > 0:\n",
62 | " d += 1 \n",
63 | " distances = new_distances\n",
64 | " # print \"d = {}, count = {}\".format(d, count)\n",
65 | " else:\n",
66 | " break\n",
67 | " \n",
68 | " result = paths.filter(lambda x: x[1][0] == v_from and x[1][-1] == v_to).collect()\n",
69 | " return ','.join(map(str, sorted(result, key=lambda x: len(x[1]))[0][1]))"
70 | ]
71 | },
72 | {
73 | "cell_type": "code",
74 | "execution_count": 5,
75 | "metadata": {},
76 | "outputs": [
77 | {
78 | "name": "stdout",
79 | "output_type": "stream",
80 | "text": [
81 | "CPU times: user 3.58 s, sys: 1.83 s, total: 5.41 s\n",
82 | "Wall time: 11min 23s\n"
83 | ]
84 | },
85 | {
86 | "data": {
87 | "text/plain": [
88 | "'12,422,53,52,107,20,23,274,34'"
89 | ]
90 | },
91 | "execution_count": 5,
92 | "metadata": {},
93 | "output_type": "execute_result"
94 | }
95 | ],
96 | "source": [
97 | "%%time\n",
98 | "shortest_path(12, 34, \"/data/twitter/twitter_sample.txt\")"
99 | ]
100 | },
101 | {
102 | "cell_type": "code",
103 | "execution_count": null,
104 | "metadata": {
105 | "collapsed": true
106 | },
107 | "outputs": [],
108 | "source": []
109 | }
110 | ],
111 | "metadata": {
112 | "kernelspec": {
113 | "display_name": "Python 2",
114 | "language": "python",
115 | "name": "python2"
116 | },
117 | "language_info": {
118 | "codemirror_mode": {
119 | "name": "ipython",
120 | "version": 2
121 | },
122 | "file_extension": ".py",
123 | "mimetype": "text/x-python",
124 | "name": "python",
125 | "nbconvert_exporter": "python",
126 | "pygments_lexer": "ipython2",
127 | "version": "2.7.12"
128 | }
129 | },
130 | "nbformat": 4,
131 | "nbformat_minor": 2
132 | }
133 |
--------------------------------------------------------------------------------
/Hands-on Reinforcement Learning with Python, Second Edition_new chapters/02. A Guide to the Gym Toolkit/2.05. Cart Pole Balancing with Random Policy.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Cart Pole Balancing with Random Policy\n",
8 | "\n",
9 | "Let's create an agent with the random policy, that is, we create the agent that selects the random action in the environment and tries to balance the pole. The agent receives +1 reward every time the pole stands straight up on the cart. We will generate over 100 episodes and we will see the return (sum of rewards) obtained over each episode. Let's learn this step by step.\n",
10 | "\n",
11 | "First, create our cart pole environment:"
12 | ]
13 | },
14 | {
15 | "cell_type": "code",
16 | "execution_count": 2,
17 | "metadata": {},
18 | "outputs": [],
19 | "source": [
20 | "import gym\n",
21 | "env = gym.make('CartPole-v0')"
22 | ]
23 | },
24 | {
25 | "cell_type": "markdown",
26 | "metadata": {},
27 | "source": [
28 | "\n",
29 | "Set the number of episodes and number of time steps in the episode:\n"
30 | ]
31 | },
32 | {
33 | "cell_type": "code",
34 | "execution_count": 3,
35 | "metadata": {},
36 | "outputs": [],
37 | "source": [
38 | "num_episodes = 100\n",
39 | "num_timesteps = 50"
40 | ]
41 | },
42 | {
43 | "cell_type": "code",
44 | "execution_count": 4,
45 | "metadata": {},
46 | "outputs": [
47 | {
48 | "name": "stdout",
49 | "output_type": "stream",
50 | "text": [
51 | "Episode: 0, Return: 23.0\n",
52 | "Episode: 10, Return: 12.0\n",
53 | "Episode: 20, Return: 23.0\n",
54 | "Episode: 30, Return: 15.0\n",
55 | "Episode: 40, Return: 19.0\n",
56 | "Episode: 50, Return: 10.0\n",
57 | "Episode: 60, Return: 16.0\n",
58 | "Episode: 70, Return: 10.0\n",
59 | "Episode: 80, Return: 22.0\n",
60 | "Episode: 90, Return: 38.0\n"
61 | ]
62 | }
63 | ],
64 | "source": [
65 | "#for each episode\n",
66 | "for i in range(num_episodes):\n",
67 | " \n",
68 | " #set the Return to 0\n",
69 | " Return = 0\n",
70 | " #initialize the state by resetting the environment\n",
71 | " state = env.reset()\n",
72 | " \n",
73 | " #for each step in the episode\n",
74 | " for t in range(num_timesteps):\n",
75 | " #render the environment\n",
76 | " env.render()\n",
77 | " \n",
78 | " #randomly select an action by sampling from the environment\n",
79 | " random_action = env.action_space.sample()\n",
80 | " \n",
81 | " #perform the randomly selected action\n",
82 | " next_state, reward, done, info = env.step(random_action)\n",
83 | "\n",
84 | " #update the return\n",
85 | " Return = Return + reward\n",
86 | "\n",
87 | " #if the next state is a terminal state then end the episode\n",
88 | " if done:\n",
89 | " break\n",
90 | " #for every 10 episodes, print the return (sum of rewards)\n",
91 | " if i%10==0:\n",
92 | " print('Episode: {}, Return: {}'.format(i, Return))\n",
93 | " "
94 | ]
95 | },
96 | {
97 | "cell_type": "markdown",
98 | "metadata": {},
99 | "source": [
100 | "Close the environment:"
101 | ]
102 | },
103 | {
104 | "cell_type": "code",
105 | "execution_count": 5,
106 | "metadata": {},
107 | "outputs": [],
108 | "source": [
109 | "env.close()"
110 | ]
111 | }
112 | ],
113 | "metadata": {
114 | "kernelspec": {
115 | "display_name": "Python 3",
116 | "language": "python",
117 | "name": "python3"
118 | },
119 | "language_info": {
120 | "codemirror_mode": {
121 | "name": "ipython",
122 | "version": 3
123 | },
124 | "file_extension": ".py",
125 | "mimetype": "text/x-python",
126 | "name": "python",
127 | "nbconvert_exporter": "python",
128 | "pygments_lexer": "ipython3",
129 | "version": "3.6.9"
130 | }
131 | },
132 | "nbformat": 4,
133 | "nbformat_minor": 2
134 | }
135 |
--------------------------------------------------------------------------------
/Hands-on Reinforcement Learning with Python, Second Edition_new chapters/06. Case Study: The MAB Problem/6.03. Epsilon-Greedy.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Epsilon-greedy\n",
8 | "\n",
9 | "We already learned about the epsilon-greedy algorithm in the previous chapters. With the epsilon-greedy, we select the best arm with probability 1-epsilon and we select the random arm with probability epsilon. Let's take a simple example and learn how we find the best arm exactly with the epsilon-greedy method in more detail. \n",
10 | "\n",
11 | "Say, we have two arms - arm 1 and arm 2. Suppose, with arm 1 we win the game 80% of the time and with arm 2 we win the game with 20% of the time. So, we can say that arm 1 is the best arm as it makes us win the game 80% of the time. Now, let's learn how to find this with the epsilon-greedy method. \n",
12 | "\n",
13 | "First, we initialize the `count` - number of times the arm is pulled, `sum_rewards` - the sum of rewards obtained from pulling the arm, `Q`- average reward obtained by pulling the arm as shown below:\n",
14 | "\n",
15 | "\n",
16 | "\n",
17 | "\n",
18 | "\n",
19 | "\n",
20 | "## Round 1:\n",
21 | "\n",
22 | "Say, in round 1 of the game, we select the random arm with probability epsilon, suppose we randomly pull the arm 1 and observe the reward. Let the reward obtained by pulling the arm 1 be 1. So, we update our table with `count` of arm 1 to 1, `sum_rewards` of arm 1 to 1 and thus the average reward `Q` of the arm 1 after round 1 will be 1 as shown below:\n",
23 | "\n",
24 | "\n",
25 | "\n",
26 | "\n",
27 | "\n",
28 | "## Round 2:\n",
29 | "\n",
30 | "Say, in round 2, we select the best arm with probability 1-epsilon. The best arm is the one which has a maximum average reward. So, we check our table as which arm has the maximum average reward, since arm 1 has the maximum average reward, we pull the arm 1 and observe the reward and let the reward obtained from pulling the arm 1 be 1. So, we update our table with `count` of arm 1 to 2, `sum_rewards` of arm 1 to 2 and thus the average reward `Q` of the arm 1 after round 2 will be 1 as shown below:\n",
31 | "\n",
32 | "\n",
33 | "\n",
34 | "\n",
35 | "## Round 3:\n",
36 | "\n",
37 | "Say, in round 3, we select the random arm with probability epsilon, suppose we randomly pull the arm 2 and observe the reward. Let the reward obtained by pulling the arm 2 be 0. So, we update our table with `count` of arm 2 to 1, `sum_rewards` of arm 2 to 0 and thus the average reward `Q` of the arm 2 after round 3 will be 0 as shown below:\n",
38 | "\n",
39 | "\n",
40 | "\n",
41 | "## Round 4:\n",
42 | "\n",
43 | "Say, in round 4, we select the best arm with probability 1-epsilon. So, we pull arm 1 since it has a maximum average reward. Let the reward obtained by pulling arm 1 be 0 this time. Now, we update our table with `count` of arm 1 to 3, `sum_rewards` of arm 2 to 2 and thus the average reward `Q` of the arm 1 after round 4 will be 0.66 as shown below:\n",
44 | "\n",
45 | "\n",
46 | "\n",
47 | "\n",
48 | "We repeat this process for several numbers of rounds, that is, for several rounds of the game, we pull the best arm with probability 1-epsilon and we pull the random arm with the probability epsilon. The updated table after some 100 rounds of game is shown below:\n",
49 | "\n",
50 | "\n",
51 | "\n",
52 | "\n",
53 | "From the above table, we can conclude that arm 1 is the best arm since it has the maximum average reward. \n"
54 | ]
55 | }
56 | ],
57 | "metadata": {
58 | "kernelspec": {
59 | "display_name": "Python 3",
60 | "language": "python",
61 | "name": "python3"
62 | },
63 | "language_info": {
64 | "codemirror_mode": {
65 | "name": "ipython",
66 | "version": 3
67 | },
68 | "file_extension": ".py",
69 | "mimetype": "text/x-python",
70 | "name": "python",
71 | "nbconvert_exporter": "python",
72 | "pygments_lexer": "ipython3",
73 | "version": "3.6.9"
74 | }
75 | },
76 | "nbformat": 4,
77 | "nbformat_minor": 2
78 | }
79 |
--------------------------------------------------------------------------------
/Hands-on Reinforcement Learning with Python, Second Edition_new chapters/01. Fundamentals of Reinforcement Learning/1.11. Different Types of Environments.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Different types of environments\n",
8 | "\n",
9 | "We learned that the environment is the world of the agent and the agent lives/stays within the environment. We can categorize the environment into different types as follows:\n",
10 | "\n",
11 | "## Deterministic and Stochastic environment\n",
12 | "\n",
13 | "__Deterministic environment__ - In a deterministic environment, we can be sure that when an agent performs an action $a$ in the state $s$ then it always reaches the state $s'$ exactly. For example, let's consider our grid world environment. Say the agent is in state A when we perform action down in the state A we always reach the state D and so it is called deterministic environment:\n",
14 | "\n",
15 | "\n",
16 | "\n",
17 | "\n",
18 | "\n",
19 | "__Stochastic environment__ - In a stochastic environment, we cannot say that by performing some action $a$ in the state $s$ the agent always reaches the state $s'$ exactly because there will be some randomness associated with the stochastic environment. For example, let's suppose our grid world environment is a stochastic environment. Say our agent is in state A, now if we perform action down in the state A then the agent doesn't always reach the state D instead it reaches the state D for 70% of the time and the state B for 30 % of the time. That is, if we perform action down in the state A then the agent reaches the state D with 70% probability and the state B with 30% probability as shown below:\n",
20 | "\n",
21 | "\n",
22 | "\n",
23 | "\n",
24 | "## Discrete and continuous environment \n",
25 | "\n",
26 | "__Discrete Environment__ - When the action space of the environment is discrete then our environment is called a discrete environment. For instance, in the grid world environment, we have discrete action space which includes actions such as [up, down, left, right] and thus our grid world environment is called the discrete environment. \n",
27 | "\n",
28 | "__Continuous environment__ - When the action space of the environment is continuous then our environment is called a continuous environment. For instance, suppose, we are training an agent to drive a car then our action space will be continuous with several continuous actions such as speed in which we need to drive the car, the number of degrees we need to rotate the wheel and so on. In such a case where our action space of the environment is continuous, it is called continuous environment. \n",
29 | "\n",
30 | "## Episodic and non-episodic environment \n",
31 | "\n",
32 | "__Episodic environment__ - In an episodic environment, an agent's current action will not affect future action and thus the episodic environment is also called the non-sequential environment. \n",
33 | "\n",
34 | "__Non-episodic environment__ - In a non-episodic environment, an agent's current action will affect future action and thus the non-episodic environment is also called the sequential environment. Example: The chessboard is a sequential environment since the agent's current action will affect future action in a chess game.\n",
35 | "\n",
36 | "## Single and multi-agent environment\n",
37 | "\n",
38 | "__Single-agent environment__ - When our environment consists of only a single agent then it is called a single-agent environment. \n",
39 | "\n",
40 | "__Multi-agent environment__ - When our environment consists of multiple agents then it is called a multi-agent environment. "
41 | ]
42 | }
43 | ],
44 | "metadata": {
45 | "kernelspec": {
46 | "display_name": "Python 3",
47 | "language": "python",
48 | "name": "python3"
49 | },
50 | "language_info": {
51 | "codemirror_mode": {
52 | "name": "ipython",
53 | "version": 3
54 | },
55 | "file_extension": ".py",
56 | "mimetype": "text/x-python",
57 | "name": "python",
58 | "nbconvert_exporter": "python",
59 | "pygments_lexer": "ipython3",
60 | "version": "3.6.9"
61 | }
62 | },
63 | "nbformat": 4,
64 | "nbformat_minor": 2
65 | }
66 |
--------------------------------------------------------------------------------
/recursion-cellular-image-classification/data_loader.py:
--------------------------------------------------------------------------------
1 | import pandas as pd
2 | from sklearn.model_selection import train_test_split
3 | from PIL import Image
4 | from torchvision import transforms as T
5 | import torch.utils.data as D
6 | import torch
7 | from config import _get_default_config
8 | from albumentations import (
9 | HorizontalFlip, IAAPerspective, ShiftScaleRotate, CLAHE, RandomRotate90,
10 | Transpose, ShiftScaleRotate, Blur, OpticalDistortion, GridDistortion, HueSaturationValue,
11 | IAAAdditiveGaussianNoise, GaussNoise, MotionBlur, MedianBlur, RandomBrightnessContrast, IAAPiecewiseAffine,
12 | IAASharpen, IAAEmboss, Flip, OneOf, Compose, RandomCrop, RandomSizedCrop, CenterCrop
13 | )
14 |
15 | path_data = '/mnt/ssd1/datasets/Recursion_class'
16 | config = _get_default_config()
17 | BATCH_SIZE = config.batch_size
18 |
19 |
20 | def strong_aug(p=.3):
21 | return Compose([
22 | # RandomRotate90(),
23 | Flip(), # good
24 | # Transpose(),
25 | # OneOf([
26 | # IAAAdditiveGaussianNoise(),
27 | # GaussNoise(),
28 | # ], p=0.2),
29 | # OneOf([
30 | # RandomCrop(384, 384),
31 | # ], p=0.2),
32 | ShiftScaleRotate(shift_limit=0.0625, scale_limit=0.2, rotate_limit=90, p=0.2), # good
33 | # OneOf([
34 | # OpticalDistortion(p=0.3),
35 | # GridDistortion(p=.1),
36 | # IAAPiecewiseAffine(p=0.3),
37 | # ], p=0.2),
38 | # OneOf([
39 | # IAASharpen(),
40 | # IAAEmboss(),
41 | # RandomBrightnessContrast(),
42 | # ], p=0.3),
43 | ], p=p)
44 |
45 |
46 | aug = strong_aug()
47 |
48 | transform = T.Compose([
49 | T.Normalize((5.845, 15.567, 10.105, 9.964, 5.576, 9.067),
50 | (6.905, 12.556, 5.584, 7.445, 4.668, 4.910))])
51 |
52 |
53 | class ImagesDS(D.Dataset):
54 | def __init__(self, df, img_dir, mode='train', site=config.site, channels=[1, 2, 3, 4, 5, 6]):
55 | self.records = df.to_records(index=False)
56 | self.channels = channels
57 | self.site = site
58 | self.mode = mode
59 | self.img_dir = img_dir
60 | self.len = df.shape[0]
61 |
62 | @staticmethod
63 | def _load_img_as_tensor(file_name):
64 | with Image.open(file_name) as img:
65 | return T.ToTensor()(img)
66 |
67 | def _get_img_path(self, index, channel):
68 | experiment, well, plate = self.records[index].experiment, self.records[index].well, self.records[index].plate
69 | return '/'.join([self.img_dir, experiment, f'Plate{plate}', f'{well}_s{self.site}_w{channel}.png'])
70 |
71 | def __getitem__(self, index):
72 | paths = [self._get_img_path(index, ch) for ch in self.channels]
73 | img = torch.cat([self._load_img_as_tensor(img_path) for img_path in paths])
74 | if self.mode == 'train':
75 | return aug(image=img.cpu().detach().numpy())['image'], int(self.records[index].sirna)
76 | # return img, int(self.records[index].sirna)
77 |
78 | else:
79 | return img, self.records[index].id_code
80 |
81 | def __len__(self):
82 | return self.len
83 |
84 |
85 | df = pd.read_csv(path_data+'/train.csv', engine='python')
86 |
87 |
88 | df_train, df_val = train_test_split(df, test_size=0.1, stratify=df.sirna, random_state=config.random_seed)
89 |
90 | if not config.all:
91 |
92 | col_name = df.columns.tolist()
93 | df_train = pd.DataFrame([x for x in df_train.values if config.experiment in x[0]])
94 | df_val = pd.DataFrame([x for x in df_val.values if config.experiment in x[0]])
95 | df_train.columns = col_name
96 | df_val.columns = col_name
97 |
98 | df_test = pd.read_csv(path_data+'/test.csv', engine='python')
99 |
100 | ds = ImagesDS(df_train, path_data, mode='train')
101 | ds_val = ImagesDS(df_val, path_data, mode='train')
102 | ds_test = ImagesDS(df_test, path_data, mode='test')
103 |
104 | loader = D.DataLoader(ds, batch_size=BATCH_SIZE, shuffle=True, num_workers=8)
105 | val_loader = D.DataLoader(ds_val, batch_size=BATCH_SIZE, shuffle=True, num_workers=8)
106 | tloader = D.DataLoader(ds_test, batch_size=BATCH_SIZE, shuffle=False, num_workers=8)
--------------------------------------------------------------------------------
/Keras starter with bagging (LB: 1120.596).py:
--------------------------------------------------------------------------------
1 | import numpy as np
2 |
3 | import pandas as pd
4 | import subprocess
5 | from scipy.sparse import csr_matrix, hstack
6 | from sklearn.metrics import mean_absolute_error
7 | from sklearn.preprocessing import StandardScaler
8 | from sklearn.cross_validation import KFold
9 | from keras.models import Sequential
10 | from keras.layers import Dense, Dropout, Activation
11 | from keras.layers.advanced_activations import PReLU
12 | def batch_generator(X, y, batch_size, shuffle):
13 | #chenglong code for fiting from generator (https://www.kaggle.com/c/talkingdata-mobile-user-demographics/forums/t/22567/neural-network-for-sparse-matrices)
14 | number_of_batches = np.ceil(X.shape[0]/batch_size)
15 | counter = 0
16 | sample_index = np.arange(X.shape[0])
17 | if shuffle:
18 | np.random.shuffle(sample_index)
19 | while True:
20 | batch_index = sample_index[batch_size*counter:batch_size*(counter+1)]
21 | X_batch = X[batch_index,:].toarray()
22 | y_batch = y[batch_index]
23 | counter += 1
24 | yield X_batch, y_batch
25 | if (counter == number_of_batches):
26 | if shuffle:
27 | np.random.shuffle(sample_index)
28 | counter = 0
29 | def batch_generatorp(X, batch_size, shuffle):
30 | number_of_batches = X.shape[0] / np.ceil(X.shape[0]/batch_size)
31 | counter = 0
32 | sample_index = np.arange(X.shape[0])
33 | while True:
34 | batch_index = sample_index[batch_size * counter:batch_size * (counter + 1)]
35 | X_batch = X[batch_index, :].toarray()
36 | counter += 1
37 | yield X_batch
38 | if (counter == number_of_batches):
39 | counter = 0
40 | ## read data
41 | train = pd.read_csv('train.csv')
42 | test = pd.read_csv('test.csv')
43 |
44 | ## set test loss to NaN
45 | test['loss'] = np.nan
46 |
47 | ## response and IDs
48 | y = train['loss'].values
49 | id_train = train['id'].values
50 | id_test = test['id'].values
51 | ## stack train test
52 | ntrain = train.shape[0]
53 | tr_te = pd.concat((train, test), axis = 0)
54 | ## Preprocessing and transforming to sparse data
55 | sparse_data = []
56 |
57 | f_cat = [f for f in tr_te.columns if 'cat' in f]
58 | for f in f_cat:
59 | dummy = pd.get_dummies(tr_te[f].astype('category'))
60 | tmp = csr_matrix(dummy)
61 | sparse_data.append(tmp)
62 |
63 | f_num = [f for f in tr_te.columns if 'cont' in f]
64 | scaler = StandardScaler()
65 | tmp = csr_matrix(scaler.fit_transform(tr_te[f_num]))
66 | sparse_data.append(tmp)
67 |
68 | del(tr_te, train, test)
69 | ## sparse train and test data
70 | xtr_te = hstack(sparse_data, format = 'csr')
71 | xtrain = xtr_te[:ntrain, :]
72 | xtest = xtr_te[ntrain:, :]
73 |
74 | print('Dim train', xtrain.shape)
75 | print('Dim test', xtest.shape)
76 |
77 | del(xtr_te, sparse_data, tmp)
78 | ## neural net
79 | def nn_model():
80 | model = Sequential()
81 | model.add(Dense(400, input_dim = xtrain.shape[1], init = 'he_normal'))
82 | model.add(PReLU())
83 | model.add(Dropout(0.4))
84 | model.add(Dense(200, init = 'he_normal'))
85 | model.add(PReLU())
86 | model.add(Dropout(0.2))
87 | model.add(Dense(1, init = 'he_normal'))
88 | model.compile(loss = 'mae', optimizer = 'adadelta')
89 | return(model)
90 | ## cv-folds
91 | nfolds = 5
92 | folds = KFold(len(y), n_folds = nfolds, shuffle = True)
93 | ## train models
94 | i = 0
95 | nbags = 5
96 | nepochs = 55
97 | pred_oob = np.zeros(xtrain.shape[0])
98 | pred_test = np.zeros(xtest.shape[0])
99 |
100 | for (inTr, inTe) in folds:
101 | xtr = xtrain[inTr]
102 | ytr = y[inTr]
103 | xte = xtrain[inTe]
104 | yte = y[inTe]
105 | pred = np.zeros(xte.shape[0])
106 | for j in range(nbags):
107 | model = nn_model()
108 | fit = model.fit_generator(generator = batch_generator(xtr, ytr, 128, True),
109 | nb_epoch = nepochs,
110 | samples_per_epoch = xtr.shape[0],
111 | verbose = 0)
112 | pred += model.predict_generator(generator = batch_generatorp(xte, 800, False), val_samples = xte.shape[0])[:,0]
113 | pred_test += model.predict_generator(generator = batch_generatorp(xtest, 800, False), val_samples = xtest.shape[0])[:,0]
114 | pred /= nbags
115 | pred_oob[inTe] = pred
116 | score = mean_absolute_error(yte, pred)
117 | i += 1
118 | print('Fold ', i, '- MAE:', score)
119 |
120 | print('Total - MAE:', mean_absolute_error(y, pred_oob))
121 | ## train predictions
122 | df = pd.DataFrame({'id': id_train, 'loss': pred_oob})
123 | df.to_csv('preds_oob.csv', index = False)
124 |
125 | ## test predictions
126 | pred_test /= (nfolds*nbags)
127 | df = pd.DataFrame({'id': id_test, 'loss': pred_test})
128 | df.to_csv('submission_keras.csv', index = False)
129 |
--------------------------------------------------------------------------------
/recursion-cellular-image-classification/eda.py:
--------------------------------------------------------------------------------
1 | import os
2 | from data_loader import loader, val_loader
3 | import torch
4 | import torch.nn as nn
5 | from torch.optim.lr_scheduler import ExponentialLR,CyclicLR
6 | from model_k import model_resnet_18
7 | from ignite.engine import Events, create_supervised_evaluator, create_supervised_trainer
8 | from ignite.metrics import Loss, Accuracy
9 | from ignite.contrib.handlers.tqdm_logger import ProgressBar
10 | from ignite.handlers import EarlyStopping, ModelCheckpoint
11 | import warnings
12 | from config import _get_default_config
13 | from scheduler import ParamScheduler, return_scale_fn
14 | from losses import FocalLoss
15 |
16 |
17 | model = model_resnet_18
18 | config = _get_default_config()
19 | MODEL_NAME = config.model
20 |
21 | path_data = '/mnt/ssd1/datasets/Recursion_class/'
22 | device = 'cuda'
23 |
24 |
25 | if config.warm_start:
26 | checkpoint_name = config.checkpoint_name
27 | checkpoint = torch.load(checkpoint_name)
28 | model.load_state_dict(checkpoint)
29 | model.to(device)
30 |
31 | os.environ["CUDA_VISIBLE_DEVICES"] = "0,1"
32 | path = '/mnt/ssd1/datasets/Recursion_class'
33 | path_data = path
34 | device = 'cuda'
35 | batch_size = 64
36 | warnings.filterwarnings('ignore')
37 |
38 |
39 | criterion = nn.CrossEntropyLoss()
40 | criterion = FocalLoss()
41 | optimizer = torch.optim.Adam(model.parameters(), lr=0.0003)
42 | # optimizer = torch.optim.RMSprop(model.parameters(), lr=0.0003, momentum=0.9)
43 |
44 | metrics = {
45 | 'loss': Loss(criterion),
46 | 'accuracy': Accuracy(),
47 | }
48 |
49 |
50 | trainer = create_supervised_trainer(model, optimizer, criterion, device=device)
51 | val_evaluator = create_supervised_evaluator(model, metrics=metrics, device=device)
52 |
53 |
54 | @trainer.on(Events.EPOCH_COMPLETED)
55 | def compute_and_display_val_metrics(engine):
56 | epoch = engine.state.epoch
57 | metrics = val_evaluator.run(val_loader).metrics
58 | print("Validation Results - Epoch: {} Average Loss: {:.4f} | Accuracy: {:.4f} "
59 | .format(engine.state.epoch,
60 | metrics['loss'],
61 | metrics['accuracy']))
62 |
63 |
64 | # scale_fn = return_scale_fn()
65 | # lr_scheduler = CyclicLR(optimizer, base_lr=0.00001, max_lr=0.001,
66 | # mode='exp_range', gamma=1.1, cycle_momentum=False)
67 | lr_scheduler = ExponentialLR(optimizer, gamma=0.95)
68 | # lr_scheduler = ParamScheduler(optimizer, scale_fn, 500 * len(loader))
69 |
70 |
71 | @trainer.on(Events.EPOCH_COMPLETED)
72 | def update_lr_scheduler(engine):
73 | lr_scheduler.step()
74 | lr = float(optimizer.param_groups[0]['lr'])
75 | print("Learning rate: {}".format(lr))
76 |
77 |
78 | check_pointer = ModelCheckpoint('checkpoint_{}'.format(config.checkpoint_folder), MODEL_NAME,
79 | n_saved=3, create_dir=True, save_as_state_dict=True,
80 | score_function=lambda engine: engine.state.metrics['accuracy'],
81 | require_empty=False, score_name="val_accuracy"
82 | )
83 |
84 | handler = EarlyStopping(patience=25, score_function=lambda engine: engine.state.metrics['accuracy'],
85 | trainer=trainer)
86 | val_evaluator.add_event_handler(Events.COMPLETED, handler)
87 | if config.all:
88 | name_exp = 'general'
89 | else:
90 | name_exp = config.experiment
91 | val_evaluator.add_event_handler(Events.COMPLETED, check_pointer,
92 | {'{}_site_{}'.format(name_exp, config.site): model})
93 |
94 |
95 | @trainer.on(Events.EPOCH_STARTED)
96 | def turn_on_layers(engine):
97 | epoch = engine.state.epoch
98 | if epoch < 2:
99 | for name, child in model.named_children():
100 | if name == 'fc' or name == 'classifier':
101 | pbar.log_message(name + ' is unfrozen')
102 | for param in child.parameters():
103 | param.requires_grad = True
104 | else:
105 | pbar.log_message(name + ' is frozen')
106 | for param in child.parameters():
107 | param.requires_grad = False
108 | elif epoch > 1:
109 | pbar.log_message("Turn on all the layers")
110 | for name, child in model.named_children():
111 | for param in child.parameters():
112 | param.requires_grad = True
113 |
114 |
115 | pbar = ProgressBar(bar_format='')
116 | pbar.attach(trainer, output_transform=lambda x: {'loss': x})
117 | trainer.run(loader, max_epochs=500)
118 |
119 |
120 | # with torch.no_grad():
121 | # preds = np.empty(0)
122 | # for x, _ in tqdm_notebook(tloader):
123 | # x = x.to(device)
124 | # output = model_resnet_18(x)
125 | # idx = output.max(dim=-1)[1].cpu().numpy()
126 | # preds = np.append(preds, idx, axis=0)
127 | #
128 | #
129 | # submission = pd.read_csv(path_data + '/test.csv')
130 | # submission['sirna'] = preds.astype(int)
131 | # submission.to_csv('submission_1.csv', index=False, columns=['id_code', 'sirna'])
132 |
--------------------------------------------------------------------------------
/Hands-on Reinforcement Learning with Python, Second Edition_new chapters/11. TRPO, PPO and ACKTR Methods/11.01. Trust Region Policy Optimization.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Trust Region Policy Optimization\n",
8 | "\n",
9 | "Trust region policy optimization shortly known as TRPO is one of the most popularly used algorithms in deep reinforcement learning. TRPO is a policy gradient algorithm and it acts as an improvement to the policy gradient with baseline we learned in chapter 8. We learned that policy gradient is an on-policy algorithm meaning that on every iteration, we improve the same policy with which we are generating trajectories. On every iteration, we update the parameter of our network and try to find the improved policy. The update rule for updating the parameter $\\theta$ of our network is given as follows:\n",
10 | "\n",
11 | "$$\\theta = \\theta + \\alpha \\nabla_{\\theta} J({\\theta}) $$\n",
12 | "\n",
13 | "Where $\\nabla_{\\theta} J({\\theta}) $ is the gradient and $\\alpha$ is known as the step size or learning rate. If the step size is large then there will be a large policy update and if it is small then there will be a small update in the policy. How can we find an optimal step size? In the policy gradient method, we keep the step size small and so on every iteration there will be a small improvement in the policy.\n",
14 | "\n",
15 | "\n",
16 | "But what happens if we take a large step on every iteration? Let's suppose we have a policy $\\pi$ parameterized by $\\theta$. So, on every iteration updating $\\theta$ implies that we are improving our policy. If the step size is large then the policy on every iteration varies greatly, that is, the old policy (policy used in the previous iteration) and the new policy (policy used in the current iteration) vary greatly. \n",
17 | "\n",
18 | "\n",
19 | "We learned that if the step size large is then the new policy and old policy will vary greatly. Since we are using parametrized policy, it implies that if we make a large update (large step size) then the parameter of old policy and new policy very heavily and this leads to a problem called model collapse.\n",
20 | "\n",
21 | "This is the reason, in the policy gradient method, instead of taking larger steps and update the parameter of our network we take a small step and update the parameter to keep the old policy and new policy closer. But how can we improve this? Can we take a larger step along with maintaining the old policy and new policy closer so that it won't affect our model performance and it will also help us to learn quickly? Yes, this problem is exactly solved by TRPO.\n",
22 | "\n",
23 | "TRPO tries to make a large policy update while imposing a constraint that old policy and new policy should not vary too much. Okay, what is this constraint? But first, how can we measure and understand if the old policy and new policy are changing greatly? Here is where we use a measure called KL divergence. The KL divergence is ubiquitous in reinforcement learning. It tells us how two probability distributions are different from each other. So, we can use the KL divergence to understand if our old policy and new policy varies greatly or not. TRPO adds a constraint that the KL divergence between the old policy and new policy should be less than or equal to some constant $\\delta$. That is, when we make a policy update, old policy and a new policy should not vary more than some constant. This constraint is called trust region constraint. \n",
24 | "\n",
25 | "Thus, TRPO tries to make a large policy update while imposing the constraint that the parameter of the old policy and a new policy should be within the trust region. Note that in the policy gradient method, we use the parameterized policy. Thus, keeping the parameter of the old policy and new policy within the trust region implies that the old policy and new policy is within the trust region.\n",
26 | "\n",
27 | "TRPO guarantees monotonic policy improvement, that is, it guarantees that there will always be a policy improvement on every iteration. This is the fundamental idea behind the TRPO algorithm. \n",
28 | "\n",
29 | "To understand how exactly TRPO works, we should understand the math behind TRPO. TRPO has pretty heavy math. But worry not! It will be simple if we understand the fundamental math concepts required to understand TRPO. So, before diving into the TRPO algorithm, first, we will understand several essential math concepts that are required to understand TRPO. Then we will learn how to design TRPO objective function with the trust region constraint and in the end, we will see how to solve the TRPO objective function. \n",
30 | "\n",
31 | "\n"
32 | ]
33 | }
34 | ],
35 | "metadata": {
36 | "kernelspec": {
37 | "display_name": "Python 3",
38 | "language": "python",
39 | "name": "python3"
40 | },
41 | "language_info": {
42 | "codemirror_mode": {
43 | "name": "ipython",
44 | "version": 3
45 | },
46 | "file_extension": ".py",
47 | "mimetype": "text/x-python",
48 | "name": "python",
49 | "nbconvert_exporter": "python",
50 | "pygments_lexer": "ipython3",
51 | "version": "3.6.9"
52 | }
53 | },
54 | "nbformat": 4,
55 | "nbformat_minor": 2
56 | }
57 |
--------------------------------------------------------------------------------
/Hands-on Reinforcement Learning with Python, Second Edition_new chapters/05. Understanding Temporal Difference Learning/5.01. TD Learning.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# TD learning\n",
8 | "\n",
9 | "The Temporal Difference (TD) learning algorithm was introduced by Richard S. Sutton in 1988. In the introduction of the chapter, we learned that the reason for the TD method to be more popular is that it takes the advantages of the dynamic programming method and the Monte Carlo method. But what are those advantages?\n",
10 | "\n",
11 | "First, let's recap quickly the advantages and disadvantages of dynamic programming and the Monte Carlo method.\n",
12 | "\n",
13 | "**Dynamic Programming** - The advantage of the dynamic programming (DP) method is that it uses the Bellman equation to compute the value of a state. That is, we learned that according to the Bellman equation, the value of a state can be obtained as a sum of the immediate reward and the discounted value of the next state. This is called bootstrapping. That is, to compute the value of a state, we don't have to wait till the end of the episode, instead, using the Bellman equation, we can estimate the value of a state just based on the value of the next state and this is called bootstrapping.\n",
14 | "\n",
15 | "Remember how we estimated the value function in dynamic programming methods (value and policy iteration)? We estimated the value function (value of a state) as $V(s) = \\sum_{s'} P_{ss'}^a [R_{ss'}^a + \\gamma V^{}(s')] $ . As you may recollect, we learned that in order to find the value of a state, we didn't have to wait till the end of the episode, instead, we bootstrap, that is we estimate the value of the current state $V(s)$ by estimating the value of the next state $V(s')$. \n",
16 | "\n",
17 | "However, the disadvantage of dynamic programming is that we can apply the DP method only when we know the model dynamics of the environment. That is, we learned that the DP is a model-based method and we should know the transition probabilities in order to use the DP method. When we don't know the model dynamics of the environment then we cannot apply the DP method. \n",
18 | "\n",
19 | "**Monte Carlo Method** - The advantage of the Monte Carlo method is that is it is a model-free method which means that it does not require the model dynamics of the environment to be known in order to estimate the value and Q function. \n",
20 | "\n",
21 | "However, the disadvantage of the Monte Carlo method is that in order to estimate the state value or Q value we need to wait till the end of the episode and if the episode is long then it will cost us a lot of time. Also, we cannot apply Monte Carlo methods to continuous tasks (non-episodic tasks). \n",
22 | "\n",
23 | "\n",
24 | "Now let's get back to TD learning. The TD learning algorithm takes the benefits of both the dynamic programming and the Monte Carlo methods into account. That is just like a dynamic programming method, we perform bootstrap so that we don't have to wait till the end of an episode to compute the state value or Q value and just like the Monte Carlo method, it is a model-free method and so it does not require the model dynamics of the environment to compute the state value or Q value. Now that we have understood the basic idea behind the TD learning algorithm, let's get into detail and learn how exactly it works. \n",
25 | "\n",
26 | "Similar to what we learned in the Monte Carlo chapter, we can use the TD learning algorithm for both the prediction and control tasks and so we can categorize TD learning into:\n",
27 | "\n",
28 | "* TD Prediction \n",
29 | "* TD Control \n",
30 | "\n",
31 | "We already learned what does prediction and control method means in the previous chapter. Let us recap that a bit before going forward. \n",
32 | "\n",
33 | "In the prediction method, a policy is given as an input and we try to predict the value function or Q function using the given policy. If we predict the value function using the given policy then we can say how good it is for the agent to be in each state if it uses the given policy. That is, we can say that what is the expected return an agent can get in each state if it acts according to the given policy. \n",
34 | "\n",
35 | "In the Control method, we will not be given any policy as an input and the goal in the control method is to find the optimal policy. So, we will initialize a random policy and then we try to find the optimal policy iteratively. That is, we try to find an optimal policy that gives the maximum return. \n",
36 | "\n",
37 | "First, let us understand how can we use TD learning to perform prediction task and then we will learn how to use TD learning for the control task."
38 | ]
39 | }
40 | ],
41 | "metadata": {
42 | "kernelspec": {
43 | "display_name": "Python 3",
44 | "language": "python",
45 | "name": "python3"
46 | },
47 | "language_info": {
48 | "codemirror_mode": {
49 | "name": "ipython",
50 | "version": 3
51 | },
52 | "file_extension": ".py",
53 | "mimetype": "text/x-python",
54 | "name": "python",
55 | "nbconvert_exporter": "python",
56 | "pygments_lexer": "ipython3",
57 | "version": "3.6.9"
58 | }
59 | },
60 | "nbformat": 4,
61 | "nbformat_minor": 2
62 | }
63 |
--------------------------------------------------------------------------------
/Hands-on Reinforcement Learning with Python, Second Edition_new chapters/01. Fundamentals of Reinforcement Learning/1.01. Basic Idea of Reinforcement Learning .ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "# Introduction\n",
8 | "\n",
9 | "Reinforcement learning (RL) is a branch of machine learning where learning occurs by interacting with an environment, unlike other machine learning paradigms like supervised and unsupervised learning. Reinforcement learning is one of the most active areas of research in artificial intelligence and it is believed that RL will take us a step closer towards achieving artificial general intelligence. In this chapter, we will build a strong foundation of reinforcement learning by understating several important and fundamental concepts involved in reinforcement learning. \n",
10 | "\n",
11 | "In this chapter, we will learn about the following topics:\n",
12 | "\n",
13 | "* Basic idea of reinforcement learning\n",
14 | "* Key elements of reinforcement learning\n",
15 | "* Reinforcement learning algorithm\n",
16 | "* How RL differs from other ML paradigms?\n",
17 | "* Markov Decision Processes\n",
18 | "* Fundamental concepts of reinforcement learning\n",
19 | "* Applications of Reinforcement Learning\n",
20 | "* Reinforcement learning glossary"
21 | ]
22 | },
23 | {
24 | "cell_type": "markdown",
25 | "metadata": {},
26 | "source": [
27 | "# Basic Idea of Reinforcement Learning \n",
28 | "\n",
29 | "Let's begin with an analogy. Let's suppose we are teaching the dog to catch a ball. Instead of teaching the dog explicitly to catch a ball, we will just throw a ball and every time the dog catches the ball, we will give the dog a cookie. If the dog fails to catch the ball then we will not give a cookie. So, the dog will figure out what action caused it to receive a cookie and repeat that action. Thus, the dog will understand that catching the ball caused it to receive a cookie and repeat catching the ball. Thus, in this way the dog will learn to catch a ball while aiming for maximizing the cookies it can receive. \n",
30 | "\n",
31 | "Similarly, in a reinforcement learning setting, we will not teach the agent what to do or how to do, instead, we will give a reward to the agent for every action it does. We will give a positive reward to the agent when it performs a good action and we will give a negative reward to the agent when it performs a bad action. The agent begins by performing a random action and if the action is good then we will give the agent a positive reward so that the agent will understand it has performed a good action and it will repeat that action and if the action performed by the agent is bad then we will give the agent a negative reward so that the agent will understand it has performed a bad action and it will not repeat that action. \n",
32 | "\n",
33 | "Thus, reinforcement learning can be viewed as a trial and error learning process where the agent tries out different actions and learns the good action which gives a positive reward. \n",
34 | "\n",
35 | "In the dog analogy, we learned, the dog represents the agent, giving a cookie to the dog upon catching the ball is a positive reward and not giving a cookie is a negative reward. So, the dog (agent) explores different actions which are catching a ball and not catching a ball and understands that catching the ball is a good action as it brings the dog a positive reward (getting a cookie).\n",
36 | "\n",
37 | "Let's understand the idea of reinforcement learning with one more simple example. Let's suppose we want to teach a robot (agent) to walk without getting hit by a mountain as shown below:\n",
38 | "\n",
39 | "\n",
40 | "\n",
41 | "We will not teach the robot explicitly to not go in the direction of the mountain, instead, if the robot hits the mountain and get stuck, we give the robot a negative reward, say -1. So, the robot will understand that hitting the mountain is the wrong action and it will not repeat that action again:\n",
42 | "\n",
43 | "\n",
44 | "\n",
45 | "Similarly, when the robot walk in the right direction without getting hit by a mountain, we will give the robot a positive reward, say +1. So, the robot will understand that not hitting the mountain is the good action and it will repeat that action:\n",
46 | "\n",
47 | "\n",
48 | "\n",
49 | "Thus, in the reinforcement learning setting, the agent explores different actions and learns the best action based on the reward it gets. \n",
50 | "\n",
51 | "Now that we have a basic idea of how reinforcement learning works, in the upcoming sections, we will get into more details and also learn the important concepts involved in reinforcement learning. \n",
52 | "\n"
53 | ]
54 | }
55 | ],
56 | "metadata": {
57 | "kernelspec": {
58 | "display_name": "Python 3",
59 | "language": "python",
60 | "name": "python3"
61 | },
62 | "language_info": {
63 | "codemirror_mode": {
64 | "name": "ipython",
65 | "version": 3
66 | },
67 | "file_extension": ".py",
68 | "mimetype": "text/x-python",
69 | "name": "python",
70 | "nbconvert_exporter": "python",
71 | "pygments_lexer": "ipython3",
72 | "version": "3.6.9"
73 | }
74 | },
75 | "nbformat": 4,
76 | "nbformat_minor": 2
77 | }
78 |
--------------------------------------------------------------------------------
/tips_tricks/Video 1.1 Improving your models using Feature engineering.ipynb:
--------------------------------------------------------------------------------
1 | {
2 | "cells": [
3 | {
4 | "cell_type": "markdown",
5 | "metadata": {},
6 | "source": [
7 | "**Types of scaling**:\n",
8 | "\n",
9 | "* MinMaxScaler - scales all features to $[a, b]$ range\n",
10 | "\n",
11 | "* StandardScaler - removes mean and divides by variance of all features. $X^{new}_i = \\frac{X_i - \\mu}{\\sigma}$, where $\\mu $is for mean and $\\sigma$ is for variance\n",
12 | "\n",
13 | "* RobustScaler - same as StandardScaler but removes median and divides by IQR\n"
14 | ]
15 | },
16 | {
17 | "cell_type": "code",
18 | "execution_count": 7,
19 | "metadata": {
20 | "collapsed": true
21 | },
22 | "outputs": [],
23 | "source": [
24 | "import pandas as pd\n",
25 | "import numpy as np"
26 | ]
27 | },
28 | {
29 | "cell_type": "code",
30 | "execution_count": 8,
31 | "metadata": {
32 | "collapsed": true
33 | },
34 | "outputs": [],
35 | "source": [
36 | "df = pd.read_csv(\"http://archive.ics.uci.edu/ml/machine-learning-databases/wine-quality/winequality-white.csv\",sep = ';')"
37 | ]
38 | },
39 | {
40 | "cell_type": "code",
41 | "execution_count": 10,
42 | "metadata": {},
43 | "outputs": [],
44 | "source": [
45 | "y = df.pop('quality')"
46 | ]
47 | },
48 | {
49 | "cell_type": "code",
50 | "execution_count": 11,
51 | "metadata": {
52 | "collapsed": true
53 | },
54 | "outputs": [],
55 | "source": [
56 | "for i in df.columns:\n",
57 | " df[i] = df[i].fillna(np.mean(df[i]))"
58 | ]
59 | },
60 | {
61 | "cell_type": "code",
62 | "execution_count": 12,
63 | "metadata": {
64 | "collapsed": true
65 | },
66 | "outputs": [],
67 | "source": [
68 | "from sklearn.preprocessing import StandardScaler,MinMaxScaler,RobustScaler\n",
69 | "from sklearn.linear_model import Ridge\n",
70 | "from sklearn.model_selection import train_test_split\n",
71 | "from sklearn.metrics import mean_squared_error"
72 | ]
73 | },
74 | {
75 | "cell_type": "code",
76 | "execution_count": 13,
77 | "metadata": {
78 | "collapsed": true
79 | },
80 | "outputs": [],
81 | "source": [
82 | "np.random.seed(42)\n",
83 | "train,test,y_train,y_test = train_test_split(df,y,test_size = 0.1)"
84 | ]
85 | },
86 | {
87 | "cell_type": "code",
88 | "execution_count": 14,
89 | "metadata": {
90 | "collapsed": true
91 | },
92 | "outputs": [],
93 | "source": [
94 | "def fit_predict(train,test,y_train,y_test,scaler = None):\n",
95 | " if scaler is None:\n",
96 | " lr = Ridge()\n",
97 | " lr.fit(train,y_train)\n",
98 | " y_pred = lr.predict(test)\n",
99 | " print('MSE score:', mean_squared_error(y_test,y_pred))\n",
100 | " else:\n",
101 | " train_scaled = scaler.fit_transform(train)\n",
102 | " test_scaled = scaler.transform(test)\n",
103 | " lr = Ridge()\n",
104 | " lr.fit(train_scaled,y_train)\n",
105 | " y_pred = lr.predict(test_scaled)\n",
106 | " print('MSE score:', mean_squared_error(y_test,y_pred))"
107 | ]
108 | },
109 | {
110 | "cell_type": "code",
111 | "execution_count": 15,
112 | "metadata": {},
113 | "outputs": [
114 | {
115 | "name": "stdout",
116 | "output_type": "stream",
117 | "text": [
118 | "MSE score: 0.57404414001\n"
119 | ]
120 | }
121 | ],
122 | "source": [
123 | "fit_predict(train,test,y_train,y_test)"
124 | ]
125 | },
126 | {
127 | "cell_type": "code",
128 | "execution_count": 16,
129 | "metadata": {},
130 | "outputs": [
131 | {
132 | "name": "stdout",
133 | "output_type": "stream",
134 | "text": [
135 | "MSE score: 0.567545067343\n"
136 | ]
137 | }
138 | ],
139 | "source": [
140 | "fit_predict(train,test,y_train,y_test,MinMaxScaler())"
141 | ]
142 | },
143 | {
144 | "cell_type": "code",
145 | "execution_count": 17,
146 | "metadata": {},
147 | "outputs": [
148 | {
149 | "name": "stdout",
150 | "output_type": "stream",
151 | "text": [
152 | "MSE score: 0.558144966334\n"
153 | ]
154 | }
155 | ],
156 | "source": [
157 | "fit_predict(train,test,y_train,y_test,StandardScaler())"
158 | ]
159 | },
160 | {
161 | "cell_type": "code",
162 | "execution_count": 18,
163 | "metadata": {},
164 | "outputs": [
165 | {
166 | "name": "stdout",
167 | "output_type": "stream",
168 | "text": [
169 | "MSE score: 0.55823299573\n"
170 | ]
171 | }
172 | ],
173 | "source": [
174 | "fit_predict(train,test,y_train,y_test,RobustScaler())"
175 | ]
176 | }
177 | ],
178 | "metadata": {
179 | "kernelspec": {
180 | "display_name": "Python 3",
181 | "language": "python",
182 | "name": "python3"
183 | },
184 | "language_info": {
185 | "codemirror_mode": {
186 | "name": "ipython",
187 | "version": 3
188 | },
189 | "file_extension": ".py",
190 | "mimetype": "text/x-python",
191 | "name": "python",
192 | "nbconvert_exporter": "python",
193 | "pygments_lexer": "ipython3",
194 | "version": "3.6.2"
195 | }
196 | },
197 | "nbformat": 4,
198 | "nbformat_minor": 2
199 | }
200 |
--------------------------------------------------------------------------------
102 |