【深度学习】PyTorch深度学习实践 - Lecture_10_Basic_CNN

news2024/12/27 11:14:57

文章目录

  • 一、CNN基础流程图
  • 二、CNN的两个阶段
  • 三、卷积的基本知识
    • 3.1 单信道的卷积
    • 3.2 三信道的卷积
    • 3.3 N信道卷积
    • 3.4 输入N信道-输出M信道卷积
    • 3.5 卷积层的常见参数
      • 3.5.1 Padding
      • 3.5.2 Stride
      • 3.5.3 下采样(MaxPooling)
  • 四、实现一个简单的CNN
    • 4.1 网络结构图
    • 4.2 PyTorch代码-CPU
    • 4.3 PyTorch代码-GPU
    • 4.4 课后作业(尝试更复杂的CNN)


一、CNN基础流程图

卷积:对数据升维
下采样:对数据降维

在这里插入图片描述

二、CNN的两个阶段

特征提取阶段:通过卷积下采样对图像数据进行升维和降维,从而实现特征提取
分类器:将特征提取阶段输出的数据展平成一维,再通过全连接层进行分类

在这里插入图片描述

三、卷积的基本知识

卷积后数据维度会变(比如信道数增加、宽度和高度减小)

在这里插入图片描述

3.1 单信道的卷积

在这里插入图片描述

然后通过滑动卷积框,多次进行卷积计算,直到卷积框移动到Input最下最右,此时就将输出矩阵的信息补充完整了

在这里插入图片描述

3.2 三信道的卷积

在这里插入图片描述
在这里插入图片描述
在这里插入图片描述

3.3 N信道卷积

在这里插入图片描述

3.4 输入N信道-输出M信道卷积

原理:采用M个卷积核对Input进行卷积,这样就得到了M层的输出

在这里插入图片描述
在这里插入图片描述

PyTorch代码实现卷积:

import torch

in_channels, out_channels = 5, 10  # 输入信道数、输出信道数
w, h = 100, 100  # 输入图片尺寸
kernel_size = (3, 3)  # 卷积核大小3*3
batch_size = 1  # 每次参与模型更新的数据数量
input = torch.randn(batch_size, in_channels, w, h)  # torch.randn 随机产生输入数据
conv_layer = torch.nn.Conv2d(in_channels, out_channels, kernel_size=kernel_size)  # 定义卷积层(输入信道数,输出信道数,卷积核大小)
output = conv_layer(input)  # 进行卷积操作
# 输出输入、输出和卷积层权重的形状
print(input.shape)
print(output.shape)
print(conv_layer.weight.shape)

输出:

torch.Size([1, 5, 100, 100])
torch.Size([1, 10, 98, 98])
torch.Size([10, 5, 3, 3])

3.5 卷积层的常见参数

3.5.1 Padding

Padding:在输入数据的四周进行扩展的数量,比如Padding = (1,1)代表在输入数据的四周一圈扩展并填充0
一般地:
当卷积核大小为3×3时:Padding=(1,1)
当卷积核大小为5×5时:Padding=(2,2)

当卷积核大小为n×n时:Padding=(m,m),其中 m =(n-1)/2,n为奇数

在这里插入图片描述

Padding默认填充0

在这里插入图片描述

Padding的意义:

  • 为了不丢弃原图信息
  • 为了保持feature map 的大小与原图一致
  • 为了让更深层的layer的input依旧保持有足够大的信息量
  • 为了实现上述目的,且不做多余的事情,padding出来的pixel的值都是0,不存在噪音问题。

PyTorch代码体会Padding:

import torch

input = [3, 4, 6, 5, 7,
         2, 4, 6, 8, 2,
         1, 6, 7, 8, 4,
         9, 7, 4, 6, 2,
         3, 7, 5, 4, 1]
input = torch.Tensor(input).view(1, 1, 5, 5)
conv_layer = torch.nn.Conv2d(1, 1, kernel_size=(3, 3), padding=(1, 1), bias=False)
kernel = torch.Tensor([1, 2, 3, 4, 5, 6, 7, 8, 9]).view(1, 1, 3, 3)
conv_layer.weight.data = kernel.data
output = conv_layer(input)
print(output)

输出:

