做程序自动把食物照片识别热量，给出饮食建议，颠覆减肥靠瞎饿。

食物热量智能分析系统 - 颠覆传统"瞎饿"减肥法

📋 项目概述

基于计算机视觉和深度学习的智能饮食管理系统，通过拍照即可获得精确的热量分析和个性化饮食建议，让减肥从"痛苦挨饿"变为"科学饮食"。

🎯 实际应用场景

场景一：大学生减脂餐管理

小李是大三学生，想减肥但不知道食堂饭菜热量。用手机拍一下红烧肉盖饭，系统立即显示：约650大卡，蛋白质25g，脂肪30g，建议搭配一份凉拌黄瓜，减少半碗米饭。

场景二：健身人群营养追踪

小王每天训练后吃蛋白粉+鸡胸肉，系统识别后分析蛋白质摄入是否达标，提醒补充复合维生素，避免只关注热量忽略营养均衡。

场景三：上班族健康午餐

张女士经常点外卖，系统识别麻辣烫后提示钠含量偏高，建议多喝水，下次选择清汤底，并推荐办公室可备的健康零食清单。

😫 行业痛点分析

痛点 现状 后果

热量估算困难 依赖包装标签或粗略估算 减肥计划严重偏差

营养结构失衡 只关注卡路里，忽略蛋白质/纤维 越减越虚，代谢下降

记录繁琐耗时 手动输入食物名称和重量 90%的人坚持不超1周

缺乏个性化 一刀切的减肥方案 易反弹，难以持续

🧠 核心逻辑架构

┌─────────────────────────────────────────────────────────────┐

│ 输入层 │

│ 食物照片采集 │

└─────────────────────────────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────────────────┐

│ 预处理层 │

│ 图像增强 + 目标检测 │

└─────────────────────────────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────────────────┐

│ 识别层 │

│ CNN分类模型 (ResNet50) │

└─────────────────────────────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────────────────┐

│ 数据层 │

│ 食物数据库查询 (热量/营养) │

└─────────────────────────────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────────────────┐

│ 分析层 │

│ 热量计算 + 营养评估 + BMI匹配 │

└─────────────────────────────────────────────────────────────┘

↓

┌─────────────────────────────────────────────────────────────┐

│ 输出层 │

│ 可视化报告 + 个性化建议 │

└─────────────────────────────────────────────────────────────┘

💻 核心代码实现

项目结构

food_calorie_analyzer/

├── main.py # 主程序入口

├── config.py # 配置文件

├── requirements.txt # 依赖包

├── README.md # 项目说明

├── data/

│ ├── food_database.json # 食物营养数据库

│ └── model_weights.h5 # 预训练模型权重

├── modules/

│ ├── __init__.py

│ ├── image_processor.py # 图像处理模块

│ ├── food_recognizer.py # 食物识别模块

│ ├── nutrition_calculator.py # 营养计算模块

│ └── diet_advisor.py # 饮食建议模块

└── utils/

├── __init__.py

└── helpers.py # 工具函数

1. 配置文件 (config.py)

"""

配置文件 - 集中管理所有配置参数

作者: AI Assistant

版本: 1.0.0

"""

import os

# ==================== 路径配置 ====================

BASE_DIR = os.path.dirname(os.path.abspath(__file__))

DATA_DIR = os.path.join(BASE_DIR, 'data')

MODEL_PATH = os.path.join(DATA_DIR, 'model_weights.h5')

FOOD_DB_PATH = os.path.join(DATA_DIR, 'food_database.json')

# ==================== 模型配置 ====================

IMAGE_SIZE = (224, 224) # ResNet50标准输入尺寸

BATCH_SIZE = 32

NUM_CLASSES = 100 # 支持识别的食物种类数

CONFIDENCE_THRESHOLD = 0.7 # 识别置信度阈值

# ==================== 用户配置 ====================

DEFAULT_DAILY_CALORIES = {

'sedentary': 1800, # 久坐(办公室)

'light': 2000, # 轻度活动(每周运动1-3次)

'moderate': 2400, # 中度活动(每周运动3-5次)

'active': 2800 # 高度活动(每周运动6-7次)

}

