Recipe_Site_traffic

import pandas as pd
import numpy as np

# Display the first few rows
print(data.head())
data.replace('NA', None, inplace=True)
# Data validation and cleaning

# Check for missing values
print(data.isnull().sum())

import pandas as pd
import numpy as np

# Display the first few rows
print(data.head())


# Data validation and cleaning

# Check for missing values
print(data.isnull().sum())


# Verify there are no remaining missing values
print(data.isnull().sum())

"""Handle Missing Values in high_traffic Column"""

# deal with rows where 'calories', 'carbohydrate', 'sugar', or 'protein' is missing
data = data.dropna(subset=['calories', 'carbohydrate', 'sugar', 'protein'])


data['high_traffic'] = data['high_traffic'].replace('High', 1).fillna(0).astype(int)

servings_mapping = {
    '4 as a snack': 3,
    '6 as a snack': 5
}
data['servings'] = data['servings'].map(servings_mapping).fillna(0).astype(int)

category_mapping = {
    'Lunch/Snacks': 1,
    'Beverages': 2,
    'Potato': 3,
    'Vegetable': 4,
    'Meat': 5,
    'Chicken': 6,
    'Pork': 7,
    'Dessert': 8,
    'Breakfast': 9,
    'One Dish Meal': 10
}

data['category'] = data['category'].map(category_mapping).fillna(0).astype(int)

# Verify there are no remaining missing values in 'high_traffic'
print(data.isnull().sum())

"""Proceed with Exploratory Data Analysis (EDA)
Now that we have a clean dataset, we can proceed with the EDA.
"""

import matplotlib.pyplot as plt
import seaborn as sns
import numpy as np

# Single variable analysis
plt.figure(figsize=(10, 6))
sns.histplot(data['calories'], bins=30, kde=True)
plt.title('Distribution of Calories')
plt.show()

plt.figure(figsize=(10, 6))
sns.histplot(data['carbohydrate'], bins=30, kde=True)
plt.title('Distribution of Carbohydrates')
plt.show()

# Two variable analysis
plt.figure(figsize=(10, 6))
sns.scatterplot(x='calories', y='protein', hue='high_traffic', data=data)
plt.title('Calories vs Protein colored by High Traffic')
plt.show()

# Summary statistics
print(data.describe())

# Select only numeric columns for correlation matrix
numeric_data = data.select_dtypes(include=[np.number])

# Correlation matrix
plt.figure(figsize=(12, 10))
corr_matrix = numeric_data.corr()
plt.title('Correlation Matrix')
sns.heatmap(corr_matrix, annot=True, fmt='.2f')
plt.show()

# Get the most correlated attributes with high_traffic
corr_with_high_traffic = corr_matrix['high_traffic'].sort_values(ascending=False)
top_corr_with_high_traffic = corr_with_high_traffic[corr_with_high_traffic != 1].head(10)
print("Top 10 most correlated attributes with high_traffic:")
print(top_corr_with_high_traffic)

"""Step 3: Model Development and Evaluation
We'll develop a model to predict whether a recipe will lead to high traffic

Based on the provided correlation results, the most important attributes to study with high_traffic would be:

Carbohydrate: This has the highest positive correlation with high_traffic, indicating that the carbohydrate content of a product is likely an important factor in determining its high_traffic.
Calories: The second highest positive correlation is with calories, suggesting that the calorie content of a product also plays a role in its high_traffic.
Category: The third highest positive correlation is with the category attribute, implying that the product category may influence its high_traffic.
Servings: The fourth highest positive correlation is with the servings attribute, indicating that the number of servings in a product could be related to its high_traffic.
These four attributes (carbohydrate, calories, category, and servings) would be the most important to focus on when studying the factors that influence high_traffic, as they have the strongest positive correlations.

Additionally, while sugar has a negative correlation with high_traffic, it may still be worth investigating further, as it could provide insights into how the sugar content of a product affects its popularity or demand.

In summary, the most important attributes to study in relation to high_traffic would be carbohydrate, calories, category, and servings, as they show the strongest positive correlations based on the provided correlation results.
"""

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split, GridSearchCV
from sklearn.preprocessing import StandardScaler
from sklearn.ensemble import RandomForestClassifier
from sklearn.metrics import precision_recall_curve, f1_score
from imblearn.over_sampling import SMOTE
from xgboost import XGBClassifier

# Example data creation (for demonstration purposes)
# data = pd.read_csv('your_data.csv')

# Fill missing values only in numeric columns with their mean
numeric_cols = data.select_dtypes(include=[np.number]).columns
data[numeric_cols] = data[numeric_cols].fillna(data[numeric_cols].mean())

# Convert 'servings' column to numeric values, coercing errors
data['servings'] = pd.to_numeric(data['servings'], errors='coerce')

# Fill any newly introduced NaNs after coercion
data['servings'].fillna(data['servings'].mean(), inplace=True)

# Verify data types and missing values
print("Data types and missing values:")
print(data.dtypes)
print(data.isnull().sum())

