快速入门Pytorch:以MNIST数据集为例

首先下载Mnist数据集,解压后放入./

import numpy as np

import struct

import matplotlib.pyplot as plt

import torch

import torch.nn as nn

import torch.nn.functional as F

from tqdm import tqdm

#数据读入部分

def readfile(tgt):

times = {'train':60000,'t10k':10000}def get_image(buf1):image_index = 0image_index += struct.calcsize('>IIII')im = []for i in range(times[tgt]):temp = struct.unpack_from('>784B', buf1, image_index)im.append(np.reshape(temp, (28, 28)))image_index += struct.calcsize('>784B')return imdef get_label(buf2): label_index = 0label_index += struct.calcsize('>II')labels = []for i in range(times[tgt]):label = struct.unpack_from('>1B', buf2, label_index)labels.append(label[0])label_index += struct.calcsize('>1B')return labelswith open(f'./{tgt}-images.idx3-ubyte', 'rb') as f1:buf1 = f1.read()im = get_image(buf1)with open(f'./{tgt}-labels.idx1-ubyte', 'rb') as f2:buf2 = f2.read()label = get_label(buf2)return  im,label

train = ‘train’

test = ‘t10k’

a = readfile(train)

b = readfile(test)

X_train = a[0]

X_train = np.stack(X_train)

X_train = torch.tensor(X_train).float()

X_train.unsqueeze_(1)

y = a[1]

torch.manual_seed(0)

#定义网络,并实现sklearn风格接口

class Net(nn.Module):

def __init__(self, *args, **kwargs):super(Net, self).__init__()self.conv1 = nn.Conv2d(1, 1, (3, 3))self.maxpoll1 = nn.MaxPool2d(kernel_size=(2, 2))self.flatten = nn.Flatten()self.fc1 = nn.Linear(169,10)self.fc2 = nn.Linear(10,10)def forward(self, x, *args, **kwargs):x = self.conv1(x)x = self.maxpoll1(x)x = self.flatten(x)# print(x.shape)x = self.fc1(x)for i in range(5):x = self.fc2(x)x = F.softmax(x)return xdef fit(self, X, y, epochs=10,batchsize = 10,need_categorize=True):if need_categorize:y = self.categorize(y).long()self.criterion = nn.CrossEntropyLoss()self.optimizer = torch.optim.Adam(self.parameters())lss = []self.train()for i in tqdm(range(epochs)):ls = 0start = 0end = batchsizecnt = 0while(1):if start >= X.shape[0] - 1:breakif end >= X.shape[0] - 1:end = X.shape[0] - 1y_pred = self.forward(X[start:end,:,:,:])# print(y[start:end,:].argmax(1))self.loss = self.criterion(y_pred, y[start:end,:].argmax(1))ls += self.lossself.optimizer.zero_grad()self.loss.backward()self.optimizer.step()start += batchsizeend += batchsizecnt += 1ls /= cnt# print(self.score(X,y))print(ls)lss.append(ls)self.eval()return lssdef predict(self,X,need_categorize=True):y = self.forward(X)y = y.argmax(1)return ydef score(self, X, y,need_categorize=True):if need_categorize:y = self.categorize(y)y1 = self.predict(X)y1 =  y1.numpy().astype('int').reshape((-1,1))y = y.numpy().argmax(1).astype('int').reshape((-1,1))metric = (y == y1).sum() / y.shape[0]return metricdef categorize(self,y):def func(x,i):i = int(i)x[i] = 1return xy = torch.tensor(y)self.dim = int(y.max() + 1)if len(y.shape) == 2:passelse:y = y.reshape((-1,1))return torch.tensor(np.stack([func(np.zeros((self.dim)),i[0]) for i in y]))

net = Net()

lss = net.fit(X_train[:10000,:,:,:],y[:10000],epochs=100,batchsize=16)#训练网络

‘’’

训练过程

1%| | 1/100 [00:02<04:14, 2.57s/it]tensor(1.6657, grad_fn=<DivBackward0>)

2%|▏ | 2/100 [00:05<04:13, 2.58s/it]tensor(1.6453, grad_fn=<DivBackward0>)

3%|▎ | 3/100 [00:07<04:16, 2.64s/it]tensor(1.6301, grad_fn=<DivBackward0>)

4%|▍ | 4/100 [00:10<04:21, 2.73s/it]tensor(1.6245, grad_fn=<DivBackward0>)

