ai/deeplearning-for-coders/05-why-use-framework.ipynb

{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"name":"python","version":"3.7.12","mimetype":"text/x-python","codemirror_mode":{"name":"ipython","version":3},"pygments_lexer":"ipython3","nbconvert_exporter":"python","file_extension":".py"},"kaggle":{"accelerator":"none","dataSources":[{"sourceId":3136,"databundleVersionId":26502,"sourceType":"competition"}],"dockerImageVersionId":30191,"isInternetEnabled":true,"language":"python","sourceType":"notebook","isGpuEnabled":false}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"## Introduction and set up","metadata":{}},{"cell_type":"markdown","source":"Based on [this notebook](https://www.kaggle.com/code/jhoward/why-you-should-use-a-framework). Hosted on [Kaggle here](https://www.kaggle.com/code/sarincasm/why-you-should-use-a-framework).","metadata":{}},{"cell_type":"markdown","source":"If you've finished going through my [Linear model and neural net from scratch\n](https://www.kaggle.com/code/jhoward/linear-model-and-neural-net-from-scratch) notebook, then now is a good time to look at how to do the same thing using a library, instead of doing it from scratch. We'll use fastai and PyTorch. The benefits of using these libraries is:\n\n- Best practices are handled for you automatically -- fast.ai has done thousands of hours of experiments to figure out what the best settings are for you\n- Less time getting set up, which means more time to try out your new ideas\n- Each idea you try will be less work, because fastai and PyTorch will do the many of the menial bits for you\n- You can always drop down from fastai to PyTorch if you need to customise any part (or drop down from the fastai Application API to the fastai mid or low tier APIs), or even drop down from PyTorch to plain python for deep customisation.\n\nLet's see how that looks in practice. We'll start by doing the same library setup as in the \"from scratch\" notebook:","metadata":{}},{"cell_type":"code","source":"from pathlib import Path\nimport os\n\niskaggle = os.environ.get('KAGGLE_KERNEL_RUN_TYPE', '')\nif iskaggle:\n    path = Path('../input/titanic')\nelse:\n    import zipfile,kaggle\n    path = Path('titanic')\n    if not path.exists():\n        kaggle.api.competition_download_cli(str(path))\n        zipfile.ZipFile(f'{path}.zip').extractall(path)","metadata":{"_kg_hide-output":true,"execution":{"iopub.status.busy":"2024-03-14T00:20:04.229774Z","iopub.execute_input":"2024-03-14T00:20:04.230156Z","iopub.status.idle":"2024-03-14T00:20:04.238093Z","shell.execute_reply.started":"2024-03-14T00:20:04.230106Z","shell.execute_reply":"2024-03-14T00:20:04.236887Z"},"trusted":true},"execution_count":4,"outputs":[]},{"cell_type":"markdown","source":"We'll import the fastai tabular library, set a random seed so the notebook is reproducible, and pick a reasonable number of significant figures to display in our tables:","metadata":{}},{"cell_type":"code","source":"from fastai.tabular.all import *\n\npd.options.display.float_format = '{:.2f}'.format\nset_seed(42)","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:19:04.548600Z","iopub.execute_input":"2024-03-14T00:19:04.548967Z","iopub.status.idle":"2024-03-14T00:19:07.385618Z","shell.execute_reply.started":"2024-03-14T00:19:04.548927Z","shell.execute_reply":"2024-03-14T00:19:07.384227Z"},"trusted":true},"execution_count":2,"outputs":[]},{"cell_type":"code","source":"?pd","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:19:25.058856Z","iopub.execute_input":"2024-03-14T00:19:25.059262Z","iopub.status.idle":"2024-03-14T00:19:25.067875Z","shell.execute_reply.started":"2024-03-14T00:19:25.059221Z","shell.execute_reply":"2024-03-14T00:19:25.066418Z"},"trusted":true},"execution_count":3,"outputs":[{"output_type":"display_data","data":{"text/plain":"\u001b[0;31mType:\u001b[0m        module\n\u001b[0;31mString form:\u001b[0m <module 'pandas' from '/opt/conda/lib/python3.7/site-packages/pandas/__init__.py'>\n\u001b[0;31mFile:\u001b[0m        /opt/conda/lib/python3.7/site-packages/pandas/__init__.py\n\u001b[0;31mDocstring:\u001b[0m  \npandas - a powerful data analysis and manipulation library for Python\n=====================================================================\n\n**pandas** is a Python package providing fast, flexible, and expressive data\nstructures designed to make working with \"relational\" or \"labeled\" data both\neasy and intuitive. It aims to be the fundamental high-level building block for\ndoing practical, **real world** data analysis in Python. Additionally, it has\nthe broader goal of becoming **the most powerful and flexible open source data\nanalysis / manipulation tool available in any language**. It is already well on\nits way toward this goal.\n\nMain Features\n-------------\nHere are just a few of the things that pandas does well:\n\n  - Easy handling of missing data in floating point as well as non-floating\n    point data.\n  - Size mutability: columns can be inserted and deleted from DataFrame and\n    higher dimensional objects\n  - Automatic and explicit data alignment: objects can be explicitly aligned\n    to a set of labels, or the user can simply ignore the labels and let\n    `Series`, `DataFrame`, etc. automatically align the data for you in\n    computations.\n  - Powerful, flexible group by functionality to perform split-apply-combine\n    operations on data sets, for both aggregating and transforming data.\n  - Make it easy to convert ragged, differently-indexed data in other Python\n    and NumPy data structures into DataFrame objects.\n  - Intelligent label-based slicing, fancy indexing, and subsetting of large\n    data sets.\n  - Intuitive merging and joining data sets.\n  - Flexible reshaping and pivoting of data sets.\n  - Hierarchical labeling of axes (possible to have multiple labels per tick).\n  - Robust IO tools for loading data from flat files (CSV and delimited),\n    Excel files, databases, and saving/loading data from the ultrafast HDF5\n    format.\n  - Time series-specific functionality: date range generation and frequency\n    conversion, moving window statistics, date shifting and lagging.\n"},"metadata":{}}]},{"cell_type":"markdown","source":"## Prep the data","metadata":{}},{"cell_type":"markdown","source":"We'll read the CSV file just like we did before:","metadata":{}},{"cell_type":"code","source":"df = pd.read_csv(path/'train.csv')","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:20:15.132774Z","iopub.execute_input":"2024-03-14T00:20:15.133252Z","iopub.status.idle":"2024-03-14T00:20:15.165366Z","shell.execute_reply.started":"2024-03-14T00:20:15.133198Z","shell.execute_reply":"2024-03-14T00:20:15.164008Z"},"trusted":true},"execution_count":5,"outputs":[]},{"cell_type":"markdown","source":"When you do everything from scratch, every bit of feature engineering requires a whole lot of work, since you have to think about things like dummy variables, normalization, missing values, and so on. But with fastai that's all done for you. So let's go wild and create lots of new features! We'll use a bunch of the most interesting ones from this fantastic [Titanic feature engineering notebook](https://www.kaggle.com/code/gunesevitan/titanic-advanced-feature-engineering-tutorial/) (and be sure to click that link and upvote that notebook if you like it to thank the author for their hard work!)","metadata":{}},{"cell_type":"code","source":"def add_features(df):\n    df['LogFare'] = np.log1p(df['Fare'])\n    df['Deck'] = df.Cabin.str[0].map(dict(A=\"ABC\", B=\"ABC\", C=\"ABC\", D=\"DE\", E=\"DE\", F=\"FG\", G=\"FG\"))\n    df['Family'] = df.SibSp+df.Parch\n    df['Alone'] = df.Family==0\n    df['TicketFreq'] = df.groupby('Ticket')['Ticket'].transform('count')\n    df['Title'] = df.Name.str.split(', ', expand=True)[1].str.split('.', expand=True)[0]\n    df['Title'] = df.Title.map(dict(Mr=\"Mr\",Miss=\"Miss\",Mrs=\"Mrs\",Master=\"Master\"))\n\nadd_features(df)","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:21:28.889748Z","iopub.execute_input":"2024-03-14T00:21:28.890970Z","iopub.status.idle":"2024-03-14T00:21:29.103398Z","shell.execute_reply.started":"2024-03-14T00:21:28.890889Z","shell.execute_reply":"2024-03-14T00:21:29.102413Z"},"trusted":true},"execution_count":6,"outputs":[]},{"cell_type":"markdown","source":"As we discussed in the last notebook, we can use `RandomSplitter` to separate out the training and validation sets:","metadata":{}},{"cell_type":"code","source":"splits = RandomSplitter(seed=42)(df)","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:21:39.700414Z","iopub.execute_input":"2024-03-14T00:21:39.700763Z","iopub.status.idle":"2024-03-14T00:21:39.707858Z","shell.execute_reply.started":"2024-03-14T00:21:39.700723Z","shell.execute_reply":"2024-03-14T00:21:39.707024Z"},"trusted":true},"execution_count":7,"outputs":[]},{"cell_type":"markdown","source":"Now the entire process of getting the data ready for training requires just this one cell!:","metadata":{}},{"cell_type":"code","source":"dls = TabularPandas(\n    df, splits=splits,\n    procs = [Categorify, FillMissing, Normalize],\n    cat_names=[\"Sex\",\"Pclass\",\"Embarked\",\"Deck\", \"Title\"],\n    cont_names=['Age', 'SibSp', 'Parch', 'LogFare', 'Alone', 'TicketFreq', 'Family'],\n    y_names=\"Survived\", y_block = CategoryBlock(),\n).dataloaders(path=\".\")","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:22:06.364462Z","iopub.execute_input":"2024-03-14T00:22:06.364765Z","iopub.status.idle":"2024-03-14T00:22:06.454769Z","shell.execute_reply.started":"2024-03-14T00:22:06.364733Z","shell.execute_reply":"2024-03-14T00:22:06.453104Z"},"trusted":true},"execution_count":8,"outputs":[]},{"cell_type":"markdown","source":"Here's what each of the parameters means:\n\n- Use `splits` for indices of training and validation sets:\n\n      splits=splits,\n    \n- Turn strings into categories, fill missing values in numeric columns with the median, normalise all numeric columns:\n    \n      procs = [Categorify, FillMissing, Normalize],\n    \n- These are the categorical independent variables:\n    \n      cat_names=[\"Sex\",\"Pclass\",\"Embarked\",\"Deck\", \"Title\"],\n    \n- These are the continuous independent variables:\n    \n      cont_names=['Age', 'SibSp', 'Parch', 'LogFare', 'Alone', 'TicketFreq', 'Family'],\n    \n- This is the dependent variable:\n    \n      y_names=\"Survived\",\n\n- The dependent variable is categorical (so build a classification model, not a regression model):\n\n      y_block = CategoryBlock(),","metadata":{}},{"cell_type":"markdown","source":"## Train the model","metadata":{}},{"cell_type":"markdown","source":"The data and model together make up a `Learner`. To create one, we say what the data is (`dls`), and the size of each hidden layer (`[10,10]`), along with any metrics we want to print along the way:","metadata":{}},{"cell_type":"code","source":"learn = tabular_learner(dls, metrics=accuracy, layers=[10,10])","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:23:27.323505Z","iopub.execute_input":"2024-03-14T00:23:27.323974Z","iopub.status.idle":"2024-03-14T00:23:27.344468Z","shell.execute_reply.started":"2024-03-14T00:23:27.323916Z","shell.execute_reply":"2024-03-14T00:23:27.343636Z"},"trusted":true},"execution_count":9,"outputs":[]},{"cell_type":"markdown","source":"You'll notice we didn't have to do any messing around to try to find a set of random coefficients that will train correctly -- that's all handled automatically.\n\nOne handy feature that fastai can also tell us what learning rate to use:","metadata":{}},{"cell_type":"code","source":"learn.lr_find(suggest_funcs=(slide, valley))","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:23:44.832835Z","iopub.execute_input":"2024-03-14T00:23:44.833279Z","iopub.status.idle":"2024-03-14T00:23:47.624350Z","shell.execute_reply.started":"2024-03-14T00:23:44.833226Z","shell.execute_reply":"2024-03-14T00:23:47.623549Z"},"trusted":true},"execution_count":10,"outputs":[{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"\n<style>\n    /* Turns off some styling */\n    progress {\n        /* gets rid of default border in Firefox and Opera. */\n        border: none;\n        /* Needs to be in here for Safari polyfill so background images work as expected. */\n        background-size: auto;\n    }\n    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n        background: #F44336;\n    }\n</style>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":""},"metadata":{}},{"execution_count":10,"output_type":"execute_result","data":{"text/plain":"SuggestedLRs(slide=0.05754399299621582, valley=0.013182567432522774)"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<Figure size 432x288 with 1 Axes>","image/png":"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\n"},"metadata":{"needs_background":"light"}}]},{"cell_type":"markdown","source":"The two colored points are both reasonable choices for a learning rate. I'll pick somewhere between the two (0.03) and train for a few epochs:","metadata":{}},{"cell_type":"code","source":"learn.fit(16, lr=0.03)","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:24:12.681919Z","iopub.execute_input":"2024-03-14T00:24:12.683170Z","iopub.status.idle":"2024-03-14T00:24:16.473505Z","shell.execute_reply.started":"2024-03-14T00:24:12.683085Z","shell.execute_reply":"2024-03-14T00:24:16.472458Z"},"trusted":true},"execution_count":11,"outputs":[{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"\n<style>\n    /* Turns off some styling */\n    progress {\n        /* gets rid of default border in Firefox and Opera. */\n        border: none;\n        /* Needs to be in here for Safari polyfill so background images work as expected. */\n        background-size: auto;\n    }\n    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n        background: #F44336;\n    }\n</style>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"<table border=\"1\" class=\"dataframe\">\n  <thead>\n    <tr style=\"text-align: left;\">\n      <th>epoch</th>\n      <th>train_loss</th>\n      <th>valid_loss</th>\n      <th>accuracy</th>\n      <th>time</th>\n    </tr>\n  </thead>\n  <tbody>\n    <tr>\n      <td>0</td>\n      <td>0.577146</td>\n      <td>0.582949</td>\n      <td>0.606742</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>1</td>\n      <td>0.510818</td>\n      <td>0.498523</td>\n      <td>0.786517</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>2</td>\n      <td>0.467023</td>\n      <td>0.459841</td>\n      <td>0.797753</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>3</td>\n      <td>0.439957</td>\n      <td>0.468547</td>\n      <td>0.797753</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>4</td>\n      <td>0.427232</td>\n      <td>0.415261</td>\n      <td>0.825843</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>5</td>\n      <td>0.416340</td>\n      <td>0.437362</td>\n      <td>0.820225</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>6</td>\n      <td>0.408347</td>\n      <td>0.413253</td>\n      <td>0.848315</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>7</td>\n      <td>0.400442</td>\n      <td>0.406075</td>\n      <td>0.803371</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>8</td>\n      <td>0.397265</td>\n      <td>0.443730</td>\n      <td>0.820225</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>9</td>\n      <td>0.392389</td>\n      <td>0.432267</td>\n      <td>0.831461</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>10</td>\n      <td>0.389983</td>\n      <td>0.415383</td>\n      <td>0.831461</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>11</td>\n      <td>0.386057</td>\n      <td>0.425319</td>\n      <td>0.820225</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>12</td>\n      <td>0.382527</td>\n      <td>0.435054</td>\n      <td>0.831461</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>13</td>\n      <td>0.378309</td>\n      <td>0.429746</td>\n      <td>0.831461</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>14</td>\n      <td>0.374304</td>\n      <td>0.419489</td>\n      <td>0.825843</td>\n      <td>00:00</td>\n    </tr>\n    <tr>\n      <td>15</td>\n      <td>0.372190</td>\n      <td>0.425430</td>\n      <td>0.831461</td>\n      <td>00:00</td>\n    </tr>\n  </tbody>\n</table>"},"metadata":{}}]},{"cell_type":"markdown","source":"We've got a similar accuracy to our previous \"from scratch\" model -- which isn't too surprising, since as we discussed, this dataset is too small and simple to really see much difference. A simple linear model already does a pretty good job. But that's OK -- the goal here is to show you how to get started with deep learning and understand how it really works, and the best way to do that is on small and easy to understand datasets.","metadata":{}},{"cell_type":"markdown","source":"## Submit to Kaggle","metadata":{}},{"cell_type":"markdown","source":"One important feature of fastai is that all the information needed to apply the data transformations and the model to a new dataset are stored in the learner. You can call `export` to save it to a file to use it later in production, or you can use the trained model right away to get predictions on a test set.\n\nTo submit to Kaggle, we'll need to read in the test set, and do the same feature engineering we did for the training set:","metadata":{}},{"cell_type":"code","source":"tst_df = pd.read_csv(path/'test.csv')\ntst_df['Fare'] = tst_df.Fare.fillna(0)\nadd_features(tst_df)","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:25:45.285116Z","iopub.execute_input":"2024-03-14T00:25:45.285465Z","iopub.status.idle":"2024-03-14T00:25:45.319638Z","shell.execute_reply.started":"2024-03-14T00:25:45.285432Z","shell.execute_reply":"2024-03-14T00:25:45.318766Z"},"trusted":true},"execution_count":12,"outputs":[]},{"cell_type":"markdown","source":"But we don't need to manually specify any of the processing steps necessary to get the data ready for modeling, since that's all saved in the learner. To specify we want to apply the same steps to a new dataset, use the `test_dl()` method:","metadata":{}},{"cell_type":"code","source":"tst_dl = learn.dls.test_dl(tst_df)","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:25:49.777620Z","iopub.execute_input":"2024-03-14T00:25:49.779034Z","iopub.status.idle":"2024-03-14T00:25:49.808456Z","shell.execute_reply.started":"2024-03-14T00:25:49.778966Z","shell.execute_reply":"2024-03-14T00:25:49.807465Z"},"trusted":true},"execution_count":13,"outputs":[]},{"cell_type":"markdown","source":"Now we can use `get_preds` to get the predictions for the test set:","metadata":{}},{"cell_type":"code","source":"preds,_ = learn.get_preds(dl=tst_dl)","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:25:56.068577Z","iopub.execute_input":"2024-03-14T00:25:56.069195Z","iopub.status.idle":"2024-03-14T00:25:56.168675Z","shell.execute_reply.started":"2024-03-14T00:25:56.069117Z","shell.execute_reply":"2024-03-14T00:25:56.167811Z"},"trusted":true},"execution_count":14,"outputs":[{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"\n<style>\n    /* Turns off some styling */\n    progress {\n        /* gets rid of default border in Firefox and Opera. */\n        border: none;\n        /* Needs to be in here for Safari polyfill so background images work as expected. */\n        background-size: auto;\n    }\n    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n        background: #F44336;\n    }\n</style>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":""},"metadata":{}}]},{"cell_type":"markdown","source":"Finally, let's create a submission CSV just like we did in the previous notebook...","metadata":{}},{"cell_type":"code","source":"tst_df['Survived'] = (preds[:,1]>0.5).int()\nsub_df = tst_df[['PassengerId','Survived']]\nsub_df.to_csv('sub.csv', index=False)","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:26:02.749463Z","iopub.execute_input":"2024-03-14T00:26:02.749910Z","iopub.status.idle":"2024-03-14T00:26:02.769950Z","shell.execute_reply.started":"2024-03-14T00:26:02.749861Z","shell.execute_reply":"2024-03-14T00:26:02.769031Z"},"trusted":true},"execution_count":15,"outputs":[]},{"cell_type":"markdown","source":"...and check that it looks reasonable:","metadata":{}},{"cell_type":"code","source":"!head sub.csv","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:26:05.805634Z","iopub.execute_input":"2024-03-14T00:26:05.806522Z","iopub.status.idle":"2024-03-14T00:26:07.054479Z","shell.execute_reply.started":"2024-03-14T00:26:05.806474Z","shell.execute_reply":"2024-03-14T00:26:07.053232Z"},"trusted":true},"execution_count":16,"outputs":[{"name":"stdout","text":"PassengerId,Survived\n892,0\n893,0\n894,0\n895,0\n896,1\n897,0\n898,1\n899,0\n900,1\n","output_type":"stream"}]},{"cell_type":"markdown","source":"## Ensembling","metadata":{}},{"cell_type":"markdown","source":"Since it's so easy to create a model now, it's easier to play with more advanced modeling approaches. For instance, we can create five separate models, each trained from different random starting points, and average them. This is the simplest approach of [ensembling](https://machinelearningmastery.com/tour-of-ensemble-learning-algorithms/) models, which combines multiple models to generate predictions that are better than any of the single models in the ensemble.\n\nTo create our ensemble, first we copy the three steps we used above to create and train a model, and apply it to the test set:","metadata":{}},{"cell_type":"code","source":"def ensemble():\n    learn = tabular_learner(dls, metrics=accuracy, layers=[10,10])\n    with learn.no_bar(),learn.no_logging(): learn.fit(16, lr=0.03)\n    return learn.get_preds(dl=tst_dl)[0]","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:28:11.178224Z","iopub.execute_input":"2024-03-14T00:28:11.178612Z","iopub.status.idle":"2024-03-14T00:28:11.187269Z","shell.execute_reply.started":"2024-03-14T00:28:11.178571Z","shell.execute_reply":"2024-03-14T00:28:11.186080Z"},"trusted":true},"execution_count":17,"outputs":[]},{"cell_type":"markdown","source":"Now we run this five times, and collect the results into a list:","metadata":{}},{"cell_type":"code","source":"learns = [ensemble() for _ in range(5)]","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:29:17.092790Z","iopub.execute_input":"2024-03-14T00:29:17.093103Z","iopub.status.idle":"2024-03-14T00:29:30.517798Z","shell.execute_reply.started":"2024-03-14T00:29:17.093069Z","shell.execute_reply":"2024-03-14T00:29:30.517012Z"},"trusted":true},"execution_count":18,"outputs":[{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"\n<style>\n    /* Turns off some styling */\n    progress {\n        /* gets rid of default border in Firefox and Opera. */\n        border: none;\n        /* Needs to be in here for Safari polyfill so background images work as expected. */\n        background-size: auto;\n    }\n    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n        background: #F44336;\n    }\n</style>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":""},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"\n<style>\n    /* Turns off some styling */\n    progress {\n        /* gets rid of default border in Firefox and Opera. */\n        border: none;\n        /* Needs to be in here for Safari polyfill so background images work as expected. */\n        background-size: auto;\n    }\n    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n        background: #F44336;\n    }\n</style>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":""},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"\n<style>\n    /* Turns off some styling */\n    progress {\n        /* gets rid of default border in Firefox and Opera. */\n        border: none;\n        /* Needs to be in here for Safari polyfill so background images work as expected. */\n        background-size: auto;\n    }\n    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n        background: #F44336;\n    }\n</style>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":""},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"\n<style>\n    /* Turns off some styling */\n    progress {\n        /* gets rid of default border in Firefox and Opera. */\n        border: none;\n        /* Needs to be in here for Safari polyfill so background images work as expected. */\n        background-size: auto;\n    }\n    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n        background: #F44336;\n    }\n</style>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":""},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":"\n<style>\n    /* Turns off some styling */\n    progress {\n        /* gets rid of default border in Firefox and Opera. */\n        border: none;\n        /* Needs to be in here for Safari polyfill so background images work as expected. */\n        background-size: auto;\n    }\n    .progress-bar-interrupted, .progress-bar-interrupted::-webkit-progress-bar {\n        background: #F44336;\n    }\n</style>\n"},"metadata":{}},{"output_type":"display_data","data":{"text/plain":"<IPython.core.display.HTML object>","text/html":""},"metadata":{}}]},{"cell_type":"markdown","source":"We stack this predictions together and take their average predictions:","metadata":{}},{"cell_type":"code","source":"ens_preds = torch.stack(learns).mean(0)","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:29:35.581685Z","iopub.execute_input":"2024-03-14T00:29:35.582040Z","iopub.status.idle":"2024-03-14T00:29:35.588511Z","shell.execute_reply.started":"2024-03-14T00:29:35.582001Z","shell.execute_reply":"2024-03-14T00:29:35.587259Z"},"trusted":true},"execution_count":19,"outputs":[]},{"cell_type":"markdown","source":"Finally, use the same code as before to generate a submission file, which we can submit to Kaggle after the notebook is saved and run:","metadata":{}},{"cell_type":"code","source":"tst_df['Survived'] = (ens_preds[:,1]>0.5).int()\nsub_df = tst_df[['PassengerId','Survived']]\nsub_df.to_csv('submission.csv', index=False)","metadata":{"execution":{"iopub.status.busy":"2024-03-14T00:31:21.707770Z","iopub.execute_input":"2024-03-14T00:31:21.708304Z","iopub.status.idle":"2024-03-14T00:31:21.722400Z","shell.execute_reply.started":"2024-03-14T00:31:21.708253Z","shell.execute_reply":"2024-03-14T00:31:21.721222Z"},"trusted":true},"execution_count":21,"outputs":[]},{"cell_type":"markdown","source":"At the time of writing, this submission is well within the top 25% of entries to the competition.\n\n(A lot of submissions to this competition use additional external data, but we have restricted ourselves to just using the data provided. We'd probably do a lot better if we used external data too. Feel free to give that a try, and see how you go. Note that you'll never be able to get to the top of the leaderboard, since a lot of folks in this competition have cheated, by downloading the answers from the internet and uploading them as their submission. In a real competition that's not possible, because the answers aren't public, but there's nothing stopping people from cheating in a tutorial/practice competition like this one. So if you're ready for a real challenge, take a look at the [competitions page](https://www.kaggle.com/competitions/) and start working on a real competition!)","metadata":{}},{"cell_type":"markdown","source":"## Final thoughts","metadata":{}},{"cell_type":"markdown","source":"As you can see, using fastai and PyTorch made things much easier than doing it from scratch, but it also hid away a lot of the details. So if you only ever use a framework, you're not going to as fully understand what's going on under the hood. That understanding can be really helpful when it comes to debugging and improving your models. But do use fastai when you're creating models on Kaggle or in \"real life\", because otherwise you're not taking advantage of all the research that's gone into optimising the models for you, and you'll end up spending more time debugging and implementing menial boiler-plate than actually solving the real problem!\n\nIf you found this notebook useful, please remember to click the little up-arrow at the top to upvote it, since I like to know when people have found my work useful, and it helps others find it too. (BTW, be sure you're looking at my [original notebook](https://www.kaggle.com/jhoward/why-you-should-use-a-framework) here when you do that, and are not on your own copy of it, otherwise your upvote won't get counted!) And if you have any questions or comments, please pop them below -- I read every comment I receive!","metadata":{}}]}