Softmax Classifier 多分类问题

news2024/10/7 10:19:28

文章目录

    • 8、Softmax Classifier 多分类问题
      • 8.1 Revision
      • 8.2 Softmax
        • 8.2.1 Design
        • 8.2.2 Softmax Layer
        • 8.2.3 NLLLoss vs CrossEntropyLoss
        • 8.2.4 Mini-Batch
      • 8.3 MNIST dataset
        • 8.3.1 Import Package
        • 8.3.2 Prepare Dataset
        • 8.3.3 Design Model
        • 8.3.4 Construct Loss and Optimizer
        • 8.3.5 Train and Test
        • 8.3.6 完整代码
        • 8.4 Kaggle Exercise

8、Softmax Classifier 多分类问题

B站视频教程传送门：PyTorch深度学习实践 - 多分类问题

8.1 Revision

1、Diabetes dataset： 糖尿病数据集

对该数据集做了二分类，并且该二分类网络的输出，概率其一： P （ y ^ = 1 ） P（\hat{y}=1） P（y^​=1），概率其二： P （ y ^ = 0 ） = 1 − P （ y ^ = 1 ） P（\hat{y}=0）=1-P（\hat{y}=1） P（y^​=0）=1−P（y^​=1） 。

2、MNIST Dataset： MNIST数据集

在该数据集中，由于是做手写数字识别，所以共有10种不同的分类标签。

8.2 Softmax

试想：如果有10个分类，应当如何设计神经网络？

8.2.1 Design

如上图，在最后输出的时候，可将原来只有一个 P ( y = 1 ) P(y=1) P(y=1) 的输出变成10个输出（因为有10个分类），就能输出该样本属于每一个分类的概率，如下表：

分类概率
y 1 ^ \hat {y_1} y1​^​ P ( y = 0 ) P(y=0) P(y=0)
y 2 ^ \hat {y_2} y2​^​ P ( y = 1 ) P(y=1) P(y=1)
……
y 10 ^ \hat {y_{10}} y10​^​ P ( y = 9 ) P(y=9) P(y=9)

注意：我们是将每一个类别看作一个二分类问题，且最后每个输出值需满足两个要求：① ≥ 0 \geq 0 ≥0，② ∑ = 1 \sum = 1 ∑=1，即输出的是一个分布。

所以，在处理多分类问题时，在最终输出层我们使用 Softmax，即最后输出满足以下两个条件：
P ( y = i ) ≥ 0 (1) \Large P(y=i) \geq 0 \tag{1} P(y=i)≥0(1)

∑ i = 0 9 P ( y = i ) = 1 (2) \Large \displaystyle \sum_{i=0}^{9} P(y=i) = 1 \tag{2} i=0∑9​P(y=i)=1(2)

8.2.2 Softmax Layer

Softmax到底是怎么实现的？用了一个什么样的计算来保证这10个元素：

问题 1：经过线性运算后，神经网络输出值可正可负，怎么将其变成正值？

问题 2：怎么让其和等于1？

假设 Z l ∈ R k Z^l \in \mathbb{R}^k Zl∈Rk 是最后一个线性层的输出，Softmax函数：
P ( y = i ) = e Z i ∑ j = 0 k − 1 e Z j , i ∈ { 0 , . . . , K − 1 } (3) \Large P(y=i) = \frac {e^{Z_i}} {\sum_{j=0}^{k-1} e^{Z_j}}, i \in \lbrace 0, ... , K-1 \rbrace \tag {3} P(y=i)=∑j=0k−1​eZj​eZi​​,i∈{0,...,K−1}(3)
Example：

L o s s ( Y ^ , Y ) = − Y l o g Y ^ (4) \Large Loss(\hat Y, Y) = -Y log \hat Y \tag {4} Loss(Y^,Y)=−YlogY^(4)

8.2.3 NLLLoss vs CrossEntropyLoss

one-hot：独热编码（One-Hot）及其代码

NLLLoss：https://pytorch.org/docs/stable/generated/torch.nn.NLLLoss.html?highlight=nllloss#torch.nn.NLLLoss

在 Numpy 中：

import numpy as np

z = np.array([0.2, 0.1, -0.1])
y = np.array([1, 0, 0])

y_pred = np.exp(z) / np.exp(z).sum()
print(y_pred)

loss = (- y * np.log(y_pred)).sum()
print(loss)

[0.37797814 0.34200877 0.28001309]
0.9729189131256584