5%|▌ | 5/100 [00:14<04:35, 2.90s/it]tensor(1.6239, grad_fn=<DivBackward0>)

6%|▌ | 6/100 [00:17<04:47, 3.06s/it]tensor(1.6188, grad_fn=<DivBackward0>)

7%|▋ | 7/100 [00:21<04:58, 3.21s/it]tensor(1.6146, grad_fn=<DivBackward0>)

8%|▊ | 8/100 [00:24<04:56, 3.22s/it]tensor(1.6073, grad_fn=<DivBackward0>)

9%|▉ | 9/100 [00:27<05:00, 3.30s/it]tensor(1.6112, grad_fn=<DivBackward0>)

10%|█ | 10/100 [00:31<05:01, 3.35s/it]tensor(1.6198, grad_fn=<DivBackward0>)

11%|█ | 11/100 [00:34<04:58, 3.35s/it]tensor(1.6143, grad_fn=<DivBackward0>)

12%|█▏ | 12/100 [00:38<04:58, 3.39s/it]tensor(1.6156, grad_fn=<DivBackward0>)

13%|█▎ | 13/100 [00:41<05:00, 3.45s/it]tensor(1.6145, grad_fn=<DivBackward0>)

14%|█▍ | 14/100 [00:45<05:00, 3.50s/it]tensor(1.6058, grad_fn=<DivBackward0>)

15%|█▌ | 15/100 [00:49<05:01, 3.55s/it]tensor(1.6014, grad_fn=<DivBackward0>)

16%|█▌ | 16/100 [00:52<04:58, 3.55s/it]tensor(1.5980, grad_fn=<DivBackward0>)

17%|█▋ | 17/100 [00:56<05:00, 3.62s/it]tensor(1.5993, grad_fn=<DivBackward0>)

18%|█▊ | 18/100 [00:59<04:55, 3.60s/it]tensor(1.6017, grad_fn=<DivBackward0>)

19%|█▉ | 19/100 [01:03<04:52, 3.61s/it]tensor(1.5985, grad_fn=<DivBackward0>)

20%|██ | 20/100 [01:07<04:49, 3.62s/it]tensor(1.6086, grad_fn=<DivBackward0>)

21%|██ | 21/100 [01:10<04:46, 3.63s/it]tensor(1.5997, grad_fn=<DivBackward0>)

22%|██▏ | 22/100 [01:14<04:46, 3.68s/it]tensor(1.5968, grad_fn=<DivBackward0>)

23%|██▎ | 23/100 [01:18<04:43, 3.68s/it]tensor(1.6002, grad_fn=<DivBackward0>)

24%|██▍ | 24/100 [01:22<04:42, 3.72s/it]tensor(1.5980, grad_fn=<DivBackward0>)

25%|██▌ | 25/100 [01:26<04:52, 3.90s/it]tensor(1.5981, grad_fn=<DivBackward0>)

26%|██▌ | 26/100 [01:31<05:02, 4.08s/it]tensor(1.5945, grad_fn=<DivBackward0>)

27%|██▋ | 27/100 [01:36<05:27, 4.48s/it]tensor(1.5995, grad_fn=<DivBackward0>)

28%|██▊ | 28/100 [01:41<05:33, 4.63s/it]tensor(1.6033, grad_fn=<DivBackward0>)

29%|██▉ | 29/100 [01:45<05:15, 4.44s/it]tensor(1.5984, grad_fn=<DivBackward0>)

30%|███ | 30/100 [01:49<05:03, 4.33s/it]tensor(1.6073, grad_fn=<DivBackward0>)

31%|███ | 31/100 [01:53<04:51, 4.22s/it]tensor(1.6063, grad_fn=<DivBackward0>)

32%|███▏ | 32/100 [01:57<04:40, 4.12s/it]tensor(1.5978, grad_fn=<DivBackward0>)

33%|███▎ | 33/100 [02:01<04:31, 4.06s/it]tensor(1.6016, grad_fn=<DivBackward0>)

34%|███▍ | 34/100 [02:05<04:24, 4.00s/it]tensor(1.6025, grad_fn=<DivBackward0>)

35%|███▌ | 35/100 [02:09<04:18, 3.98s/it]tensor(1.6040, grad_fn=<DivBackward0>)

36%|███▌ | 36/100 [02:13<04:23, 4.11s/it]tensor(1.5952, grad_fn=<DivBackward0>)

37%|███▋ | 37/100 [02:17<04:21, 4.15s/it]tensor(1.6000, grad_fn=<DivBackward0>)

