深度学习 Day14——P3天气识别

SARIMAX时间序列预测实战:从季节性识别到业务归因 时间序列预测中,当数据呈现固定周期重复模式(如日周期、周周期、月周期),传统ARIMA模型因缺乏对‘节奏感’的建模能力而表现滞后。SARIMAX作为其增强版本,在保留ARIMA短期记忆机制基础上,引入季节性结构(p,d,q)(P,D,Q)s,并支持外生变量(exogenous variables)融合,实现统计规律与业务驱动因素的解耦建模。该模型具备强可解释性——系数可直接映射为‘去年同月影响0.83单位’‘气温每升1℃销量增0.45杯’等业务语言,广泛应用于零售库存、能源负荷、物流调度等场景。本文聚焦真实 阅读详情


前言

本文将采用pytorch框架创建CNN网络,实现天气识别。讲述实现代码与执行结果,并浅谈涉及知识点。
关键字: torchvision.transforms.Compose()详解,pathlib中glob匹配多个格式文件获取数据列表,plt.tight_layout()作用,x.view()函数,The freeze_support error解决方案,提升测试acc–改变优化器。

1 我的环境

  • 电脑系统:Windows 11
  • 语言环境:python 3.8.6
  • 编译器:pycharm2020.2.3
  • 深度学习环境:
    torch == 1.9.1+cu111
    torchvision == 0.10.1+cu111
  • 显卡:NVIDIA GeForce RTX 4070

2 代码实现与执行结果

2.1 前期准备

2.1.1 引入库

import torch
import torch.nn as nn

from torchvision import transforms, datasets
import os
from pathlib import Path
from PIL import Image
from torchinfo import summary
import torch.nn.functional as F
import matplotlib.pyplot as plt

plt.rcParams['font.sans-serif'] = ['SimHei']  # 用来正常显示中文标签
plt.rcParams['axes.unicode_minus'] = False  # 用来正常显示负号
plt.rcParams['figure.dpi'] = 100  # 分辨率
import warnings

warnings.filterwarnings('ignore')  # 忽略一些warning内容,无需打印

2.1.2 设置GPU(如果设备上支持GPU就使用GPU,否则使用CPU)

"""前期准备-设置GPU"""
# 如果设备上支持GPU就使用GPU,否则使用CPU
 device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
 print("Using {} device".format(device))

输出

Using cuda device

2.1.3 导入数据

'''前期工作-导入数据'''
data_dir = "D:/DeepLearning/data/weather_photos/"
data_dir = Path(data_dir)

data_paths = list(data_dir.glob('*'))
classeNames = [str(path).split("\\")[-1] for path in data_paths]
print(classeNames)

输出

['cloudy', 'rain', 'shine', 'sunrise']

2.1.4 可视化数据

'''前期工作-可视化数据'''
# 指定图像文件夹路径
image_folder = os.path.join(data_dir, 'cloudy/')
# 获取文件夹中的所有图像文件
image_files = [f for f in os.listdir(image_folder) if f.endswith((".jpg", ".png", ".jpeg"))]
# 创建Matplotlib图像
fig, axes = plt.subplots(3, 8, figsize=(16, 6))
# 使用列表推导式加载和显示图像
for ax, img_file in zip(axes.flat, image_files):
    img_path = os.path.join(image_folder, img_file)
    img = Image.open(img_path)
    ax.imshow(img)
    ax.axis('off')
# 显示图像
plt.tight_layout()
plt.show()

在这里插入图片描述

2.1.4 图像数据变换

'''前期工作-图像数据变换'''
total_datadir = data_dir

# 关于transforms.Compose的更多介绍可以参考:https://blog.youkuaiyun.com/qq_38251616/article/details/124878863
train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),  # 将输入图片resize成统一尺寸
    transforms.ToTensor(),  # 将PIL Image或numpy.ndarray转换为tensor,并归一化到[0,1]之间
    transforms.Normalize(  # 标准化处理-->转换为标准正太分布(高斯分布),使模型更容易收敛
        mean=[0.485, 0.456, 0.406],
        std=[0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])
total_data = datasets.ImageFolder(total_datadir, transform=train_transforms)
print(total_data)

输出

Dataset ImageFolder
    Number of datapoints: 1125
    Root location: D:\DeepLearning\data\weather_photos
    StandardTransform
Transform: Compose(
               Resize(size=[224, 224], interpolation=bilinear, max_size=None, antialias=None)
               ToTensor()
               Normalize(mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225])
           )

2.1.4 划分数据集

'''前期工作-划分数据集'''
train_size = int(0.8 * len(total_data))  # train_size表示训练集大小,通过将总体数据长度的80%转换为整数得到;
test_size = len(total_data) - train_size  # test_size表示测试集大小,是总体数据长度减去训练集大小。
# 使用torch.utils.data.random_split()方法进行数据集划分。该方法将总体数据total_data按照指定的大小比例([train_size, test_size])随机划分为训练集和测试集,
# 并将划分结果分别赋值给train_dataset和test_dataset两个变量。
train_dataset, test_dataset = torch.utils.data.random_split(total_data, [train_size, test_size])
print(train_dataset, test_dataset)

输出

