文章目录

  • 一 Pytorch完成基础模型
    • 1. Pytorch完成模型常用API
      • 1.1 `nn.Module`
      • 1.2 优化器类
      • 1.3 损失函数
      • 1.4 线性回归完整代码
    • 2. 在GPU上运行代码
    • 3. 常见的优化算法介绍
      • 3.1 梯度下降算法（batch gradient descent BGD）
      • 3.2 随机梯度下降法 (Stochastic gradient descent SGD)
      • 3.3 小批量梯度下降 (Mini-batch gradient descent MBGD）
      • 3.4 动量法
      • 3.5 AdaGrad
      • 3.6 RMSProp
      • 3.7 Adam
      • 3.8 效果演示
  • 二 Pytorch中的数据加载
    • 1. 模型中使用数据加载器的目的
    • 2. 数据集类
      • 2.1 Dataset基类介绍
      • 2.2 数据加载案例
    • 3. 迭代数据集
    • 4. pytorch自带的数据集
      • 4.1 torchversion.datasets
      • 4.2 MNIST数据集的介绍

一 Pytorch完成基础模型

1. Pytorch完成模型常用API

在前一部分，已经实现了通过torch的相关方法完成反向传播和参数更新，在pytorch中预设了一些更加灵活简单的对象，用来构造模型、定义损失，优化损失等

其中一些常用的API

1.1 nn.Module

nn.Module 是torch.nn提供的一个类，是pytorch中自定义网络的一个基类，在这个类中定义了很多有用的方法，在继承这个类定义网络的时候非常简单

当自定义网络的时候，有两个方法需要特别注意：

  • __init__需要调用super方法，继承父类的属性和方法
  • forward方法必须实现，用来定义网络的前向计算的过程

用前面的y = wx+b的模型举例如下：

from torch import nn
class Lr(nn.Module):def __init__(self):super(Lr, self).__init__()  #继承父类init的参数# Linear进行如y = x + b的操作，第一个参数为输入数据特征，第二个为输出数据的特征，不包括样本的数量，如64行1列，只会记录1列self.linear = nn.Linear(1, 1) # 为模型再添加一层，模型此时包括两层的全连接层self.fc1 = nn.linear(1,1)def forward(self, x):out = self.linear(x)out = fc1(out)# 经过relu处理输出out = relu(out)return out

注意：

  • nn.Linear为torch预定义好的线性模型，也被称为全链接层，传入的参数为输入的数量，输出的数量(in_features, out_features),是不算(batch_size的列数)
  • nn.Module定义了__call__方法，实际上__call__调用的就是forward方法，即Lr的实例，能够直接被传入参数调用，实际上调用的是forward方法并传入参数
# 实例化模型
model = Lr()
# 传入数据，计算结果
predict = model(x)

1.2 优化器类

优化器(optimizer)，可以理解为torch封装的用来进行更新参数的方法，比如常见的随机梯度下降(stochastic gradient descent,SGD)

优化器类都是由torch.optim提供的，例如

  • torch.optim.SGD(参数，学习率)
  • torch.optim.Adam(参数，学习率)

注意：

  • 参数可以使用model.parameters()来获取，获取模型中所有requires_grad=True的参数
  • 优化类的使用方法
    • 实例化
    • 所有参数的梯度，将其值置为0
    • 反向传播计算梯度
    • 更新参数值

示例如下：

optimizer = optim.SGD(model.parameters(), lr=1e-3) #1. 实例化
optimizer.zero_grad() #2. 梯度置为0
loss.backward() #3. 计算梯度
optimizer.step()  #4. 更新参数的值

1.3 损失函数

前面的例子是一个回归问题，torch中也预测了很多损失函数

  • 均方误差:nn.MSELoss(),常用于回归问题
  • 交叉熵损失：nn.CrossEntropyLoss()，常用于分类问题

使用方法：

model = Lr() #1. 实例化模型
criterion = nn.MSELoss() #2. 实例化损失函数
optimizer = optim.SGD(model.parameters(), lr=1e-3) #3. 实例化优化器类
for i in range(100):y_predict = model(x_true) #4. 向前计算预测值loss = criterion(y_true,y_predict) #5. 调用损失函数传入真实值和预测值，得到损失结果optimizer.zero_grad() #6. 当前循环参数梯度置为0loss.backward() #7. 计算梯度optimizer.step()  #8. 更新参数的值

1.4 线性回归完整代码

import torch
from torch import nn
from torch import optim
import numpy as np
from matplotlib import pyplot as plt# 0. 定义数据
x = torch.rand([50,1])
y = x*3 + 0.8# 1.定义模型
class Lr(nn.Module):def __init__(self):super(Lr,self).__init__()self.linear = nn.Linear(1,1)def forward(self, x):out = self.linear(x)return out# 2. 实例化模型，loss，和优化器
model = Lr()
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=1e-3)
# 3. 训练模型，循环进行梯度下降
for i in range(30000):out = model(x) #3.1 获取预测值loss = criterion(y,out) #3.2 计算损失optimizer.zero_grad()  #3.3 梯度归零loss.backward() #3.4 计算梯度optimizer.step()  # 3.5 更新梯度if (i+1) % 20 == 0:print('Epoch[{}/{}], loss: {:.6f}'.format(i,30000,loss.data))# 4. 模型评估
model.eval() #设置模型为评估模式，即预测模式，以上可称为训练模型
predict = model(x)
predict = predict.data.numpy()
plt.scatter(x.data.numpy(),y.data.numpy(),c="r")
plt.plot(x.data.numpy(),predict)
plt.show()