38%|███▊ | 38/100 [02:22<04:23, 4.25s/it]tensor(1.6040, grad_fn=<DivBackward0>)

39%|███▉ | 39/100 [02:26<04:22, 4.31s/it]tensor(1.6014, grad_fn=<DivBackward0>)

40%|████ | 40/100 [02:30<04:15, 4.27s/it]tensor(1.6053, grad_fn=<DivBackward0>)

41%|████ | 41/100 [02:34<04:05, 4.16s/it]tensor(1.6016, grad_fn=<DivBackward0>)

42%|████▏ | 42/100 [02:39<04:03, 4.20s/it]tensor(1.5973, grad_fn=<DivBackward0>)

43%|████▎ | 43/100 [02:43<03:57, 4.16s/it]tensor(1.5943, grad_fn=<DivBackward0>)

44%|████▍ | 44/100 [02:47<04:02, 4.33s/it]tensor(1.6000, grad_fn=<DivBackward0>)

45%|████▌ | 45/100 [02:52<03:58, 4.34s/it]tensor(1.5918, grad_fn=<DivBackward0>)

46%|████▌ | 46/100 [02:56<03:54, 4.35s/it]tensor(1.6148, grad_fn=<DivBackward0>)

47%|████▋ | 47/100 [03:00<03:49, 4.33s/it]tensor(1.6056, grad_fn=<DivBackward0>)

48%|████▊ | 48/100 [03:04<03:41, 4.25s/it]tensor(1.5986, grad_fn=<DivBackward0>)

49%|████▉ | 49/100 [03:08<03:32, 4.16s/it]tensor(1.6038, grad_fn=<DivBackward0>)

50%|█████ | 50/100 [03:12<03:25, 4.11s/it]tensor(1.6008, grad_fn=<DivBackward0>)

51%|█████ | 51/100 [03:16<03:19, 4.07s/it]tensor(1.5996, grad_fn=<DivBackward0>)

52%|█████▏ | 52/100 [03:20<03:13, 4.03s/it]tensor(1.5983, grad_fn=<DivBackward0>)

53%|█████▎ | 53/100 [03:24<03:06, 3.98s/it]tensor(1.6088, grad_fn=<DivBackward0>)

54%|█████▍ | 54/100 [03:28<03:02, 3.96s/it]tensor(1.6084, grad_fn=<DivBackward0>)

55%|█████▌ | 55/100 [03:32<02:56, 3.92s/it]tensor(1.5990, grad_fn=<DivBackward0>)

56%|█████▌ | 56/100 [03:36<02:51, 3.89s/it]tensor(1.5984, grad_fn=<DivBackward0>)

57%|█████▋ | 57/100 [03:39<02:44, 3.84s/it]tensor(1.5975, grad_fn=<DivBackward0>)

58%|█████▊ | 58/100 [03:43<02:40, 3.81s/it]tensor(1.5939, grad_fn=<DivBackward0>)

59%|█████▉ | 59/100 [03:47<02:35, 3.79s/it]tensor(1.5983, grad_fn=<DivBackward0>)

60%|██████ | 60/100 [03:51<02:29, 3.75s/it]tensor(1.6144, grad_fn=<DivBackward0>)

61%|██████ | 61/100 [03:54<02:26, 3.77s/it]tensor(1.5967, grad_fn=<DivBackward0>)

62%|██████▏ | 62/100 [03:58<02:24, 3.81s/it]tensor(1.6061, grad_fn=<DivBackward0>)

63%|██████▎ | 63/100 [04:02<02:23, 3.87s/it]tensor(1.6089, grad_fn=<DivBackward0>)

64%|██████▍ | 64/100 [04:06<02:20, 3.90s/it]tensor(1.6301, grad_fn=<DivBackward0>)

65%|██████▌ | 65/100 [04:10<02:16, 3.91s/it]tensor(1.6260, grad_fn=<DivBackward0>)

66%|██████▌ | 66/100 [04:14<02:12, 3.90s/it]tensor(1.6090, grad_fn=<DivBackward0>)

67%|██████▋ | 67/100 [04:18<02:08, 3.89s/it]tensor(1.6034, grad_fn=<DivBackward0>)

68%|██████▊ | 68/100 [04:22<02:07, 3.97s/it]tensor(1.6016, grad_fn=<DivBackward0>)

69%|██████▉ | 69/100 [04:26<02:06, 4.07s/it]tensor(1.6103, grad_fn=<DivBackward0>)

