K-近邻和神经网络

K-近邻（K-NN, K-Nearest Neighbors）

原理

K-近邻（K-NN）是一种非参数分类和回归算法。K-NN 的主要思想是根据距离度量（如欧氏距离）找到训练数据集中与待预测样本最近的 K 个样本，并根据这 K 个样本的标签来进行预测。对于分类任务，K-NN 通过投票的方式选择出现最多的类别作为预测结果；对于回归任务，K-NN 通过计算 K 个最近邻样本的平均值来进行预测。

公式

K-NN 的主要步骤包括：

1. 计算待预测样本与训练集中每个样本之间的距离。常用的距离度量包括欧氏距离、曼哈顿距离等。

   

2. 找到距离最近的 K 个样本。
3. 对于分类任务，通过投票决定预测结果：

   

其中，Nk 表示样本 x 的 K 个最近邻样本集合，I 是指示函数。

1. 对于回归任务，通过计算平均值决定预测结果：

   

生活场景应用的案例

手写数字识别：K-NN 可以用于手写数字识别任务。假设我们有一个手写数字的图片数据集，每张图片都被标注了对应的数字。我们可以使用 K-NN 模型来识别新图片中的数字。

案例描述

假设我们有一个手写数字图片的数据集，包括以下特征：

• 图片像素值（每张图片由一个固定大小的像素矩阵表示）

我们希望通过这些像素值来预测图片中的数字。我们可以使用 K-NN 模型进行训练和预测。训练完成后，我们可以使用模型来识别新图片中的数字，并评估模型的性能。

代码解析

下面是一个使用 Python 实现上述手写数字识别案例的示例，使用了 scikit-learn 库。

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.neighbors import KNeighborsClassifier
from sklearn.metrics import accuracy_score, confusion_matrix, classification_report
import matplotlib.pyplot as plt
from sklearn.datasets import load_digits

# 载入手写数字数据集
digits = load_digits()
X = digits.data
y = digits.target

# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建K-NN模型并训练
k = 5
model = KNeighborsClassifier(n_neighbors=k)
model.fit(X_train, y_train)

# 预测
y_pred = model.predict(X_test)

# 评估模型
accuracy = accuracy_score(y_test, y_pred)
cm = confusion_matrix(y_test, y_pred)
report = classification_report(y_test, y_pred)

print(f"Accuracy: {accuracy}")
print("Confusion Matrix:")
print(cm)
print("Classification Report:")
print(report)

# 可视化部分测试结果
fig, axes = plt.subplots(1, 5, figsize=(10, 3))
for ax, image, prediction in zip(axes, X_test, y_pred):
    ax.set_axis_off()
    image = image.reshape(8, 8)
    ax.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title(f'Pred: {prediction}')
plt.show()

在这个示例中：

1. 我们使用了 sklearn.datasets 中的手写数字数据集。这个数据集包含了 8x8 像素的图片，每张图片代表一个手写数字。
2. 将数据集拆分为训练集和测试集。
3. 使用训练集训练 K-NN 分类模型。
4. 通过测试集进行预测并评估模型的性能。
5. 输出准确率（accuracy）、混淆矩阵（confusion matrix）和分类报告（classification report）。
6. 可视化部分测试结果，展示模型的预测效果。

这个案例展示了如何使用 K-NN 模型来识别手写数字，基于图片的像素值特征。模型训练完成后，可以用于预测新图片中的数字，并帮助解决实际的手写数字识别问题。

神经网络（Neural Network）

原理

神经网络是一种模仿生物神经元结构的计算模型，由多个节点（神经元）和连接（权重）组成。神经网络主要由输入层、隐藏层和输出层构成，每一层包含若干神经元。通过层与层之间的连接和激活函数（如ReLU、Sigmoid等），神经网络能够拟合复杂的非线性关系，实现分类、回归等任务。

训练神经网络的过程通常使用反向传播算法，通过计算损失函数的梯度来调整网络的权重，以最小化预测误差。

公式

1. 神经元的线性组合：

