整理了27个Python人工智能库，一定要收藏（3）

上一篇 / 下一篇  2022-08-22 11:32:46

查看( 195 ) / 评论( 0 ) / 评分( 0 / 0 )
　　21、PyTorch
　　PyTorch 的前身是 Torch，其底层和 Torch 框架一样，但是使用 Python 重新写了很多内容，不仅更加灵活，支持动态图，而且提供了 Python 接口。
　　# 导入库
　　import torch
　　from torch import nn
　　from torch.utils.data import DataLoader
　　from torchvision import datasets
　　from torchvision.transforms import ToTensor, Lambda, Compose
　　import matplotlib.pyplot as plt
　　# 模型构建
　　device = "cuda" if torch.cuda.is_available() else "cpu"
　　print("Using {} device".format(device))
　　# Define model
　　class NeuralNetwork(nn.Module):
　　   def __init__(self):
　　       super(NeuralNetwork, self).__init__()
　　       self.flatten = nn.Flatten()
　　       self.linear_relu_stack = nn.Sequential(
　　           nn.Linear(28*28, 512),
　　           nn.ReLU(),
　　           nn.Linear(512, 512),
　　           nn.ReLU(),
　　           nn.Linear(512, 10),
　　           nn.ReLU()
　　       )
　　   def forward(self, x):
　　       x = self.flatten(x)
　　       logits = self.linear_relu_stack(x)
　　       return logits
　　model = NeuralNetwork().to(device)
　　# 损失函数和优化器
　　loss_fn = nn.CrossEntropyLoss()
　　optimizer = torch.optim.SGD(model.parameters(), lr=1e-3)
　　# 模型训练
　　def train(dataloader, model, loss_fn, optimizer):
　　   size = len(dataloader.dataset)
　　   for batch, (X, y) in enumerate(dataloader):
　　       X, y = X.to(device), y.to(device)
　　       # Compute prediction error
　　       pred = model(X)
　　       loss = loss_fn(pred, y)
　　       # Backpropagation
　　       optimizer.zero_grad()
　　       loss.backward()
　　       optimizer.step()
　　       if batch % 100 == 0:
　　           loss, current = loss.item(), batch * len(X)
　　           print(f"loss: {loss:>7f}  [{current:>5d}/{size:>5d}]")
　　22、Theano
　　Theano 是一个 Python 库，它允许定义、优化和有效地计算涉及多维数组的数学表达式，建在 NumPy 之上。
　　在 Theano 中实现计算雅可比矩阵：
　　import theano
　　import theano.tensor as T
　　x = T.dvector('x')
　　y = x ** 2
　　J, updates = theano.scan(lambda i, y,x : T.grad(y[i], x), sequences=T.arange(y.shape[0]), non_sequences=[y,x])
　　f = theano.function([x], J, updates=updates)
　　f([4, 4])
　　23、Keras
　　Keras 是一个用 Python 编写的高级神经网络 API，它能够以 TensorFlow, CNTK, 或者 Theano 作为后端运行。Keras 的开发重点是支持快速的实验，能够以最小的时延把想法转换为实验结果。
　　from keras.models import Sequential
　　from keras.layers import Dense
　　# 模型构建
　　model = Sequential()
　　model.add(Dense(units=64, activation='relu', input_dim=100))
　　model.add(Dense(units=10, activation='softmax'))
　　# 模型编译与训练
　　model.compile(loss='categorical_crossentropy',
　　             optimizer='sgd',
　　             metrics=['accuracy'])
　　model.fit(x_train, y_train, epochs=5, batch_size=32)
　　24、Caffe
　　在 Caffe2 官方网站上，这样说道：Caffe2 现在是 PyTorch 的一部分。虽然这些 api 将继续工作，但鼓励使用 PyTorch api。
　　25、MXNet
　　MXNet 是一款设计为效率和灵活性的深度学习框架。它允许混合符号编程和命令式编程，从而最大限度提高效率和生产力。
　　使用 MXNet 构建手写数字识别模型：
　　import mxnet as mx
　　from mxnet import gluon
　　from mxnet.gluon import nn
　　from mxnet import autograd as ag
　　import mxnet.ndarray as F
　　# 数据加载
　　mnist = mx.test_utils.get_mnist()
　　batch_size = 100
　　train_data = mx.io.NDArrayIter(mnist['train_data'], mnist['train_label'], batch_size, shuffle=True)
　　val_data = mx.io.NDArrayIter(mnist['test_data'], mnist['test_label'], batch_size)
　　# CNN模型
　　class Net(gluon.Block):
　　   def __init__(self, **kwargs):
　　       super(Net, self).__init__(**kwargs)
　　       self.conv1 = nn.Conv2D(20, kernel_size=(5,5))
　　       self.pool1 = nn.MaxPool2D(pool_size=(2,2), strides = (2,2))
　　       self.conv2 = nn.Conv2D(50, kernel_size=(5,5))
　　       self.pool2 = nn.MaxPool2D(pool_size=(2,2), strides = (2,2))
　　       self.fc1 = nn.Dense(500)
　　       self.fc2 = nn.Dense(10)
　　   def forward(self, x):
　　       x = self.pool1(F.tanh(self.conv1(x)))
　　       x = self.pool2(F.tanh(self.conv2(x)))
　　       # 0 means copy over size from corresponding dimension.
　　       # -1 means infer size from the rest of dimensions.
　　       x = x.reshape((0, -1))
　　       x = F.tanh(self.fc1(x))
　　       x = F.tanh(self.fc2(x))
　　       return x
　　net = Net()
　　# 初始化与优化器定义
　　# set the context on GPU is available otherwise CPU
　　ctx = [mx.gpu() if mx.test_utils.list_gpus() else mx.cpu()]
　　net.initialize(mx.init.Xavier(magnitude=2.24), ctx=ctx)
　　trainer = gluon.Trainer(net.collect_params(), 'sgd', {'learning_rate': 0.03})
　　# 模型训练
　　# Use Accuracy as the evaluation metric.
　　metric = mx.metric.Accuracy()
　　softmax_cross_entropy_loss = gluon.loss.SoftmaxCrossEntropyLoss()
　　for i in range(epoch):
　　   # Reset the train data iterator.
　　   train_data.reset()
　　   for batch in train_data:
　　       data = gluon.utils.split_and_load(batch.data[0], ctx_list=ctx, batch_axis=0)
　　       label = gluon.utils.split_and_load(batch.label[0], ctx_list=ctx, batch_axis=0)
　　       outputs = []
　　       # Inside training scope
　　       with ag.record():
　　           for x, y in zip(data, label):
　　               z = net(x)
　　               # Computes softmax cross entropy loss.
　　               loss = softmax_cross_entropy_loss(z, y)
　　               # Backpropogate the error for one iteration.
　　               loss.backward()
　　               outputs.append(z)
　　       metric.update(label, outputs)
　　       trainer.step(batch.data[0].shape[0])
　　   # Gets the evaluation result.
　　   name, acc = metric.get()
　　   # Reset evaluation result to initial state.
　　   metric.reset()
　　   print('training acc at epoch %d: %s=%f'%(i, name, acc))
　　26、PaddlePaddle
　　飞桨 (PaddlePaddle) 以百度多年的深度学习技术研究和业务应用为基础，集深度学习核心训练和推理框架、基础模型库、端到端开发套件、丰富的工具组件于一体。是中国首个自主研发、功能完备、开源开放的产业级深度学习平台。
　　使用 PaddlePaddle 实现 LeNtet5：
　　# 导入需要的包
　　import paddle
　　import numpy as np
　　from paddle.nn import Conv2D, MaxPool2D, Linear
　　## 组网
　　import paddle.nn.functional as F
　　# 定义 LeNet 网络结构
　　class LeNet(paddle.nn.Layer):
　　   def __init__(self, num_classes=1):
　　       super(LeNet, self).__init__()
　　       # 创建卷积和池化层
　　       # 创建第1个卷积层
　　       self.conv1 = Conv2D(in_channels=1, out_channels=6, kernel_size=5)
　　       self.max_pool1 = MaxPool2D(kernel_size=2, stride=2)
　　       # 尺寸的逻辑：池化层未改变通道数；当前通道数为6
　　       # 创建第2个卷积层
　　       self.conv2 = Conv2D(in_channels=6, out_channels=16, kernel_size=5)
　　       self.max_pool2 = MaxPool2D(kernel_size=2, stride=2)
　　       # 创建第3个卷积层
　　       self.conv3 = Conv2D(in_channels=16, out_channels=120, kernel_size=4)
　　       # 尺寸的逻辑：输入层将数据拉平[B,C,H,W] -> [B,C*H*W]
　　       # 输入size是[28,28]，经过三次卷积和两次池化之后，C*H*W等于120
　　       self.fc1 = Linear(in_features=120, out_features=64)
　　       # 创建全连接层，第一个全连接层的输出神经元个数为64， 第二个全连接层输出神经元个数为分类标签的类别数
　　       self.fc2 = Linear(in_features=64, out_features=num_classes)
　　   # 网络的前向计算过程
　　   def forward(self, x):
　　       x = self.conv1(x)
　　       # 每个卷积层使用Sigmoid激活函数，后面跟着一个2x2的池化
　　       x = F.sigmoid(x)
　　       x = self.max_pool1(x)
　　       x = F.sigmoid(x)
　　       x = self.conv2(x)
　　       x = self.max_pool2(x)
　　       x = self.conv3(x)
　　       # 尺寸的逻辑：输入层将数据拉平[B,C,H,W] -> [B,C*H*W]
　　       x = paddle.reshape(x, [x.shape[0], -1])
　　       x = self.fc1(x)
　　       x = F.sigmoid(x)
　　       x = self.fc2(x)
　　       return x
　　27、CNTK
　　CNTK(Cognitive Toolkit) 是一个深度学习工具包，通过有向图将神经网络描述为一系列计算步骤。在这个有向图中，叶节点表示输入值或网络参数，而其他节点表示对其输入的矩阵运算。CNTK 可以轻松地实现和组合流行的模型类型，如 CNN 等。
　　CNTK 用网络描述语言 (network description language, NDL) 描述一个神经网络。简单的说，要描述输入的 feature，输入的 label，一些参数，参数和输入之间的计算关系，以及目标节点是什么。
　　NDLNetworkBuilder=[
　　   run=ndlLR
　　   ndlLR=[
　　     # sample and label dimensions
　　     SDim=$dimension$
　　     LDim=1
　　     features=Input(SDim, 1)
　　     labels=Input(LDim, 1)
　　     # parameters to learn
　　      B0 = Parameter(4)  
　　     W0 = Parameter(4, SDim)
　　     B = Parameter(LDim)
　　     W = Parameter(LDim, 4)
　　     # operations
　　     t0 = Times(W0, features)
　　     z0 = Plus(t0, B0)
　　      s0 = Sigmoid(z0)    
　　     t = Times(W, s0)
　　     z = Plus(t, B)
　　     s = Sigmoid(z)    
　　     LR = Logistic(labels, s)
　　     EP = SquareError(labels, s)
　　     # root nodes
　　     FeatureNodes=(features)
　　     LabelNodes=(labels)
　　     CriteriaNodes=(LR)
　　     EvalNodes=(EP)
　　     OutputNodes=(s,t,z,s0,W0)
　　    ]

收藏 举报

TAG: 软件开发 Python

 

评分：0

我来说两句

Open Toolbar