CrossEntropyLoss：https://pytorch.org/docs/stable/generated/torch.nn.CrossEntropyLoss.html?highlight=crossentropyloss#torch.nn.CrossEntropyLoss

在 PyTorch 中：

import torch

z = torch.Tensor([[0.2, 0.1, -0.1]])
y = torch.LongTensor([0])

criterion = torch.nn.CrossEntropyLoss()

loss = criterion(z, y)
print(loss)

tensor(0.9729)

C r o s s E n t r o p y L o s s < = = > L o g S o f t m a x + N L L L o s s \Large CrossEntropyLoss \lt==\gt LogSoftmax + NLLLoss CrossEntropyLoss<==>LogSoftmax+NLLLoss

神经网络的最后一层不需要做激活（经过Softmax层的计算），直接输入到CrossEntropyLoss损失函数中即可。

8.2.4 Mini-Batch

import torch

criterion = torch.nn.CrossEntropyLoss()
Y = torch.LongTensor([2, 0, 1])

Y_pred1 = torch.Tensor([[0.1, 0.2, 0.9],
                        [1.1, 0.1, 0.2],
                        [0.2, 2.1, 0.1]])
Y_pred2 = torch.Tensor([[0.8, 0.2, 0.3],
                        [0.2, 0.3, 0.5],
                        [0.2, 0.2, 0.5]])

loss_1 = criterion(Y_pred1, Y)
loss_2 = criterion(Y_pred2, Y)
print('Batch Loss1 =', loss_1.data, '\nBatch Loss2 =', loss_2.data)

Batch Loss1 = tensor(0.4966) 
Batch Loss2 = tensor(1.2389)

8.3 MNIST dataset

以下是 MNIST 手写数据集中的一个图像：

8.3.1 Import Package

import torch
from torchvision import transforms  # 构造 DataLoader
from torch.utils.data import DataLoader  # 同上
from torchvision import datasets
import torch.nn.functional as F  # 激活函数 relu()
import torch.optim as optim  # 构造优化器

8.3.2 Prepare Dataset

batch_size = 64

transform = transforms.Compose([
    transforms.ToTensor(),  # 将PIL Image 转换为 Tensor
    transforms.Normalize((0.1307,), (0.3081,))  # 均值 和 标准差
])

train_dataset = datasets.MNIST(root='../data/mnist', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)

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

1、ToTensor()：将 PIL Image 转换成 PyTorch Tensor
P I L I m a g e : Z 28 × 28 , p i x e l ∈ { 0 , . . . , 255 } \Large PIL\quad Image: \mathbb{Z}^{28 \times 28}, pixel \in \{0, ... ,255\} PILImage:Z28×28,pixel∈{0,...,255}

P y T o r c h T e n s o r : R 1 × 28 × 28 , p i x e l ∈ [ 0 , 1 ] \Large PyTorch\quad Tensor: \mathbb{R}^{1 \times 28 \times 28}, pixel \in [ 0, 1] PyTorchTensor:R1×28×28,pixel∈[0,1]

2、Normalize((mean, ), (std, ))：均值 标准差，数据归一化
P i x e l n o r m = P i x e l o r i g i n − m e a n s t d \Large Pixel_{norm} = \frac {Pixel_{origin} - mean} {std} Pixelnorm​=stdPixelorigin​−mean​

8.3.3 Design Model

class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.l1 = torch.nn.Linear(784, 512)
        self.l2 = torch.nn.Linear(512, 256)
        self.l3 = torch.nn.Linear(256, 128)
        self.l4 = torch.nn.Linear(128, 64)
        self.l5 = torch.nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return self.l5(x)  # 最后一层 不需要激活


model = Net()

8.3.4 Construct Loss and Optimizer

criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # 进一步优化，momentum：冲量

8.3.5 Train and Test

def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()  # 清零

        # forward + backward + update
        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 test():
    correct = 0
    total = 0
    with torch.no_grad():  # 不需要计算梯度
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('Accuracy on test set: %d %%' % (100 * correct / total))


if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()

8.3.6 完整代码

import torch
from torchvision import transforms  # 构造 DataLoader
from torch.utils.data import DataLoader  # 同上
from torchvision import datasets
import torch.nn.functional as F  # 激活函数 relu()
import torch.optim as optim  # 构造优化器

batch_size = 64

transform = transforms.Compose([
    transforms.ToTensor(),  # 将PIL Image 转换为 Tensor
    transforms.Normalize((0.1307,), (0.3081,))  # 均值 和 标准差
])

