Optimising Nutrition Reviewed By Grok AI

Alex Laverty
Alex Laverty
March 19, 2025
optimising-nutrition

I’ve been doing some more work on my nutrition optimisation script, the script is now running on a schedule via Github Actions, it now supports a number of diet types All, Vegan, Whole Food Plant Based, Nutrient Dense. Every hour it generates new recipes, it will look at the diet json files and read the exclusion and inclusion lists defined in the JSON file and then randomly select a random number of foods from the Australian Nutrition database csv along with their nutrition data and then the script will do a random number of generations of a genetic algorithm attempting to determine the number of grams per food item required to match as closely as possible to the recommended daily intake of essential vitamins and minerals for a 39 year old male (myself), it then saves the generated recipes in the github repo as JSON and HTML files and generates and index of these recipes and sorts them by score, the lower the score the better and the more the closer it is to matching the micronutrient RDI targets. There is a clean up at the end of the script that deletes recipes with a score that’s higher then the specified value and deletes any recipes over a total of 250 files, so over time the script will continue to generate better recipes and push out the ones with higher scores.

Challenges so far have been the Vegan and WFPB json files, trying to exclude all of the meat items, every time I think I’ve excluded them all I see a vegan recipe generated with a Camel or Emu or some type of fish in it and I need to exclude that item from the list and even more so for Whole Food Plant Based have to exclude the meat and all of the non whole food items like cakes and biscuits and packaged goods etc, so it’s still a work in progress.

I fed the optimising nutrition script into Grok and asked it to review the code it has provided some good suggestions that I will take on board :

review the logic of this script, I am a 39 year old male moderately active and want to generate recipes that meet 100% of my daily recommended intake of the essential vitamins and minerals, determine any issues in this script and any flaws

Grok AI Code Review

I’ll review your script for generating recipes that meet 100% of your daily recommended intake (RDI) of essential nutrients. As a 39-year-old moderately active male, your RDI values in the JSON look generally appropriate (based on standard guidelines like those from the NIH or USDA), though I’ll point out potential issues and suggest improvements. Here’s my analysis of the script’s logic and potential flaws:

Strengths of the Script

  1. Genetic Algorithm Approach: Using a genetic algorithm (GA) to optimize nutrient intake is a solid choice for this complex, multi-variable problem. It effectively balances exploration (randomness) and exploitation (optimization toward RDI targets).
  2. Flexible Nutrient Targets: The script scales RDI targets based on the number of meals, which is practical for daily planning.
  3. Detailed Reporting: The JSON and HTML reports are comprehensive, providing actionable insights into food quantities, nutrient profiles, and optimization performance.
  4. Penalty System: Differentiating penalties for under-RDI, over-RDI, and upper limits (UL), with special handling for water-soluble vs. fat-soluble vitamins, is a thoughtful approach to nutrient safety and balance.
  5. Diet Type Support: Filtering foods based on diet types (e.g., vegan, whole food plant-based) adds versatility.

Issues and Flaws

Here are the key issues I identified in the script, along with their potential impact:

1. Missing Upper Limit (UL) Enforcement

  • Problem: While the script penalizes exceeding ULs (e.g., in _calculate_nutrition_score), it doesn’t strictly enforce them. The penalty for exceeding ULs (over_ul) is randomized between 1.8 and 2.5, which may not be strong enough to prevent unsafe nutrient levels (e.g., Vitamin A at 3000 µg or Zinc at 40 mg).
  • Impact: For a 39-year-old male, exceeding ULs for certain nutrients (e.g., Vitamin A, Iron) could lead to toxicity over time.
  • Fix: Add a hard constraint in evaluate_solution to disqualify solutions exceeding ULs for critical nutrients, or increase the over_ul penalty significantly (e.g., 10x instead of 2.5x).

2. Energy (kJ) Handling is Incomplete

  • Problem: The script treats “Energy with dietary fibre, equated (kJ)” as a nutrient with an RDI (10,878 kJ) and UL (13,389 kJ), but the logic in _calculate_nutrition_score re-reads rdi.json instead of using the passed targets dictionary. This is inconsistent and assumes the JSON file is always available.
  • Impact: For a moderately active 39-year-old male, energy needs are ~10,000-11,000 kJ (2400-2600 kcal), which aligns with your RDI. However, the UL seems arbitrary and may not reflect realistic limits. Plus, the re-reading of JSON could fail if the file is missing.
  • Fix: Use the targets dictionary consistently for all nutrients, including energy. Define a more realistic UL (e.g., 15,000 kJ) based on activity level and safety margins.

3. Food Quantity Range is Limited

  • Problem: In create_solution, food amounts are initialized between 25-100g, and mutations adjust by ±20g. This range is too narrow to meet 100% RDI for a full day in one meal (your number_of_meals=1 setting).
  • Impact: With only 25-100g per food, it’s unlikely to hit high RDIs (e.g., 3400 mg Potassium, 38g Fiber) without including more foods or larger portions.
  • Fix: Increase the range (e.g., 25-500g) and adjust mutation steps proportionally. Alternatively, use a food database with serving size metadata to scale amounts realistically.

4. Nutrient Mapping Mismatch

  • Problem: The nutrient_mapping parameter in optimize_nutrition is a dictionary from rdi.json, but the script uses its keys directly as column names in food_df. However, rdi.json keys (e.g., “Protein (g)”) don’t match typical food database column names (e.g., “PROTEIN”).
  • Impact: This causes warnings ("Column not found") and sets missing nutrients to 0, skewing optimization results.
  • Fix: Create a proper mapping dictionary (e.g., {'Protein (g)': 'PROTEIN', ...}) and pass it to optimize_nutrition. Ensure food_df columns align with this mapping.

