Spaces:
Runtime error
Runtime error
File size: 15,446 Bytes
27132ea | 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 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 173 174 175 176 177 178 179 180 181 182 183 184 185 186 187 188 189 190 191 192 193 194 195 196 197 198 199 200 201 202 203 204 205 206 207 208 209 210 211 212 213 214 215 216 217 218 219 220 221 222 223 224 225 226 227 228 229 230 231 232 233 234 235 236 237 238 239 240 241 242 243 244 245 246 247 248 249 250 251 252 253 254 255 256 257 258 259 260 261 262 263 264 265 266 267 268 269 270 271 272 273 274 275 276 277 278 279 280 281 282 283 284 285 286 287 288 289 290 291 292 293 294 295 296 297 298 299 300 301 302 303 304 305 306 307 308 309 310 311 312 313 314 315 316 317 318 319 320 321 322 323 324 325 326 327 328 329 330 331 332 333 334 335 336 337 338 339 340 341 342 343 344 345 346 347 | # Download latest version
path = kagglehub.dataset_download("irkaal/foodcom-recipes-and-reviews") # Changed this line to only include the dataset handle
# Access the recipes.csv file within the downloaded dataset
recipes_csv_path = os.path.join(path, "recipes.csv")
dataset_dir = '/root/.cache/kagglehub/datasets/irkaal/foodcom-recipes-and-reviews/versions/2/' # Changed to the directory containing recipes.csv
# Find the CSV file within the directory
for filename in os.listdir(dataset_dir):
if filename.endswith('.csv'):
csv_file = os.path.join(dataset_dir, filename)
break
# Load the dataset from the identified CSV file
data = pd.read_csv(recipes_csv_path)
df = data.copy()
# Select and reorder columns in the dataset for further analysis
selected_columns = ['RecipeId', 'Calories', 'FatContent', 'SaturatedFatContent',
'CholesterolContent', 'SodiumContent', 'CarbohydrateContent',
'FiberContent', 'SugarContent', 'ProteinContent']
# Check if all selected columns exist in the DataFrame
missing_columns = [col for col in selected_columns if col not in df.columns]
if missing_columns:
print(f"The following columns are not in the DataFrame: {missing_columns}")
# Option 1: Raise an error to stop execution
# raise KeyError(f"Missing columns: {missing_columns}")
# Option 2: Select only the available columns
selected_columns = [col for col in selected_columns if col in df.columns]
print(f"Proceeding with available columns: {selected_columns}")
# Apply the selected columns to the DataFrame
df = df[selected_columns]
# Display summary statistics of the DataFrame, including specified percentiles
# Transpose the result for better readability
summary_statistics = df.describe(percentiles=[0.05, 0.1, 0.25, 0.5, 0.75, 0.9, 0.95]).T
# Define the columns to filter based on the 95th percentile
# Ensure these column names exactly match the names in your DataFrame
# Check for case sensitivity and typos
filter_columns = ['Calories', 'FatContent', 'SaturatedFatContent',
'CholesterolContent', 'SodiumContent',
'CarbohydrateContent', 'FiberContent',
'SugarContent', 'ProteinContent']
# Before calculating quantiles, check if the columns exist in the DataFrame:
for column in filter_columns:
if column not in df.columns:
print(f"Column '{column}' not found in DataFrame. Please check the column names.")
# You might want to raise an exception or handle the missing column in a way that suits your needs.
# Compute the 95th percentile values for each specified column
percentile_95_thresholds = df[filter_columns].quantile(0.95)
# Apply filtering to the DataFrame based on the 95th percentile values
filtered_df = df[(df[filter_columns] <= percentile_95_thresholds).all(axis=1)]
# Drop the 'RecipeId' column from the DataFrame and assign the result to X
X = df.drop(columns=['RecipeId'])
# Assign the 'RecipeId' column to y
y = df['RecipeId']
# Initialize the MinMaxScaler
scaler = MinMaxScaler()
# Fit the scaler to X and transform it
X_scaled = scaler.fit_transform(X)
# Split the already scaled data into training and evaluation sets
X_train_scaled, X_eval_scaled = train_test_split(X_scaled, train_size=0.8, random_state=42)
# Neural Network Model Architecture
num_features = X_train_scaled.shape[1] # Number of features in the input data
# Define the autoencoder model
model = Sequential([
# Encoder
Dense(256, input_shape=(num_features,)), # Input layer with 256 neurons
LeakyReLU(), # Activation function with a small slope for negative inputs
Dropout(0.2), # Dropout layer with 20% dropout rate to prevent overfitting
Dense(128), # Hidden layer with 128 neurons
LeakyReLU(), # Activation function
Dropout(0.2), # Dropout layer
Dense(64), # Hidden layer with 64 neurons
LeakyReLU(), # Activation function
Dropout(0.2), # Dropout layer
# Bottleneck
Dense(32), # Bottleneck layer with 32 neurons, this is the compressed representation of the input data
# The bottleneck layer reduces the dimensionality of the input data, capturing essential features
# Decoder
Dense(64), # Hidden layer in the decoder with 64 neurons
LeakyReLU(), # Activation function
Dropout(0.2), # Dropout layer
Dense(128), # Hidden layer with 128 neurons
LeakyReLU(), # Activation function
Dropout(0.2), # Dropout layer
Dense(256), # Hidden layer with 256 neurons
LeakyReLU(), # Activation function
# Output layer
Dense(num_features, activation='linear') # Output layer with the same number of neurons as features, linear activation
# The linear activation function in the output layer allows the network to reconstruct the input data directly
])
# Define the optimizer with a learning rate
optimizer = Adam(learning_rate=0.0001)
# Compile the model
model.compile(optimizer=optimizer,
loss='mse', # Mean Squared Error for regression
metrics=['mae']) # Mean Absolute Error for regression evaluation
# Fit the model with scaled training data as both input and target
training_history = model.fit(X_train_scaled, X_train_scaled,
validation_data=(X_eval_scaled, X_eval_scaled),
epochs=10)
# Extract validation loss from the training history
validation_loss = training_history.history['val_loss']
# Predict latent features using the trained model
predicted_latent_features = model.predict(X_scaled)
# Manual calculation of cosine similarity
# Compute the Dot Product:
# This calculates the dot product between each pair of latent feature vectors.
# The result is a matrix where each entry represents the dot product (or similarity) between two feature vectors.
similarity_matrix = np.dot(predicted_latent_features, predicted_latent_features.T)
# Calculate the Norms:
# The norm (or magnitude) of each latent feature vector is calculated.
# 'axis=1' indicates that the norm is computed for each row (each feature vector).
# 'keepdims=True' keeps the dimensions of the output the same for broadcasting purposes.
norms = np.linalg.norm(predicted_latent_features, axis=1, keepdims=True)
# Normalize the Similarity Matrix:
# Each entry in the similarity matrix is divided by the product of the norms of the vectors being compared.
# This normalizes the similarity scores to cosine similarity, which ranges from -1 to 1.
similarity_matrix /= np.dot(norms, norms.T)
similarity_matrix_sklearn = cosine_similarity(predicted_latent_features)
# Initialize a dictionary to store recommendations
recommendations_dict = {}
# Iterate over each item in the dataset
for item_index in range(len(X_scaled)):
# Sort indices based on similarity in descending order
sorted_indices = similarity_matrix[item_index].argsort()[::-1]
# Create a list of tuples with similarity scores and indices, excluding the item itself
similar_items_list = [(similarity_matrix[item_index][idx], idx) for idx in sorted_indices if idx != item_index]
# Store the list of similar items for the current item in the recommendations dictionary
recommendations_dict[item_index] = similar_items_list
# Calculate Basal Metabolic Rate (BMR)
def compute_bmr(gender, body_weight, body_height, age):
"""
Calculate Basal Metabolic Rate (BMR) based on gender, body weight, body height, and age.
Args:
gender (str): Gender of the individual ('male' or 'female').
body_weight (float): Body weight of the individual in kilograms.
body_height (float): Body height of the individual in centimeters.
age (int): Age of the individual in years.
Return:
float: Basal Metabolic Rate (BMR) value.
"""
if gender == 'male':
# For Men: BMR = (10 x weight in kg) + (6.25 x height in cm) - (5 x age in years) + 5
bmr_value = 10 * body_weight + 6.25 * body_height - 5 * age + 5
elif gender == 'female':
# For Women: BMR = (10 x weight in kg) + (6.25 x height in cm) - (5 x age in years) - 161
bmr_value = 10 * body_weight + 6.25 * body_height - 5 * age - 161
else:
raise ValueError("Invalid gender. Please choose 'male' or 'female'.")
return bmr_value
def compute_daily_caloric_intake(bmr, activity_intensity, objective):
"""
Calculate total daily caloric intake based on Basal Metabolic Rate (BMR), activity level, and personal goal.
Args:
bmr (float): Basal Metabolic Rate (BMR) value.
activity_intensity (str): Activity level of the individual ('sedentary', 'lightly_active', 'moderately_active', 'very_active', 'extra_active').
objective (str): Personal goal of the individual ('weight_loss', 'muscle_gain', 'health_maintenance').
Return:
int: Total daily caloric intake.
"""
# Define activity multipliers based on intensity
intensity_multipliers = {
'sedentary': 1.2,
'lightly_active': 1.375,
'moderately_active': 1.55,
'very_active': 1.725,
'extra_active': 1.9
}
# Define goal adjustments based on objective
objective_adjustments = {
'weight_loss': 0.8,
'muscle_gain': 1.2,
'health_maintenance': 1
}
# Calculate maintenance calories based on activity intensity
maintenance_calories = bmr * intensity_multipliers[activity_intensity]
# Adjust maintenance calories based on personal objective
total_caloric_intake = maintenance_calories * objective_adjustments[objective]
return round(total_caloric_intake)
def suggest_recipes(category, body_weight, body_height, age, activity_intensity, objective):
"""
Generate food recommendations based on the user's profile and dietary goals.
Args:
category (str): Gender category of the user ('male' or 'female').
body_weight (float): Weight of the user in kilograms.
body_height (float): Height of the user in centimeters.
age (int): Age of the user in years.
activity_intensity (str): Physical activity level of the user ('sedentary', 'lightly_active', 'moderately_active', 'very_active', 'extra_active').
objective (str): Dietary objective of the user ('weight_loss', 'muscle_gain', 'health_maintenance').
Return:
pd.DataFrame: Recommended recipes including name and calorie content.
"""
# Calculate the Basal Metabolic Rate (BMR) for the user
bmr = compute_bmr(category, body_weight, body_height, age)
# Calculate the total daily caloric intake based on activity intensity and dietary objective
total_calories = compute_daily_caloric_intake(bmr, activity_intensity, objective)
# Prepare input data for the model with desired total calories
user_input_features = np.array([[total_calories, 0, 0, 0, 0, 0, 0, 0, 0]])
# Scale the input data to match the model's training scale
scaled_input_features = scaler.transform(user_input_features)
# Predict latent features for the input data
predicted_latent_features = model.predict(scaled_input_features)
# Find the index with the highest prediction probability
top_prediction_index = np.argmax(predicted_latent_features.flatten())
# Retrieve recommended recipes based on the highest prediction
similar_recipe_indices = np.array(recommendations_dict[top_prediction_index])
recommended_recipes = data.iloc[similar_recipe_indices[:, 1].astype(int)][['Name', 'Calories']]
return recommended_recipes.head(5)
# Define the input values
user_category = 'male'
user_body_weight = 80 # in kilograms
user_body_height = 170 # in centimeters
user_age = 50 # in years
user_activity_intensity = 'moderately_active'
user_objective = 'weight_loss'
# Generate suggested recipes
suggested_recipes = suggest_recipes(
category=user_category,
body_weight=user_body_weight,
body_height=user_body_height,
age=user_age,
activity_intensity=user_activity_intensity,
objective=user_objective
)
# Calculate required daily calories
required_calories = compute_daily_caloric_intake(
bmr=compute_bmr(user_category, user_body_weight, user_body_height, user_age),
activity_intensity=user_activity_intensity,
objective=user_objective
)
# Function to calculate BMR
def compute_bmr(gender, body_weight, body_height, age):
if gender == 'male':
return 10 * body_weight + 6.25 * body_height - 5 * age + 5
elif gender == 'female':
return 10 * body_weight + 6.25 * body_height - 5 * age - 161
else:
raise ValueError("Invalid gender. Choose 'male' or 'female'.")
# Function to calculate daily caloric intake
def compute_daily_caloric_intake(bmr, activity_intensity, objective):
intensity_multipliers = {
'sedentary': 1.2,
'lightly_active': 1.375,
'moderately_active': 1.55,
'very_active': 1.725,
'extra_active': 1.9
}
objective_adjustments = {
'weight_loss': 0.8,
'muscle_gain': 1.2,
'health_maintenance': 1
}
maintenance_calories = bmr * intensity_multipliers[activity_intensity]
return round(maintenance_calories * objective_adjustments[objective])
# Function to suggest recipes
def suggest_recipes(category, body_weight, body_height, age, activity_intensity, objective):
# Calculate BMR and daily caloric intake
bmr = compute_bmr(category, body_weight, body_height, age)
total_calories = compute_daily_caloric_intake(bmr, activity_intensity, objective)
# Prepare input for the model
user_input_features = np.array([[total_calories, 0, 0, 0, 0, 0, 0, 0, 0]])
scaled_input_features = scaler.transform(user_input_features)
# Predict latent features
predicted_latent_features = model.predict(scaled_input_features)
# Find recommendations
top_prediction_index = np.argmax(predicted_latent_features.flatten())
similar_recipe_indices = np.array(recommendations_dict[top_prediction_index])
recommended_recipes = data.iloc[similar_recipe_indices[:, 1].astype(int)][['Name', 'Calories']]
# Return the top 5 suggested recipes
return recommended_recipes.head(5).to_dict(orient='records')
# Define the Gradio interface function
def gradio_diet_recommender(category, body_weight, body_height, age, activity_intensity, objective):
try:
recommendations = suggest_recipes(category, body_weight, body_height, age, activity_intensity, objective)
result = f"Top Recommended Recipes:\n\n"
for idx, recipe in enumerate(recommendations):
result += f"{idx + 1}. {recipe['Name']} - {recipe['Calories']} Calories\n"
return result
except Exception as e:
return str(e)
# Create the Gradio interface
interface = gr.Interface(
fn=gradio_diet_recommender,
inputs=[
gr.Radio(choices=['male', 'female'], label="Gender"),
gr.Number(label="Body Weight (kg)"),
gr.Number(label="Body Height (cm)"),
gr.Number(label="Age (years)"),
gr.Dropdown(choices=['sedentary', 'lightly_active', 'moderately_active', 'very_active', 'extra_active'], label="Activity Intensity"),
gr.Dropdown(choices=['weight_loss', 'muscle_gain', 'health_maintenance'], label="Objective")
],
outputs="text",
title="Diet Recommender System",
description="Provide your details to receive a customized diet plan."
)
# Launch the Gradio app
interface.launch() |