train_dataset = datasets.MNIST(root='../data/mnist', train=True, download=True, transform=transform)
train_loader = DataLoader(train_dataset, shuffle=True, batch_size=batch_size)

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


class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.l1 = torch.nn.Linear(784, 512)
        self.l2 = torch.nn.Linear(512, 256)
        self.l3 = torch.nn.Linear(256, 128)
        self.l4 = torch.nn.Linear(128, 64)
        self.l5 = torch.nn.Linear(64, 10)

    def forward(self, x):
        x = x.view(-1, 784)
        x = F.relu(self.l1(x))
        x = F.relu(self.l2(x))
        x = F.relu(self.l3(x))
        x = F.relu(self.l4(x))
        return self.l5(x)  # 最后一层 不需要激活


model = Net()

criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # 进一步优化，momentum：冲量


def train(epoch):
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader, 0):
        inputs, target = data
        optimizer.zero_grad()  # 清零

        # forward + backward + update
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()
        if batch_idx % 300 == 299:
            print('[%d, %3d] loss: %.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0


def test():
    correct = 0
    total = 0
    with torch.no_grad():  # 不需要计算梯度
        for data in test_loader:
            images, labels = data
            outputs = model(images)
            _, predicted = torch.max(outputs, dim=1)
            total += labels.size(0)
            correct += (predicted == labels).sum().item()
    print('Accuracy on test set: %d %%' % (100 * correct / total))


if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)
        test()

[1, 300] loss: 2.228
[1, 600] loss: 1.029
[1, 900] loss: 0.434
Accuracy on test set: 89 %
[2, 300] loss: 0.321
[2, 600] loss: 0.268
[2, 900] loss: 0.237
Accuracy on test set: 93 %
[3, 300] loss: 0.192
[3, 600] loss: 0.172
[3, 900] loss: 0.153
Accuracy on test set: 95 %
[4, 300] loss: 0.131
[4, 600] loss: 0.123
[4, 900] loss: 0.111
Accuracy on test set: 96 %
[5, 300] loss: 0.092
[5, 600] loss: 0.097
[5, 900] loss: 0.092
Accuracy on test set: 97 %
[6, 300] loss: 0.077
[6, 600] loss: 0.071
[6, 900] loss: 0.076
Accuracy on test set: 96 %
[7, 300] loss: 0.060
[7, 600] loss: 0.059
[7, 900] loss: 0.061
Accuracy on test set: 97 %
[8, 300] loss: 0.045
[8, 600] loss: 0.049
[8, 900] loss: 0.052
Accuracy on test set: 97 %
[9, 300] loss: 0.039
[9, 600] loss: 0.038
[9, 900] loss: 0.040
Accuracy on test set: 97 %
[10, 300] loss: 0.032
[10, 600] loss: 0.032
[10, 900] loss: 0.034
Accuracy on test set: 97 %

8.4 Kaggle Exercise

Otto Group Product Classification Challenge：https://www.kaggle.com/competitions/otto-group-product-classification-challenge

代码如下：

import pandas as pd
import numpy as np
import torch
from torch.utils.data import Dataset
from torch.utils.data import DataLoader
import torch.optim as optim


# 数据预处理
# 定义函数将类别标签转为id表示，方便后面计算交叉熵
def labels2id(labels):
    target_id = []  # 给所有target建立一个词典
    target_labels = ['Class_1', 'Class_2', 'Class_3', 'Class_4', 'Class_5', 'Class_6', 'Class_7', 'Class_8',
                     'Class_9']  # 自定义9个标签
    for label in labels:  # 遍历labels中的所有label
        target_id.append(target_labels.index(label))  # 添加label对应的索引项到target_labels中
    return target_id


class OttogroupDataset(Dataset):  # 准备数据集
    def __init__(self, filepath):
        data = pd.read_csv(filepath)
        labels = data['target']
        self.len = data.shape[0]  # 多少行多少列

        # 处理特征和标签
        self.x_data = torch.tensor(np.array(data)[:, 1:-1].astype(float))  # 1:-1 左闭右开
        self.y_data = labels2id(labels)

    def __getitem__(self, index):  # 魔法方法 支持dataset[index]
        return self.x_data[index], self.y_data[index]

    def __len__(self):  # 魔法函数 len() 返回长度
        return self.len


# 载入训练集
train_dataset = OttogroupDataset('../data/Otto Group Product Classification Challenge/train.csv')

# 建立数据加载器
train_loader = DataLoader(dataset=train_dataset, batch_size=64, shuffle=True, num_workers=0)