# ==================== 营养目标比例 ====================

NUTRITION_RATIOS = {

'protein': 0.25, # 蛋白质占比

'carbs': 0.50, # 碳水化合物占比

'fat': 0.25, # 脂肪占比

'fiber_min': 25, # 最小膳食纤维(g)

'sugar_max': 50 # 最大添加糖(g)

}

2. 图像处理模块 (modules/image_processor.py)

"""

图像处理模块 - 负责食物照片的预处理和增强

核心功能：图像加载、尺寸调整、增强处理、批量处理

"""

import cv2

import numpy as np

from PIL import Image

import tensorflow as tf

from typing import Tuple, List, Optional

import logging

# 配置日志

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(__name__)

class ImageProcessor:

"""

图像处理器类

该类封装了食物照片的所有预处理操作，确保输入模型的图像质量一致。

Attributes:

target_size: 目标图像尺寸 (height, width)

normalize: 是否进行归一化处理

"""

def __init__(self, target_size: Tuple[int, int] = (224, 224),

normalize: bool = True):

"""

初始化图像处理器

Args:

target_size: 目标图像尺寸，默认(224, 224)适配ResNet50

normalize: 是否将像素值归一化到[0,1]

"""

self.target_size = target_size

self.normalize = normalize

logger.info(f"图像处理器初始化完成，目标尺寸: {target_size}")

def load_image(self, image_path: str) -> Optional[np.ndarray]:

"""

加载图像文件

Args:

image_path: 图像文件路径

Returns:

numpy数组格式的图像，加载失败返回None

Raises:

FileNotFoundError: 文件不存在时抛出

ValueError: 图像格式不支持时抛出

"""

if not os.path.exists(image_path):

raise FileNotFoundError(f"图像文件不存在: {image_path}")

try:

# 使用OpenCV读取图像，保留原始色彩空间

image = cv2.imread(image_path)

if image is None:

raise ValueError(f"无法读取图像文件: {image_path}")

# BGR转RGB (OpenCV默认BGR格式)

image = cv2.cvtColor(image, cv2.COLOR_BGR2RGB)

logger.debug(f"成功加载图像: {image_path}, 形状: {image.shape}")

return image

except Exception as e:

logger.error(f"加载图像失败: {e}")

return None

def preprocess_single(self, image: np.ndarray) -> np.ndarray:

"""

单张图像预处理流水线

处理流程: 尺寸调整 → 中心裁剪 → 归一化 → 维度扩展

Args:

image: 原始图像数组 (H, W, C)

Returns:

预处理后的图像数组 (1, H, W, C)，适合模型输入

"""

# Step 1: 调整尺寸 (保持宽高比，不足部分填充)

processed = self._resize_with_padding(image)

# Step 2: 数据增强 (训练时启用，推理时可选)

processed = self._apply_augmentation(processed, training=False)

# Step 3: 像素值归一化 [0, 255] → [0, 1]

if self.normalize:

processed = processed.astype(np.float32) / 255.0

# Step 4: 添加批次维度

processed = np.expand_dims(processed, axis=0)

logger.debug(f"预处理完成，输出形状: {processed.shape}")

return processed

def _resize_with_padding(self, image: np.ndarray) -> np.ndarray:

"""

保持宽高比的尺寸调整 + 填充

使用letterbox方式处理，避免图像变形影响识别精度

Args:

image: 原始图像

Returns:

调整后的图像

"""

old_height, old_width = image.shape[:2]

target_height, target_width = self.target_size

# 计算缩放比例，取较小值保证完整显示

scale = min(target_width / old_width, target_height / old_height)

# 计算新尺寸

new_width = int(old_width * scale)

new_height = int(old_height * scale)

# 缩放图像

resized = cv2.resize(image, (new_width, new_height),

interpolation=cv2.INTER_LINEAR)

# 创建目标画布并居中放置

canvas = np.zeros((target_height, target_width, 3), dtype=np.uint8)

