迁移学习:使用Restnet预训练模型构建高效的水果识别模型

目录

引言

1 迁移学习

1.1 什么是迁移学习

1.2 迁移学习能解决什么问题

1.3 迁移学习面临的三个问题

1.3.1 何时迁移

1.3.2 何处迁移

1.3.3 如何迁移

1.4 迁移学习的分类

1.4.1 按照学习方式的划分

1.4.2 按照使用方法的划分

2 Restnet网络

2.1 Restnet介绍

 2.2 Restnet网络结构

3 迁移学习代码实现

3.1 数据集介绍

3.2 预训练模型下载

3.3 基于pytorch使用Restnet预训练模型进行迁移学习

3.4 基于pytorch不进行迁移学习的情况下进行网络训练

4 总结


引言

本项目在Restnet预训练模型的基础上,通过迁移学习构建了水果分类识别模型,经过30epochs训练,实现了模型的快速收敛,准确率达到了96%以上。通过此项目实战,我们进一步熟悉了如何在预训练模型的基础上进行迁移学习,构建新的深度学习模型。技术伙伴们可参考本项目增加数据分类或使用其他数据集,通过迁移学习构建新的分类识别模型。

1 迁移学习

1.1 什么是迁移学习

迁移学习(Transfer Learning)是一种机器学习方法,就是把为任务 A 开发的模型作为初始点,重新使用在为任务 B 开发模型的过程中。迁移学习是通过从已学习的相关任务中转移知识来改进学习的新任务,虽然大多数机器学习算法都是为了解决单个任务而设计的,但是促进迁移学习的算法的开发是机器学习社区持续关注的话题。

迁移学习通俗来讲就是学会举一反三的能力,通过运用已有的知识来学习新的知识,其核心是找到已有知识和新知识之间的相似性,通过这种相似性的迁移达到迁移学习的目的。世间万事万物皆有共性,如何合理地找寻它们之间的相似性,进而利用这个桥梁来帮助学习新知识,是迁移学习的核心问题。

1.2 迁移学习能解决什么问题

当前的人工智能技术大多需要有大量高质量的数据支撑,使用实验室构造的数据可以一定程度上解决这一难题,满足基本的训练需求。然而,到了实际的局点上使用的时候,往往会因为构造数据与实际数据的差异而导致预测的结果不够准确。这一问题的出现,给AI算法提出了新的要求——在充分利用实验室构造数据的基础上,也要在局点真实数据上获得很好的结果。“ 迁移学习 ”作为一种解决方法帮助我们在有限数据集上训练得到一个需要海量数据训练效果的模型,起到事半功倍的效果。

迁移学习的应用往往不限于特定的领域,只要该问题满足迁移学习的场景,就可以尝使用迁移学习来解决。计算机视觉、文本分类、行为识别、自然语言处理、室内定位、视频监控、舆情分析、人机交互等领域都可以使用到迁移学习的技术。

1.3 迁移学习面临的三个问题

1.3.1 何时迁移

何时迁移对应于迁移学习的可能性和使用迁移学习的原因. 值得注意的是, 此步骤应该发生在迁移学习的第一步. 给定待学习的目标,我们首先要做的便是判断当时的任务是否适合进行迁移学习

1.3.2 何处迁移

判断当时的任务适合迁移学习之后, 第二步要解决的是从何处进行迁移. 这里何处我们可以使用what和where来表达便于理解. what, 指的是要迁移什么知识,这些知识可以是神经网络权值, 特征变化矩阵某些参数等; 而where指的是要从那个地方进行迁移, 这些地方可以是某个源域, 某个神经元, 某个随机森林的树等.

1.3.3 如何迁移

这一步是绝大多数迁移学习方法的着力点. 给定待学习的源域和目标域, 这一步则是要学习最优的迁移学习方法以达到最好的性能.

1.4 迁移学习的分类

