图像分类-demo(Lenet),tensorflow和Alexnet

目录

demo(Lenet)

代码实现基本步骤:

TensorFlow

一、核心概念

二、主要特点

三、简单实现

参数:

模型编译

模型训练

模型评估

Alexnet

model.py

train.py

predict.py


demo(Lenet)

PyTorch提供了一个名为“torchvision”的附加库,其中包含了各种预训练的模型和常用的数据集,以及用于构建和训练计算机视觉模型的实用工具。

LeNet是一个经典的卷积神经网络架构,用于手写数字识别任务(如MNIST数据集)。

pytorch tensor的通道排序:[batch, channel, height, width]

Lenet是一个 7 层的神经网络,包含 3 个卷积层,2 个池化层,1 个全连接层,1个输出层。其中所有卷积层的卷积核都为 5x5,步长=1,池化方法都为平均池化,激活函数为 ReLu。图中最后一步是要和全连接层连接,所以要转换为一维向量。函数用view。

代码实现基本步骤:
  • model.py:定义LeNet网络模型
  • train.py:加载数据集并训练,计算loss和accuracy,保存训练好的网络参数
  • predict.py:用自己的数据集进行分类测试

TensorFlow

TensorFlow是一个由谷歌开发的开源机器学习框架,被广泛应用于构建和训练各种类型的机器学习模型。

一、核心概念

TensorFlow的核心概念是使用数据流图来表示数学计算的过程。数据流图由一系列节点和边组成的有向图,其中节点表示数学计算操作,而边则表示数据(张量)的流动。这种表示方式使得TensorFlow能够高效地处理复杂的数学计算和机器学习算法。

二、主要特点
  1. 灵活性:TensorFlow支持动态图和静态图两种模式,用户可以根据需要选择适合自己的开发模式。
  2. 自动微分:TensorFlow自带自动微分功能,可以方便地计算模型的梯度,这对于优化机器学习模型至关重要。
  3. 分布式训练:TensorFlow支持分布式训练,可以在多台机器上分布式训练模型,这对于处理大规模数据集和复杂模型非常有用。
  4. 高级API:TensorFlow提供了高级API,如Keras,可以方便地构建和训练模型。Keras已经发展成一个独立的深度学习框架,并在TensorFlow 2.x版本中得到了更好的支持和集成。
    (ps:后面我们也会学习低级API,需要手动定义输入Tensor、各个层的计算过程(如卷积、激活、池化等),并将这些计算过程组合成一个完整的计算图。)
  5. 部署和移动端支持:TensorFlow支持将训练好的模型部署到生产环境和移动端,方便用户在不同平台上进行应用。
三、简单实现
import tensorflow as tf
from tensorflow.keras import layers, models
# 加载和预处理数据(这里以MNIST手写数字数据集为例)
mnist = tf.keras.datasets.mnist
(x_train, y_train), (x_test, y_test) = mnist.load_data()
x_train, x_test = x_train / 255.0, x_test / 255.0 # 归一化像素值到0-1之间
# 构建模型
model = models.Sequential([
layers.Flatten(input_shape=(28, 28)), # 将28x28的输入图像展平为一维向量
layers.Dense(128, activation='relu'), # 全连接层,128个神经元,ReLU激活函数
layers.Dropout(0.2), # Dropout层,用于减少过拟合,丢弃20/神经元
layers.Dense(10, activation='softmax') # 输出层,10个神经元(对应10个类别),softmax激活函数
])
# 编译模型
model.compile(optimizer='adam',
loss='sparse_categorical_crossentropy',
metrics=['accuracy'])
# 训练模型
model.fit(x_train, y_train, epochs=5)
# 评估模型
test_loss, test_acc = model.evaluate(x_test, y_test, verbose=2)
print(f'\nTest accuracy: {test_acc}')
  1. 我们首先加载了MNIST数据集,并将其分为训练集和测试集。
  2. 接着,我们对图像数据进行了归一化处理,将像素值从0-255缩放到0-1之间。
  3. 然后,我们构建了一个简单的神经网络模型,该模型包含一个展平层、一个全连接层(带有ReLU激活函数)、一个Dropout层(用于减少过拟合)和一个输出层(带有softmax激活函数,用于多分类任务)。
  4. 我们编译了模型,指定了优化器(Adam)、损失函数(稀疏分类交叉熵)和评估指标(准确率)。
  5. 最后,我们训练了模型,并在测试集上评估了其性能。