70%|███████ | 70/100 [04:30<02:00, 4.03s/it]tensor(1.6197, grad_fn=<DivBackward0>)

71%|███████ | 71/100 [04:34<01:56, 4.02s/it]tensor(1.6116, grad_fn=<DivBackward0>)

72%|███████▏ | 72/100 [04:38<01:51, 4.00s/it]tensor(1.6138, grad_fn=<DivBackward0>)

73%|███████▎ | 73/100 [04:42<01:46, 3.96s/it]tensor(1.6181, grad_fn=<DivBackward0>)

74%|███████▍ | 74/100 [04:46<01:42, 3.93s/it]tensor(1.6069, grad_fn=<DivBackward0>)

75%|███████▌ | 75/100 [04:50<01:37, 3.89s/it]tensor(1.6059, grad_fn=<DivBackward0>)

76%|███████▌ | 76/100 [04:54<01:37, 4.05s/it]tensor(1.6237, grad_fn=<DivBackward0>)

77%|███████▋ | 77/100 [04:58<01:34, 4.09s/it]tensor(1.6089, grad_fn=<DivBackward0>)

78%|███████▊ | 78/100 [05:02<01:25, 3.91s/it]tensor(1.6178, grad_fn=<DivBackward0>)

79%|███████▉ | 79/100 [05:05<01:18, 3.76s/it]tensor(1.6188, grad_fn=<DivBackward0>)

80%|████████ | 80/100 [05:09<01:13, 3.69s/it]tensor(1.6343, grad_fn=<DivBackward0>)

81%|████████ | 81/100 [05:12<01:08, 3.61s/it]tensor(1.6117, grad_fn=<DivBackward0>)

82%|████████▏ | 82/100 [05:16<01:05, 3.66s/it]tensor(1.6036, grad_fn=<DivBackward0>)

83%|████████▎ | 83/100 [05:19<01:00, 3.57s/it]tensor(1.6103, grad_fn=<DivBackward0>)

84%|████████▍ | 84/100 [05:23<00:56, 3.52s/it]tensor(1.6077, grad_fn=<DivBackward0>)

85%|████████▌ | 85/100 [05:26<00:52, 3.52s/it]tensor(1.6200, grad_fn=<DivBackward0>)

86%|████████▌ | 86/100 [05:30<00:48, 3.50s/it]tensor(1.6193, grad_fn=<DivBackward0>)

87%|████████▋ | 87/100 [05:33<00:45, 3.49s/it]tensor(1.6079, grad_fn=<DivBackward0>)

88%|████████▊ | 88/100 [05:37<00:41, 3.48s/it]tensor(1.6000, grad_fn=<DivBackward0>)

89%|████████▉ | 89/100 [05:40<00:37, 3.44s/it]tensor(1.6084, grad_fn=<DivBackward0>)

90%|█████████ | 90/100 [05:43<00:34, 3.42s/it]tensor(1.6139, grad_fn=<DivBackward0>)

91%|█████████ | 91/100 [05:47<00:30, 3.40s/it]tensor(1.6149, grad_fn=<DivBackward0>)

92%|█████████▏| 92/100 [05:50<00:27, 3.40s/it]tensor(1.6075, grad_fn=<DivBackward0>)

93%|█████████▎| 93/100 [05:53<00:23, 3.38s/it]tensor(1.6105, grad_fn=<DivBackward0>)

94%|█████████▍| 94/100 [05:57<00:20, 3.38s/it]tensor(1.6165, grad_fn=<DivBackward0>)

95%|█████████▌| 95/100 [06:00<00:16, 3.38s/it]tensor(1.6063, grad_fn=<DivBackward0>)

96%|█████████▌| 96/100 [06:04<00:13, 3.38s/it]tensor(1.6069, grad_fn=<DivBackward0>)

97%|█████████▋| 97/100 [06:07<00:10, 3.35s/it]tensor(1.6090, grad_fn=<DivBackward0>)

98%|█████████▊| 98/100 [06:10<00:06, 3.33s/it]tensor(1.6037, grad_fn=<DivBackward0>)

99%|█████████▉| 99/100 [06:13<00:03, 3.31s/it]tensor(1.6162, grad_fn=<DivBackward0>)

100%|██████████| 100/100 [06:17<00:00, 3.78s/it]tensor(1.6157, grad_fn=<DivBackward0>)

‘’’

plt.plot(list(range(len(lss))),lss)#可视化loss