<torch.utils.data.dataset.Subset object at 0x000001A0144E8D00> <torch.utils.data.dataset.Subset object at 0x000001A0144E8DC0>

2.1.4 加载数据

'''前期工作-加载数据'''
batch_size = 32

train_dl = torch.utils.data.DataLoader(train_dataset,
                                       batch_size=batch_size,
                                       shuffle=True,
                                       num_workers=1)
test_dl = torch.utils.data.DataLoader(test_dataset,
                                      batch_size=batch_size,
                                      shuffle=True,
                                      num_workers=1)

2.1.4 查看数据

'''前期工作-查看数据'''
for X, y in test_dl:
    print("Shape of X [N, C, H, W]: ", X.shape)
    print("Shape of y: ", y.shape, y.dtype)
    break

输出

Shape of X [N, C, H, W]:  torch.Size([32, 3, 224, 224])
Shape of y:  torch.Size([32]) torch.int64

2.2 构建CNN网络模型

在这里插入图片描述

"""构建CNN网络"""
class Network_bn(nn.Module):
    def __init__(self):
        super(Network_bn, self).__init__()
        """
        nn.Conv2d()函数:
        第一个参数(in_channels)是输入的channel数量
        第二个参数(out_channels)是输出的channel数量
        第三个参数(kernel_size)是卷积核大小
        第四个参数(stride)是步长,默认为1
        第五个参数(padding)是填充大小,默认为0
        """
        self.conv1 = nn.Conv2d(in_channels=3, out_channels=12, kernel_size=5, stride=1, padding=0)
        self.bn1 = nn.BatchNorm2d(12)
        self.conv2 = nn.Conv2d(in_channels=12, out_channels=12, kernel_size=5, stride=1, padding=0)
        self.bn2 = nn.BatchNorm2d(12)
        self.pool = nn.MaxPool2d(2, 2)
        self.conv4 = nn.Conv2d(in_channels=12, out_channels=24, kernel_size=5, stride=1, padding=0)
        self.bn4 = nn.BatchNorm2d(24)
        self.conv5 = nn.Conv2d(in_channels=24, out_channels=24, kernel_size=5, stride=1, padding=0)
        self.bn5 = nn.BatchNorm2d(24)
        self.fc1 = nn.Linear(24 * 50 * 50, len(classeNames))

    def forward(self, x):
        x = F.relu(self.bn1(self.conv1(x)))
        x = F.relu(self.bn2(self.conv2(x)))
        x = self.pool(x)
        x = F.relu(self.bn4(self.conv4(x)))
        x = F.relu(self.bn5(self.conv5(x)))
        x = self.pool(x)
        x = x.view(-1, 24 * 50 * 50)
        x = self.fc1(x)

        return x
        
model = Network_bn().to(device)
print(model)
summary(model)        

输出

Network_bn(
  (conv1): Conv2d(3, 12, kernel_size=(5, 5), stride=(1, 1))
  (bn1): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv2): Conv2d(12, 12, kernel_size=(5, 5), stride=(1, 1))
  (bn2): BatchNorm2d(12, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (pool): MaxPool2d(kernel_size=2, stride=2, padding=0, dilation=1, ceil_mode=False)
  (conv4): Conv2d(12, 24, kernel_size=(5, 5), stride=(1, 1))
  (bn4): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (conv5): Conv2d(24, 24, kernel_size=(5, 5), stride=(1, 1))
  (bn5): BatchNorm2d(24, eps=1e-05, momentum=0.1, affine=True, track_running_stats=True)
  (fc1): Linear(in_features=60000, out_features=4, bias=True)
)
=================================================================
Layer (type:depth-idx)                   Param #
=================================================================
Network_bn                               --
├─Conv2d: 1-1                            912
├─BatchNorm2d: 1-2                       24
├─Conv2d: 1-3                            3,612
├─BatchNorm2d: 1-4                       24
├─MaxPool2d: 1-5                         --
├─Conv2d: 1-6                            7,224
├─BatchNorm2d: 1-7                       48
├─Conv2d: 1-8                            14,424
├─BatchNorm2d: 1-9                       48
├─Linear: 1-10                           240,004
=================================================================
Total params: 266,320
Trainable params: 266,320
Non-trainable params: 0
=================================================================

2.3 训练模型

2.3.1 训练模型

"""训练模型--设置超参数"""
loss_fn = nn.CrossEntropyLoss()  # 创建损失函数,计算实际输出和真实相差多少,交叉熵损失函数,事实上,它就是做图片分类任务时常用的损失函数
learn_rate = 1e-4  # 学习率
opt = torch.optim.SGD(model.parameters(), lr=learn_rate)  # 作用是定义优化器,用来训练时候优化模型参数;其中,SGD表示随机梯度下降,用于控制实际输出y与真实y之间的相差有多大

2.3.2 编写训练函数