1.4.1 按照学习方式的划分

  • 基于样本的迁移学习(Instance based Transfer Learning):对不同的样本给予不同的权重,样本越相似,权重越高。高权重样本优先级更高,完成迁移。
  • 基于特征的迁移学习(Feature based Transfer Learning):是对特征进行变换。假设源域和目标域的特征原来不在一个空间,或者说它们在原来那个空间上不相似,那我们就想办法把它们变换到一个空间里面,最小化二者对应点的距离,完成迁移
  • 基于模型的迁移学习(Model based Transfer Learning):就是重新利用模型里的参数。该类方法在神经网络里面用的特别多,因为神经网络的结构可以直接进行迁移。比finetune就是模型参数迁移的很好的体现。
  • 基于关系的迁移学习:发掘相似场景的关系,两组中如果有一组源域和目标域的关系可确定,可以迁移到另一组上。比如老师上课、学生听课就可以类比为公司开会的场景,这种类比就是一种关系的迁移。

1.4.2 按照使用方法的划分

  • 微调(Finetune):将别人训练好的网络模型修改后用于自己的。用预训练的网络权值代替随机初始化权值
  • 混合特征提取(Fixed Feature Extractor):将预训练网络作为新任务特征提取,也就是新模型的前几层用预训练网络做替换

2 Restnet网络

2.1 Restnet介绍

深度学习在图像分类、目标检测、语音识别等领域取得了重大突破,但是随着网络层数的增加,梯度消失和梯度爆炸问题逐渐凸显。随着层数的增加,梯度信息在反向传播过程中逐渐变小,导致网络难以收敛。同时,梯度爆炸问题也会导致网络的参数更新过大,无法正常收敛。

为了解决这些问题,ResNet提出了一个创新的思路:引入残差块(Residual Block)。残差块的设计允许网络学习残差映射,从而减轻了梯度消失问题,使得网络更容易训练。

下图是一个基本残差块。它的操作是把某层输入跳跃连接到下一层乃至更深层的激活层之前,同本层输出一起经过激活函数输出。
 

 2.2 Restnet网络结构

 ResNet的经典网络结构有:ResNet-18、ResNet-34、ResNet-50、ResNet-101、ResNet-152几种,其中,ResNet-18和ResNet-34的基本结构相同,属于相对浅层的网络,后面3种属于更深层的网络,其中RestNet50最为常用。

3 迁移学习代码实现

3.1 数据集介绍

在数据集目录下,存放着10个文件夹,文件夹名称为水果类型,每个文件夹包含几百到几千张此类水果的图片,如下图所示:

 以apple文件夹为例,内容如下:

下载地址:第一个包,第二个包

两个数据包下载完成后,都解压到/opt/dataset/fruit目录下,完成后如下所示:

# ll fruit/
总用量 508
drwxr-xr-x 2 root root 36864 8月   2 16:35 apple
drwxr-xr-x 2 root root 24576 8月   2 16:36 apricot
drwxr-xr-x 2 root root 40960 8月   2 16:36 banana
drwxr-xr-x 2 root root 20480 8月   2 16:36 blueberry
drwxr-xr-x 2 root root 45056 8月   2 16:37 cherry
drwxr-xr-x 2 root root 12288 8月   2 16:37 citrus
drwxr-xr-x 2 root root 49152 8月   2 16:38 grape
drwxr-xr-x 2 root root 16384 8月   2 16:38 lemon
drwxr-xr-x 2 root root 36864 8月   2 16:39 litchi
drwxr-xr-x 2 root root 49152 8月   2 16:39 mango

3.2 预训练模型下载