tensor([[[[ 91., 168., 224., 215., 127.],
          [114., 211., 295., 262., 149.],
          [192., 259., 282., 214., 122.],
          [194., 251., 253., 169.,  86.],
          [ 96., 112., 110.,  68.,  31.]]]], grad_fn=<ThnnConv2DBackward>)

3.5.2 Stride

Stride:卷积核滑动的步长,为一个元组。如Stride =(2,2)分别表示宽和高方向上的滑动步长

在这里插入图片描述

PyTorch代码体会Stride:

import torch

input = [3, 4, 6, 5, 7,
         2, 4, 6, 8, 2,
         1, 6, 7, 8, 4,
         9, 7, 4, 6, 2,
         3, 7, 5, 4, 1]
input = torch.Tensor(input).view(1, 1, 5, 5)
conv_layer = torch.nn.Conv2d(1, 1, kernel_size=(3, 3), stride=(2, 2), bias=False)
kernel = torch.Tensor([1, 2, 3, 4, 5, 6, 7, 8, 9]).view(1, 1, 3, 3)
conv_layer.weight.data = kernel.data
output = conv_layer(input)
print(output)

输出:

tensor([[[[211., 262.],
          [251., 169.]]]], grad_fn=<ThnnConv2DBackward>)

3.5.3 下采样(MaxPooling)

最常用的下采样方法是最大池化(Max Pooling)
如下图所示,MaxPooling=(2,2),即将输入数据分成四个(2,2)无交集的区域,然后选取每个区域的最大值作为输出数据

在这里插入图片描述

由MaxPooling的计算特性可知,MaxPooling不会对信道的数量产生影响

PyTorch代码体会MaxPooling:

import torch

input = [3, 4, 6, 5,
         2, 4, 6, 8,
         1, 6, 7, 5,
         9, 7, 4, 6]
input = torch.Tensor(input).view(1, 1, 4, 4)
max_pooling_layer = torch.nn.MaxPool2d(kernel_size=(2, 2))
output = max_pooling_layer(input)
print(output)

输出:

tensor([[[[4., 8.],
          [9., 7.]]]])

四、实现一个简单的CNN

4.1 网络结构图

在这里插入图片描述
在这里插入图片描述

4.2 PyTorch代码-CPU

构建网络模型:

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=(5, 5))
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=(5, 5))
        self.pooling = torch.nn.MaxPool2d((2, 2))
        self.fc = torch.nn.Linear(320, 10)

    def forward(self, x):
        batch_size = x.size(0)
        x = torch.relu(self.pooling(self.conv1(x)))
        x = torch.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1)
        x = self.fc(x)
        return x

完整代码:

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.optim as optim


class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=(5, 5))
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=(5, 5))
        self.pooling = torch.nn.MaxPool2d((2, 2))
        self.fc = torch.nn.Linear(320, 10)

    def forward(self, x):
        batch_size = x.size(0)
        x = torch.relu(self.pooling(self.conv1(x)))
        x = torch.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1)
        x = self.fc(x)
        return x


# 单次训练函数
def train(epoch, criterion):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0


# 单次测试函数
def ttt():
    correct = 0.0
    total = 0.0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('Accuracy on test set: %d %% [%d/%d]' % (100 * correct / total, correct, total))


if __name__ == '__main__':
    batch_size = 64
    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
    train_dataset = datasets.MNIST(root='../dataset/', train=True, download=True, transform=transform)

    train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)

    test_dataset = datasets.MNIST(root='../dataset/', train=False, download=True, transform=transform)
    test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)

    # 声明模型
    model = Net()
    # 定义损失函数
    criterion = torch.nn.CrossEntropyLoss()
    # 定义优化器
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

    for epoch in range(10):
        train(epoch, criterion)
        ttt()

输出:

[1,   300] loss: 0.564
[1,   600] loss: 0.191
[1,   900] loss: 0.141
Accuracy on test set: 96 %
[2,   300] loss: 0.110
[2,   600] loss: 0.092
[2,   900] loss: 0.088
Accuracy on test set: 97 %
[3,   300] loss: 0.079
[3,   600] loss: 0.072
[3,   900] loss: 0.069
Accuracy on test set: 98 %
[4,   300] loss: 0.064
[4,   600] loss: 0.056
[4,   900] loss: 0.063
Accuracy on test set: 98 %
[5,   300] loss: 0.052
[5,   600] loss: 0.053
[5,   900] loss: 0.055
Accuracy on test set: 98 %
[6,   300] loss: 0.048
[6,   600] loss: 0.050
[6,   900] loss: 0.045
Accuracy on test set: 98 %
[7,   300] loss: 0.048
[7,   600] loss: 0.042
[7,   900] loss: 0.041
Accuracy on test set: 98 %
[8,   300] loss: 0.039
[8,   600] loss: 0.042
[8,   900] loss: 0.040
Accuracy on test set: 98 %
[9,   300] loss: 0.039
[9,   600] loss: 0.034
[9,   900] loss: 0.039
Accuracy on test set: 98 %
[10,   300] loss: 0.034
[10,   600] loss: 0.036
[10,   900] loss: 0.035
Accuracy on test set: 98 %

