記9（Torch

目錄

  • 1、Troch

1、Troch

函數說明舉例
torch.tensor()
torch.arange()		創建張量創建一個標量：torch.tensor(42)
創建一個一維張量：torch.tensor([1, 2, 3])
創建一個二維張量：torch.tensor([[1, 2], [3, 4]])
生成一維等差張量：語法：torch.arange(start=0, end, step=1, *, dtype=None, device=None, requires_grad=False)
torch.arange(3)就是tensor([0, 1, 2])
torch.view()改變張量的形狀1行8列改2行4列：torch.arange(1, 9).view(2, 4)
torch.cat()指定維度拼接張量torch.cat((torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6]])), dim=0)
# tensor([[1, 2], [3, 4], [5, 6]])
索引與切片和numpy數組用法一致
tensor.t()張量轉置torch.tensor([[1, 2, 3], [4, 5, 6]]).t()
tensor([[1, 4], [2, 5], [3, 6]])
torch.mm()矩陣乘法torch.mm(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6], [7, 8]]))
# tensor([[19, 22], [43, 50]])
torch.mul()元素級乘法torch.mul(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6], [7, 8]]))
# tensor([[ 5, 12], [21, 32]])
torch.sum()求和torch.sum(torch.tensor([[1, 2], [3, 4]])) # tensor(10)
torch.mean()求均值torch.mean(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))
# tensor(2.5000)
torch.std()求標準差torch.std(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))
# tensor(2.2910) 即：((1-2)**2 + (2-2)**2 + (3-2)**2 + (4-2)**2)**0.5
torch.max()
torch.min()		求最大值、最小值及其索引見下面代碼（后面都見下面代碼，不寫了）
torch.abs()絕對值
torch.exp()指數運算，torch.exp(x)就是e^x
torch.log()對數運算，toch.log(2)就是ln2≈0.6931
torch.floor()
torch.ceil()		向下取整floor
向上取整ceil
nn.Linear(x, y)定義一個線性層，x行y列，總共x*y個weight神經元，y個bias神經元
optimizer.zero_grad()梯度清零，清空優化器跟蹤的參數的梯度（即 model.parameters() 中注冊的參數）
layer.weight.grad
layer.bias.grad		保存該層的 權重weight梯度信息 和 偏置bias梯度信息
model.named_parameters()通過迭代器 獲取模型的所有參數（而不是某一層）及其梯度 [(n, p.grad) for n, p in model.named_parameters()]
torch.nn.utils.clip_grad_norm_()梯度裁剪,用于防止梯度爆炸的技術，通過對模型的梯度進行裁剪。
import torch, math
import torch.nn as nn
import torch.optim as optim# torch.tensor()
print(torch.tensor(42))             # 創建一個標量（零維張量），tensor(42)
print(torch.tensor([1,2,3]))        # 創建一個一維張量，tensor([1, 2, 3])
print(torch.tensor([[1,2],[3,4]]))  # 創建一個二維張量，tensor([[1, 2], [3, 4]])# torch.arange()，一維等差張量
print(torch.arange(1,5))            # tensor([2, 3, 4])
print(torch.arange(3))              # tensor([0, 1, 2])# tensor1.view()        改變形狀
tensor1 = torch.arange(1, 9)        # tensor1 = tensor([1, 2, 3, 4, 5, 6, 7, 8])
print(tensor1.view(2, 4))           # 或者 tensor1.view(-1, 4)、tensor1.view(2, -1)：tensor([[1, 2, 3, 4], [5, 6, 7, 8]])# torch.cat()       拼接
print(torch.cat((torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6]])), dim=0))
# 上面就是按照第0個維度拼接（就是第1維度不變，例如[1,2]拼接前后一致）tensor([[1, 2], [3, 4], [5, 6]])# 索引和切片
tensor1 = torch.tensor([[1, 2, 3, 4, 5, 6], [7, 8, 9, 10, 11, 12]])
print(tensor1[0, :])            # 獲取第一行：tensor([1, 2, 3, 4, 5, 6])
print(tensor1[0, 0:3])          # 獲取第一行從索引0開始，到索引3（不包括3）的元素：tensor([1, 2, 3])
print(tensor1[0, 0:3:2])        # 獲取第一行，且從索引0開始，到索引3（不包括3），步長為2的元素：tensor([1, 3])
print(tensor1[:, 0])            # 獲取第一列：tensor([1, 7])
print(tensor1[1:, 1:])          # 獲取子集：tensor([[ 8,  9, 10, 11, 12]])# torch.t()         轉置
print(torch.tensor([[1, 2, 3], [4, 5, 6]]).t())     # tensor([[1, 4], [2, 5], [3, 6]])# torch.mm()        矩陣乘法
print(torch.mm(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6], [7, 8]]))) # tensor([[19, 22], [43, 50]])# torch.mul()        元素級乘法
print(torch.mul(torch.tensor([[1, 2], [3, 4]]), torch.tensor([[5, 6], [7, 8]]))) # tensor([[ 5, 12], [21, 32]])# torch.sum()       求和
print(torch.sum(torch.tensor([[1, 2], [3, 4]])))    # tensor(10)# torch.mean()      求均值
print(torch.mean(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))   # tensor(2.5000)# torch.std()       求標準差
print(torch.std(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))    # tensor(2.2910) 即：((1-2)**2 + (2-2)**2 + (3-2)**2 + (4-2)**2)**0.5# torch.max()、torch.min()           求最大值、最小值及其索引
print(torch.max(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))    # tensor(4.)
print(torch.max(torch.tensor([[1.0, 2.0], [3.0, 4.0]]), dim=1))     # torch.return_types.max( values=tensor([2., 4.]), indices=tensor([1, 1]))
print(torch.min(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))    # tensor(1.)# torch.abs()       絕對值
print(torch.abs(torch.tensor([[-1, 2], [-3, 4]])))      # tensor([[1, 2], [3, 4]])# torch.exp()       指數運算，torch.exp(x)就是e^x
print(torch.exp(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))    # tensor([[ 2.7183,  7.3891], [20.0855, 54.5981]])# torch.log()       對數運算，就是 ln2≈0.6931
print(torch.log(torch.tensor([[1.0, 2.0], [3.0, 4.0]])))    # tensor([[0.0000, 0.6931], [1.0986, 1.3863]])# torch.floor()、torch.ceil()    向下取整floor、向上取整ceil
print(torch.floor(torch.tensor([[1.2, 2.8], [3.5, 4.1]])))  # tensor([[1., 2.], [3., 4.]])
print(torch.ceil(torch.tensor([[1.2, 2.8], [3.5, 4.1]])))  # tensor([[2., 3.], [4., 5.]])# nn.Linear(x, y)       定義一個線性層，x行y列，總共x*y個weight神經元，y個bias神經元
layer1 = nn.Linear(3, 1)        # 定義一個線性層
print(f"layer1\t權重 W:{layer1.weight.shape}\t偏置 b:{layer1.bias.shape}")  # 查看權重和偏置：layer1	權重 W:torch.Size([1, 3])	偏置 b:torch.Size([1])
layer2 = nn.Linear(3, 2)        # 定義一個線性層
print(f"layer2\t權重 W:{layer2.weight.shape}\t偏置 b:{layer2.bias.shape}")  # 查看權重和偏置：layer2	權重 W:torch.Size([2, 3])	偏置 b:torch.Size([2])# 損失函數      可以調用類形式的損失函數(torch.nn)和函數形式的損失函數(torch.nn.functional)
#           torch.nn：需要實例化對象，可以初始化時固定參數
#           torch.nn.funcional：直接調用函數，每次調用顯式傳遞所有參數
criterion = nn.CrossEntropyLoss(reduction="mean")  # 初始化時固定參數
outputs = torch.randn(3, 5)  # 模型輸出（3個樣本，5個類別）
labels = torch.tensor([2, 0, 4])  # 真實標簽
loss1 = criterion(outputs, labels)  # 直接調用
import torch.nn.functional as F
loss2 = F.cross_entropy(outputs,labels,reduction="mean"  # 每次調用需顯式傳遞參數
)# 優化器       torch.optim模塊提供多種優化函數，例如隨機梯度下降(SGD)、Adam
# optimizer.zero_grad()         梯度清零，清空優化器跟蹤的參數的梯度（即 model.parameters() 中注冊的參數）
# layer.weight.grad、layer.bias.grad     保存該層的 權重weight梯度信息 和 偏置bias梯度信息
# model.named_parameters()      通過迭代器 獲取模型的所有參數（而不是某一層）及其梯度 [(n, p.grad) for n, p in model.named_parameters()]
torch.manual_seed(77)                               # 設置隨機種子，77可以改為其他數字
model = nn.Linear(3, 1)                             # 定義模型：簡單線性層，就是3行1列 個神經元
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 定義優化器：隨機梯度下降優化器
inputs = torch.randn(10, 3)                         # 模擬輸入數據和標簽：batch_size批量大小10，特征維度3（就是3行10列的張量，10個樣品，每個樣品）
labels = torch.randn(10, 1)                         # 對應標簽
for epoch in range(2):                              # 訓練循環optimizer.zero_grad()                   # 1. 梯度清零outputs = model(inputs)                 # 2. 前向傳播計算損失loss = nn.MSELoss()(outputs, labels)print(f"計算epoch={epoch}的loss前：weight：{model.weight.grad}\tbias：{model.bias.grad}")loss.backward()                         # 3. 反向傳播計算梯度print(f"計算epoch={epoch}的loss后：weight：{model.weight.grad}\tbias：{model.bias.grad}")optimizer.step()                        # 4. 優化器更新參數
# 計算epoch=0的loss前：weight：None	bias：None
# 計算epoch=0的loss后：weight：tensor([[-1.2573, -0.0045, -0.6926]])	bias：tensor([0.2520])
# 計算epoch=1的loss前：weight：tensor([[0., 0., 0.]])	bias：tensor([0.])
# 計算epoch=1的loss后：weight：tensor([[-1.2206, -0.0055, -0.6704]])	bias：tensor([0.2330])
# 如果注釋掉optimizer.zero_grad()，可以對比bias變化，下面的 0.4849≈0.2520+0.2330
# 計算epoch=0的loss前：weight：None	bias：None
# 計算epoch=0的loss后：weight：tensor([[-1.2573, -0.0045, -0.6926]])	bias：tensor([0.2520])
# 計算epoch=1的loss前：weight：tensor([[-1.2573, -0.0045, -0.6926]])	bias：tensor([0.2520])
# 計算epoch=1的loss后：weight：tensor([[-2.4779, -0.0100, -1.3630]])	bias：tensor([0.4849])# torch.nn.utils.clip_grad_norm_()      梯度裁剪
torch.manual_seed(77)                               # 設置隨機種子，77可以改為其他數字
model = nn.Linear(3, 1)
optimizer = optim.SGD(model.parameters(), lr=0.01)
input_data = torch.randn(10, 3)
output = model(input_data)                                          # 前向傳播
loss = torch.nn.functional.mse_loss(output, torch.randn(10, 1))
loss.backward()                                                     # 反向傳播
print(f"裁剪前梯度：weight.grad={model.weight.grad}\tbias.grad={model.bias.grad}")
grads = torch.cat([p.grad.flatten() for p in model.parameters()])   # grads = tensor([-1.2573, -0.0045, -0.6926,  0.2520])
weightGrad, biasGrad = model.weight.grad*1/torch.norm(grads), model.bias.grad*1/torch.norm(grads)
print(f"手動計算裁剪后梯度：weight.grad={weightGrad}\tbias.grad={biasGrad}")
torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1.0)            # 梯度裁剪
print(f"裁剪后梯度：{model.weight.grad}\tbias.grad={model.bias.grad}")
optimizer.step()
# 打印：
# 裁剪前梯度：weight.grad=tensor([[-1.2573, -0.0045, -0.6926]])	bias.grad=tensor([0.2520])
# 手動計算裁剪后梯度：weight.grad=tensor([[-0.8627, -0.0031, -0.4752]])	bias.grad=tensor([0.1729])
# 裁剪后梯度：tensor([[-0.8627, -0.0031, -0.4752]])	bias.grad=tensor([0.1729])
# 可見：-0.8627 = -1.2573 * 1 / math.sqrt((1.2573*1.2573 + 0.0045*0.0045 + 0.6926*0.6926 + 0.2520*0.2520))# DataLoader\Dataset        torch.utils.data提供了用于加載和處理數據的工具
# 例如：DataLoader(my_dataset, batch_size=2, shuffle=True):
#       創建一個數據加載器，my_dataset 必須繼承自torch.utils.data.Dataset的自定義數據集對象
#       需要實現__len__()（返回數據集大小）和__getitem__()（根據索引返回樣本和標簽）方法。
#       batch_size=2：每個批次包含2個樣本。例如，若數據集有1000個樣本，則會生成500個批次（每個批次2個樣本）。
#       shuffle=True：在每個epoch開始時打亂數據順序（默認shuffle=False）。提升泛化能力
from torch.utils.data import DataLoader, Dataset
class CustomDataset(Dataset):           # 自定義數據集類def __init__(self, data):self.data = datadef __len__(self):return len(self.data)def __getitem__(self, index):return self.data[index]
my_dataset = CustomDataset([1, 2, 3, 4, 5])     # 創建自定義數據集實例
data_loader = DataLoader(my_dataset, batch_size=2, shuffle=True)    # 創建數據加載器
for batch in data_loader:       # 迭代數據加載器print("Batch:", batch)
# 打印
# Batch: tensor([2, 3])
# Batch: tensor([4, 5])
# Batch: tensor([1])# 學習率調度     .optim.lr_scheduler 模塊提供了多種學習率調度器，例如學習率衰減等
from torch.optim.lr_scheduler import StepLR
torch.manual_seed(77)                               # 設置隨機種子，77可以改為其他數字
model = nn.Linear(3, 1)                             # 定義模型：簡單線性層，就是3行1列 個神經元
optimizer = optim.SGD(model.parameters(), lr=0.01)  # 定義優化器：隨機梯度下降優化器
scheduler = StepLR(optimizer, step_size=5, gamma=0.1)   # 按照固定周期調整優化器的學習率：每隔 5 個epoch調整一次學習率，每次將學習率縮小10倍（乘0.1）
inputs = torch.randn(10, 3)                         # 模擬輸入數據和標簽：batch_size批量大小10，特征維度3（就是3行10列的張量，10個樣品，每個樣品）
labels = torch.randn(10, 1)                         # 對應標簽
for epoch in range(20):                              # 訓練循環optimizer.zero_grad()                   # 1. 梯度清零outputs = model(inputs)                 # 2. 前向傳播計算損失loss = nn.MSELoss()(outputs, labels)print(f"計算epoch={epoch}的loss前：weight：{model.weight.grad}\tbias：{model.bias.grad}")loss.backward()                         # 3. 反向傳播計算梯度print(f"計算epoch={epoch}的loss后：weight：{model.weight.grad}\tbias：{model.bias.grad}")optimizer.step()                        # 4. 優化器更新參數scheduler.step()                        # 5、更新學習率

