merge with huggingface

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+*.json filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,3 @@
+.env
+env/
+__pycache__/

Dockerfile

@@ -0,0 +1,25 @@
+# Use the official Python image from the Docker Hub
+FROM python:3.9-slim
+
+# Set the working directory in the container
+WORKDIR /app
+
+# Copy the requirements.txt file into the container at /app
+COPY requirements.txt requirements.txt
+
+# Install the dependencies
+RUN pip install --no-cache-dir -r requirements.txt
+
+# Copy the rest of the application code into the container at /app
+COPY . .
+
+# Set environment variables for Flask
+ENV FLASK_APP=server.py
+ENV FLASK_RUN_HOST=0.0.0.0
+ENV FLASK_RUN_PORT=7860
+
+# Expose port 7860 to the outside world
+EXPOSE 7860
+
+# Run the application
+CMD ["flask", "run"]

models/fitness_model.py

@@ -0,0 +1,259 @@
+from sklearn.preprocessing import OneHotEncoder
+import random
+import pandas as pd
+import os
+import pickle
+
+SERVER_FILE_DIR = os.path.dirname(os.path.abspath(__file__))
+FITNESS_MODEL_PATH = os.path.join(
+    SERVER_FILE_DIR, *"../resources/models/fitness_model.pkl".split("/")
+)
+
+
+class FitnessModel:
+    def __init__(self, excercise_path, kmeans_path, plan_classifier_path):
+        self.data = pd.read_csv(excercise_path)
+        self.kmeans = None
+        self.plan_classifier = None
+        self.encoder = None
+        self.cluster_data = {}
+        self.X_train_cols = [
+            "level_Advanced",
+            "level_Beginner",
+            "level_Intermediate",
+            "goal_ Get Fitter",
+            "goal_ Lose Weight",
+            "goal_Gain Muscle",
+            "goal_Get Fitter",
+            "goal_Increase Endurance",
+            "goal_Increase Strength",
+            "goal_Sports Performance",
+            "gender_Female",
+            "gender_Male",
+            "gender_Male & Female",
+        ]
+
+        # Load kmeans model
+        with open(kmeans_path, "rb") as f:
+            self.kmeans = pickle.load(f)
+
+        # Load plan classifier model
+        with open(plan_classifier_path, "rb") as f:
+            self.plan_classifier = pickle.load(f)
+
+        # Iterate over each cluster label
+        for cluster_label in range(90):
+            # Filter the dataset to get data for the current cluster
+            cluster_subset = self.data[self.data["cluster"] == cluster_label]
+
+            # Add the cluster data to the dictionary
+            self.cluster_data[cluster_label] = cluster_subset
+
+        features = self.data[["Level", "goal", "bodyPart"]]
+
+        # Perform one-hot encoding for categorical features
+        self.encoder = OneHotEncoder(sparse=False)
+        encoded_features = self.encoder.fit_transform(features)
+
+    def choose_plan(self, level, goal, gender):
+        global plan_classifier
+        # Convert input into a DataFrame
+        input_data = pd.DataFrame(
+            {"level": [level], "goal": [goal], "gender": [gender]}
+        )
+
+        # One-hot encode the input data
+        input_encoded = pd.get_dummies(input_data, columns=["level", "goal", "gender"])
+
+        # Ensure that input has the same columns as the model was trained on
+        # This is necessary in case some categories are missing in the input
+        missing_cols = set(self.X_train_cols) - set(input_encoded.columns)
+        for col in missing_cols:
+            input_encoded[col] = 0
+
+        # Reorder columns to match the order of columns in X_train
+        input_encoded = input_encoded[self.X_train_cols]
+
+        # Make prediction for the given input using the trained model
+        prediction = self.plan_classifier.predict(input_encoded)
+
+        # Convert each string in the list to a list of strings
+        daily_activities_lists = [day.split(", ") for day in prediction[0]]
+
+        return daily_activities_lists
+
+    def get_daily_recommendation(self, home_or_gym, level, goal, bodyParts, equipments):
+        if goal in ["Lose Weight", "Get Fitter"]:
+            goal = "Get Fitter & Lose Weight"
+        daily_recommendations = []
+
+        bodyParts = [bp for bp in bodyParts if "-" not in bp]
+        # Repeat elements in bodyParts until it reaches a size of 6
+        while len(bodyParts) < 6:
+            bodyParts += bodyParts
+
+        # Limit bodyParts to size 6
+        bodyParts = bodyParts[:6]
+
+        for bodyPart in bodyParts:
+            # Predict cluster for the specified combination of goal, level, and body part
+            input_data = [[level, goal, bodyPart]]
+            predicted_cluster = self.kmeans.predict(self.encoder.transform(input_data))[
+                0
+            ]
+            print(predicted_cluster)
+            # Get data for the predicted cluster
+            cluster_subset = self.cluster_data[predicted_cluster]
+
+            # Filter data based on location (home or gym)
+            if home_or_gym == 0:
+                cluster_subset = cluster_subset[
+                    ~cluster_subset["equipment"].isin(equipments)
+                ]
+
+            # Randomly select one exercise from the cluster if any left after equipment filtering
+            if not cluster_subset.empty:
+                selected_exercise = random.choice(
+                    cluster_subset.to_dict(orient="records")
+                )
+                daily_recommendations.append(selected_exercise)
+
+        # Remove duplicates from the list
+        unique_recommendations = []
+        seen_names = set()
+        for exercise in daily_recommendations:
+            if exercise["name"] not in seen_names:
+                unique_recommendations.append(exercise)
+                seen_names.add(exercise["name"])
+
+        return unique_recommendations
+
+    def get_gender_adjustment(self, gender):
+        return 1.0 if gender == "Male" else 0.7
+
+    def get_age_adjustment(self, age):
+        if age < 30:
+            return 1.0
+        elif 30 <= age < 50:
+            return 0.5
+        else:
+            return 0.1
+
+    def get_level_adjustment(self, level):
+        if level == "Beginner":
+            return 0.8
+        elif level == "Intermediate":
+            return 1.0
+        elif level == "Advanced":
+            return 1.2
+
+    def get_body_part_adjustment(self, body_part):
+        body_parts = {
+            "chest": 1,
+            "shoulders": 0.8,
+            "waist": 0.6,
+            "upper legs": 0.7,
+            "back": 0.9,
+            "lower legs": 0.5,
+            "upper arms": 0.8,
+            "cardio": 0.7,
+            "lower arms": 0.6,
+            "neck": 0.5,
+        }
+        return body_parts.get(body_part, 0)
+
+    def adjust_workout(self, gender, age, feedback, body_part, level, old_weight):
+        gender_adjustment = self.get_gender_adjustment(gender)
+        age_adjustment = self.get_age_adjustment(age)
+        level_adjustment = self.get_level_adjustment(level)
+        body_part_adjustment = self.get_body_part_adjustment(body_part)
+
+        increasing_factor_of_weight = (
+            age_adjustment
+            * body_part_adjustment
+            * gender_adjustment
+            * level_adjustment
+            * 0.3
+        )
+
+        if not feedback:
+            increasing_factor_of_weight = (1 - increasing_factor_of_weight) * -0.1
+
+        new_weight = old_weight + increasing_factor_of_weight * old_weight
+
+        return new_weight
+
+    def calculate_new_repetition(self, level, goal):
+        if goal in ["Lose Weight", "Get Fitter"]:
+            if level == "Beginner":
+                return 15
+            elif level == "Intermediate":
+                return 12
+            elif level == "Expert":
+                return 10
+        elif goal == "Gain Muscle":
+            if level == "Beginner":
+                return 10
+            elif level == "Intermediate":
+                return 8
+            elif level == "Advanced":
+                return 6
+
+    def calculate_new_duration(self, level):
+
+        if level == "Beginner":
+            return 20
+        elif level == "Intermediate":
+            return 50
+        elif level == "Advanced":
+            return 80
+
+    def predict(
+        self, home_or_gym, level, goal, gender, age, feedback, old_weight, equipments
+    ):
+
+        plan = self.choose_plan(level, goal, gender)
+        print(plan)
+
+        while len(plan) < 30:
+            plan.extend(plan)
+        plan = plan[:30]
+
+        all_recommendations = []
+        for day_body_parts in plan:
+            daily_exercises = self.get_daily_recommendation(
+                home_or_gym, level, goal, day_body_parts, equipments
+            )
+            daily_recommendations = []
+
+            for exercise in daily_exercises:
+                weights = self.adjust_workout(
+                    gender, age, feedback, exercise["bodyPart"], level, old_weight
+                )
+                repetitions = self.calculate_new_repetition(level, goal)
+                duration = self.calculate_new_duration(level)
+                weights_or_duration = (
+                    weights if exercise["type"] == "weight" else duration
+                )
+                exercise_recommendations = {
+                    "name": exercise["name"],
+                    "type": exercise["type"],
+                    "equipment": exercise["equipment"],
+                    "bodyPart": exercise["bodyPart"],
+                    "target": exercise["target"],
+                    "weights_or_duration": weights_or_duration,
+                    "sets": exercise["sets"],
+                    "repetitions": repetitions,
+                }
+                daily_recommendations.append(exercise_recommendations)
+            all_recommendations.append(daily_recommendations)
+
+        return all_recommendations  # Trim to ensure exactly 30 elements
+
+    @classmethod
+    def load(cls):
+        with open(FITNESS_MODEL_PATH, "rb") as f:
+            print(f)
+            fitness_model = pickle.load(f)
+
+        return fitness_model

