十大人工智能迷你项目

1 Apr 2025 | 阅读 18 分钟

在接下来的教程中，我们将讨论一些有趣的人工智能迷你项目。

项目 1：客户支持聊天机器人

项目目标

应对客户支持查询的复杂性。这是通过聊天机器人实现的。聊天机器人旨在协助用户。他们获得指导来处理常规和特定查询。聊天机器人还为常见问题提供即时解决方案。

关键概念

自然语言处理 (NLP)：这是分析用户消息的过程。该过程涉及提取意图和实体。此外，它还有助于生成合适的响应。
意图分类：工作是将用户输入分类到预设类别中。例如，我们有“订单状态”或“退货”。还有“配送”。目标是准确响应。
实体识别：这是提取详细信息的过程。例如姓名、日期甚至产品名称。它们来自用户输入。

技术栈

库

Flask 或 Django 用于 Web 界面。NLTK spaCy 或 Rasa 用于自然语言理解 (NLU)。Hugging Face Transformers 用于预训练的 NLP 模型。SQL 或 NoSQL 数据库使用。它存储用户信息和之前的交互。例如，SQLite 和 MongoDB。

分步实施

步骤 1：定义聊天机器人需求和用例

列出常见的客户咨询。例如，检查订单状态或退款政策。还需要解决账户问题。
确定聊天机器人的具体操作。它应该回答常见问题。它应该处理一些账户任务。然而，任务应该是简单的。应该将其重定向到人工代表。

步骤 2：设置后端（Flask API）

启动 Flask 或 Django 服务器。该服务器将管理通信。它将聊天机器人模型与 Web 或移动前端连接起来。建立不同的端点。例如 /message。用于接收用户消息并发送响应。还创建 /feedback。用户评价互动。如果发生这种情况，请存储反馈。

步骤 3：开发基于规则的响应系统（可选）

responses = {
    "order status": "Please provide your order number to check the status.",
    "return policy": "Our return policy allows for returns within 30 days of purchase.",
    "shipping info": "Shipping typically takes 3-5 business days."
}

def get_response(message):
    for key in responses:
        if key in message.lower():
            return responses[key]
    return "I'm sorry, I don't understand. Could you clarify?"  

该方法快速有效。它适用于常规和已知的问题。

步骤 4：NLP 和意图分类

数据收集：准备查询和答案的数据集。这是为聊天机器人准备的。它必须理解意图。例如，客户服务常见问题解答。
预处理：分词。删除停用词。清理文本数据。
模型选择：模型可以预训练。例如，BERT 和 DistilBERT。这些来自 Hugging Face。或者你可以训练一个分类器。使用 scikit-learn 等库。
训练模型：训练模型。它需要对传入的消息进行分类。根据意图执行此操作。

from transformers import pipeline
classifier = pipeline("zero-shot-classification", model="facebook/bart-large-mnli")

def classify_intent(message):
    intents = ["order status", "returns", "shipping information", "account issues"]
    result = classifier(message, intents)
    return result["labels"][0]   

实体提取：可以使用 spaCy 或 Rasa 进行实体提取。我们提取实体。这些可能是订单号或产品名称。

步骤 5：集成意图分类与响应

意图到响应的映射

def respond_to_intent(intent, entities=None):
    if intent == "order status":
        return "Could you provide your order number?"
    elif intent == "returns":
        return "Our return policy allows returns within 30 days of purchase."
    # More intents here
    else:
        return "I'm here to help! Could you clarify your question?"   

步骤 6：为用户互动创建数据库（可选）

考虑使用 SQLite 等简单数据库。它有助于聊天机器人回忆用户互动。因此，可以实现上下文感知响应。

示例表结构

CREATE TABLE interactions (
    user_id TEXT,
    timestamp DATETIME DEFAULT CURRENT_TIMESTAMP,
    message TEXT,
    intent TEXT,
    response TEXT
);   

步骤 7：创建前端界面

使用 HTML/CSS。JavaScript 也是如此。你可以使用 React 等框架。使用这些工具创建聊天界面。

步骤 8：一切都关乎测试和评估。

聊天机器人测试很重要。使用各种用户输入测试它至关重要。这些输入各不相同，涵盖了所有定义的意图和实体。评估其性能很重要。此评估应侧重于意图分类。提供的响应的准确性是另一个需要评估的关键方面。