class Net(torch.nn.Module):
    def __init__(self):
        super(Net, self).__init__()
        self.l1 = torch.nn.Linear(93, 64)  # 93个feature
        self.l2 = torch.nn.Linear(64, 32)
        self.l3 = torch.nn.Linear(32, 16)
        self.l4 = torch.nn.Linear(16, 9)
        self.relu = torch.nn.ReLU()  # 激活函数

    def forward(self, x):  # 正向传播
        x = self.relu(self.l1(x))
        x = self.relu(self.l2(x))
        x = self.relu(self.l3(x))
        return self.l4(x)  # 最后一层不做激活，不进行非线性变换

    def predict(self, x):  # 预测函数
        with torch.no_grad():  # 梯度清零 不累计梯度
            x = self.relu(self.l1(x))
            x = self.relu(self.l2(x))
            x = self.relu(self.l3(x))
            x = self.relu(self.l4(x))
            # 这里先取出最大概率的索引，即是所预测的类别。
            _, predicted = torch.max(x, dim=1)
            # 将预测的类别转为one-hot表示，方便保存为预测文件。
            y = pd.get_dummies(predicted)
            return y


model = Net()

criterion = torch.nn.CrossEntropyLoss()
optimizer = optim.SGD(model.parameters(), lr=0.01, momentum=0.5)  # 冲量，冲过鞍点和局部最优


def train(epoch):  # 单次循环 epoch决定循环多少次
    running_loss = 0.0
    for batch_idx, data in enumerate(train_loader):
        inputs, target = data  # 输入数据
        inputs = inputs.float()
        optimizer.zero_grad()  # 优化器归零

        # 前馈+反馈+更新
        outputs = model(inputs)
        loss = criterion(outputs, target)
        loss.backward()
        optimizer.step()

        running_loss += loss.item()  # 累计的损失
        if batch_idx % 300 == 299:  # 每300轮输出一次
            print('[%d, %3d] loss:%.3f' % (epoch + 1, batch_idx + 1, running_loss / 300))
            running_loss = 0.0


if __name__ == '__main__':
    for epoch in range(10):
        train(epoch)


# 定义预测保存函数，用于保存预测结果。
def predict_save():
    test_data = pd.read_csv('../data/Otto Group Product Classification Challenge/test.csv')
    test_inputs = torch.tensor(
        np.array(test_data)[:, 1:].astype(float))  # test_data是series，要转为array；[1:]指的是第一列开始到最后，左闭右开，去掉‘id’列
    out = model.predict(test_inputs.float())  # 调用预测函数，并将inputs 改为float格式

    # 自定义新的标签
    labels = ['Class_1', 'Class_2', 'Class_3', 'Class_4', 'Class_5', 'Class_6',
              'Class_7', 'Class_8', 'Class_9']

    # 添加列标签
    out.columns = labels

    # 插入id行
    out.insert(0, 'id', test_data['id'])
    output = pd.DataFrame(out)
    output.to_csv('../data/Otto Group Product Classification Challenge/my_predict.csv', index=False)
    return output


predict_save()

[1, 300] loss:1.584
[1, 600] loss:0.898
[1, 900] loss:0.799
[2, 300] loss:0.741
[2, 600] loss:0.721
[2, 900] loss:0.694
[3, 300] loss:0.672
[3, 600] loss:0.670
[3, 900] loss:0.662
[4, 300] loss:0.645
[4, 600] loss:0.648
[4, 900] loss:0.631
[5, 300] loss:0.623
[5, 600] loss:0.630
[5, 900] loss:0.611
[6, 300] loss:0.609
[6, 600] loss:0.600
[6, 900] loss:0.599
[7, 300] loss:0.586
[7, 600] loss:0.584
[7, 900] loss:0.594
[8, 300] loss:0.586
[8, 600] loss:0.568
[8, 900] loss:0.568
[9, 300] loss:0.566
[9, 600] loss:0.568
[9, 900] loss:0.566
[10, 300] loss:0.556
[10, 600] loss:0.552
[10, 900] loss:0.559

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

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

相关文章

农业气象站—提供多元化数据

农业气象站—提供多元化数据

中国气象局应急减灾与公共服务司司长王志华曾表示&#xff0c;“农业气象灾害风险预警是守住粮食安全底线的关键一环。”在全球新冠肺炎疫情常态化的形势下&#xff0c;我国将粮食安全摆在了更突出的位置。 粮食在我国具有重要的战略地位&#xff0c;自从建国以来&#xff0c;…
阅读更多...
功能测试（环境搭建）