其中，xi 是输入，wi 是权重，b 是偏置，z 是神经元的加权和。

1. 激活函数： 常用的激活函数包括：

• Sigmoid 函数：

• ReLU 函数：

1. 反向传播：

反向传播算法通过计算损失函数的梯度来更新权重：

其中，η 是学习率，L 是损失函数。

生活场景应用的案例

图像分类：神经网络广泛应用于图像分类任务。假设我们有一个包含手写数字图片的数据集，每张图片都被标注了对应的数字。我们可以使用神经网络模型来识别新图片中的数字。

案例描述

假设我们有一个手写数字图片的数据集，包括以下特征：

• 图片像素值（每张图片由一个固定大小的像素矩阵表示）

我们希望通过这些像素值来预测图片中的数字。我们可以使用神经网络模型进行训练和预测。训练完成后，我们可以使用模型来识别新图片中的数字，并评估模型的性能。

代码解析

下面是一个使用 Python 实现上述手写数字识别案例的示例，使用了 tensorflow 和 keras 库。

import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.utils import to_categorical
from sklearn.datasets import load_digits

# 载入手写数字数据集
digits = load_digits()
X = digits.images
y = digits.target

# 预处理数据
X = X / 16.0  # 将像素值归一化到 [0, 1]
y = to_categorical(y, num_classes=10)  # 将标签转换为one-hot编码

# 调整数据维度以适应TensorFlow模型
X = X.reshape(-1, 8, 8, 1)  # 使用-1使reshape自动计算样本数量

# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建神经网络模型
model = Sequential([
    Flatten(input_shape=(8, 8, 1)),  # 展平输入图像
    Dense(128, activation='relu'),  # 隐藏层，包含128个神经元
    Dense(64, activation='relu'),  # 隐藏层，包含64个神经元
    Dense(10, activation='softmax')  # 输出层，包含10个神经元，对应10个类别
])

# 编译模型
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 训练模型
model.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.2)

# 评估模型
loss, accuracy = model.evaluate(X_test, y_test)
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true = np.argmax(y_test, axis=1)

print(f"Accuracy: {accuracy}")
print("Classification Report:")
print(classification_report(y_true, y_pred_classes))

# 可视化部分测试结果
fig, axes = plt.subplots(1, 5, figsize=(10, 3))
for ax, image, prediction in zip(axes, X_test, y_pred_classes):
    ax.set_axis_off()
    image = image.reshape(8, 8)  # 确保图像形状正确
    ax.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title(f'Pred: {prediction}')
plt.show()

在这个示例中：

1. 我们使用了 sklearn.datasets 中的手写数字数据集。这个数据集包含了 8x8 像素的图片，每张图片代表一个手写数字。
2. 将数据集拆分为训练集和测试集，并对数据进行预处理，将像素值归一化并将标签转换为 one-hot 编码。
3. 创建了一个包含两个隐藏层的神经网络模型。
4. 使用训练集训练神经网络模型。
5. 通过测试集进行预测并评估模型的性能。
6. 输出准确率（accuracy）和分类报告（classification report）。
7. 可视化部分测试结果，展示模型的预测效果。

这个案例展示了如何使用神经网络模型来识别手写数字，基于图片的像素值特征。模型训练完成后，可以用于预测新图片中的数字，并帮助解决实际的手写数字识别问题。

具体应用

• 对预测结果进行可视化展示：

• • 在预测结果后，展示原始图片及其预测结果。

• 保存和加载训练好的模型：

• • 保存训练好的模型。
  • 加载已保存的模型进行预测。

import os
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.utils import to_categorical
from sklearn.datasets import load_digits
from PIL import Image  # 用于加载自定义图片

# 载入手写数字数据集
digits = load_digits()
X = digits.images
y = digits.target

# 预处理数据
X = X / 16.0  # 将像素值归一化到 [0, 1]
y = to_categorical(y, num_classes=10)  # 将标签转换为one-hot编码

# 调整数据维度以适应TensorFlow模型
X = X.reshape(-1, 8, 8, 1)  # 使用-1使reshape自动计算样本数量

# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 创建神经网络模型
model = Sequential([
    Flatten(input_shape=(8, 8, 1)),  # 展平输入图像
    Dense(128, activation='relu'),  # 隐藏层，包含128个神经元
    Dense(64, activation='relu'),  # 隐藏层，包含64个神经元
    Dense(10, activation='softmax')  # 输出层，包含10个神经元，对应10个类别
])

# 编译模型
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 训练模型
model.fit(X_train, y_train, epochs=20, batch_size=32, validation_split=0.2)

# 保存训练好的模型
model.save('digit_recognition_model.h5')

# 加载训练好的模型
# model = load_model('digit_recognition_model.h5')

# 评估模型
loss, accuracy = model.evaluate(X_test, y_test)
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true = np.argmax(y_test, axis=1)

print(f"Accuracy: {accuracy}")
print("Classification Report:")
print(classification_report(y_true, y_pred_classes))

# 可视化部分测试结果
fig, axes = plt.subplots(1, 5, figsize=(10, 3))
for ax, image, prediction in zip(axes, X_test, y_pred_classes):
    ax.set_axis_off()
    image = image.reshape(8, 8)  # 确保图像形状正确
    ax.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title(f'Pred: {prediction}')
plt.show()

# 加载并预处理单张图片
def load_and_preprocess_image(filepath):
    img = Image.open(filepath).convert('L')  # 转换为灰度图像
    img = img.resize((8, 8))  # 调整图像大小为8x8
    img = np.array(img) / 16.0  # 归一化像素值
    img = img.reshape(1, 8, 8, 1)  # 调整图像维度
    return img

# 加载并预处理文件夹中的所有图片
def load_images_from_folder(folder):
    images = []
    filepaths = []
    for filename in os.listdir(folder):
        if filename.endswith(('png', 'jpg', 'jpeg')):
            filepath = os.path.join(folder, filename)
            img = load_and_preprocess_image(filepath)
            images.append(img)
            filepaths.append(filepath)
    return np.vstack(images), filepaths

# 使用模型预测文件夹中的多张图片
def predict_custom_images_from_folder(folder):
    imgs, filepaths = load_images_from_folder(folder)
    preds = model.predict(imgs)
    pred_classes = np.argmax(preds, axis=1)
    return pred_classes, filepaths

# 示例：预测文件夹中的多张自定义图片并展示结果
custom_image_folder = 'path/to/your/folder'  # 替换为自定义图片文件夹路径
predicted_classes, filepaths = predict_custom_images_from_folder(custom_image_folder)

# 打印预测结果并可视化
fig, axes = plt.subplots(1, len(filepaths), figsize=(15, 3))
for ax, filepath, pred_class in zip(axes, filepaths, predicted_classes):
    ax.set_axis_off()
    img = Image.open(filepath).convert('L')
    img = img.resize((8, 8))
    img = np.array(img
    ax.imshow(img, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title(f'Pred: {pred_class}')
    print(f'The predicted class for {filepath} is: {pred_class}')
plt.show()

a. 添加更多的训练数据来提高模型的准确性。

b. 使用混淆矩阵来详细分析模型的分类结果。

import os
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from sklearn.datasets import load_digits
from PIL import Image

# 载入手写数字数据集
digits = load_digits()
X = digits.images
y = digits.target

# 预处理数据
X = X / 16.0  # 将像素值归一化到 [0, 1]
y = to_categorical(y, num_classes=10)  # 将标签转换为one-hot编码

# 调整数据维度以适应TensorFlow模型
X = X.reshape(-1, 8, 8, 1)  # 使用-1使reshape自动计算样本数量

# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 再拆分训练集以创建验证集
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=42)

# 数据扩充
datagen = ImageDataGenerator(
    rotation_range=10,
    zoom_range=0.1,
    width_shift_range=0.1,
    height_shift_range=0.1
)
datagen.fit(X_train)

# 创建神经网络模型
model = Sequential([
    Flatten(input_shape=(8, 8, 1)),  # 展平输入图像
    Dense(128, activation='relu'),  # 隐藏层，包含128个神经元
    Dense(64, activation='relu'),  # 隐藏层，包含64个神经元
    Dense(10, activation='softmax')  # 输出层，包含10个神经元，对应10个类别
])

# 编译模型
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 训练模型
model.fit(datagen.flow(X_train, y_train, batch_size=32), epochs=20, validation_data=(X_val, y_val))

# 保存训练好的模型
model.save('digit_recognition_model.h5')

# 加载训练好的模型
# model = load_model('digit_recognition_model.h5')

# 评估模型
loss, accuracy = model.evaluate(X_test, y_test)
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true = np.argmax(y_test, axis=1)

print(f"Accuracy: {accuracy}")
print("Classification Report:")
print(classification_report(y_true, y_pred_classes))

# 生成混淆矩阵
cm = confusion_matrix(y_true, y_pred_classes)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=np.arange(10))
disp.plot(cmap=plt.cm.Blues)
plt.show()