参数:
  • layers.Flatten(input_shape=(28, 28))Flatten层用于将输入图像(28x28像素)展平为一维向量(784个元素)。这是必要的,因为全连接层需要一维输入。

  • layers.Dense(10, activation='softmax'): 这是输出层,具有10个神经元(对应于10个数字类别)。使用softmax激活函数将输出转换为概率分布。

模型编译
  • optimizer='adam': 指定优化器为Adam。

  • loss='sparse_categorical_crossentropy': 指定损失函数为稀疏分类交叉熵。由于y_trainy_test是整数标签而不是one-hot编码,因此使用稀疏版本。

  • metrics=['accuracy']: 指定评估模型性能的指标为准确率。

模型训练
  • model.fit(x_train, y_train, epochs=5): 使用训练数据x_trainy_train来训练模型,训练5个周期(epoch)。每个周期都会遍历整个训练集一次。
模型评估
  • model.evaluate(x_test, y_test, verbose=2): 使用测试数据x_testy_test来评估模型的性能。verbose=2表示在评估过程中显示每个批次的损失和准确率。

Alexnet

ISLVRC 2012
训练集:1,281,167张已标注图片
验证集:50,000张已标注图片
测试集:100,000张未标注图片

经卷积后的矩阵尺寸大小计算公式为: N = (W − F + 2P ) / S + 1

① 输入图片大小 W(高)×W(宽) ② Filter(卷积核)大小 F×F ③ 步长 S ④ padding的像素数 P

例如:像卷积1中,因为作者用了两个GPU,我们只看一个。kernels=48*2,已知输入为[224,224,3(深度为3)]输出为55*55*96(48*2)高*宽*池化核数。
N = (W − F + 2P ) / S + 1 =[224-11+(1+2)]/4+1=55

代码示例:


import torch.nn as nn
import torch


class AlexNet(nn.Module):
    def __init__(self, num_classes=1000, init_weights=False):
        super(AlexNet, self).__init__()
        self.features = nn.Sequential(
            nn.Conv2d(3, 48, kernel_size=11, stride=4, padding=2),  # input[3, 224, 224]  output[48, 55, 55]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[48, 27, 27]
            nn.Conv2d(48, 128, kernel_size=5, padding=2),           # output[128, 27, 27]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 13, 13]
            nn.Conv2d(128, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 192, kernel_size=3, padding=1),          # output[192, 13, 13]
            nn.ReLU(inplace=True),
            nn.Conv2d(192, 128, kernel_size=3, padding=1),          # output[128, 13, 13]
            nn.ReLU(inplace=True),
            nn.MaxPool2d(kernel_size=3, stride=2),                  # output[128, 6, 6]
        )
        self.classifier = nn.Sequential(
            nn.Dropout(p=0.5),
            nn.Linear(128 * 6 * 6, 2048),
            nn.ReLU(inplace=True),
            nn.Dropout(p=0.5),
            nn.Linear(2048, 2048),
            nn.ReLU(inplace=True),
            nn.Linear(2048, num_classes),
        )
        if init_weights:
            self._initialize_weights()

    def forward(self, x):
        x = self.features(x)
        x = torch.flatten(x, start_dim=1)
        x = self.classifier(x)
        return x

    def _initialize_weights(self):
        for m in self.modules():
            if isinstance(m, nn.Conv2d):
                nn.init.kaiming_normal_(m.weight, mode='fan_out', nonlinearity='relu')
                if m.bias is not None:
                    nn.init.constant_(m.bias, 0)
            elif isinstance(m, nn.Linear):
                nn.init.normal_(m.weight, 0, 0.01)
                nn.init.constant_(m.bias, 0)
 