Extensions

情感分析：添加情感分析是关键一步。此分析可识别用户情绪。聊天机器人可以相应地调整其响应。
语音集成：与语音识别 API 集成很重要。Google Speech-to-Text 是一个很好的例子。此集成允许语音交互。
转接人工支持：需要一个转接机制。如果聊天机器人无法解决查询，则将其转接给人工代理。这就是目的。

项目 2：使用 MNIST 进行手写数字识别

目的

训练一个 CNN 来使用 MNIST 数据集对数字（0-9）的手写体进行分类。

步骤：

步骤 1：加载数据集

使用 tf.keras.datasets.mnist 加载 60,000 个训练图像和 10,000 个测试图像，每个图像都标有 0-9。

步骤 2：预处理

标准化像素值（0-1 范围）并将图像重塑为 28x28x1。

步骤 3：构建模型

层：使用两个带有 ReLU 激活的 Conv2D 层，然后是 MaxPooling、Flatten、Dense 层和一个用于 10 个类别的 SoftMax 输出层。
编译：使用 Adam 优化器和分类交叉熵损失函数。

步骤 4：训练和测试

在 10 个 epoch 的数据上训练，并在 20% 的训练数据上进行验证。
在测试数据集上进行测试以获得准确率得分。

步骤 5：可视化

绘制训练/验证准确率曲线。显示一些示例预测。

扩展名

超参数已调整，添加了数据增强，甚至可以通过序列分割进行多数字识别。

import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Conv2D, MaxPooling2D, Flatten, Dense, Dropout
import matplotlib.pyplot as plt

# Load and preprocess the dataset
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0  # Normalize to 0-1
x_train = x_train.reshape(-1, 28, 28, 1)
x_test = x_test.reshape(-1, 28, 28, 1)

# Build the CNN model
model = Sequential([
    Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    MaxPooling2D(2, 2),
    Conv2D(64, (3, 3), activation='relu'),
    MaxPooling2D(2, 2),
    Flatten(),
    Dense(128, activation='relu'),
    Dropout(0.5),
    Dense(10, activation='softmax')
])

# Compile the model
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Train the model
history = model.fit(x_train, y_train, epochs=10, batch_size=64, validation_split=0.2)

# Evaluate on test data
test_loss, test_accuracy = model.evaluate(x_test, y_test)
print("Test accuracy:", test_accuracy)

# Plot training/validation accuracy
plt.plot(history.history['accuracy'], label='Training Accuracy')
plt.plot(history.history['val_accuracy'], label='Validation Accuracy')
plt.xlabel('Epoch')
plt.ylabel('Accuracy')
plt.legend()
plt.show()

# Display a sample prediction
import numpy as np
sample_idx = np.random.randint(len(x_test))
sample_image = x_test[sample_idx].reshape(28, 28)
predicted_label = model.predict(x_test[sample_idx].reshape(1, 28, 28, 1)).argmax()

plt.imshow(sample_image, cmap='gray')
plt.title(f"Predicted: {predicted_label}")
plt.show()   

说明

数据预处理

加载 MNIST 数据，将像素值标准化为 0-1，并将图像重塑为 CNN 输入。

模型架构：

Conv2D 层：使用滤波器（32 和 64）提取空间特征。
MaxPooling2D：下采样特征图以减小尺寸。
Flatten：将 2D 特征转换为 1D。
Dense 层：带有用于正则化的 dropout 的全连接层，最后是用于 10 类输出的 softmax。

编译和训练

使用 adam 优化器和交叉熵损失进行编译，训练 10 个 epoch。

评估和绘图

提供测试准确率以及训练验证准确率。

预报

生成一个随机选择的测试图像及其类别预测。

项目 3：情感分析工具

在此基础上，目标是构建一个模型，该模型分析任何给定的文本数据片段的情感是积极、消极还是中性，同时使用带有标签情感的简单数据集进行工作，例如，关于电影的评论集或任何可能存在的推文。

步骤：

步骤 1：数据

使用 IMDb 等数据集，其中包含正面和负面评论。现在，必须使用 tf.keras.datasets 等网站获取此数据集。或者你也可以在 R 中通过 Kaggle 下载它。

