“AI”科普丨27 个 Python 人工智能类库_是一个_数据
来源：数据STUDIO
本文约8000字，建议阅读10分钟
本文对目前较为常见的人工智能库进行简要全面的先容。
为了大家能够对人工智能常用的 Python 库有一个初步的理解，以选择能够知足自己需求的库进行学习，对目前较为常见的人工智能库进行简要全面的先容。
1、NumpyNumPy(Numerical Python)是 Python的一个扩展程序库，支持大量的维度数组与矩阵运算，此外也针对数组运算供应大量的数学函数库，Numpy底层利用C措辞编写，数组中直接存储工具，而不是存储工具指针，以是其运算效率远高于纯Python代码。我们可以在示例中比拟下纯Python与利用Numpy库在打算列表sin值的速率比拟：
import numpy as npimport mathimport randomimport timestart = time.time()for i in range(10): list_1 = list(range(1,10000)) for j in range(len(list_1)): list_1[j] = math.sin(list_1[j])print("利用纯Python用时{}s".format(time.time()-start))start = time.time()for i in range(10): list_1 = np.array(np.arange(1,10000)) list_1 = np.sin(list_1)print("利用Numpy用时{}s".format(time.time()-start))
从如下运行结果，可以看到利用 Numpy 库的速率快于纯 Python 编写的代码：
利用纯Python用时0.017444372177124023s利用Numpy用时0.001619577407836914s2、OpenCV
OpenCV 是一个的跨平台打算机视觉库，可以运行在 Linux、Windows 和 Mac OS 操作系统上。它轻量级而且高效——由一系列 C 函数和少量 C++ 类构成，同时也供应了 Python 接口，实现了图像处理和打算机视觉方面的很多通用算法。下面代码考试测验利用一些大略的滤镜，包括图片的平滑处理、高斯模糊等：
import numpy as npimport cv2 as cvfrom matplotlib import pyplot as pltimg = cv.imread('h89817032p0.png')kernel = np.ones((5,5),np.float32)/25dst = cv.filter2D(img,-1,kernel)blur_1 = cv.GaussianBlur(img,(5,5),0)blur_2 = cv.bilateralFilter(img,9,75,75)plt.figure(figsize=(10,10))plt.subplot(221),plt.imshow(img[:,:,::-1]),plt.title('Original')plt.xticks([]), plt.yticks([])plt.subplot(222),plt.imshow(dst[:,:,::-1]),plt.title('Averaging')plt.xticks([]), plt.yticks([])plt.subplot(223),plt.imshow(blur_1[:,:,::-1]),plt.title('Gaussian')plt.xticks([]), plt.yticks([])plt.subplot(224),plt.imshow(blur_1[:,:,::-1]),plt.title('Bilateral')plt.xticks([]), plt.yticks([])plt.show()
OpenCV
3、Scikit-image
scikit-image是基于scipy的图像处理库，它将图片作为numpy数组进行处理。例如，可以利用scikit-image改变图片比例，scikit-image供应了rescale、resize以及downscale_local_mean等函数。
from skimage import data, color, iofrom skimage.transform import rescale, resize, downscale_local_meanimage = color.rgb2gray(io.imread('h89817032p0.png'))image_rescaled = rescale(image, 0.25, anti_aliasing=False)image_resized = resize(image, (image.shape[0] // 4, image.shape[1] // 4), anti_aliasing=True)image_downscaled = downscale_local_mean(image, (4, 3))plt.figure(figsize=(20,20))plt.subplot(221),plt.imshow(image, cmap='gray'),plt.title('Original')plt.xticks([]), plt.yticks([])plt.subplot(222),plt.imshow(image_rescaled, cmap='gray'),plt.title('Rescaled')plt.xticks([]), plt.yticks([])plt.subplot(223),plt.imshow(image_resized, cmap='gray'),plt.title('Resized')plt.xticks([]), plt.yticks([])plt.subplot(224),plt.imshow(image_downscaled, cmap='gray'),plt.title('Downscaled')plt.xticks([]), plt.yticks([])plt.show()
Scikit-image
4、PIL
Python Imaging Library(PIL) 已经成为 Python 事实上的图像处理标准库了，这是由于，PIL 功能非常强大，但API却非常大略易用。但是由于PIL仅支持到 Python 2.7，再加上年久失落修，于是一群志愿者在 PIL 的根本上创建了兼容的版本，名字叫 Pillow，支持最新 Python 3.x，又加入了许多新特性，因此，我们可以跳过 PIL，直接安装利用 Pillow。
5、Pillow
利用 Pillow 天生字母验证码图片：
from PIL import Image, ImageDraw, ImageFont, ImageFilterimport random# 随机字母:def rndChar(): return chr(random.randint(65, 90))# 随机颜色1:def rndColor(): return (random.randint(64, 255), random.randint(64, 255), random.randint(64, 255))# 随机颜色2:def rndColor2(): return (random.randint(32, 127), random.randint(32, 127), random.randint(32, 127))# 240 x 60:width = 60 6height = 60 6image = Image.new('RGB', (width, height), (255, 255, 255))# 创建Font工具:font = ImageFont.truetype('/usr/share/fonts/wps-office/simhei.ttf', 60)# 创建Draw工具:draw = ImageDraw.Draw(image)# 添补每个像素:for x in range(width): for y in range(height): draw.point((x, y), fill=rndColor())# 输出笔墨:for t in range(6): draw.text((60 t + 10, 150), rndChar(), font=font, fill=rndColor2())# 模糊:image = image.filter(ImageFilter.BLUR)image.save('code.jpg', 'jpeg')
验证码
6、SimpleCV
SimpleCV 是一个用于构建打算机视觉运用程序的开源框架。利用它，可以访问高性能的打算机视觉库，如 OpenCV，而不必首先理解位深度、文件格式、颜色空间、缓冲区管理、特色值或矩阵等术语。但其对付 Python3 的支持很差很差，在 Python3.7 中利用如下代码：
from SimpleCV import Image, Color, Display# load an image from imgurimg = Image('http://i.imgur.com/lfAeZ4n.png')# use a keypoint detector to find areas of interestfeats = img.findKeypoints()# draw the list of keypointsfeats.draw(color=Color.RED)# show the resulting image. img.show()# apply the stuff we found to the image.output = img.applyLayers()# save the results.output.save('juniperfeats.png')
会报如下缺点，因此不建议在 Python3 中利用：
SyntaxError: Missing parentheses in call to 'print'. Did you mean print('unit test')?
7、Mahotas
Mahotas 是一个快速打算机视觉算法库，其构建在 Numpy 之上，目前拥有超过100种图像处理和打算机视觉功能，并在不断增长。利用 Mahotas 加载图像，并对像素进行操作：
import numpy as npimport mahotasimport mahotas.demosfrom mahotas.thresholding import soft_thresholdfrom matplotlib import pyplot as pltfrom os import pathf = mahotas.demos.load('lena', as_grey=True)f = f[128:,128:]plt.gray()# Show the data:print("Fraction of zeros in original image: {0}".format(np.mean(f==0)))plt.imshow(f)plt.show()
Mahotas8、Ilastik
Ilastik 能够给用户供应良好的基于机器学习的生物信息图像剖析做事，利用机器学习算法，轻松地分割，分类，跟踪和计数细胞或其他实验数据。大多数操作都是交互式的，并不须要机器学习专业知识。
9、Scikit-learn
Scikit-learn 是针对 Python 编程措辞的免费软件机器学习库。它具有各种分类，回归和聚类算法，包括支持向量机，随机森林，梯度提升，k均值和 DBSCAN 等多种机器学习算法。利用Scikit-learn实现KMeans算法：
import timeimport numpy as npimport matplotlib.pyplot as pltfrom sklearn.cluster import MiniBatchKMeans, KMeansfrom sklearn.metrics.pairwise import pairwise_distances_argminfrom sklearn.datasets import make_blobs# Generate sample datanp.random.seed(0)batch_size = 45centers = [[1, 1], [-1, -1], [1, -1]]n_clusters = len(centers)X, labels_true = make_blobs(n_samples=3000, centers=centers, cluster_std=0.7)# Compute clustering with Meansk_means = KMeans(init='k-means++', n_clusters=3, n_init=10)t0 = time.time()k_means.fit(X)t_batch = time.time() - t0# Compute clustering with MiniBatchKMeansmbk = MiniBatchKMeans(init='k-means++', n_clusters=3, batch_size=batch_size, n_init=10, max_no_improvement=10, verbose=0)t0 = time.time()mbk.fit(X)t_mini_batch = time.time() - t0# Plot resultfig = plt.figure(figsize=(8, 3))fig.subplots_adjust(left=0.02, right=0.98, bottom=0.05, top=0.9)colors = ['#4EACC5', '#FF9C34', '#4E9A06']# We want to have the same colors for the same cluster from the# MiniBatchKMeans and the KMeans algorithm. Let's pair the cluster centers per# closest one.k_means_cluster_centers = k_means.cluster_centers_order = pairwise_distances_argmin(k_means.cluster_centers_, mbk.cluster_centers_)mbk_means_cluster_centers = mbk.cluster_centers_[order]k_means_labels = pairwise_distances_argmin(X, k_means_cluster_centers)mbk_means_labels = pairwise_distances_argmin(X, mbk_means_cluster_centers)# KMeansfor k, col in zip(range(n_clusters), colors): my_members = k_means_labels == k cluster_center = k_means_cluster_centers[k] plt.plot(X[my_members, 0], X[my_members, 1], 'w', markerfacecolor=col, marker='.') plt.plot(cluster_center[0], cluster_center[1], 'o', markerfacecolor=col, markeredgecolor='k', markersize=6)plt.title('KMeans')plt.xticks(())plt.yticks(())plt.show()
KMeans
10、SciPy
SciPy 库供应了许多用户友好和高效的数值打算，如数值积分、插值、优化、线性代数等。SciPy 库定义了许多数学物理的分外函数，包括椭圆函数、贝塞尔函数、伽马函数、贝塔函数、超几何函数、抛物线圆柱函数等等。
from scipy import specialimport matplotlib.pyplot as pltimport numpy as npdef drumhead_height(n, k, distance, angle, t): kth_zero = special.jn_zeros(n, k)[-1] return np.cos(t) np.cos(nangle) special.jn(n, distancekth_zero)theta = np.r_[0:2np.pi:50j]radius = np.r_[0:1:50j]x = np.array([r np.cos(theta) for r in radius])y = np.array([r np.sin(theta) for r in radius])z = np.array([drumhead_height(1, 1, r, theta, 0.5) for r in radius])fig = plt.figure()ax = fig.add_axes(rect=(0, 0.05, 0.95, 0.95), projection='3d')ax.plot_surface(x, y, z, rstride=1, cstride=1, cmap='RdBu_r', vmin=-0.5, vmax=0.5)ax.set_xlabel('X')ax.set_ylabel('Y')ax.set_xticks(np.arange(-1, 1.1, 0.5))ax.set_yticks(np.arange(-1, 1.1, 0.5))ax.set_zlabel('Z')plt.show()
SciPy
11、NLTK
NLTK 是构建Python程序以处理自然措辞的库。它为50多个语料库和词汇资源(如 WordNet )供应了易于利用的接口，以及一套用于分类、分词、词干、标记、解析和语义推理的文本处理库、工业级自然措辞处理 (Natural Language Processing, NLP) 库的包装器。NLTK被称为 “a wonderful tool for teaching, and working in, computational linguistics using Python”。
import nltkfrom nltk.corpus import treebank# 首次利用须要***nltk.download('punkt')nltk.download('averaged_perceptron_tagger')nltk.download('maxent_ne_chunker')nltk.download('words')nltk.download('treebank')sentence = """At eight o'clock on Thursday morning Arthur didn't feel very good."""# Tokenizetokens = nltk.word_tokenize(sentence)tagged = nltk.pos_tag(tokens)# Identify named entitiesentities = nltk.chunk.ne_chunk(tagged)# Display a parse treet = treebank.parsed_sents('wsj_0001.mrg')[0]t.draw()
NLTK
12、spaCy
spaCy 是一个免费的开源库，用于 Python 中的高等 NLP。它可以用于构建处理大量文本的运用程序；也可以用来构建信息提取或自然措辞理解系统，或者对文本进行预处理以进行深度学习。
import spacy texts = [ "Net income was $9.4 million compared to the prior year of $2.7 million.", "Revenue exceeded twelve billion dollars, with a loss of $1b.", ] nlp = spacy.load("en_core_web_sm") for doc in nlp.pipe(texts, disable=["tok2vec", "tagger", "parser", "attribute_ruler", "lemmatizer"]): # Do something with the doc here print([(ent.text, ent.label_) for ent in doc.ents])nlp.pipe 天生 Doc 工具，因此我们可以对它们进行迭代并访问命名实体预测：[('$9.4 million', 'MONEY'), ('the prior year', 'DATE'), ('$2.7 million', 'MONEY')][('twelve billion dollars', 'MONEY'), ('1b', 'MONEY')]
librosa 是一个用于音乐和音频剖析的 Python 库，它供应了创建音乐信息检索系统所必需的功能和函数。
# Beat tracking exampleimport librosa# 1. Get the file path to an included audio examplefilename = librosa.example('nutcracker')# 2. Load the audio as a waveform `y`# Store the sampling rate as `sr`y, sr = librosa.load(filename)# 3. Run the default beat trackertempo, beat_frames = librosa.beat.beat_track(y=y, sr=sr)print('Estimated tempo: {:.2f} beats per minute'.format(tempo))# 4. Convert the frame indices of beat events into timestampsbeat_times = librosa.frames_to_time(beat_frames, sr=sr)
Pandas 是一个快速、强大、灵巧且易于利用的开源数据剖析和操尴尬刁难象， Pandas 可以从各种文件格式比如 CSV、JSON、SQL、Microsoft Excel 导入数据，可以对各种数据进走运算操作，比如归并、再成形、选择，还有数据洗濯和数据加工特色。Pandas 广泛运用在学术、金融、统计学等各个数据剖析领域。
import matplotlib.pyplot as pltimport pandas as pdimport numpy as npts = pd.Series(np.random.randn(1000), index=pd.date_range("1/1/2000", periods=1000))ts = ts.cumsum()df = pd.DataFrame(np.random.randn(1000, 4), index=ts.index, columns=list("ABCD"))df = df.cumsum()df.plot()plt.show()
Pandas
15、Matplotlib
Matplotlib 是Python的绘图库，它供应了一整套和 matlab 相似的命令 API，可以天生出版质量级别的精美图形，Matplotlib 使绘图变得非常大略，在易用性和性能间取得了精良的平衡。利用 Matplotlib 绘制多曲线图：
# plot_multi_curve.pyimport numpy as npimport matplotlib.pyplot as pltx = np.linspace(0.1, 2 np.pi, 100)y_1 = xy_2 = np.square(x)y_3 = np.log(x)y_4 = np.sin(x)plt.plot(x,y_1)plt.plot(x,y_2)plt.plot(x,y_3)plt.plot(x,y_4)plt.show()
Matplotlib
16、Seaborn
Seaborn 是在 Matplotlib 的根本上进行了更高等的API封装的Python数据可视化库，从而使得作图更加随意马虎，该当把 Seaborn 视为 Matplotlib 的补充，而不是替代物。
import seaborn as snsimport matplotlib.pyplot as pltsns.set_theme(style="ticks")df = sns.load_dataset("penguins")sns.pairplot(df, hue="species")plt.show()
seaborn
17、Orange
Orange 是一个开源的数据挖掘和机器学习软件，供应了一系列的数据探索、可视化、预处理以及建模组件。Orange 拥有俊秀直不雅观的交互式用户界面，非常适宜新手进行探索性数据剖析和可视化展示；同时高等用户也可以将其作为 Python 的一个编程模块进行数据操作和组件开拓。利用 pip 即可安装 Orange，好评～
$ pip install orange3
安装完成后，在命令行输入 orange-canvas 命令即可启动 Orange 图形界面：
$ orange-canvas
启动完成后，即可看到 Orange 图形界面，进行各种操作。
Orange
18、PyBrain
PyBrain 是 Python 的模块化机器学习库。它的目标是为机器学习任务和各种预定义的环境供应灵巧、易于利用且强大的算法来测试和比较算法。PyBrain 是 Python-Based Reinforcement Learning, Artificial Intelligence and Neural Network Library 的缩写。我们将利用一个大略的例子来展示 PyBrain 的用法，构建一个多层感知器 (Multi Layer Perceptron, MLP)。首先，我们创建一个新的前馈网络工具：
from pybrain.structure import FeedForwardNetworkn = FeedForwardNetwork()
接下来，构建输入、隐蔽和输出层：
from pybrain.structure import LinearLayer, SigmoidLayerinLayer = LinearLayer(2)hiddenLayer = SigmoidLayer(3)outLayer = LinearLayer(1)
为了利用所构建的层，必须将它们添加到网络中：
n.addInputModule(inLayer)n.addModule(hiddenLayer)n.addOutputModule(outLayer)
可以添加多个输入和输出模块。为了向前打算和反向偏差传播，网络必须知道哪些层是输入、哪些层是输出。这就须要明确确定它们该当如何连接。为此，我们利用最常见的连接类型，全连接层，由 FullConnection 类实现：
from pybrain.structure import FullConnectionin_to_hidden = FullConnection(inLayer, hiddenLayer)hidden_to_out = FullConnection(hiddenLayer, outLayer)
与层一样，我们必须明确地将它们添加到网络中：
n.addConnection(in_to_hidden)n.addConnection(hidden_to_out)
所有元素现在都已准备就位，末了，我们须要调用.sortModules()方法使MLP可用：
n.sortModules()
这个调用会实行一些内部初始化，这在利用网络之前是必要的。
19、Milk
MILK(MACHINE LEARNING TOOLKIT) 是 Python 措辞的机器学习工具包。它紧张是包含许多分类器比如 SVMS、K-NN、随机森林以及决策树中利用监督分类法，它还可实行特色选择，可以形身分歧的例如无监督学习、密切关系传播和由 MILK 支持的 K-means 聚类平分类系统。利用 MILK 演习一个分类器：
import numpy as npimport milkfeatures = np.random.rand(100,10)labels = np.zeros(100)features[50:] += .5labels[50:] = 1learner = milk.defaultclassifier()model = learner.train(features, labels)# Now you can use the model on new examples:example = np.random.rand(10)print(model.apply(example))example2 = np.random.rand(10)example2 += .5print(model.apply(example2))
TensorFlow 是一个端到端开源机器学习平台。它拥有一个全面而灵巧的生态系统，一样平常可以将其分为 TensorFlow1.x 和 TensorFlow2.x，TensorFlow1.x 与 TensorFlow2.x 的紧张差异在于 TF1.x 利用静态图而 TF2.x 利用Eager Mode动态图。这里紧张利用TensorFlow2.x作为示例，展示在 TensorFlow2.x 中构建卷积神经网络 (Convolutional Neural Network, CNN)。
import tensorflow as tffrom tensorflow.keras import datasets, layers, models# 数据加载(train_images, train_labels), (test_images, test_labels) = datasets.cifar10.load_data()# 数据预处理train_images, test_images = train_images / 255.0, test_images / 255.0# 模型构建model = models.Sequential()model.add(layers.Conv2D(32, (3, 3), activation='relu', input_shape=(32, 32, 3)))model.add(layers.MaxPooling2D((2, 2)))model.add(layers.Conv2D(64, (3, 3), activation='relu'))model.add(layers.MaxPooling2D((2, 2)))model.add(layers.Conv2D(64, (3, 3), activation='relu'))model.add(layers.Flatten())model.add(layers.Dense(64, activation='relu'))model.add(layers.Dense(10))# 模型编译与演习model.compile(optimizer='adam', loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True), metrics=['accuracy'])history = model.fit(train_images, train_labels, epochs=10, validation_data=(test_images, test_labels))
PyTorch 的前身是 Torch，其底层和 Torch 框架一样，但是利用 Python 重新写了很多内容，不仅更加灵巧，支持动态图，而且供应了 Python 接口。
# 导入库import torchfrom torch import nnfrom torch.utils.data import DataLoaderfrom torchvision import datasetsfrom torchvision.transforms import ToTensor, Lambda, Composeimport matplotlib.pyplot as plt# 模型构建device = "cuda" if torch.cuda.is_available() else "cpu"print("Using {} device".format(device))# Define modelclass NeuralNetwork(nn.Module): def __init__(self): super(NeuralNetwork, self).__init__() self.flatten = nn.Flatten() self.linear_relu_stack = nn.Sequential( nn.Linear(2828, 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 logitsmodel = 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}]")
Theano 是一个 Python 库，它许可定义、优化和有效地皮算涉及多维数组的数学表达式，建在 NumPy 之上。在 Theano 中实现打算雅可比矩阵：
import theanoimport theano.tensor as Tx = T.dvector('x')y = x 2J, 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])
Keras 是一个用 Python 编写的高等神经网络 API，它能够以 TensorFlow, CNTK, 或者 Theano 作为后端运行。Keras 的开拓重点是支持快速的实验，能够以最小的时延把想法转换为实验结果。
from keras.models import Sequentialfrom 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)
在 Caffe2 官方网站上，这样说道：Caffe2 现在是 PyTorch 的一部分。虽然这些 api 将连续事情，但鼓励利用 PyTorch api。
25、MXNet
MXNet 是一款设计为效率和灵巧性的深度学习框架。它许可稠浊符号编程和命令式编程，从而最大限度提高效率和生产力。利用 MXNet 构建手写数字识别模型：
import mxnet as mxfrom mxnet import gluonfrom mxnet.gluon import nnfrom mxnet import autograd as agimport mxnet.ndarray as F# 数据加载mnist = mx.test_utils.get_mnist()batch_size = 100train_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 xnet = Net()# 初始化与优化器定义# set the context on GPU is available otherwise CPUctx = [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))
飞桨 (PaddlePaddle) 以百度多年的深度学习技能研究和业务运用为根本，集深度学习核心演习和推理框架、根本模型库、端到端开拓套件、丰富的工具组件于一体。是中国首个自主研发、功能完备、开源开放的家当级深度学习平台。利用 PaddlePaddle 实现 LeNtet5：
# 导入须要的包import paddleimport numpy as npfrom 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,CHW] # 输入size是[28,28]，经由三次卷积和两次池化之后，CHW即是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,CHW] x = paddle.reshape(x, [x.shape[0], -1]) x = self.fc1(x) x = F.sigmoid(x) x = self.fc2(x) return x
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) ]
本文系作者个人观点，不代表本站立场，转载请注明出处！