本文來自互聯網用戶投稿，該文觀點僅代表作者本人，不代表本站立場。本站僅提供信息存儲空間服務，不擁有所有權，不承擔相關法律責任。
如若轉載，請注明出處：http://www.pswp.cn/web/79191.shtml
繁體地址，請注明出處：http://hk.pswp.cn/web/79191.shtml
英文地址，請注明出處：http://en.pswp.cn/web/79191.shtml

如若內容造成侵權/違法違規/事實不符，請聯系多彩編程網進行投訴反饋email:809451989@qq.com，一經查實，立即刪除！

相關文章

flask開啟https服務支持

flask開啟https服務支持

目錄 一、背景 二、開啟https支持 三、自簽名 1、安裝openssl 2、驗證安裝 3、自簽名 四、編寫代碼 五、訪問https接口 一、背景 最近在做自動化業務，需要兼容現在主流的框架開發的前端頁面，于是到github找到了幾個項目，clone下來項目并…
閱讀更多...
路由交換實驗

路由交換實驗

案例一：實施和配置RIPV2 1.給AR1配置接口 查看R1接口配置情況 2.配置三臺路由的RIP協議，版本為version2 ，關閉自動匯總，通告所有的直連接口 案例二：配置多區域的OSPF協議 1.配置R1的接口IP地址參數 2.配置r2,r3的接口參…
閱讀更多...
北斗導航 ｜ RTKLib中重難點技術，公式，代碼

