├── Ads_CTR_Optimisation.csv ├── Apriori Python Lecture.ipynb ├── Artificial Neural Network.ipynb ├── Artificial Neural Networks.R ├── Convolutional Neural Network.ipynb ├── Data Preprocessing Data Section 2.ipynb ├── Decision Tree Classification.R ├── Decision Tree Classification.ipynb ├── Decision Tree Regression .ipynb ├── Decision Tree Regression.R ├── Grid Search.R ├── Grid Search.ipynb ├── HC in Python.ipynb ├── HC in R.R ├── K-Means Clustering Lecture.R ├── K-Means Clustering Lecture.ipynb ├── Kernel PCA.R ├── Kernel PCA.ipynb ├── Kernel SVM.R ├── Kernel SVM.ipynb ├── Linear Discriminant Analysis (LDA).R ├── Linear Discriminant Analysis (LDA).ipynb ├── Logistic Regression Lecture.R ├── Logistic Regression.ipynb ├── Market_Basket_Optimisation.csv ├── Missing Data.ipynb ├── Multiple Linear Regression Lecture and HW.R ├── Naive Bayes.R ├── Naive Bayes.ipynb ├── Natural Language Processing.ipynb ├── Polynomial Regression Lecture.R ├── Polynomial Regression Lecture.ipynb ├── Principal Component Analysis.R ├── Principal Component Analysis.ipynb ├── README.md ├── Random Forest Classification Lecture.R ├── Random Forest Classification.ipynb ├── Random Forest Regression.R ├── Random Forest Regression.ipynb ├── Restaurant_Reviews.tsv ├── SVM Lecture.R ├── SVM Lecture.ipynb ├── SVR.R ├── Simple Linear Regression.R ├── Simple Linear Regression.ipynb ├── Social_Network_Ads.csv ├── Support Vector Regression Lecture.ipynb ├── Thompson Sampling Lecture.ipynb ├── UCB.R ├── Upper Confidence Bound .ipynb ├── apriori.R ├── categorical_data.R ├── eclat.R ├── missing_data.R ├── natural_language_processing.R ├── thompson_sampling.R ├── upper_confidence_bound.R ├── xgboost.R └── xgboost.py /Artificial Neural Networks.R: -------------------------------------------------------------------------------- 1 | # Artificial Neural Network 2 | 3 | # Changing the Working Directory 4 | setwd('./Machine Learning A-Z/Part 8 - Deep Learning/Section 40 - Artificial Neural Networks (ANN)') 5 | 6 | ## Importing the dataset 7 | dataset = read.csv('Churn_Modelling.csv') 8 | dataset = dataset[4:14] 9 | 10 | ## Encoding the categorical variables as factors 11 | dataset$Geography = as.numeric(factor(dataset$Geography, 12 | levels = c('France', 'Spain', 'Germany'), 13 | labels = c(1, 2, 3))) 14 | dataset$Gender = as.numeric(factor(dataset$Gender, 15 | levels = c('Female', 'Male'), 16 | labels = c(1, 2))) 17 | 18 | ## Splitting the dataset into the Training set and Test set 19 | 20 | library(caTools) 21 | set.seed(123) 22 | split = sample.split(dataset$Exited, SplitRatio = 0.8) 23 | training_set = subset(dataset, split == TRUE) 24 | test_set = subset(dataset, split == FALSE) 25 | 26 | ## Feature Scaling 27 | 28 | training_set[-11] = scale(training_set[-11]) 29 | test_set[-11] = scale(test_set[-11]) 30 | 31 | # Fitting ANN to the Training set 32 | 33 | library(h2o) 34 | h2o.init(nthreads = -1) 35 | model = h2o.deeplearning(y = 'Exited', 36 | training_frame = as.h2o(training_set), 37 | activation = 'Rectifier', 38 | hidden = c(5,5), 39 | epochs = 100, 40 | train_samples_per_iteration = -2) 41 | 42 | # Predicting the Test set results 43 | 44 | y_pred = h2o.predict(model, newdata = as.h2o(test_set[-11])) 45 | y_pred 46 | 47 | y_pred = (y_pred > 0.5) 48 | y_pred = as.vector(y_pred) 49 | y_pred 50 | 51 | # Making the Confusion Matrix 52 | 53 | cm = table(test_set[, 11], y_pred) 54 | cm 55 | 56 | (1546+182)/2000 57 | 58 | # h2o.shutdown() 59 | 60 | -------------------------------------------------------------------------------- /Convolutional Neural Network.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Building the Convolutional Neural Network" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": {}, 14 | "outputs": [ 15 | { 16 | "name": "stderr", 17 | "output_type": "stream", 18 | "text": [ 19 | "Using TensorFlow backend.\n" 20 | ] 21 | } 22 | ], 23 | "source": [ 24 | "from keras.models import Sequential\n", 25 | "from keras.layers import Convolution2D\n", 26 | "from keras.layers import MaxPooling2D\n", 27 | "from keras.layers import Flatten\n", 28 | "from keras.layers import Dense" 29 | ] 30 | }, 31 | { 32 | "cell_type": "markdown", 33 | "metadata": {}, 34 | "source": [ 35 | "# Initializing the CNN" 36 | ] 37 | }, 38 | { 39 | "cell_type": "code", 40 | "execution_count": 2, 41 | "metadata": { 42 | "collapsed": true 43 | }, 44 | "outputs": [], 45 | "source": [ 46 | "classifier = Sequential()" 47 | ] 48 | }, 49 | { 50 | "cell_type": "markdown", 51 | "metadata": {}, 52 | "source": [ 53 | "# Step 1 - Convolution" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "classifier.add(Convolution2D(32, 3, 3, input_shape = (64, 64, 3), activation = 'relu'))" 61 | ] 62 | }, 63 | { 64 | "cell_type": "markdown", 65 | "metadata": {}, 66 | "source": [ 67 | "# Step 2 - Pooling" 68 | ] 69 | }, 70 | { 71 | "cell_type": "code", 72 | "execution_count": 4, 73 | "metadata": { 74 | "collapsed": true 75 | }, 76 | "outputs": [], 77 | "source": [ 78 | "classifier.add(MaxPooling2D(pool_size = (2, 2)))" 79 | ] 80 | }, 81 | { 82 | "cell_type": "markdown", 83 | "metadata": {}, 84 | "source": [ 85 | "# Adding a Second Convolutional Layer" 86 | ] 87 | }, 88 | { 89 | "cell_type": "code", 90 | "execution_count": 5, 91 | "metadata": {}, 92 | "outputs": [ 93 | { 94 | "name": "stderr", 95 | "output_type": "stream", 96 | "text": [ 97 | "/home/atse/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: UserWarning: Update your `Conv2D` call to the Keras 2 API: `Conv2D(32, (3, 3), activation=\"relu\")`\n", 98 | " \"\"\"Entry point for launching an IPython kernel.\n" 99 | ] 100 | } 101 | ], 102 | "source": [ 103 | "classifier.add(Convolution2D(32, 3, 3, activation = 'relu'))\n", 104 | "classifier.add(MaxPooling2D(pool_size = (2, 2)))" 105 | ] 106 | }, 107 | { 108 | "cell_type": "markdown", 109 | "metadata": {}, 110 | "source": [ 111 | "# Step 3 - Flattening" 112 | ] 113 | }, 114 | { 115 | "cell_type": "code", 116 | "execution_count": 6, 117 | "metadata": { 118 | "collapsed": true 119 | }, 120 | "outputs": [], 121 | "source": [ 122 | "classifier.add(Flatten())" 123 | ] 124 | }, 125 | { 126 | "cell_type": "markdown", 127 | "metadata": {}, 128 | "source": [ 129 | "# Step 4 - Full Connection" 130 | ] 131 | }, 132 | { 133 | "cell_type": "code", 134 | "execution_count": 7, 135 | "metadata": {}, 136 | "outputs": [ 137 | { 138 | "name": "stderr", 139 | "output_type": "stream", 140 | "text": [ 141 | "/home/atse/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: UserWarning: Update your `Dense` call to the Keras 2 API: `Dense(activation=\"relu\", units=128)`\n", 142 | " \"\"\"Entry point for launching an IPython kernel.\n" 143 | ] 144 | } 145 | ], 146 | "source": [ 147 | "classifier.add(Dense(output_dim = 128, activation = 'relu'))" 148 | ] 149 | }, 150 | { 151 | "cell_type": "code", 152 | "execution_count": 8, 153 | "metadata": {}, 154 | "outputs": [ 155 | { 156 | "name": "stderr", 157 | "output_type": "stream", 158 | "text": [ 159 | "/home/atse/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:1: UserWarning: Update your `Dense` call to the Keras 2 API: `Dense(activation=\"sigmoid\", units=1)`\n", 160 | " \"\"\"Entry point for launching an IPython kernel.\n" 161 | ] 162 | } 163 | ], 164 | "source": [ 165 | "classifier.add(Dense(output_dim = 1, activation = 'sigmoid'))" 166 | ] 167 | }, 168 | { 169 | "cell_type": "markdown", 170 | "metadata": {}, 171 | "source": [ 172 | "# Compiling the CNN" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 9, 178 | "metadata": { 179 | "collapsed": true 180 | }, 181 | "outputs": [], 182 | "source": [ 183 | "classifier.compile(optimizer = 'adam', loss = 'binary_crossentropy', metrics = ['accuracy'])" 184 | ] 185 | }, 186 | { 187 | "cell_type": "markdown", 188 | "metadata": {}, 189 | "source": [ 190 | "# Fitting the CNN to the Images" 191 | ] 192 | }, 193 | { 194 | "cell_type": "code", 195 | "execution_count": 10, 196 | "metadata": { 197 | "collapsed": true 198 | }, 199 | "outputs": [], 200 | "source": [ 201 | "from keras.preprocessing.image import ImageDataGenerator" 202 | ] 203 | }, 204 | { 205 | "cell_type": "code", 206 | "execution_count": 13, 207 | "metadata": { 208 | "collapsed": true 209 | }, 210 | "outputs": [], 211 | "source": [ 212 | "train_datagen = ImageDataGenerator(rescale = 1./255,\n", 213 | " shear_range = 0.2,\n", 214 | " zoom_range = 0.2,\n", 215 | " horizontal_flip = True)" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": 14, 221 | "metadata": {}, 222 | "outputs": [ 223 | { 224 | "data": { 225 | "text/plain": [ 226 | "" 227 | ] 228 | }, 229 | "execution_count": 14, 230 | "metadata": {}, 231 | "output_type": "execute_result" 232 | } 233 | ], 234 | "source": [ 235 | "train_datagen" 236 | ] 237 | }, 238 | { 239 | "cell_type": "code", 240 | "execution_count": 12, 241 | "metadata": { 242 | "collapsed": true 243 | }, 244 | "outputs": [], 245 | "source": [ 246 | "test_datagen = ImageDataGenerator(rescale = 1./255)" 247 | ] 248 | }, 249 | { 250 | "cell_type": "code", 251 | "execution_count": 15, 252 | "metadata": {}, 253 | "outputs": [ 254 | { 255 | "data": { 256 | "text/plain": [ 257 | "" 258 | ] 259 | }, 260 | "execution_count": 15, 261 | "metadata": {}, 262 | "output_type": "execute_result" 263 | } 264 | ], 265 | "source": [ 266 | "test_datagen" 267 | ] 268 | }, 269 | { 270 | "cell_type": "code", 271 | "execution_count": 20, 272 | "metadata": {}, 273 | "outputs": [ 274 | { 275 | "name": "stdout", 276 | "output_type": "stream", 277 | "text": [ 278 | "Found 8000 images belonging to 2 classes.\n" 279 | ] 280 | }, 281 | { 282 | "data": { 283 | "text/plain": [ 284 | "" 285 | ] 286 | }, 287 | "execution_count": 20, 288 | "metadata": {}, 289 | "output_type": "execute_result" 290 | } 291 | ], 292 | "source": [ 293 | "training_set = train_datagen.flow_from_directory('dataset/training_set',\n", 294 | " target_size = (64, 64),\n", 295 | " batch_size = 32,\n", 296 | " class_mode = 'binary')\n", 297 | "training_set" 298 | ] 299 | }, 300 | { 301 | "cell_type": "code", 302 | "execution_count": 21, 303 | "metadata": {}, 304 | "outputs": [ 305 | { 306 | "name": "stdout", 307 | "output_type": "stream", 308 | "text": [ 309 | "Found 2000 images belonging to 2 classes.\n" 310 | ] 311 | }, 312 | { 313 | "data": { 314 | "text/plain": [ 315 | "" 316 | ] 317 | }, 318 | "execution_count": 21, 319 | "metadata": {}, 320 | "output_type": "execute_result" 321 | } 322 | ], 323 | "source": [ 324 | "test_set = test_datagen.flow_from_directory('dataset/test_set',\n", 325 | " target_size = (64, 64),\n", 326 | " batch_size = 32,\n", 327 | " class_mode = 'binary')\n", 328 | "test_set" 329 | ] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": 22, 334 | "metadata": {}, 335 | "outputs": [ 336 | { 337 | "name": "stderr", 338 | "output_type": "stream", 339 | "text": [ 340 | "/home/atse/miniconda3/lib/python3.6/site-packages/ipykernel_launcher.py:5: UserWarning: Update your `fit_generator` call to the Keras 2 API: `fit_generator(" 404 | ] 405 | }, 406 | "execution_count": 22, 407 | "metadata": {}, 408 | "output_type": "execute_result" 409 | } 410 | ], 411 | "source": [ 412 | "classifier.fit_generator(training_set,\n", 413 | " samples_per_epoch = 8000,\n", 414 | " nb_epoch = 25,\n", 415 | " validation_data = test_set,\n", 416 | " nb_val_samples = 2000)" 417 | ] 418 | }, 419 | { 420 | "cell_type": "code", 421 | "execution_count": null, 422 | "metadata": {}, 423 | "outputs": [], 424 | "source": [] 425 | }, 426 | { 427 | "cell_type": "code", 428 | "execution_count": null, 429 | "metadata": { 430 | "collapsed": true 431 | }, 432 | "outputs": [], 433 | "source": [] 434 | } 435 | ], 436 | "metadata": { 437 | "kernelspec": { 438 | "display_name": "Python 3", 439 | "language": "python", 440 | "name": "python3" 441 | }, 442 | "language_info": { 443 | "codemirror_mode": { 444 | "name": "ipython", 445 | "version": 3 446 | }, 447 | "file_extension": ".py", 448 | "mimetype": "text/x-python", 449 | "name": "python", 450 | "nbconvert_exporter": "python", 451 | "pygments_lexer": "ipython3", 452 | "version": "3.6.0" 453 | } 454 | }, 455 | "nbformat": 4, 456 | "nbformat_minor": 2 457 | } 458 | -------------------------------------------------------------------------------- /Data Preprocessing Data Section 2.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Importing the Libraries" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "import numpy as np\n", 19 | "import pandas as pd" 20 | ] 21 | }, 22 | { 23 | "cell_type": "code", 24 | "execution_count": 2, 25 | "metadata": { 26 | "collapsed": true 27 | }, 28 | "outputs": [], 29 | "source": [ 30 | "import matplotlib.pyplot as plt\n", 31 | "%matplotlib inline" 32 | ] 33 | }, 34 | { 35 | "cell_type": "markdown", 36 | "metadata": {}, 37 | "source": [ 38 | "## Importing the Dataset" 39 | ] 40 | }, 41 | { 42 | "cell_type": "code", 43 | "execution_count": 3, 44 | "metadata": { 45 | "collapsed": true 46 | }, 47 | "outputs": [], 48 | "source": [ 49 | "dataset = pd.read_csv('Data.csv')" 50 | ] 51 | }, 52 | { 53 | "cell_type": "code", 54 | "execution_count": 4, 55 | "metadata": { 56 | "collapsed": true 57 | }, 58 | "outputs": [], 59 | "source": [ 60 | "X = dataset.iloc[:, :-1].values\n", 61 | "y = dataset.iloc[:, 3].values" 62 | ] 63 | }, 64 | { 65 | "cell_type": "markdown", 66 | "metadata": {}, 67 | "source": [ 68 | "## Taking Care of Missing Data" 69 | ] 70 | }, 71 | { 72 | "cell_type": "code", 73 | "execution_count": 5, 74 | "metadata": { 75 | "collapsed": true 76 | }, 77 | "outputs": [], 78 | "source": [ 79 | "from sklearn.preprocessing import Imputer" 80 | ] 81 | }, 82 | { 83 | "cell_type": "code", 84 | "execution_count": 6, 85 | "metadata": { 86 | "collapsed": true 87 | }, 88 | "outputs": [], 89 | "source": [ 90 | "imputer = Imputer(missing_values = 'NaN', strategy = 'mean', axis = 0)" 91 | ] 92 | }, 93 | { 94 | "cell_type": "code", 95 | "execution_count": 7, 96 | "metadata": { 97 | "collapsed": true 98 | }, 99 | "outputs": [], 100 | "source": [ 101 | "imputer = imputer.fit(X[:, 1:3])" 102 | ] 103 | }, 104 | { 105 | "cell_type": "code", 106 | "execution_count": 8, 107 | "metadata": { 108 | "collapsed": true 109 | }, 110 | "outputs": [], 111 | "source": [ 112 | "X[:, 1:3] = imputer.transform(X[:, 1:3])" 113 | ] 114 | }, 115 | { 116 | "cell_type": "code", 117 | "execution_count": 9, 118 | "metadata": { 119 | "collapsed": false 120 | }, 121 | "outputs": [ 122 | { 123 | "data": { 124 | "text/plain": [ 125 | "array([['France', 44.0, 72000.0],\n", 126 | " ['Spain', 27.0, 48000.0],\n", 127 | " ['Germany', 30.0, 54000.0],\n", 128 | " ['Spain', 38.0, 61000.0],\n", 129 | " ['Germany', 40.0, 63777.77777777778],\n", 130 | " ['France', 35.0, 58000.0],\n", 131 | " ['Spain', 38.77777777777778, 52000.0],\n", 132 | " ['France', 48.0, 79000.0],\n", 133 | " ['Germany', 50.0, 83000.0],\n", 134 | " ['France', 37.0, 67000.0]], dtype=object)" 135 | ] 136 | }, 137 | "execution_count": 9, 138 | "metadata": {}, 139 | "output_type": "execute_result" 140 | } 141 | ], 142 | "source": [ 143 | "X" 144 | ] 145 | }, 146 | { 147 | "cell_type": "markdown", 148 | "metadata": {}, 149 | "source": [ 150 | "### Encoding Categorical Data" 151 | ] 152 | }, 153 | { 154 | "cell_type": "code", 155 | "execution_count": 10, 156 | "metadata": { 157 | "collapsed": true 158 | }, 159 | "outputs": [], 160 | "source": [ 161 | "from sklearn.preprocessing import LabelEncoder, OneHotEncoder" 162 | ] 163 | }, 164 | { 165 | "cell_type": "code", 166 | "execution_count": 11, 167 | "metadata": { 168 | "collapsed": true 169 | }, 170 | "outputs": [], 171 | "source": [ 172 | "labelencoder_X = LabelEncoder()" 173 | ] 174 | }, 175 | { 176 | "cell_type": "code", 177 | "execution_count": 12, 178 | "metadata": { 179 | "collapsed": false 180 | }, 181 | "outputs": [], 182 | "source": [ 183 | "X[:, 0] = labelencoder_X.fit_transform(X[:, 0])" 184 | ] 185 | }, 186 | { 187 | "cell_type": "code", 188 | "execution_count": 13, 189 | "metadata": { 190 | "collapsed": false 191 | }, 192 | "outputs": [], 193 | "source": [ 194 | "onehotencoder = OneHotEncoder(categorical_features = [0])" 195 | ] 196 | }, 197 | { 198 | "cell_type": "code", 199 | "execution_count": 14, 200 | "metadata": { 201 | "collapsed": true 202 | }, 203 | "outputs": [], 204 | "source": [ 205 | "X = onehotencoder.fit_transform(X).toarray()" 206 | ] 207 | }, 208 | { 209 | "cell_type": "code", 210 | "execution_count": 15, 211 | "metadata": { 212 | "collapsed": false 213 | }, 214 | "outputs": [ 215 | { 216 | "data": { 217 | "text/plain": [ 218 | "array([[ 1.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", 219 | " 4.40000000e+01, 7.20000000e+04],\n", 220 | " [ 0.00000000e+00, 0.00000000e+00, 1.00000000e+00,\n", 221 | " 2.70000000e+01, 4.80000000e+04],\n", 222 | " [ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00,\n", 223 | " 3.00000000e+01, 5.40000000e+04],\n", 224 | " [ 0.00000000e+00, 0.00000000e+00, 1.00000000e+00,\n", 225 | " 3.80000000e+01, 6.10000000e+04],\n", 226 | " [ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00,\n", 227 | " 4.00000000e+01, 6.37777778e+04],\n", 228 | " [ 1.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", 229 | " 3.50000000e+01, 5.80000000e+04],\n", 230 | " [ 0.00000000e+00, 0.00000000e+00, 1.00000000e+00,\n", 231 | " 3.87777778e+01, 5.20000000e+04],\n", 232 | " [ 1.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", 233 | " 4.80000000e+01, 7.90000000e+04],\n", 234 | " [ 0.00000000e+00, 1.00000000e+00, 0.00000000e+00,\n", 235 | " 5.00000000e+01, 8.30000000e+04],\n", 236 | " [ 1.00000000e+00, 0.00000000e+00, 0.00000000e+00,\n", 237 | " 3.70000000e+01, 6.70000000e+04]])" 238 | ] 239 | }, 240 | "execution_count": 15, 241 | "metadata": {}, 242 | "output_type": "execute_result" 243 | } 244 | ], 245 | "source": [ 246 | "X" 247 | ] 248 | }, 249 | { 250 | "cell_type": "markdown", 251 | "metadata": {}, 252 | "source": [ 253 | "# Y" 254 | ] 255 | }, 256 | { 257 | "cell_type": "code", 258 | "execution_count": 16, 259 | "metadata": { 260 | "collapsed": true 261 | }, 262 | "outputs": [], 263 | "source": [ 264 | "labelencoder_y = LabelEncoder()" 265 | ] 266 | }, 267 | { 268 | "cell_type": "code", 269 | "execution_count": 17, 270 | "metadata": { 271 | "collapsed": false 272 | }, 273 | "outputs": [], 274 | "source": [ 275 | "y = labelencoder_y.fit_transform(y)" 276 | ] 277 | }, 278 | { 279 | "cell_type": "code", 280 | "execution_count": 18, 281 | "metadata": { 282 | "collapsed": false 283 | }, 284 | "outputs": [ 285 | { 286 | "data": { 287 | "text/plain": [ 288 | "array([0, 1, 0, 0, 1, 1, 0, 1, 0, 1], dtype=int64)" 289 | ] 290 | }, 291 | "execution_count": 18, 292 | "metadata": {}, 293 | "output_type": "execute_result" 294 | } 295 | ], 296 | "source": [ 297 | "y" 298 | ] 299 | }, 300 | { 301 | "cell_type": "markdown", 302 | "metadata": {}, 303 | "source": [ 304 | "# Machine Learning by Splitting into the Train Test Split Set" 305 | ] 306 | }, 307 | { 308 | "cell_type": "code", 309 | "execution_count": 21, 310 | "metadata": { 311 | "collapsed": false 312 | }, 313 | "outputs": [], 314 | "source": [ 315 | "from sklearn.cross_validation import train_test_split" 316 | ] 317 | }, 318 | { 319 | "cell_type": "code", 320 | "execution_count": 22, 321 | "metadata": { 322 | "collapsed": true 323 | }, 324 | "outputs": [], 325 | "source": [ 326 | "X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0)" 327 | ] 328 | }, 329 | { 330 | "cell_type": "markdown", 331 | "metadata": {}, 332 | "source": [ 333 | "# Feature Scaling" 334 | ] 335 | }, 336 | { 337 | "cell_type": "code", 338 | "execution_count": 23, 339 | "metadata": { 340 | "collapsed": true 341 | }, 342 | "outputs": [], 343 | "source": [ 344 | "from sklearn.preprocessing import StandardScaler" 345 | ] 346 | }, 347 | { 348 | "cell_type": "code", 349 | "execution_count": 24, 350 | "metadata": { 351 | "collapsed": true 352 | }, 353 | "outputs": [], 354 | "source": [ 355 | "sc_X = StandardScaler()" 356 | ] 357 | }, 358 | { 359 | "cell_type": "code", 360 | "execution_count": 25, 361 | "metadata": { 362 | "collapsed": true 363 | }, 364 | "outputs": [], 365 | "source": [ 366 | "X_train = sc_X.fit_transform(X_train)" 367 | ] 368 | }, 369 | { 370 | "cell_type": "code", 371 | "execution_count": 26, 372 | "metadata": { 373 | "collapsed": true 374 | }, 375 | "outputs": [], 376 | "source": [ 377 | "X_test = sc_X.transform(X_test)" 378 | ] 379 | }, 380 | { 381 | "cell_type": "code", 382 | "execution_count": null, 383 | "metadata": { 384 | "collapsed": true 385 | }, 386 | "outputs": [], 387 | "source": [] 388 | } 389 | ], 390 | "metadata": { 391 | "kernelspec": { 392 | "display_name": "Python [Root]", 393 | "language": "python", 394 | "name": "Python [Root]" 395 | }, 396 | "language_info": { 397 | "codemirror_mode": { 398 | "name": "ipython", 399 | "version": 3 400 | }, 401 | "file_extension": ".py", 402 | "mimetype": "text/x-python", 403 | "name": "python", 404 | "nbconvert_exporter": "python", 405 | "pygments_lexer": "ipython3", 406 | "version": "3.5.2" 407 | } 408 | }, 409 | "nbformat": 4, 410 | "nbformat_minor": 0 411 | } 412 | -------------------------------------------------------------------------------- /Decision Tree Classification.R: -------------------------------------------------------------------------------- 1 | # Decision Tree Classification Lecture 2 | 3 | ### Changing the Working Directory 4 | 5 | setwd('./Machine Learning A-Z/Part 3 - Classification/Section 19 - Decision Tree Classification') 6 | 7 | ## Importing the Dataset 8 | 9 | dataset = read.csv('Social_Network_Ads.csv') 10 | dataset = dataset[3:5] 11 | 12 | ## Encoding the Target Feature as Factor 13 | 14 | dataset$Purchased = factor(dataset$Purchased, levels = c(0,1)) 15 | 16 | ## Splitting the Dataset into the Training Set and Test Set 17 | 18 | library(caTools) 19 | set.seed(123) 20 | split = sample.split(dataset$Purchased, SplitRatio = 0.75) 21 | training_set = subset(dataset, split == TRUE) 22 | test_set = subset(dataset, split == FALSE) 23 | 24 | ## Feature Scaling 25 | 26 | training_set[-3] = scale(training_set[-3]) 27 | test_set[-3] = scale(test_set[-3]) 28 | 29 | ## Fitting Decision Tree to the Training Set 30 | 31 | library(rpart) 32 | 33 | classifier = rpart(formula = Purchased ~ ., 34 | data=training_set) 35 | 36 | 37 | ## Predicting the Test Set Results 38 | 39 | y_pred = predict(classifier, newdata = test_set[-3], type = 'class') 40 | y_pred 41 | 42 | ## Making the Confusion Matrix 43 | 44 | cm = table(test_set[,3], y_pred) 45 | cm 46 | 47 | ## Visualizing the Training Set Results 48 | 49 | library(ElemStatLearn) 50 | set = training_set 51 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 52 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 53 | grid_set = expand.grid(X1, X2) 54 | colnames(grid_set) = c('Age', 'EstimatedSalary') 55 | y_grid = predict(classifier, newdata = grid_set, type ='class') 56 | plot(set[, -3], 57 | main = 'Decision Tree (Training Set)', 58 | xlab = 'Age', ylab = 'Estimated Salary', 59 | xlim = range(X1), ylim = range(X2)) 60 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 61 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'salmon', 'blue')) 62 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) 63 | 64 | ## Visualizing the Test Set Results 65 | 66 | 67 | set = test_set 68 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 69 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 70 | grid_set = expand.grid(X1, X2) 71 | colnames(grid_set) = c('Age', 'EstimatedSalary') 72 | y_grid = predict(classifier, newdata = grid_set, type = 'class') 73 | plot(set[, -3], 74 | main = 'Decision Tree (Test Set)', 75 | xlab = 'Age', ylab = 'Estimated Salary', 76 | xlim = range(X1), ylim = range(X2)) 77 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 78 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'red', 'green')) 79 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'blue', 'orange')) 80 | 81 | 82 | ## Plotting the Decision Tree 83 | 84 | plot(classifier) 85 | text(classifier) -------------------------------------------------------------------------------- /Decision Tree Regression .ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Loading the Libraries" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 1, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "import numpy as np" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": 2, 24 | "metadata": { 25 | "collapsed": true 26 | }, 27 | "outputs": [], 28 | "source": [ 29 | "import pandas as pd" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 3, 35 | "metadata": { 36 | "collapsed": true 37 | }, 38 | "outputs": [], 39 | "source": [ 40 | "import matplotlib.pyplot as plt" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 4, 46 | "metadata": { 47 | "collapsed": true 48 | }, 49 | "outputs": [], 50 | "source": [ 51 | "%matplotlib inline" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "# Reading the Data" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 5, 64 | "metadata": { 65 | "collapsed": true 66 | }, 67 | "outputs": [], 68 | "source": [ 69 | "dataset = pd.read_csv('Position_Salaries.csv')" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 6, 75 | "metadata": { 76 | "collapsed": true 77 | }, 78 | "outputs": [], 79 | "source": [ 80 | "X = dataset.iloc[:, 1:2].values" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 7, 86 | "metadata": { 87 | "collapsed": true 88 | }, 89 | "outputs": [], 90 | "source": [ 91 | "y = dataset.iloc[:, 2].values" 92 | ] 93 | }, 94 | { 95 | "cell_type": "markdown", 96 | "metadata": {}, 97 | "source": [ 98 | "# Fitting the Decision Tree Regression to the Dataset" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 9, 104 | "metadata": { 105 | "collapsed": true 106 | }, 107 | "outputs": [], 108 | "source": [ 109 | "from sklearn.tree import DecisionTreeRegressor" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 10, 115 | "metadata": { 116 | "collapsed": true 117 | }, 118 | "outputs": [], 119 | "source": [ 120 | "regressor = DecisionTreeRegressor(random_state = 0)" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 11, 126 | "metadata": { 127 | "collapsed": false 128 | }, 129 | "outputs": [ 130 | { 131 | "data": { 132 | "text/plain": [ 133 | "DecisionTreeRegressor(criterion='mse', max_depth=None, max_features=None,\n", 134 | " max_leaf_nodes=None, min_impurity_split=1e-07,\n", 135 | " min_samples_leaf=1, min_samples_split=2,\n", 136 | " min_weight_fraction_leaf=0.0, presort=False, random_state=0,\n", 137 | " splitter='best')" 138 | ] 139 | }, 140 | "execution_count": 11, 141 | "metadata": {}, 142 | "output_type": "execute_result" 143 | } 144 | ], 145 | "source": [ 146 | "regressor.fit(X,y)" 147 | ] 148 | }, 149 | { 150 | "cell_type": "markdown", 151 | "metadata": {}, 152 | "source": [ 153 | "# Predicting a New Result" 154 | ] 155 | }, 156 | { 157 | "cell_type": "code", 158 | "execution_count": 20, 159 | "metadata": { 160 | "collapsed": false 161 | }, 162 | "outputs": [], 163 | "source": [ 164 | "y_pred = regressor.predict(6.5)" 165 | ] 166 | }, 167 | { 168 | "cell_type": "code", 169 | "execution_count": 21, 170 | "metadata": { 171 | "collapsed": false 172 | }, 173 | "outputs": [ 174 | { 175 | "data": { 176 | "text/plain": [ 177 | "array([ 150000.])" 178 | ] 179 | }, 180 | "execution_count": 21, 181 | "metadata": {}, 182 | "output_type": "execute_result" 183 | } 184 | ], 185 | "source": [ 186 | "y_pred" 187 | ] 188 | }, 189 | { 190 | "cell_type": "markdown", 191 | "metadata": {}, 192 | "source": [ 193 | "# Visulaizing the Regression Results (In Higher Resolution)" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": 15, 199 | "metadata": { 200 | "collapsed": true 201 | }, 202 | "outputs": [], 203 | "source": [ 204 | "X_grid = np.arange(min(X), max(X), 0.01)" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": 16, 210 | "metadata": { 211 | "collapsed": true 212 | }, 213 | "outputs": [], 214 | "source": [ 215 | "X_grid = X_grid.reshape((len(X_grid), 1))" 216 | ] 217 | }, 218 | { 219 | "cell_type": "code", 220 | "execution_count": 18, 221 | "metadata": { 222 | "collapsed": false 223 | }, 224 | "outputs": [ 225 | { 226 | "data": { 227 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAAEZCAYAAADYGFGeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n", 228 | "text/plain": [ 229 | "" 230 | ] 231 | }, 232 | "metadata": {}, 233 | "output_type": "display_data" 234 | } 235 | ], 236 | "source": [ 237 | "plt.scatter(X, y, color = 'orange')\n", 238 | "plt.plot(X_grid, regressor.predict(X_grid), color = 'blue')\n", 239 | "plt.title('Truth or Bluff (Decision Tree Regression)')\n", 240 | "plt.xlabel('Position Level')\n", 241 | "plt.ylabel('Salary')\n", 242 | "plt.show()" 243 | ] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": { 249 | "collapsed": true 250 | }, 251 | "outputs": [], 252 | "source": [] 253 | } 254 | ], 255 | "metadata": { 256 | "anaconda-cloud": {}, 257 | "kernelspec": { 258 | "display_name": "Python [Root]", 259 | "language": "python", 260 | "name": "Python [Root]" 261 | }, 262 | "language_info": { 263 | "codemirror_mode": { 264 | "name": "ipython", 265 | "version": 3 266 | }, 267 | "file_extension": ".py", 268 | "mimetype": "text/x-python", 269 | "name": "python", 270 | "nbconvert_exporter": "python", 271 | "pygments_lexer": "ipython3", 272 | "version": "3.5.2" 273 | } 274 | }, 275 | "nbformat": 4, 276 | "nbformat_minor": 0 277 | } 278 | -------------------------------------------------------------------------------- /Decision Tree Regression.R: -------------------------------------------------------------------------------- 1 | # Decision Tree Regression in R 2 | 3 | ## Setting the Working Directory 4 | setwd('./Machine Learning A-Z/Part 2 - Regression/Section 8 - Decision Tree Regression') 5 | 6 | # Importing the dataset 7 | dataset = read.csv('Position_Salaries.csv') 8 | dataset = dataset[2:3] 9 | 10 | # Fitting the Decision Tree Regression to the dataset 11 | library(e1071) 12 | library(rpart) 13 | regressor = rpart(formula = Salary ~ ., 14 | data = dataset, 15 | control = rpart.control(minsplit = 1)) 16 | 17 | # Predicting a new result 18 | y_pred = predict(regressor, data.frame(Level = 6.5)) 19 | y_pred 20 | 21 | # Visualising the SVR Model results 22 | 23 | library(ggplot2) 24 | X_grid = seq(min(dataset$Level), max(dataset$Level), 0.1) 25 | ggplot() + 26 | geom_point(aes(x = dataset$Level, y = dataset$Salary), 27 | colour = 'red') + 28 | geom_line(aes(x = X_grid, y = predict(regressor, 29 | newdata = data.frame(Level=X_grid))), 30 | colour = 'blue') + 31 | ggtitle('Truth or Bluff (Decision Tree Regression)') + 32 | xlab('Level') + 33 | ylab('Salary') -------------------------------------------------------------------------------- /Grid Search.R: -------------------------------------------------------------------------------- 1 | # Grid Search 2 | 3 | # Setting Working Directory 4 | setwd('./Machine Learning A-Z/Part 10 - Model Selection/Section 52 - Evaluating & Improving Model Performance') 5 | 6 | # Importing the dataset 7 | dataset = read.csv('Social_Network_Ads.csv') 8 | dataset = dataset[3:5] 9 | 10 | # Encoding the target feature as factor 11 | dataset$Purchased = factor(dataset$Purchased, levels = c(0, 1)) 12 | 13 | # Splitting the dataset into the Training set and Test set 14 | 15 | library(caTools) 16 | set.seed(123) 17 | split = sample.split(dataset$Purchased, SplitRatio = 0.75) 18 | training_set = subset(dataset, split == TRUE) 19 | test_set = subset(dataset, split == FALSE) 20 | 21 | # Feature Scaling 22 | training_set[-3] = scale(training_set[-3]) 23 | test_set[-3] = scale(test_set[-3]) 24 | 25 | # Fitting Kernel SVM to the Training set 26 | 27 | library(e1071) 28 | classifier = svm(formula = Purchased ~ ., 29 | data = training_set, 30 | type = 'C-classification', 31 | kernel = 'radial') 32 | classifier 33 | 34 | # Predicting the Test set results 35 | y_pred = predict(classifier, newdata = test_set[-3]) 36 | y_pred 37 | 38 | # Making the Confusion Matrix 39 | cm = table(test_set[, 3], y_pred) 40 | cm 41 | 42 | # Applying k-Fold Cross Validation 43 | 44 | library(caret) 45 | 46 | folds = createFolds(training_set$Purchased, k = 10) 47 | folds 48 | 49 | cv = lapply(folds, function(x) { 50 | training_fold = training_set[-x, ] 51 | test_fold = training_set[x, ] 52 | classifier = svm(formula = Purchased ~ ., 53 | data = training_fold, 54 | type = 'C-classification', 55 | kernel = 'radial') 56 | y_pred = predict(classifier, newdata = test_fold[-3]) 57 | cm = table(test_fold[, 3], y_pred) 58 | accuracy = (cm[1,1] + cm[2,2]) / (cm[1,1] + cm[2,2] + cm[1,2] + cm[2,1]) 59 | return(accuracy) 60 | }) 61 | cv 62 | 63 | accuracy = mean(as.numeric(cv)) 64 | accuracy 65 | 66 | # Applying Grid Search to find the best parameters 67 | 68 | library(caret) 69 | classifier = train(form = Purchased ~ ., data = training_set, method = 'svmRadial') 70 | classifier 71 | classifier$bestTune 72 | 73 | # Visualising the Training set results 74 | library(ElemStatLearn) 75 | set = training_set 76 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 77 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 78 | grid_set = expand.grid(X1, X2) 79 | colnames(grid_set) = c('Age', 'EstimatedSalary') 80 | y_grid = predict(classifier, newdata = grid_set) 81 | plot(set[, -3], 82 | main = 'Kernel SVM (Training Set)', 83 | xlab = 'Age', ylab = 'Estimated Salary', 84 | xlim = range(X1), ylim = range(X2)) 85 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 86 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'springgreen3', 'tomato')) 87 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) 88 | 89 | # Visualising the Test set results 90 | library(ElemStatLearn) 91 | set = test_set 92 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 93 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 94 | grid_set = expand.grid(X1, X2) 95 | colnames(grid_set) = c('Age', 'EstimatedSalary') 96 | y_grid = predict(classifier, newdata = grid_set) 97 | plot(set[, -3], main = 'Kernel SVM (Test Set)', 98 | xlab = 'Age', ylab = 'Estimated Salary', 99 | xlim = range(X1), ylim = range(X2)) 100 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 101 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'springgreen3', 'tomato')) 102 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) -------------------------------------------------------------------------------- /HC in R.R: -------------------------------------------------------------------------------- 1 | # Hierarchical Clustering 2 | 3 | ### Part 1 4 | 5 | ## Change Working Directory 6 | 7 | setwd('./Machine Learning A-Z/Part 4 - Clustering/Section 25 - Hierarchical Clustering') 8 | 9 | ## Importing the Mall Dataset 10 | 11 | dataset <- read.csv("Mall_Customers.csv") 12 | dataset 13 | X <- dataset[4:5] 14 | X 15 | 16 | ### Part 2 17 | 18 | ## Using the Dendrogram to Find the Optimal Number of Clusters 19 | 20 | dendrogram = hclust(dist(X, method = 'euclidean'), method='ward.D') 21 | plot(dendrogram, main=paste('Dendrogram'), 22 | xlab='Customers', ylab='Euclidean Distances') 23 | 24 | ### Part 3 25 | 26 | ## Fitting Hierarchical Clustering to the Mall Dataset 27 | 28 | hc = hclust(dist(X, method='euclidean'), method='ward.D') 29 | y_hc = cutree(hc, 5) 30 | y_hc 31 | 32 | ### Part 4 33 | 34 | ## Visualizing the Clusters 35 | library(cluster) 36 | clusplot(X, y_hc, lines = 0, shade = TRUE, color = TRUE, 37 | labels = 2, plotchar = FALSE, span = TRUE, 38 | main = paste('Clusters of Clients'), 39 | xlab = "Annual Income", 40 | ylab = "Spending Score") 41 | 42 | 43 | 44 | -------------------------------------------------------------------------------- /K-Means Clustering Lecture.R: -------------------------------------------------------------------------------- 1 | # K-Means Clustering 2 | 3 | ## Change Working Directory 4 | setwd('./Machine Learning A-Z/Part 4 - Clustering/Section 24 - K-Means Clustering') 5 | 6 | ## Importing the Mall Dataset 7 | dataset <- read.csv("Mall_Customers.csv") 8 | dataset 9 | X <- dataset[4:5] 10 | X 11 | 12 | ## Using the Elbow Method to Find the Optimal Number of Clusters 13 | set.seed(6) 14 | wcss <- vector() 15 | for (i in 1:10) wcss[i] <- sum(kmeans(X,i)$withinss) 16 | plot(1:10, wcss, type = "b", main = paste('Clusters of Clients'), 17 | xlab = "Number of Clusters", ylab = "WCSS") 18 | 19 | ## Applying K-Means to the Mall Dataset 20 | set.seed(29) 21 | kmeans <- kmeans(X, 5, iter.max = 300, nstart = 10) 22 | 23 | ## Visualizing the Clusters 24 | library(cluster) 25 | clusplot(X, kmeans$cluster, lines = 0, shade = TRUE, color = TRUE, 26 | labels = 2, plotchar = FALSE, span = TRUE, 27 | main = paste('Clusters of Clients'), 28 | xlab = "Annual Income", 29 | ylab = "Spending Score") 30 | -------------------------------------------------------------------------------- /Kernel PCA.R: -------------------------------------------------------------------------------- 1 | # Kernel PCA 2 | 3 | # Setting the Working Directory 4 | setwd('./Machine Learning A-Z/Part 9 - Dimensionality Reduction/Section 48 - Kernel PCA') 5 | 6 | # Importing the dataset 7 | dataset = read.csv('Social_Network_Ads.csv') 8 | dataset = dataset[, 3:5] 9 | 10 | # Splitting the dataset into the Training set and Test set 11 | # install.packages('caTools') 12 | library(caTools) 13 | set.seed(123) 14 | split = sample.split(dataset$Purchased, SplitRatio = 0.75) 15 | training_set = subset(dataset, split == TRUE) 16 | test_set = subset(dataset, split == FALSE) 17 | 18 | # Feature Scaling 19 | training_set[, 1:2] = scale(training_set[, 1:2]) 20 | test_set[, 1:2] = scale(test_set[, 1:2]) 21 | 22 | # Applying Kernel PCA 23 | # install.packages('kernlab') 24 | library(kernlab) 25 | kpca = kpca(~., data = training_set[-3], kernel = 'rbfdot', features = 2) 26 | training_set_pca = as.data.frame(predict(kpca, training_set)) 27 | training_set_pca$Purchased = training_set$Purchased 28 | test_set_pca = as.data.frame(predict(kpca, test_set)) 29 | test_set_pca$Purchased = test_set$Purchased 30 | 31 | # Fitting Logistic Regression to the Training set 32 | classifier = glm(formula = Purchased ~ ., 33 | family = binomial, 34 | data = training_set_pca) 35 | 36 | # Predicting the Test set results 37 | prob_pred = predict(classifier, type = 'response', newdata = test_set_pca[-3]) 38 | y_pred = ifelse(prob_pred > 0.5, 1, 0) 39 | 40 | # Making the Confusion Matrix 41 | cm = table(test_set_pca[, 3], y_pred) 42 | 43 | # Visualising the Training set results 44 | install.packages('ElemStatLearn') 45 | library(ElemStatLearn) 46 | set = training_set_pca 47 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 48 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 49 | grid_set = expand.grid(X1, X2) 50 | colnames(grid_set) = c('V1', 'V2') 51 | prob_set = predict(classifier, type = 'response', newdata = grid_set) 52 | y_grid = ifelse(prob_set > 0.5, 1, 0) 53 | plot(set[, -3], 54 | main = 'Logistic Regression (Training set)', 55 | xlab = 'PC1', ylab = 'PC2', 56 | xlim = range(X1), ylim = range(X2)) 57 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 58 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'springgreen3', 'tomato')) 59 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) 60 | 61 | # Visualising the Test set results 62 | # install.packages('ElemStatLearn') 63 | library(ElemStatLearn) 64 | set = test_set_pca 65 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 66 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 67 | grid_set = expand.grid(X1, X2) 68 | colnames(grid_set) = c('V1', 'V2') 69 | prob_set = predict(classifier, type = 'response', newdata = grid_set) 70 | y_grid = ifelse(prob_set > 0.5, 1, 0) 71 | plot(set[, -3], 72 | main = 'Logistic Regression (Test set)', 73 | xlab = 'Age', ylab = 'Estimated Salary', 74 | xlim = range(X1), ylim = range(X2)) 75 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 76 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'springgreen3', 'tomato')) 77 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) -------------------------------------------------------------------------------- /Kernel SVM.R: -------------------------------------------------------------------------------- 1 | # Kernel SVM 2 | 3 | ### Changing the Working Directory 4 | 5 | setwd('./Machine Learning A-Z/Part 3 - Classification/Section 17 - Kernel SVM') 6 | 7 | ## Importing the Dataset 8 | 9 | dataset = read.csv('Social_Network_Ads.csv') 10 | dataset = dataset[3:5] 11 | 12 | ## Splitting the Dataset into the Training Set and Test Set 13 | 14 | library(caTools) 15 | set.seed(123) 16 | split = sample.split(dataset$Purchased, SplitRatio = 0.75) 17 | training_set = subset(dataset, split == TRUE) 18 | test_set = subset(dataset, split == FALSE) 19 | 20 | ## Feature Scaling 21 | 22 | training_set[-3] = scale(training_set[-3]) 23 | test_set[-3] = scale(test_set[-3]) 24 | 25 | ## Fitting classifier to the Training Set 26 | 27 | library(e1071) 28 | 29 | classifier = svm(formula = Purchased ~ ., 30 | data = training_set, 31 | type = 'C-classification', 32 | kernel = 'radial') 33 | 34 | ## Predicting the Test Set Results 35 | 36 | y_pred = predict(classifier, newdata = test_set[-3]) 37 | 38 | ## Making the Confusion Matrix 39 | 40 | cm = table(test_set[,3], y_pred) 41 | cm 42 | 43 | ## Visualizing the Training Set Results 44 | 45 | library(ElemStatLearn) 46 | set = training_set 47 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 48 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 49 | grid_set = expand.grid(X1, X2) 50 | colnames(grid_set) = c('Age', 'EstimatedSalary') 51 | y_grid = predict(classifier, newdata = grid_set) 52 | plot(set[, -3], 53 | main = 'Kernel SVM (Training Set)', 54 | xlab = 'Age', ylab = 'Estimated Salary', 55 | xlim = range(X1), ylim = range(X2)) 56 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 57 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'salmon', 'blue')) 58 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) 59 | 60 | ## Visualizing the Test Set Results 61 | 62 | 63 | set = test_set 64 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 65 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 66 | grid_set = expand.grid(X1, X2) 67 | colnames(grid_set) = c('Age', 'EstimatedSalary') 68 | y_grid = predict(classifier, newdata = grid_set) 69 | plot(set[, -3], 70 | main = 'Kernel SVM (Test Set)', 71 | xlab = 'Age', ylab = 'Estimated Salary', 72 | xlim = range(X1), ylim = range(X2)) 73 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 74 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'khaki', 'maroon')) 75 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'blue', 'orange')) 76 | -------------------------------------------------------------------------------- /Linear Discriminant Analysis (LDA).R: -------------------------------------------------------------------------------- 1 | # LDA 2 | 3 | # Setting the Working Directory 4 | setwd('./Machine Learning A-Z/Part 9 - Dimensionality Reduction/Section 47 - Linear Discriminant Analysis (LDA)') 5 | 6 | # Importing the dataset 7 | dataset = read.csv('Wine.csv') 8 | 9 | # Splitting the dataset into the Training set and Test set 10 | library(caTools) 11 | set.seed(123) 12 | split = sample.split(dataset$Customer_Segment, SplitRatio = 0.8) 13 | training_set = subset(dataset, split == TRUE) 14 | test_set = subset(dataset, split == FALSE) 15 | 16 | # Feature Scaling 17 | training_set[-14] = scale(training_set[-14]) 18 | test_set[-14] = scale(test_set[-14]) 19 | 20 | # Applying LDA 21 | library(MASS) 22 | lda = lda(formula = Customer_Segment ~ ., data = training_set) 23 | training_set = as.data.frame(predict(lda, training_set)) 24 | training_set = training_set[c(5, 6, 1)] 25 | test_set = as.data.frame(predict(lda, test_set)) 26 | test_set = test_set[c(5, 6, 1)] 27 | 28 | # Fitting SVM to the Training set 29 | library(e1071) 30 | classifier = svm(formula = class ~ ., 31 | data = training_set, 32 | type = 'C-classification', 33 | kernel = 'linear') 34 | 35 | # Predicting the Test set results 36 | y_pred = predict(classifier, newdata = test_set[-3]) 37 | y_pred 38 | 39 | # Making the Confusion Matrix 40 | cm = table(test_set[, 3], y_pred) 41 | cm 42 | 43 | # Visualising the Training set results 44 | library(ElemStatLearn) 45 | set = training_set 46 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 47 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 48 | grid_set = expand.grid(X1, X2) 49 | colnames(grid_set) = c('x.LD1', 'x.LD2') 50 | y_grid = predict(classifier, newdata = grid_set) 51 | plot(set[, -3], 52 | main = 'SVM (Training Set)', 53 | xlab = 'LD1', ylab = 'LD2', 54 | xlim = range(X1), ylim = range(X2)) 55 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 56 | points(grid_set, pch = '.', col = ifelse(y_grid == 2, 'deepskyblue', ifelse(y_grid == 1, 'springgreen3', 'tomato'))) 57 | points(set, pch = 21, bg = ifelse(set[, 3] == 2, 'blue3', ifelse(set[, 3] == 1, 'green4', 'red3'))) 58 | 59 | # Visualising the Test set results 60 | library(ElemStatLearn) 61 | set = test_set 62 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 63 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 64 | grid_set = expand.grid(X1, X2) 65 | colnames(grid_set) = c('x.LD1', 'x.LD2') 66 | y_grid = predict(classifier, newdata = grid_set) 67 | plot(set[, -3], main = 'SVM (Test Set)', 68 | xlab = 'LD1', ylab = 'LD2', 69 | xlim = range(X1), ylim = range(X2)) 70 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 71 | points(grid_set, pch = '.', col = ifelse(y_grid == 2, 'deepskyblue', ifelse(y_grid == 1, 'springgreen3', 'tomato'))) 72 | points(set, pch = 21, bg = ifelse(set[, 3] == 2, 'blue3', ifelse(set[, 3] == 1, 'green4', 'red3'))) -------------------------------------------------------------------------------- /Logistic Regression Lecture.R: -------------------------------------------------------------------------------- 1 | # Logistic Regression 2 | 3 | ## Changing the Working Directory 4 | setwd('./Machine Learning A-Z/Part 3 - Classification/Section 14 - Logistic Regression') 5 | 6 | ## Importing the Dataset 7 | 8 | dataset = read.csv('./Social_Network_Ads.csv') 9 | dataset = dataset[,3:5] 10 | 11 | 12 | ## Splitting the Data into Train and Test Set 13 | 14 | library(caTools) 15 | set.seed(123) 16 | split = sample.split(dataset$Purchased, SplitRatio = 0.75) 17 | training_set = subset(dataset, split == TRUE) 18 | test_set = subset(dataset, split == FALSE) 19 | 20 | 21 | ## Feature Scaling 22 | training_set[, 1:2] = scale(training_set[, 1:2]) 23 | test_set[, 1:2] = scale(test_set[, 1:2]) 24 | 25 | ## Fitting Logistic Regression to the Training Set 26 | 27 | classifier = glm(formula = Purchased ~ . , family = binomial, data = training_set) 28 | 29 | ## Predicting the Test Set Results 30 | 31 | prob_pred = predict(classifier, type = 'response', newdata = test_set[-3]) 32 | prob_pred 33 | 34 | y_pred = ifelse(prob_pred > 0.5, 1, 0) 35 | y_pred 36 | 37 | ## Making the Confusion Matrix 38 | 39 | cm = table(test_set[, 3], y_pred) 40 | cm 41 | 42 | ## Visualizing the Training Set Results 43 | 44 | library(ElemStatLearn) 45 | set = training_set 46 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 47 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 48 | grid_set = expand.grid(X1, X2) 49 | colnames(grid_set) = c('Age', 'EstimatedSalary') 50 | prob_set = predict(classifier, type = 'response', newdata = grid_set) 51 | y_grid = ifelse(prob_set > 0.5,1,0) 52 | plot(set[, -3], 53 | main = 'Logistic Regression (Training Set)', 54 | xlab = 'Age', ylab = 'Estimated Salary', 55 | xlim = range(X1), ylim = range(X2)) 56 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 57 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'springgreen3', 'tomato')) 58 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) 59 | 60 | 61 | ## Visualising the Test Set Results 62 | 63 | set = test_set 64 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 65 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 66 | grid_set = expand.grid(X1, X2) 67 | colnames(grid_set) = c('Age', 'EstimatedSalary') 68 | prob_set = predict(classifier, type = 'response', newdata = grid_set) 69 | y_grid = ifelse(prob_set > 0.5,1,0) 70 | plot(set[, -3], 71 | main = 'Logistic Regression (Test Set)', 72 | xlab = 'Age', ylab = 'Estimated Salary', 73 | xlim = range(X1), ylim = range(X2)) 74 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 75 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'springgreen3', 'tomato')) 76 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) 77 | -------------------------------------------------------------------------------- /Missing Data.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Data Preprocessing" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 19, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "# Importing the libraries\n", 19 | "import numpy as np\n", 20 | "import pandas as pd" 21 | ] 22 | }, 23 | { 24 | "cell_type": "code", 25 | "execution_count": 20, 26 | "metadata": { 27 | "collapsed": true 28 | }, 29 | "outputs": [], 30 | "source": [ 31 | "import matplotlib.pyplot as plt" 32 | ] 33 | }, 34 | { 35 | "cell_type": "code", 36 | "execution_count": 21, 37 | "metadata": { 38 | "collapsed": true 39 | }, 40 | "outputs": [], 41 | "source": [ 42 | "dataset = pd.read_csv('Data.csv')" 43 | ] 44 | }, 45 | { 46 | "cell_type": "code", 47 | "execution_count": 22, 48 | "metadata": { 49 | "collapsed": true 50 | }, 51 | "outputs": [], 52 | "source": [ 53 | "X = dataset.iloc[:, :-1].values\n", 54 | "y = dataset.iloc[:, 3].values" 55 | ] 56 | }, 57 | { 58 | "cell_type": "code", 59 | "execution_count": 23, 60 | "metadata": { 61 | "collapsed": true 62 | }, 63 | "outputs": [], 64 | "source": [ 65 | "# Taking care of missing data\n", 66 | "from sklearn.preprocessing import Imputer" 67 | ] 68 | }, 69 | { 70 | "cell_type": "code", 71 | "execution_count": 30, 72 | "metadata": { 73 | "collapsed": true 74 | }, 75 | "outputs": [], 76 | "source": [ 77 | "imputer = Imputer(missing_values = 'NaN', strategy = 'mean', axis = 0)" 78 | ] 79 | }, 80 | { 81 | "cell_type": "code", 82 | "execution_count": 31, 83 | "metadata": { 84 | "collapsed": false 85 | }, 86 | "outputs": [], 87 | "source": [ 88 | "imputer = imputer.fit(X[:, 1:3])" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 32, 94 | "metadata": { 95 | "collapsed": false 96 | }, 97 | "outputs": [], 98 | "source": [ 99 | "X[:, 1:3] = imputer.transform(X[:, 1:3])" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 34, 105 | "metadata": { 106 | "collapsed": false 107 | }, 108 | "outputs": [ 109 | { 110 | "data": { 111 | "text/plain": [ 112 | "array([['France', 44.0, 72000.0],\n", 113 | " ['Spain', 27.0, 48000.0],\n", 114 | " ['Germany', 30.0, 54000.0],\n", 115 | " ['Spain', 38.0, 61000.0],\n", 116 | " ['Germany', 40.0, 63777.77777777778],\n", 117 | " ['France', 35.0, 58000.0],\n", 118 | " ['Spain', 38.77777777777778, 52000.0],\n", 119 | " ['France', 48.0, 79000.0],\n", 120 | " ['Germany', 50.0, 83000.0],\n", 121 | " ['France', 37.0, 67000.0]], dtype=object)" 122 | ] 123 | }, 124 | "execution_count": 34, 125 | "metadata": {}, 126 | "output_type": "execute_result" 127 | } 128 | ], 129 | "source": [ 130 | "X" 131 | ] 132 | }, 133 | { 134 | "cell_type": "code", 135 | "execution_count": null, 136 | "metadata": { 137 | "collapsed": false 138 | }, 139 | "outputs": [], 140 | "source": [] 141 | }, 142 | { 143 | "cell_type": "code", 144 | "execution_count": 14, 145 | "metadata": { 146 | "collapsed": true 147 | }, 148 | "outputs": [], 149 | "source": [] 150 | }, 151 | { 152 | "cell_type": "code", 153 | "execution_count": null, 154 | "metadata": { 155 | "collapsed": true 156 | }, 157 | "outputs": [], 158 | "source": [] 159 | } 160 | ], 161 | "metadata": { 162 | "anaconda-cloud": {}, 163 | "kernelspec": { 164 | "display_name": "Python [Root]", 165 | "language": "python", 166 | "name": "Python [Root]" 167 | }, 168 | "language_info": { 169 | "codemirror_mode": { 170 | "name": "ipython", 171 | "version": 3 172 | }, 173 | "file_extension": ".py", 174 | "mimetype": "text/x-python", 175 | "name": "python", 176 | "nbconvert_exporter": "python", 177 | "pygments_lexer": "ipython3", 178 | "version": "3.5.2" 179 | } 180 | }, 181 | "nbformat": 4, 182 | "nbformat_minor": 0 183 | } 184 | -------------------------------------------------------------------------------- /Multiple Linear Regression Lecture and HW.R: -------------------------------------------------------------------------------- 1 | # Multiple Linear Regression 2 | 3 | setwd('./Machine Learning A-Z/Part 2 - Regression/Section 5 - Multiple Linear Regression') 4 | 5 | # Importing the dataset 6 | dataset = read.csv('50_Startups.csv') 7 | # dataset = dataset[, 2:3] 8 | 9 | # Encoding categorical data 10 | dataset$State = factor(dataset$State, 11 | levels = c('New York', 'California', 'Florida'), 12 | labels = c(1, 2, 3)) 13 | 14 | dataset 15 | 16 | 17 | # Splitting the dataset into the Training set and Test set 18 | # install.packages('caTools') 19 | library(caTools) 20 | set.seed(123) 21 | split = sample.split(dataset$Profit, SplitRatio = 0.8) 22 | training_set = subset(dataset, split == TRUE) 23 | test_set = subset(dataset, split == FALSE) 24 | 25 | 26 | ## Part 2 27 | # Feature Scaling 28 | # training_set[, 2:3] = scale(training_set[, 2:3]) 29 | # test_set[, 2:3] = scale(test_set[, 2:3]) 30 | 31 | # Fitting Multiple Linear Regression Models 32 | regressor = lm(formula = Profit ~ ., data = training_set) 33 | summary(regressor) 34 | 35 | 36 | ## Part 3 - Predicting the Test Set Results 37 | 38 | y_pred = predict(regressor, newdata = test_set) 39 | y_pred 40 | 41 | ## Building the Optimal Model Using Backward Elimination 42 | 43 | regressor = lm(formula = Profit ~ R.D.Spend + Administration + 44 | Marketing.Spend + State, data = dataset) 45 | summary(regressor) 46 | 47 | #### Iteration 1 48 | 49 | regressor = lm(formula = Profit ~ R.D.Spend + Administration + 50 | Marketing.Spend, data = dataset) 51 | summary(regressor) 52 | 53 | 54 | #### Iteration 2 (Solutions) 55 | regressor = lm(formula = Profit ~ R.D.Spend + Marketing.Spend, data = dataset) 56 | summary(regressor) 57 | 58 | 59 | #### Iteration 3 60 | 61 | regressor = lm(formula = Profit ~ R.D.Spend, data = dataset) 62 | summary(regressor) 63 | 64 | 65 | -------------------------------------------------------------------------------- /Naive Bayes.R: -------------------------------------------------------------------------------- 1 | # Support Vector Machine (SVM) Lecture 2 | 3 | ### Changing the Working Directory 4 | 5 | setwd('./Machine Learning A-Z/Part 3 - Classification/Section 18 - Naive Bayes') 6 | 7 | ## Importing the Dataset 8 | 9 | dataset = read.csv('Social_Network_Ads.csv') 10 | dataset = dataset[3:5] 11 | 12 | ## Encoding the Target Feature as Factor 13 | 14 | dataset$Purchased = factor(dataset$Purchased, levels = c(0,1)) 15 | 16 | ## Splitting the Dataset into the Training Set and Test Set 17 | 18 | library(caTools) 19 | set.seed(123) 20 | split = sample.split(dataset$Purchased, SplitRatio = 0.75) 21 | training_set = subset(dataset, split == TRUE) 22 | test_set = subset(dataset, split == FALSE) 23 | 24 | ## Feature Scaling 25 | 26 | training_set[-3] = scale(training_set[-3]) 27 | test_set[-3] = scale(test_set[-3]) 28 | 29 | ## Fitting Naive Bayes to the Training Set 30 | 31 | library(e1071) 32 | 33 | classifier = naiveBayes(x = training_set[-3], 34 | y = training_set$Purchased) 35 | 36 | ## Predicting the Test Set Results 37 | 38 | y_pred = predict(classifier, newdata = test_set[-3]) 39 | y_pred 40 | 41 | ## Making the Confusion Matrix 42 | 43 | cm = table(test_set[,3], y_pred) 44 | cm 45 | 46 | ## Visualizing the Training Set Results 47 | 48 | library(ElemStatLearn) 49 | set = training_set 50 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 51 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 52 | grid_set = expand.grid(X1, X2) 53 | colnames(grid_set) = c('Age', 'EstimatedSalary') 54 | y_grid = predict(classifier, newdata = grid_set) 55 | plot(set[, -3], 56 | main = 'Naive Bayes (Training Set)', 57 | xlab = 'Age', ylab = 'Estimated Salary', 58 | xlim = range(X1), ylim = range(X2)) 59 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 60 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'salmon', 'blue')) 61 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) 62 | 63 | ## Visualizing the Test Set Results 64 | 65 | 66 | set = test_set 67 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 68 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 69 | grid_set = expand.grid(X1, X2) 70 | colnames(grid_set) = c('Age', 'EstimatedSalary') 71 | y_grid = predict(classifier, newdata = grid_set) 72 | plot(set[, -3], 73 | main = 'Naive Bayes (Test Set)', 74 | xlab = 'Age', ylab = 'Estimated Salary', 75 | xlim = range(X1), ylim = range(X2)) 76 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 77 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'khaki', 'maroon')) 78 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'blue', 'orange')) 79 | -------------------------------------------------------------------------------- /Polynomial Regression Lecture.R: -------------------------------------------------------------------------------- 1 | # Polynomial Regression 2 | 3 | ## Setting the Working Directory 4 | setwd('./Machine Learning A-Z/Part 2 - Regression/Section 6 - Polynomial Regression') 5 | 6 | 7 | ## Importing the dataset 8 | dataset = read.csv('Position_Salaries.csv') 9 | dataset = dataset[2:3] 10 | 11 | ## Part 2 12 | 13 | ### Fitting Linear Regression to the Dataset 14 | 15 | lin_reg = lm(formula = Salary ~ ., data = dataset) 16 | summary(lin_reg) 17 | 18 | ### Fitting Polynomial Regression to the Dataset 19 | 20 | dataset$Level2 = dataset$Level^2 21 | dataset$Level3 = dataset$Level^3 22 | dataset$Level4 = dataset$Level^4 23 | dataset 24 | poly_reg = lm(formula = Salary ~ . , data = dataset) 25 | summary(poly_reg) 26 | 27 | 28 | ## Part 3 29 | 30 | ### Visualizing Linear Regression Results 31 | 32 | library(ggplot2) 33 | ggplot() + 34 | geom_point(aes(x = dataset$Level, y = dataset$Salary), color = 'red') + 35 | geom_line(aes(x = dataset$Level, y = predict(lin_reg, newdata = dataset)), color = 'blue') + 36 | ggtitle('Truth or Bluff (Linear Regression)') + 37 | xlab('Level') + ylab('Salary') 38 | 39 | 40 | ### Visualizing Polynomial Regression Results 41 | 42 | ggplot() + 43 | geom_point(aes(x = dataset$Level, y = dataset$Salary), color = 'salmon') + 44 | geom_line(aes(x = dataset$Level, y = predict(poly_reg, newdata = dataset)), color = 'darkgreen') + 45 | ggtitle('Truth or Bluff (Polynomial Regression)') + 46 | xlab('Level') + ylab('Salary') 47 | 48 | ## Part 4 49 | 50 | ### Predicting a New Result with Linear Regression 51 | 52 | y_pred = predict(lin_reg, data.frame(Level = 6.5)) 53 | y_pred 54 | 55 | 56 | ### Predicting a New Result with Polynomial Regression 57 | 58 | y_pred = predict(poly_reg, data.frame(Level = 6.5, 59 | Level2 = 6.5^2, 60 | Level3 = 6.5^3, 61 | Level4 = 6.5^4)) 62 | y_pred 63 | 64 | 65 | -------------------------------------------------------------------------------- /Principal Component Analysis.R: -------------------------------------------------------------------------------- 1 | # PCA 2 | 3 | # Setting the Working Directory 4 | setwd('./Machine Learning A-Z/Part 9 - Dimensionality Reduction/Section 46 - Principal Component Analysis (PCA)') 5 | 6 | # Importing the dataset 7 | dataset = read.csv('Wine.csv') 8 | 9 | # Splitting the dataset into the Training set and Test set 10 | # install.packages('caTools') 11 | library(caTools) 12 | set.seed(123) 13 | split = sample.split(dataset$Customer_Segment, SplitRatio = 0.8) 14 | training_set = subset(dataset, split == TRUE) 15 | test_set = subset(dataset, split == FALSE) 16 | 17 | # Feature Scaling 18 | training_set[-14] = scale(training_set[-14]) 19 | test_set[-14] = scale(test_set[-14]) 20 | 21 | # Applying PCA 22 | # install.packages('caret') 23 | library(caret) 24 | # install.packages('e1071') 25 | library(e1071) 26 | pca = preProcess(x = training_set[-14], method = 'pca', pcaComp = 2) 27 | training_set = predict(pca, training_set) 28 | training_set = training_set[c(2, 3, 1)] 29 | test_set = predict(pca, test_set) 30 | test_set = test_set[c(2, 3, 1)] 31 | 32 | # Fitting SVM to the Training set 33 | # install.packages('e1071') 34 | library(e1071) 35 | classifier = svm(formula = Customer_Segment ~ ., 36 | data = training_set, 37 | type = 'C-classification', 38 | kernel = 'linear') 39 | 40 | # Predicting the Test set results 41 | y_pred = predict(classifier, newdata = test_set[-3]) 42 | 43 | # Making the Confusion Matrix 44 | cm = table(test_set[, 3], y_pred) 45 | 46 | # Visualising the Training set results 47 | library(ElemStatLearn) 48 | set = training_set 49 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 50 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 51 | grid_set = expand.grid(X1, X2) 52 | colnames(grid_set) = c('PC1', 'PC2') 53 | y_grid = predict(classifier, newdata = grid_set) 54 | plot(set[, -3], 55 | main = 'SVM (Training Set)', 56 | xlab = 'PC1', ylab = 'PC2', 57 | xlim = range(X1), ylim = range(X2)) 58 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 59 | points(grid_set, pch = '.', col = ifelse(y_grid == 2, 'deepskyblue', ifelse(y_grid == 1, 'springgreen3', 'tomato'))) 60 | points(set, pch = 21, bg = ifelse(set[, 3] == 2, 'blue3', ifelse(set[, 3] == 1, 'green4', 'red3'))) 61 | 62 | # Visualising the Test set results 63 | set = test_set 64 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 65 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 66 | grid_set = expand.grid(X1, X2) 67 | colnames(grid_set) = c('PC1', 'PC2') 68 | y_grid = predict(classifier, newdata = grid_set) 69 | plot(set[, -3], main = 'SVM (Test Set)', 70 | xlab = 'PC1', ylab = 'PC2', 71 | xlim = range(X1), ylim = range(X2)) 72 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 73 | points(grid_set, pch = '.', col = ifelse(y_grid == 2, 'deepskyblue', ifelse(y_grid == 1, 'springgreen3', 'tomato'))) 74 | points(set, pch = 21, bg = ifelse(set[, 3] == 2, 'blue3', ifelse(set[, 3] == 1, 'green4', 'red3'))) -------------------------------------------------------------------------------- /README.md: -------------------------------------------------------------------------------- 1 | # Machine-Learning-A-Z 2 | 3 | This is a repository for the Udemy course on Machine Learning with Python and R. 4 | -------------------------------------------------------------------------------- /Random Forest Classification Lecture.R: -------------------------------------------------------------------------------- 1 | # Random Forest Classifier Lecture 2 | 3 | ### Changing the Working Directory 4 | 5 | setwd('./Machine Learning A-Z/Part 3 - Classification/Section 20 - Random Forest Classification') 6 | 7 | ## Importing the Dataset 8 | 9 | dataset = read.csv('Social_Network_Ads.csv') 10 | dataset = dataset[3:5] 11 | 12 | ## Encoding the Target Feature as Factor 13 | 14 | dataset$Purchased = factor(dataset$Purchased, levels = c(0,1)) 15 | 16 | ## Splitting the Dataset into the Training Set and Test Set 17 | 18 | library(caTools) 19 | set.seed(123) 20 | split = sample.split(dataset$Purchased, SplitRatio = 0.75) 21 | training_set = subset(dataset, split == TRUE) 22 | test_set = subset(dataset, split == FALSE) 23 | 24 | ## Feature Scaling 25 | 26 | training_set[-3] = scale(training_set[-3]) 27 | test_set[-3] = scale(test_set[-3]) 28 | 29 | ## Fitting Random Forest Classification to the Training Set 30 | 31 | library(randomForest) 32 | 33 | classifier = randomForest(x = training_set[-3], 34 | y = training_set$Purchased, 35 | ntree = 10) 36 | 37 | 38 | ## Predicting the Test Set Results 39 | 40 | y_pred = predict(classifier, newdata = test_set[-3]) 41 | y_pred 42 | 43 | ## Making the Confusion Matrix 44 | 45 | cm = table(test_set[,3], y_pred) 46 | cm 47 | 48 | ## Visualizing the Training Set Results 49 | 50 | library(ElemStatLearn) 51 | set = training_set 52 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 53 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 54 | grid_set = expand.grid(X1, X2) 55 | colnames(grid_set) = c('Age', 'EstimatedSalary') 56 | y_grid = predict(classifier, newdata = grid_set, type ='class') 57 | plot(set[, -3], 58 | main = 'Random Forest Classifier (Training Set)', 59 | xlab = 'Age', ylab = 'Estimated Salary', 60 | xlim = range(X1), ylim = range(X2)) 61 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 62 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'salmon', 'blue')) 63 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) 64 | 65 | ## Visualizing the Test Set Results 66 | 67 | 68 | set = test_set 69 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 70 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 71 | grid_set = expand.grid(X1, X2) 72 | colnames(grid_set) = c('Age', 'EstimatedSalary') 73 | y_grid = predict(classifier, newdata = grid_set, type = 'class') 74 | plot(set[, -3], 75 | main = 'Random Forest Classifier (Test Set)', 76 | xlab = 'Age', ylab = 'Estimated Salary', 77 | xlim = range(X1), ylim = range(X2)) 78 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 79 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'red', 'green')) 80 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'blue', 'orange')) 81 | 82 | 83 | ## Plotting the Decision Tree 84 | 85 | plot(classifier) 86 | text(classifier) -------------------------------------------------------------------------------- /Random Forest Regression.R: -------------------------------------------------------------------------------- 1 | # Random Forest Regression in R 2 | 3 | ## Setting the Working Directory 4 | setwd('./Machine Learning A-Z/Part 2 - Regression/Section 9 - Random Forest Regression') 5 | 6 | # Importing the dataset 7 | dataset = read.csv('Position_Salaries.csv') 8 | dataset = dataset[2:3] 9 | 10 | # Fitting the Random Forest Regression to the dataset 11 | library(e1071) 12 | library(randomForest) 13 | library(rpart) 14 | set.seed(1234) 15 | regressor = randomForest(x = dataset[1], 16 | y = dataset$Salary, 17 | ntree = 500) 18 | regressor 19 | 20 | # Predicting a new result 21 | 22 | y_pred = predict(regressor, data.frame(Level = 6.5)) 23 | y_pred 24 | 25 | # Visualising the Random Forest Regression Model results 26 | 27 | library(ggplot2) 28 | X_grid = seq(min(dataset$Level), max(dataset$Level), 0.01) 29 | ggplot() + 30 | geom_point(aes(x = dataset$Level, y = dataset$Salary), 31 | color = 'red') + 32 | geom_line(aes(x = X_grid, y = predict(regressor, 33 | newdata = data.frame(Level=X_grid))), 34 | color = 'blue') + 35 | ggtitle('Truth or Bluff (Random Forest Regression)') + 36 | xlab('Level') + 37 | ylab('Salary') -------------------------------------------------------------------------------- /Random Forest Regression.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Importing the Packages" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 28, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "import numpy as np" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": 29, 24 | "metadata": { 25 | "collapsed": true 26 | }, 27 | "outputs": [], 28 | "source": [ 29 | "import pandas as pd" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 30, 35 | "metadata": { 36 | "collapsed": true 37 | }, 38 | "outputs": [], 39 | "source": [ 40 | "import matplotlib.pyplot as plt\n", 41 | "%matplotlib inline" 42 | ] 43 | }, 44 | { 45 | "cell_type": "markdown", 46 | "metadata": {}, 47 | "source": [ 48 | "# Reading the Dataset" 49 | ] 50 | }, 51 | { 52 | "cell_type": "code", 53 | "execution_count": 31, 54 | "metadata": { 55 | "collapsed": true 56 | }, 57 | "outputs": [], 58 | "source": [ 59 | "dataset = pd.read_csv('Position_Salaries.csv')" 60 | ] 61 | }, 62 | { 63 | "cell_type": "code", 64 | "execution_count": 32, 65 | "metadata": { 66 | "collapsed": true 67 | }, 68 | "outputs": [], 69 | "source": [ 70 | "X = dataset.iloc[:, 1:2].values" 71 | ] 72 | }, 73 | { 74 | "cell_type": "code", 75 | "execution_count": 33, 76 | "metadata": { 77 | "collapsed": true 78 | }, 79 | "outputs": [], 80 | "source": [ 81 | "y = dataset.iloc[:, 2].values" 82 | ] 83 | }, 84 | { 85 | "cell_type": "markdown", 86 | "metadata": {}, 87 | "source": [ 88 | "# Fitting the Random Forest Regression to the Dataset" 89 | ] 90 | }, 91 | { 92 | "cell_type": "code", 93 | "execution_count": 34, 94 | "metadata": { 95 | "collapsed": true 96 | }, 97 | "outputs": [], 98 | "source": [ 99 | "from sklearn.ensemble import RandomForestRegressor" 100 | ] 101 | }, 102 | { 103 | "cell_type": "code", 104 | "execution_count": 48, 105 | "metadata": { 106 | "collapsed": true 107 | }, 108 | "outputs": [], 109 | "source": [ 110 | "regressor = RandomForestRegressor(n_estimators = 300, random_state = 0)" 111 | ] 112 | }, 113 | { 114 | "cell_type": "code", 115 | "execution_count": 49, 116 | "metadata": { 117 | "collapsed": false 118 | }, 119 | "outputs": [ 120 | { 121 | "data": { 122 | "text/plain": [ 123 | "RandomForestRegressor(bootstrap=True, criterion='mse', max_depth=None,\n", 124 | " max_features='auto', max_leaf_nodes=None,\n", 125 | " min_impurity_split=1e-07, min_samples_leaf=1,\n", 126 | " min_samples_split=2, min_weight_fraction_leaf=0.0,\n", 127 | " n_estimators=300, n_jobs=1, oob_score=False, random_state=0,\n", 128 | " verbose=0, warm_start=False)" 129 | ] 130 | }, 131 | "execution_count": 49, 132 | "metadata": {}, 133 | "output_type": "execute_result" 134 | } 135 | ], 136 | "source": [ 137 | "regressor.fit(X, y)" 138 | ] 139 | }, 140 | { 141 | "cell_type": "markdown", 142 | "metadata": {}, 143 | "source": [ 144 | "# Predicting a New Result" 145 | ] 146 | }, 147 | { 148 | "cell_type": "code", 149 | "execution_count": 50, 150 | "metadata": { 151 | "collapsed": true 152 | }, 153 | "outputs": [], 154 | "source": [ 155 | "y_pred = regressor.predict(6.5)" 156 | ] 157 | }, 158 | { 159 | "cell_type": "code", 160 | "execution_count": 51, 161 | "metadata": { 162 | "collapsed": false 163 | }, 164 | "outputs": [ 165 | { 166 | "data": { 167 | "text/plain": [ 168 | "array([ 160333.33333333])" 169 | ] 170 | }, 171 | "execution_count": 51, 172 | "metadata": {}, 173 | "output_type": "execute_result" 174 | } 175 | ], 176 | "source": [ 177 | "y_pred" 178 | ] 179 | }, 180 | { 181 | "cell_type": "markdown", 182 | "metadata": {}, 183 | "source": [ 184 | "# Visualizing the Regression Results" 185 | ] 186 | }, 187 | { 188 | "cell_type": "code", 189 | "execution_count": 52, 190 | "metadata": { 191 | "collapsed": true 192 | }, 193 | "outputs": [], 194 | "source": [ 195 | "X_grid = np.arange(min(X), max(X), 0.01)" 196 | ] 197 | }, 198 | { 199 | "cell_type": "code", 200 | "execution_count": 53, 201 | "metadata": { 202 | "collapsed": true 203 | }, 204 | "outputs": [], 205 | "source": [ 206 | "X_grid = X_grid.reshape((len(X_grid),1))" 207 | ] 208 | }, 209 | { 210 | "cell_type": "code", 211 | "execution_count": 54, 212 | "metadata": { 213 | "collapsed": false 214 | }, 215 | "outputs": [ 216 | { 217 | "data": { 218 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAaQAAAEZCAYAAADYGFGeAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nZmaF8P8BYAetpfMdij0AAAAASUVORK5CYII=\n", 219 | "text/plain": [ 220 | "" 221 | ] 222 | }, 223 | "metadata": {}, 224 | "output_type": "display_data" 225 | } 226 | ], 227 | "source": [ 228 | "plt.scatter(X, y, color = 'orange')\n", 229 | "plt.plot(X_grid, regressor.predict(X_grid), color = 'blue')\n", 230 | "plt.title('Truth or Bluff (Random Forest Regression)')\n", 231 | "plt.xlabel('Position Level')\n", 232 | "plt.ylabel('Salary')\n", 233 | "plt.show()" 234 | ] 235 | }, 236 | { 237 | "cell_type": "code", 238 | "execution_count": null, 239 | "metadata": { 240 | "collapsed": true 241 | }, 242 | "outputs": [], 243 | "source": [] 244 | }, 245 | { 246 | "cell_type": "code", 247 | "execution_count": null, 248 | "metadata": { 249 | "collapsed": true 250 | }, 251 | "outputs": [], 252 | "source": [] 253 | }, 254 | { 255 | "cell_type": "code", 256 | "execution_count": null, 257 | "metadata": { 258 | "collapsed": true 259 | }, 260 | "outputs": [], 261 | "source": [] 262 | } 263 | ], 264 | "metadata": { 265 | "anaconda-cloud": {}, 266 | "kernelspec": { 267 | "display_name": "Python [Root]", 268 | "language": "python", 269 | "name": "Python [Root]" 270 | }, 271 | "language_info": { 272 | "codemirror_mode": { 273 | "name": "ipython", 274 | "version": 3 275 | }, 276 | "file_extension": ".py", 277 | "mimetype": "text/x-python", 278 | "name": "python", 279 | "nbconvert_exporter": "python", 280 | "pygments_lexer": "ipython3", 281 | "version": "3.5.2" 282 | } 283 | }, 284 | "nbformat": 4, 285 | "nbformat_minor": 0 286 | } 287 | -------------------------------------------------------------------------------- /SVM Lecture.R: -------------------------------------------------------------------------------- 1 | # Support Vector Machine (SVM) Lecture 2 | 3 | ### Changing the Working Directory 4 | 5 | setwd('./Machine Learning A-Z/Part 3 - Classification/Section 16 - Support Vector Machine (SVM)') 6 | 7 | ## Importing the Dataset 8 | 9 | dataset = read.csv('Social_Network_Ads.csv') 10 | dataset = dataset[3:5] 11 | 12 | ## Splitting the Dataset into the Training Set and Test Set 13 | 14 | library(caTools) 15 | set.seed(123) 16 | split = sample.split(dataset$Purchased, SplitRatio = 0.75) 17 | training_set = subset(dataset, split == TRUE) 18 | test_set = subset(dataset, split == FALSE) 19 | 20 | ## Feature Scaling 21 | 22 | training_set[-3] = scale(training_set[-3]) 23 | test_set[-3] = scale(test_set[-3]) 24 | 25 | ## Fitting classifier to the Training Set 26 | 27 | library(e1071) 28 | 29 | classifier = svm(formula = Purchased ~ ., 30 | data = training_set, 31 | type = 'C-classification', 32 | kernel = 'linear') 33 | 34 | ## Predicting the Test Set Results 35 | 36 | y_pred = predict(classifier, newdata = test_set[-3]) 37 | 38 | ## Making the Confusion Matrix 39 | 40 | cm = table(test_set[,3], y_pred) 41 | 42 | ## Visualizing the Training Set Results 43 | 44 | library(ElemStatLearn) 45 | set = training_set 46 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 47 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 48 | grid_set = expand.grid(X1, X2) 49 | colnames(grid_set) = c('Age', 'EstimatedSalary') 50 | y_grid = predict(classifier, newdata = grid_set) 51 | plot(set[, -3], 52 | main = 'SVM (Training Set)', 53 | xlab = 'Age', ylab = 'Estimated Salary', 54 | xlim = range(X1), ylim = range(X2)) 55 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 56 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'salmon', 'blue')) 57 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'green4', 'red3')) 58 | 59 | ## Visualizing the Test Set Results 60 | 61 | 62 | set = test_set 63 | X1 = seq(min(set[, 1]) - 1, max(set[, 1]) + 1, by = 0.01) 64 | X2 = seq(min(set[, 2]) - 1, max(set[, 2]) + 1, by = 0.01) 65 | grid_set = expand.grid(X1, X2) 66 | colnames(grid_set) = c('Age', 'EstimatedSalary') 67 | y_grid = predict(classifier, newdata = grid_set) 68 | plot(set[, -3], 69 | main = 'SVM (Test Set)', 70 | xlab = 'Age', ylab = 'Estimated Salary', 71 | xlim = range(X1), ylim = range(X2)) 72 | contour(X1, X2, matrix(as.numeric(y_grid), length(X1), length(X2)), add = TRUE) 73 | points(grid_set, pch = '.', col = ifelse(y_grid == 1, 'khaki', 'maroon')) 74 | points(set, pch = 21, bg = ifelse(set[, 3] == 1, 'blue', 'orange')) 75 | -------------------------------------------------------------------------------- /SVR.R: -------------------------------------------------------------------------------- 1 | # Support Vector Regression 2 | 3 | ## Setting the Working Directory 4 | setwd('./Machine Learning A-Z/Part 2 - Regression/Section 7 - Support Vector Regression (SVR)') 5 | 6 | # Importing the dataset 7 | dataset = read.csv('Position_Salaries.csv') 8 | dataset = dataset[2:3] 9 | 10 | # Fitting the SVR Model to the dataset 11 | library(e1071) 12 | regressor = svm(formula = Salary ~ ., 13 | data= dataset, 14 | type= 'eps-regression') 15 | 16 | # Predicting a new result 17 | y_pred = predict(regressor, data.frame(Level = 6.5)) 18 | 19 | # Visualising the SVR Model results 20 | # install.packages('ggplot2') 21 | library(ggplot2) 22 | ggplot() + 23 | geom_point(aes(x = dataset$Level, y = dataset$Salary), 24 | colour = 'red') + 25 | geom_line(aes(x = dataset$Level, y = predict(regressor, newdata = dataset)), 26 | colour = 'blue') + 27 | ggtitle('Truth or Bluff (SVR)') + 28 | xlab('Level') + 29 | ylab('Salary') -------------------------------------------------------------------------------- /Simple Linear Regression.R: -------------------------------------------------------------------------------- 1 | # Simple Linear Regression 2 | 3 | # Importing the dataset 4 | dataset = read.csv('Salary_Data.csv') 5 | 6 | # Splitting the dataset into the Training set and Test set 7 | library(caTools) 8 | set.seed(123) 9 | split = sample.split(dataset$Salary, SplitRatio = 2/3) 10 | training_set = subset(dataset, split == TRUE) 11 | test_set = subset(dataset, split == FALSE) 12 | 13 | # Fitting Simple Linear Regression to the Training Set (Part 2) 14 | 15 | regressor = lm(formula = Salary ~ YearsExperience, 16 | data=training_set) 17 | summary(regressor) 18 | 19 | 20 | # Predictiing the Test Set Results (Part 3) 21 | 22 | y_pred = predict(regressor, newdata = test_set) 23 | y_pred 24 | 25 | 26 | # Visualization (Part 4) 27 | 28 | library(ggplot2) 29 | 30 | ### Training Set 31 | ggplot() + 32 | geom_point(aes(x = training_set$YearsExperience, y = training_set$Salary), 33 | color = 'green') + 34 | geom_line(aes(x = training_set$YearsExperience, y = predict(regressor, newdata = training_set)), 35 | color = 'darkred') + 36 | ggtitle('Salary vs Experience (Training Set)') + 37 | xlab('Years of Experience') + 38 | ylab('Salary') 39 | 40 | # Visualising the Test set results 41 | 42 | ggplot() + 43 | geom_point(aes(x = test_set$YearsExperience, y = test_set$Salary), 44 | color = 'maroon') + 45 | geom_line(aes(x = training_set$YearsExperience, y = predict(regressor, newdata = training_set)), 46 | color = 'navy') + 47 | ggtitle('Salary vs Experience (Test Set)') + 48 | xlab('Years of Experience') + 49 | ylab('Salary') -------------------------------------------------------------------------------- /Social_Network_Ads.csv: -------------------------------------------------------------------------------- 1 | User ID,Gender,Age,EstimatedSalary,Purchased 2 | 15624510,Male,19,19000,0 3 | 15810944,Male,35,20000,0 4 | 15668575,Female,26,43000,0 5 | 15603246,Female,27,57000,0 6 | 15804002,Male,19,76000,0 7 | 15728773,Male,27,58000,0 8 | 15598044,Female,27,84000,0 9 | 15694829,Female,32,150000,1 10 | 15600575,Male,25,33000,0 11 | 15727311,Female,35,65000,0 12 | 15570769,Female,26,80000,0 13 | 15606274,Female,26,52000,0 14 | 15746139,Male,20,86000,0 15 | 15704987,Male,32,18000,0 16 | 15628972,Male,18,82000,0 17 | 15697686,Male,29,80000,0 18 | 15733883,Male,47,25000,1 19 | 15617482,Male,45,26000,1 20 | 15704583,Male,46,28000,1 21 | 15621083,Female,48,29000,1 22 | 15649487,Male,45,22000,1 23 | 15736760,Female,47,49000,1 24 | 15714658,Male,48,41000,1 25 | 15599081,Female,45,22000,1 26 | 15705113,Male,46,23000,1 27 | 15631159,Male,47,20000,1 28 | 15792818,Male,49,28000,1 29 | 15633531,Female,47,30000,1 30 | 15744529,Male,29,43000,0 31 | 15669656,Male,31,18000,0 32 | 15581198,Male,31,74000,0 33 | 15729054,Female,27,137000,1 34 | 15573452,Female,21,16000,0 35 | 15776733,Female,28,44000,0 36 | 15724858,Male,27,90000,0 37 | 15713144,Male,35,27000,0 38 | 15690188,Female,33,28000,0 39 | 15689425,Male,30,49000,0 40 | 15671766,Female,26,72000,0 41 | 15782806,Female,27,31000,0 42 | 15764419,Female,27,17000,0 43 | 15591915,Female,33,51000,0 44 | 15772798,Male,35,108000,0 45 | 15792008,Male,30,15000,0 46 | 15715541,Female,28,84000,0 47 | 15639277,Male,23,20000,0 48 | 15798850,Male,25,79000,0 49 | 15776348,Female,27,54000,0 50 | 15727696,Male,30,135000,1 51 | 15793813,Female,31,89000,0 52 | 15694395,Female,24,32000,0 53 | 15764195,Female,18,44000,0 54 | 15744919,Female,29,83000,0 55 | 15671655,Female,35,23000,0 56 | 15654901,Female,27,58000,0 57 | 15649136,Female,24,55000,0 58 | 15775562,Female,23,48000,0 59 | 15807481,Male,28,79000,0 60 | 15642885,Male,22,18000,0 61 | 15789109,Female,32,117000,0 62 | 15814004,Male,27,20000,0 63 | 15673619,Male,25,87000,0 64 | 15595135,Female,23,66000,0 65 | 15583681,Male,32,120000,1 66 | 15605000,Female,59,83000,0 67 | 15718071,Male,24,58000,0 68 | 15679760,Male,24,19000,0 69 | 15654574,Female,23,82000,0 70 | 15577178,Female,22,63000,0 71 | 15595324,Female,31,68000,0 72 | 15756932,Male,25,80000,0 73 | 15726358,Female,24,27000,0 74 | 15595228,Female,20,23000,0 75 | 15782530,Female,33,113000,0 76 | 15592877,Male,32,18000,0 77 | 15651983,Male,34,112000,1 78 | 15746737,Male,18,52000,0 79 | 15774179,Female,22,27000,0 80 | 15667265,Female,28,87000,0 81 | 15655123,Female,26,17000,0 82 | 15595917,Male,30,80000,0 83 | 15668385,Male,39,42000,0 84 | 15709476,Male,20,49000,0 85 | 15711218,Male,35,88000,0 86 | 15798659,Female,30,62000,0 87 | 15663939,Female,31,118000,1 88 | 15694946,Male,24,55000,0 89 | 15631912,Female,28,85000,0 90 | 15768816,Male,26,81000,0 91 | 15682268,Male,35,50000,0 92 | 15684801,Male,22,81000,0 93 | 15636428,Female,30,116000,0 94 | 15809823,Male,26,15000,0 95 | 15699284,Female,29,28000,0 96 | 15786993,Female,29,83000,0 97 | 15709441,Female,35,44000,0 98 | 15710257,Female,35,25000,0 99 | 15582492,Male,28,123000,1 100 | 15575694,Male,35,73000,0 101 | 15756820,Female,28,37000,0 102 | 15766289,Male,27,88000,0 103 | 15593014,Male,28,59000,0 104 | 15584545,Female,32,86000,0 105 | 15675949,Female,33,149000,1 106 | 15672091,Female,19,21000,0 107 | 15801658,Male,21,72000,0 108 | 15706185,Female,26,35000,0 109 | 15789863,Male,27,89000,0 110 | 15720943,Male,26,86000,0 111 | 15697997,Female,38,80000,0 112 | 15665416,Female,39,71000,0 113 | 15660200,Female,37,71000,0 114 | 15619653,Male,38,61000,0 115 | 15773447,Male,37,55000,0 116 | 15739160,Male,42,80000,0 117 | 15689237,Male,40,57000,0 118 | 15679297,Male,35,75000,0 119 | 15591433,Male,36,52000,0 120 | 15642725,Male,40,59000,0 121 | 15701962,Male,41,59000,0 122 | 15811613,Female,36,75000,0 123 | 15741049,Male,37,72000,0 124 | 15724423,Female,40,75000,0 125 | 15574305,Male,35,53000,0 126 | 15678168,Female,41,51000,0 127 | 15697020,Female,39,61000,0 128 | 15610801,Male,42,65000,0 129 | 15745232,Male,26,32000,0 130 | 15722758,Male,30,17000,0 131 | 15792102,Female,26,84000,0 132 | 15675185,Male,31,58000,0 133 | 15801247,Male,33,31000,0 134 | 15725660,Male,30,87000,0 135 | 15638963,Female,21,68000,0 136 | 15800061,Female,28,55000,0 137 | 15578006,Male,23,63000,0 138 | 15668504,Female,20,82000,0 139 | 15687491,Male,30,107000,1 140 | 15610403,Female,28,59000,0 141 | 15741094,Male,19,25000,0 142 | 15807909,Male,19,85000,0 143 | 15666141,Female,18,68000,0 144 | 15617134,Male,35,59000,0 145 | 15783029,Male,30,89000,0 146 | 15622833,Female,34,25000,0 147 | 15746422,Female,24,89000,0 148 | 15750839,Female,27,96000,1 149 | 15749130,Female,41,30000,0 150 | 15779862,Male,29,61000,0 151 | 15767871,Male,20,74000,0 152 | 15679651,Female,26,15000,0 153 | 15576219,Male,41,45000,0 154 | 15699247,Male,31,76000,0 155 | 15619087,Female,36,50000,0 156 | 15605327,Male,40,47000,0 157 | 15610140,Female,31,15000,0 158 | 15791174,Male,46,59000,0 159 | 15602373,Male,29,75000,0 160 | 15762605,Male,26,30000,0 161 | 15598840,Female,32,135000,1 162 | 15744279,Male,32,100000,1 163 | 15670619,Male,25,90000,0 164 | 15599533,Female,37,33000,0 165 | 15757837,Male,35,38000,0 166 | 15697574,Female,33,69000,0 167 | 15578738,Female,18,86000,0 168 | 15762228,Female,22,55000,0 169 | 15614827,Female,35,71000,0 170 | 15789815,Male,29,148000,1 171 | 15579781,Female,29,47000,0 172 | 15587013,Male,21,88000,0 173 | 15570932,Male,34,115000,0 174 | 15794661,Female,26,118000,0 175 | 15581654,Female,34,43000,0 176 | 15644296,Female,34,72000,0 177 | 15614420,Female,23,28000,0 178 | 15609653,Female,35,47000,0 179 | 15594577,Male,25,22000,0 180 | 15584114,Male,24,23000,0 181 | 15673367,Female,31,34000,0 182 | 15685576,Male,26,16000,0 183 | 15774727,Female,31,71000,0 184 | 15694288,Female,32,117000,1 185 | 15603319,Male,33,43000,0 186 | 15759066,Female,33,60000,0 187 | 15814816,Male,31,66000,0 188 | 15724402,Female,20,82000,0 189 | 15571059,Female,33,41000,0 190 | 15674206,Male,35,72000,0 191 | 15715160,Male,28,32000,0 192 | 15730448,Male,24,84000,0 193 | 15662067,Female,19,26000,0 194 | 15779581,Male,29,43000,0 195 | 15662901,Male,19,70000,0 196 | 15689751,Male,28,89000,0 197 | 15667742,Male,34,43000,0 198 | 15738448,Female,30,79000,0 199 | 15680243,Female,20,36000,0 200 | 15745083,Male,26,80000,0 201 | 15708228,Male,35,22000,0 202 | 15628523,Male,35,39000,0 203 | 15708196,Male,49,74000,0 204 | 15735549,Female,39,134000,1 205 | 15809347,Female,41,71000,0 206 | 15660866,Female,58,101000,1 207 | 15766609,Female,47,47000,0 208 | 15654230,Female,55,130000,1 209 | 15794566,Female,52,114000,0 210 | 15800890,Female,40,142000,1 211 | 15697424,Female,46,22000,0 212 | 15724536,Female,48,96000,1 213 | 15735878,Male,52,150000,1 214 | 15707596,Female,59,42000,0 215 | 15657163,Male,35,58000.0,0 216 | 15622478,Male,47.0,43000,0 217 | 15779529,Female,60,108000,1 218 | 15636023,Male,49,65000,0 219 | 15582066,Male,40,78000,0 220 | 15666675,Female,46,96000,0 221 | 15732987,Male,59,143000,1 222 | 15789432,Female,41,80000,0 223 | 15663161,Male,35,91000,1 224 | 15694879,Male,37,144000,1 225 | 15593715,Male,60,102000,1 226 | 15575002,Female,35,60000,0 227 | 15622171,Male,37,53000,0 228 | 15795224,Female,36,126000,1 229 | 15685346,Male,56,133000,1 230 | 15691808,Female,40,72000,0 231 | 15721007,Female,42,80000,1 232 | 15794253,Female,35,147000,1 233 | 15694453,Male,39,42000,0 234 | 15813113,Male,40,107000,1 235 | 15614187,Male,49,86000,1 236 | 15619407,Female,38,112000,0 237 | 15646227,Male,46,79000,1 238 | 15660541,Male,40,57000,0 239 | 15753874,Female,37,80000,0 240 | 15617877,Female,46,82000,0 241 | 15772073,Female,53,143000,1 242 | 15701537,Male,42,149000,1 243 | 15736228,Male,38,59000,0 244 | 15780572,Female,50,88000,1 245 | 15769596,Female,56,104000,1 246 | 15586996,Female,41,72000,0 247 | 15722061,Female,51,146000,1 248 | 15638003,Female,35,50000,0 249 | 15775590,Female,57,122000,1 250 | 15730688,Male,41,52000,0 251 | 15753102,Female,35,97000,1 252 | 15810075,Female,44,39000,0 253 | 15723373,Male,37,52000,0 254 | 15795298,Female,48,134000,1 255 | 15584320,Female,37,146000,1 256 | 15724161,Female,50,44000,0 257 | 15750056,Female,52,90000,1 258 | 15609637,Female,41,72000,0 259 | 15794493,Male,40,57000,0 260 | 15569641,Female,58,95000,1 261 | 15815236,Female,45,131000,1 262 | 15811177,Female,35,77000,0 263 | 15680587,Male,36,144000,1 264 | 15672821,Female,55,125000,1 265 | 15767681,Female,35,72000,0 266 | 15600379,Male,48,90000,1 267 | 15801336,Female,42,108000,1 268 | 15721592,Male,40,75000,0 269 | 15581282,Male,37,74000,0 270 | 15746203,Female,47,144000,1 271 | 15583137,Male,40,61000,0 272 | 15680752,Female,43,133000,0 273 | 15688172,Female,59,76000,1 274 | 15791373,Male,60,42000,1 275 | 15589449,Male,39,106000,1 276 | 15692819,Female,57,26000,1 277 | 15727467,Male,57,74000,1 278 | 15734312,Male,38,71000,0 279 | 15764604,Male,49,88000,1 280 | 15613014,Female,52,38000,1 281 | 15759684,Female,50,36000,1 282 | 15609669,Female,59,88000,1 283 | 15685536,Male,35,61000,0 284 | 15750447,Male,37,70000,1 285 | 15663249,Female,52,21000,1 286 | 15638646,Male,48,141000,0 287 | 15734161,Female,37,93000,1 288 | 15631070,Female,37,62000,0 289 | 15761950,Female,48,138000,1 290 | 15649668,Male,41,79000,0 291 | 15713912,Female,37,78000,1 292 | 15586757,Male,39,134000,1 293 | 15596522,Male,49,89000,1 294 | 15625395,Male,55,39000,1 295 | 15760570,Male,37,77000,0 296 | 15566689,Female,35,57000,0 297 | 15725794,Female,36,63000,0 298 | 15673539,Male,42,73000,1 299 | 15705298,Female,43,112000,1 300 | 15675791,Male,45,79000,0 301 | 15747043,Male,46,117000,1 302 | 15736397,Female,58,38000,1 303 | 15678201,Male,48,74000,1 304 | 15720745,Female,37,137000,1 305 | 15637593,Male,37,79000,1 306 | 15598070,Female,40,60000,0 307 | 15787550,Male,42,54000,0 308 | 15603942,Female,51,134000,0 309 | 15733973,Female,47,113000,1 310 | 15596761,Male,36,125000,1 311 | 15652400,Female,38,50000,0 312 | 15717893,Female,42,70000,0 313 | 15622585,Male,39,96000,1 314 | 15733964,Female,38,50000,0 315 | 15753861,Female,49,141000,1 316 | 15747097,Female,39,79000,0 317 | 15594762,Female,39,75000,1 318 | 15667417,Female,54,104000,1 319 | 15684861,Male,35,55000,0 320 | 15742204,Male,45,32000,1 321 | 15623502,Male,36,60000,0 322 | 15774872,Female,52,138000,1 323 | 15611191,Female,53,82000,1 324 | 15674331,Male,41,52000,0 325 | 15619465,Female,48,30000,1 326 | 15575247,Female,48,131000,1 327 | 15695679,Female,41,60000,0 328 | 15713463,Male,41,72000,0 329 | 15785170,Female,42,75000,0 330 | 15796351,Male,36,118000,1 331 | 15639576,Female,47,107000,1 332 | 15693264,Male,38,51000,0 333 | 15589715,Female,48,119000,1 334 | 15769902,Male,42,65000,0 335 | 15587177,Male,40,65000,0 336 | 15814553,Male,57,60000,1 337 | 15601550,Female,36,54000,0 338 | 15664907,Male,58,144000,1 339 | 15612465,Male,35,79000,0 340 | 15810800,Female,38,55000,0 341 | 15665760,Male,39,122000,1 342 | 15588080,Female,53,104000,1 343 | 15776844,Male,35,75000,0 344 | 15717560,Female,38,65000,0 345 | 15629739,Female,47,51000,1 346 | 15729908,Male,47,105000,1 347 | 15716781,Female,41,63000,0 348 | 15646936,Male,53,72000,1 349 | 15768151,Female,54,108000,1 350 | 15579212,Male,39,77000,0 351 | 15721835,Male,38,61000,0 352 | 15800515,Female,38,113000,1 353 | 15591279,Male,37,75000,0 354 | 15587419,Female,42,90000,1 355 | 15750335,Female,37,57000,0 356 | 15699619,Male,36,99000,1 357 | 15606472,Male,60,34000,1 358 | 15778368,Male,54,70000,1 359 | 15671387,Female,41,72000,0 360 | 15573926,Male,40,71000,1 361 | 15709183,Male,42,54000,0 362 | 15577514,Male,43,129000,1 363 | 15778830,Female,53,34000,1 364 | 15768072,Female,47,50000,1 365 | 15768293,Female,42,79000,0 366 | 15654456,Male,42,104000,1 367 | 15807525,Female,59,29000,1 368 | 15574372,Female,58,47000,1 369 | 15671249,Male,46,88000,1 370 | 15779744,Male,38,71000,0 371 | 15624755,Female,54,26000,1 372 | 15611430,Female,60,46000,1 373 | 15774744,Male,60,83000,1 374 | 15629885,Female,39,73000,0 375 | 15708791,Male,59,130000,1 376 | 15793890,Female,37,80000,0 377 | 15646091,Female,46,32000,1 378 | 15596984,Female,46,74000,0 379 | 15800215,Female,42,53000,0 380 | 15577806,Male,41,87000,1 381 | 15749381,Female,58,23000,1 382 | 15683758,Male,42,64000,0 383 | 15670615,Male,48,33000,1 384 | 15715622,Female,44,139000,1 385 | 15707634,Male,49,28000,1 386 | 15806901,Female,57,33000,1 387 | 15775335,Male,56,60000,1 388 | 15724150,Female,49,39000,1 389 | 15627220,Male,39,71000,0 390 | 15672330,Male,47,34000,1 391 | 15668521,Female,48,35000,1 392 | 15807837,Male,48,33000,1 393 | 15592570,Male,47,23000,1 394 | 15748589,Female,45,45000,1 395 | 15635893,Male,60,42000,1 396 | 15757632,Female,39,59000,0 397 | 15691863,Female,46,41000,1 398 | 15706071,Male,51,23000,1 399 | 15654296,Female,50,20000,1 400 | 15755018,Male,36,33000,0 401 | 15594041,Female,49,36000,1 -------------------------------------------------------------------------------- /Support Vector Regression Lecture.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Loading the Libraries" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 52, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "import numpy as np" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": 53, 24 | "metadata": { 25 | "collapsed": true 26 | }, 27 | "outputs": [], 28 | "source": [ 29 | "import pandas as pd" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 54, 35 | "metadata": { 36 | "collapsed": true 37 | }, 38 | "outputs": [], 39 | "source": [ 40 | "import matplotlib.pyplot as plt" 41 | ] 42 | }, 43 | { 44 | "cell_type": "code", 45 | "execution_count": 55, 46 | "metadata": { 47 | "collapsed": true 48 | }, 49 | "outputs": [], 50 | "source": [ 51 | "%matplotlib inline" 52 | ] 53 | }, 54 | { 55 | "cell_type": "markdown", 56 | "metadata": {}, 57 | "source": [ 58 | "# Reading the Data" 59 | ] 60 | }, 61 | { 62 | "cell_type": "code", 63 | "execution_count": 56, 64 | "metadata": { 65 | "collapsed": true 66 | }, 67 | "outputs": [], 68 | "source": [ 69 | "dataset = pd.read_csv('Position_Salaries.csv')" 70 | ] 71 | }, 72 | { 73 | "cell_type": "code", 74 | "execution_count": 57, 75 | "metadata": { 76 | "collapsed": true 77 | }, 78 | "outputs": [], 79 | "source": [ 80 | "X = dataset.iloc[:, 1:2].values" 81 | ] 82 | }, 83 | { 84 | "cell_type": "code", 85 | "execution_count": 58, 86 | "metadata": { 87 | "collapsed": true 88 | }, 89 | "outputs": [], 90 | "source": [ 91 | "y = dataset.iloc[:, 2].values" 92 | ] 93 | }, 94 | { 95 | "cell_type": "markdown", 96 | "metadata": {}, 97 | "source": [ 98 | "# Feature Scaling" 99 | ] 100 | }, 101 | { 102 | "cell_type": "code", 103 | "execution_count": 59, 104 | "metadata": { 105 | "collapsed": true 106 | }, 107 | "outputs": [], 108 | "source": [ 109 | "from sklearn.preprocessing import StandardScaler" 110 | ] 111 | }, 112 | { 113 | "cell_type": "code", 114 | "execution_count": 60, 115 | "metadata": { 116 | "collapsed": true 117 | }, 118 | "outputs": [], 119 | "source": [ 120 | "sc_X = StandardScaler()" 121 | ] 122 | }, 123 | { 124 | "cell_type": "code", 125 | "execution_count": 61, 126 | "metadata": { 127 | "collapsed": true 128 | }, 129 | "outputs": [], 130 | "source": [ 131 | "sc_y = StandardScaler()" 132 | ] 133 | }, 134 | { 135 | "cell_type": "code", 136 | "execution_count": 62, 137 | "metadata": { 138 | "collapsed": false 139 | }, 140 | "outputs": [ 141 | { 142 | "name": "stderr", 143 | "output_type": "stream", 144 | "text": [ 145 | "C:\\Users\\atse\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:429: DataConversionWarning: Data with input dtype int64 was converted to float64 by StandardScaler.\n", 146 | " warnings.warn(msg, _DataConversionWarning)\n" 147 | ] 148 | } 149 | ], 150 | "source": [ 151 | "X = sc_X.fit_transform(X)" 152 | ] 153 | }, 154 | { 155 | "cell_type": "code", 156 | "execution_count": 63, 157 | "metadata": { 158 | "collapsed": false 159 | }, 160 | "outputs": [ 161 | { 162 | "name": "stderr", 163 | "output_type": "stream", 164 | "text": [ 165 | "C:\\Users\\atse\\Anaconda3\\lib\\site-packages\\sklearn\\utils\\validation.py:429: DataConversionWarning: Data with input dtype int64 was converted to float64 by StandardScaler.\n", 166 | " warnings.warn(msg, _DataConversionWarning)\n", 167 | "C:\\Users\\atse\\Anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\data.py:586: DeprecationWarning: Passing 1d arrays as data is deprecated in 0.17 and will raise ValueError in 0.19. Reshape your data either using X.reshape(-1, 1) if your data has a single feature or X.reshape(1, -1) if it contains a single sample.\n", 168 | " warnings.warn(DEPRECATION_MSG_1D, DeprecationWarning)\n", 169 | "C:\\Users\\atse\\Anaconda3\\lib\\site-packages\\sklearn\\preprocessing\\data.py:649: DeprecationWarning: Passing 1d arrays as data is deprecated in 0.17 and will raise ValueError in 0.19. Reshape your data either using X.reshape(-1, 1) if your data has a single feature or X.reshape(1, -1) if it contains a single sample.\n", 170 | " warnings.warn(DEPRECATION_MSG_1D, DeprecationWarning)\n" 171 | ] 172 | } 173 | ], 174 | "source": [ 175 | "y = sc_y.fit_transform(y)" 176 | ] 177 | }, 178 | { 179 | "cell_type": "markdown", 180 | "metadata": {}, 181 | "source": [ 182 | "# Fitting SVR to the Dataset" 183 | ] 184 | }, 185 | { 186 | "cell_type": "code", 187 | "execution_count": 64, 188 | "metadata": { 189 | "collapsed": false 190 | }, 191 | "outputs": [], 192 | "source": [ 193 | "from sklearn.svm import SVR" 194 | ] 195 | }, 196 | { 197 | "cell_type": "code", 198 | "execution_count": 65, 199 | "metadata": { 200 | "collapsed": true 201 | }, 202 | "outputs": [], 203 | "source": [ 204 | "regressor = SVR(kernel = 'rbf')" 205 | ] 206 | }, 207 | { 208 | "cell_type": "code", 209 | "execution_count": 66, 210 | "metadata": { 211 | "collapsed": false 212 | }, 213 | "outputs": [ 214 | { 215 | "data": { 216 | "text/plain": [ 217 | "SVR(C=1.0, cache_size=200, coef0=0.0, degree=3, epsilon=0.1, gamma='auto',\n", 218 | " kernel='rbf', max_iter=-1, shrinking=True, tol=0.001, verbose=False)" 219 | ] 220 | }, 221 | "execution_count": 66, 222 | "metadata": {}, 223 | "output_type": "execute_result" 224 | } 225 | ], 226 | "source": [ 227 | "regressor.fit(X, y)" 228 | ] 229 | }, 230 | { 231 | "cell_type": "markdown", 232 | "metadata": {}, 233 | "source": [ 234 | "# Predicting a New Result" 235 | ] 236 | }, 237 | { 238 | "cell_type": "code", 239 | "execution_count": 67, 240 | "metadata": { 241 | "collapsed": true 242 | }, 243 | "outputs": [], 244 | "source": [ 245 | "y_pred = sc_y.inverse_transform(regressor.predict(sc_X.transform(np.array([[6.5]]))))" 246 | ] 247 | }, 248 | { 249 | "cell_type": "code", 250 | "execution_count": 68, 251 | "metadata": { 252 | "collapsed": false 253 | }, 254 | "outputs": [ 255 | { 256 | "data": { 257 | "text/plain": [ 258 | "array([ 170370.0204065])" 259 | ] 260 | }, 261 | "execution_count": 68, 262 | "metadata": {}, 263 | "output_type": "execute_result" 264 | } 265 | ], 266 | "source": [ 267 | "y_pred" 268 | ] 269 | }, 270 | { 271 | "cell_type": "markdown", 272 | "metadata": {}, 273 | "source": [ 274 | "# Visualizing the SVR Results" 275 | ] 276 | }, 277 | { 278 | "cell_type": "code", 279 | "execution_count": 69, 280 | "metadata": { 281 | "collapsed": false 282 | }, 283 | "outputs": [ 284 | { 285 | "data": { 286 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAZAAAAEZCAYAAAC5AHPcAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nhIJAEWXLAAAAAElFTkSuQmCC\n", 287 | "text/plain": [ 288 | "" 289 | ] 290 | }, 291 | "metadata": {}, 292 | "output_type": "display_data" 293 | } 294 | ], 295 | "source": [ 296 | "plt.scatter(X, y, color = 'red')\n", 297 | "plt.plot(X, regressor.predict(X), color = 'blue')\n", 298 | "plt.title('Truth or Bluff (SVR)')\n", 299 | "plt.xlabel('Position level')\n", 300 | "plt.ylabel('Salary')\n", 301 | "plt.show()" 302 | ] 303 | }, 304 | { 305 | "cell_type": "code", 306 | "execution_count": null, 307 | "metadata": { 308 | "collapsed": true 309 | }, 310 | "outputs": [], 311 | "source": [] 312 | }, 313 | { 314 | "cell_type": "code", 315 | "execution_count": null, 316 | "metadata": { 317 | "collapsed": true 318 | }, 319 | "outputs": [], 320 | "source": [] 321 | }, 322 | { 323 | "cell_type": "code", 324 | "execution_count": null, 325 | "metadata": { 326 | "collapsed": true 327 | }, 328 | "outputs": [], 329 | "source": [] 330 | }, 331 | { 332 | "cell_type": "code", 333 | "execution_count": null, 334 | "metadata": { 335 | "collapsed": true 336 | }, 337 | "outputs": [], 338 | "source": [] 339 | } 340 | ], 341 | "metadata": { 342 | "anaconda-cloud": {}, 343 | "kernelspec": { 344 | "display_name": "Python [Root]", 345 | "language": "python", 346 | "name": "Python [Root]" 347 | }, 348 | "language_info": { 349 | "codemirror_mode": { 350 | "name": "ipython", 351 | "version": 3 352 | }, 353 | "file_extension": ".py", 354 | "mimetype": "text/x-python", 355 | "name": "python", 356 | "nbconvert_exporter": "python", 357 | "pygments_lexer": "ipython3", 358 | "version": "3.5.2" 359 | } 360 | }, 361 | "nbformat": 4, 362 | "nbformat_minor": 0 363 | } 364 | -------------------------------------------------------------------------------- /Thompson Sampling Lecture.ipynb: -------------------------------------------------------------------------------- 1 | { 2 | "cells": [ 3 | { 4 | "cell_type": "markdown", 5 | "metadata": {}, 6 | "source": [ 7 | "# Importing the Libraries" 8 | ] 9 | }, 10 | { 11 | "cell_type": "code", 12 | "execution_count": 6, 13 | "metadata": { 14 | "collapsed": true 15 | }, 16 | "outputs": [], 17 | "source": [ 18 | "import numpy as np" 19 | ] 20 | }, 21 | { 22 | "cell_type": "code", 23 | "execution_count": 7, 24 | "metadata": { 25 | "collapsed": true 26 | }, 27 | "outputs": [], 28 | "source": [ 29 | "import pandas as pd" 30 | ] 31 | }, 32 | { 33 | "cell_type": "code", 34 | "execution_count": 8, 35 | "metadata": { 36 | "collapsed": true 37 | }, 38 | "outputs": [], 39 | "source": [ 40 | "import matplotlib.pyplot as plt\n", 41 | "%matplotlib inline" 42 | ] 43 | }, 44 | { 45 | "cell_type": "code", 46 | "execution_count": 9, 47 | "metadata": { 48 | "collapsed": true 49 | }, 50 | "outputs": [], 51 | "source": [ 52 | "import random\n", 53 | "import math" 54 | ] 55 | }, 56 | { 57 | "cell_type": "markdown", 58 | "metadata": {}, 59 | "source": [ 60 | "# Importing the Dataset" 61 | ] 62 | }, 63 | { 64 | "cell_type": "code", 65 | "execution_count": 10, 66 | "metadata": { 67 | "collapsed": true 68 | }, 69 | "outputs": [], 70 | "source": [ 71 | "dataset = pd.read_csv('Ads_CTR_Optimisation.csv')" 72 | ] 73 | }, 74 | { 75 | "cell_type": "markdown", 76 | "metadata": {}, 77 | "source": [ 78 | "# Random Sampling" 79 | ] 80 | }, 81 | { 82 | "cell_type": "code", 83 | "execution_count": 11, 84 | "metadata": { 85 | "collapsed": true 86 | }, 87 | "outputs": [], 88 | "source": [ 89 | "N = 10000\n", 90 | "d = 10\n", 91 | "ads_selected = []\n", 92 | "total_reward = 0\n", 93 | "for n in range(0, N):\n", 94 | " ad = random.randrange(d)\n", 95 | " ads_selected.append(ad)\n", 96 | " reward = dataset.values[n, ad]\n", 97 | " total_reward = total_reward + reward" 98 | ] 99 | }, 100 | { 101 | "cell_type": "markdown", 102 | "metadata": {}, 103 | "source": [ 104 | "# Random Sampling Visualizing the Results" 105 | ] 106 | }, 107 | { 108 | "cell_type": "code", 109 | "execution_count": 12, 110 | "metadata": {}, 111 | "outputs": [ 112 | { 113 | "data": { 114 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEWCAYAAACe8xtsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\nRK5CYII=\n", 115 | "text/plain": [ 116 | "" 117 | ] 118 | }, 119 | "metadata": {}, 120 | "output_type": "display_data" 121 | } 122 | ], 123 | "source": [ 124 | "plt.hist(ads_selected, color='red')\n", 125 | "plt.title('Histogram of Ads Selections')\n", 126 | "plt.xlabel('Ads')\n", 127 | "plt.ylabel('Number of Times Each Ad was Selected')\n", 128 | "plt.show()" 129 | ] 130 | }, 131 | { 132 | "cell_type": "markdown", 133 | "metadata": {}, 134 | "source": [ 135 | "# Implementing Thompson Sampling" 136 | ] 137 | }, 138 | { 139 | "cell_type": "code", 140 | "execution_count": 13, 141 | "metadata": { 142 | "collapsed": true 143 | }, 144 | "outputs": [], 145 | "source": [ 146 | "N = 10000\n", 147 | "d = 10\n", 148 | "ads_selected = []\n", 149 | "numbers_of_rewards_1 = [0] * d\n", 150 | "numbers_of_rewards_0 = [0] * d\n", 151 | "total_reward = 0\n", 152 | "for n in range(0, N):\n", 153 | " ad = 0\n", 154 | " max_random = 0\n", 155 | " for i in range(0, d):\n", 156 | " random_beta = random.betavariate(numbers_of_rewards_1[i] + 1, numbers_of_rewards_0[i] + 1)\n", 157 | " if random_beta > max_random:\n", 158 | " max_random = random_beta\n", 159 | " ad = i\n", 160 | " ads_selected.append(ad)\n", 161 | " reward = dataset.values[n, ad]\n", 162 | " if reward == 1:\n", 163 | " numbers_of_rewards_1[ad] = numbers_of_rewards_1[ad] + 1\n", 164 | " else:\n", 165 | " numbers_of_rewards_0[ad] = numbers_of_rewards_0[ad] + 1\n", 166 | " total_reward = total_reward + reward" 167 | ] 168 | }, 169 | { 170 | "cell_type": "markdown", 171 | "metadata": {}, 172 | "source": [ 173 | "# Visualizing the Results (Part 2)" 174 | ] 175 | }, 176 | { 177 | "cell_type": "code", 178 | "execution_count": 17, 179 | "metadata": {}, 180 | "outputs": [ 181 | { 182 | "data": { 183 | "image/png": "iVBORw0KGgoAAAANSUhEUgAAAY8AAAEWCAYAAACe8xtsAAAABHNCSVQICAgIfAhkiAAAAAlwSFlz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\n8oiIiI79f6siRUjQya0nAAAAAElFTkSuQmCC\n", 184 | "text/plain": [ 185 | "" 186 | ] 187 | }, 188 | "metadata": {}, 189 | "output_type": "display_data" 190 | } 191 | ], 192 | "source": [ 193 | "plt.hist(ads_selected, color='black')\n", 194 | "plt.title('Histogram of Ads Selections')\n", 195 | "plt.xlabel('Ads')\n", 196 | "plt.ylabel('Number of Times Each Ad was Selected')\n", 197 | "plt.show()" 198 | ] 199 | }, 200 | { 201 | "cell_type": "code", 202 | "execution_count": null, 203 | "metadata": { 204 | "collapsed": true 205 | }, 206 | "outputs": [], 207 | "source": [] 208 | } 209 | ], 210 | "metadata": { 211 | "kernelspec": { 212 | "display_name": "Python [conda root]", 213 | "language": "python", 214 | "name": "conda-root-py" 215 | }, 216 | "language_info": { 217 | "codemirror_mode": { 218 | "name": "ipython", 219 | "version": 3 220 | }, 221 | "file_extension": ".py", 222 | "mimetype": "text/x-python", 223 | "name": "python", 224 | "nbconvert_exporter": "python", 225 | "pygments_lexer": "ipython3", 226 | "version": "3.5.3" 227 | } 228 | }, 229 | "nbformat": 4, 230 | "nbformat_minor": 2 231 | } 232 | -------------------------------------------------------------------------------- /UCB.R: -------------------------------------------------------------------------------- 1 | # Reinforcement Learning 2 | 3 | ### Part 1 4 | 5 | ## Setting the Working Directory 6 | 7 | setwd('./Machine Learning A-Z/Part 6 - Reinforcement Learning/Section 32 - Upper Confidence Bound (UCB)') 8 | 9 | ## Import the Dataset 10 | 11 | dataset = read.csv('./Ads_CTR_Optimisation.csv') 12 | View(dataset) 13 | 14 | ## Implementing Random Selection 15 | N = 10000 16 | d = 10 17 | ads_selected = integer(0) 18 | total_reward = 0 19 | for (n in 1:N) { 20 | ad = sample(1:10, 1) 21 | ads_selected = append(ads_selected, ad) 22 | reward = dataset[n, ad] 23 | total_reward = total_reward + reward 24 | } 25 | total_reward 26 | 27 | ## Visualizing the Results - Histogram 28 | 29 | hist(ads_selected, col='blue', main='Histogram of Ads Selection', 30 | xlab='Ads', ylab='Number of Times Each Ad Was Selected') 31 | 32 | ### Part 2 33 | #### Implementing Upper Confidence Bound 34 | 35 | N = 10000 36 | d = 10 37 | ads_selected = integer() 38 | numbers_of_selections = integer(d) 39 | sums_of_rewards = integer(d) 40 | total_reward = 0 41 | #### For Loop in UCB 42 | 43 | for (n in 1:N){ 44 | ad = 0 45 | max_upper_bound = 0 46 | for (i in 1:d){ 47 | if (numbers_of_selections[i] > 0){ 48 | average_reward = sums_of_rewards[i]/numbers_of_selections[i] 49 | delta_i = sqrt(3/2 * log(n)/numbers_of_selections[i]) 50 | upper_bound = average_reward + delta_i 51 | }else { 52 | upper_bound = 1e400 53 | } 54 | if (upper_bound > max_upper_bound){ 55 | max_upper_bound = upper_bound 56 | ad = i 57 | } 58 | } 59 | ### Part 3 60 | 61 | ads_selected = append(ads_selected, ad) 62 | numbers_of_selections[ad] = numbers_of_selections[ad] + 1 63 | reward = dataset[n, ad] 64 | sums_of_rewards[ad] = sums_of_rewards[ad] + reward 65 | total_reward = total_reward + reward 66 | } 67 | ads_selected 68 | total_reward 69 | 70 | ### Part 4 71 | 72 | #### Visualizing the Results - Histogram 73 | 74 | hist(ads_selected, col = 'red', main = 'Histogram of Ads Selections', 75 | xlab = 'Ads', ylab = 'Number of Times Each Ad was Selected') 76 | -------------------------------------------------------------------------------- /apriori.R: -------------------------------------------------------------------------------- 1 | # Apriori 2 | 3 | ### Part 1 4 | 5 | ## Change Working Directory 6 | 7 | setwd('./Machine Learning A-Z/Part 5 - Association Rule Learning/Section 28 - Apriori') 8 | 9 | 10 | # Data Preprocessing 11 | 12 | ### Loading the Arules Package 13 | 14 | library(arules) 15 | dataset = read.csv('Market_Basket_Optimisation.csv', header = FALSE) 16 | dataset = read.transactions('Market_Basket_Optimisation.csv', sep = ',', rm.duplicates = TRUE) 17 | summary(dataset) 18 | itemFrequencyPlot(dataset, topN = 100) 19 | itemFrequencyPlot(dataset, topN = 10) 20 | 3*7/7500 21 | 22 | ## Part 2 23 | 24 | ### Training Apriori on the dataset 25 | rules = apriori(data = dataset, parameter = list(support = 0.003, confidence = 0.4)) 26 | 27 | 28 | ## Part 3 29 | 30 | ### Visualising the results 31 | inspect(sort(rules, by = 'lift')[1:10]) 32 | 33 | 34 | 35 | -------------------------------------------------------------------------------- /categorical_data.R: -------------------------------------------------------------------------------- 1 | # Data Preprocessing 2 | 3 | # Importing the dataset 4 | dataset = read.csv('Data.csv') 5 | 6 | # Taking care of missing data 7 | dataset$Age = ifelse(is.na(dataset$Age), 8 | ave(dataset$Age, FUN = function(x) mean(x, na.rm = TRUE)), 9 | dataset$Age) 10 | dataset$Salary = ifelse(is.na(dataset$Salary), 11 | ave(dataset$Salary, FUN = function(x) mean(x, na.rm = TRUE)), 12 | dataset$Salary) 13 | 14 | # Encoding categorical data 15 | dataset$Country = factor(dataset$Country, 16 | levels = c('France', 'Spain', 'Germany'), 17 | labels = c(1, 2, 3)) 18 | dataset$Purchased = factor(dataset$Purchased, 19 | levels = c('No', 'Yes'), 20 | labels = c(0, 1)) 21 | dataset -------------------------------------------------------------------------------- /eclat.R: -------------------------------------------------------------------------------- 1 | # Eclat 2 | 3 | ## Setting the Working Directory 4 | 5 | setwd('./Machine Learning A-Z/Part 5 - Association Rule Learning/Section 29 - Eclat') 6 | 7 | 8 | # Data Preprocessing 9 | # install.packages('arules') 10 | library(arules) 11 | dataset = read.csv('Market_Basket_Optimisation.csv') 12 | dataset = read.transactions('Market_Basket_Optimisation.csv', sep = ',', rm.duplicates = TRUE) 13 | summary(dataset) 14 | itemFrequencyPlot(dataset, topN = 10) 15 | 16 | # Training Eclat on the dataset 17 | rules = eclat(data = dataset, parameter = list(support = 0.003, minlen = 2)) 18 | 19 | # Visualising the results 20 | inspect(sort(rules, by = 'support')[1:10]) -------------------------------------------------------------------------------- /missing_data.R: -------------------------------------------------------------------------------- 1 | # Data Preprocessing 2 | 3 | # Importing the dataset 4 | dataset = read.csv('Data.csv') 5 | 6 | # Taking care of missing data 7 | dataset$Age = ifelse(is.na(dataset$Age), 8 | ave(dataset$Age, FUN = function(x) mean(x, na.rm = TRUE)), 9 | dataset$Age) 10 | dataset$Salary = ifelse(is.na(dataset$Salary), 11 | ave(dataset$Salary, FUN = function(x) mean(x, na.rm = TRUE)), 12 | dataset$Salary) 13 | 14 | # Running the Data 15 | 16 | dataset 17 | 18 | -------------------------------------------------------------------------------- /natural_language_processing.R: -------------------------------------------------------------------------------- 1 | # Natural Language Processing 2 | 3 | ## Part 1 4 | 5 | # Setting the Working Directory 6 | setwd('./Machine Learning A-Z/Part 7 - Natural Language Processing/Section 37 - Natural Language Processing Algorithms') 7 | 8 | # Importing the dataset 9 | dataset_original = read.delim('Restaurant_Reviews.tsv', quote = '', stringsAsFactors = FALSE) 10 | 11 | ## Part 2 12 | 13 | # Cleaning the texts 14 | # install.packages('tm') 15 | # install.packages('SnowballC') 16 | library(tm) 17 | library(SnowballC) 18 | corpus = VCorpus(VectorSource(dataset_original$Review)) 19 | 20 | ## Part 3 21 | corpus = tm_map(corpus, content_transformer(tolower)) 22 | as.character(corpus[[1]]) 23 | ## Part 4 24 | corpus = tm_map(corpus, removeNumbers) 25 | as.character(corpus[[841]]) 26 | 27 | ## Part 5 28 | corpus = tm_map(corpus, removePunctuation) 29 | as.character(corpus[[1]]) 30 | 31 | ## Part 6 32 | corpus = tm_map(corpus, removeWords, stopwords()) 33 | as.character(corpus[[1]]) 34 | 35 | ## Part 7 36 | corpus = tm_map(corpus, stemDocument) 37 | as.character(corpus[[1]]) 38 | 39 | ## Part 8 40 | corpus = tm_map(corpus, stripWhitespace) 41 | as.character(corpus[[841]]) 42 | as.character(corpus[[1]]) 43 | 44 | ## Part 9 45 | 46 | # Creating the Bag of Words model 47 | dtm = DocumentTermMatrix(corpus) 48 | dtm = removeSparseTerms(dtm, 0.999) 49 | 50 | ## Part 10 51 | 52 | # Importing the dataset 53 | dataset = read.csv('Social_Network_Ads.csv') 54 | dataset = dataset[3:5] 55 | 56 | dataset = as.data.frame(as.matrix(dtm)) 57 | dataset$Liked = dataset_original$Liked 58 | 59 | # Encoding the target feature as factor 60 | dataset$Liked = factor(dataset$Liked, levels = c(0, 1)) 61 | dataset$Liked 62 | 63 | # Splitting the dataset into the Training set and Test set 64 | 65 | library(caTools) 66 | set.seed(123) 67 | split = sample.split(dataset$Liked, SplitRatio = 0.8) 68 | training_set = subset(dataset, split == TRUE) 69 | test_set = subset(dataset, split == FALSE) 70 | 71 | # Fitting Random Forest Classification to the Training set 72 | 73 | library(randomForest) 74 | classifier = randomForest(x = training_set[-692], 75 | y = training_set$Liked, 76 | ntree = 10) 77 | classifier 78 | 79 | # Predicting the Test set results 80 | y_pred = predict(classifier, newdata = test_set[-692]) 81 | y_pred 82 | 83 | # Making the Confusion Matrix 84 | cm = table(test_set[, 692], y_pred) 85 | cm 86 | 87 | (79+70)/200 -------------------------------------------------------------------------------- /thompson_sampling.R: -------------------------------------------------------------------------------- 1 | # Thompson Sampling 2 | 3 | ### Part 1 4 | 5 | ## Setting the Working Directory 6 | 7 | setwd('./Machine Learning A-Z/Part 6 - Reinforcement Learning/Section 33 - Thompson Sampling') 8 | 9 | # Importing the dataset 10 | dataset = read.csv('Ads_CTR_Optimisation.csv') 11 | 12 | # Implementing Thompson Sampling 13 | N = 10000 14 | d = 10 15 | ads_selected = integer(0) 16 | numbers_of_rewards_1 = integer(d) 17 | numbers_of_rewards_0 = integer(d) 18 | total_reward = 0 19 | for (n in 1:N) { 20 | ad = 0 21 | max_random = 0 22 | for (i in 1:d) { 23 | random_beta = rbeta(n = 1, 24 | shape1 = numbers_of_rewards_1[i] + 1, 25 | shape2 = numbers_of_rewards_0[i] + 1) 26 | if (random_beta > max_random) { 27 | max_random = random_beta 28 | ad = i 29 | } 30 | } 31 | ads_selected = append(ads_selected, ad) 32 | reward = dataset[n, ad] 33 | if (reward == 1) { 34 | numbers_of_rewards_1[ad] = numbers_of_rewards_1[ad] + 1 35 | } else { 36 | numbers_of_rewards_0[ad] = numbers_of_rewards_0[ad] + 1 37 | } 38 | total_reward = total_reward + reward 39 | } 40 | total_reward 41 | 42 | 43 | ## Part 2 - Visualising the results 44 | hist(ads_selected, 45 | col = 'salmon', 46 | main = 'Histogram of Ads Selections', 47 | xlab = 'Ads', 48 | ylab = 'Number of Times Each Ad was Selected') -------------------------------------------------------------------------------- /upper_confidence_bound.R: -------------------------------------------------------------------------------- 1 | # Upper Confidence Bound 2 | 3 | # Importing the dataset 4 | dataset = read.csv('Ads_CTR_Optimisation.csv') 5 | 6 | # Implementing UCB 7 | N = 10000 8 | d = 10 9 | ads_selected = integer(0) 10 | numbers_of_selections = integer(d) 11 | sums_of_rewards = integer(d) 12 | total_reward = 0 13 | for (n in 1:N) { 14 | ad = 0 15 | max_upper_bound = 0 16 | for (i in 1:d) { 17 | if (numbers_of_selections[i] > 0) { 18 | average_reward = sums_of_rewards[i] / numbers_of_selections[i] 19 | delta_i = sqrt(3/2 * log(n) / numbers_of_selections[i]) 20 | upper_bound = average_reward + delta_i 21 | } else { 22 | upper_bound = 1e400 23 | } 24 | if (upper_bound > max_upper_bound) { 25 | max_upper_bound = upper_bound 26 | ad = i 27 | } 28 | } 29 | ads_selected = append(ads_selected, ad) 30 | numbers_of_selections[ad] = numbers_of_selections[ad] + 1 31 | reward = dataset[n, ad] 32 | sums_of_rewards[ad] = sums_of_rewards[ad] + reward 33 | total_reward = total_reward + reward 34 | } 35 | 36 | # Visualising the results 37 | hist(ads_selected, 38 | col = 'blue', 39 | main = 'Histogram of ads selections', 40 | xlab = 'Ads', 41 | ylab = 'Number of times each ad was selected') -------------------------------------------------------------------------------- /xgboost.R: -------------------------------------------------------------------------------- 1 | # XGBoost 2 | 3 | # Setting the Working Directory 4 | setwd('./Documents/Machine Learning A-Z/Part 10 - Model Selection/Section 53 - Combining Several Models') 5 | 6 | # Importing the Dataset 7 | dataset = read.csv('Churn_Modelling.csv') 8 | dataset = dataset[4:14] 9 | 10 | # Encoding the categorical Variables as Factors 11 | dataset$Geography = as.numeric(factor(dataset$Geography, 12 | levels = c('France', 'Spain', 'Germany'), 13 | labels = c(1, 2, 3))) 14 | dataset$Gender = as.numeric(factor(dataset$Gender, 15 | levels = c('Female', 'Male'), 16 | labels = c(1, 2))) 17 | 18 | # Splitting the Dataset into the Training Set and Test Set 19 | 20 | library(caTools) 21 | set.seed(123) 22 | split = sample.split(dataset$Exited, SplitRatio = 0.8) 23 | training_set = subset(dataset, split == TRUE) 24 | test_set = subset(dataset, split == FALSE) 25 | 26 | # Fitting XGBoost to the Training Set 27 | 28 | library(xgboost) 29 | classifier = xgboost(data = as.matrix(training_set[-11]), label = training_set$Exited, nrounds = 10) 30 | classifier 31 | 32 | # Predicting the Test Set Results 33 | 34 | y_pred = predict(classifier, newdata = as.matrix(test_set[-11])) 35 | y_pred = (y_pred >= 0.5) 36 | y_pred 37 | 38 | # Making the Confusion Matrix 39 | cm = table(test_set[, 11], y_pred) 40 | cm 41 | 42 | # Applying k-Fold Cross Validation 43 | 44 | library(caret) 45 | 46 | folds = createFolds(training_set$Exited, k = 10) 47 | folds 48 | 49 | cv = lapply(folds, function(x) { 50 | training_fold = training_set[-x, ] 51 | test_fold = training_set[x, ] 52 | classifier = xgboost(data = as.matrix(training_set[-11]), label = training_set$Exited, nrounds = 10) 53 | y_pred = predict(classifier, newdata = as.matrix(test_fold[-11])) 54 | y_pred = (y_pred >= 0.5) 55 | cm = table(test_fold[, 11], y_pred) 56 | accuracy = (cm[1,1] + cm[2,2]) / (cm[1,1] + cm[2,2] + cm[1,2] + cm[2,1]) 57 | return(accuracy) 58 | }) 59 | cv 60 | 61 | accuracy = mean(as.numeric(cv)) -------------------------------------------------------------------------------- /xgboost.py: -------------------------------------------------------------------------------- 1 | # XGBoost 2 | 3 | # Install xgboost following the instructions on this link: http://xgboost.readthedocs.io/en/latest/build.html# 4 | 5 | # Importing the libraries 6 | import numpy as np 7 | import matplotlib.pyplot as plt 8 | import pandas as pd 9 | 10 | # Importing the dataset 11 | dataset = pd.read_csv('Churn_Modelling.csv') 12 | X = dataset.iloc[:, 3:13].values 13 | y = dataset.iloc[:, 13].values 14 | 15 | # Encoding categorical data 16 | from sklearn.preprocessing import LabelEncoder, OneHotEncoder 17 | labelencoder_X_1 = LabelEncoder() 18 | X[:, 1] = labelencoder_X_1.fit_transform(X[:, 1]) 19 | labelencoder_X_2 = LabelEncoder() 20 | X[:, 2] = labelencoder_X_2.fit_transform(X[:, 2]) 21 | onehotencoder = OneHotEncoder(categorical_features = [1]) 22 | X = onehotencoder.fit_transform(X).toarray() 23 | X = X[:, 1:] 24 | 25 | # Splitting the dataset into the Training set and Test set 26 | from sklearn.model_selection import train_test_split 27 | X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2, random_state = 0) 28 | 29 | # Fitting XGBoost to the Training set 30 | from xgboost import XGBClassifier 31 | classifier = XGBClassifier() 32 | classifier.fit(X_train, y_train) 33 | 34 | # Predicting the Test set results 35 | y_pred = classifier.predict(X_test) 36 | 37 | # Making the Confusion Matrix 38 | from sklearn.metrics import confusion_matrix 39 | cm = confusion_matrix(y_test, y_pred) 40 | 41 | # Applying k-Fold Cross Validation 42 | from sklearn.model_selection import cross_val_score 43 | accuracies = cross_val_score(estimator = classifier, X = X_train, y = y_train, cv = 10) 44 | accuracies.mean() 45 | accuracies.std() --------------------------------------------------------------------------------