第二步：数据预处理

文本被分割成单词；这种现象称为分词。
删除停用词是常用词，如“and”、“the”等；它们对我们的讨论贡献不大。
填充：确保模型训练的输入具有固定长度。

步骤 3：模型开发

在文本序列上应用 LSTM 层。
顺序模型：设计一个 embedding 层，一个 LSTM 层，以及一个带有 sigmoid 激活的密集输出层，以实现二元分类。

步骤 4：编译和训练模型

使用二元交叉熵损失和 Adam 优化器进行编译。
用验证数据训练几个 epoch，看看效果如何。

步骤 5：评估和测试

在测试数据上评估模型准确率。
在自定义文本输入上测试模型预测。

import tensorflow as tf
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense, Dropout

# Sample Data Loading (use any labeled sentiment dataset)
(x_train, y_train), (x_test, y_test) = tf.keras.datasets.imdb.load_data(num_words=10000)

# Preprocess Data
max_length = 100  # Limit review length
x_train = pad_sequences(x_train, maxlen=max_length)
x_test = pad_sequences(x_test, maxlen=max_length)
# Build the Model
model = Sequential([
    Embedding(input_dim=10000, output_dim=32, input_length=max_length),
    LSTM(64, dropout=0.5, recurrent_dropout=0.5),
    Dense(1, activation='sigmoid')
])

# Compile Model
model.compile(optimizer='adam', loss='binary_crossentropy', metrics=['accuracy'])

# Train the Model
history = model.fit(x_train, y_train, epochs=5, batch_size=64, validation_split=0.2)

# Evaluate Model
test_loss, test_accuracy = model.evaluate(x_test, y_test)
print("Test Accuracy:", test_accuracy)

# Predict Sentiment of a Sample Text
sample_text = "This movie was fantastic and well-directed!"
tokenizer = Tokenizer(num_words=10000)
tokenizer.fit_on_texts([sample_text])
sequence = tokenizer.texts_to_sequences([sample_text])
padded_sequence = pad_sequences(sequence, maxlen=max_length)
prediction = model.predict(padded_sequence)
sentiment = "Positive" if prediction > 0.5 else "Negative"
print("Predicted Sentiment:", sentiment)   

说明

数据加载和预处理
- 加载 IMDB 数据集；将词汇量限制为 10,000。
- 将序列长度填充到最多 100 个单词，使输入大小相等。
模型架构
- Embedding 层：将单词转换为 32 维的密集向量
- LSTM 层：学习序列依赖性，使用 dropout 进行正则化。
- Dense 层：具有 sigmoid 激活的最终层，用于二元情感分类。
编译和训练
模型使用 adam 作为优化器和二元交叉熵损失进行编译，验证拆分为 5 个 epoch。
评估：在测试数据上评估模型。打印模型的准确率。
预测：分词并填充样本文本。根据输出概率将情感预测为“正面”或“负面”

项目 4：电影推荐系统

目的

设计一个系统，根据用户的兴趣向用户推荐电影，利用协同过滤或基于内容的过滤。

步骤：

步骤 1：数据收集

使用 MovieLens 数据集，可在 grouplens.org 上获取，其中包含用户评分、电影元数据和类型。

步骤 2：数据预处理

将数据加载到 DataFrame 中，例如在 movies.csv 和 ratings.csv 中。
根据公共列合并数据；例如，movieId 将每个评分与电影信息关联起来。

步骤 3：推荐技术

协同过滤：利用用户-物品交互-评分来查找相似用户或电影
基于内容的过滤：根据电影特征进行推荐-类型、导演是什么-因此，使用余弦相似度或 TF-IDF 进行文本特征分析

步骤 4：模型构建-协同过滤

使用奇异值分解 (SVD) 的矩阵分解来查找代表用户和电影偏好的潜在因子。
可选：如果你需要进行协同过滤，可以使用 Surprise 库。

步骤 5：进行推荐

计算相似度分数-对于基于内容-或分解用户-物品矩阵-对于协同过滤。
根据相似度分数或预测评分，获取特定用户或电影最相似的物品。

import pandas as pd
from surprise import Dataset, Reader, SVD
from surprise.model_selection import train_test_split
from surprise import accuracy