4.3 PyTorch代码-GPU

import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.optim as optim


class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 10, kernel_size=(5, 5))
        self.conv2 = torch.nn.Conv2d(10, 20, kernel_size=(5, 5))
        self.pooling = torch.nn.MaxPool2d((2, 2))
        self.fc = torch.nn.Linear(320, 10)

    def forward(self, x):
        batch_size = x.size(0)
        x = torch.relu(self.pooling(self.conv1(x)))
        x = torch.relu(self.pooling(self.conv2(x)))
        x = x.view(batch_size, -1)
        x = self.fc(x)
        return x


# 单次训练函数
def train(epoch, criterion):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        # 将inputs, target转移到Gpu或者Cpu上
        inputs, target = inputs.to(device), target.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0


# 单次测试函数
def ttt():
    correct = 0.0
    total = 0.0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            # 将images, labels转移到Gpu或者Cpu上
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('Accuracy on test set: %d %% [%d/%d]' % (100 * correct / total, correct, total))


if __name__ == '__main__':
    batch_size = 64
    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
    train_dataset = datasets.MNIST(root='../dataset/', train=True, download=True, transform=transform)

    train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)

    test_dataset = datasets.MNIST(root='../dataset/', train=False, download=True, transform=transform)
    test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

    # 声明模型
    model = Net()
    # 将模型转移道Gpu或者Cpu上
    model.to(device)
    # 定义损失函数
    criterion = torch.nn.CrossEntropyLoss()
    # 定义优化器
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

    for epoch in range(10):
        train(epoch, criterion)
        ttt()

输出:

[1,   300] loss: 0.666
[1,   600] loss: 0.206
[1,   900] loss: 0.148
Accuracy on test set: 96 % [9652/10000]
[2,   300] loss: 0.117
[2,   600] loss: 0.109
[2,   900] loss: 0.097
Accuracy on test set: 97 % [9749/10000]
[3,   300] loss: 0.080
[3,   600] loss: 0.082
[3,   900] loss: 0.077
Accuracy on test set: 98 % [9804/10000]
[4,   300] loss: 0.067
[4,   600] loss: 0.070
[4,   900] loss: 0.062
Accuracy on test set: 98 % [9814/10000]
[5,   300] loss: 0.056
[5,   600] loss: 0.060
[5,   900] loss: 0.059
Accuracy on test set: 98 % [9845/10000]
[6,   300] loss: 0.053
[6,   600] loss: 0.047
[6,   900] loss: 0.054
Accuracy on test set: 98 % [9855/10000]
[7,   300] loss: 0.047
[7,   600] loss: 0.048
[7,   900] loss: 0.044
Accuracy on test set: 98 % [9845/10000]
[8,   300] loss: 0.044
[8,   600] loss: 0.041
[8,   900] loss: 0.042
Accuracy on test set: 98 % [9883/10000]
[9,   300] loss: 0.040
[9,   600] loss: 0.039
[9,   900] loss: 0.041
Accuracy on test set: 98 % [9867/10000]
[10,   300] loss: 0.038
[10,   600] loss: 0.036
[10,   900] loss: 0.038
Accuracy on test set: 98 % [9872/10000]

4.4 课后作业(尝试更复杂的CNN)

在这里插入图片描述

PyTorch-GPU代码实现:

除了上图所示的改变外,我还做了以下2点改变:

  • 为了获得更多的特征。增加了每个层的信道数量
  • 为了获得更多的特征,并考虑到计算量开销,采取了卷积核大小逐层递减的策略,第一层卷积核大小设置为(9,9),第二层卷积核大小设置为(7,7),第三层卷积核大小设置为(5,5),为了保证足够多的特征数量,每一层都采用了padding