model.py

这个文件一个用于图像分类的卷积神经网络模型。

  • 初始化函数 __init__
    • num_classes:模型输出的类别数,默认为1000。
    • init_weights:一个布尔值,指示是否在初始化时自动设置模型权重,默认为False。
    • self.features:定义了模型的特征提取部分,包括一系列的卷积层、ReLU激活函数和最大池化层。
    • self.classifier:定义了模型的分类部分,包括全连接层、Dropout层和ReLU激活函数。
    • 如果init_weights为True,则调用_initialize_weights函数来初始化权重。
  • 前向传播函数 forward
    • 输入图像x通过self.features进行特征提取,然后通过torch.flatten将特征图展平为一维向量。
    • 展平后的特征向量通过self.classifier进行分类,输出每个类别的预测得分。
  • 权重初始化函数 _initialize_weights
    • 遍历模型的所有模块,如果模块是卷积层或全连接层,则使用特定的方法初始化其权重和偏置。

import os
import sys
import json

import torch
import torch.nn as nn
from torchvision import transforms, datasets, utils
import matplotlib.pyplot as plt
import numpy as np
import torch.optim as optim
from tqdm import tqdm

from model import AlexNet

tqdm用于显示进度条。
from model import AlexNet导入了自定义的AlexNet模型。


def main():
    device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
    print("using {} device.".format(device))

检查CUDA是否可用,并据此选择使用GPU还是CPU。

    data_transform = {
        "train": transforms.Compose([transforms.RandomResizedCrop(224),
                                     transforms.RandomHorizontalFlip(),
                                     transforms.ToTensor(),
                                     transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))]),
        "val": transforms.Compose([transforms.Resize((224, 224)),  # cannot 224, must (224, 224)
                                   transforms.ToTensor(),
                                   transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])}

定义了训练和验证数据的预处理步骤,包括随机裁剪、水平翻转、调整大小、归一化

    data_root = os.path.abspath(os.path.join(os.getcwd(), "../.."))  # get data root path
    image_path = os.path.join(data_root, "data_set", "flower_data")  # flower data set path
    assert os.path.exists(image_path), "{} path does not exist.".format(image_path)
    train_dataset = datasets.ImageFolder(root=os.path.join(image_path, "train"),
                                         transform=data_transform["train"])

使用datasets.ImageFolder加载训练和验证数据集。
类标签处理

    train_num = len(train_dataset)

    # {'daisy':0, 'dandelion':1, 'roses':2, 'sunflower':3, 'tulips':4}
    flower_list = train_dataset.class_to_idx
    cla_dict = dict((val, key) for key, val in flower_list.items())
    # write dict into json file
    json_str = json.dumps(cla_dict, indent=4)
    with open('class_indices.json', 'w') as json_file:
        json_file.write(json_str)

将类别索引映射到类别名称,并保存到JSON文件中。
数据加载器

    batch_size = 32
    nw = min([os.cpu_count(), batch_size if batch_size > 1 else 0, 8])  # number of workers
    print('Using {} dataloader workers every process'.format(nw))

    train_loader = torch.utils.data.DataLoader(train_dataset,
                                               batch_size=batch_size, shuffle=True,
                                               num_workers=nw)

    validate_dataset = datasets.ImageFolder(root=os.path.join(image_path, "val"),
                                            transform=data_transform["val"])

创建数据加载器,用于批量加载数据。
num_workers指定了加载数据时使用的进程数。

    val_num = len(validate_dataset)
    validate_loader = torch.utils.data.DataLoader(validate_dataset,
                                                  batch_size=4, shuffle=False,
                                                  num_workers=nw)

    print("using {} images for training, {} images for validation.".format(train_num,
                                                                           val_num))
    # test_data_iter = iter(validate_loader)
    # test_image, test_label = test_data_iter.next()
    #
    # def imshow(img):
    #     img = img / 2 + 0.5  # unnormalize
    #     npimg = img.numpy()
    #     plt.imshow(np.transpose(npimg, (1, 2, 0)))
    #     plt.show()
    #
    # print(' '.join('%5s' % cla_dict[test_label[j].item()] for j in range(4)))
    # imshow(utils.make_grid(test_image))