注意：

model.eval()表示设置模型为评估模式，即预测模式或者使用model.train(mode=True) 设置模型为训练模式

在当前的线性回归中，上述并无区别

但是在其他的一些模型中，训练的参数和预测的参数会不相同，到时候就需要具体告诉程序当前操作是在进行训练还是预测，比如模型中存在Dropout，BatchNorm的时候

输出如下：

2. 在GPU上运行代码

当模型太大，或者参数太多的情况下，为了加快训练速度，经常会使用GPU来进行训练

此时我们的代码需要稍作调整：

  • 判断GPU是否可用torch.cuda.is_available()
torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
>>device(type='cuda', index=0)  #使用gpu
>>device(type='cpu') #使用cpu
  • 把模型参数和input数据转化为cuda的支持类型
model.to(device)
x_true.to(device)
  • 在GPU上计算结果也为cuda的数据类型，需要转化为numpy或者torch的cpu的tensor类型
predict = predict.cpu().detach().numpy()

detach()的效果和data的相似，但是detach()是深拷贝，data是取值，是浅拷贝

修改之后的代码如下：

import torch
from torch import nn
from torch import optim
import numpy as np
from matplotlib import pyplot as plt
import time# 1. 定义数据
x = torch.rand([50,1])
y = x*3 + 0.8#2 .定义模型
class Lr(nn.Module):def __init__(self):super(Lr,self).__init__()self.linear = nn.Linear(1,1)def forward(self, x):out = self.linear(x)return out# 2. 实例化模型，loss，和优化器
# 实例化device对象，用于向GPU转换
device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
x,y = x.to(device),y.to(device)model = Lr().to(device)
criterion = nn.MSELoss()
optimizer = optim.SGD(model.parameters(), lr=1e-3)#3. 训练模型
for i in range(30000):out = model(x)loss = criterion(y,out)optimizer.zero_grad()loss.backward()optimizer.step()if (i+1) % 20 == 0:print('Epoch[{}/{}], loss: {:.6f}'.format(i,30000,loss.data))#4. 模型评估
model.eval() #
predict = model(x)
predict = predict.cpu().detach().numpy() #转化为numpy数组
plt.scatter(x.cpu().data.numpy(),y.cpu().data.numpy(),c="r")
plt.plot(x.cpu().data.numpy(),predict,)
plt.show()

总结：

  • 自定义的参数和数据，需要转化为cuda支持的tensor
  • model需要转化为cuda支持的model
  • 执行的结果需要和cpu的tensor计算的时候
    • tensor.cpu()把cuda的tensor转化为cpu的tensor

3. 常见的优化算法介绍

3.1 梯度下降算法（batch gradient descent BGD）

每次迭代都需要把所有样本都送入，这样的好处是每次迭代都顾及了全部的样本，做的是全局最优化，但是有可能达到局部最优。

不适合大数据量的场景。

3.2 随机梯度下降法 (Stochastic gradient descent SGD)

针对梯度下降算法训练速度过慢的缺点，提出了随机梯度下降算法，随机梯度下降算法算法是从样本中随机抽出一个，训练后按梯度更新一次，然后再抽取一个，再更新一次，在样本量及其大的情况下，可能不用训练完所有的样本就可以获得一个损失值在可接受范围之内的模型了。

torch中的api为：torch.optim.SGD()