预训练模型下载地址如下:

    model_urls = {
        'resnet18': 'https://download.pytorch.org/models/resnet18-f37072fd.pth',
        'resnet34': 'https://download.pytorch.org/models/resnet34-b627a593.pth',
        'resnet50': 'https://download.pytorch.org/models/resnet50-0676ba61.pth',
        'resnet101': 'https://download.pytorch.org/models/resnet101-63fe2227.pth',
        'resnet152': 'https://download.pytorch.org/models/resnet152-394f9c45.pth',
        'resnext50_32x4d': 'https://download.pytorch.org/models/resnext50_32x4d-7cdf4587.pth',
        'resnext101_32x8d': 'https://download.pytorch.org/models/resnext101_32x8d-8ba56ff5.pth',
        'wide_resnet50_2': 'https://download.pytorch.org/models/wide_resnet50_2-95faca4d.pth',
        'wide_resnet101_2': 'https://download.pytorch.org/models/wide_resnet101_2-32ee1156.pth',
    }

 下载restnet50的模型,存放到/opt/models目录下

3.3 基于pytorch使用Restnet预训练模型进行迁移学习

水果识别模型在Restnet的基础上,增加一个全连接层,将Restnet预训练模型的2048输出变换到对应的水果分类数量的输出。

import torch
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import datetime
import numpy as np

from torchvision.datasets import ImageFolder
from torchvision import transforms
from torchvision.models import resnet50
from sklearn.model_selection import train_test_split

# 图像变换
transform = transforms.Compose([transforms.Resize((224, 224)),
                                transforms.ToTensor(),
                                transforms.Normalize(
                                     mean=[0.485, 0.456, 0.406],
                                     std=[0.229, 0.224, 0.225]
                                ), ])
# 加载数据集
dataset = ImageFolder('/opt/dataset/fruit', transform=transform)

# 划分训练集与测试集
train_dataset, valid_dataset = train_test_split(dataset, test_size=0.2, random_state=10)

batch_size = 64
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True, drop_last=True)
test_loader = DataLoader(dataset=valid_dataset, batch_size=batch_size, shuffle=True, drop_last=True)

restnet_pretrained_path = '/opt/models/resnet50-0676ba61.pth'
checkpoint_path = '/opt/checkpoint/fruit_reg.pth'
checkpoint_resume = False

