Guide To Cracking The MachineHack ‘Pre-Owned Cars Price Prediction’ Hackathon
MachineHack one of the leading hackathon platforms dedicated to the Data Science community, is back again with an exciting hackathon for all data science enthusiasts. This new hackathon, in partnership with Imarticus Learning, challenges the data science community to predict the resale value of a car from various features. Predicting The Costs Of Used Cars Hackathon consists of data collected from various sources across India. In this article, we will continue from where we stopped, to preprocess and build a simple regression model for the hackathon. So without further ado let’s begin with a basic solution. Data Preprocessing By the end of the first part, we had already performed Exploratory Data Analysis and also cleaned the data to some extent making it ready for the next stage which is Data Preprocessing. We now have a clean dataset that we believe consists of only the values or numbers that are required to train a model and make some predictions. However, that data is still not ready to be trained. The data still consists of empty cells or nans that needs to be filled and also we need to encode and scale the data. We will also split the training set to a training set and a validation set so that we can evaluate the model for prediction accuracy. Encoding Categorical Variables We will start by encoding the categorical features in the cleaned dataset.To  encode we must know all the unique values or categories in each of the columns(‘Brand’, ‘Model’, ‘Location’,’Fuel_Type’, ‘Transmission’, ‘Owner_Type’). Follow the below steps. Finding all unique categories #'Brand', 'Model', 'Location','Fuel_Type', 'Transmission', 'Owner_Type' all_brands = list(set(list(training_set.Brand) + list(test_set.Brand))) all_models = list(set(list(training_set.Model) + list(test_set.Model))) all_locations = list(set(list(training_set.Location) + list(test_set.Location))) all_fuel_types = list(set(list(training_set.Fuel_Type) + list(test_set.Fuel_Type))) all_transmissions = list(set(list(training_set.Transmission) + list(test_set.Transmission))) all_owner_types = list(set(list(training_set.Owner_Type) + list(test_set.Owner_Type))) Initializing label encoders and fitting the categories #Initializing label encoders from sklearn.preprocessing import LabelEncoder le_brands = LabelEncoder() le_models = LabelEncoder() le_locations = LabelEncoder() le_fuel_types = LabelEncoder() le_transmissions = LabelEncoder() le_owner_types = LabelEncoder() #Fitting the categories le_brands.fit(all_brands) le_models.fit(all_models) le_locations.fit(all_locations) le_fuel_types.fit(all_fuel_types) le_transmissions.fit(all_transmissions) le_owner_types.fit(all_owner_types) Transforming the data in training set and test_set #Applying encoding to Training_set data training_set['Brand'] = le_brands.transform(training_set['Brand']) training_set['Model'] = le_models.transform(training_set['Model']) training_set['Location'] = le_locations.transform(training_set['Location']) training_set['Fuel_Type'] = le_fuel_types.transform(training_set['Fuel_Type']) training_set['Transmission'] = le_transmissions.transform(training_set['Transmission']) training_set['Owner_Type'] = le_owner_types.transform(training_set['Owner_Type']) #Applying encoding to Test_set data test_set['Brand'] = le_brands.transform(test_set['Brand']) test_set['Model'] = le_models.transform(test_set['Model']) test_set['Location'] = le_locations.transform(test_set['Location']) test_set['Fuel_Type'] = le_fuel_types.transform(test_set['Fuel_Type']) test_set['Transmission'] = le_transmissions.transform(test_set['Transmission']) test_set['Owner_Type'] = le_owner_types.transform(test_set['Owner_Type']) On executing the above code blocks, the training_set and test_set will be converted to completely numerical datasets as shown below. Imputing Missing Values Now we can impute or fill up the missing values. Just before imputing we will classify the predictors and target. Classifying predictors and target # Dependent Variable Y_train_data = training_set.iloc[:, -1].values # Independent Variables X_train_data = training_set.iloc[:,0 : -1].values # Independent Variables for test Set X_test = test_set.iloc[:,:].values Initializing and fitting the imputer from sklearn.impute import SimpleImputer #Training Set Imputation imputer = SimpleImputer(missing_values = np.nan, strategy = 'most_frequent') imputer = imputer.fit(X_train_data[:,8:12]) X_train_data[:,8:12] = imputer.transform(X_train_data[:,8:12]) #Test_set Imputation imputer = SimpleImputer(missing_values = np.nan, strategy = 'most_frequent') imputer = imputer.fit(X_test[:,8:12]) X_test[:,8:12] = imputer.transform(X_test[:,8:12]) The above code block will replace all missing values or ‘Nan’ with the most frequently occurring element in each respective column. Splitting The Training Data Into Training And Validation Sets from sklearn.model_selection import train_test_split #Splitting the training set into Training and validation sets X_train, X_val, Y_train, Y_val = train_test_split(X_train_data, Y_train_data, test_size = 0.2, random_state = 1) Scaling The Data #Feature Scaling from sklearn.preprocessing import StandardScaler sc = StandardScaler() #Scaling Original Training Data X_train_data = sc.fit_transform(X_train_data) #Reshaping vector to array for transforming Y_train_data = Y_train_data.reshape((len(Y_train_data), 1)) Y_train_data = sc.fit_transform(Y_train_data) #converting back to vector Y_train_data = Y_train_data.ravel() X_test = sc.transform(X_test) # Scaling Splitted training and val sets X_train = sc.fit_transform(X_train) X_val = sc.fit_transform(X_val) #Reshaping vector to array for transforming Y_train = Y_train.reshape((len(Y_train), 1)) Y_train = sc.fit_transform(Y_train) #converting back to vector Y_train = Y_train.ravel() The above code blocks on execution will transform the datasets into scaled or normalised datasets. As shown below for example data in X_train has been reduced to a smaller range. Modelling And Predicting We are down to the final stage of modelling the data. We will create a simple linear regression model to predict the Price for the given test data. But before we do that we need to check how efficient our model is for which we have created a validation set. We will use the Root Mean Log Squared Error (RMLSE) on the validation set for calculating the accuracy as mentioned in the hackathons evaluation page. Calculating Accuracy With RMLSE # Score Calculation def score(y_pred, y_true): error = np.square(np.log10(y_pred +1) - np.log10(y_true +1)).mean() ** 0.5 score = 1 - error return score #The actual recordings to be tested against y_true = Y_val Testing The Model On Validation Sets #Initializing Linear regressor from sklearn.linear_model import LinearRegression lr = LinearRegression() #Fitting the regressor with training data lr.fit(X_train,Y_train) #Predicting the target(Price) for predictors in validation set X_val Y_pred = sc.inverse_transform(lr.predict(X_val)) #Eliminating negative values in prediction for score calculation for i in range(len(Y_pred)): if Y_pred[i] < 0: Y_pred[i] = 0 #Printing the score for validation sets print("\n\n Linear Regression SCORE : ", score(Y_pred, y_true)) Output: Linear Regression SCORE :  0.763433258668093 Predicting The Price For Test Set #Initializing a new regressor lr2 = LinearRegression() #Fitting the regressor with complete training data(X_train_data,Y_train_data) lr2.fit(X_train_data,Y_train_data) #Predicting the target(Price) for predictors in the test data Y_pred2 = sc.inverse_transform(lr2.predict(X_test)) #Eliminating negative values in prediction for score calculation for i in range(len(Y_pred2)): if Y_pred2[i] < 0: Y_pred2[i] = 0 Saving the predictions to an excel sheet pd.DataFrame(Y_pred2, columns = ['Price']).to_excel("predictions.xlsx") Finally, you can submit the excel in the assignment page of the hackathon and see your score on the leaderboard. The above solution has attained a leaderboard score of 0.76959 at MachineHack. Use the above code as a starter pack, use your own ideas and submit the solutions to learn and win prizes. Good luck and happy modelling!
MachineHack one of the leading hackathon platforms dedicated to the Data Science community, is back again with an exciting hackathon for all data science enthusiasts. This new hackathon, in partnership with Imarticus Learning, challenges the data science community to predict the resale value of a car from various features. Predicting The Costs Of Used Cars […]
The complete step by step solution to cracking Machinehack's Predicting The Costs Of Used Cars - Hackathon By Imarticus Learning
["Hackathon", "Machinehack", "regression"]
["data science", "Go", "API", "TPU", "programming_languages:R", "AI", "Machinehack", "ML", "programming_languages:Go", "regression", "Hackathon", "Ray", "R"]
["AI", "ML", "data science", "Ray", "TPU", "R", "Go", "API", "programming_languages:R", "programming_languages:Go"]
A Computer Science Engineer turned Data Scientist who is passionate about AI and all related technologies. 
Contact: amal.nair@analyticsindiamag.com