北斗導航 ｜ RTKLib中重難點技術，公式，代碼

Rtklib 一、抗差自適應卡爾曼濾波1. **核心難點**2. **公式與代碼實現**二、模糊度固定與LAMBDA算法1. **核心難點**2. **LAMBDA算法實現**3. **部分模糊度固定技術**三、偽距單點定位與誤差修正1. **多系統多頻點修正**2. **接收機鐘差與系統間偏差**四、動態模型與周跳處理1.…
閱讀更多...
RT-Thread 深入系列 Part 2：RT-Thread 內核核心機制深度剖析

RT-Thread 深入系列 Part 2：RT-Thread 內核核心機制深度剖析

摘要： 本文從線程管理、調度器原理、中斷處理與上下文切換、IPC 同步機制、內存管理五大核心模塊出發，深入剖析 RT-Thread 內核實現細節，并輔以源碼解讀、流程圖、時序圖與性能數據。 目錄 線程管理與調度器原理 1.1 線程控制塊（TCB）結構 1.2 就緒隊列與優先級調度 1.3 時…
閱讀更多...
STM32部分：3、STM32CubeMX 工程創建

STM32部分：3、STM32CubeMX 工程創建

飛書文檔https://x509p6c8to.feishu.cn/wiki/LfMpwjktZiMAuMkayt6c0LGZnpx 1、打開STM32CUBEMX，選擇File->New Project 如果首次使用，可能會自動下載一些依賴包，可以等待下載完成。 2、選擇對應芯片 MCU/MPU Selector->輸入“STM32F1…
閱讀更多...
第十五章，SSL VPN