# 可视化部分测试结果
fig, axes = plt.subplots(1, 5, figsize=(10, 3))
for ax, image, prediction in zip(axes, X_test, y_pred_classes):
    ax.set_axis_off()
    image = image.reshape(8, 8)  # 确保图像形状正确
    ax.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title(f'Pred: {prediction}')
plt.show()

# 加载并预处理单张图片
def load_and_preprocess_image(filepath):
    img = Image.open(filepath).convert('L')  # 转换为灰度图像
    img = img.resize((8, 8))  # 调整图像大小为8x8
    img = np.array(img) / 16.0  # 归一化像素值
    img = img.reshape(1, 8, 8, 1)  # 调整图像维度
    return img

# 加载并预处理文件夹中的所有图片
def load_images_from_folder(folder):
    images = []
    filepaths = []
    for filename in os.listdir(folder):
        if filename.endswith(('png', 'jpg', 'jpeg')):
            filepath = os.path.join(folder, filename)
            img = load_and_preprocess_image(filepath)
            images.append(img)
            filepaths.append(filepath)
    return np.vstack(images), filepaths

# 使用模型预测文件夹中的多张图片
def predict_custom_images_from_folder(folder):
    imgs, filepaths = load_images_from_folder(folder)
    preds = model.predict(imgs)
    pred_classes = np.argmax(preds, axis=1)
    return pred_classes, filepaths

# 示例：预测文件夹中的多张自定义图片并展示结果
custom_image_folder = 'path/to/your/folder'  # 替换为自定义图片文件夹路径
predicted_classes, filepaths = predict_custom_images_from_folder(custom_image_folder)

# 打印预测结果并可视化
fig, axes = plt.subplots(1, len(filepaths), figsize=(15, 3))
for ax, filepath, pred_class in zip(axes, filepaths, predicted_classes):
    ax.set_axis_off()
    img = Image.open(filepath).convert('L')
    img = img.resize((8, 8))
    img = np.array(img)
    ax.imshow(img, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title(f'Pred: {pred_class}')
    print(f'The predicted class for {filepath} is: {pred_class}')
plt.show()

a. 使用更多的手写数字样本进行训练，以提高模型对手写数字的识别能力。

b. 尝试使用不同的模型架构，如卷积神经网络（CNN），以提高模型的识别准确率。

import os
import numpy as np
import pandas as pd
from sklearn.model_selection import train_test_split
from sklearn.metrics import classification_report, confusion_matrix, ConfusionMatrixDisplay
import matplotlib.pyplot as plt
import tensorflow as tf
from tensorflow.keras.models import Sequential, load_model
from tensorflow.keras.layers import Dense, Flatten
from tensorflow.keras.utils import to_categorical
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from sklearn.datasets import load_digits
from PIL import Image

# 载入手写数字数据集
digits = load_digits()
X = digits.images
y = digits.target

# 预处理数据
X = X / 16.0  # 将像素值归一化到 [0, 1]
y = to_categorical(y, num_classes=10)  # 将标签转换为one-hot编码

# 调整数据维度以适应TensorFlow模型
X = X.reshape(-1, 8, 8, 1)  # 使用-1使reshape自动计算样本数量

# 拆分训练集和测试集
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size=0.2, random_state=42)

