Updated app.py to use deep learning

app.py

@@ -1,137 +1,136 @@
-import random
 import gradio as gr
-from joblib import load
-
-# Model URL for each
-rf_model_url = 'random_forest_model.joblib'
-
-
-# Load Model method
-def load_model(url):
-    return load(rf_model_url)
-
-
-def bool_value(val):
-    if not val:
-        return 0
-    else:
-        return 1
-
-
-def gender(val):
-    if val == 'Male':
-        return 1
-    elif val == 'Female':
-        return 0
-    else:
-        return 2
-
-
-def race(val):
-    if val == 'Hispanic':
-        return 2
-    elif val == 'Black':
-        return 1
-    elif val == 'White':
-        return 5
-    elif val == 'Other':
-        return 4
-    elif val == 'Asian':
-        return 0
-    else:
-        return 3
-
-
-def search_outcome(val, end_range):
-    if not val:
-        return 2  # Which mean no search was conducted
-    else:
-        return random.randrange(0, end_range)
-
-
-def search_reason(val, end_range):
-    if not val:
-        return 726  # Which mean no search was conducted
-    else:
-        return random.randrange(0, end_range)
-
-
-# Make Prediction Model but would also like to add Gender and Race
-def make_predication(year_stopped, offences, search, doc, car_year, alcohol, safety, genders, speeding,
-                     races, accident, actual_accident, damage, road_signs, injury, belt, disobedience, bad_driving,
-                     phone):
-    input_features = {
-        'encoded_Search Outcome': search_outcome(search, 6),
-        'encoded_Search Reason For Stop': search_reason(search, 727),
-        'Number Of Offences': offences,
-        'Search Conducted': bool_value(search),
-        'Year Stopped': year_stopped,
-        'encoded_SubAgency': random.randrange(0, 7),
-        'encoded_Arrest Type': random.randrange(0, 18),
-        'Invalid Documentation': bool_value(doc),
-        'Year': car_year,  # int
-        'encoded_Driver City': random.randrange(0, 8114),  # int
-        'encoded_Make': random.randrange(0, 57),  # int
-        'Alcohol': bool_value(alcohol),  # bool
-        'encoded_Color': random.randrange(0, 25),  # int
-        'Vehicle Safety And Standards': bool_value(safety),  # bool
-        'Speeding': bool_value(speeding),
-        'encoded_Race': race(races),
-        'Contributed To Accident': bool_value(accident),
-        'Accident': bool_value(actual_accident),
-        'encoded_VehicleType': random.randrange(0, 31),
-        'Property Damage': bool_value(damage),
-        'Road Signs And Markings': bool_value(road_signs),
-        'Personal Injury': bool_value(injury),
-        'encoded_Gender': gender(genders),
-        'Belts': bool_value(belt),
-        'Disobedience': bool_value(disobedience),
-        'encoded_DL State': random.randrange(0, 70),
-        'encoded_State': random.randrange(0, 68),
-        'Negligent Driving': bool_value(bad_driving),
-        'encoded_Driver State': random.randrange(0, 67),
-        'Mobile Phone': bool_value(phone)
-    }
-
-    x_input_feature = [[input_features[feature] for feature in sorted(input_features)]]
-    rfc_model = load_model(rf_model_url)
-    prd = rfc_model.predict(x_input_feature)
-
-    if prd == 0:
-        return 'Citation'
-    elif prd == 1:
-        return 'SERO'
-    else:
-        return 'Warning'
-
-
-iface = gr.Interface(fn=make_predication,
-                     inputs=[gr.components.Slider(minimum=2010, maximum=2023, step=1, label='Citation Year'),
-                             gr.components.Slider(minimum=1, step=1, label='Number of offences found for stop'),
-                             gr.components.Checkbox(label='Was a search conducted'),
-                             gr.components.Checkbox(label='Any invalid documents'),
-                             gr.components.Slider(minimum=1990, maximum=2023, step=1, label='Make Year'),
-                             gr.components.Checkbox(label='Was alcohol involved'),
-                             gr.components.Checkbox(label='Safety Standard issues in Vehicle'),
-                             gr.components.Dropdown(label='Gender', choices=['Female',
-                                                                             'Male',
-                                                                             'Unknown']),
-                             gr.components.Checkbox(label='Speeding'),
-                             gr.components.Dropdown(label='Race', choices=['Asian',
-                                                                           'Black',
-                                                                           'Hispanic',
-                                                                           'Native American',
-                                                                           'Other',
-                                                                           'White']),
-                             gr.components.Checkbox(label='Irregularities which could contribute to accident'),
-                             gr.components.Checkbox(label='Was the stop actual for an accident'),
-                             gr.components.Checkbox(label='Any Property damage'),
-                             gr.components.Checkbox(label='Road sign violation involvement'),
-                             gr.components.Checkbox(label='Any injuries'),
-                             gr.components.Checkbox(label='Seat Belts irregulation'),
-                             gr.components.Checkbox(label='Any disobedience'),
-                             gr.components.Checkbox(label='Bad driving'),
-                             gr.components.Checkbox(label='Mobile phone')],
+import pandas as pd
+import numpy as np
+from tensorflow import keras
+import pickle
+
+# Configuration section START
+
+with open('model_config.pkl', 'rb') as f:
+    tf = pickle.load(f)
+
+model = keras.models.load_model('model.keras')
+
+all_selected_features = ['Alcohol', 'Arrest Type', 'Belts', 'Contributed To Accident', 'Disobedience', 'Driver City',
+                         'Gender',
+                         'Invalid Documentation', 'Make', 'Mobile Phone', 'Negligent Driving', 'Number Of Offences',
+                         'Personal Injury',
+                         'Property Damage', 'Race', 'Road Signs And Markings', 'Search Outcome', 'Speeding',
+                         'Stop Hour', 'Stop Year',
+                         'SubAgency', 'Vehicle Safety And Standards', 'VehicleType', 'Year']
+very_high_cardinality_features = ['Driver City']
+high_cardinality_features = ['Make', 'VehicleType']
+bools = ['Alcohol', 'Belts', 'Contributed To Accident', 'Disobedience', 'Invalid Documentation', 'Mobile Phone',
+         'Negligent Driving',
+         'Personal Injury', 'Property Damage', 'Road Signs And Markings', 'Speeding', 'Vehicle Safety And Standards']
+num_cols = ['Driver City', 'Make', 'Number Of Offences', 'Stop Hour', 'Stop Year', 'VehicleType', 'Year']
+
+
+# Configuration section END
+
+
+make_prediction(alcohol, arrest_type, belts, contributed_to_accident, disobedience, driver_city, gender,
+                    invalid_documentation, make, mobile_phone, negligent_driving, number_of_offences, personal_injury,
+                    property_damage, race, road_signs_and_markings, search_outcome, speeding, stop_hour, stop_year,
+                    subagency, vehicle_safety_and_standards, vehicletype, year):
+    """
+    Function to predict the 'Violation Type' of an individual sample of traffic stop:
+    :param alcohol: boolean
+    :param arrest_type: String
+    :param belts: Boolean
+    :param contributed_to_accident: Boolean
+    :param disobedience: Boolean
+    :param driver_city: String
+    :param gender: 'M', 'F' or 'N'
+    :param invalid_documentation: Boolean
+    :param make: String
+    :param mobile_phone: Boolean
+    :param negligent_driving: Boolean
+    :param number_of_offences: Integer
+    :param personal_injury: Boolean
+    :param property_damage: Boolean
+    :param race: One of 'HISPANIC', 'BLACK', 'WHITE', 'OTHER', 'ASIAN', or 'NATIVE AMERICAN'
+    :param road_signs_and_markings: Boolean
+    :param search_outcome: String
+    :param speeding: Boolean
+    :param stop_hour: Integer
+    :param stop_year: Integer
+    :param subagency: String
+    :param vehicle_safety_and_standards: Boolean
+    :param vehicletype: String
+    :param year: Integer
+    :return:
+    """
+    # Create a dataframe with the feature values
+    X = pd.DataFrame([[alcohol, arrest_type, belts, contributed_to_accident, disobedience, driver_city, gender,
+                       invalid_documentation, make,
+                       mobile_phone, negligent_driving, number_of_offences, personal_injury, property_damage, race,
+                       road_signs_and_markings,
+                       search_outcome, speeding, stop_hour, stop_year, subagency, vehicle_safety_and_standards,
+                       vehicletype, year]],
+                     columns=all_selected_features)
+
+    # Transform the features
+    # Encode very high cardinality features (Driver City) with ordinal encoding, by fitting on the whole dataset
+    oev = tf["OrdinalEncoder_VeryHighCardinality"].set_params(handle_unknown='use_encoded_value').set_params(
+        unknown_value=6714)
+    X[very_high_cardinality_features] = oev.transform(X[very_high_cardinality_features])
+
+    # Encode high cardinality features with ordinal encoding by fitting only on the training set
+    X[high_cardinality_features] = tf["OrdinalEncoder_HighCardinality"].transform(X[high_cardinality_features])
+
+    # Scale all the numerical features, including those that were ordinal encoded
+    X[num_cols] = tf["StandardScaler"].transform(X[num_cols])
+
+    # Convert booleans to numbers
+    X[bools] = X[bools].astype('int8')
+
+    # One-hot encode the low cardinality features
+    X = tf['OneHotEncoder'].transform(X)
+
+    # Make the prediction using the model
+    prediction = model.predict(X, verbose=0)
+
+    prediction = tf["LabelEncoder"].inverse_transform(np.argmax(prediction, axis=1))
+
+    # Return the prediction
+    return prediction[0]
+
+arrest_types = ['A - Marked Patrol', 'G - Marked Moving Radar (Stationary)',
+       'Q - Marked Laser', 'L - Motorcycle',
+       'H - Unmarked Moving Radar (Stationary)', 'O - Foot Patrol',
+       'E - Marked Stationary Radar', 'B - Unmarked Patrol',
+       'S - License Plate Recognition', 'R - Unmarked Laser',
+       'J - Unmarked Moving Radar (Moving)', 'M - Marked (Off-Duty)',
+       'I - Marked Moving Radar (Moving)',
+       'F - Unmarked Stationary Radar', 'D - Unmarked VASCAR',
+       'K - Aircraft Assist', 'C - Marked VASCAR', 'P - Mounted Patrol',
+       'N - Unmarked (Off-Duty)']
+
+iface = gr.Interface(fn=make_prediction,
+                     inputs=[gr.components.Checkbox(label='Was the driver under the influence of alcohol?'),
+                             gr.components.Dropdown(label='Choose the arrest type', choices=arrest_types, value='A - Marked Patrol')
+                             gr.components.Checkbox(label='Were seatbelts used appropriately?'),
+                             gr.components.Checkbox(label='Did the driver actions contribute to an accident?'),
+                             gr.components.Checkbox(label='Was the driver disobedient? (such as failing to display documentation upon request)?'),
+                             gr.components.Dropdown(label='Choose the arrest type', choices=tf['OrdinalEncoder_VeryHighCardinality'].categories_, value='SILVER SPRING')
+                             gr.components.Dropdown(label='Driver Gender', choices=['M', 'F', 'N'], value='M')
+                             gr.components.Checkbox(label='Was the driver driving with Invalid Documentation (such as suspended registration, suspended license, expired registration plates and validation tabs or expired license plate)?'),
+                             gr.components.Dropdown(label='Vehicle Make', choices=tf['OrdinalEncoder_HighCardinality'].categories_[0], value='TOYOTA')
+                             gr.components.Checkbox(label='Was the driver using a mobile phone while driving?'),
+                             gr.components.Checkbox(label='Was the driver caught driving with negligence (example switching lanes in an unsafe manner)?'),
+                             gr.components.Slider(minimum=1, step=1, label='Number of offences committed')],
+                             gr.components.Checkbox(label='Did the violation involve any personal injury?'),
+                             gr.components.Checkbox(label='Did the violation involve any property damage?'),
+                             gr.components.Dropdown(label='Choose the race of the driver', choices=tf['OneHotEncoder'].transformers_[0][1].categories_[2], value='WHITE')
+                             gr.components.Checkbox(label='Did the driver fail to obey signs and markings (such as traffic control device instructions, stop lights, red signal and stop sign lines)?'),
+                             gr.components.Dropdown(label='Choose the race of the driver', choices=tf['OneHotEncoder'].transformers_[0][1].categories_[3], value='NO SEARCH CONDUCTED')
+                             gr.components.Checkbox(label='Was the driver caught speeding?'),
+                             gr.components.Slider(maximum=23, step=1, label='Time HOUR when stop occurred in 24-hour format')],
+                             gr.components.Slider(minimum=2012, maximum=2024, step=1, label='Year when stop occurred')],
+                             gr.components.Dropdown(label='What is the name of the subagency that conducted the traffic stop?', choices=tf['OneHotEncoder'].transformers_[0][1].categories_[1], value='4th District, Wheaton')
+                             gr.components.Checkbox(label='Was the vehicle safe and up to standards (lights properly switched, registration plates attached etc.)?'),
+                             gr.components.Slider(minimum=1970, maximum=2023, step=1, label='Year of manufacture of the vehicle:)],
                      outputs=["text"])
 
-iface.launch(debug=True)
+iface.launch(debug=True)