#可以看出因为定义了一个权值复用五次的全连接层(self.fc2),网络发生了明显的过拟合

net.score(X_train[20000:60000-1,:,:,:],y[20000:60000 - 1]) #评估网络

#0.8310457761444036

#随机挑选几个样本进行可视化

for i in range(9):

item = np.random.randint(0,60000 -1)plt.subplot(3, 3, i + 1)title = f"标签:{str(y[item])} 预测:{net.predict(X_train[[item],:,:,:])[0]}"plt.title(title, fontproperties='SimHei')plt.imshow(X_train[item,:,:,:].squeeze(0), cmap='gray')

plt.show()

#可视化一下self.fc1的权值

for i in range(10):

plt.subplot(3,4,i+1)plt.title(f'{i}')plt.imshow(list(net.fc1.parameters())[0][i,:].view((13,13)).detach().numpy(),cmap='gray')

plt.show()

查看全文
如若内容造成侵权/违法违规/事实不符，请联系编程学习网邮箱：809451989@qq.com进行投诉反馈，一经查实，立即删除！

python基础语法（二）
1.input() 输入指令函数 name = input(请输入你的名字：) print(欢迎+ name)# 结果如下：请输入你的名字：小白欢迎小白2.int函数 num1 = int(input(请输入第一个数字：)) num2 = input(请输入第二个个数字：) print(type(num1)) print(type(num2))# 结果如下：请输入第一个…...
2024/5/6 20:25:00
go 获取cpu核数
简言1. go语言提供了强大的runtime库，可以轻松获取系统信息2. NumCPU()函数可以获取cpu的核数实验如下图：代码如下：package main import ("fmt""runtime" ) func main() {fmt.Println("cpu:", runtime.NumCPU()) }...
2024/4/24 3:26:06
数据挖掘和数据仓库
数据挖掘和数据仓库数据挖掘概念基于AI、机器学习、统计学等技术，高度自动化的分析原有数据，进行归纳推理，从数据仓库中提取可信的、新颖的、有效的、人们感兴趣的、别人能理解的知识的高级处理过程。模式分类：预测性模式或描述性模式实际应用中可细分为：关联模式、…...
2024/5/4 8:48:50
eth0:ERROR while getting interface flags:No such device问题解决或者右上角网络连接图标消失的解决方法
itualbox安装unbuntu server版本,一直连不上网对于CentOS8（对于我的情况）也是适用的打开ubuntu里的网络设置 vi /etc/network/interfaces配置如下: auto eth0 iface eth0 inet dhcp重启网络设备: /etc/init.d/networking restart会报下面的错误 SIOCSIFADDR: No such devic…...
2024/5/4 11:48:31
CentOS6.9安装ElasticSearch
本篇笔记记录了CentOS6.9下安装ElasticSearch的过程安装jdk1.8 yum install java-1.8.0-openjdk添加elasticsearch用户和组 groupadd elasticsearch useradd -g elasticsearch elasticsearch创建目录 mkdir -p /usr/local cd /usr/local下载ElasticSearch wget -c https://arti…...
2024/5/4 13:14:39
Centos：完美解决python升级导致的yum报错问题(相信我这是一篇有用的文章)
忙碌了两个小事的陈师傅，决定发一篇博客以防其他网友继续撞坑！！！问题大致如下： There was a problem importing one of the Python modules required to run yum. The error leading to this problem was: No module named yum Please install a package which provides …...
2024/4/24 9:53:46
STM32编译报错--有可能是缺少文件
刚开始接触32单片机开发板，发现32建工程比51要复杂很多，要包含很多文件，一个文件的缺失就可能造成全盘皆输。按照步骤建工程，却发现有错误和警告？很有可能是缺少文件 Template–OBJ文件下可能缺少此文件：只有将文件全部包含进去才能顺利执行 fighting...
2024/4/16 9:18:32
CodeChef Squared Subsequences
题意：在给定序列中找任意长度的连续子序列，使得子序列所有数的乘积等于p2-q2。问有多少个这样的子序列。题记：任意整数的平方差是满足2k+1或者4k。奇数乘奇数=奇数，奇数乘偶数=偶数，偶数乘偶数=4*k 首先算出程度为n的序列的总子序列长度，然后遍历数组，当遇到一个偶数且…...
2024/4/16 9:18:27
Synchronized与Lock的区别
synchronized与Lock的区别synchronized是java内置关键字，属于jvm层面；Lock是一个接口(常用的实现类为ReentrantLock)； synchronized无法判断是否获取锁的状态，Lock可以判断是否获取到锁； synchronized会自动释放锁(a 线程执行完同步代码会释放锁 ,b 线程执行过程中发生异常…...
2024/4/16 9:18:27
2020华为软件精英挑战赛历程总结——初赛篇
前言去年懵懵懂懂，一个人从头自闭到尾，到最后也没对上判题器，复赛第十遗憾离场。今年的开端也是十分不顺，我们提交的第一发线上14s，这时候前排已经有0.x的成绩了，一度陷入深深的自我怀疑之中。好在队友十分carry，多核输出的感觉真的挺爽，后来慢慢找到节奏，一路从二十…...
2024/5/4 8:20:16
选项卡效果实现-vue
效果一 <html lang="en"><head><meta charset="UTF-8"><meta name="viewport" content="width=device-width, initial-scale=1.0"><meta http-equiv="X-UA-Compatible" content="ie=edge&q…...
2024/4/24 9:53:45
[Git & Jetbrans ~ Webstorm] - Jetbrans2020.1系列软件上传本地项目到Github
步骤在菜单中选择VCS -> Import into Version Control -> Share Project on Github 第一次使用需输入账户密码Server可以填其它Git服务器填写仓库名称出现该弹窗则上传成功可以在Github上查看...
2024/4/24 9:53:44
HTML快速入门笔记
网页结构DOCTYPE 声明使用HTML的版本 < header > 表示页面中的一个内容区块或者整个页面的标题。 < nav >表示页面中导航链接的部分 < article > 表示页面中一块与上下文不相关的独立内容。比如一篇文章中的文章。 < sectior >表示页面中一块内容区块 …...
2024/5/4 1:13:17
有序数组寻找和为目标值的一组数
二分思想注意需要有序数组！！！一个“指针”a从数组首位开始搜索，另一“指针”b从数组尾部开始搜索。循环：(a!=b){sum = a+b，若sum正确则返回。若sum>目标值，那么b--，寻找更小值。否则a++，寻找更大值。}循环正常退出则表明不存在两个数...
2024/4/24 9:53:41
关于springboot中RestController和Controller的区别
对于长期使用springboot或者ssm的同学来说:@Controller或者@RestController等注解最熟悉不过了，最近做项目的时候，同事们发现有人用的是@RestController,有人用的是@Controller,引起了争议，那么，这些注解到底有什么区别呢？对性能方面影响大吗？ ##关于@Controller和RestCo…...
2024/4/24 9:53:40
SpringBoot Interceptor
Interceptor 介绍拦截器 (Interceptor) 同 Filter 过滤器一样，它们都是面向切面编程——AOP 的具体实现。可以使用 Interceptor 来执行某些任务，例如在 Controller 处理请求之前编写日志，添加或更新配置等。在 Spring 中，当请求发送到 Controller 时，在被 Controller 处…...
2024/4/24 9:53:42
图书管理系统的结构流程图
图书管理系统的结构流程图顶层图：0层图：1层图（图书借阅）（图书管理）二层图：借书还书...
2024/4/24 9:53:38
java包
在计算机中存放了若干类型的文档，为了管理方便，操作系统采用了树形结构的文件夹形式存放这些文档，并对文档进行管理，可以将文档分门别类地存储，易于查找，解决了文件名冲突的问题。为了更好地组织类，Java提供了包机制。包是类的容器，用于分隔类名空间。如果没有指定包名…...
2024/4/24 9:53:38
必不可少的移动端特效
目标：能够写出移动端触屏事件能够写出常见的移动端特效能够使用移动端开发插件开发移动端特效能够使用移动端开发框架开发移动端特效1. 触屏事件 1.1. 触屏事件概述移动端浏览器兼容性较好，我们不需要考虑以前 JS 的兼容性问题，可以放心的使用原生 JS 书写效果，但是移动…...
2024/4/24 9:53:38
嵌入式编程设计模式——观察者模式（发布-订阅模式）
观察者模式是最常见的模式之一。这种模式提供一种方法来时对象“监听”其他对象，而不需要修改任何数据服务器。在嵌入式领域，这意味着数据能够很容易分享给其他元素。观察者模式不需要数据服务器对它的客户有任何信息，只需要客户提供订阅功能，允许客户在通知列表中动态添加…...
2024/5/4 11:02:38

快速入门Pytorch:以MNIST数据集为例

相关文章

最新文章