remove models server code

.env.example

@@ -1,6 +1,5 @@
 PORT =
-
 DB_URI =
-
 JWT_SECRET =
-JWT_EXPIRES_IN =
+JWT_EXPIRES_IN =
+MODELS_SERVER_URL=

Dockerfile

@@ -1,9 +1,6 @@
 # Use the official Node.js v18 image as the base image
 FROM node:18
 
-# install python3 and pip
-RUN apt-get update && apt-get install -y python3 python3-pip
-
 # Set the working directory inside the container
 WORKDIR /app
 
@@ -27,12 +24,10 @@ ENV PORT=7860
 ARG JWT_SECRET
 ARG JWT_EXPIRES_IN
 ARG DB_URI
-
-# install python dependencies
-RUN pip3 install -r requirements.txt --break-system-packages
+ARG MODELS_SERVER_URL
 
 # Expose the port on which your application will run
 EXPOSE $PORT
 
 # Command to run the application
-CMD ["./run-script.sh"]
+CMD ["npm", "run", "start:dev"]

models-server/models/fitness_model.py

@@ -1,259 +0,0 @@
-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-server/models/nutrition_model.py

@@ -1,96 +0,0 @@
-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, "../../src/resources/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)
-

models-server/resources/models/fitness_model.pkl

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

models-server/resources/models/nutrition_model.pkl

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

models-server/server.py

@@ -1,62 +0,0 @@
-from flask import Flask, request, jsonify
-from dotenv import load_dotenv
-import os
-from models.fitness_model import FitnessModel
-from models.nutrition_model import NutritionModel
-
-load_dotenv()
-
-
-HOST = os.getenv("MODELS_HOST") or "127.0.0.1"
-PORT = os.getenv("MODELS_PORT") or "3030"
-
-
-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(host=HOST, port=PORT, debug=True)

requirements.txt

@@ -1,7 +0,0 @@
-Flask>=3.0.0,<4.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

run-script.sh

@@ -1,4 +0,0 @@
-#!/bin/sh
-
-python models-server/server.py &
-npm run start:dev

src/configs/config.ts

@@ -29,5 +29,5 @@ export const config: Config = {
     expiresIn: Env.get("JWT_EXPIRES_IN").toString(),
   },
   saltRounds: Env.get("SALT_ROUNDS", 5).toNumber(),
-  modelsServerUrl: `${Env.get("MODELS_HOST", 'http://127.0.0.1').toString()}:${Env.get("MODELS_PORT", '3030').toString()}`,
+  modelsServerUrl: Env.get("MODELS_SERVER_URL").toString(),
 };