"""训练模型--编写训练函数"""
# 训练循环
def train(dataloader, model, loss_fn, optimizer):
    size = len(dataloader.dataset)  # 训练集的大小,一共60000张图片
    num_batches = len(dataloader)  # 批次数目,1875(60000/32)

    train_loss, train_acc = 0, 0  # 初始化训练损失和正确率

    for X, y in dataloader:  # 加载数据加载器,得到里面的 X(图片数据)和 y(真实标签)
        X, y = X.to(device), y.to(device) # 用于将数据存到显卡

        # 计算预测误差
        pred = model(X)  # 网络输出
        loss = loss_fn(pred, y)  # 计算网络输出和真实值之间的差距,targets为真实值,计算二者差值即为损失

        # 反向传播
        optimizer.zero_grad()  # 清空过往梯度
        loss.backward()  # 反向传播,计算当前梯度
        optimizer.step()  # 根据梯度更新网络参数

        # 记录acc与loss
        train_acc += (pred.argmax(1) == y).type(torch.float).sum().item()
        train_loss += loss.item()

    train_acc /= size
    train_loss /= num_batches

    return train_acc, train_loss

2.3.3 编写测试函数

"""训练模型--编写测试函数"""
# 测试函数和训练函数大致相同,但是由于不进行梯度下降对网络权重进行更新,所以不需要传入优化器
def test(dataloader, model, loss_fn):
    size = len(dataloader.dataset)  # 测试集的大小,一共10000张图片
    num_batches = len(dataloader)  # 批次数目,313(10000/32=312.5,向上取整)
    test_loss, test_acc = 0, 0

    # 当不进行训练时,停止梯度更新,节省计算内存消耗
    with torch.no_grad(): # 测试时模型参数不用更新,所以 no_grad,整个模型参数正向推就ok,不反向更新参数
        for imgs, target in dataloader:
            imgs, target = imgs.to(device), target.to(device)

            # 计算loss
            target_pred = model(imgs)
            loss = loss_fn(target_pred, target)

            test_loss += loss.item()
            test_acc += (target_pred.argmax(1) == target).type(torch.float).sum().item()#统计预测正确的个数

    test_acc /= size
    test_loss /= num_batches

    return test_acc, test_loss

2.3.4 正式训练

"""训练模型--正式训练"""
epochs = 20
train_loss = []
train_acc = []
test_loss = []
test_acc = []

for epoch in range(epochs):
    model.train()
    epoch_train_acc, epoch_train_loss = train(train_dl, model, loss_fn, opt)

    model.eval()
    epoch_test_acc, epoch_test_loss = test(test_dl, model, loss_fn)

    train_acc.append(epoch_train_acc)
    train_loss.append(epoch_train_loss)
    test_acc.append(epoch_test_acc)
    test_loss.append(epoch_test_loss)

    template = ('Epoch:{:2d}, Train_acc:{:.1f}%, Train_loss:{:.3f}, Test_acc:{:.1f}%,Test_loss:{:.3f}')
    print(template.format(epoch + 1, epoch_train_acc * 100, epoch_train_loss, epoch_test_acc * 100, epoch_test_loss))
print('Done')

输出

Epoch: 1, Train_acc:55.8%, Train_loss:1.098, Test_acc:58.7%,Test_loss:1.073
Epoch: 2, Train_acc:79.8%, Train_loss:0.682, Test_acc:74.2%,Test_loss:1.073
Epoch: 3, Train_acc:83.7%, Train_loss:0.536, Test_acc:78.2%,Test_loss:0.552
Epoch: 4, Train_acc:85.3%, Train_loss:0.472, Test_acc:80.9%,Test_loss:0.466
Epoch: 5, Train_acc:88.4%, Train_loss:0.412, Test_acc:82.7%,Test_loss:0.477
Epoch: 6, Train_acc:88.8%, Train_loss:0.367, Test_acc:88.0%,Test_loss:0.418
Epoch: 7, Train_acc:90.7%, Train_loss:0.318, Test_acc:88.4%,Test_loss:0.411
Epoch: 8, Train_acc:91.4%, Train_loss:0.288, Test_acc:86.2%,Test_loss:0.371
Epoch: 9, Train_acc:91.8%, Train_loss:0.289, Test_acc:86.7%,Test_loss:0.377
Epoch:10, Train_acc:91.4%, Train_loss:0.282, Test_acc:89.3%,Test_loss:0.342
Epoch:11, Train_acc:93.1%, Train_loss:0.248, Test_acc:89.3%,Test_loss:0.332
Epoch:12, Train_acc:93.6%, Train_loss:0.230, Test_acc:87.6%,Test_loss:0.344
Epoch:13, Train_acc:94.8%, Train_loss:0.216, Test_acc:88.9%,Test_loss:0.381
Epoch:14, Train_acc:94.2%, Train_loss:0.206, Test_acc:87.6%,Test_loss:0.340
Epoch:15, Train_acc:94.8%, Train_loss:0.199, Test_acc:88.4%,Test_loss:0.316
Epoch:16, Train_acc:94.7%, Train_loss:0.205, Test_acc:88.4%,Test_loss:0.475
Epoch:17, Train_acc:95.7%, Train_loss:0.222, Test_acc:86.7%,Test_loss:0.340
Epoch:18, Train_acc:96.1%, Train_loss:0.200, Test_acc:88.0%,Test_loss:0.319
Epoch:19, Train_acc:95.4%, Train_loss:0.182, Test_acc:88.4%,Test_loss:0.337
Epoch:20, Train_acc:96.8%, Train_loss:0.192, Test_acc:89.3%,Test_loss:0.304
Done