3.3 小批量梯度下降 (Mini-batch gradient descent MBGD）

SGD相对来说要快很多，但是也有存在问题，由于单个样本的训练可能会带来很多噪声，使得SGD并不是每次迭代都向着整体最优化方向，因此在刚开始训练时可能收敛得很快，但是训练一段时间后就会变得很慢。在此基础上又提出了小批量梯度下降法，它是每次从样本中随机抽取一小批进行训练，而不是一个样本，这样既保证了效果又保证的速度。

3.4 动量法

mini-batch SGD算法虽然这种算法能够带来很好的训练速度，但是在到达最优点的时候并不能够总是真正到达最优点，而是在最优点附近徘徊。

另一个缺点就是mini-batch SGD需要挑选一个合适的学习率，当采用小的学习率的时候，会导致网络在训练的时候收敛太慢；当采用大的学习率的时候，会导致在训练过程中优化的幅度跳过函数的范围，也就是可能跳过最优点。希望的仅仅是网络在优化的时候网络的损失函数有一个很好的收敛速度同时又不至于摆动幅度太大。

所以Momentum优化器刚好可以解决目前所面临的问题，它主要是基于梯度的移动指数加权平均，对网络的梯度进行平滑处理的，让梯度的摆动幅度变得更小。
g r a d e n t = 0.8 ∇ w + 0.2 h i s t o r y _ g r a d e n t ， ∇ w 表示当前的梯度 w = w − α ∗ g r a d e n t ， α 表示学习率 \begin{align*} &gradent = 0.8\nabla w + 0.2 history\_gradent &，\nabla w 表示当前的梯度\\ &w = w - \alpha* gradent &，\alpha表示学习率 \end{align*} ​gradent=0.8∇w+0.2history_gradentw=w−α∗gradent​，∇w表示当前的梯度，α表示学习率​
（注：t+1的histroy_gradent 为第t次的gradent）

3.5 AdaGrad

AdaGrad算法就是将每一个参数的每一次迭代的梯度取平方累加后在开方，用全局学习率除以这个数，作为学习率的动态更新，从而达到自适应学习率的效果
g r a d e n t = h i s t o r y _ g r a d e n t + ( ∇ w ) 2 w = w − α g r a d e n t + δ ∇ w , δ 为小常数，为了数值稳定大约设置为 1 0 − 7 \begin{align*} &gradent = history\_gradent + (\nabla w)^2 \\ &w = w - \frac{\alpha}{\sqrt{gradent}+\delta} \nabla w ,&\delta为小常数，为了数值稳定大约设置为10^{-7} \end{align*} ​gradent=history_gradent+(∇w)2w=w−gradent ​+δα​∇w,​δ为小常数，为了数值稳定大约设置为10−7​

3.6 RMSProp

Momentum优化算法中，虽然初步解决了优化中摆动幅度大的问题，但为了进一步优化损失函数在更新中存在摆动幅度过大的问题，并且进一步加快函数的收敛速度，RMSProp算法对参数的梯度使用了平方加权平均数。
g r a d e n t = 0.8 ∗ h i s t o r y _ g r a d e n t + 0.2 ∗ ( ∇ w ) 2 w = w − α g r a d e n t + δ ∇ w \begin{align*} & gradent = 0.8*history\_gradent + 0.2*(\nabla w)^2 \\ & w = w - \frac{\alpha}{\sqrt{gradent}+\delta} \nabla w \end{align*} ​gradent=0.8∗history_gradent+0.2∗(∇w)2w=w−gradent ​+δα​∇w​

3.7 Adam

Adam（Adaptive Moment Estimation）算法是将Momentum算法和RMSProp算法结合起来使用的一种算法,能够达到防止梯度的摆幅多大，同时还能够加开收敛速度
1. 需要初始化梯度的累积量和平方累积量 v w = 0 , s w = 0 2. 第 t 轮训练中，首先可以计算得到 M o m e n t u m 和 R M S P r o p 的参数更新： v w = 0.8 v + 0.2 ∇ w , M o m e n t u m 计算的梯度 s w = 0.8 ∗ s + 0.2 ∗ ( ∇ w ) 2 , R M S P r o p 计算的梯度 3. 对其中的值进行处理后，得到： w = w − α s w + δ v w \begin{align*} & 1. 需要初始化梯度的累积量和平方累积量 \\ & v_w = 0,s_w = 0 \\ & 2. 第 t 轮训练中，首先可以计算得到Momentum和RMSProp的参数更新：\\ & v_w = 0.8v + 0.2 \nabla w \qquad,Momentum计算的梯度\\ & s_w = 0.8*s + 0.2*(\nabla w)^2 \qquad,RMSProp计算的梯度\\ & 3. 对其中的值进行处理后，得到：\\ & w = w - \frac{\alpha}{\sqrt{s_w}+\delta} v_w \end{align*} ​1.需要初始化梯度的累积量和平方累积量vw​=0,sw​=02.第t轮训练中，首先可以计算得到Momentum和RMSProp的参数更新：vw​=0.8v+0.2∇w,Momentum计算的梯度sw​=0.8∗s+0.2∗(∇w)2,RMSProp计算的梯度3.对其中的值进行处理后，得到：w=w−sw​ ​+δα​vw​​
torch中的api为：torch.optim.Adam()

3.8 效果演示

二 Pytorch中的数据加载

1. 模型中使用数据加载器的目的

在前面的线性回归模型中，使用的数据很少，所以直接把全部数据放到模型中去使用。

但是在深度学习中，数据量通常是都非常多，非常大的，如此大量的数据，不可能一次性的在模型中进行向前的计算和反向传播，经常会对整个数据进行随机的打乱顺序，把数据处理成一个个的batch，同时还会对数据进行预处理。

pytorch中的数据加载的方法如下

2. 数据集类

2.1 Dataset基类介绍

在torch中提供了数据集的基类torch.utils.data.Dataset，继承这个基类，能够非常快速的实现对数据的加载。

torch.utils.data.Dataset的源码如下：

class Dataset(object):"""An abstract class representing a Dataset.All other datasets should subclass it. All subclasses should override``__len__``, that provides the size of the dataset, and ``__getitem__``,supporting integer indexing in range from 0 to len(self) exclusive."""def __getitem__(self, index):raise NotImplementedErrordef __len__(self):raise NotImplementedErrordef __add__(self, other):return ConcatDataset([self, other])

可知：需要在自定义的数据集类中继承Dataset类，同时还需要实现两个方法：

  • __len__方法，能够实现通过全局的len()方法获取其中的元素个数
  • __getitem__方法，能够通过传入索引的方式获取数据，例如通过dataset[i]获取其中的第i条数据
  • __add__方法：将两个数据集合并成一个

2.2 数据加载案例

下面通过一个例子来看看如何使用Dataset来加载数据

数据来源：http://archive.ics.uci.edu/ml/datasets/SMS+Spam+Collection

数据介绍：SMS Spam Collection是用于骚扰短信识别的经典数据集，完全来自真实短信内容，包括4831条正常短信和747条骚扰短信。正常短信和骚扰短信保存在一个文本文件中。 每行完整记录一条短信内容，每行开头通过ham和spam标识正常短信和骚扰短信

数据实例：

实现如下：

from torch.utils.data import Dataset,DataLoader
import pandas as pd# 使用r表示后面是一个字符串
data_path = r"data\SMSSpamCollection"# 完成数据集类，继承自Dataset，重写三个方法
class CifarDataset(Dataset):def __init__(self):lines = open(data_path,"r")# 对数据进行处理，前4个为label，后面的为短信内容# strip消除换行符lines = [[i[:4].strip(),i[4:].strip()] for i in lines]# 转化为dataFrameself.df = pd.DataFrame(lines,columns=["label","sms"])# 获取index位置的数据def __getitem__(self, index):single_item = self.df.iloc[index,:]return single_item.values[0],single_item.values[1]def __len__(self):return self.df.shape[0]

之后对Dataset进行实例化，可以跌倒获取其中的数据

d = CifarDataset()
for i in range(len(d)):print(i,d[i])

输出如下：

....
5571 ('ham', 'Pity, * was in mood for that. So...any other suggestions?')
5572 ('ham', "The guy did some bitching but I acted like i'd be interested in buying something else next week and he gave it to us for free")
5573 ('ham', 'Rofl. Its true to its name')

3. 迭代数据集

使用上述的方法能够进行数据的读取，但是其中还有很多内容没有实现：

  • 批处理数据（Batching the data）
  • 打乱数据（Shuffling the data）
  • 使用多线程 multiprocessing 并行加载数据。

在pytorch中torch.utils.data.DataLoader提供了上述的所用方法

DataLoader的使用方法示例：

from torch.utils.data import DataLoaderdataset = CifarDataset()
data_loader = DataLoader(dataset=dataset,batch_size=10,shuffle=True,num_workers=2)# 遍历，获取其中的每个batch的结果
for index, (label, context) in enumerate(data_loader):print(index,label,context)print("*"*100)

其中参数含义：

  1. dataset：提前定义的dataset的实例
  2. batch_size:传入数据的batch的大小，常用128,256等等
  3. shuffle：bool类型，表示是否在每次获取数据的时候提前打乱数据
  4. num_workers:加载数据的线程数

数据迭代器的返回结果如下：

555 ('spam', 'ham', 'spam', 'ham', 'ham', 'ham', 'ham', 'spam', 'ham', 'ham') ('URGENT! We are trying to contact U. Todays draw shows that you have won a £800 prize GUARANTEED. Call 09050003091 from....", 'swhrt how u dey,hope ur ok, tot about u 2day.love n miss.take care.')
***********************************************************************************
556 ('ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'ham', 'spam') ('He telling not to tell any one. If so treat for me hi hi hi', 'Did u got that persons story', "Don kn....1000 cash prize or a prize worth £5000')

注意：

  1. len(dataset) = 数据集的样本数
  2. len(dataloader) = math.ceil(样本数/batch_size) 向上取整

4. pytorch自带的数据集

pytorch中自带的数据集由两个上层api提供，分别是torchvision和torchtext

其中：

  1. torchvision提供了对图片数据处理相关的api和数据

    • 数据位置：torchvision.datasets，例如：torchvision.datasets.MNIST(手写数字图片数据)
  2. torchtext提供了对文本数据处理相关的API和数据
    • 数据位置：torchtext.datasets,例如：torchtext.datasets.IMDB（电影评论文本数据）

下面以Mnist手写数字为例，下面来看看pytorch如何加载其中自带的数据集

使用方法和之前一样：

  1. 准备好Dataset实例
  2. 把dataset交给dataloder 打乱顺序，组成batch

4.1 torchversion.datasets

torchversoin.datasets中的数据集类（比如torchvision.datasets.MNIST）,都是继承自Dataset

意味着：直接对torchvision.datasets.MNIST进行实例化就可以得到Dataset的实例

但是MNIST API中的参数需要注意一下：

torchvision.datasets.MNIST(root='/files/', train=True, download=True, transform=)

  1. root参数表示数据存放的位置
  2. train：bool类型，表示是使用训练集的数据还是测试集的数据
  3. download：bool类型，表示是否需要下载数据到root目录
  4. transform:实现的对图片的处理函数

4.2 MNIST数据集的介绍

数据集的原始地址：http://yann.lecun.com/exdb/mnist/

MNIST是由Yann LeCun等人提供的免费的图像识别的数据集，其中包括60000个训练样本和10000个测试样本，其中图拍了的尺寸已经进行的标准化的处理，都是黑白的图像，大小为28X28

执行代码，下载数据，观察数据类型：

import torchvisiondataset = torchvision.datasets.MNIST(root="./data",train=True,download=True,transform=None)print(dataset[0])

下载的数据如下：

代码输出结果如下：

Downloading http://yann.lecun.com/exdb/mnist/train-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/train-labels-idx1-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-images-idx3-ubyte.gz
Downloading http://yann.lecun.com/exdb/mnist/t10k-labels-idx1-ubyte.gz
Processing...
Done!
(<PIL.Image.Image image mode=L size=28x28 at 0x18D303B9C18>, tensor(5))

其中数据集返回了两条数据，可以猜测为图片的数据和目标值

返回值的第0个为Image类型，可以调用show() 方法打开，发现为手写数字5

import torchvisiondataset = torchvision.datasets.MNIST(root="./data",train=True,download=True,transform=None)print(dataset[0])img = dataset[0][0]
img.show() #打开图片

图片如下：

由上可知：返回值为(图片，目标值),这个结果也可以通过观察源码得到

深度学习【使用pytorch实现基础模型、优化算法介绍、数据集的加载】相关推荐

  1. 深度学习机器学习面试题汇——模型优化，轻量化，模型压缩

    深度学习机器学习面试题汇--模型优化,轻量化,模型压缩 提示:互联网大厂可能考的面试题 若CNN网络很庞大,在手机上运行效率不高,对应模型压缩方法有了解吗 介绍一下模型压缩常用的方法?为什么用知识蒸馏 ...

  2. 深度学习（18）神经网络与全连接层一: 数据加载

    深度学习(18)神经网络与全连接层一: 数据加载 1. 常用数据集 2. MNIST数据集 (1) MNIST样本 (2) MNIST加载案例 3. CIFAR10/100 (1) CIFAR10/1 ...

  3. 斯坦福CRFM遭业界炮轰：深度学习做不了基础模型！

    来源:新智元 [导读]AI 最近的发展似乎都是靠大规模的深度学习模型推动的,所以斯坦福最近成立一个基础模型研究中心CRFM来专门研究大规模的深度学习模型.但业界普遍不看好斯坦福的这个操作,认为深度学习 ...

  4. 从零开始构建基于textcnn的文本分类模型（上），word2vec向量训练，预训练词向量模型加载，pytorch Dataset、collete_fn、Dataloader转换数据集并行加载

    伴随着bert.transformer模型的提出,文本预训练模型应用于各项NLP任务.文本分类任务是最基础的NLP任务,本文回顾最先采用CNN用于文本分类之一的textcnn模型,意在巩固分词.词向量 ...

  5. （d2l-ai/d2l-zh）《动手学深度学习》pytorch 笔记（2）前言（介绍各种机器学习问题）以及数据操作预备知识Ⅰ

    开源项目地址:d2l-ai/d2l-zh 教材官网:https://zh.d2l.ai/ 书介绍:https://zh-v2.d2l.ai/ 笔记基于2021年7月26日发布的版本,书及代码下载地址在 ...

  6. 07组第二次作业 深度学习和pytorch基础

    07组第二次作业 深度学习和pytorch基础 1.视频学习 20020007118 张泽峰 1.1绪论 人工智能的前景比较广阔,人才缺口比较大. 专家系统 早期的人工智能依赖于专家系统 通过一些专家 ...

  7. OUC暑期培训（深度学习）——第一周学习记录：深度学习和pytorch基础

    第一周学习:深度学习和pytorch基础 目录 第一周学习:深度学习和pytorch基础 Part 1:视频学习: 1. 绪论: 2. 深度学习概述: Part 2:代码练习: 1. pytorch基 ...

  8. 第1周学习：深度学习和pytorch基础

    第1周学习:深度学习和pytorch基础 一.概念学习 1.1关于一些基本问题的思考 1.2深度学习基础 二.代码练习 pytorch 基础练习 螺旋数据分类问题 一.概念学习 1.1关于一些基本问题 ...

  9. 《深度学习之pytorch实战计算机视觉》第6章 PyTorch基础（代码可跑通）

    上一篇文章<深度学习之pytorch实战计算机视觉>第5章 Python基础讲了Python基础.接下来看看第6章 PyTorch基础. 目录 6.1 PyTorch中的Tensor 6. ...

最新文章

  1. Appro DM8127 IPNC 挂载NFS遇到的问题及解决
  2. redis搭建与安装2
  3. 方差分析数据.rar
  4. Boost学习笔记-智能指针
  5. BW report execution callstack
  6. batch批处理程序easyadd——追加单行文本到指定txt文件末尾
  7. Jessica Kerr：高绩效团队简史
  8. NB-IOT(6)---NB-IoT物联网行业解决方案
  9. svn 导入的 web项目怎么变成了java项目了
  10. 京东大数据技术白皮书 附下载地址
  11. 微信小程序调用百度云H5人脸识别
  12. eclipse中文教程
  13. 分享:中兴 远航 30 pro root 解锁BL magisk ZTE 7532N 8040N 9041N 刷机 刷面具原厂刷机包 root方法下载
  14. 数据分析学习笔记--航空公司客户价值分析（代码）
  15. Android面试之J2SE基础
  16. 软考中级 真题 2014年下半年 系统集成项目管理工程师 基础知识 上午试卷
  17. 黄子韬快手带货首秀GMV破2.3亿，真性情无套路直播效果拉满！
  18. 微信公众号开发笔记（八）发送图片消息
  19. 深入理解计算机大端与小端
  20. Flutter 多子 Widget 布之Stack、Positioned

热门文章

  1. ORCLE替换内容中的回车、换行、制表符（tab)
  2. 3.知识图谱业务落地技术推荐之国内知识图谱平台汇总(竞品)[阿里、腾讯、华为等】
  3. Python手册(Machine Learning)--statsmodels(Regression)
  4. 请问这个问题怎么解决呀？打开什么也用不了
  5. 两步解决XMind发生了错误，请参阅日志文件
  6. JS逆向hook通用脚本合集
  7. 华为手机比较好用的三款推荐
  8. 万物智联下，腾讯云IoT的差异化发展之路“新”在何处？
  9. 【ROM制作工具】如何三分钟学会制作手机线刷包？一键制作线刷包详细教程
  10. 腾讯多媒体实验室画质增强技术的前沿应用