功能测试（环境搭建）

目录 1.功能测试流程&#xff1a; 2.环境搭建&#xff08;源码&#xff09; 2.1.环境说明&#xff08;后台&#xff09;&#xff1a; 2.2.代码仓库获取代码 2.3.项目环境搭建 2.4后台部署 3.环境搭建&#xff08;war包&#xff09; 1.功能测试流程&#xff1a; 2.环境搭建…
阅读更多...
【C++初阶】八、STL---list（总）|list的介绍|list的使用

【C++初阶】八、STL---list（总）|list的介绍|list的使用

目录 一、list的介绍 二、list的使用 2.1 Construct 2.2 operator 2.3 Iterators 2.4 Capacity 2.5 Element access 2.6 Modifiers 2.7 Operations 一、list的介绍 有数据结构作为基础&#xff0c;STL 上手很快&#xff0c;学习成本也低&#xff0c;本文也是讲解 list…
阅读更多...
大数据技术架构(组件)17——Hive：UDF/UDTF/UDAF三者区别

大数据技术架构(组件)17——Hive：UDF/UDTF/UDAF三者区别

1.4.12、三者区别1.4.12.1、UDFUDF全称为User Defined Function&#xff08;即用户自定义函数&#xff09;&#xff0c;UDF开发在日常工作当中是非常普遍的。我们写一段SQL&#xff0c;调用UDF&#xff0c;得到结果就算是结束了&#xff0c;但大家有没有想过UDF底层是怎么执行的…
阅读更多...
CSS语法指南

CSS语法指南

学前需求 需要对HTML有一定的了解 什么是 CSS? CSS 指层叠样式表 (Cascading Style Sheets) 样式定义如何显示 HTML 元素样式通常存储在样式表中把样式添加到 HTML 4.0 中&#xff0c;是为了解决内容与表现分离的问题外部样式表可以极大提高工作效率外部样式表通常存储在 CS…
阅读更多...
操作系统—王道考研之进程管理

操作系统—王道考研之进程管理

by:星辰 课程视频链接:https://www.bilibili.com/video/BV1YE411D7nH 第 2 章 进程管理 2.1 进程与线程 2.1.1 进程的定义、特征、组成、组织 2.1.1.1 总览 2.1.1.2 进程的定义 &#xff08;1&#xff09;程序的概念 程序&#xff1a;一组计算机能识别和执行的指令。 是静…
阅读更多...
C语言及算法设计课程实验五：循环结构程序设计

C语言及算法设计课程实验五：循环结构程序设计

C语言及算法设计课程实验五&#xff1a;循环结构程序设计一、实验目的二、实验内容2.1、统计字符个数2.2、输出所有的“水仙花数”2.3、猴子吃桃问题2.4、牛顿迭代法求方程三、实验步骤3.1、循环结构程序设计实验题目一&#xff1a;统计字符个数1、定义变量2、 输入一串字符3、…
阅读更多...
基础IO（上）

基础IO（上）

基础IO&#xff08;上&#xff09;回顾文件知识回顾C文件接口系统文件I/O接口介绍openclosewriteread理解文件描述符fd理解0 1 2 3 4....文件描述符的分配规则重定向的本质及相关操作认识重定向重定向的具体原理重定向的操作追加重定向和输入重定向追加重定向输入重定向缓冲区的…
阅读更多...
C++ STL源码剖析 笔记补充

C++ STL源码剖析 笔记补充

写在前面 简单记录一些《C STL源码剖析中》涉及到的C语法和注意事项。 1. 静态常量成员在类内直接初始化 如果含有const static integral类型的成员变量&#xff0c;可以在类内定义时直接初始化&#xff1b; 注意integral不只是int类型&#xff0c;而是包含所有的整型&#…
阅读更多...
＜ 每日算法 - Javascript解析：经典弹珠游戏 ＞

＜ 每日算法 - Javascript解析：经典弹珠游戏 ＞

每日算法 - JavaScript解析&#xff1a;弹珠游戏一、任务描述&#xff1a;》 示例一&#xff1a;》示例二二、题意解析三、解决方案&#xff1a;往期内容 &#x1f4a8;一、任务描述&#xff1a; 欢迎各位来到「力扣嘉年华」&#xff0c;接下来将为各位介绍在活动中广受好评的…
阅读更多...
HSAF实战收获

HSAF实战收获

