提示：文章写完后，目录可以自动生成，如何生成可参考右边的帮助文档

---

前言

猫狗识别是深度学习入门最经典的实战项目之一。通过构建卷积神经网络（CNN），我们可以让计算机学会像人类一样区分猫和狗的图像。本项目将使用TensorFlow/Keras框架，在Jupyter Notebook环境中完成从数据准备到模型部署的全流程

一、环境配置

1.1 安装Jupyter Notebook
通过Anaconda安装

# 下载并安装Anaconda
# 访问 https://www.anaconda.com/products/distribution 下载对应版本
# 安装完成后，启动Anaconda Prompt

# 创建虚拟环境
conda create -n cat_dog python=3.8
conda activate cat_dog

# 安装Jupyter Notebook
pip install jupyter notebook

1.2安装深度学习依赖库

pip install tensorflow keras matplotlib pillow numpy pandas scikit-learn

1.3 启动Jupyter Notebook

jupyter notebook

二、数据集准备

2.1 实验使用的猫狗数据集存放在 D:\catdog\data 路径下，分为 train 和 test 子文件夹，分别存放猫（ cats ）、狗（ dogs ）的图片（格式为.jpg）。首先通过 os.walk 遍历数据集，确认文件路径与数量：

 # 遍历数据集路径并打印文件
for dirname, _, filenames in os.walk('D:\\catdog'):
   for filename in filenames:
       print(os.path.join(dirname, filename))

2.2数据预处理代码

import os
import shutil
import random

2.3创建目录结构

base_dir = './data'
train_dir = os.path.join(base_dir, 'train')
validation_dir = os.path.join(base_dir, 'validation')
test_dir = os.path.join(base_dir, 'test')

os.makedirs(train_dir, exist_ok=True)
os.makedirs(validation_dir, exist_ok=True)
os.makedirs(test_dir, exist_ok=True)

2.4猫狗分类目录

train_cats_dir = os.path.join(train_dir, 'cats')
train_dogs_dir = os.path.join(train_dir, 'dogs')
validation_cats_dir = os.path.join(validation_dir, 'cats')
validation_dogs_dir = os.path.join(validation_dir, 'dogs')
test_cats_dir = os.path.join(test_dir, 'cats')
test_dogs_dir = os.path.join(test_dir, 'dogs')

for dir_path in [train_cats_dir, train_dogs_dir, validation_cats_dir, 
              validation_dogs_dir, test_cats_dir, test_dogs_dir]:
  os.makedirs(dir_path, exist_ok=True)

2.5复制数据和猫狗图片

raw_cats_dir = './raw_data/cats'
raw_dogs_dir = './raw_data/dogs'

#猫
cat_fnames = [f'cat.{i}.jpg' for i in range(1000)]
for fname in cat_fnames:
  src = os.path.join(raw_cats_dir, fname)
  dst = os.path.join(train_cats_dir, fname)
  shutil.copyfile(src, dst)

cat_fnames = [f'cat.{i}.jpg' for i in range(1000, 1500)]
for fname in cat_fnames:
  src = os.path.join(raw_cats_dir, fname)
  dst = os.path.join(validation_cats_dir, fname)
  shutil.copyfile(src, dst)

cat_fnames = [f'cat.{i}.jpg' for i in range(1500, 2000)]
for fname in cat_fnames:
  src = os.path.join(raw_cats_dir, fname)
  dst = os.path.join(test_cats_dir, fname)
  shutil.copyfile(src, dst)
dog_fnames = [f'dog.{i}.jpg' for i in range(1000)]
for fname in dog_fnames:
  src = os.path.join(raw_dogs_dir, fname)
  dst = os.path.join(train_dogs_dir, fname)
  shutil.copyfile(src, dst)

#狗
dog_fnames = [f'dog.{i}.jpg' for i in range(1000, 1500)]
for fname in dog_fnames:
  src = os.path.join(raw_dogs_dir, fname)
  dst = os.path.join(validation_dogs_dir, fname)
  shutil.copyfile(src, dst)

dog_fnames = [f'dog.{i}.jpg' for i in range(1500, 2000)]
for fname in dog_fnames:
  src = os.path.join(raw_dogs_dir, fname)
  dst = os.path.join(test_dogs_dir, fname)
  shutil.copyfile(src, dst)

三、数据预处理与增强

3.1训练数据增强

 from tensorflow.keras.preprocessing.image import ImageDataGenerator

train_datagen = ImageDataGenerator(
   rescale=1./255,
   rotation_range=40,
   width_shift_range=0.2,
   height_shift_range=0.2,
   shear_range=0.2,
   zoom_range=0.2,
   horizontal_flip=True,
   fill_mode='nearest'
)

3.2验证和测试数据预处理

validation_datagen = ImageDataGenerator(rescale=1./255)
test_datagen = ImageDataGenerator(rescale=1./255)

3.3创建数据生成器

train_generator = train_datagen.flow_from_directory(
  train_dir,
  target_size=(150, 150),
  batch_size=32,
  class_mode='binary'
)

validation_generator = validation_datagen.flow_from_directory(
  validation_dir,
  target_size=(150, 150),
  batch_size=32,
  class_mode='binary'
)