5. Single-Meal Assumption

  • Problem: You set number_of_meals=1, aiming for 100% RDI in one meal, but the script’s logic (e.g., scaling RDIs by number_of_meals) assumes multiple meals. This inconsistency could confuse results.
  • Impact: A single meal hitting 100% RDI (e.g., 10,878 kJ, 91g protein) is impractical for most people due to volume and digestion limits.
  • Fix: Either adjust number_of_meals to 3 (typical daily meals) and aim for ~33% RDI per meal, or explicitly design for a single meal with realistic portion constraints (e.g., max 1000g total food).

6. Random Food Selection

  • Problem: The script randomly selects 10-30 foods per run (n_foods = random.randint(10, 30)), which may exclude nutrient-dense options critical for meeting RDIs (e.g., spinach for folate, salmon for omega-3s).
  • Impact: This randomness reduces consistency and may fail to meet 100% RDI for some nutrients by chance.
  • Fix: Pre-filter foods based on nutrient density (e.g., using nutrient_score) before random selection, or increase the pool size (e.g., 50 foods).

7. Lack of Practicality Constraints

  • Problem: The optimization doesn’t consider meal practicality (e.g., taste compatibility, preparation feasibility, or total volume).
  • Impact: You might get a “recipe” with 100g of broccoli, 75g of liver, and 50g of almonds—nutrient-rich but unpalatable or hard to prepare together.
  • Fix: Add constraints like maximum total weight (e.g., 800g), food category diversity (e.g., at least one protein, carb, fat source), or a taste compatibility score.

8. Missing Dependencies and Error Handling

  • Problem: The script assumes the presence of Release 2 - Nutrient file.xlsx, rdi.json, and diet config files (e.g., vegan.json). Missing files or mismatched formats will crash it.
  • Impact: Reduces robustness for real-world use.
  • Fix: Add try-except blocks around file operations and provide default fallbacks or clear error messages.

9. RDI Values for Your Profile

  • Problem: Some RDI values seem off for a 39-year-old moderately active male:
    • Protein (91g): High end; typically 56-70g unless very active or muscular.
    • Vitamin D (15 µg): Matches standard, but many adults need more (20-50 µg) depending on sunlight exposure.
    • Omega-3 (1600 mg): High; typical RDI is 250-500 mg EPA/DHA, though 1600 mg aligns with some heart health guidelines.
  • Impact: Over- or under-targeting nutrients could skew results.
  • Fix: Verify RDIs against authoritative sources (e.g., NIH, IOM) and adjust based on your activity level (e.g., ~0.8g protein/kg body weight).

Suggestions for Improvement

  1. Add a Feasibility Check: After optimization, validate that the total food weight is reasonable (e.g., 500-1000g for one meal) and nutrients are within safe ranges (RDI ≤ intake ≤ UL).
  2. Incorporate Activity Level: Adjust energy and protein RDIs dynamically based on your moderate activity (e.g., use Harris-Benedict equation for BMR + activity factor).
  3. Improve Nutrient Scoring: Weight nutrients by their physiological importance (e.g., prioritize deficiencies like Vitamin D or Iron over excesses of water-soluble vitamins).
  4. Test with Real Data: Run the script with your food database and check if it consistently hits 100% RDI for all nutrients. Tweak population_size and generations if needed.
  5. Add a Recipe Generator: Convert the food list into a practical recipe with preparation instructions (e.g., “Grilled Salmon with Broccoli and Quinoa”).

Example Fix for Key Issues

Here’s a snippet addressing some critical flaws:

# Adjust RDI for activity level (example: 80kg male, moderate activity)
basal_energy = 10 * 80 + 6.25 * 175 - 5 * 39 + 5  # Harris-Benedict BMR (~1700 kcal)
energy_rdi = basal_energy * 1.55  # Moderate activity factor (~2600 kcal = 10878 kJ)
rdi_values["Energy with dietary fibre, equated (kJ)"] = {"rdi": energy_rdi, "ul": energy_rdi * 1.3}

# Enforce UL in evaluate_solution
def evaluate_solution(solution):
    current_nutrients = {nutrient: 0 for nutrient in meal_rdi_targets}
    for food, amount in solution.items():
        for nutrient in meal_rdi_targets:
            if nutrient in foods_df.loc[food]:
                nutrient_per_gram = foods_df.loc[food][nutrient] / foods_df.loc[food]['density']
                current_nutrients[nutrient] += nutrient_per_gram * amount
    # Check ULs
    with open('rdi.json', 'r') as f:
        nutrient_data = json.load(f)
    for nutrient, value in current_nutrients.items():
        ul = nutrient_data.get(nutrient, {}).get('ul', float('inf'))
        if value > ul:
            return float('inf')  # Disqualify solution
    return _calculate_nutrition_score(current_nutrients, meal_rdi_targets, penalties)

# Wider food range
def create_solution():
    return {food: random.uniform(25, 500) for food in available_foods}

Conclusion

Your script is a strong foundation for generating nutrient-optimized recipes, but it needs refinement to ensure safety (UL enforcement), practicality (portion sizes, meal feasibility), and accuracy (nutrient mapping, RDI alignment). With the fixes above, it should better meet your goal of 100% RDI for a 39-year-old moderately active male. Let me know if you’d like help testing it with your food database or refining specific parts!

Alex Laverty
Alex Laverty