# Load and preprocess the MovieLens dataset
movies = pd.read_csv('movies.csv')
ratings = pd.read_csv('ratings.csv')

# Initialize the dataset for Surprise
reader = Reader(rating_scale=(1, 5))
data = Dataset.load_from_df(ratings[['userId', 'movieId', 'rating']], reader)
trainset, testset = train_test_split(data, test_size=0.2)

# Build and train the SVD model
model = SVD()
model.fit(trainset)

# Evaluate the model
predictions = model.test(testset)
rmse = accuracy.rmse(predictions)

# Make Recommendations for a specific user
user_id = 1
movies_watched = ratings[ratings['userId'] == user_id]['movieId']
all_movie_ids = movies['movieId'].unique()
unwatched_movies = [m for m in all_movie_ids if m not in movies_watched.values]

# Predict ratings for unwatched movies
recommended_movies = [(movie, model.predict(user_id, movie).est) for movie in unwatched_movies]
recommended_movies = sorted(recommended_movies, key=lambda x: x[1], reverse=True)[:5]

# Display recommended movies
recommended_titles = movies[movies['movieId'].isin([m[0] for m in recommended_movies])]
print("Recommended Movies for User", user_id)
print(recommended_titles[['title']])   

项目 5：简单的 NLP 聊天机器人

构建一个非常简单的聊天机器人，它可以使用自然语言处理技术（如文本预处理、词嵌入和序列模型）进行对话和回答问题。

步骤：

步骤 1：收集数据

一套问题和答案，或使用数据集，例如康奈尔电影对话集，其中包含对话交流。

步骤 2：分词

将文本分割成单词或句子。
清理：移除特殊字符，将文本转换为小写，并处理标点符号。
编码：使用词嵌入将单词转换为数字向量，如 Word2Vec 或 GloVe。

步骤 3：模型构建

基于 LSTM 层的编码器-解码器的基本 Seq2Seq 模型。
在对话对上训练模型以查找问答模式。

步骤 4：响应生成

用户查询：编码器-解码器模型根据训练数据返回响应。
使用束搜索或贪婪解码来恢复最可能的响应。

步骤 5：测试

使用不同的问题和响应测试聊天机器人。
收听更自然连贯的响应。

import numpy as np
import tensorflow as tf
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Embedding, LSTM, Dense, Bidirectional
from tensorflow.keras.preprocessing.text import Tokenizer
from tensorflow.keras.preprocessing.sequence import pad_sequences

# Sample training data (for demonstration)
questions = ["Hello", "How are you?", "What is your name?", "Tell me a joke"]
answers = ["Hi there!", "I'm a bot, feeling great!", "I am ChatBot.", "Why did the bot cross the road? To debug!"]

# Preprocess Data
tokenizer = Tokenizer()
tokenizer.fit_on_texts(questions + answers)
vocab_size = len(tokenizer.word_index) + 1
max_length = max(len(seq) for seq in tokenizer.texts_to_sequences(questions + answers))

# Convert text to sequences
questions_seq = pad_sequences(tokenizer.texts_to_sequences(questions), maxlen=max_length, padding='post')
answers_seq = pad_sequences(tokenizer.texts_to_sequences(answers), maxlen=max_length, padding='post')

# Model Building
model = Sequential([
    Embedding(vocab_size, 64, input_length=max_length),
    Bidirectional(LSTM(64, return_sequences=True)),
    LSTM(64),
    Dense(vocab_size, activation='softmax')
])

# Compile Model
model.compile(optimizer='adam', loss='sparse_categorical_crossentropy', metrics=['accuracy'])

# Prepare target data for training (shifted sequences for seq2seq learning)
answers_input = np.array(answers_seq)
answers_output = np.expand_dims(answers_seq, axis=-1)  # Target output

# Train Model
model.fit(questions_seq, answers_output, epochs=500)

# Function to predict response
def generate_response(input_text):
    input_seq = pad_sequences(tokenizer.texts_to_sequences([input_text]), maxlen=max_length, padding='post')
    prediction = model.predict(input_seq)
    response_seq = [np.argmax(token) for token in prediction[0]]
    response = " ".join([tokenizer.index_word[idx] for idx in response_seq if idx in tokenizer.index_word])
    return response