# Ensure that all columns used in the model are numeric
X = data[['calories', 'carbohydrate', 'sugar', 'protein', 'category', 'servings']]
y = data['high_traffic']
print("Feature data types:")
print(X.dtypes)  # This should print all numeric types

print("nnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnnn")
# Split the data with stratification
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42, stratify=y)

print(data['high_traffic'].unique())

# Apply SMOTE to handle class imbalance in the training set
smote = SMOTE(random_state=42)
X_train_res, y_train_res = smote.fit_resample(X_train, y_train)

# Verify class distribution after SMOTE
print("Class distribution in training set after SMOTE:")
print(y_train_res.value_counts())

# Standardize the features
scaler = StandardScaler()
X_train_res = scaler.fit_transform(X_train_res)
X_test = scaler.transform(X_test)

# Hyperparameter tuning for Random Forest Classifier ***********
param_grid = {
    'n_estimators': [100, 200, 300],
    'max_depth': [5, 10, 15],
    'min_samples_split': [2, 5, 10],
    'min_samples_leaf': [1, 2, 4]
}

grid_search = GridSearchCV(RandomForestClassifier(random_state=42), param_grid, cv=5, scoring='f1')
grid_search.fit(X_train_res, y_train_res)
best_model = grid_search.best_estimator_

# Evaluate the best model
y_pred_best = best_model.predict(X_test)
precision_best, recall_best, _ = precision_recall_curve(y_test, y_pred_best)
f1_best = f1_score(y_test, y_pred_best)

# Ensure target_recall is defined
target_recall = 0.8  # Example value

idx_best = np.argmax(recall_best >= target_recall)
precision_at_80_recall_best = precision_best[idx_best]

# Fit an ensemble model (XGBoost)****************
ensemble_model = XGBClassifier(random_state=42)
ensemble_model.fit(X_train_res, y_train_res)

# Evaluate the ensemble model
y_pred_ensemble = ensemble_model.predict(X_test)
precision_ensemble, recall_ensemble, _ = precision_recall_curve(y_test, y_pred_ensemble)
f1_ensemble = f1_score(y_test, y_pred_ensemble)
idx_ensemble = np.argmax(recall_ensemble >= target_recall)
precision_at_80_recall_ensemble = precision_ensemble[idx_ensemble]

print("Best Random Forest Classifier evaluation:")
print(f"Precision at 80% recall: {precision_at_80_recall_best:.2f}")
print(f"F1-score: {f1_best:.2f}")

print("Ensemble model (XGBoost) evaluation:")
print(f"Precision at 80% recall: {precision_at_80_recall_ensemble:.2f}")
print(f"F1-score: {f1_ensemble:.2f}")

"""Step 4: Business Metric Definition
Define a metric for the business to monitor and estimate the initial value(s) for the metric based on the current data.
"""

from sklearn.metrics import precision_score
print("X_test shape:", X_test.shape)
print("y_test shape:", y_test.shape)
# Assuming you have a trained model
# Generate predictions for the test data
y_pred = best_model.predict(X_test)
y_pred_comp = ensemble_model.predict(X_test)

print(y_test.shape)
print(y_pred.shape)

# Calculate precision for both models
precision_baseline = precision_score(y_test, y_pred)
precision_comparison = precision_score(y_test, y_pred_comp)

print("Baseline Model Precision:", precision_baseline)
print("Comparison Model Precision:", precision_comparison)

# Recommendation: Use the model with higher precision

"""Step 5: Final Summary and Recommendations
Prepare a final summary including recommendations based on the analysis.
"""

from sklearn.metrics import precision_score, accuracy_score

summary = """
### Final Summary and Recommendations

**Data Validation and Cleaning:**
- Missing values in numeric columns were filled with the mean of each column.
- Rows with missing 'high_traffic' values were dropped.

**Exploratory Data Analysis (EDA):**
- The distribution of calories and carbohydrates was analyzed.
- A scatter plot of calories vs protein colored by high traffic was created.
- Summary statistics and a correlation matrix were produced.

**Model Development and Evaluation:**
- A Random Forest classifier was used as the baseline model with an accuracy of {baseline_accuracy:.2f}.
- A Logistic Regression model was used for comparison with an accuracy of {comparison_accuracy:.2f}.
- The precision for predicting high traffic recipes was {precision_baseline:.2f} for the baseline model and {precision_comparison:.2f} for the comparison model.

**Business Metric Definition:**
- Precision for high traffic prediction is recommended as the key metric.
- The initial value for the precision metric is {precision_baseline:.2f} for the baseline model.

**Recommendations:**
- Use the Random Forest classifier as it showed higher precision in predicting high traffic recipes.
- Regularly monitor the precision metric to ensure the model's performance remains high.
- Consider collecting more data or additional features to improve the model further.
"""

print(summary.format(
    baseline_accuracy=accuracy_score(y_test, y_pred),
    comparison_accuracy=accuracy_score(y_test, y_pred_comp),
    precision_baseline=precision_baseline,
    precision_comparison=precision_comparison
))