模型、损失函数和优化器

    net = AlexNet(num_classes=5, init_weights=True)

    net.to(device)  #网络指定到我们设备中
    loss_function = nn.CrossEntropyLoss()
    # pata = list(net.parameters())
    optimizer = optim.Adam(net.parameters(), lr=0.0002)

初始化AlexNet模型,并设置类别数为5。
将模型移动到指定的设备上(GPU或CPU)。
使用交叉熵损失函数。
使用Adam优化器。

    epochs = 10
    save_path = './AlexNet.pth'
    best_acc = 0.0
    train_steps = len(train_loader)
    for epoch in range(epochs):
        # train
        net.train()
        running_loss = 0.0
        train_bar = tqdm(train_loader, file=sys.stdout)
        for step, data in enumerate(train_bar):
            images, labels = data
            optimizer.zero_grad()
            outputs = net(images.to(device))
            loss = loss_function(outputs, labels.to(device))
            loss.backward()
            optimizer.step()

            # print statistics
            running_loss += loss.item()

            train_bar.desc = "train epoch[{}/{}] loss:{:.3f}".format(epoch + 1,
                                                                     epochs,
                                                                     loss)

        # validate
        net.eval()    #在网络搭建过程中,我们失去了一部分神经元但我们只希望在训练中,不希望在预测过程中起作用
        acc = 0.0  # accumulate accurate number / epoch
        with torch.no_grad():
            val_bar = tqdm(validate_loader, file=sys.stdout)
            for val_data in val_bar:
                val_images, val_labels = val_data
                outputs = net(val_images.to(device))
                predict_y = torch.max(outputs, dim=1)[1]
                acc += torch.eq(predict_y, val_labels.to(device)).sum().item()

        val_accurate = acc / val_num
        print('[epoch %d] train_loss: %.3f  val_accuracy: %.3f' %
              (epoch + 1, running_loss / train_steps, val_accurate))

        if val_accurate > best_acc:
            best_acc = val_accurate
            torch.save(net.state_dict(), save_path)

训练过程分为多个epoch。
在每个epoch中,模型先切换到训练模式,然后遍历训练数据集。
使用优化器更新模型参数。
每个epoch结束后,模型切换到评估模式,遍历验证数据集以计算准确率。
如果当前epoch的验证准确率高于之前的最高准确率,则保存模型。

    print('Finished Training')


if __name__ == '__main__':
    main()

train.py

训练AlexNet模型的完整流程。

  • 设置设备(GPU或CPU)。
  • 定义数据预处理流程data_transform,包括随机裁剪、水平翻转、归一化等。
  • 设置数据集的路径,并加载训练和验证数据集。
  • 将类别索引映射到类别名称,并保存为JSON文件。
  • 配置数据加载器DataLoader,包括批量大小、是否打乱数据、工作线程数等。
  • 初始化AlexNet模型,设置损失函数(交叉熵损失)和优化器(Adam)。
  • 训练模型:
    • 在每个epoch中,模型首先在训练集上进行训练,计算损失并更新权重。
    • 然后,在验证集上评估模型的准确性。
    • 记录每个epoch的训练损失和验证准确性。
    • 如果当前epoch的验证准确性高于之前的最佳准确性,则保存模型权重。

import os
import json

import torch
from PIL import Image
from torchvision import transforms
import matplotlib.pyplot as plt

from model import AlexNet


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

    data_transform = transforms.Compose(
        [transforms.Resize((224, 224)),
         transforms.ToTensor(),
         transforms.Normalize((0.5, 0.5, 0.5), (0.5, 0.5, 0.5))])