models/nutrition_model.py

@@ -0,0 +1,97 @@
+import random
+import pandas as pd
+import numpy as np
+import pickle
+import os
+
+SERVER_FILE_DIR = os.path.dirname(os.path.abspath(__file__))
+NUTRITION_MODEL_PATH = os.path.join(SERVER_FILE_DIR, "../resources/models/nutrition_model.pkl")
+MEALS_JSON_PATH = os.path.join(SERVER_FILE_DIR, "../resources/datasets/meals.json")
+
+# Ensure the file exists
+if not os.path.exists(MEALS_JSON_PATH):
+    raise FileNotFoundError(f"File {MEALS_JSON_PATH} does not exist")
+
+df = pd.read_json(MEALS_JSON_PATH)
+
+
+class NutritionModel:
+    def __init__(self):
+        self.load()
+
+    def generate_plan(self, calories):
+        lunch_attr = {
+            "Calories": calories * 0.5,
+            "FatContent": random.uniform(19, 97),
+            "SaturatedFatContent": random.uniform(6, 12),
+            "CholesterolContent": random.uniform(77, 299),
+            "SodiumContent": random.uniform(565, 2299),
+            "CarbohydrateContent": random.uniform(28, 317),
+            "FiberContent": random.uniform(2, 38),
+            "SugarContent": random.uniform(0, 38),
+            "ProteinContent": random.uniform(20, 123)
+        }
+        
+        lunch_df = pd.DataFrame(lunch_attr, index=[0])
+        
+        breakfast_attr = {
+            "Calories": calories * 0.30,
+            "FatContent": random.uniform(8.7, 20),
+            "SaturatedFatContent": random.uniform(1.7, 3.7),
+            "CholesterolContent": random.uniform(0, 63),
+            "SodiumContent": random.uniform(163, 650),
+            "CarbohydrateContent": random.uniform(23, 56),
+            "FiberContent": random.uniform(2.6, 8),
+            "SugarContent": random.uniform(3.5, 13),
+            "ProteinContent": random.uniform(6, 25)
+        }
+        
+        breakfast_df = pd.DataFrame(breakfast_attr, index=[0])
+        
+        dinner_attr = {
+            "Calories": calories * 0.30,
+            "FatContent": random.uniform(8.7, 20),
+            "SaturatedFatContent": random.uniform(1.7, 3.7),
+            "CholesterolContent": random.uniform(0, 63),
+            "SodiumContent": random.uniform(163, 650),
+            "CarbohydrateContent": random.uniform(23, 56),
+            "FiberContent": random.uniform(2.6, 8),
+            "SugarContent": random.uniform(3.5, 13),
+            "ProteinContent": random.uniform(6, 25)
+        }
+        
+        dinner_df = pd.DataFrame(dinner_attr, index=[0])
+        
+        snack_attr = {
+            "Calories": random.uniform(90, 190),
+            "FatContent": random.uniform(1.7, 10),
+            "SaturatedFatContent": random.uniform(0.7, 3),
+            "CholesterolContent": random.uniform(2, 16),
+            "SodiumContent": random.uniform(47, 200),
+            "CarbohydrateContent": random.uniform(10, 31),
+            "FiberContent": random.uniform(0.4, 2.5),
+            "SugarContent": random.uniform(5.7, 21),
+            "ProteinContent": random.uniform(3, 20)
+        }
+        
+        snack_df = pd.DataFrame(snack_attr, index=[0])
+        
+        lunch = self.nutrition_model.transform(lunch_df)
+        breakfast = self.nutrition_model.transform(breakfast_df)
+        dinner = self.nutrition_model.transform(dinner_df)
+        snack = self.nutrition_model.transform(snack_df)
+
+        meals = np.concatenate((breakfast, lunch, dinner, snack), axis=0)
+        meals = np.transpose(meals)
+
+        days = []
+        for i in range(7):
+            day_meals = df.iloc[meals[i]].to_dict(orient="records")
+            days.append(day_meals)
+
+        return days
+
+    def load(self):
+        with open(NUTRITION_MODEL_PATH, "rb") as f:
+            self.nutrition_model = pickle.load(f)
+