第十五章，SSL VPN

前言 IPSec 和 SSL 對比 IPSec遠程接入場景---client提前安裝軟件，存在一定的兼容性問題 IPSec協議只能夠對感興趣的流量進行加密保護，意味著接入用戶需要不停的調整策略，來適應IPSec隧道 IPSec協議對用戶訪問權限顆粒度劃分的不夠詳細&…
閱讀更多...
深度學習系統學習系列【4】之反向傳播（BP)四個基本公式推導

深度學習系統學習系列【4】之反向傳播（BP)四個基本公式推導

文章目錄 補充知識：? 和 ⊙ 運算符詳解? (nabla) 運算符⊙ (圓圈點) 運算符 反向傳播基本公式計算圖和基本定義BP1：輸出層誤差推導BP1公式的重要性實際例子BP2第 l l l層誤差推導BP3 ：損失函數關于偏置(b)偏導的推導BP4： 損失函…
閱讀更多...
極狐Gitlab 如何創建并使用子群組？

極狐Gitlab 如何創建并使用子群組？

極狐GitLab 是 GitLab 在中國的發行版，關于中文參考文檔和資料有： 極狐GitLab 中文文檔極狐GitLab 中文論壇極狐GitLab 官網 子群組 (BASIC ALL) 您可以將極狐GitLab 群組組織成子群組。您可以使用子群組： 內部和外部組織分開。因為每個子…
閱讀更多...
HarmonyOS基本的應用的配置