# 计算偏移量，使图像居中

x_offset = (target_width - new_width) // 2

y_offset = (target_height - new_height) // 2

# 将缩放后的图像放置到画布中心

canvas[y_offset:y_offset + new_height,

x_offset:x_offset + new_width] = resized

return canvas

def _apply_augmentation(self, image: np.ndarray,

training: bool = False) -> np.ndarray:

"""

数据增强处理

训练时应用随机增强提升模型泛化能力

推理时不应用随机变换，保证结果一致性

Args:

image: 输入图像

training: 是否为训练模式

Returns:

增强后的图像

"""

if not training:

return image

# 随机水平翻转 (概率50%)

if np.random.random() > 0.5:

image = cv2.flip(image, 1)

# 随机亮度调整 (±10%)

brightness_delta = np.random.uniform(-0.1, 0.1)

image = np.clip(image * (1 + brightness_delta), 0, 255).astype(np.uint8)

# 随机对比度调整 (±10%)

contrast_factor = np.random.uniform(0.9, 1.1)

mean_val = np.mean(image)

image = np.clip((image - mean_val) * contrast_factor + mean_val,

0, 255).astype(np.uint8)

return image

def preprocess_batch(self, image_paths: List[str]) -> Tuple[np.ndarray, List[str]]:

"""

批量图像预处理

高效处理多张图像，适用于批量预测场景

Args:

image_paths: 图像路径列表

Returns:

(预处理后的图像数组, 有效图像路径列表)

"""

valid_images = []

valid_paths = []

for path in image_paths:

image = self.load_image(path)

if image is not None:

processed = self.preprocess_single(image)

valid_images.append(processed)

valid_paths.append(path)

if not valid_images:

raise ValueError("批量处理失败，没有有效的图像")

# 堆叠为批次张量

batch = np.vstack(valid_images)

logger.info(f"批量预处理完成，共{len(valid_paths)}张图像")

return batch, valid_paths

# ==================== 使用示例 ====================

if __name__ == "__main__":

# 创建处理器实例

processor = ImageProcessor(target_size=(224, 224))

# 测试单张图像处理

test_image_path = "test_food.jpg"

if os.path.exists(test_image_path):

original = processor.load_image(test_image_path)

processed = processor.preprocess_single(original)

print(f"原始形状: {original.shape} → 处理后形状: {processed.shape}")

3. 食物识别模块 (modules/food_recognizer.py)

"""

食物识别模块 - 基于深度学习的图像分类器

核心功能：加载预训练模型、食物类别预测、置信度评估

"""

import json

import numpy as np

import tensorflow as tf

from typing import Dict, List, Tuple, Optional

from datetime import datetime

import logging

# 配置日志

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(__name__)

class FoodRecognizer:

"""

食物识别器类

基于ResNet50的迁移学习模型，专门针对100种常见食物进行微调。

Attributes:

model: TensorFlow/Keras模型实例

class_names: 食物类别名称列表

confidence_threshold: 预测置信度阈值

"""

def __init__(self, model_path: str,

class_names_path: str,

confidence_threshold: float = 0.7):

"""

初始化食物识别器

Args:

model_path: 预训练模型权重路径

class_names_path: 食物类别名称JSON文件路径

confidence_threshold: 置信度阈值，低于此值的结果将被过滤

"""

self.confidence_threshold = confidence_threshold

self.model = None

self.class_names = []

# 加载类别名称

self._load_class_names(class_names_path)

# 构建并加载模型

self._build_and_load_model(model_path)

logger.info(f"食物识别器初始化完成，支持{len(self.class_names)}种食物")

def _load_class_names(self, path: str) -> None:

"""

加载食物类别名称

Args:

path: JSON文件路径

"""

try:

with open(path, 'r', encoding='utf-8') as f:

data = json.load(f)

self.class_names = data.get('classes', [])

logger.info(f"成功加载{len(self.class_names)}个食物类别")

except Exception as e:

logger.warning(f"加载类别名称失败，使用默认类别: {e}")