收获1&#xff1a;MySQL数据类型对应Java类型表格这里的timestamp类型在Java中对应TimeStamp类型&#xff0c;varchar和char都是对饮的String类型收获2&#xff1a;TableFieldTableField(exist false) 注解加载bean属性上&#xff0c;表示当前属性不是数据库的字段&#xff0c…
阅读更多...
[golang Web开发] 4.golang web开发:模板引擎

[golang Web开发] 4.golang web开发:模板引擎

一.简介 使用 Go 的 Web 模板引擎需要以下两个步骤&#xff1a; (1).对文本格式的模板源进行语法分析&#xff0c;创建一个经过语法分析的模板结构&#xff0c;其中模板源既可以是一个字符串,也可以是模板文件中包含的内容 (2).执行经过语法分析的模板&#xff0c;将ResponseWr…
阅读更多...
Django User模型

Django User模型

Django User模型用户管理自定义用户模型Django自定义验证引用User模型视图开发创建序列器创建视图创建路由用户注册注册序列化器注册视图注册路由用户管理 在开发登录功能的时候需要数据库来保存用户登录信息和状态&#xff0c;Django中有个内置app 名为 django.contrib.auth …
阅读更多...
ICT是什么

ICT是什么

信息与通信技术&#xff08;ICT&#xff0c;information and communications technology&#xff09;是一个涵盖性术语&#xff0c;覆盖了所有通信设备或应用软件&#xff1a;比如说&#xff0c;收音机、电视、移动电话、计算机、网络硬件和软件、卫星系统&#xff0c;等等&…
阅读更多...
（1）Nginx简介和安装教程

（1）Nginx简介和安装教程

目录 一、下载 二、报错提醒&环境安装 1、安装gcc编译器 2、安装perl库 3、安装 zlib库 4、也可通过命令进行统一安装 三、编译及安装 四、启动并访问 1、启动 2、访问 3、问题排查 五、安装成系统文件 一、下载 官网地址&#xff1a;nginx news Nginx官网提供…
阅读更多...
OAuth2入门

OAuth2入门

1.下载资源 演示代码&#xff1a; OAuth2-example: 演示OAuth2的认证流程https://gitee.com/lisenaq/oauth2-example克隆下载到本地&#xff1a; 导入项目&#xff1a; client 客户 authorization-server 认证服务 resource-owner 资源所有者 resource-server 资源…
阅读更多...
儿童台灯哪个品牌更护眼推荐？儿童书桌台灯品牌排行榜

儿童台灯哪个品牌更护眼推荐？儿童书桌台灯品牌排行榜

不难发现&#xff0c;近些年我国儿童近视率增长迅速&#xff0c;随着生活条件越来越好&#xff0c;对电子章产品的普及非常广泛&#xff0c;每个家庭的孩子必不可少的就是伏案完成作业&#xff0c;这样的话就需要使用到台灯&#xff0c;选购台灯的时候最好选择适合儿童的专业护…
阅读更多...
【算法基础】高精度加法

【算法基础】高精度加法

&#x1f466;个人主页&#xff1a;Weraphael ✍&#x1f3fb;作者简介&#xff1a;目前是C语言学习者 ✈️专栏&#xff1a;【C/C】算法 &#x1f40b; 希望大家多多支持&#xff0c;咱一起进步&#xff01;&#x1f601; 如果文章对你有帮助的话 欢迎 评论&#x1f4ac; 点赞…
阅读更多...
一篇五分生信临床模型预测文章代码复现——FIgure 9.列线图构建，ROC分析，DCA分析 （三）

一篇五分生信临床模型预测文章代码复现——FIgure 9.列线图构建，ROC分析，DCA分析 （三）

之前讲过临床模型预测的专栏，但那只是基础版本，下面我们以自噬相关基因为例子，模仿一篇五分文章，将图和代码复现出来，学会本专栏课程，可以具备发一篇五分左右文章的水平： 本专栏目录如下： Figure 1：差异表达基因及预后基因筛选(图片仅供参考) Figure 2. 生存分析，…
阅读更多...
axios实战学习——使用高德地图api接口数据实现天气查询案例

axios实战学习——使用高德地图api接口数据实现天气查询案例

文章目录&#x1f4cb;前言&#x1f3af;案例介绍&#x1f9e9;关于高德开发平台1️⃣创建应用生成Key2️⃣查看API文档&#x1f9e9;测试接口&#x1f3af;案例编写&#x1f3af;实现效果&#x1f4cb;前言 关于这个Vue axios 获取接口数据的操作&#xff0c;这篇文章就不过…
阅读更多...
推荐文章
最新文章

Copyright @ 2022~2023