# Test the chatbot
print("Bot:", generate_response("Hello"))
print("Bot:", generate_response("Tell me a joke"))   

说明

数据准备

分词问题和答案，vocab_size 覆盖整个词汇表，max_length 覆盖最大序列的长度
将所有文本转换为填充后的序列，以便所有输入的大小都统一

模型架构

Embedding 层：密集词嵌入
Bidirectional LSTM：该层从两侧读取输入以理解上下文
LSTM 层：包含另一个 LSTM 层来捕获序列中的依赖关系
Dense 层：使用 softmax 在词汇表上输出单词的概率分布。

项目 6：使用迁移学习进行图像分类器

任务

使用预训练模型，例如 MobileNet、VGG16，将图像分类为预定义的类别，例如猫与狗或多个对象类别，同时训练时间短且准确率高。

步骤：

步骤 1：数据收集

使用图像数据集，最好是 CIFAR-10，但使用你自己的数据集也可以。这些应该预先标记，以便可以区分类别。

步骤 2：预处理

图像调整大小：所有图像都需要调整到预训练网络的输入大小。我们假设在这种情况下，VGG16 需要 224x224。
标准化：将像素值缩放到 0 到 1 之间以进行统一处理。

步骤 3：加载预训练模型

使用 tf.keras.applications 中的预训练网络 MobileNet 或 VGG16。
冻结基础层以保留学习的特征，并添加用于分类的自定义层（密集层和 dropout 层）。

步骤 4：编译和训练

使用分类交叉熵损失和 Adam 优化器
在多个 epoch 上进行微调以适应新类别

步骤 5：评估和测试

评估测试数据的模型准确率
使用自定义图像进行测试以验证分类器

import tensorflow as tf
from tensorflow.keras.preprocessing.image import ImageDataGenerator
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import Dense, GlobalAveragePooling2D, Dropout

# Data Preparation (assume 'train' and 'test' folders with subfolders for each class)
data_gen = ImageDataGenerator(rescale=1./255, validation_split=0.2)
train_data = data_gen.flow_from_directory('data/train', target_size=(224, 224), batch_size=32, class_mode='categorical', subset='training')
val_data = data_gen.flow_from_directory('data/train', target_size=(224, 224), batch_size=32, class_mode='categorical', subset='validation')

# Load Pre-trained Model
base_model = tf.keras.applications.MobileNetV2(input_shape=(224, 224, 3), include_top=False, weights='imagenet')
base_model.trainable = False  # Freeze base model layers

# Add Custom Layers
model = Sequential([
    base_model,
    GlobalAveragePooling2D(),
    Dropout(0.3),
    Dense(128, activation='relu'),
    Dropout(0.3),
    Dense(train_data.num_classes, activation='softmax')
])

# Compile the Model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Train the Model
history = model.fit(train_data, validation_data=val_data, epochs=5)

# Evaluate the Model
test_loss, test_accuracy = model.evaluate(val_data)
print("Validation Accuracy:", test_accuracy)

# Predict on a New Image
import numpy as np
from tensorflow.keras.preprocessing import image

def predict_image(img_path):
    img = image.load_img(img_path, target_size=(224, 224))
    img_array = image.img_to_array(img) / 255.0
    img_array = np.expand_dims(img_array, axis=0)
    predictions = model.predict(img_array)
    predicted_class = np.argmax(predictions)
    return train_data.class_indices, predicted_class

class_labels, prediction = predict_image('data/test/sample.jpg')
print("Predicted class:", list(class_labels.keys())[prediction])   

说明

数据准备

ImageDataGenerator 会从按每个类别组织的子文件夹中的文件夹调整图像大小并对其进行标准化。
flow_from_directory 加载数据，将其分为训练集（80%）和验证集（20%）。

模型设置

基础模型：加载预训练的 MobileNetV2（不包括顶层），并冻结它以保留学习到的特征。
自定义层：添加一个全局平均池化层，用于额外学习的密集层，以及一个用于多类预测的最终 softmax 层。

编译和训练

使用 adam 优化器和分类交叉熵损失编译模型，并在训练和验证数据上训练 5 个 epoch。

求值

评估模型在验证集上的性能并打印准确率。

预报

一个辅助函数处理新图像，将其通过模型运行，并根据模型的输出返回预测的类别索引。