HarmonyOS基本的應用的配置

鴻蒙HarmonyOS組建頁面 1、創建ets文件并配置2、修改main_pages.json文件3、修改EntryAbility.ets文件（啟動時加載的頁面） 1、創建ets文件并配置 Index.ets是創建項目自動構建生成的，我們可以將其刪除掉，并重新在page文件夾下創建…
閱讀更多...
強化學習三大基本方法-DP、MC、TD

強化學習三大基本方法-DP、MC、TD

強化學習進階 本文主要講解 動態規劃法（Dynamic Programming DP）蒙特卡洛法（Monte Carlo MC）時序差分法（Temporal Difference TD） 1. 動態規劃法 1.1 動態規劃概念 動態規劃核心思想： 其核心…
閱讀更多...
《Spring Boot 3.0全新特性詳解與實戰案例》

《Spring Boot 3.0全新特性詳解與實戰案例》

大家好呀！今天讓我們輕松掌握Spring Boot 3.0的所有新特性！🚀 📌 第一章：Spring Boot 3.0簡介 1.1 什么是Spring Boot 3.0？ Spring Boot 3.0就像是Java開發者的"超級工具箱"🧰&…
閱讀更多...
【推薦筆記工具】思源筆記 - 隱私優先的個人知識管理系統，支持 Markdown 排版、塊級引用和雙向鏈接