定义了一个预处理管道,它首先将图像调整到224x224像素(AlexNet的输入大小),然后将图像转换为PyTorch张量,并对每个通道进行归一化处理。归一化使用均值(0.5, 0.5, 0.5)和标准差(0.5, 0.5, 0.5)

    # load image
    img_path = r"D:\pycharm\深度学习-图像分类\data_set\flower_data\train\tulips\11746276_de3dec8201.jpg"
    assert os.path.exists(img_path), "file: '{}' dose not exist.".format(img_path)
    img = Image.open(img_path)

    plt.imshow(img)
    # [N, C, H, W],
    img = data_transform(img)
    # expand batch dimension
    img = torch.unsqueeze(img, dim=0)

将图像通过预处理管道,并增加一个批量维度,因为PyTorch模型期望输入是一个四维张量,其中N是批量大小,C是通道数,HW分别是高度和宽度。

    # read class_indict
    json_path = './class_indices.json'
    assert os.path.exists(json_path), "file: '{}' dose not exist.".format(json_path)

    with open(json_path, "r") as f:
        class_indict = json.load(f)

读取包含类别索引映射的JSON文件,这个文件应该有一个从类别索引到类别名称的映射。

    # create model
    model = AlexNet(num_classes=5).to(device)

    # load model weights
    weights_path = "./AlexNet.pth"
    assert os.path.exists(weights_path), "file: '{}' dose not exist.".format(weights_path)
    model.load_state_dict(torch.load(weights_path))

    model.eval()

创建AlexNet模型实例,指定类别数为5,并将模型移动到之前设置的设备上(GPU或CPU)。然后加载预训练的权重,并将模型设置为评估模式,这意味着在推理期间不会进行梯度计算或权重更新。
    with torch.no_grad():
        # predict class
        output = torch.squeeze(model(img.to(device))).cpu()
        predict = torch.softmax(output, dim=0)
        predict_cla = torch.argmax(predict).numpy()

使用torch.no_grad()禁用梯度计算,因为我们在进行推理而不是训练。将图像张量移动到设备上,通过模型进行前向传播,得到输出。然后应用softmax函数得到概率分布,并找到概率最高的类别的索引。

    print_res = "class: {}   prob: {:.3}".format(class_indict[str(predict_cla)],
                                                 predict[predict_cla].numpy())
    plt.title(print_res)
    for i in range(len(predict)):
        print("class: {:10}   prob: {:.3}".format(class_indict[str(i)],
                                                  predict[i].numpy()))
    plt.show()

打印出预测结果,包括类别名称和对应的概率,并在图像上显示这个信息作为标题。然后遍历所有类别的概率,并打印出来。最后,显示图像。


if __name__ == '__main__':
    main()

predict.py

使用PyTorch框架和AlexNet模型进行图像分类的完整示例。

  • 设置设备:根据是否检测到CUDA设备(GPU),设置PyTorch使用CPU或GPU。
  • 定义数据转换:使用transforms.Compose定义一个转换序列,包括调整图像大小到224x224,转换为Tensor,然后进行归一化。
  • 加载图像:使用PIL打开指定路径的图像,并检查文件是否存在。
  • 显示原始图像:使用matplotlib显示原始图像。
  • 图像预处理:应用之前定义的转换序列,并增加批量维度以匹配模型输入要求。
  • 读取类别索引:从JSON文件中加载类别索引映射,用于将模型预测的数字标签转换为可读的类别名称。
  • 创建模型:实例化AlexNet模型,设置类别数为5(假设有5个类别),并将模型移至之前确定的设备(CPU或GPU)。
  • 加载模型权重:从指定路径加载训练好的模型权重。
  • 模型评估模式:设置模型为评估模式,关闭dropout和batch normalization的训练特性。
  • 进行预测
    • 使用torch.no_grad()上下文管理器关闭梯度计算,减少内存消耗,加快计算速度。
    • 将预处理后的图像传入模型进行预测,对输出进行squeeze操作去除多余的维度,然后将结果移至CPU。
    • 应用softmax函数计算每个类别的预测概率。
    • 找到概率最高的类别作为预测结果。
  • 显示结果:打印并显示预测类别和概率,以及所有类别的预测概率。

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

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

