本章详细介绍了用于 peach 分类任务的深度学习模型的设计与实现过程。我们采用了预训练的 ResNet50 模型作为基础，并进行了适当的修改以适应具体任务的需求。此外，我们还实现了数据加载、图像增强、模型训练、评估和预测等功能模块。 根据文档代码用代码中的数据替换以上内容

本章详细介绍了用于 peach 分类任务的深度学习模型的设计与实现过程。我们设计了一个自定义的卷积神经网络（CNN）模型，并进行了以下步骤：

1. **环境配置**：禁用了 OneDNN 优化并设置了日志级别。
2. **数据路径定义**：指定了训练、验证和测试数据集的路径以及标签文件和输出文件的路径。
3. **数据加载**：编写了 `load_data` 函数来加载和处理图像数据及标签。
4. **标签映射**：将文本标签映射为数值标签，以便于模型训练。
5. **模型创建**：定义了一个 CNN 模型，包括多个卷积层、池化层、全连接层和 dropout 层。
6. **模型编译**：使用 Adam 优化器和稀疏分类交叉熵损失函数编译模型。
7. **图像增强**：使用 `ImageDataGenerator` 进行数据增强，以提高模型的泛化能力。
8. **模型训练**：通过 `fit` 方法训练模型，并在验证集上进行验证。
9. **模型转换**：将训练好的 Keras 模型转换为 TensorFlow Lite 格式，便于部署。
10. **模型评估**：编写了 `evaluate_model` 函数来评估模型在验证集上的性能，包括准确率和 F1 分数。
11. **预测与保存**：编写了 `predict_and_save` 函数来对测试集进行预测，并将结果保存到 CSV 文件中。

以下是关键代码片段：

import os
os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
os.environ['TF_CPP_MIN_LOG_LEVEL'] = '2'
import json
import numpy as np
import pandas as pd
from PIL import Image
import tensorflow as tf
from sklearn.model_selection import train_test_split
from tensorflow.keras.models import Model
from tensorflow.keras.layers import Input, Conv2D, MaxPooling2D, Flatten, Dense, Dropout
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.optimizers import Adam
from sklearn.metrics import f1_score, accuracy_score

# 定义数据路径
TRAIN_DATA_DIR = "C:\\Users\\24067\\Desktop\\peach_split\\train"
VAL_DATA_DIR = "C:\\Users\\24067\\Desktop\\peach_split\\val"
TEST_DATA_DIR = "C:\\Users\\24067\\Desktop\\peach_split\\test"
TRAIN_LABEL_PATH = "C:\\Users\\24067\\Desktop\\train_label.json"
VAL_LABEL_PATH = "C:\\Users\\24067\\Desktop\\val_label.json"
OUTPUT_PATH = "C:\\Users\\24067\\Desktop\\data\\submission.csv"
MODEL_SAVE_PATH = "C:\\Users\\24067\\Desktop\\data\\model.tflite"

# 数据加载
def load_data(data_dir, label_path):
    with open(label_path, 'r') as f:
        labels_list = json.load(f)
    labels = {item['文件名']: item['标签'] for item in labels_list if '文件名' in item and '标签' in item}
    images = []
    targets = []
    for file_name, label in labels.items():
        img_path = os.path.join(data_dir, file_name)
        if not os.path.exists(img_path):
            continue
        img = Image.open(img_path).resize((128, 128))
        img_array = np.array(img) / 255.0
        images.append(img_array)
        targets.append(label)
    if len(images) == 0:
        raise ValueError("No valid images found.")
    return np.array(images), np.array(targets)

# 加载训练数据
train_images, train_labels = load_data(TRAIN_DATA_DIR, TRAIN_LABEL_PATH)
# 加载验证数据
val_images, val_labels = load_data(VAL_DATA_DIR, VAL_LABEL_PATH)

# 标签映射
label_map = {'特级': 3, '一级': 2, '二级': 1, '三级': 0}
train_labels = np.array([label_map[label] for label in train_labels])
val_labels = np.array([label_map[label] for label in val_labels])

# 创建模型
def create_model(input_shape=(128, 128, 3)):
    inputs = Input(shape=input_shape)
    x = Conv2D(32, (3, 3), activation='relu')(inputs)
    x = MaxPooling2D((2, 2))(x)
    x = Conv2D(64, (3, 3), activation='relu')(x)
    x = MaxPooling2D((2, 2))(x)
    x = Conv2D(128, (3, 3), activation='relu')(x)
    x = MaxPooling2D((2, 2))(x)
    x = Flatten()(x)
    x = Dense(128, activation='relu')(x)
    x = Dropout(0.5)(x)
    outputs = Dense(4, activation='softmax')(x)
    model = Model(inputs=inputs, outputs=outputs)
    return model

# 实例化模型
model = create_model()

# 编译模型
model.compile(optimizer=Adam(learning_rate=0.001), loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# 图像增强
datagen = ImageDataGenerator(
    rotation_range=20,
    width_shift_range=0.2,
    height_shift_range=0.2,
    horizontal_flip=True,
    vertical_flip=True
)

# 训练模型
history = model.fit(datagen.flow(train_images, train_labels, batch_size=32), epochs=200, validation_data=(val_images, val_labels))

# 转换为 TensorFlow Lite 格式
converter = tf.lite.TFLiteConverter.from_keras_model(model)
tflite_model = converter.convert()
with open(MODEL_SAVE_PATH, 'wb') as f:
    f.write(tflite_model)

# 评估模型
def evaluate_model(model, X, y):
    predictions = model.predict(X)
    predicted_labels = np.argmax(predictions, axis=1)
    accuracy = accuracy_score(y, predicted_labels)
    f1 = f1_score(y, predicted_labels, average='weighted')
    print(f'Accuracy: {accuracy:.4f}')
    print(f'F1 Score: {f1:.4f}')
    return accuracy, f1

evaluate_model(model, val_images, val_labels)

# 预测测试集并保存结果
def predict_and_save(test_data_dir, output_path):
    test_images = []
    test_file_names = []
    for file_name in os.listdir(test_data_dir):
        img_path = os.path.join(test_data_dir, file_name)
        if not os.path.exists(img_path):
            continue
        img = Image.open(img_path).resize((128, 128))
        img_array = np.array(img) / 255.0
        test_images.append(img_array)
        test_file_names.append(file_name)
    test_images = np.array(test_images)
    predictions = model.predict(test_images)
    predicted_labels = np.argmax(predictions, axis=1)
    label_map_inv = {v: k for k, v in label_map.items()}
    predicted_labels = [label_map_inv[label] for label in predicted_labels]
    submission_df = pd.DataFrame({'文件名': test_file_names, '标签': predicted_labels})
    submission_df.to_csv(output_path, index=False)

# 进行预测并保存结果
predict_and_save(TEST_DATA_DIR, OUTPUT_PATH)

通过上述步骤，我们成功地构建并训练了一个用于 peach 分类的深度学习模型，并对其性能进行了评估和测试集预测。