2.4 结果可视化

"""训练模型--结果可视化"""
epochs_range = range(epochs)

plt.figure(figsize=(12, 3))
plt.subplot(1, 2, 1)

plt.plot(epochs_range, train_acc, label='Training Accuracy')
plt.plot(epochs_range, test_acc, label='Test Accuracy')
plt.legend(loc='lower right')
plt.title('Training and Validation Accuracy')

plt.subplot(1, 2, 2)
plt.plot(epochs_range, train_loss, label='Training Loss')
plt.plot(epochs_range, test_loss, label='Test Loss')
plt.legend(loc='upper right')
plt.title('Training and Validation Loss')
plt.show()

在这里插入图片描述

3 知识点详解

3.1 torchvision.transforms.Compose()详解

torchvision是pytorch的一个图形库,它服务于PyTorch深度学习框架的,主要用来构建计算机视觉模型。torchvision.transforms主要是用于常见的一些图形变换。以下是torchvision的构成:

1.torchvision.datasets: 一些加载数据的函数及常用的数据集接口;
2.torchvision.models: 包含常用的模型结构(含预训练模型),例如AlexNet、VGG、ResNet等;
3.torchvision.transforms: 常用的图片变换,例如裁剪、旋转等;
4.torchvision.utils: 其他的一些有用的方法。

torchvision.transforms.Compose()类的主要作用是串联多个图片变换的操作。

from torchvision.transforms import transforms

train_transforms = transforms.Compose([
    transforms.Resize([224, 224]),                  # 将输入图片resize成统一尺寸
    transforms.RandomRotation(degrees=(-10, 10)),   # 随机旋转,-10到10度之间随机选
    transforms.RandomHorizontalFlip(p=0.5),         # 随机水平翻转 选择一个概率概率
    transforms.RandomVerticalFlip(p=0.5),           # 随机垂直翻转
    transforms.RandomPerspective(distortion_scale=0.6, p=1.0),    # 随机视角
    transforms.GaussianBlur(kernel_size=(5, 9), sigma=(0.1, 5)),  # 随机选择的高斯模糊模糊图像
    transforms.ToTensor(),          # 将PIL Image或numpy.ndarray转换为tensor,并归一化到[0,1]之间
    transforms.Normalize(           # 标准化处理-->转换为标准正太分布(高斯分布),使模型更容易收敛
        mean=[0.485, 0.456, 0.406], 
        std = [0.229, 0.224, 0.225])  # 其中 mean=[0.485,0.456,0.406]与std=[0.229,0.224,0.225] 从数据集中随机抽样计算得到的。
])

参考链接:torchvision.transforms.Compose()详解【Pytorch入门手册】

3.2 pathlib中glob匹配多个格式文件获取数据列表

可视化数据可用另一种方式显示

'''数据预处理-可视化数据'''
    cloudyPath = Path(data_dir)/"cloudy"
    image_files = list(p.resolve() for p in cloudyPath.glob('*') if p.suffix in [".jpg", ".png", ".jpeg"])

    plt.figure(figsize=(16, 6))
    for i in range(len(image_files[:24])):
        image_file = image_files[i]
        ax = plt.subplot(3, 8, i + 1)
        img = Image.open(str(image_file))
        plt.imshow(img)
        plt.axis("off")
    # 显示图片
    plt.tight_layout()
    plt.show()

3.3 plt.tight_layout()作用

tight_layout会自动调整子图参数,使之填充整个图像区域。这是个实验特性,可能在一些情况下不工作。它仅仅检查坐标轴标签、刻度标签以及标题的部分。

当你拥有多个子图时,你会经常看到不同轴域的标签叠在一起。

plt.rcParams['savefig.facecolor'] = "0.8"

def example_plot(ax, fontsize=12):
     ax.plot([1, 2])
     ax.locator_params(nbins=3)
     ax.set_xlabel('x-label', fontsize=fontsize)
     ax.set_ylabel('y-label', fontsize=fontsize)
     ax.set_title('Title', fontsize=fontsize)

plt.close('all')
fig, ((ax1, ax2), (ax3, ax4)) = plt.subplots(nrows=2, ncols=2)
example_plot(ax1)
example_plot(ax2)
example_plot(ax3)
example_plot(ax4)

产生图片:
在这里插入图片描述
增加plt.tight_layout()会调整子图之间的间隔来减少堆叠。
在这里插入图片描述
参考链接:plt.tight_layout()

3.4 x.view()函数

在构建神经网络的时候,经常会用到x.view()函数,实际上view()类似于reshape()的用法,将张量重新规划格式,本文将简单介绍这个函数的用法。

import torch

a = torch.arange(1,17)
print(a.shape)
print(a)
a = a.view(-1,4)
print(a.shape)
print(a)

输出

torch.Size([16])
tensor([ 1,  2,  3,  4,  5,  6,  7,  8,  9, 10, 11, 12, 13, 14, 15, 16])
torch.Size([4, 4])
tensor([[ 1,  2,  3,  4],
        [ 5,  6,  7,  8],
        [ 9, 10, 11, 12],
        [13, 14, 15, 16]])