项目 7：人脸检测应用程序

目标：使用预训练模型（例如 Haar 级联或深度学习模型（如 MTCNN））开发一种用于图像或视频流的人脸检测应用程序，该应用程序采用计算机视觉技术。

步骤：

步骤 1：环境设置

安装库：OpenCV 用于图像处理和人脸检测，Matplotlib 用于可视化。

步骤 2：加载预训练模型

加载预训练的人脸检测模型，例如 Haar 级联或深度学习模型（如 MTCNN）。

步骤 3：读取输入图像或视频

加载将进行人脸检测的图像或视频流。

步骤 4：人脸检测

将模型馈送以检测人脸。在检测到的人脸周围绘制边界框并显示输出。

步骤 5：使用不同输入进行测试

在多个图像或视频馈送上运行应用程序以测试人脸检测功能。

import cv2
import matplotlib.pyplot as plt

# Load pre-trained Haar cascade classifier for face detection
face_cascade = cv2.CascadeClassifier(cv2.data.haarcascades + 'haarcascade_frontalface_default.xml')

# Function to detect faces in an image
def detect_faces(image_path):
    # Read the image
    img = cv2.imread(image_path)
    img_gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)

    # Detect faces
    faces = face_cascade.detectMultiScale(img_gray, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

    # Draw rectangles around faces
    for (x, y, w, h) in faces:
        cv2.rectangle(img, (x, y), (x + w, y + h), (255, 0, 0), 2)

    return img, faces

# Test with an example image
image_path = 'data/test/image.jpg'  # Replace with your image path
detected_image, detected_faces = detect_faces(image_path)

# Display the output image with detected faces
plt.imshow(cv2.cvtColor(detected_image, cv2.COLOR_BGR2RGB))
plt.axis('off')
plt.title(f'Detected Faces: {len(detected_faces)}')
plt.show()

# Optionally, run face detection on video stream
def detect_faces_in_video():
    cap = cv2.VideoCapture(0)  # Open video capture (0 for webcam)
    
    while True:
        ret, frame = cap.read()
        if not ret:
            break
        
        gray_frame = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
        faces = face_cascade.detectMultiScale(gray_frame, scaleFactor=1.1, minNeighbors=5, minSize=(30, 30))

        for (x, y, w, h) in faces:
            cv2.rectangle(frame, (x, y), (x + w, y + h), (255, 0, 0), 2)
        
        cv2.imshow('Face Detection', frame)
        
        # Exit on 'q' key
        if cv2.waitKey(1) & 0xFF == ord('q'):
            break

    cap.release()
    cv2.destroyAllWindows()

# Uncomment to run video detection
# detect_faces_in_video()   

说明

加载 Haar 级联：加载 Haar 级联模型以检测正面人脸。
检测人脸：在 detect_faces 函数中，检测人脸并用矩形突出显示。
显示结果：使用 Matplotlib 显示带有检测到人脸的图像。
可选视频检测：另一个函数允许使用网络摄像头实时进行人脸检测。

项目 8：手写数字识别系统

目标

开发一个系统，可以使用机器学习，特别是卷积神经网络 (CNN)，从图像中识别手写数字（0-9）。

步骤：

第一步：数据收集

使用 MNIST 数据集，该数据集包含 70,000 张手写数字图像。它作为 TensorFlow 和 Keras 安装的一部分。

步骤 2：数据预处理

通过整数除以 255 将像素值缩放到 0-1 之间。
使用重塑图像的形状以适应 CNN 请求的输入形状（该形状期望为 28x28 像素）。

步骤 3：模型构建

使用卷积层和池化层配置 CNN 架构，这些层可以组合成密集输出层
使用 ReLU 和 softmax 进行分类激活。

步骤 4：编译和训练

使用分类交叉熵损失和优化器：Adam 编译模型。
在训练数据集上训练，在验证数据集上验证

步骤 5：测试/评估

在测试集上评估模型的准确率。
使用此模型对新图像的手写数字进行分类。

import numpy as np
import tensorflow as tf
from tensorflow.keras import layers, models
from tensorflow.keras.datasets import mnist
import matplotlib.pyplot as plt

# Load MNIST dataset
(x_train, y_train), (x_test, y_test) = mnist.load_data()

# Preprocess Data
x_train = x_train.astype('float32') / 255.0  # Normalize to [0, 1]
x_test = x_test.astype('float32') / 255.0
x_train = np.expand_dims(x_train, -1)  # Add channel dimension
x_test = np.expand_dims(x_test, -1)

# One-hot encoding of labels
y_train = tf.keras.utils.to_categorical(y_train, 10)
y_test = tf.keras.utils.to_categorical(y_test, 10)

# Build the CNN Model
model = models.Sequential([
    layers.Conv2D(32, (3, 3), activation='relu', input_shape=(28, 28, 1)),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.MaxPooling2D((2, 2)),
    layers.Conv2D(64, (3, 3), activation='relu'),
    layers.Flatten(),
    layers.Dense(64, activation='relu'),
    layers.Dense(10, activation='softmax')
])

# Compile the Model
model.compile(optimizer='adam', loss='categorical_crossentropy', metrics=['accuracy'])

# Train the Model
history = model.fit(x_train, y_train, epochs=5, batch_size=64, validation_split=0.2)

# Evaluate the Model
test_loss, test_accuracy = model.evaluate(x_test, y_test)
print("Test Accuracy:", test_accuracy)

# Function to Predict a Handwritten Digit
def predict_digit(image):
    image = np.expand_dims(image, axis=0)  # Add batch dimension
    prediction = model.predict(image)
    return np.argmax(prediction)

# Test Prediction on a Sample Image
sample_image = x_test[0]  # Get a sample from the test set
predicted_digit = predict_digit(sample_image)

# Display the Sample Image and Prediction
plt.imshow(sample_image.squeeze(), cmap='gray')
plt.title(f'Predicted Digit: {predicted_digit}')
plt.axis('off')
plt.show()   

说明

数据加载：加载 MNIST 数据集，该数据集包含手写数字的训练集和测试集。
预处理：标准化和重塑图像格式，使其成为 CNN 模型中的适当输入
CNN 架构：模型采用卷积层进行特征提取，然后进行密集应用进行分类。
训练和评估：模型将使用 MNIST 数据集进行训练和测试，这可能会提供高准确率。
预测函数：分配一个函数来从新图像中预测数字，并呈现一个示例图像作为视觉证据。

项目 9：实时目标检测系统

目标

构建一个实时目标检测系统，在该系统中，视频流中的对象使用预训练的深度学习模型进行识别和标记，该模型可以是 YOLO (You Only Look Once) 或 SSD (Single Shot Detector)。

步骤：

步骤 1：环境设置

安装 OpenCV 和 TensorFlow（或 PyTorch）来处理视频流和模型加载。

步骤 2：加载预训练模型

我们将使用一个预训练模型，可以是 YOLOv3 或 SSD，它可以检测大多数通用对象，如人、汽车和动物。
YOLO 的模型和配置文件可从 Darknet 或 OpenCV 的 DNN 模块等来源获得。

步骤 3：读取视频流

从网络摄像头或外部视频源捕获实时视频馈送

步骤 4：检测目标

将视频馈送帧传递给模型
在检测到的对象周围绘制边界框并显示标签

步骤 5：显示结果

实时显示带有边界框和每个检测对象的标签的视频

import cv2
import numpy as np

# Load YOLO model and classes
net = cv2.dnn.readNet('yolov3.weights', 'yolov3.cfg')
layer_names = net.getLayerNames()
output_layers = [layer_names[i[0] - 1] for i in net.getUnconnectedOutLayers()]

with open('coco.names', 'r') as f:
    classes = f.read().strip().split('\n')

# Real-time video feed
cap = cv2.VideoCapture(0)

while True:
    ret, frame = cap.read()
    if not ret:
        break
    
    # Preprocess frame
    blob = cv2.dnn.blobFromImage(frame, 0.00392, (416, 416), (0, 0, 0), True, crop=False)
    net.setInput(blob)
    detections = net.forward(output_layers)
    
    # Process detections
    for detection in detections:
        for object_detection in detection:
            scores = object_detection[5:]
            class_id = np.argmax(scores)
            confidence = scores[class_id]
            if confidence > 0.5:
                center_x, center_y, width, height = (object_detection[0:4] * np.array([frame.shape[1], frame.shape[0]] * 2)).astype(int)
                x = int(center_x - width / 2)
                y = int(center_y - height / 2)
                cv2.rectangle(frame, (x, y), (x + width, y + height), (255, 0, 0), 2)
                cv2.putText(frame, f"{classes[class_id]} {confidence:.2f}", (x, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, (255, 255, 255), 2)
    cv2.imshow('Object Detection', frame)
    if cv2.waitKey(1) == ord('q'):
        break
cap.release()
cv2.destroyAllWindows()   

说明

导入：OpenCV 用于视频处理；NumPy 用于数组操作。
加载 YOLO 模型：YOLO_model 如下 yolov3.weights 和 yolov3.cfg 用于目标检测。
类别和层：读取类别名称并确定 YOLO 的输出层。
视频捕获：启动网络摄像头并处理每一帧。
目标检测：对每一帧运行 blob，将其发送到模型，然后循环检测置信度高于 0.5 的对象。
显示结果：绘制带标签的边界框；显示视频。按“q”键退出。

项目 10：语音转文本转录系统

目标

构建一个系统，可以使用自动语音识别 (ASR) 模型将口语转换为文本。

步骤：

步骤 1：设置环境

安装 SpeechRecognition 和 pyaudio 用于处理音频，以及 gTTS (Google Text-to-Speech) 用于可选播放。

步骤 2：开始语音识别

使用 SpeechRecognition 库中的 recognizer 来使用麦克风并记录音频输入。

步骤 3：语音转录

通过 recognizer 方法（例如，recognize_google - Google 的 ASR）将音频转换为文本

步骤 4：输出/保存转录

在终端以书面形式返回或将文本保存到文本文件中。

import speech_recognition as sr

# Initialize the recognizer
recognizer = sr.Recognizer()

def transcribe_audio():
    with sr.Microphone() as source:
        print("Listening for audio input...")
        recognizer.adjust_for_ambient_noise(source)  # Adjust to background noise
        audio = recognizer.listen(source)
        
        try:
            # Transcribe using Google's ASR
            text = recognizer.recognize_google(audio)
            print("Transcribed Text:", text)
        except sr.UnknownValueError:
            print("Could not understand audio.")
        except sr.RequestError:
            print("Could not request results; check your network connection.")

# Run transcription function
transcribe_audio()   

说明

导入和设置：使用 SpeechRecognition 创建一个用于捕获音频的 recognizer。
收听和转录：降噪，收听来自麦克风的音频，并使用 Google 的 ASR 进行实时转录。
显示：打印转录内容，或者在音频不清晰或网络失败的情况下处理错误。

下一主题使用线性回归进行波士顿房价 Kaggle 挑战

Python

Java

.Net Framework

AI, ML and Data Science

Cloud Technology

B.Tech and MCA

Web Technology

PHP

Software Testing

Technical Interview

Java Interview

Python

Web Interview

Database Interview

B.Tech / MCA

Important Interview

Software Testing Interview

Company Interviews

Online Compilers

Multiple Choice Questions

人工智能

智能体

解决问题

对抗性搜索

知识表示

不确定知识 R.

AI 的子集

现实世界中的 AI

人工智能选择题

其他

相关教程

十大人工智能迷你项目

项目 1：客户支持聊天机器人

项目目标

关键概念

技术栈

分步实施

Extensions

项目 2：使用 MNIST 进行手写数字识别

目的

步骤：

扩展名

说明

项目 3：情感分析工具

步骤：

说明

项目 4：电影推荐系统

目的

步骤：

项目 5：简单的 NLP 聊天机器人

步骤：

说明

项目 6：使用迁移学习进行图像分类器

任务

步骤：

说明

项目 7：人脸检测应用程序

步骤：

说明

项目 8：手写数字识别系统

目标

步骤：

说明

项目 9：实时目标检测系统

目标

步骤：

说明

项目 10：语音转文本转录系统

目标

步骤：

说明

相关帖子

如何制作自己的 AI（人工智能）？

人工智能在证券市场的应用

AI 伦理（AI 道德准则）

深度学习在人工智能中的应用

用于大数据分析的人工智能

人工智能的环境影响

最佳人工智能游戏

手机中的人工智能