import torch
from torchvision import transforms
from torchvision import datasets
from torch.utils.data import DataLoader
import torch.optim as optim


class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.conv1 = torch.nn.Conv2d(1, 20, padding=(4, 4), kernel_size=(9, 9))
        self.conv2 = torch.nn.Conv2d(20, 40, padding=(3, 3), kernel_size=(7, 7))
        self.conv3 = torch.nn.Conv2d(40, 60, padding=(2, 2), kernel_size=(5, 5))
        self.pooling = torch.nn.MaxPool2d((2, 2))
        self.fc1 = torch.nn.Linear(540, 256)
        self.fc2 = torch.nn.Linear(256, 10)

    def forward(self, x):
        batch_size = x.size(0)
        x = torch.relu(self.pooling(self.conv1(x)))
        x = torch.relu(self.pooling(self.conv2(x)))
        x = torch.relu(self.pooling(self.conv3(x)))
        x = x.view(batch_size, -1)
        x = torch.relu(self.fc1(x))
        x = self.fc2(x)
        return x


# 单次训练函数
def train(epoch, criterion):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        # 将inputs, target转移到Gpu或者Cpu上
        inputs, target = inputs.to(device), target.to(device)
        optimizer.zero_grad()
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()
        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %5d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0


# 单次测试函数
def ttt():
    correct = 0.0
    total = 0.0
    with torch.no_grad():
        for data in test_loader:
            images, labels = data
            # 将images, labels转移到Gpu或者Cpu上
            images, labels = images.to(device), labels.to(device)
            outputs = model(images)
            _, predicted = torch.max(outputs.data, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('Accuracy on test set: %d %% [%d/%d]' % (100 * correct / total, correct, total))


if __name__ == '__main__':
    batch_size = 64
    transform = transforms.Compose([transforms.ToTensor(), transforms.Normalize((0.1307,), (0.3081,))])
    train_dataset = datasets.MNIST(root='../dataset/', train=True, download=True, transform=transform)

    train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)

    test_dataset = datasets.MNIST(root='../dataset/', train=False, download=True, transform=transform)
    test_loader = DataLoader(test_dataset, shuffle=False, batch_size=batch_size)

    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")

    # 声明模型
    model = Net()
    # 将模型转移道Gpu或者Cpu上
    model.to(device)
    # 定义损失函数
    criterion = torch.nn.CrossEntropyLoss()
    # 定义优化器
    optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)

    for epoch in range(10):
        train(epoch, criterion)
        ttt()

输出:

[1,   300] loss: 1.350
[1,   600] loss: 0.215
[1,   900] loss: 0.139
Accuracy on test set: 96 % [9684/10000]
[2,   300] loss: 0.103
[2,   600] loss: 0.090
[2,   900] loss: 0.079
Accuracy on test set: 98 % [9800/10000]
[3,   300] loss: 0.070
[3,   600] loss: 0.064
[3,   900] loss: 0.060
Accuracy on test set: 98 % [9856/10000]
[4,   300] loss: 0.048
[4,   600] loss: 0.053
[4,   900] loss: 0.051
Accuracy on test set: 98 % [9833/10000]
[5,   300] loss: 0.044
[5,   600] loss: 0.040
[5,   900] loss: 0.041
Accuracy on test set: 98 % [9850/10000]
[6,   300] loss: 0.032
[6,   600] loss: 0.039
[6,   900] loss: 0.036
Accuracy on test set: 98 % [9889/10000]
[7,   300] loss: 0.027
[7,   600] loss: 0.033
[7,   900] loss: 0.031
Accuracy on test set: 99 % [9906/10000]
[8,   300] loss: 0.023
[8,   600] loss: 0.028
[8,   900] loss: 0.027
Accuracy on test set: 99 % [9903/10000]
[9,   300] loss: 0.022
[9,   600] loss: 0.025
[9,   900] loss: 0.023
Accuracy on test set: 98 % [9873/10000]
[10,   300] loss: 0.020
[10,   600] loss: 0.019
[10,   900] loss: 0.021
Accuracy on test set: 99 % [9910/10000]

从输出结果可以看出,正确率从之前的98%提升至了99%,说明本节建立的三层CNN模型比之前的两层CNN模型具有更好的特征提取能力和分类能力。