这里view的第一个参数有时会是-1,-1代表不确定,行数将由张量的长度除以列数决定,也就是说
a.view(-1,4) == a.view(4,4)
a.view(-1,8) == a.view(2,8)

参考链接:x.view(-1,4)

3.5 The freeze_support error解决方案

RuntimeError:
       An attempt has been made to start a new process before the
       current process has finished its bootstrapping phase.

   This probably means that you are not using fork to start your
   child processes and you have forgotten to use the proper idiom
   in the main module:

       if __name__ == '__main__':
           freeze_support()
           ...

   The "freeze_support()" line can be omitted if the program
   is not going to be frozen to produce an executable.

这个错误相信很多人都碰到过,就是,在Linux中可以很好运行的代码,在Windows中会给出这样的错误。
究其原因,往往出现在multiprocess上。当程序中调用 multiprocess函数,却不是在main中时,会出现这样的报错。

解决方案:
写一个main函数,然后在if name == ‘main’:中运行这个main函数。把那些引用multiprocessing的函数作都放到main()函数里去执行就OK了。
参考链接:Windows freeze_support Error: An attempt has been made to start a new process

3.6 提升测试acc–改变优化器

原文优化器设置为SDG

opt = torch.optim.Adam(model.parameters(), lr=learn_rate) 

变更优化器为Adam后,代码如下

opt = torch.optim.Adam(model.parameters(), lr=learn_rate) 

变更后,测试精度提升

Epoch: 2, Train_acc:84.2%, Train_loss:0.435, Test_acc:90.2%,Test_loss:0.257
Epoch: 3, Train_acc:89.1%, Train_loss:0.323, Test_acc:84.9%,Test_loss:0.481
Epoch: 4, Train_acc:89.3%, Train_loss:0.346, Test_acc:91.6%,Test_loss:0.218
Epoch: 5, Train_acc:91.3%, Train_loss:0.272, Test_acc:92.9%,Test_loss:0.271
Epoch: 6, Train_acc:96.9%, Train_loss:0.183, Test_acc:94.7%,Test_loss:0.184
Epoch: 7, Train_acc:93.8%, Train_loss:0.261, Test_acc:92.0%,Test_loss:0.312
Epoch: 8, Train_acc:95.6%, Train_loss:0.141, Test_acc:92.4%,Test_loss:0.203
Epoch: 9, Train_acc:97.2%, Train_loss:0.143, Test_acc:94.2%,Test_loss:0.170
Epoch:10, Train_acc:93.1%, Train_loss:0.224, Test_acc:93.8%,Test_loss:0.265
Epoch:11, Train_acc:95.3%, Train_loss:0.275, Test_acc:93.8%,Test_loss:0.211
Epoch:12, Train_acc:95.6%, Train_loss:0.164, Test_acc:94.7%,Test_loss:0.196
Epoch:13, Train_acc:98.2%, Train_loss:0.066, Test_acc:93.3%,Test_loss:0.432
Epoch:14, Train_acc:99.0%, Train_loss:0.052, Test_acc:95.1%,Test_loss:0.191
Epoch:15, Train_acc:98.7%, Train_loss:0.087, Test_acc:93.3%,Test_loss:0.248
Epoch:16, Train_acc:96.8%, Train_loss:0.156, Test_acc:93.8%,Test_loss:0.290
Epoch:17, Train_acc:97.7%, Train_loss:0.067, Test_acc:93.8%,Test_loss:0.268
Epoch:18, Train_acc:99.1%, Train_loss:0.036, Test_acc:94.7%,Test_loss:0.388
Epoch:19, Train_acc:99.6%, Train_loss:0.021, Test_acc:95.6%,Test_loss:0.176
Epoch:20, Train_acc:99.9%, Train_loss:0.012, Test_acc:95.1%,Test_loss:0.181
Done

在这里插入图片描述
优化器的详解可以参考链接深度学习 Day11——T11优化器对比实验

总结

通过本文的学习,遇到The freeze_support error问题,网上检索该问题解决方案,顺利解决该问题,并通过改变优化器的方式,提升了原有模型的测试精度。

阿里云Qwen-Audio-3.0-TTS-Plus语音合成实战指南 文本转语音(TTS)技术作为人工智能语音合成的重要分支,通过深度学习模型将文字信息转化为自然流畅的语音输出。其技术原理基于端到端的神经网络架构,能够学习语音的韵律、音调和情感特征。在工程实践中,TTS技术的价值体现在提升人机交互体验、实现无障碍通信以及降低内容制作成本等方面。该技术广泛应用于智能语音助手、有声内容制作、教育培训和客服系统等场景。以阿里云Qwen-Audio-3.0-TTS-Plus为例,该模型在语音自然度和情感表达方面表现优异,支持流式合成和情感标签控制等高级功能。通过合理的API集成和参数 阅读详情

相关推荐

零售销量预测实战:混合模型架构与业务驱动的时序建模