相关文章

修复PDF打印速度慢

详细问题: 当您尝试将 PDF 文件打印到本地或网络打印机时,打印需要很长时间,因为发送打印作业后,打印机开始打印的速度非常慢,在打印任务中可以看到打印传输的数据在缓慢增长。 从其他程序打印时也不会出现打印速度慢…

单点登录Apereo CAS 7.1安装配置教程

笔者目前正在做一个单点登录的课题,历时较长总算摸到一些门路,其中的辛酸不易按下不表。截至本文发布,CAS的最新版本为7.1。由于涉及到课题内容,而且内容比较新,整理试验不容易,暂时只对VIP开放,后续课题完成后会完全开放,敬请谅解。 CAS项目区别 在CAS的项目选择上,…

Vue3 组件封装

1. 组件特性 在Vue中组件是一个独立的实例,每个组件都有共通点,就是:属性、插槽、事件、方法; 在日常我们使用第三方组件库的时候,组件库的文档都会说明上面四个特性,而组件封装就是围绕这四个特性进行的…

AI大模型 向量Embeddings+向量数据库实现文搜文、图搜图

文搜文、图搜图介绍: 文搜文 :即文本搜索文本,是指通过输入关键词或短语,在大量文本数据中检索出与之相关的内容 。 搜 索引擎(百度、谷歌、 360 ) 、 文档管理系统 、 电商搜索 。 图搜图 :即图像搜…

从零开始搭建一个node.js后端服务项目

目录 一、下载node.js及配置环境 二、搭建node.js项目及安装express框架 三、集成nodemon,实现代码热部署 四、Express 应用程序生成器 一、下载node.js及配置环境 网上很多安装教程,此处就不再赘述了 版本信息 C:\Users\XXX>node -v v20.15.0…

IDEA Sping Boot 多配置文件application Maven动态切换

新建application-dev.yml与application-prod.yml pom.xml文件下添加profiles等 让idea识别出配置文件 <profiles><profile><id>dev</id><properties><!-- 环境标识&#xff0c;需要与配置文件的名称相对应 --><profiles.active>dev&…

【系统架构设计师】案例专题六(8大系统架构设计之7): 安全架构设计考点梳理

更多内容请见: 备考系统架构设计师-核心总结目录 文章目录 一、安全架构概述2、信息安全面临的威胁2、安全架构的定义和范围3、与信息安全相关的国内外标准及组织二、安全模型1、状态机模型2、Bell-LaPadula模型3、Biba模型4、Clark-Wilson模型5、Chinese Wall模型三、系统安全…

欧科云链研究院深掘链上数据:洞察未来Web3的隐秘价值

目前链上数据正处于迈向下一个爆发的重要时刻。 随着Web3行业发展&#xff0c;公链数量呈现爆发式的增长&#xff0c;链上积聚的财富效应&#xff0c;特别是由行业热点话题引领的链上交互行为爆发式增长带来了巨量的链上数据&#xff0c;这些数据构筑了一个行为透明但与物理世…

(32)噪声信号的时域分析:均值、方差、与功率

文章目录 前言一、生成噪声信号并画图二、计算信号的均值、方差、与功率三、结果分析 前言 本文对叠加了高斯白噪声的一段整周期余弦信号进行时域分析&#xff0c;使用MATLAB进行信号生成&#xff0c;并计算其均值、方差、与功率。最后给出对计算结果的分析&#xff0c;阐明均…

小程序该如何上架

小程序的上架流程通常包括准备工作、代码审核、人工审核以及上线发布等关键步骤。以下是一个详细的小程序上架指南&#xff1a; 一、准备工作 注册开发者账号&#xff1a; 在微信小程序平台或支付宝开放平台等相应的小程序发布平台上注册开发者账号。 开发小程序&#xff1a; …

开源新生活,社区齐乐活:COSCon'24 社区合作和开源集市招募中,诚邀广大社区参与!...