if __name__ == "__main__":
    # 加载预训练模型
    model = resnet50()
    model.load_state_dict(torch.load(restnet_pretrained_path))

    # 替换最后一层全连接层,构建新的网络,实现迁移学习
    num_classes = len(dataset.classes)
    in_features = model.fc.in_features
    model.fc = torch.nn.Linear(in_features, num_classes)

    # 模型训练
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model.to(device)

    criterion = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(model.parameters(), lr=0.0001, momentum=0.9)
    num_epochs = 30

    accuracy_rate = []
    for epoch in range(num_epochs):
        print('Epoch [{}/{}], start'.format(epoch + 1, num_epochs))

        for inputs, labels in train_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch + 1, num_epochs, loss.item()))

        # 模型验证
        model.eval()
        correct = 0
        total = 0

        with torch.no_grad():
            for inputs, labels in test_loader:
                inputs, labels = inputs.to(device), labels.to(device)
                outputs = model(inputs)
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()

        accuracy = correct / total * 100
        accuracy_rate.append(accuracy)
        print('Accuracy: {:.2f}%'.format(accuracy))

    accuracy_rate = np.array(accuracy_rate)
    times = np.linspace(1, num_epochs, num_epochs)
    plt.xlabel('times')
    plt.ylabel('accuracy rate')
    plt.plot(times, accuracy_rate)
    plt.show()

    print(f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')},accuracy_rate={accuracy_rate}")
    torch.save(model.state_dict(), checkpoint_path)
Epoch [1/30], Loss: 1.4853     Accuracy: 63.69% 

Epoch [2/30], Loss: 0.2206     Accuracy: 92.35%

Epoch [3/30], Loss: 0.1856     Accuracy: 94.56%

Epoch [4/30], Loss: 0.1025     Accuracy: 93.97%

Epoch [5/30], Loss: 0.0543     Accuracy: 95.31%

Epoch [6/30], Loss: 0.0335     Accuracy: 95.80%

Epoch [7/30], Loss: 0.0114     Accuracy: 95.64%

Epoch [8/30], Loss: 0.0159     Accuracy: 95.20%

Epoch [9/30], Loss: 0.0060     Accuracy: 95.96%

Epoch [10/30], Loss: 0.0027    Accuracy: 96.01%

Epoch [11/30], Loss: 0.0052    Accuracy: 96.07%

Epoch [12/30], Loss: 0.0030    Accuracy: 96.01%

Epoch [13/30], Loss: 0.0035    Accuracy: 96.01%

Epoch [14/30], Loss: 0.0026    Accuracy: 96.12%

Epoch [15/30], Loss: 0.0008    Accuracy: 95.96%

Epoch [16/30], Loss: 0.0013    Accuracy: 96.01%

Epoch [17/30], Loss: 0.0008    Accuracy: 96.17%

Epoch [18/30], Loss: 0.0005    Accuracy: 96.01%

Epoch [19/30], Loss: 0.0010    Accuracy: 96.07%

Epoch [20/30], Loss: 0.0009    Accuracy: 96.07%

Epoch [21/30], Loss: 0.0002    Accuracy: 95.96%

Epoch [22/30], Loss: 0.0002    Accuracy: 96.01%

Epoch [23/30], Loss: 0.0006    Accuracy: 96.39%

Epoch [24/30], Loss: 0.0010    Accuracy: 96.12%

Epoch [25/30], Loss: 0.0008    Accuracy: 96.07%

Epoch [26/30], Loss: 0.0011    Accuracy: 96.01%

Epoch [27/30], Loss: 0.0003    Accuracy: 96.07%

Epoch [28/30], Loss: 0.0006    Accuracy: 96.07%

Epoch [29/30], Loss: 0.0005    Accuracy: 96.07%

Epoch [30/30], Loss: 0.0002    Accuracy: 96.23%

经过10个epochs,模型开始收敛,30个epochs准确率变化曲线如下所示:

3.4 基于pytorch不进行迁移学习的情况下进行网络训练

import torch
from torch.utils.data import DataLoader
import matplotlib.pyplot as plt
import datetime
import numpy as np

from torchvision.datasets import ImageFolder
from torchvision import transforms

from torchvision.models import resnet50

from sklearn.model_selection import train_test_split

# 图像变换
transform = transforms.Compose([transforms.Resize((224, 224)),
                                transforms.ToTensor(),
                                transforms.Normalize(
                                     mean=[0.485, 0.456, 0.406],
                                     std=[0.229, 0.224, 0.225]
                                ), ])
# 加载数据集
dataset = ImageFolder('./data/fruit', transform=transform)

# 划分训练集与测试集
train_dataset, valid_dataset = train_test_split(dataset, test_size=0.2, random_state=0)

batch_size = 64
train_loader = DataLoader(dataset=train_dataset, batch_size=batch_size, shuffle=True, drop_last=True)
test_loader = DataLoader(dataset=valid_dataset, batch_size=batch_size, shuffle=True, drop_last=True)

checkpoint_path = './checkpoint/fruit_reg.pth'
checkpoint_resume = False

if __name__ == "__main__":
    # 加载预训练模型
    model = resnet50()

    # 替换最后一层全连接层,构建新的网络
    num_classes = len(dataset.classes)
    in_features = model.fc.in_features
    model.fc = torch.nn.Linear(in_features, num_classes)

    # 模型训练
    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
    model.to(device)

    criterion = torch.nn.CrossEntropyLoss()
    optimizer = torch.optim.SGD(model.parameters(), lr=0.001, momentum=0.9)
    num_epochs = 10

    accuracy_rate = []
    for epoch in range(num_epochs):

        print('Epoch [{}/{}], start'.format(epoch + 1, num_epochs))

        for inputs, labels in train_loader:
            inputs, labels = inputs.to(device), labels.to(device)
            optimizer.zero_grad()
            outputs = model(inputs)
            loss = criterion(outputs, labels)
            loss.backward()
            optimizer.step()

        print('Epoch [{}/{}], Loss: {:.4f}'.format(epoch + 1, num_epochs, loss.item()))

        # 模型验证
        model.eval()
        correct = 0
        total = 0

        with torch.no_grad():
            for inputs, labels in test_loader:
                inputs, labels = inputs.to(device), labels.to(device)
                outputs = model(inputs)
                _, predicted = torch.max(outputs.data, 1)
                total += labels.size(0)
                correct += (predicted == labels).sum().item()

        accuracy = correct / total * 100
        accuracy_rate.append(accuracy)
        print('Accuracy: {:.2f}%'.format(accuracy))

    accuracy_rate = np.array(accuracy_rate)
    times = np.linspace(1, num_epochs, num_epochs)
    plt.xlabel('times')
    plt.ylabel('accuracy rate')
    plt.plot(times, accuracy_rate)
    plt.show()

    print(f"{datetime.datetime.now().strftime('%Y-%m-%d %H:%M:%S')},accuracy_rate={accuracy_rate}")
    torch.save(model.state_dict(), checkpoint_path)
Epoch [1/30], Loss: 2.1676  Accuracy: 18.32%

Epoch [2/30], Loss: 1.9645  Accuracy: 20.85%

Epoch [3/30], Loss: 1.9394  Accuracy: 37.55%

Epoch [4/30], Loss: 1.3242  Accuracy: 40.46%

Epoch [5/30], Loss: 1.1633  Accuracy: 48.38%

Epoch [6/30], Loss: 1.4852  Accuracy: 52.80%

Epoch [7/30], Loss: 1.0438  Accuracy: 55.01%

Epoch [8/30], Loss: 1.2010  Accuracy: 52.86%

Epoch [9/30], Loss: 0.9826  Accuracy: 55.28%

Epoch [10/30], Loss: 1.0562  Accuracy: 53.72%

Epoch [11/30], Loss: 1.2049  Accuracy: 61.15%

Epoch [12/30], Loss: 1.0919  Accuracy: 59.91%

Epoch [13/30], Loss: 0.7103  Accuracy: 59.81%

Epoch [14/30], Loss: 0.7970  Accuracy: 61.64%

Epoch [15/30], Loss: 1.4505  Accuracy: 60.56%

Epoch [16/30], Loss: 1.0294  Accuracy: 60.02%

Epoch [17/30], Loss: 1.0225  Accuracy: 55.39%

Epoch [18/30], Loss: 0.9417  Accuracy: 64.33%

Epoch [19/30], Loss: 0.7826  Accuracy: 66.06%

Epoch [20/30], Loss: 0.8774  Accuracy: 65.09%

Epoch [21/30], Loss: 0.9671  Accuracy: 63.36%

Epoch [22/30], Loss: 0.7064  Accuracy: 66.81%

Epoch [23/30], Loss: 0.6465  Accuracy: 65.89%

Epoch [24/30], Loss: 0.7217  Accuracy: 64.55%

Epoch [25/30], Loss: 0.7089  Accuracy: 68.05%

Epoch [26/30], Loss: 0.8506  Accuracy: 66.76%

Epoch [27/30], Loss: 0.9541  Accuracy: 67.73%

Epoch [28/30], Loss: 1.1595  Accuracy: 68.21%

Epoch [29/30], Loss: 0.8493  Accuracy: 68.59%

Epoch [30/30], Loss: 0.8297  Accuracy: 71.55%

如果不采用迁移学习(即不加载Restnet50的预训练模型),经过30 epochs的训练后,模型并未收敛,得到的准确率曲线如下:

4 总结

本项目在Restnet50预训练模型的基础上,通过迁移学习,在水果数据上实现模型的训练和识别,经过30个epoches,在测试集上的准确率达到了96%,模型完成了快速收敛。

从训练效果来看,无论是准确率还是收敛速度,采用迁移学习后的网络都远高于未采用迁移学习的网络,充分体现了迁移学习价值。

此迁移学习训练方法可以扩展应用于其他数据集,在有限的数据集和计算资源的情况下,使用迁移学习可以快速训练出表现良好的分类识别模型。

 项目完整代码:代码地址

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

如若内容造成侵权/违法违规/事实不符,请联系我们进行投诉反馈qq邮箱809451989@qq.com,一经查实,立即删除!

相关文章

GO学习之 多线程(goroutine)

GO系列 1、GO学习之Hello World 2、GO学习之入门语法 3、GO学习之切片操作 4、GO学习之 Map 操作 5、GO学习之 结构体 操作 6、GO学习之 通道(Channel) 7、GO学习之 多线程(goroutine) 文章目录 GO系列前言一、并发介绍1.1 进程和线程和协程1.2 并发和并行 二、goroutine介绍三…

Centos7 上安装 redis-dump 和redis-load 命令

一、安装rvm 1、安装GPG keys gpg2 --keyserver keyserver.ubuntu.com --recv-keys 409B6B1796C275462A1703113804BB82D39DC0E3 7D2BAF1CF37B13E2069D6956105BD0E739499BDBcurl -sSL http://rvm.io/mpapis.asc | gpg2 --import - curl -sSL http://rvm.io/pkuczynski.asc | g…

【C++】开源:matplotlib-cpp静态图表库配置与使用

😏★,:.☆( ̄▽ ̄)/$:.★ 😏 这篇文章主要介绍matplotlib-cpp图表库配置与使用。 无专精则不能成,无涉猎则不能通。——梁启超 欢迎来到我的博客,一起学习,共同进步。 喜欢的朋友可以关注一下&…

VLT:Vision-Language Transformer用于引用的视觉语言转换和查询生成分割

摘要 在这项工作中,我们解决了引用分割的挑战性任务。引用分割中的查询表达式通常通过描述目标对象与其他对象的关系来表示目标对象。因此,为了在图像中的所有实例中找到目标实例,模型必须对整个图像有一个整体的理解。为了实现这一点&#…

超全整理,Jmeter性能测试-常用Jmeter第三方插件详解(超细)

目录:导读 前言一、Python编程入门到精通二、接口自动化项目实战三、Web自动化项目实战四、App自动化项目实战五、一线大厂简历六、测试开发DevOps体系七、常用自动化测试工具八、JMeter性能测试九、总结(尾部小惊喜) 前言 Jmeter作为一个开…

不规则文件转JSON

需求分析: 有时候,我们取出来的数据并不是一个规则的JSON文件,这个时候面对存库还是ES检索都是一个问题,所以我们就需要进行解析,然而用字符串分割是不现实的,我们需要一种快速的方法。 问题解决&#x…

使用 Docker Compose 部署单机版 Redis:简单高效的数据缓存与存储

家人们啦!今天我们来介绍如何使用 docker-compose 部署单机版 Redis,这是一个简单高效的数据缓存与存储解决方案,广泛应用于Web应用、移动应用以及各类数据处理场景。我们过后几篇文章了将会介绍cluster和sentinel集群的部署。通过本文的指导…

【LeetCode每日一题】——304.二维区域和检索-矩阵不可变

文章目录 一【题目类别】二【题目难度】三【题目编号】四【题目描述】五【题目示例】六【题目提示】七【解题思路】八【时间频度】九【代码实现】十【提交结果】 一【题目类别】 矩阵 二【题目难度】 中等 三【题目编号】 304.二维区域和检索-矩阵不可变 四【题目描述】 …

(学习笔记-进程管理)进程

进程 我们编写的代码只是一个存储在硬盘的静态文件,通过编译后会生成二进制可执行文件,当我们运行这个可执行文件后,它会被装载到内存中,接着CPU会执行程序中的每一条指令,那么这个运行中的程序就被称为进程。 现在我…

关于docker的一些深入了解

本文将深入介绍一下docker方面的知识,不尽完全,慢慢完善。 进程 进程的概念 在介绍docker的相关知识前,先了解一下相关概念。进程就是系统中正在运行的程序,进程是操作系统的概念,每当我们执行一个程序时&#xff0…

【unity】Pico VR 开发笔记(视角移动)

【unity】Pico VR 开发笔记(视角移动) 视角移动是简单的基础功能,这里区别于头显定位获得的小范围位移,是长距离不影响安全边界的位移方式。的常见的位移方式有两种,其一是触发后瞬间传送到指定位置,其次是…

Linux: 设置qmake的Qt版本

Qt开发,qmake会对应一个Qt版本,有时候需要切换这个版本,例如把qmake从Qt5.12切换到Qt5.9, 怎么操作呢? 案例如下: 银河麒麟V10系统,下载安装了Qt5.9.8,但是检查qmake发现它使用的是5.12.8&…

OPC DA 客户端与服务器的那点事

C#开发OPC客户端,使用OPCDAAuto.dll。在开发过程中偶遇小坎坷,主要记录一下问题解决办法。 1、建立客户端,参考链接。建立WinFrom工程,将博客中代码全部复制即可运行: https://www.cnblogs.com/kjgagaga/p/17011730.…

Java阶段五Day19

Java阶段五Day19 问题解析 需求单查询列表功能的bug 业务逻辑: 需要用户登录,师傅入驻,审核入驻通过 查询师傅详情(areaIds,categoryIds) demand-server-dao-impl 包含持久层实现 requestOrderMappe…

Vue——formcreate表单设计器自定义组件实现(二)

前面我写过一个自定义电子签名的formcreate表单设计器组件,那时初识formcreate各种使用也颇为生疏,不过总算套出了一个组件不是。此次时隔半年又有机会接触formcreate,重新熟悉和领悟了一番各个方法和使用指南。趁热打铁将此次心得再次分享。…

身体原来是一份宝贵的“情绪地图”, 疾病都在教导我们如何与世界相处

当我们生病时 很多时候,是一个契机 让我们来倾听自己内心的压抑的真实 聆听身体的声音 身体能够教会我们如何对待情绪 进而教导我们如何与世界相处 -1- 身体上,有你的情绪地图 皮肤是身体的镜子,身体则是心灵的镜子。生病&#xff0c…

什么是微服务

微服务的架构特征: 单一职责:微服务拆分粒度更小,每一个服务都对应唯一的业务能力,做到单一职责自治:团队独立、技术独立、数据独立,独立部署和交付面向服务:服务提供统一标准的接口&#xff0…

《Java-SE-第二十八章》之CAS

前言 在你立足处深挖下去,就会有泉水涌出!别管蒙昧者们叫嚷:“下边永远是地狱!” 博客主页:KC老衲爱尼姑的博客主页 博主的github,平常所写代码皆在于此 共勉:talk is cheap, show me the code 作者是爪哇岛的新手,水平很有限&…

AI绘图实战(十二):让AI设计LOGO/图标/标识 | Stable Diffusion成为设计师生产力工具

S:AI能取代设计师么? I :至少在设计行业,目前AI扮演的主要角色还是超级工具,要顶替?除非甲方对设计效果无所畏惧~~ 预先学习: 安装及其问题解决参考:《Windows安装Stable Diffusion …

Kali部署dvwa和pikachu靶场

kali换源 进入 vim /etc/apt/sources.list deb https://mirrors.aliyun.com/kali kali-rolling main non-free contrib deb-src https://mirrors.aliyun.com/kali kali-rolling main non-free contrib替换完后更新源 apt-get upadteDVWA靶场环境搭建 使用git从github上把DV…