销量预测本质是业务逻辑与时间序列规律的协同建模,而非单纯拟合历史曲线。其核心原理在于分离可解释的业务干预(如促销、断货)、高维非线性特征(天气、竞品、节假日)与纯粹时间依赖(周/季度周期、趋势)。技术价值体现在稳定性提升与线上可控性增强——混合架构通过规则层保障可干预性、树模型层处理异构特征、SARIMAX层校准残差,显著缓解促销干扰和冷启动问题。典型应用场景覆盖区域连锁超市的14天日粒度采购决策,尤其适用于历史数据不足、业务规则复杂、实时性要求高的零售产线。本文聚焦真实项目中验证有效的双阶差分、滞后滑动窗

掬水月在手,弄花香满衣 417

深度学习 Day 2——如何利用CNN实现天气识别?

21天学习挑战赛——深度学习 Day 2

北天的博客 3248

Python时间序列分析实战:可解释、可审计、可落地的工作流

时间序列分析是金融、工业、零售等领域的核心预测技术,其本质是建模数据随时间演化的规律性与不确定性。原理上需兼顾平稳性检验、周期分解、特征构造与因果对齐,而非简单套用LSTM或Prophet等黑箱模型。技术价值在于将预测结果转化为业务可理解、可干预、可归因的决策依据,显著提升模型在真实场景中的可信度与复用性。典型应用场景包括销量预测、设备故障预警、电力负荷调度等,尤其适用于需满足SLA、接受人工审核、对接运维系统的生产环境。本文基于pandas、statsmodels与scikit-learn构建端到端可解释

weixin_30514745的博客 441

深度学习 Day26——利用Pytorch实现天气识别

365天深度学习训练营[第十六周]——本期博客我们将学习利用Pytorch实现天气识别,并在谷歌的colab平台进行我们的模型训练,最后再调用我们训练好的模型堆本地的一张图片进行预测,具体更多内容就在本期博客中!

北天的博客 3526

非科班转行数据科学的18个月真实进阶路径

数据科学不是调包拼凑,而是数学直觉、工程能力与业务语感三位一体的实践学科。从线性回归的几何直观到PCA的降维本质,从手写SVD实现到特征工程中的缺失值归因,其核心在于建立‘问题—原理—代码—业务’的闭环认知。尤其对非科班学习者,跳过黑箱操作、直击梯度下降的三维动态过程、在真实销售数据中验证统计显著性,才能跨越Kaggle幻觉与生产环境的鸿沟。本文聚焦Data Science落地所需的肌肉记忆构建,涵盖数学筑基、工程锚定、业务翻译三大阶段,助力零基础者扎实迈入企业级数据岗位。

xjwolaile的博客 393

YOLOv8施工现场安全检测系统:从原理到工程部署实践

目标检测作为计算机视觉的核心技术,通过深度学习算法实现对图像中特定物体的识别与定位。其原理基于卷积神经网络提取特征,结合边界框回归和分类器完成精准检测。在工程实践中,目标检测技术能够实现自动化监控和智能分析,大幅提升作业效率。特别是在安全生产领域,该技术可应用于安全帽佩戴识别、反光衣检测、危险区域入侵预警等场景。基于YOLOv8的施工现场安全检测系统,将先进的目标检测算法与建筑行业安全管理需求深度结合,通过实时视频分析实现7×24小时不间断安全监控。系统支持GPU加速推理,处理速度可达30-60FPS,检测

weixin_30323631的博客 561

深度学习P3-实现天气识别

本文为🔗中的学习记录博客我的环境:1.语言:python3.72.编译器:pycharm。

qq_66033623的博客 256

时序预测基准测试:5个经典模型构建可复现评估流程

时间序列预测本质上是建模历史依赖与业务规律的双重任务。其核心原理在于通过稳定、可解释、低维护成本的方法建立性能下限,从而量化后续模型的真实增益。技术价值体现在消除无效调参、暴露数据本质特性、支撑生产环境确定性交付;典型应用场景覆盖电商销量、电力负荷、物流时效及用户活跃度等需滚动预测的业务系统。实践中,简单移动平均(SMA)和指数平滑(ETS)作为最基础但强鲁棒性的基线,能快速揭示序列平稳性与趋势季节结构,是避免过度拟合与资源浪费的第一道标尺。

congran6617的博客 1046

Pytorch实战 | P3 天气图片识别(深度学习实践pytorch)

● 语言环境:Python3.8● 编译器:pycharm● 深度学习环境:Pytorch代码主流程 main.py。

weixin_35820421的博客 1098

【信息科学与工程学】计算机科学与自动化——第十八篇 存储系统设计 10 存储器/存储软件/存储芯片/存储盘/存储系统/存储网络01

③ MTJ电阻 → 界面:TMR=(R_AP-R_P)/R_P = 2P₁P₂/(1-P₁P₂) (Julliere模型);③ 访问延迟模型 → 统计:平均访问延迟 = p_hot * t_dram + (1-p_hot) * t_nvm + t_migration_overhead;:① 储能电容计算 → 数学物理:所需能量 E = P * t_backup,电容 C = 2E / (V_start² - V_end²);:① B-tree平衡 → 代数:树高 h = log_m(N),m为扇出;

weixin_49199313的博客 266

Python天气预测与可视化实战:从API数据到线性回归完整指南