# 使用默认类别作为后备

self.class_names = [

'apple', 'banana', 'orange', 'rice', 'noodle',

'chicken_breast', 'pork_belly', 'beef_steak',

'tomato_egg', 'mapo_tofu', 'kung_pao_chicken'

]

def _build_and_load_model(self, model_path: str) -> None:

"""

构建模型架构并加载预训练权重

采用ResNet50作为骨干网络，顶层替换为自定义分类头：

- GlobalAveragePooling2D

- Dense(512, ReLU)

- Dropout(0.5)

- Dense(num_classes, Softmax)

Args:

model_path: 模型权重文件路径

"""

try:

# 构建基础模型 (不包含顶层)

base_model = tf.keras.applications.ResNet50(

weights=None, # 不使用ImageNet预训练权重

include_top=False,

input_shape=(224, 224, 3)

)

# 冻结骨干网络的前面层（可选，用于迁移学习）

for layer in base_model.layers[:-20]:

layer.trainable = False

# 构建自定义分类头

x = base_model.output

x = tf.keras.layers.GlobalAveragePooling2D()(x)

x = tf.keras.layers.Dense(512, activation='relu')(x)

x = tf.keras.layers.Dropout(0.5)(x)

predictions = tf.keras.layers.Dense(

len(self.class_names),

activation='softmax'

)(x)

# 组装完整模型

self.model = tf.keras.Model(inputs=base_model.input, outputs=predictions)

# 加载训练好的权重

self.model.load_weights(model_path)

# 编译模型（推理模式下主要用于warmup）

self.model.compile(

optimizer='adam',

loss='categorical_crossentropy',

metrics=['accuracy']

)

logger.info(f"模型加载成功，参数量: {self.model.count_params():,}")

except Exception as e:

logger.error(f"模型加载失败: {e}")

raise RuntimeError(f"无法加载模型权重: {model_path}")

def predict(self, preprocessed_image: np.ndarray,

top_k: int = 5) -> List[Dict]:

"""

对预处理后的图像进行食物识别

Args:

preprocessed_image: 预处理后的图像数组 (1, H, W, C)

top_k: 返回置信度最高的前K个结果

Returns:

识别结果列表，每项包含食物名称和置信度

示例: [{'food_name': 'apple', 'confidence': 0.95}, ...]

"""

if self.model is None:

raise RuntimeError("模型未正确初始化")

# 执行预测

start_time = datetime.now()

predictions = self.model.predict(preprocessed_image, verbose=0)

inference_time = (datetime.now() - start_time).total_seconds() * 1000

# 解析预测结果

results = []

for i in range(min(top_k, len(self.class_names))):

confidence = float(predictions[0][i])

if confidence >= self.confidence_threshold:

results.append({

'food_name': self.class_names[i],

'confidence': round(confidence, 4),

'rank': i + 1

})

# 按置信度降序排序

results.sort(key=lambda x: x['confidence'], reverse=True)

logger.debug(f"预测完成，耗时{inference_time:.2f}ms，"

f"最高置信度: {results[0]['confidence'] if results else 0}")

return results

def predict_from_path(self, image_path: str,

top_k: int = 5) -> List[Dict]:

"""

从图像路径直接进行预测（便捷方法）

Args:

image_path: 图像文件路径

top_k: 返回前K个结果

Returns:

识别结果列表

"""

from .image_processor import ImageProcessor

processor = ImageProcessor()

image = processor.load_image(image_path)

if image is None:

raise ValueError(f"无法加载图像: {image_path}")

preprocessed = processor.preprocess_single(image)

return self.predict(preprocessed, top_k)

def get_model_info(self) -> Dict:

"""

获取模型信息

Returns:

包含模型详细信息的字典

"""

if self.model is None:

return {'status': 'not_initialized'}

return {

'status': 'ready',

'num_classes': len(self.class_names),

'input_shape': self.model.input_shape[1:],

'output_shape': self.model.output_shape[1:],

'total_params': self.model.count_params(),

'trainable_params': sum([

tf.keras.backend.count_params(w)

for w in self.model.trainable_weights

]),

'classes': self.class_names[:10] + ['...'] # 只显示前10个

}