本文来自互联网用户投稿,该文观点仅代表作者本人,不代表本站立场。本站仅提供信息存储空间服务,不拥有所有权,不承担相关法律责任。如若转载,请注明出处:http://www.coloradmin.cn/o/83359.html

如若内容造成侵权/违法违规/事实不符,请联系多彩编程网进行投诉反馈,一经查实,立即删除!

相关文章

【案例教程】气象数值预报WRF-DA资料同化系统理论、运行与变分、混合同化新方法技术

【视频教程】WRF DA资料同化系统理论、运行与与变分、混合同化新方法技术应用https://mp.weixin.qq.com/s?__bizMzAxNzcxMzc5MQ&mid2247518760&idx1&snddbc45296acc595402434b88bc179a27&chksm9be39538ac941c2eabab2492e997827d0e1269de3b229fadee72f1223bbcd…

机器学习实战教程(三):决策树实战篇

一、前言 上篇文章机器学习实战教程&#xff08;二&#xff09;&#xff1a;决策树基础篇之让我们从相亲说起机器学习实战教程&#xff08;二&#xff09;&#xff1a;决策树基础篇_M_Q_T的博客-CSDN博客机器学习实战教程&#xff08;二&#xff09;&#xff1a;决策树基础篇之…

web前端期末大作业 html+css+javascript汽车销售网站 学生网页设计实例 企业网站制作

&#x1f389;精彩专栏推荐 &#x1f4ad;文末获取联系 ✍️ 作者简介: 一个热爱把逻辑思维转变为代码的技术博主 &#x1f482; 作者主页: 【主页——&#x1f680;获取更多优质源码】 &#x1f393; web前端期末大作业&#xff1a; 【&#x1f4da;毕设项目精品实战案例 (10…

JQuery高级(回调函数 clearInterval 插件)

回调函数&#xff1a; 定义&#xff1a;回调函数被认为是一种高级函数&#xff0c;一种被作为参数传递给另一个函数的高级函数。回调函数的本质是一种模式(一种解决常见问题的模式)&#xff0c;因此回调函数也被称为回调模式。 简而言之&#xff1a;一个函数在另一个函数中…

Vue3+Vite项目按需自动导入配置及常见问题修复

文章目录一、Vue API自动导入1.1 配置unplugin-auto-import1.2 可能遇到ts,eslint不识别而导入报错的问题1.3 配置src/component目录下的组件自动引入二、按需引入UI组件库&#xff08;antd,element-plus&#xff09;2.1、按需引入element-plus2.2 ant-design-vue 按需引入2.3 …

Qt多线程调用gdal库接口

作者:朱金灿 来源:clever101的专栏 为什么大多数人学不会人工智能编程?>>> 效果图和程序说明 效果图如下: 这个程序是Qt的GUI程序,用于给指定的图像文件创建金字塔。 为什么要使用多线程 使用多线程的好处主要有两点: 1.多线程在很多时候显得更人性化些。比…

计算机研究生就业方向之去大厂做售前

我一直跟学生们说你考计算机的研究生之前一定要想好你想干什么&#xff0c;如果你只是转码&#xff0c;那么你不一定要考研&#xff0c;至少以下几个职位研究生是没有啥优势的&#xff1a; 1&#xff0c;软件测试工程师&#xff08;培训一下就行&#xff09; 2&#xff0c;前…

【Docker】如何用Docker安装Tomcat

专栏精选文章 《Docker是什么&#xff1f;Docker从介绍到Linux安装图文详细教程》《30条Docker常用命令图文举例总结》《Docker如何构建自己的镜像&#xff1f;从镜像构建到推送远程镜像仓库图文教程》《Docker多个容器和宿主机之间如何进行数据同步和数据共享&#xff1f;容器…

关于linux下的xinetd服务

我们在网络通信时候用到socket套接字&#xff0c;有的时候我们更希望Linux能使用http协议等于前端有一定的交互&#xff0c;那么xinetd服务无疑是Linux下一种很好的方法。 什么是xinetd呢&#xff1f;xinetd是新一代的网络守护进程服务程序&#xff0c;又叫超级Internet服务器,…

[附源码]Python计算机毕业设计SSM基于的婚恋系统(程序+LW)