【推薦筆記工具】思源筆記 - 隱私優先的個人知識管理系統，支持 Markdown 排版、塊級引用和雙向鏈接

Typora 使用Typora好多年了，一直非常的喜歡這個簡潔的Markdown編輯工具，低版本的免費且好用。 Typora官網地址： https://typora.io/ https://typoraio.cn/ Typora的文檔樹如下，細看后，總覺得差點意思! 思源筆記 今…
閱讀更多...
虛擬文件系統

虛擬文件系統

虛擬文件系統（Virtual File System，VFS）是操作系統內核中的一個抽象層，它為不同的文件系統（如ext4、NTFS、FAT32等）提供統一的訪問接口。通過VFS，用戶和應用程序無需關心底層文件系統的具體差異…
閱讀更多...
Kubernetes Gateway API 部署詳解：從入門到實戰

Kubernetes Gateway API 部署詳解：從入門到實戰

引言 在 Kubernetes 中管理網絡流量一直是一個復雜而關鍵的任務。傳統的 Ingress API 雖然廣泛使用，但其功能有限且擴展性不足。Kubernetes Gateway API 作為新一代標準，提供了更強大的路由控制能力，支持多協議、跨命名空間路由和細粒度的流量管理。本文將帶你從零開始部署…
閱讀更多...
關于大數據的基礎知識（二）——國內大數據產業鏈分布結構

關于大數據的基礎知識（二）——國內大數據產業鏈分布結構

成長路上不孤單😊😊😊😊😊😊 【14后😊///計算機愛好者😊///持續分享所學😊///如有需要歡迎收藏轉發///😊】 今日分享關于大數據的基礎知識（二&a…
閱讀更多...
py實現win自動化自動登陸qq

py實現win自動化自動登陸qq

系列文章目錄 py實現win自動化自動登陸qq 文章目錄 系列文章目錄前言一、上代碼？總結 前言 之前都是網頁自動化感覺太容易了，就來嘗嘗win自動化，就先寫了一個qq登陸的，這個是拿到className 然后進行點擊等。 一、上代碼&#xf…
閱讀更多...
動態創建鏈表（頭插法、尾插法）

動態創建鏈表（頭插法、尾插法）

今天我們來學習動態創建鏈表！！！ 動態創建鏈表：分為頭插法和尾插法 頭插法（動態創建）： 頭插法就是讓新節點變成頭 代碼如下 吐血了：這邊有個非常重要的知識點，這邊第三…
閱讀更多...
Dp通用套路(閆式)

Dp通用套路(閆式)

閆式dp分析法： 從集合角度來分析DP問題。 核心思想： DP是一種求有限集中的最值或者個數問題 由于集合中元素的數量都是指數級別的，直接用定義去求，把每種方案都用dfs暴力枚舉一遍，時間復雜度很高，此時用…
閱讀更多...
33、前臺搜索功能怎么實現？

33、前臺搜索功能怎么實現？

輸入搜索的東西，如果為空 如果有 前端是提交表單，方式是 post 后端接受 調用 mybatisplus的categoryService.getById 用戶在搜索框內輸入關鍵字之后，執行 js 中的 load方法，前端提交表單， 后端 controller 中的loa…
閱讀更多...
Spring Boot 框架概述

Spring Boot 框架概述

1. 簡介 Spring Boot 是由 Pivotal 團隊開發的一個用于簡化 Spring 應用開發的框架。它通過提供默認配置、嵌入式服務器和自動配置等特性，讓開發者能夠更快速地構建獨立的、生產級別的 Spring 應用。 Spring Boot 的主要特點包括： 快速創建獨立的 Spri…
閱讀更多...
最新文章

Copyright @ 2022~2023