{"metadata":{"kernelspec":{"language":"python","display_name":"Python 3","name":"python3"},"language_info":{"pygments_lexer":"ipython3","nbconvert_exporter":"python","version":"3.6.4","file_extension":".py","codemirror_mode":{"name":"ipython","version":3},"name":"python","mimetype":"text/x-python"}},"nbformat_minor":4,"nbformat":4,"cells":[{"cell_type":"markdown","source":"# 7 Coolest Python Packages Top Kagglers Are Using Without Telling You\n## Let me expose the secrets...\n![](https://cdn-images-1.medium.com/max/1200/1*5IFgojJ4nU8f0YKTcjWDrg.jpeg)\n<figcaption style=\"text-align: center;\">\n    <strong>\n        Photo by \n        <a href='https://www.pexels.com/@miphotography?utm_content=attributionCopyText&utm_medium=referral&utm_source=pexels'>Miesha Maiden</a>\n        on \n        <a href='https://www.pexels.com/photo/pineapple-with-brown-sunglasses-459601/?utm_content=attributionCopyText&utm_medium=referral&utm_source=pexels'>Pexels.</a> All images are by author unless specified otherwise.\n    </strong>\n</figcaption>","metadata":{}},{"cell_type":"markdown","source":"## Setup","metadata":{"_kg_hide-input":true}},{"cell_type":"code","source":"import warnings\n\nimport matplotlib.pyplot as plt\nimport numpy as np\nimport optuna\nimport pandas as pd\nimport seaborn as sns\n\nwarnings.filterwarnings(\"ignore\")\noptuna.logging.set_verbosity(optuna.logging.WARNING)","metadata":{"execution":{"iopub.status.busy":"2021-08-06T10:07:33.134762Z","iopub.execute_input":"2021-08-06T10:07:33.135224Z","iopub.status.idle":"2021-08-06T10:07:33.142201Z","shell.execute_reply.started":"2021-08-06T10:07:33.135192Z","shell.execute_reply":"2021-08-06T10:07:33.140919Z"},"_kg_hide-input":true,"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"Kaggle is a hot spot for what is trending in data science and machine learning.\n\nDue to its competitiveness, the top players are constantly looking for new tools, technologies, and frameworks that give them an edge over others. If a new package or an algorithm delivers actionable value, there is a good chance it receives immediate adoption and becomes popular.\n\nThis post is about 7 of such trendies packages that are direct replacements for many tools and technologies that are either outdated or need urgent upgrades.","metadata":{}},{"cell_type":"markdown","source":"# 1. UMAP","metadata":{}},{"cell_type":"markdown","source":"![](https://cdn-images-1.medium.com/max/800/1*1sUCX4FKCLjJzbEqMjg2YQ.png)\n<figcaption style=\"text-align: center;\">\n    <strong>\n        <a href='https://www.kaggle.com/subinium/tps-jun-this-is-original-eda-viz/notebook?scriptVersionId=64865915&cellId=37'>Link to the code of the plot.</a>\n    </strong>\n</figcaption>","metadata":{}},{"cell_type":"markdown","source":"Above is a 100k row dataset with 75 features projected to 2D using a package called UMAP. Each dot represents a single sample in a classification problem and is color-encoded based on their class.\n\nMassive datasets like these can make you miserable during EDA, mainly because of the computation and time expenses they come with. So, it is important that each plot you create is spot-on and reveals something significant about the data.\n\nI think that's one of the reasons why UMAP (Uniform Manifold Approximation and Projection) is so well-received on Kaggle. It is efficient, low-code, and lets you take a real \"look\" at the data from a high-dimensional perspective:\n\n<p float=\"left\">\n  <img src=\"https://umap-learn.readthedocs.io/en/latest/_images/plotting_21_2.png\" width=\"250\" height=\"250\">\n  <img src=\"https://umap-learn.readthedocs.io/en/latest/_images/plotting_32_2.png\" width=\"250\" height=\"250\"> \n  <img src=\"https://umap-learn.readthedocs.io/en/latest/_images/plotting_34_2.png\" width=\"250\" height=\"250\">\n</p","metadata":{}},{"cell_type":"markdown","source":"When I look at plots like these, they remind me of why I got into data science in the first place - data is beautiful!\n\n### 🛠 GitHub and documentation\n- https://umap-learn.readthedocs.io/en/latest/\n- https://github.com/lmcinnes/umap\n\n### 🔬 Papers\n- [UMAP: Uniform Manifold Approximation and Projection for Dimension Reduction](https://arxiv.org/abs/1802.03426)\n\n### 💻 Demo\n\nUMAP offers an easy, Sklearn-compatible API. After importing the `UMAP` module, call its `fit` on the feature and target arrays (`X`, `y`) to project them to 2D by default:","metadata":{}},{"cell_type":"markdown","source":"```python\nimport umap  # pip install umap-learn\n\n# Create the mapper\nmapper = umap.UMAP()\n# Fit to the data\nmapper.fit(X, y)\n\n# Plot as a scatterplot\numap.plot.points(mapper)\n```","metadata":{}},{"cell_type":"markdown","source":"The most important parameters of `UMAP` estimator are `n_neighbors` and `min_dist` (minimum distance). Think of `n_neighbors` as a handle that controls the zoom level of the projection. `min_dist` is the minimum distance between each projected point.\n\nIf you wish to project to a higher dimension, you can tweak `n_components` just like in  Sklearn's `PCA`.","metadata":{}},{"cell_type":"markdown","source":"# 2. Datatable","metadata":{}},{"cell_type":"markdown","source":"![](https://cdn-images-1.medium.com/max/800/1*HfCFXaFA0cS2uLw1Gv3x9w.png)","metadata":{}},{"cell_type":"markdown","source":"As dataset sizes are getting bigger, people are paying more attention to out-of-memory, multi-threaded data preprocessing tools to escape the performance limitations of Pandas.\n\nOne of the most promising tools in this regard is `datatable`, inspired by R's `data.table` package. It is developed by H2O.ai to support parallel-computing and out-of-memory operations on big data (up to 100 GB), as required by today's machine learning applications.\n\nWhile `datatable` does not have as large a suite of manipulation functions as pandas, it is found to heavily outperform it on most common operations. In an [experiment](https://www.kaggle.com/rohanrao/tutorial-on-reading-large-datasets) done on a 100M row dataset, datatable manages to read the data into memory in just over a minute, 9 times faster than pandas.","metadata":{}},{"cell_type":"markdown","source":"### 🛠 GitHub and documentation\n- https://github.com/h2oai/datatable\n- https://datatable.readthedocs.io/en/latest/?badge=latest\n\n### 💻 Demo","metadata":{}},{"cell_type":"markdown","source":"The main data structure in `datatable` is `Frame` (as in DataFrame). ","metadata":{}},{"cell_type":"code","source":"import datatable as dt  # pip install datatable\n\nframe = dt.fread(\"https://raw.githubusercontent.com/BexTuychiev/medium_stories/master/2021/august/2_popular_kaggle_packages/data/station_day.csv\")\nframe.head(5)","metadata":{"execution":{"iopub.status.busy":"2021-08-06T10:07:33.14418Z","iopub.execute_input":"2021-08-06T10:07:33.144689Z","iopub.status.idle":"2021-08-06T10:07:33.598202Z","shell.execute_reply.started":"2021-08-06T10:07:33.144642Z","shell.execute_reply":"2021-08-06T10:07:33.597393Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"type(frame)","metadata":{"execution":{"iopub.status.busy":"2021-08-06T10:07:33.603184Z","iopub.execute_input":"2021-08-06T10:07:33.605795Z","iopub.status.idle":"2021-08-06T10:07:33.612189Z","shell.execute_reply.started":"2021-08-06T10:07:33.605745Z","shell.execute_reply":"2021-08-06T10:07:33.611472Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"A simple GroupBy operation:","metadata":{}},{"cell_type":"code","source":"from datatable import by, f, sum\n\ntips = sns.load_dataset(\"tips\")\nframe = dt.Frame(tips)\nframe[:, sum(f.total_bill), by(f.size)]","metadata":{"execution":{"iopub.status.busy":"2021-08-06T10:07:33.613357Z","iopub.execute_input":"2021-08-06T10:07:33.613723Z","iopub.status.idle":"2021-08-06T10:07:33.670296Z","shell.execute_reply.started":"2021-08-06T10:07:33.613694Z","shell.execute_reply":"2021-08-06T10:07:33.669465Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# 3. Lazypredict","metadata":{}},{"cell_type":"markdown","source":"Lazypredict is one of the best one-liner packages I have ever seen.\n\nUsing the library, you can train almost all Sklearn models plus XGBoost and LightGBM in a single line of code. It only has two estimators - one for regression and one for classification. Fitting either one on a dataset with a given target will evaluate more than 30 base models and generate a report with their rankings on several popular metrics.\n\n### 💻 Demo","metadata":{}},{"cell_type":"markdown","source":"```python\nfrom lazypredict.Supervised import (  # pip install lazypredict\n    LazyClassifier,\n    LazyRegressor,\n)\nfrom sklearn.datasets import load_boston\nfrom sklearn.model_selection import train_test_split\n\n# Load data and split\nX, y = load_boston(return_X_y=True)\nX_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2)\n\n# Fit LazyRegressor\nreg = LazyRegressor(ignore_warnings=True, random_state=1121218, verbose=False)\nmodels, predictions = reg.fit(X_train, X_test, y_train, y_test)  # pass all sets\n\nmodels.head(10)\n```","metadata":{"execution":{"iopub.status.busy":"2021-08-06T10:06:16.307862Z","iopub.execute_input":"2021-08-06T10:06:16.308309Z","iopub.status.idle":"2021-08-06T10:06:17.353925Z","shell.execute_reply.started":"2021-08-06T10:06:16.308271Z","shell.execute_reply":"2021-08-06T10:06:17.352114Z"}}},{"cell_type":"markdown","source":"![image.png](attachment:41542a5f-77e6-4b56-8898-9f8cbc519658.png)","metadata":{"execution":{"iopub.status.busy":"2021-08-06T10:04:36.380179Z","iopub.status.idle":"2021-08-06T10:04:36.380635Z"}},"attachments":{"41542a5f-77e6-4b56-8898-9f8cbc519658.png":{"image/png":"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"}}},{"cell_type":"markdown","source":"An insight like this will free you from the manual task of selecting a base model, a time much better spent on tasks like feature engineering.\n\n### 🛠 GitHub and documentation\n- https://lazypredict.readthedocs.io/en/latest/index.html\n- https://github.com/shankarpandala/lazypredict","metadata":{}},{"cell_type":"markdown","source":"# 4. Optuna","metadata":{}},{"cell_type":"markdown","source":"![](https://miro.medium.com/max/1400/0*IBkpkOCS0anhUHWp.png)","metadata":{}},{"cell_type":"markdown","source":"One of the more recent libraries I have added to my skill-stack is Kagglers' favorite - Optuna. \n\nOptuna is a next-generation automatic hyperparameter tuning framework, designed to work on virtually any model and neural network available in today's ML and Deep learning packages. \n\nIt offers several advantages over similar tools like GridSearch, TPOT, HyperOPT, etc:\n- Platform-agnostic: has APIs to work with any framework, including XGBoost, LightGBM, CatBoost, Sklearn, Keras, TensorFlow, PyTorch, etc.\n- A large suite of optimization algorithms with early stopping and pruning features baked in\n- Easy parallelization with little or no changes to the code\n- Built in support to visually explore tuning history and the importance of each hyperparameter.\n\nMy most favorite feature is its ability to pause/resume/save search histories. Optuna keeps track of all previous rounds of tuning and you can resume the search for however long you want until you get the performance you want. \n\nBesides, you can make Optuna RAM-independent for massive datasets and searching by storing results in a local or a remote database by just adding an extra parameter.\n\n### 🛠 GitHub and documentation\n- https://github.com/optuna/optuna\n- https://optuna.readthedocs.io/en/stable/\n\n### 🔬 Papers\n- [Optuna: A Next-generation Hyperparameter Optimization Framework](https://arxiv.org/abs/1907.10902)\n\n### 💻 Demo","metadata":{}},{"cell_type":"code","source":"import optuna  # pip install optuna\n\n\ndef objective(trial):\n    x = trial.suggest_float(\"x\", -7, 7)\n    y = trial.suggest_float(\"y\", -7, 7)\n    return (x - 1) ** 2 + (y + 3) ** 2\n\n\nstudy = optuna.create_study()\nstudy.optimize(objective, n_trials=200)  # number of iterations\n\nstudy.best_params","metadata":{"execution":{"iopub.status.busy":"2021-08-06T10:07:33.673976Z","iopub.execute_input":"2021-08-06T10:07:33.674644Z","iopub.status.idle":"2021-08-06T10:07:35.018827Z","shell.execute_reply.started":"2021-08-06T10:07:33.674604Z","shell.execute_reply":"2021-08-06T10:07:35.017901Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"code","source":"study.best_value","metadata":{"execution":{"iopub.status.busy":"2021-08-06T10:07:35.019865Z","iopub.execute_input":"2021-08-06T10:07:35.02011Z","iopub.status.idle":"2021-08-06T10:07:35.026138Z","shell.execute_reply.started":"2021-08-06T10:07:35.020087Z","shell.execute_reply":"2021-08-06T10:07:35.02497Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"For the sake of simplicity, we are trying to optimize the function $(x - 1)^2 + (y + 3)^2$. As you can see, the tuned values for `x` and `y` are pretty close to the optimal (1, -3). \n\nHyperparamter tuning for real estimators is a bit more involved, so why don't you check out my detailed guide:\n\nhttps://www.kaggle.com/bextuychiev/no-bs-guide-to-hyperparameter-tuning-with-optuna","metadata":{}},{"cell_type":"markdown","source":"# 5. SHAP","metadata":{}},{"cell_type":"markdown","source":"![](https://shap.readthedocs.io/en/latest/_images/shap_header.png)","metadata":{}},{"cell_type":"markdown","source":"Explainable AI (XAI) is one of the strongest trends in the ML and AI sphere. Companies and businesses are starting to be fussy over the adoption of AI solutions due to their \"black box\" nature.\n\nHey, no one can blame them. If data scientists themselves are coming up with tools to understand the models they created, the worries and suspicions of business owners are entirely justified.\n\nOne of those tools that often come up in grandmasters' notebooks on Kaggle is SHAP.\n\nSHAP (Shapley Additive exPlanations) is an approach to explain how a model works using concepts from game theory. At its score, SHAP uses something called Shapley values to explain:\n- Which features in the model are the most important\n- The model's decisions behind any single prediction. For example, asking which features led to this particular output.\n\nThe most notable aspects of SHAP are its unified theme and unique plots that break down the mechanics of any model and neural network. Here is an example plot that shows the feature importances in terms of Shapley values for a single prediction:\n\n![](https://raw.githubusercontent.com/slundberg/shap/master/docs/artwork/boston_waterfall.png)","metadata":{}},{"cell_type":"markdown","source":"Trust me, SHAP has way cooler plots. It is such a powerful tool that the Kaggle platform has an [entire free course](https://www.kaggle.com/learn/machine-learning-explainability) built around it. \n\n### 🛠 GitHub and documentation\n- https://shap.readthedocs.io/en/latest/index.html\n- https://github.com/slundberg/shap\n\n### 🔬 Papers\n- [A Unified Approach to Interpreting Model Predictions](https://proceedings.neurips.cc/paper/2017/hash/8a20a8621978632d76c43dfd28b67767-Abstract.html)\n- [From local explanations to global understanding with explainable AI for trees](https://www.nature.com/articles/s42256-019-0138-9)\n- [Explainable machine-learning predictions for the prevention of hypoxaemia during surgery](https://www.nature.com/articles/s41551-018-0304-0)\n\n### 💻 Demo\nHere is a short snippet to create a beeswarm plot of all predictions from the classic Diabeters dataset:","metadata":{}},{"cell_type":"code","source":"import shap  # pip install shap\nimport xgboost as xgb\n\n# Load and train a model\nX, y = shap.datasets.diabetes()\nclf = xgb.XGBRegressor().fit(X, y)\n\n# Explain model's predictions with SHAP\nexplainer = shap.Explainer(clf)\nshap_values = explainer(X)\n\n# Visualize the predictions' explanation\nshap.plots.beeswarm(shap_values)","metadata":{"execution":{"iopub.status.busy":"2021-08-06T10:07:35.028792Z","iopub.execute_input":"2021-08-06T10:07:35.029302Z","iopub.status.idle":"2021-08-06T10:07:42.517777Z","shell.execute_reply.started":"2021-08-06T10:07:35.029239Z","shell.execute_reply":"2021-08-06T10:07:42.516717Z"},"trusted":true},"execution_count":null,"outputs":[]},{"cell_type":"markdown","source":"# 6. Rapids cuDF","metadata":{}},{"cell_type":"markdown","source":"![](https://cdn-images-1.medium.com/max/800/1*ZoH5jGuQiKKhxeZYNHcwDA.png)","metadata":{}},{"cell_type":"markdown","source":"If you thought GPUs are deep learning-exclusive, you are *horribly* mistaken.\n\nThe cuDF library, created by the open-source platform RAPIDs, enables you to run tabular manipulation operations on one or more GPUs.\n\nUnlike datatable, cuDF has a very similar API to Pandas, thus offering a less steep learning curve. As it is standard with GPUs, the library is super fast, giving it an edge over datatable when combined with its Pandas-like API.\n\nThe only hassle when using cuDF is its installation - it requires:\n- CUDA Toolkit 11.0+\n- NVIDIA driver 450.80.02+\n- Pascal architecture or better (Compute Capability >=6.0)\n\nIf you want to try out the library without installation limitations, Kaggle kernels are a great option. Here is a [notebook](https://www.kaggle.com/rohanrao/tutorial-on-reading-large-datasets?scriptVersionId=49328159&cellId=14) to get you started.\n\n### 🛠 GitHub and documentation\n- https://docs.rapids.ai/api/cudf/stable/\n- https://github.com/rapidsai/cudf\n\n### 💻 Demo\nHere is a snippet from the documentation that shows a simple GroupBy operation on the tips dataset:","metadata":{}},{"cell_type":"markdown","source":"```python\nimport cudf, io, requests\nfrom io import StringIO\n\nurl = \"https://github.com/plotly/datasets/raw/master/tips.csv\"\ncontent = requests.get(url).content.decode('utf-8')\n\ntips_df = cudf.read_csv(StringIO(content))\ntips_df['tip_percentage'] = tips_df['tip'] / tips_df['total_bill'] * 100\n\n# display average tip by dining party size\nprint(tips_df.groupby('size').tip_percentage.mean())\n```","metadata":{}},{"cell_type":"markdown","source":"# 7. Automatic EDA libraries","metadata":{}},{"cell_type":"markdown","source":"Normally, I am against any library or tool that takes a programmer away from writing actual code. But, since auto-EDA libraries are all the rage now on Kaggle, I had to include this section for completeness.\n\nInitially, this section was supposed to be only about AutoViz, which uses XGBoost under the hood to display the most important information of the dataset (that's why I chose it). Later, I decided to include a few others as well.\n\nHere is a list of the best auto EDA libraries I have found:\n- **DataPrep** - the most comprehensive auto EDA \\[[GitHub](https://github.com/sfu-db/dataprep), [Documentation](https://docs.dataprep.ai/index.html)\\]\n- **AutoViz** - the fastest auto EDA \\[[GitHub](https://github.com/AutoViML/AutoViz)]\n- **PandasProfiling** - the earliest and one of the best auto EDA tools \\[[GitHub](https://github.com/pandas-profiling/pandas-profiling), [Documentation](https://pandas-profiling.github.io/pandas-profiling/docs/master/rtd/)\\]\n- **Lux** - the most user-friendly and luxurious EDA \\[[GitHub](https://github.com/lux-org/lux), [Documentation](https://lux-api.readthedocs.io/en/latest/)\\]\n\n### 💻 Demo\nIf you want to see how each package performs EDA, check out this great [notebook](https://www.kaggle.com/andreshg/automatic-eda-libraries-comparisson/notebook#6.-%F0%9F%93%8A-D-Tale-%F0%9F%93%9A) on Kaggle.","metadata":{}},{"cell_type":"markdown","source":"## Summary","metadata":{}},{"cell_type":"markdown","source":"The available tools and packages to execute data science tasks are endless. Everyone has the right to be overwhelmed by this.\n\nBut I sincerely hope the tools outlined in this posted helped narrow down your focus to what is trending and delivering results in the hands of members of the largest ML community.","metadata":{}},{"cell_type":"markdown","source":"## Here are my latest viral hits...\n- [20 Burning XGBoost FAQs Answered to Use the Library Like a Pro](https://towardsdatascience.com/20-burning-xgboost-faqs-answered-to-use-the-library-like-a-pro-f8013b8df3e4?source=your_stories_page-------------------------------------)\n- [25 Pandas Functions You Didn’t Know Existed | P(Guarantee) = 0.8](https://towardsdatascience.com/25-pandas-functions-you-didnt-know-existed-p-guarantee-0-8-1a05dcaad5d0?source=your_stories_page-------------------------------------)\n- [Matplotlib vs. Plotly: Let’s Decide Once and for All\n](https://towardsdatascience.com/matplotlib-vs-plotly-lets-decide-once-and-for-all-ad25a5e43322?source=your_stories_page-------------------------------------)","metadata":{}}]}