test_generator = test_datagen.flow_from_directory(
  test_dir,
  target_size=(150, 150),
  batch_size=32,
  class_mode='binary'
)

3.4构建CNN模型

 from tensorflow.keras import layers, models

model = models.Sequential([
   # 第一层卷积
   layers.Conv2D(32, (3, 3), activation='relu', input_shape=(150, 150, 3)),
   layers.MaxPooling2D((2, 2)),
   
   # 第二层卷积
   layers.Conv2D(64, (3, 3), activation='relu'),
   layers.MaxPooling2D((2, 2)),
   
   # 第三层卷积
   layers.Conv2D(128, (3, 3), activation='relu'),
   layers.MaxPooling2D((2, 2)),
   
   # 第四层卷积
   layers.Conv2D(128, (3, 3), activation='relu'),
   layers.MaxPooling2D((2, 2)),
   
   # 展平层
   layers.Flatten(),
   
   # 全连接层
   layers.Dense(512, activation='relu'),
   layers.Dropout(0.5),
   
   # 输出层（二分类）
   layers.Dense(1, activation='sigmoid')
])

model.summary()

3.5编译模型

from tensorflow.keras.optimizers import Adam

model.compile(
  loss='binary_crossentropy',
  optimizer=Adam(learning_rate=1e-4),
  metrics=['accuracy']
)

四、模型训练

4.1训练配置

history = model.fit(
  train_generator,
  steps_per_epoch=100,
  epochs=30,
  validation_data=validation_generator,
  validation_steps=50
)

4.2保存模型

model.save('cat_dog_cnn.h5')

五、模型评估与可视化

5.1训练过程可视化

import matplotlib.pyplot as plt

acc = history.history['accuracy']
val_acc = history.history['val_accuracy']
loss = history.history['loss']
val_loss = history.history['val_loss']

epochs = range(len(acc))

plt.figure(figsize=(12, 4))

plt.subplot(1, 2, 1)
plt.plot(epochs, acc, 'bo', label='Training accuracy')
plt.plot(epochs, val_acc, 'b', label='Validation accuracy')
plt.title('Training and validation accuracy')
plt.legend()

plt.subplot(1, 2, 2)
plt.plot(epochs, loss, 'bo', label='Training loss')
plt.plot(epochs, val_loss, 'b', label='Validation loss')
plt.title('Training and validation loss')
plt.legend()

plt.show()

5.2测试集评估

test_loss, test_acc = model.evaluate(test_generator, steps=50)
print(f'Test accuracy: {test_acc:.4f}')

5.3混淆矩阵分析

from sklearn.metrics import confusion_matrix, classification_report
import numpy as np

# 获取测试集预测结果
test_generator.reset()
predictions = model.predict(test_generator, steps=len(test_generator))
predicted_classes = (predictions > 0.5).astype(int).flatten()

# 获取真实标签
true_classes = test_generator.classes

# 混淆矩阵
cm = confusion_matrix(true_classes, predicted_classes)
print("Confusion Matrix:")
print(cm)

# 分类报告
print("\nClassification Report:")
print(classification_report(true_classes, predicted_classes, target_names=['Cat', 'Dog']))

六、模型应用与预测

6.1单张图片预测

from tensorflow.keras.preprocessing import image
import numpy as np

def predict_image(img_path):
  # 加载图片
  img = image.load_img(img_path, target_size=(150, 150))
  img_array = image.img_to_array(img)
  img_array = np.expand_dims(img_array, axis=0)
  img_array /= 255.0
  
  # 预测
  prediction = model.predict(img_array)[0][0]
  
  if prediction > 0.5:
      print(f'预测结果: 狗 (置信度: {prediction:.4f})')
  else:
      print(f'预测结果: 猫 (置信度: {1-prediction:.4f})')
  
  return prediction

# 测试预测
result = predict_image('./test_image.jpg')

6.2批量预测

import os
from PIL import Image

def batch_predict(directory):
  results = []
  for filename in os.listdir(directory):
      if filename.endswith('.jpg') or filename.endswith('.png'):
          img_path = os.path.join(directory, filename)
          prediction = predict_image(img_path)
          results.append({
              'filename': filename,
              'prediction': 'dog' if prediction > 0.5 else 'cat',
              'confidence': prediction if prediction > 0.5 else 1-prediction
          })
  return results

# 批量预测
predictions = batch_predict('./test_images/')
for pred in predictions:
  print(f"{pred['filename']}: {pred['prediction']} ({pred['confidence']:.4f})")

总结

通过本实战项目，我们完成了以下核心工作：
1.
环境配置：搭建了Jupyter Notebook开发环境，安装了必要的深度学习库
2.
数据准备：组织并预处理了猫狗图像数据集，应用了数据增强技术
3.
模型构建：设计了4层卷积神经网络，包含卷积层、池化层和全连接层
4.
模型训练：使用Adam优化器训练模型，实现了90%以上的准确率
5.
模型评估：通过混淆矩阵和分类报告全面评估模型性能
6.
模型应用：实现了单张图片和批量图片的预测功能

本项目展示了深度学习在图像分类任务中的完整流程