# 再拆分训练集以创建验证集
X_train, X_val, y_train, y_val = train_test_split(X_train, y_train, test_size=0.2, random_state=42)

# 数据扩充
datagen = ImageDataGenerator(
    rotation_range=5,
    zoom_range=0.05,
    width_shift_range=0.05,
    height_shift_range=0.05
)
datagen.fit(X_train)

# 创建神经网络模型
model = Sequential([
    Flatten(input_shape=(8, 8, 1)),  # 展平输入图像
    Dense(128, activation='relu'),  # 隐藏层，包含128个神经元
    Dense(64, activation='relu'),  # 隐藏层，包含64个神经元
    Dense(10, activation='softmax')  # 输出层，包含10个神经元，对应10个类别
])

# 编译模型
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# 训练模型
history = model.fit(datagen.flow(X_train, y_train, batch_size=32), epochs=20, validation_data=(X_val, y_val))

# 保存训练好的模型
model.save('digit_recognition_model.h5')

# 加载训练好的模型
# model = load_model('digit_recognition_model.h5')

# 评估模型
loss, accuracy = model.evaluate(X_test, y_test)
y_pred = model.predict(X_test)
y_pred_classes = np.argmax(y_pred, axis=1)
y_true = np.argmax(y_test, axis=1)

print(f"Accuracy: {accuracy}")
print("Classification Report:")
print(classification_report(y_true, y_pred_classes))

# 生成混淆矩阵
cm = confusion_matrix(y_true, y_pred_classes)
disp = ConfusionMatrixDisplay(confusion_matrix=cm, display_labels=np.arange(10))
disp.plot(cmap=plt.cm.Blues)
plt.show()

# 可视化部分测试结果
fig, axes = plt.subplots(1, 5, figsize=(10, 3))
for ax, image, prediction in zip(axes, X_test, y_pred_classes):
    ax.set_axis_off()
    image = image.reshape(8, 8)  # 确保图像形状正确
    ax.imshow(image, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title(f'Pred: {prediction}')
plt.show()

# 加载并预处理单张图片
def load_and_preprocess_image(filepath):
    img = Image.open(filepath).convert('L')  # 转换为灰度图像
    img = img.resize((8, 8))  # 调整图像大小为8x8
    img = np.array(img) / 255.0  # 归一化像素值到 [0, 1]
    img = img.reshape(1, 8, 8, 1)  # 调整图像维度
    return img

# 加载并预处理文件夹中的所有图片
def load_images_from_folder(folder):
    images = []
    filepaths = []
    for filename in os.listdir(folder):
        if filename.endswith(('png', 'jpg', 'jpeg')):
            filepath = os.path.join(folder, filename)
            img = load_and_preprocess_image(filepath)
            images.append(img)
            filepaths.append(filepath)
    return np.vstack(images), filepaths

# 使用模型预测文件夹中的多张图片
def predict_custom_images_from_folder(folder):
    imgs, filepaths = load_images_from_folder(folder)
    preds = model.predict(imgs)
    pred_classes = np.argmax(preds, axis=1)
    return pred_classes, filepaths

# 示例：预测文件夹中的多张自定义图片并展示结果
custom_image_folder = 'path/to/your/folder'  # 替换为自定义图片文件夹路径
predicted_classes, filepaths = predict_custom_images_from_folder(custom_image_folder)

# 打印预测结果并可视化
fig, axes = plt.subplots(1, len(filepaths), figsize=(15, 3))
for ax, filepath, pred_class in zip(axes, filepaths, predicted_classes):
    ax.set_axis_off()
    img = Image.open(filepath).convert('L')
    img = img.resize((8, 8))
    img = np.array(img)
    ax.imshow(img, cmap=plt.cm.gray_r, interpolation='nearest')
    ax.set_title(f'Pred: {pred_class}')
    print(f'The predicted class for {filepath} is: {pred_class}')
plt.show()