├── Interview Preparation- Day 1.ipynb ├── Interview Preparation- Day 2- Linear Regression.ipynb ├── Interview Preparation- Day 3-SVM.ipynb ├── Interview Preparation- Day 4- Decision Trees.ipynb ├── Interview Preparation- Day 5-Logistic Regression.ipynb ├── Interview Preparation-Random Forest-Bagging.ipynb ├── Interview Preparation-Xgboost,GBboost,Adaboost--Boosting.ipynb └── README.md /Interview Preparation- Day 1.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### How To Learn Machine Learning Algorithms For Interviews\n", 8 | "\n", 9 | "#### Naive Bayes Classifier\n", 10 | "\n", 11 | "Theoretical Understanding:\n", 12 | "\n", 13 | "1. Tutorial 48th : https://www.youtube.com/watch?v=jS1CKhALUBQ\n", 14 | "2. Tutorial 49th: https://www.youtube.com/watch?v=temQ8mHpe3k" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "##### 1. What Are the Basic Assumption?\n", 22 | "Features Are Independent" 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "##### 2. Advantages\n", 30 | "1. Work Very well with many number of features\n", 31 | "2. Works Well with Large training Dataset\n", 32 | "3. It converges faster when we are training the model\n", 33 | "4. It also performs well with categorical features" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "##### 3. Disadvantages\n", 41 | "1. Correlated features affects performance" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "##### 4. Whether Feature Scaling is required?\n", 49 | "No\n", 50 | "##### 5. Impact of Missing Values?\n", 51 | "Naive Bayes can handle missing data. Attributes are handled separately by the algorithm at both model construction time and prediction time. As such, if a data instance has a missing value for an attribute, it can be ignored while preparing the model, and ignored when a probability is calculated for a class value\n", 52 | "tutorial :https://www.youtube.com/watch?v=EqjyLfpv5oA\n", 53 | "##### 6. Impact of outliers?\n", 54 | "It is usually robust to outliers" 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "##### Different Problem statement you can solve using Naive Baye's\n", 62 | "1. Sentiment Analysis\n", 63 | "2. Spam classification\n", 64 | "3. twitter sentiment analysis\n", 65 | "4. document categorization" 66 | ] 67 | }, 68 | { 69 | "cell_type": "code", 70 | "execution_count": null, 71 | "metadata": {}, 72 | "outputs": [], 73 | "source": [ 74 | "-" 75 | ] 76 | } 77 | ], 78 | "metadata": { 79 | "kernelspec": { 80 | "display_name": "Python 3", 81 | "language": "python", 82 | "name": "python3" 83 | }, 84 | "language_info": { 85 | "codemirror_mode": { 86 | "name": "ipython", 87 | "version": 3 88 | }, 89 | "file_extension": ".py", 90 | "mimetype": "text/x-python", 91 | "name": "python", 92 | "nbconvert_exporter": "python", 93 | "pygments_lexer": "ipython3", 94 | "version": "3.7.9" 95 | } 96 | }, 97 | "nbformat": 4, 98 | "nbformat_minor": 4 99 | } 100 | -------------------------------------------------------------------------------- /Interview Preparation- Day 2- Linear Regression.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### How To Learn Machine Learning Algorithms For Interviews\n", 8 | "\n", 9 | "#### Linear Regression\n", 10 | "\n", 11 | "Theoretical Understanding:\n", 12 | "\n", 13 | "1. https://www.youtube.com/watch?v=1-OGRohmH2s&list=PLZoTAELRMXVPBTrWtJkn3wWQxZkmTXGwe&index=29\n", 14 | "2. https://www.youtube.com/watch?v=5rvnlZWzox8&list=PLZoTAELRMXVPBTrWtJkn3wWQxZkmTXGwe&index=34\n", 15 | "3. https://www.youtube.com/watch?v=NAPhUDjgG_s&list=PLZoTAELRMXVPBTrWtJkn3wWQxZkmTXGwe&index=32\n", 16 | "4. https://www.youtube.com/watch?v=WuuyD3Yr-js&list=PLZoTAELRMXVPBTrWtJkn3wWQxZkmTXGwe&index=35\n", 17 | "5. https://www.youtube.com/watch?v=BqzgUnrNhFM&list=PLZoTAELRMXVPBTrWtJkn3wWQxZkmTXGwe&index=33" 18 | ] 19 | }, 20 | { 21 | "cell_type": "markdown", 22 | "metadata": {}, 23 | "source": [ 24 | "##### Interview Question on Multicollinearity\n", 25 | "\n", 26 | "1. https://www.youtube.com/watch?v=tcaruVHXZwE" 27 | ] 28 | }, 29 | { 30 | "cell_type": "markdown", 31 | "metadata": {}, 32 | "source": [ 33 | "##### 1. What Are the Basic Assumption?(favourite)\n", 34 | "There are four assumptions associated with a linear regression model:\n", 35 | "\n", 36 | "1. Linearity: The relationship between X and the mean of Y is linear.\n", 37 | "2. Homoscedasticity: The variance of residual is the same for any value of X.\n", 38 | "3. Independence: Observations are independent of each other.\n", 39 | "4. Normality: For any fixed value of X, Y is normally distributed." 40 | ] 41 | }, 42 | { 43 | "cell_type": "markdown", 44 | "metadata": {}, 45 | "source": [ 46 | "##### 2. Advantages\n", 47 | "1. Linear regression performs exceptionally well for linearly separable data\n", 48 | "2. Easy to implement and train the model\n", 49 | "3. It can handle overfitting using dimensionlity reduction techniques and cross validation and regularization \n" 50 | ] 51 | }, 52 | { 53 | "cell_type": "markdown", 54 | "metadata": {}, 55 | "source": [ 56 | "##### 3. Disadvantages\n", 57 | "1. Sometimes Lot of Feature Engineering Is required\n", 58 | "2. If the independent features are correlated it may affect performance\n", 59 | "3. It is often quite prone to noise and overfitting" 60 | ] 61 | }, 62 | { 63 | "attachments": { 64 | "image.png": { 65 | "image/png": "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" 66 | } 67 | }, 68 | "cell_type": "markdown", 69 | "metadata": {}, 70 | "source": [ 71 | "##### 4. Whether Feature Scaling is required?\n", 72 | "Yes\n", 73 | "##### 5. Impact of Missing Values?\n", 74 | "It is sensitive to missing values\n", 75 | "##### 6. Impact of outliers?\n", 76 | "linear regression needs the relationship between the independent and dependent variables to be linear. It is also important to check for outliers since linear regression is sensitive to outlier effects.\n", 77 | "\n", 78 | "![image.png](attachment:image.png)" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "##### Types of Problems it can solve(Supervised)\n", 86 | "1. Regression" 87 | ] 88 | }, 89 | { 90 | "cell_type": "markdown", 91 | "metadata": {}, 92 | "source": [ 93 | "##### Overfitting And Underfitting\n", 94 | "HomeWork?" 95 | ] 96 | }, 97 | { 98 | "cell_type": "markdown", 99 | "metadata": {}, 100 | "source": [ 101 | "##### Different Problem statement you can solve using Linear Regression\n", 102 | "1. Advance House Price Prediction\n", 103 | "2. Flight Price Prediction" 104 | ] 105 | }, 106 | { 107 | "cell_type": "markdown", 108 | "metadata": {}, 109 | "source": [ 110 | "#### Practical Implementation\n", 111 | "1. https://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LinearRegression.html" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": null, 117 | "metadata": {}, 118 | "outputs": [], 119 | "source": [] 120 | } 121 | ], 122 | "metadata": { 123 | "kernelspec": { 124 | "display_name": "Python 3", 125 | "language": "python", 126 | "name": "python3" 127 | }, 128 | "language_info": { 129 | "codemirror_mode": { 130 | "name": "ipython", 131 | "version": 3 132 | }, 133 | "file_extension": ".py", 134 | "mimetype": "text/x-python", 135 | "name": "python", 136 | "nbconvert_exporter": "python", 137 | "pygments_lexer": "ipython3", 138 | "version": "3.7.9" 139 | } 140 | }, 141 | "nbformat": 4, 142 | "nbformat_minor": 4 143 | } 144 | -------------------------------------------------------------------------------- /Interview Preparation- Day 3-SVM.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### How To Learn Machine Learning Algorithms For Interviews\n", 8 | "\n", 9 | "#### SVM\n", 10 | "\n", 11 | "Theoretical Understanding:\n", 12 | "\n", 13 | "1. https://www.youtube.com/watch?v=H9yACitf-KM\n", 14 | "2. https://www.youtube.com/watch?v=Js3GLb1xPhc" 15 | ] 16 | }, 17 | { 18 | "cell_type": "markdown", 19 | "metadata": {}, 20 | "source": [ 21 | "##### 1. What Are the Basic Assumption?\n", 22 | "There are no such assumptions" 23 | ] 24 | }, 25 | { 26 | "cell_type": "markdown", 27 | "metadata": {}, 28 | "source": [ 29 | "##### 2. Advantages\n", 30 | "1. SVM is more effective in high dimensional spaces.\n", 31 | "2. SVM is relatively memory efficient.\n", 32 | "3. SVM’s are very good when we have no idea on the data.\n", 33 | "4. Works well with even unstructured and semi structured data like text, Images and trees.\n", 34 | "5. The kernel trick is real strength of SVM. With an appropriate kernel function, we can solve any complex problem.\n", 35 | "6. SVM models have generalization in practice, the risk of over-fitting is less in SVM." 36 | ] 37 | }, 38 | { 39 | "cell_type": "markdown", 40 | "metadata": {}, 41 | "source": [ 42 | "##### 3. Disadvantages\n", 43 | "1. More Training Time is required for larger dataset\n", 44 | "2. It is difficult to choose a good kernel function\n", 45 | "https://www.youtube.com/watch?v=mTyT-oHoivA\n", 46 | "3. The SVM hyper parameters are Cost -C and gamma. It is not that easy to fine-tune these hyper-parameters. It is hard to visualize their impact" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "##### 4. Whether Feature Scaling is required?\n", 54 | "Yes\n", 55 | "##### 5. Impact of Missing Values?\n", 56 | "Although SVMs are an attractive option when constructing a classifier, SVMs do not easily accommodate missing covariate information. Similar to other prediction and classification methods, in-attention to missing data when constructing an SVM can impact the accuracy and utility of the resulting classifier.\n", 57 | "##### 6. Impact of outliers?\n", 58 | "It is usually sensitive to outliers\n", 59 | "https://arxiv.org/abs/1409.0934#:~:text=Despite%20its%20popularity%2C%20SVM%20has,causes%20the%20sensitivity%20to%20outliers." 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "##### Types of Problems it can solve(Supervised)\n", 67 | "1. Classification\n", 68 | "2. Regression" 69 | ] 70 | }, 71 | { 72 | "cell_type": "markdown", 73 | "metadata": {}, 74 | "source": [ 75 | "##### Overfitting And Underfitting\n", 76 | "In SVM, to avoid overfitting, we choose a Soft Margin, instead of a Hard one i.e. we let some data points enter our margin intentionally (but we still penalize it) so that our classifier don't overfit on our training sample\n", 77 | "\n", 78 | "https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "##### Different Problem statement you can solve using Naive Baye's\n", 86 | "1. We can use SVM with every ANN usecases\n", 87 | "2. Intrusion Detection\n", 88 | "3. Handwriting Recognition" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "#### Practical Implementation\n", 96 | "1. https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVC.html\n", 97 | "2. https://scikit-learn.org/stable/modules/generated/sklearn.svm.SVR.html" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "##### Performance Metrics" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "##### Classification\n", 112 | "1. Confusion Matrix \n", 113 | "2. Precision,Recall, F1 score\n", 114 | "\n", 115 | "##### Regression\n", 116 | "1. R2,Adjusted R2\n", 117 | "2. MSE,RMSE,MAE" 118 | ] 119 | }, 120 | { 121 | "cell_type": "code", 122 | "execution_count": null, 123 | "metadata": {}, 124 | "outputs": [], 125 | "source": [] 126 | } 127 | ], 128 | "metadata": { 129 | "kernelspec": { 130 | "display_name": "Python 3", 131 | "language": "python", 132 | "name": "python3" 133 | }, 134 | "language_info": { 135 | "codemirror_mode": { 136 | "name": "ipython", 137 | "version": 3 138 | }, 139 | "file_extension": ".py", 140 | "mimetype": "text/x-python", 141 | "name": "python", 142 | "nbconvert_exporter": "python", 143 | "pygments_lexer": "ipython3", 144 | "version": "3.7.9" 145 | } 146 | }, 147 | "nbformat": 4, 148 | "nbformat_minor": 4 149 | } 150 | -------------------------------------------------------------------------------- /Interview Preparation- Day 4- Decision Trees.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### How To Learn Machine Learning Algorithms For Interviews\n", 8 | "\n", 9 | "#### Decision Tree Classifier And Regressor\n", 10 | "Interview Questions:\n", 11 | "1. Decision Tree \n", 12 | "2. Entropy, Information Gain, Gini Impurity\n", 13 | "3. Decision Tree Working For Categorical and Numerical Features\n", 14 | "4. What are the scenarios where Decision Tree works well\n", 15 | "5. Decision Tree Low Bias And High Variance- Overfitting\n", 16 | "6. Hyperparameter Techniques\n", 17 | "7. Library used for constructing decision tree\n", 18 | "8. Impact of Outliers Of Decision Tree\n", 19 | "9. Impact of mising values on Decision Tree\n", 20 | "10. Does Decision Tree require Feature Scaling\n", 21 | " \n", 22 | "\n", 23 | "Theoretical Understanding:\n", 24 | "\n", 25 | "1. Tutorial 37:Entropy In Decision Tree https://www.youtube.com/watch?v=1IQOtJ4NI_0\n", 26 | "2. Tutorial 38:Information Gain https://www.youtube.com/watch?v=FuTRucXB9rA\n", 27 | "3. Tutorial 39:Gini Impurity https://www.youtube.com/watch?v=5aIFgrrTqOw\n", 28 | "4. Tutorial 40: Decision Tree For Numerical Features: https://www.youtube.com/watch?v=5O8HvA9pMew \n", 29 | "5. How To Visualize DT: https://www.youtube.com/watch?v=ot75kOmpYjI" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": null, 35 | "metadata": {}, 36 | "outputs": [], 37 | "source": [] 38 | }, 39 | { 40 | "cell_type": "markdown", 41 | "metadata": {}, 42 | "source": [ 43 | "##### 1. What Are the Basic Assumption?\n", 44 | "There are no such assumptions" 45 | ] 46 | }, 47 | { 48 | "cell_type": "markdown", 49 | "metadata": {}, 50 | "source": [ 51 | "##### 2. Advantages\n", 52 | "Advantages of Decision Tree\n", 53 | "\n", 54 | "1. Clear Visualization: The algorithm is simple to understand, interpret and visualize as the idea is mostly used in our daily lives. Output of a Decision Tree can be easily interpreted by humans.\n", 55 | "\n", 56 | "2. Simple and easy to understand: Decision Tree looks like simple if-else statements which are very easy to understand.\n", 57 | "\n", 58 | "3. Decision Tree can be used for both classification and regression problems.\n", 59 | "\n", 60 | "4. Decision Tree can handle both continuous and categorical variables.\n", 61 | "\n", 62 | "5. No feature scaling required: No feature scaling (standardization and normalization) required in case of Decision Tree as it uses rule based approach instead of distance calculation.\n", 63 | "\n", 64 | "6. Handles non-linear parameters efficiently: Non linear parameters don't affect the performance of a Decision Tree unlike curve based algorithms. So, if there is high non-linearity between the independent variables, Decision Trees may outperform as compared to other curve based algorithms.\n", 65 | "\n", 66 | "7. Decision Tree can automatically handle missing values.\n", 67 | "\n", 68 | "8. Decision Tree is usually robust to outliers and can handle them automatically.\n", 69 | "\n", 70 | "9. Less Training Period: Training period is less as compared to Random Forest because it generates only one tree unlike forest of trees in the Random Forest. " 71 | ] 72 | }, 73 | { 74 | "cell_type": "markdown", 75 | "metadata": {}, 76 | "source": [ 77 | "##### 3. Disadvantages\n", 78 | "Disadvantages of Decision Tree\n", 79 | "\n", 80 | "1. Overfitting: This is the main problem of the Decision Tree. It generally leads to overfitting of the data which ultimately leads to wrong predictions. In order to fit the data (even noisy data), it keeps generating new nodes and ultimately the tree becomes too complex to interpret. In this way, it loses its generalization capabilities. It performs very well on the trained data but starts making a lot of mistakes on the unseen data.\n", 81 | "\n", 82 | "\n", 83 | "2. High variance: As mentioned in point 1, Decision Tree generally leads to the overfitting of data. Due to the overfitting, there are very high chances of high variance in the output which leads to many errors in the final estimation and shows high inaccuracy in the results. In order to achieve zero bias (overfitting), it leads to high variance. \n", 84 | "\n", 85 | "3. Unstable: Adding a new data point can lead to re-generation of the overall tree and all nodes need to be recalculated and recreated. \n", 86 | "\n", 87 | "4. Not suitable for large datasets: If data size is large, then one single tree may grow complex and lead to overfitting. So in this case, we should use Random Forest instead of a single Decision Tree." 88 | ] 89 | }, 90 | { 91 | "cell_type": "markdown", 92 | "metadata": {}, 93 | "source": [ 94 | "##### 4. Whether Feature Scaling is required?\n", 95 | "No\n", 96 | "\n", 97 | "##### 6. Impact of outliers?\n", 98 | "It is not sensitive to outliers.Since, extreme values or outliers, never cause much reduction in RSS, they are never involved in split. Hence, tree based methods are insensitive to outliers." 99 | ] 100 | }, 101 | { 102 | "cell_type": "markdown", 103 | "metadata": {}, 104 | "source": [ 105 | "##### Types of Problems it can solve(Supervised)\n", 106 | "1. Classification\n", 107 | "2. Regression" 108 | ] 109 | }, 110 | { 111 | "cell_type": "markdown", 112 | "metadata": {}, 113 | "source": [ 114 | "##### Overfitting And Underfitting\n", 115 | "Ho to avoid overfitting\n", 116 | "\n", 117 | "https://www.youtube.com/watch?v=SLOyyFHbiqo" 118 | ] 119 | }, 120 | { 121 | "cell_type": "markdown", 122 | "metadata": {}, 123 | "source": [ 124 | "\n" 125 | ] 126 | }, 127 | { 128 | "cell_type": "markdown", 129 | "metadata": {}, 130 | "source": [ 131 | "#### Practical Implementation\n", 132 | "1. https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html\n", 133 | "2. https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html" 134 | ] 135 | }, 136 | { 137 | "cell_type": "markdown", 138 | "metadata": {}, 139 | "source": [ 140 | "##### Performance Metrics" 141 | ] 142 | }, 143 | { 144 | "cell_type": "markdown", 145 | "metadata": {}, 146 | "source": [ 147 | "##### Classification\n", 148 | "1. Confusion Matrix \n", 149 | "2. Precision,Recall, F1 score\n", 150 | "\n", 151 | "##### Regression\n", 152 | "1. R2,Adjusted R2\n", 153 | "2. MSE,RMSE,MAE" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": null, 159 | "metadata": {}, 160 | "outputs": [], 161 | "source": [] 162 | } 163 | ], 164 | "metadata": { 165 | "kernelspec": { 166 | "display_name": "Python 3", 167 | "language": "python", 168 | "name": "python3" 169 | }, 170 | "language_info": { 171 | "codemirror_mode": { 172 | "name": "ipython", 173 | "version": 3 174 | }, 175 | "file_extension": ".py", 176 | "mimetype": "text/x-python", 177 | "name": "python", 178 | "nbconvert_exporter": "python", 179 | "pygments_lexer": "ipython3", 180 | "version": "3.7.9" 181 | } 182 | }, 183 | "nbformat": 4, 184 | "nbformat_minor": 4 185 | } 186 | -------------------------------------------------------------------------------- /Interview Preparation- Day 5-Logistic Regression.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### How To Learn Machine Learning Algorithms For Interviews\n", 8 | "\n", 9 | "#### Logistics Regression\n", 10 | " \n", 11 | "\n", 12 | "Theoretical Understanding:\n", 13 | "\n", 14 | "1. Tutorial 35:Logitic Regression Part 1 https://www.youtube.com/watch?v=L_xBe7MbPwk\n", 15 | "2. Tutorial 36:Logitic Regression Part 2 https://www.youtube.com/watch?v=uFfsSgQgerw\n", 16 | "3. Tutorial 39:Logitic Regression Part 3 https://www.youtube.com/watch?v=V8fS0T_ktn4\n", 17 | "4. Tutorial 42:How To Find Optimal Threshold for Binary classification: https://www.youtube.com/watch?v=_AjhdXuXEDE\n", 18 | "5. Interview question: https://www.youtube.com/watch?v=tcaruVHXZwE&t=122s" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": null, 24 | "metadata": {}, 25 | "outputs": [], 26 | "source": [] 27 | }, 28 | { 29 | "cell_type": "markdown", 30 | "metadata": {}, 31 | "source": [ 32 | "##### 1. What Are the Basic Assumption?\n", 33 | "1. Linear Relation between independent features and the log odds" 34 | ] 35 | }, 36 | { 37 | "cell_type": "markdown", 38 | "metadata": {}, 39 | "source": [ 40 | "##### 2. Advantages\n", 41 | "Advantages of Logistics Regression\n", 42 | "\n", 43 | "1. Logistic Regression Are very easy to understand\n", 44 | "2. It requires less training\n", 45 | "3. Good accuracy for many simple data sets and it performs well when the dataset is linearly separable.\n", 46 | "4. It makes no assumptions about distributions of classes in feature space.\n", 47 | "5. Logistic regression is less inclined to over-fitting but it can overfit in high dimensional datasets.One may consider Regularization (L1 and L2) techniques to avoid over-fittingin these scenarios.\n", 48 | "6. Logistic regression is easier to implement, interpret, and very efficient to train.\n" 49 | ] 50 | }, 51 | { 52 | "cell_type": "markdown", 53 | "metadata": {}, 54 | "source": [ 55 | "##### 3. Disadvantages\n", 56 | "1. Sometimes Lot of Feature Engineering Is required\n", 57 | "2. If the independent features are correlated it may affect performance\n", 58 | "3. It is often quite prone to noise and overfitting\n", 59 | "4. If the number of observations is lesser than the number of features, Logistic Regression should not be used, otherwise, it may lead to overfitting.\n", 60 | "5. \tNon-linear problems can’t be solved with logistic regression because it has a linear decision surface. Linearly separable data is rarely found in real-world scenarios.\n", 61 | "6. It is tough to obtain complex relationships using logistic regression. More powerful and compact algorithms such as Neural Networks can easily outperform this algorithm.\n", 62 | "7. In Linear Regression independent and dependent variables are related linearly. But Logistic Regression needs that independent variables are linearly related to the log odds (log(p/(1-p))." 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": {}, 68 | "source": [ 69 | "##### 4. Whether Feature Scaling is required?\n", 70 | "yes\n", 71 | "\n", 72 | "#### 5. Missing Values\n", 73 | "Sensitive to missing values\n", 74 | "\n", 75 | "##### 6. Impact of outliers?\n", 76 | "Like linear regression, estimates of the logistic regression are sensitive to the unusual observations: outliers, high leverage, and influential observations. Numerical examples and analysis are presented to demonstrate the most recent outlier diagnostic methods using data sets from medical domain" 77 | ] 78 | }, 79 | { 80 | "cell_type": "markdown", 81 | "metadata": {}, 82 | "source": [ 83 | "##### Types of Problems it can solve(Supervised)\n", 84 | "1. Classification" 85 | ] 86 | }, 87 | { 88 | "cell_type": "markdown", 89 | "metadata": {}, 90 | "source": [ 91 | "\n" 92 | ] 93 | }, 94 | { 95 | "cell_type": "markdown", 96 | "metadata": {}, 97 | "source": [ 98 | "#### Practical Implementation\n", 99 | "1. http://scikit-learn.org/stable/modules/generated/sklearn.linear_model.LogisticRegression.html" 100 | ] 101 | }, 102 | { 103 | "cell_type": "markdown", 104 | "metadata": {}, 105 | "source": [ 106 | "##### Performance Metrics" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "##### Classification\n", 114 | "1. Confusion Matrix \n", 115 | "2. Precision,Recall, F1 score\n", 116 | "\n", 117 | "1. Part 1 https://www.youtube.com/watch?v=aWAnNHXIKww\n", 118 | "2. Part 2 https://www.youtube.com/watch?v=A_ZKMsZ3f3o" 119 | ] 120 | }, 121 | { 122 | "cell_type": "code", 123 | "execution_count": null, 124 | "metadata": {}, 125 | "outputs": [], 126 | "source": [] 127 | } 128 | ], 129 | "metadata": { 130 | "kernelspec": { 131 | "display_name": "Python 3", 132 | "language": "python", 133 | "name": "python3" 134 | }, 135 | "language_info": { 136 | "codemirror_mode": { 137 | "name": "ipython", 138 | "version": 3 139 | }, 140 | "file_extension": ".py", 141 | "mimetype": "text/x-python", 142 | "name": "python", 143 | "nbconvert_exporter": "python", 144 | "pygments_lexer": "ipython3", 145 | "version": "3.7.9" 146 | } 147 | }, 148 | "nbformat": 4, 149 | "nbformat_minor": 4 150 | } 151 | -------------------------------------------------------------------------------- /Interview Preparation-Random Forest-Bagging.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### How To Learn Machine Learning Algorithms For Interviews\n", 8 | "\n", 9 | "#### Decision Tree Classifier And Regressor\n", 10 | "Interview Questions:\n", 11 | "1. Decision Tree \n", 12 | "2. Entropy, Information Gain, Gini Impurity\n", 13 | "3. Decision Tree Working For Categorical and Numerical Features\n", 14 | "4. What are the scenarios where Decision Tree works well\n", 15 | "5. Decision Tree Low Bias And High Variance- Overfitting\n", 16 | "6. Hyperparameter Techniques\n", 17 | "7. Library used for constructing decision tree\n", 18 | "8. Impact of Outliers Of Decision Tree\n", 19 | "9. Impact of mising values on Decision Tree\n", 20 | "10. Does Decision Tree require Feature Scaling\n", 21 | "\n", 22 | "##### Random Forest Classifier And Regresor\n", 23 | "\n", 24 | "11. Ensemble Techniques(Boosting And Bagging)\n", 25 | "12. Working of Random Forest Classifier\n", 26 | "13. Working of Random Forest Regresor\n", 27 | "14. Hyperparameter Tuning(Grid Search And RandomSearch)\n", 28 | " \n", 29 | "\n", 30 | "Theoretical Understanding:\n", 31 | "\n", 32 | "1. Tutorial 37:Entropy In Decision Tree https://www.youtube.com/watch?v=1IQOtJ4NI_0\n", 33 | "2. Tutorial 38:Information Gain https://www.youtube.com/watch?v=FuTRucXB9rA\n", 34 | "3. Tutorial 39:Gini Impurity https://www.youtube.com/watch?v=5aIFgrrTqOw\n", 35 | "4. Tutorial 40: Decision Tree For Numerical Features: https://www.youtube.com/watch?v=5O8HvA9pMew \n", 36 | "5. How To Visualize DT: https://www.youtube.com/watch?v=ot75kOmpYjI\n", 37 | "\n", 38 | "Theoretical Understanding:\n", 39 | "1. Ensemble technique(Bagging): https://www.youtube.com/watch?v=KIOeZ5cFZ50\n", 40 | "2. Random forest Classifier And Regressor\n", 41 | "https://www.youtube.com/watch?v=nxFG5xdpDto\n", 42 | "3. Construct Decision Tree And working in Random Forest: https://www.youtube.com/watch?v=WQ0iJSbnnZA&t=406s" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "#### Important properties of Random Forest Classifiers \n", 50 | "\n", 51 | "1. Decision Tree---Low Bias And High Variance\n", 52 | " \n", 53 | "2. Ensemble Bagging(Random Forest Classifier)--Low Bias And Low Variance\n", 54 | " " 55 | ] 56 | }, 57 | { 58 | "cell_type": "markdown", 59 | "metadata": {}, 60 | "source": [ 61 | "##### 1. What Are the Basic Assumption?\n", 62 | "There are no such assumptions" 63 | ] 64 | }, 65 | { 66 | "cell_type": "markdown", 67 | "metadata": {}, 68 | "source": [ 69 | "##### 2. Advantages\n", 70 | "Advantages of Random Forest\n", 71 | "\n", 72 | "1. Doesn't Overfit\n", 73 | "\n", 74 | "2. Favourite algorithm for Kaggle competition\n", 75 | "\n", 76 | "3. Less Parameter Tuning required\n", 77 | "\n", 78 | "4. Decision Tree can handle both continuous and categorical variables.\n", 79 | "\n", 80 | "5. No feature scaling required: No feature scaling (standardization and normalization) required in case of Random Forest as it uses DEcision Tree internally\n", 81 | "\n", 82 | "6. Suitable for any kind of ML problems\n", 83 | " " 84 | ] 85 | }, 86 | { 87 | "cell_type": "markdown", 88 | "metadata": {}, 89 | "source": [ 90 | "##### 3. Disadvantages\n", 91 | "Disadvantages of Random Forest\n", 92 | "\n", 93 | "1.Biased With features having many categories\n", 94 | "\n", 95 | "2. Biased in multiclass classification problems towards more frequent classes." 96 | ] 97 | }, 98 | { 99 | "cell_type": "markdown", 100 | "metadata": {}, 101 | "source": [ 102 | "##### 4. Whether Feature Scaling is required?\n", 103 | "No\n", 104 | "\n", 105 | "##### 6. Impact of outliers?\n", 106 | "Robust to Outliers" 107 | ] 108 | }, 109 | { 110 | "cell_type": "markdown", 111 | "metadata": {}, 112 | "source": [ 113 | "##### Types of Problems it can solve(Supervised)\n", 114 | "1. Classification\n", 115 | "2. Regression" 116 | ] 117 | }, 118 | { 119 | "cell_type": "markdown", 120 | "metadata": {}, 121 | "source": [ 122 | "\n" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "#### Practical Implementation\n", 130 | "1. https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeClassifier.html\n", 131 | "2. https://scikit-learn.org/stable/modules/generated/sklearn.tree.DecisionTreeRegressor.html\n", 132 | "\n", 133 | "1. https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestClassifier.html\n", 134 | "2. https://scikit-learn.org/stable/modules/generated/sklearn.ensemble.RandomForestRegressor.html" 135 | ] 136 | }, 137 | { 138 | "cell_type": "markdown", 139 | "metadata": {}, 140 | "source": [ 141 | "##### Performance Metrics" 142 | ] 143 | }, 144 | { 145 | "cell_type": "markdown", 146 | "metadata": {}, 147 | "source": [ 148 | "##### Classification\n", 149 | "1. Confusion Matrix \n", 150 | "2. Precision,Recall, F1 score\n", 151 | "\n", 152 | "##### Regression\n", 153 | "1. R2,Adjusted R2\n", 154 | "2. MSE,RMSE,MAE" 155 | ] 156 | }, 157 | { 158 | "cell_type": "code", 159 | "execution_count": null, 160 | "metadata": {}, 161 | "outputs": [], 162 | "source": [] 163 | } 164 | ], 165 | "metadata": { 166 | "kernelspec": { 167 | "display_name": "Python 3", 168 | "language": "python", 169 | "name": "python3" 170 | }, 171 | "language_info": { 172 | "codemirror_mode": { 173 | "name": "ipython", 174 | "version": 3 175 | }, 176 | "file_extension": ".py", 177 | "mimetype": "text/x-python", 178 | "name": "python", 179 | "nbconvert_exporter": "python", 180 | "pygments_lexer": "ipython3", 181 | "version": "3.7.7" 182 | } 183 | }, 184 | "nbformat": 4, 185 | "nbformat_minor": 4 186 | } 187 | -------------------------------------------------------------------------------- /Interview Preparation-Xgboost,GBboost,Adaboost--Boosting.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "### How To Learn Machine Learning Algorithms For Interviews\n", 8 | "\n", 9 | "#### Decision Tree Classifier And Regressor\n", 10 | "Interview Questions:\n", 11 | "1. Decision Tree \n", 12 | "2. Entropy, Information Gain, Gini Impurity\n", 13 | "3. Decision Tree Working For Categorical and Numerical Features\n", 14 | "4. What are the scenarios where Decision Tree works well\n", 15 | "5. Decision Tree Low Bias And High Variance- Overfitting\n", 16 | "6. Hyperparameter Techniques\n", 17 | "7. Library used for constructing decision tree\n", 18 | "8. Impact of Outliers Of Decision Tree\n", 19 | "9. Impact of mising values on Decision Tree\n", 20 | "10. Does Decision Tree require Feature Scaling\n", 21 | "\n", 22 | "#### Xgboost Classifier And Regressor, GB Algorithm, Adaboost\n", 23 | "\n", 24 | " \n", 25 | "\n", 26 | "Decision Tree Theoretical Understanding:\n", 27 | "\n", 28 | "1. Tutorial 37:Entropy In Decision Tree https://www.youtube.com/watch?v=1IQOtJ4NI_0\n", 29 | "2. Tutorial 38:Information Gain https://www.youtube.com/watch?v=FuTRucXB9rA\n", 30 | "3. Tutorial 39:Gini Impurity https://www.youtube.com/watch?v=5aIFgrrTqOw\n", 31 | "4. Tutorial 40: Decision Tree For Numerical Features: https://www.youtube.com/watch?v=5O8HvA9pMew \n", 32 | "5. How To Visualize DT: https://www.youtube.com/watch?v=ot75kOmpYjI\n", 33 | "\n", 34 | "Theoretical Understanding:\n", 35 | "\n", 36 | "1. Ensemble technique(Bagging): https://www.youtube.com/watch?v=KIOeZ5cFZ50\n", 37 | "2. Adaboost(Boosting Technique):https://www.youtube.com/watch?v=NLRO1-jp5F8\n", 38 | "3. Gradient Boosting In Depth Intuition Part 1: https://www.youtube.com/watch?v=Nol1hVtLOSg\n", 39 | "4. Gradient Boosting In Depth Intuition Part 2: https://www.youtube.com/watch?v=Oo9q6YtGzvc\n", 40 | "5. Xgboost Classifier Indepth Intuition: https://www.youtube.com/watch?v=gPciUPwWJQQ\n", 41 | "6. Xgboost Regression Indpeth Intuition: https://www.youtube.com/watch?v=w-_vmVfpssg\n", 42 | "7. Implementation of Xgboost: https://youtu.be/9HomdnM12o4" 43 | ] 44 | }, 45 | { 46 | "cell_type": "markdown", 47 | "metadata": {}, 48 | "source": [ 49 | "##### 1. What Are the Basic Assumption?\n", 50 | "There are no such assumptions" 51 | ] 52 | }, 53 | { 54 | "cell_type": "markdown", 55 | "metadata": {}, 56 | "source": [ 57 | "#### Missing Values\n", 58 | "1. Adaboost can handle mising values\n", 59 | "2. Xgboosst and GBoost cannot handle missing values" 60 | ] 61 | }, 62 | { 63 | "cell_type": "markdown", 64 | "metadata": {}, 65 | "source": [ 66 | "##### 2. Advantages\n", 67 | "Advantages of Adaboost\n", 68 | "\n", 69 | "1. Doesn't Overfit\n", 70 | "\n", 71 | "2. It has few parameters to tune\n", 72 | " \n", 73 | "Advantages of Gradient Boost And Xgboost\n", 74 | " \n", 75 | "1. It has a great performance\n", 76 | "2. It can solve complex non linear functions \n", 77 | "3. It is better in solve any kind of ML usecases.\n", 78 | " " 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "##### 3. Disadvantages\n", 86 | "Disadvantages of Gradient Boosting And Xgboost\n", 87 | "\n", 88 | "1.It requires some amount of parameter tuning" 89 | ] 90 | }, 91 | { 92 | "cell_type": "markdown", 93 | "metadata": {}, 94 | "source": [ 95 | "##### 4. Whether Feature Scaling is required?\n", 96 | "No\n", 97 | "\n", 98 | "##### 6. Impact of outliers?\n", 99 | "Robust to Outliers in Gradient Boosting And Xgboost,\n", 100 | "Sensitive to outliers in Adaboost" 101 | ] 102 | }, 103 | { 104 | "cell_type": "markdown", 105 | "metadata": {}, 106 | "source": [ 107 | "##### Types of Problems it can solve(Supervised)\n", 108 | "1. Classification\n", 109 | "2. Regression" 110 | ] 111 | }, 112 | { 113 | "cell_type": "markdown", 114 | "metadata": {}, 115 | "source": [ 116 | "\n" 117 | ] 118 | }, 119 | { 120 | "cell_type": "markdown", 121 | "metadata": {}, 122 | "source": [ 123 | "##### Performance Metrics" 124 | ] 125 | }, 126 | { 127 | "cell_type": "markdown", 128 | "metadata": {}, 129 | "source": [ 130 | "##### Classification\n", 131 | "1. Confusion Matrix \n", 132 | "2. Precision,Recall, F1 score\n", 133 | "\n", 134 | "##### Regression\n", 135 | "1. R2,Adjusted R2\n", 136 | "2. MSE,RMSE,MAE" 137 | ] 138 | }, 139 | { 140 | "cell_type": "code", 141 | "execution_count": null, 142 | "metadata": {}, 143 | "outputs": [], 144 | "source": [] 145 | } 146 | ], 147 | "metadata": { 148 | "kernelspec": { 149 | "display_name": "Python 3", 150 | "language": "python", 151 | "name": "python3" 152 | }, 153 | "language_info": { 154 | "codemirror_mode": { 155 | "name": "ipython", 156 | "version": 3 157 | }, 158 | "file_extension": ".py", 159 | "mimetype": "text/x-python", 160 | "name": "python", 161 | "nbconvert_exporter": "python", 162 | "pygments_lexer": "ipython3", 163 | "version": "3.7.7" 164 | } 165 | }, 166 | "nbformat": 4, 167 | "nbformat_minor": 4 168 | } 169 | -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Interview-Prepartion-Data-Science --------------------------------------------------------------------------------