File size: 4,005 Bytes
5ea8735 |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 |
import os
import gradio as gr
import pandas as pd
from KNN.KNNModel import KNNModel
class KNN_UI:
def __init__(self):
self.knn_model = KNNModel()
try:
# Load and preprocess data
self.knn_model.load_and_preprocess_data()
# Find optimal k and train the model
X_train, X_test, y_train, y_test = self.knn_model.load_and_preprocess_data()
self.knn_model.find_optimal_k(X_train, y_train)
self.knn_model.train_model(X_train, y_train)
except Exception as e:
print(f"Error during initialization: {e}")
def get_interface(self) -> gr.Blocks:
with gr.Blocks() as interface:
#self.__get_inputs_ui()
gr.Markdown("## Fat Percentage Prediction through kNN Regressor" )
gr.Markdown("")
gr.Markdown(
"Welcome to the **Fat Percentage Prediction** section. Here, you can determine an individual's Fat Percentage based on a set of input parameters."
)
gr.Markdown(
"You are to input details such as workout frequency, session duration, water intake, calories burned, and experience level to make a prediction. "
"The Experience Level is grouped into three Levels: 1- Beginner, Professional, and 3- Expert. "
)
self.__get_inputs_ui()
return interface
def __get_inputs_ui(self):
def predict(workout_frequency,session_duration, water_intake, calories_burned, experience_level):
try:
# Encode categorical features
if 'Experience_Level' not in self.knn_model.label_encoders:
return f"Error: 'Experience_Level' encoder not found. Ensure the column exists in the dataset."
experience_level_encoded = self.knn_model.label_encoders['Experience_Level'].transform([experience_level])[0]
# Create input DataFrame
input_data = pd.DataFrame({
'Workout_Frequency (days/week)': [workout_frequency],
'Session_Duration (hours)': [session_duration],
'Water_Intake (liters)': [water_intake],
'Calories_Burned': [calories_burned],
'Experience_Level': [experience_level_encoded]
})
# Predict fat percentage
predicted_fat_percentage = self.knn_model.predict(input_data)
return f"Predicted Fat Percentage: {predicted_fat_percentage:.2f}%"
except Exception as e:
return f"Error: {str(e)}"
with gr.Column() as inputs_ui:
gr.Markdown("# Input your record")
workout_frequency = gr.Number(label="Workout Frequency (days/week)", minimum=1, maximum=7, step=1, value=3)
session_duration = gr.Number(label="Session Duration (hours)", minimum=0.0, maximum=24.0, step=0.1, value=1.25)
water_intake = gr.Number(label="Water Intake (liters/day)", minimum=0.0, maximum=10.0, step=0.1, value=2.5)
calories_burned = gr.Number(label="Calories Burned", minimum=0.0, maximum=2000.0, step=0.1, value=905.5)
experience_level = gr.Dropdown(
label="Experience Level",
choices=self.knn_model.label_encoders['Experience_Level'].classes_.tolist()
)
predict_btn = gr.Button("Calculate")
gr.Markdown("# Calculated Fat Percentage")
res = gr.Markdown("")
predict_btn.click(predict, inputs=[calories_burned, session_duration, workout_frequency, water_intake, experience_level], outputs=res)
return inputs_ui
# Initialize the UI and launch the Gradio interface
if __name__ == "__main__":
knn_ui = KNN_UI()
interface = knn_ui.get_interface()
interface.launch() |