项目运行 环境配置&#xff1a; Jdk1.8 Tomcat7.0 Mysql HBuilderX&#xff08;Webstorm也行&#xff09; Eclispe&#xff08;IntelliJ IDEA,Eclispe,MyEclispe,Sts都支持&#xff09;。 项目技术&#xff1a; SSM mybatis Maven Vue 等等组成&#xff0c;B/S模式 M…

ERStudio操作指南

ERStudio操作指南一、创建逻辑模型二、生成SQL脚本本文使用的ER/Studio版本&#xff1a;ER/Studio Version 8.0.2 一、创建逻辑模型 1、打开ER/Studio后&#xff0c;选择&#xff1a;File>New&#xff0c;打开如下界面&#xff0c;选择Draw a new data model。 如上图&am…

接口调用、客户端lb、嵌套JSON解析、慎用 foreach、新建类封装

文章目录接口调用出错推荐客户端负载均衡多层JSON嵌套大数据量 插入慎用foreach使用Api时新建一个类封装、方便维护接口调用出错 故障转移&#xff1a;重试选择其他可用节点&#xff0c;做好幂等性可用&#xff01;&#xff01;&#xff01;快速失败 推荐客户端负载均衡 服务…

如何在 Java 中调用 MATLAB 代码

文章目录测评完整源代码运行环境&#xff1a; MATLAB R2022a Java 8&#xff08;1.8.0_311&#xff09; IntelliJ IDEA 2022.2.1 (Ultimate Edition) Maven 3.8.3 Windows 10 教育版 64位 使用混合编程通常都不是好主意&#xff0c;但是有时候会遇到极端的情况。Java 擅长…

git与github安装与配置

git与github安装与配置 最近总是害怕电脑和实验代码突然出事&#xff0c;想了想&#xff0c;拖了很久的git给搞好&#xff0c;所以花了几个小时&#xff0c;从入门到搭建好&#xff0c;这篇文章与其他文章来说&#xff0c;总体上是大同小异&#xff0c;算是前人的一个总结&…

【python基于mysql数据库实现无页面学生信息管理系统】

python基于mysql数据库实现无页面学生信息管理系统以及简单操作mysql前言一、分步讲解0.创建两张数据表1.大概思路2.首先连接数据库3.查看所有学生成绩信息4.查看所有学生个人信息5.查看指定学生成绩信息6.添加学生个人信息7.添加学生成绩信息8.修改学生个人信息9.修改学生成绩…

多模态融合技术

多模态融合的主要目标是缩小模态间的异质性差异&#xff0c;同时保持各模态特定语义的完整性&#xff0c;并在深度学习模型中取得较优的性能。 一、多模态融合架构 多模态融合架构分为&#xff1a;联合架构&#xff0c;协同架构和编解码器架构。联合架构是将单模态表示投影到…

数据库运维 | 携程分布式图数据库NebulaGraph运维治理实践

作者简介&#xff1a;Patrick Yu&#xff0c;携程云原生研发专家&#xff0c;关注非关系型分布式数据存储及相关技术。 背景 随着互联网世界产生的数据越来越多&#xff0c;数据之间的联系越来越复杂层次越来越深&#xff0c;人们希望从这些纷乱复杂的数据中探索各种关联的需求…

[附源码]Python计算机毕业设计大学生心理健康咨询系统Django(程序+LW)

该项目含有源码、文档、程序、数据库、配套开发软件、软件安装教程 项目运行 环境配置&#xff1a; Pychram社区版 python3.7.7 Mysql5.7 HBuilderXlist pipNavicat11Djangonodejs。 项目技术&#xff1a; django python Vue 等等组成&#xff0c;B/S模式 pychram管理等…

(免费分享)基于jsp,ssm酒店管理系统

开发工具&#xff1a;eclipse&#xff0c;mysql5.7 Tomcat8.0&#xff0c;jdk1.8 系统分用户前台和管理后台两部分 前台截图&#xff1a; 后台截图&#xff1a; package com.mypower.controller;import java.io.IOException; import java.io.OutputStream; import java.io.P…

行业如此内卷,品牌如何实现可持续招商增长?

文|螳螂观察&#xff08;TanglangFin&#xff09; 作者|陈小江 2019年&#xff0c;厦门的一位单亲妈妈&#xff0c;听了一堂课&#xff0c;驱车十几个小时抵达南京&#xff0c;就为找一个人。 找一个&#xff0c;能救企业的人。 由于股权融资对赌失败&#xff0c;这位原本坐…