# ==================== 使用示例 ====================

if __name__ == "__main__":

# 初始化识别器（需要实际的模型文件）

recognizer = FoodRecognizer(

model_path="data/model_weights.h5",

class_names_path="data/class_names.json",

confidence_threshold=0.7

)

# 打印模型信息

info = recognizer.get_model_info()

print(json.dumps(info, indent=2))

4. 营养计算模块 (modules/nutrition_calculator.py)

"""

营养计算模块 - 基于食物识别结果计算营养成分

核心功能：热量查询、营养素计算、BMI评估、每日摄入统计

"""

import json

from typing import Dict, List, Optional, Tuple

from dataclasses import dataclass

from datetime import datetime

import logging

# 配置日志

logging.basicConfig(level=logging.INFO)

logger = logging.getLogger(__name__)

@dataclass

class NutritionResult:

"""

营养计算结果数据类

用于存储单次食物识别的营养分析结果

Attributes:

food_name: 食物名称

confidence: 识别置信度

quantity_grams: 估算重量（克）

calories: 热量（千卡）

protein: 蛋白质（克）

carbs: 碳水化合物（克）

fat: 脂肪（克）

fiber: 膳食纤维（克）

sugar: 糖分（克）

sodium: 钠含量（毫克）

timestamp: 记录时间戳

"""

food_name: str

confidence: float

quantity_grams: float

calories: float

protein: float

carbs: float

fat: float

fiber: float

sugar: float

sodium: float

timestamp: str

def to_dict(self) -> Dict:

"""转换为字典格式"""

return {

'food_name': self.food_name,

'confidence': round(self.confidence, 4),

'quantity_grams': round(self.quantity_grams, 1),

'calories': round(self.calories, 1),

'protein': round(self.protein, 1),

'carbs': round(self.carbs, 1),

'fat': round(self.fat, 1),

'fiber': round(self.fiber, 1),

'sugar': round(self.sugar, 1),

'sodium': round(self.sodium, 1),

'timestamp': self.timestamp

}

class NutritionCalculator:

"""

营养计算器类

整合食物数据库和营养学算法，提供全面的营养分析功能。

Attributes:

food_db: 食物营养数据库

bmi_standards: BMI标准参考值

"""

def __init__(self, food_db_path: str):

"""

初始化营养计算器

Args:

food_db_path: 食物营养数据库JSON文件路径

"""

self.food_db = self._load_food_database(food_db_path)

self.bmi_standards = {

'underweight': (0, 18.5),

'normal': (18.5, 24.0),

'overweight': (24.0, 28.0),

'obese': (28.0, float('inf'))

}

logger.info(f"营养计算器初始化完成，数据库包含{len(self.food_db)}种食物")

def _load_food_database(self, path: str) -> Dict:

"""

加载食物营养数据库

数据库格式示例:

{

"apple": {

"calories_per_100g": 52,

"protein_per_100g": 0.3,

"carbs_per_100g": 14,

"fat_per_100g": 0.2,

"fiber_per_100g": 2.4,

"sugar_per_100g": 10,

"sodium_per_100g": 1,

"category": "fruit",

"glycemic_index": 36

},

...

}

Args:

path: 数据库文件路径

Returns:

食物营养数据字典

"""

try:

with open(path, 'r', encoding='utf-8') as f:

database = json.load(f)

logger.info(f"成功加载食物数据库: {path}")

return database

except FileNotFoundError:

logger.warning(f"食物数据库文件不存在: {path}，使用内置简化数据库")

return self._get_default_food_database()

except json.JSONDecodeError as e:

logger.error(f"数据库JSON解析错误: {e}")

return self._get_default_food_database()

def _get_default_food_database(self) -> Dict:

"""

获取默认简化食物数据库（后备方案）

Returns:

包含常见食物的简化营养数据库

"""

利用AI解决实际问题，如果你觉得这个工具好用，欢迎关注长安牧笛！