requirements.txt

@@ -0,0 +1,8 @@
+Flask>=3.0.0,<4.0.0
+numpy>=1.20.0,<2.0.0
+anakin-language-server>=1.0.0,<2.0.0
+python-dotenv>=1.0.0,<2.0.0
+scikit-learn>=1.2.0,<1.3.0
+black>=24.0.0,<25.0.0
+pandas>=2.2.0,<2.3.0
+python-dotenv>=1.0.0,<2.0.0

resources/datasets/meals.json

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0149719d8294fc792dfe053133b3c9edce076b5d69978b26185e96cfec9a5140
+size 4038577

resources/models/fitness_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:665d34c71c506fa1cdbd8d74b54f6ca84f1b9f5a397a6bb90d608cc699f2a61d
+size 95457799

resources/models/nutrition_model.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9cd0dc84cc9dcc0c985725e8d5cda8d9f9b0571c6c3219bdef2309f177b46ae1
+size 258480

server.py

@@ -0,0 +1,57 @@
+from flask import Flask, request, jsonify
+from dotenv import load_dotenv
+from models.fitness_model import FitnessModel
+from models.nutrition_model import NutritionModel
+
+load_dotenv()
+
+
+fitness_model = FitnessModel.load()
+nutrition_model = NutritionModel()
+nutrition_model.load()
+app = Flask("model-server")
+
+
+@app.get("/")
+def health():
+    return "I'm alive!!"
+
+
+@app.post("/fitness")
+def fitness_predict():
+    paramNames = [
+        "home_or_gym",
+        "level",
+        "goal",
+        "gender",
+        "age",
+        "feedback",
+        "old_weight",
+        "equipments",
+    ]
+
+    params = {}
+    for paramName in paramNames:
+        value = request.json.get(paramName)
+        if value is None:
+            return jsonify({"error": f"{paramName} is missing"}), 400
+        params[paramName] = value
+
+    return jsonify({"result": fitness_model.predict(**params)})
+
+
+@app.post("/nutrition")
+def nutrition_predict():
+    paramNames = ["calories"]
+
+    params = {}
+    for paramName in paramNames:
+        value = request.json.get(paramName)
+        if value is None:
+            return jsonify({"error": f"{paramName} is missing"}), 400
+        params[paramName] = value
+    return jsonify({"result": nutrition_model.generate_plan(**params)})
+
+
+if __name__ == "__main__":
+    app.run()