一年一度的开源盛会&#xff0c;COSCon24第九届中国开源年会暨开源社10周年嘉年华&#xff0c;将于11月2-3日&#xff0c;在北京•中关村国家自主创新示范区展示中心召开&#xff01;本次大会的主题是&#xff1a;「Open Source&#xff0c;Open Life | 开源新生活」&#xff0…

git error: You have not concluded your merge (MERGE_HEAD exists).

本地作了修改并提交远程&#xff0c;但管理员并未合并。此时本地又作了修改&#xff0c;而管理员合并了其它分支&#xff0c;且这个合并分支同时修改了当前本地分支共同的文件。本着提交前同步最新远程代码的原则&#xff0c;结果在合并远程分支时冲突了。其实解决这个冲突再合…

电脑无线网wifi和有线网同时使用(内网+外网同时使用)

一、要求 我这里以无线网wifi为外网&#xff0c;有线网卡为内网为例&#xff1a; 一、基本信息 无线wifi&#xff08;外网&#xff09;&#xff1a;ip是192.168.179.235&#xff0c;网关是192.168.179.95有线网&#xff08;内网&#xff09;&#xff1a;ip是192.168.10.25&…

C语言实现输出空心数字金字塔

如下图所示&#xff0c;那么&#xff0c;该怎么实现呢 #include <stdio.h>void hallow(int n);int main(void) {int n;printf("请输入一个数");scanf("%d",&n);hallow(n);return 0; }void hallow(int n) {int i,j,k1;for (i 1; i <n-1; i) {…

网络爬虫自动化Selenium模拟用户操作

自动化测试和网络爬虫在现代软件开发中占据着重要的位置。它们通过自动化用户操作,减少了人工重复操作的时间成本。Selenium作为一个功能强大且应用广泛的自动化工具,不仅能在不同的浏览器中运行自动化测试,还能进行跨平台测试,并允许与多种编程语言集成。本教程将介绍如何…

Java面向对象编程--高级

目录 一、static关键字 1.1 静态变量 1.2 静态内存解析 1.3 static的应用与练习 二、单例设计模式 2.1 单例模式 2.2 如何实现单例模式 三、代码块 3.1 详解 3.2 练习&#xff0c;测试 四、final关键字 五、抽象类与抽象方法 5.1 abstract 5.2 练习 六、接口 6.…

以JavaScript的学习角度看Axios,并以spring boot+vue3为例具体分析实现

什么是Axios Axios 是一个基于 Promise 的 HTTP 客户端&#xff0c;用于在浏览器和 后端 中发送异步的 HTTP 请求。它功能强大、易用&#xff0c;常用于与 API 交互&#xff0c;发送 GET、POST、PUT、DELETE 等请求。 Axios 的主要特点&#xff1a; 支持 Promise Axios 基于 …

连接redis哨兵碰到的一些问题

1.Could not get a resource from the pool 可以跟进对应的getResource方法&#xff0c;看下这个问题的具体异常是什么&#xff0c;如NOAUTH Authentication required&#xff0c;这种异常就是说明了漏配置了redis的密码&#xff0c;补充下就好。 2. java.lang.NoSuchMethodE…

【花卉识别系统】Python+卷积神经网络算法+人工智能+深度学习+图像识别+算法模型

一、介绍 花朵识别系统。本系统采用Python作为主要编程语言&#xff0c;基于TensorFlow搭建ResNet50卷积神经网络算法模型&#xff0c;并基于前期收集到的5种常见的花朵数据集&#xff08;向日葵、玫瑰、蒲公英、郁金香、菊花&#xff09;进行处理后进行模型训练&#xff0c;最…

SpringBoot基础(一)

5.注解Configuration 标注一个类为配置类 6.注解Bean 用Bean标注方法等价于XML中配置的bean Configuration //容器启动时加载 public class AppBootConfig {//创建bean实例 别名为stuBean(name "stu")public Student getStudent(){Student stu new Student();s…