在数据驱动的开发场景中,从公开接口获取真实数据、完成清洗与建模,并通过图表呈现结果,是机器学习与数据分析入门必须掌握的核心能力。本文围绕这一通用技术链路,讲解如何通过requests调用开放气象API获取历史天气数据,利用pandas完成缺失值与异常值处理,再基于scikit-learn构建线性回归模型实现温度预测,同时使用matplotlib与pyecharts绘制静态和交互式可视化图表。整个过程覆盖数据获取、特征构造、模型训练、误差评估、图表美化与文档整理,不仅适用于期末课程设计,也能为真实业务中的趋势

weixin_34277853的博客 371

Pytorch入门实战第三周:天气识别

🍨本文为[🔗365天深度学习训练营](https://mp.weixin.qq.com/s/rbOOmire8OocQ90QM78DRA) 中的学习记录博客​​​​​​K同学啊本周学习目标:基本目标——本地读取并加载数据、测试集上的Accuracy达到93;拔高目标——通过调整使得Accuracy达到95%;调用模型识别一张本地的图片学习重点:通过本地数据加载,调整模型参数以提高在测试集上的Accuracy。

weixin_46620278的博客 1212

盘古天气大模型:3D地球Transformer与分层时间聚合的气象AI范式革命

气象AI正从传统数值预报(NWP)向数据驱动范式演进,其核心在于如何融合物理先验与深度学习。3D地球特异性Transformer通过球面坐标嵌入、垂直注意力掩码和多物理量解耦头,突破了ViT等视觉模型在球面气象数据上的结构性失真;分层时间聚合则以多尺度并行预测替代自回归迭代,显著抑制误差累积并保障物理一致性。这类技术不仅提升中程全球预报精度与速度,更推动AI4S在气象业务系统中实现可插拔、可验证、可回溯的工程落地。盘古天气大模型正是这一范式跃迁的标志性实践。

weixin_42554042的博客 245

CLIP ViT-H-14实战案例:城市街景图像时序变化分析与异常事件识别

本文介绍了如何在星图GPU平台上自动化部署CLIP ViT-H-14图像编码服务,实现城市街景时序变化分析与异常事件识别。该方案通过提取图像特征向量并计算时序相似度,可高效检测违章建筑、道路损坏等异常变化,为智慧城市管理提供AI技术支持。

weixin_42575109的博客 225

【Qt-4】QT基于qhttp-server搭建http服务器

QT搭建http服务器

WXG1011的博客 5715

车规级非易失存储选型指南:从AEC-Q100到ISO 26262的可靠性设计

非易失存储器是电子系统中负责长期保存关键数据与代码的核心组件,其可靠性直接决定了系统的长期稳定运行能力。在汽车电子领域,这一要求被提升到了极致,必须满足严苛的车规级标准。从原理上看,存储器的数据保持能力、擦写寿命等关键参数在高温、振动等恶劣环境下会急剧衰减,因此需要专门的设计与验证。其技术价值在于保障车辆全生命周期的功能安全与数据完整性,避免因存储失效导致的安全隐患或频繁维护。应用场景涵盖从发动机控制单元、自动驾驶域控制器到智能座舱的各类电子控制单元。本文聚焦于车规级非易失存储的选型,深入解析AEC-Q10

weixin_30938149的博客 460

一文搞懂循环神经网络(RNN)

RNN与传统神经网络 循环神经网络是专门处理序列数据的神经网络,传统的神经网络模型(左图),输入层(input layer)到隐藏层(hidden layer),隐藏层再到输出层(output layer),层与层之间是全连接的,但是隐藏层节点之间是无连接的。循环神经网络(右图),隐藏层节点之间是有连接的。 RNN的基本结构 其中,右图圆形的箭头表示隐藏层的自连接。 在RNN中,每一层都共享参数U、V、W,降低了网络中需要学习的参数,提高学习效率。 输入单元(input units)记为: 隐藏单元

mint1993的专栏 6028

电源工程师必看:平均电流模式BUCK双环控制详解(从传递函数到Psim仿真)

本文详细解析了平均电流模式BUCK变换器的双环控制策略,从传递函数推导到Psim仿真实现。针对电源工程师关注的环路设计和稳定性问题,深入比较了电压模式、峰值电流模式和平均电流模式的优缺点,并提供了12V/3A BUCK变换器的完整设计案例,帮助工程师掌握平均电流控制这一中高功率应用的首选方案。

weixin_42696271的博客 400

数学建模竞赛实战:基于LightGBM与优化模型的生鲜商品定价补货决策

在零售供应链管理中,需求预测与库存优化是核心挑战,尤其在生鲜这类高损耗、需求波动大的品类中。其基本原理是通过历史销售数据,分析价格、季节性、天气等多因素对销量的影响,构建精准的需求预测模型。这一技术的价值在于将依赖经验的决策转化为数据驱动的科学决策,从而显著降低损耗、提升利润。典型的应用场景包括超市每日的蔬菜水果补货与动态定价。本文以2023年高教社杯国赛C题为背景,深入探讨了如何运用LightGBM等机器学习算法进行需求预测,并结合非线性规划模型进行定价与补货的联合优化,为参赛者提供了一套从数据处理、特征

weixin_33770878的博客 418

RAGFlow源码解析-2、从源码构架ragflow v0.25.0镜像

本文详细记录了从零开始构建自定义RAGFlow镜像lt/ragflow:0.25.0的全过程。首先介绍了环境准备,包括检查Node.js、Docker版本和项目结构。然后详细说明了构建步骤:编译前端、创建自定义Dockerfile、构建镜像和验证。接着讲解了docker-compose配置修改要点,包括网络定义、MySQL依赖处理等。最后总结了部署过程中遇到的五个关键问题及解决方案,包括networks未定义、MySQL服务依赖、tiktoken文件缺失、数据库配置错误和端口映射问题。通过完整的操作流程和问

liutao841204的专栏 364

基于STM32的便携式心率血氧监测系统 | 保姆式教程 开源可复刻

本项目基于STM32F103C8T6核心控制器,完整实现了便携式心率血氧监测系统的全功能开发,覆盖MAX30102光电传感器驱动、PPG信号处理、心率血氧解算算法、人机交互、数据存储、报警保护、低功耗管理等核心功能,全程采用无跳步保姆式教学,从硬件选型、接线、CubeMX配置、代码开发、调试优化全流程拆解,跟着步骤一步步操作,就能顺利完成项目复刻

ZhongWeiXiang9的博客 769

MyEMS集成LSTM:能源负荷预测实战,准确率稳定95%

时间序列预测是工业能源管理的核心需求之一,传统统计方法受限于线性假设,难以捕捉工厂负荷的周期性与随机波动。长短期记忆网络(LSTM)通过门控机制保留长期依赖,在非线性时序建模中表现突出。在开源能源管理系统MyEMS中,结合数据清洗、特征工程与模型部署,可构建高精度负荷预测模块。本文以实际项目为例,展示从数据预处理到LSTM训练、评估及回写MyEMS的完整链路,最终将运行时段预测准确率稳定在95%左右,为需量管控、光伏储能调度提供决策支持。

weixin_34081595的博客 368

手把手教你:在openEuler 22.03上离线搞定OpenSSH 9.8升级(CentOS 7.9通用)

本文详细介绍了在openEuler 22.03和CentOS 7.9系统上离线升级OpenSSH 9.8的完整流程,包括准备工作、离线包获取、安装步骤、服务管理及回滚方案。特别针对无外网环境的企业服务器,提供安全可靠的离线升级解决方案,帮助运维人员有效提升系统安全性。

weixin_30682415的博客 194

回归树入门:用‘如果…那么…’思维理解机器学习

回归树是机器学习中最基础、最可解释的预测模型,其核心思想是通过递归分组实现数值预测,而非依赖复杂数学公式。它基于业务决策逻辑,将连续目标变量按特征阈值离散化为多个局部均值,天然适配存在断点规则的实际场景(如运营时段、促销周期、天气阈值)。相比线性模型,回归树不假设数据平滑,更擅长捕捉隐性分段关系与非线性交互;其分裂准则(如方差最小)背后实为业务可解释性、数据稳定性与计算效率三重约束的平衡。作为XGBoost、随机森林等集成方法的基学习器,回归树既是可落地的独立工具,也是理解更复杂AI模型的思维起点。

weixin_33713503的博客 378

《干货满满!AI 应用架构师打造 AI 驱动生产计划的实战技巧》

生产计划是制造企业的“大脑”——它决定了买什么物料、产多少产品、用什么设备、什么时候交货,直接影响企业的成本、效率和客户满意度。需求预测靠经验,误差常超20%;排产依赖Excel,调整一次要3天;供应链协同靠邮件,物料延迟导致停产屡见不鲜。作为AI应用架构师,我们的任务是用AI重新“激活”这个“大脑”——用数据驱动的预测替代经验判断,用智能优化替代人工排产,用实时协同替代被动响应。本文结合3个制造业实战案例5段可运行代码2个数字孪生模型,从架构设计→核心模块实现→落地踩坑。

移动开发前沿的博客 1089

RK3588与FocalTech触摸屏代码适配全解析:从原理到实战

摘要:本文详细介绍了瑞芯微RK3588处理器与FocalTech触摸屏的适配过程,包括硬件特性、驱动加载、设备树配置和常见问题解决方案。RK3588作为8nm工艺的高性能处理器,具备强大的计算能力和丰富的接口资源;FocalTech触摸屏则采用电容式技术,支持I2C/SPI接口。适配关键步骤包括驱动程序加载、硬件连接检查、设备树配置和内核版本兼容性处理,并提供了代码示例和问题排查方法。随着嵌入式设备智能化发展,该适配技术将持续优化,为智能交互提供更优解决方案。

远程部署调试 运行安装 项目调试 二次开发 项目技术新 持续迭代 部分源码免费分享 273
上一篇: 深度学习 Day13——P2彩色图片分类
下一篇: 深度学习 Day15——P4猴痘病识别
LittleRuby
博客等级 码龄7年 465粉丝 38原创
评论 1
成就一亿技术人!
拼手气红包6.0元
还能输入1000个字符
 
 条评论被折叠 查看
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付:10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值