Press "Enter" to skip to content

『深度应用』OneFlow快速上手指南

本站内容均来自兴趣收集,如不慎侵害的您的相关权益,请留言告知,我们将尽快删除.谢谢.

 

现实中没有复杂的系统

 

–《极简主义》范式一:事情其实很简单

 

0. 引子

 

为什幺会有写这篇文章?

 

 

这不是一篇广告文,笔者不是大 V,没人联系写稿,请放心食用。

 

这不是一片解析文,笔者水平有限,还无法做出深度解读。 zhuanlan.zhihu.com/p/85111240 此篇对 TF2.0 的解析就差很大火候,让大家见笑了。

 

这可以算是一篇技术文章,通过对 OneFlow 安装,简单上手等操作来对比 OneFlow 较主流深度学习框架的难易程度。

 

 

简单分析下深度学习框架现状:

 

虽然不是解析文章,但针对深度学习框架分析还是要有一些的。现在主流的深度学习框架(不包括推理框架)可以说是 TensorFlow,PyTorch,MXNet 三足鼎力,其实这也是 ta 们背后资本与资源的角逐。TensorFlow 凭借其完备性以及在部署方面的积累依旧处于优势地位,逼得 PyTorch,MXNet 等其他小众框架祭出了 ONNX 来打破 TensorFlow 的部署的垄断地位。PyTorch 能成功从 TensorFlow 抢下学术界一块大蛋糕,很大程度上归功于其方向的正确性,没有在 TensorFlow 优势方面拼刺刀,而是在 TensorFlow 痛点处发力,通过易用性来争取用户。而 MXNet 就很难与 TensorFlow 与 PyTorch 有一战之力了,MXNet 本身的一些优势也不是 TensorFlow 与 PyTorch 的使用痛点很难让用户有迁移的动力。

 

反观国内的赛场,百度的飞桨 PaddlePaddle,虽然开源很早,但一直处于不温不火的状态。国内的框架的确还无法与国际主流框架展开竞争,差距还是巨大。但是今年还是有四家国内机构或公司选择了开源,华为的 MineSpore,清华的 Jittor,旷世的 MegEngine,以及今天主角一流科技的 OneFlow。虽竞争力不大,但在中美贸易摩擦下,自主产权越来越受到重视。

 

其实以笔者愚见,开发者并不会在意使用的是那个框架,更在意的是这个框架的完备性与便易性。当时大规模开发者从 TensorFlow1.x 转到 PyTorch 就可以说明,品牌对于开发者并不是很重要,重要的还是框架好不好用。所以笔者对国内开源框架还是积极持乐观态度的,做的好就会有用户支持。

 

下面,我们来看看 OneFlow 究竟做的如何。

 

1. 上手

 

以下部分内容来自 OneFlow 开发文档: docs.oneflow.org/index.html

 

1.0 简单介绍

 

OneFlow 是什幺?

 

OneFlow 是开源的、采用全新架构设计,世界领先的工业级通用深度学习框架。

 

OneFlow 优势是什幺?

分布式训练全新体验,多机多卡如单机单卡一样简单
完美契合一站式平台 (k8s + docker)
原生支持超大模型
近零运行时开销、线性加速比
灵活支持多种深度学习编译器
自动混合精度
中立开放,合作面广
持续完善的算子集、模型库

1.1 安装指南

 

安装 OneFlow 稳定发布版

 

系统要求:前提 Nvidia driver 与 CUDA 安装完成

Python >= 3.5
Nvidia Linux x86_64 driver version >= 440.33

安装 OneFlow with legacy CUDA 指令如下:

 

pip install --find-links https://oneflow-inc.github.io/nightly oneflow_cu102 --user
pip install --find-links https://oneflow-inc.github.io/nightly oneflow_cu101 --user
pip install --find-links https://oneflow-inc.github.io/nightly oneflow_cu100 --user
pip install --find-links https://oneflow-inc.github.io/nightly oneflow_cu92 --user
pip install --find-links https://oneflow-inc.github.io/nightly oneflow_cu91 --user
pip install --find-links https://oneflow-inc.github.io/nightly oneflow_cu90 --user

 

如何查看本机 Nvidia Linux x86_64 driver version?可以看到笔者的 Driver Version: 450.57

 

(base) [email protected]:~$ nvidia-smi
+-----------------------------------------------------------------------------+
| NVIDIA-SMI 450.57       Driver Version: 450.57       CUDA Version: 11.0     |
|-------------------------------+----------------------+----------------------+
| GPU  Name        Persistence-M| Bus-Id        Disp.A | Volatile Uncorr. ECC |
| Fan  Temp  Perf  Pwr:Usage/Cap|         Memory-Usage | GPU-Util  Compute M. |
|===============================+======================+======================|
|   0  GeForce RTX 208...  Off  | 00000000:01:00.0 Off |                  N/A |
| 47%   54C    P2    80W / 257W |   5136MiB / 11019MiB |     38%      Default |
+-------------------------------+----------------------+----------------------+
+-----------------------------------------------------------------------------+
|  GPU   GI   CI        PID   Type   Process name                  GPU Memory |
|=============================================================================|
|    0   N/A  N/A      1668      G   /usr/bin/totem                     10MiB |
|    0   N/A  N/A      1974      G   /usr/lib/xorg/Xorg                857MiB |
|    0   N/A  N/A      2128      G   /usr/bin/gnome-shell              331MiB |
|    0   N/A  N/A      2563      G   ...token=2514374358980620094      376MiB |
|    0   N/A  N/A     14664      C   python                           2531MiB |
|    0   N/A  N/A     27295      G   ...AAAAAAAAA= --shared-files      872MiB |
|    0   N/A  N/A     31690      G   ...token=3577040725527546973      149MiB |
+-----------------------------------------------------------------------------+

 

如何查看本机 cuda 版本?可以看到笔者的 Cuda 为 10.2

 

(base) [email protected]:~$ nvcc -V
nvcc: NVIDIA (R) Cuda compiler driver
Copyright (c) 2005-2019 NVIDIA Corporation
Built on Wed_Oct_23_19:24:38_PDT_2019
Cuda compilation tools, release 10.2, V10.2.89

 

下面通过 Conda 来安装 OneFlow 框架,Conda 推荐安装 miniconda

 

依次输入:

 

conda create --name OF python=3.7 -y
conda install cudatoolkit=10.2 cudnn=7 -y
pip install --find-links https://oneflow-inc.github.io/nightly oneflow_cu102 --user

 

使用以下指令测试安装完成:

 

(OF) [email protected]:~$ python
Python 3.7.8 | packaged by conda-forge | (default, Jul 31 2020, 02:25:08) 
Type "help", "copyright", "credits" or "license" for more information.

 

3 分钟快速上手

 

这篇文章介绍了如何快速上手 OneFlow ,我们可以在 3 分钟内完成一个完整的神经网络训练过程。

 

运行一个例子

 

如果已经安装好了 OneFlow ,可以使用以下命令下载 文档仓库 中的 mlp_mnist.py 脚本,并运行。

 

wget https://docs.oneflow.org/code/quick_start/mlp_mnist.py

 

将得到类似以下输出:

 

输出的是一串数字,每个数字代表了每一轮训练后的损失值,训练的目标是损失值越小越好。到此您已经用 OneFlow 完成了一个完整的神经网络的训练。

 

代码解读

 

下面是完整代码。

 

import oneflow.typing as tp
@flow.global_function(type="train")
    images: tp.Numpy.Placeholder((BATCH_SIZE, 1, 28, 28), dtype=flow.float),
    labels: tp.Numpy.Placeholder((BATCH_SIZE,), dtype=flow.int32),
with flow.scope.placement("cpu", "0:0"):
        initializer = flow.truncated_normal(0.1)
        reshape = flow.reshape(images, [images.shape[0], -1])
        hidden = flow.layers.dense(
            kernel_initializer=initializer,
        logits = flow.layers.dense(
            hidden, 10, kernel_initializer=initializer, 
        loss = flow.nn.sparse_softmax_cross_entropy_with_logits(labels, logits)
    lr_scheduler = flow.optimizer.PiecewiseConstantScheduler([], [0.1])
    flow.optimizer.SGD(lr_scheduler, momentum=0).minimize(loss)
if __name__ == "__main__":
    check_point = flow.train.CheckPoint()
    (train_images, train_labels), (test_images, test_labels) = flow.data.load_mnist(
for i, (images, labels) in enumerate(zip(train_images, train_labels)):
        loss = train_job(images, labels)

 

接下来让我们简单介绍下这段代码。

 

OneFlow 相对其他深度学习框架较特殊的地方是这里:

 

@flow.global_function(type="train")
    images: tp.Numpy.Placeholder((BATCH_SIZE, 1, 28, 28), dtype=flow.float),
    labels: tp.Numpy.Placeholder((BATCH_SIZE,), dtype=flow.int32),

 

train_job 是一个被 @flow.global_function 修饰的函数,通常被称为作业函数 (job function)。只有被 @flow.global_function 修饰的作业函数才能够被 OneFlow 识别,通过 type 来指定 job 的类型:type=”train” 为训练作业;type=”predict” 为验证或预测作业。

 

在 OneFlow 中一个神经网络的训练或者预测作业需要两部分信息:

 

learning rate

 

lr_scheduler = flow.optimizer.PiecewiseConstantScheduler([], [0.1]) flow.optimizer.SGD(lr_scheduler, momentum=0).minimize(loss)

 

这段代码里包含了训练一个神经网络的所有元素,除了上面说的作业函数及其配置之外:

 

check_point.init()
flow.data.load_mnist(BATCH_SIZE,BATCH_SIZE)
train_job(images, labels)
print(loss.mean())

 

以上只是一个简单网络的示例,在 使用卷积神经网络进行手写体识别 中,我们对使用 OneFlow 的流程进行了更加全面和具体的介绍。 另外,还可参考 OneFlow  基础专题 中对于训练中各类问题的详细介绍。同时还提供了一些经典网络的 样例代码 及数据供参考。

 

2. 解析

 

识别 MNIST 手写体数字

 

在这篇文章中,我们将学习:

使用 oneflow 接口配置软硬件环境
使用 oneflow 的接口定义训练模型
实现 oneflow 的训练作业函数
模型的保存和加载
实现 oneflow 的校验作业函数

本文通过使用 LeNet 模型,训练 MNIST 数据集向大家介绍使用 OneFlow 的各个核心环节,文末附有完整的示例代码。

 

在学习之前,也可以通过以下命令查看各脚本功能 ( 脚本运行依赖 GPU )。

 

首先,同步本文档仓库并切换到对应路径:

 

git clone https://github.com/Oneflow-Inc/oneflow-documentation.git
cd oneflow-documentation/cn/docs/code/quick_start/

 

模型训练python lenet_train.py

以上命令将对 MNIST 数据集进行训练,并保存模型。

 

输出:

 

File mnist.npz already exist, path: ./mnist.npz

 

训练模型是以下 lenet_eval.py 与  lenet_test.py 的前提条件,你也可以直接下载使用我们已经训练好的模型,略过训练步骤

 

wget https://oneflow-public.oss-cn-beijing.aliyuncs.com/online_document/docs/quick_start/lenet_models_1.zip

 

模型校验python lenet_eval.py

以上命令,使用 MNIST 测试集对刚刚生成的模型进行校验,并给出准确率。

 

输出:

 

File mnist.npz already exist, path: ./mnist.npz

图像识别

python lenet_test.py ./9.png

 

以上命令将使用之前训练的模型对我们准备好的 “9.png” 图片中的内容进行预测。 你也可以下载我们 提取好的 mnist 图片 ,自行验证自己训练模型的预测效果。

 

MNIST 数据集介绍

 

MNIST 是一个手写数字的数据库。包括了训练集与测试集;训练集包含了 60000 张图片以及图片对应的标签,测试集包含了 60000 张图片以及图片测试的标签。Yann LeCun 等已经将图片进行了大小归一化及居中处理,并且打包为二进制文件供下载。 yann.lecun.com/exdb/mnist/

 

定义训练模型

 

oneflow.nn 及  oneflow.layers 提供了部分用于构建模型的算子。

 

def lenet(data, train=False):
    initializer = flow.truncated_normal(0.1)
    conv1 = flow.layers.conv2d(
        kernel_initializer=initializer,
    pool1 = flow.nn.max_pool2d(
        conv1, ksize=2, strides=2, padding="SAME", 
    conv2 = flow.layers.conv2d(
        kernel_initializer=initializer,
    pool2 = flow.nn.max_pool2d(
        conv2, ksize=2, strides=2, padding="SAME", 
    reshape = flow.reshape(pool2, [pool2.shape[0], -1])
    hidden = flow.layers.dense(
        kernel_initializer=initializer,
        hidden = flow.nn.dropout(hidden, rate=0.5, )
return flow.layers.dense(hidden, 10, kernel_initializer=initializer, )

 

以上代码中,我们搭建了一个 LeNet 网络模型。

 

实现训练作业函数

 

OneFlow 中提供了 oneflow.global_function 装饰器,通过它,可以将一个 Python 函数转变为训练作业函数(job function)。

 

global_function 装饰器

 

oneflow.global_function 装饰器接收一个 type 作为参数用于指定作业类型,type=”train” 指定作业类型为训练,type=”predict” 指定作业类型为预测或验证。装饰器内部还有一个  function_config 对象参数用于具体类型的作业配置。

 

@flow.global_function(type="train")
    images: tp.Numpy.Placeholder((BATCH_SIZE, 1, 28, 28), dtype=flow.float),
    labels: tp.Numpy.Placeholder((BATCH_SIZE,), dtype=flow.int32),

 

其中的 tp.Numpy.Placeholder 是数据占位符,  tp.Numpy 指定这个作业函数在调用时,将返回一个  numpy 对象。

 

指定优化特征

 

我们可以通过 flow.optimizer 接口指定待优化参数和优化器。这样,OneFlow 在每次迭代训练作业的过程中,将以指定的方式作为优化目标。

 

@flow.global_function(type="train")
    images: tp.Numpy.Placeholder((BATCH_SIZE, 1, 28, 28), dtype=flow.float),
    labels: tp.Numpy.Placeholder((BATCH_SIZE,), dtype=flow.int32),
with flow.scope.placement("gpu", "0:0"):
        logits = lenet(images, train=True)
        loss = flow.nn.sparse_softmax_cross_entropy_with_logits(
            labels, logits, 
    lr_scheduler = flow.optimizer.PiecewiseConstantScheduler([], [0.1])
    flow.optimizer.SGD(lr_scheduler, momentum=0).minimize(loss)

 

以上,我们通过 flow.nn.sparse_softmax_cross_entropy_with_logits 求得 loss ,并且将优化 loss 作为目标参数。

 

lr_scheduler设定了学习率计划,[0.1] 表明初始学习率为 0.1;

 

flow.optimizer.SGD则指定了优化器为 sgd;loss 作为参数传递给 minimize 表明优化器将以最小化 loss 为目标。

 

调用作业函数并交互

 

调用作业函数就可以开始训练。

 

调用作业函数时的返回结果,由定义作业函数时指定的返回值类型决定,可以返回一个,也可以返回多个结果。

 

返回一个结果的例子

 

lenet_train.py 中定义作业函数:

 

@flow.global_function(type="train")
    images: tp.Numpy.Placeholder((BATCH_SIZE, 1, 28, 28), dtype=flow.float),
    labels: tp.Numpy.Placeholder((BATCH_SIZE,), dtype=flow.int32),
with flow.scope.placement("gpu", "0:0"):
        logits = lenet(images, train=True)
        loss = flow.nn.sparse_softmax_cross_entropy_with_logits(
            labels, logits, 
    lr_scheduler = flow.optimizer.PiecewiseConstantScheduler([], [0.1])
    flow.optimizer.SGD(lr_scheduler, momentum=0).minimize(loss)

 

该作业函数的返回值类型为 tp.Numpy ,则当调用时,会返回一个 numpy 对象:

 

for i, (images, labels) in enumerate(zip(train_images, train_labels)):
            loss = train_job(images, labels)

 

我们调用了 train_job 并每循环 20 次打印 1 次  loss

 

返回多个结果的例子

 

在校验模型的代码 lenet_eval.py 中定义的作业函数:

 

@flow.global_function(type="predict")
    images: tp.Numpy.Placeholder((BATCH_SIZE, 1, 28, 28), dtype=flow.float),
    labels: tp.Numpy.Placeholder((BATCH_SIZE,), dtype=flow.int32),
) -> Tuple[tp.Numpy, tp.Numpy]:
with flow.scope.placement("gpu", "0:0"):
        logits = lenet(images, train=False)
        loss = flow.nn.sparse_softmax_cross_entropy_with_logits(
            labels, logits,

 

该作业函数的返回值类型为 Tuple[tp.Numpy, tp.Numpy] ,则当调用时,会返回一个  tuple 容器,里面有 2 个元素,每个元素都是一个  numpy 对象:

 

for i, (images, labels) in enumerate(zip(test_images, test_labels)):
            labels, logits = eval_job(images, labels)

 

我们调用作业函数返回了 labelslogits ,并用它们评估模型准确率。

 

同步与异步调用

 

本文所有代码都是同步方式调用作业函数,实际上 OneFlow 还支持异步方式调用作业函数,具体内容在 获取作业函数的结果 一文中详细介绍。

 

模型的初始化、保存与加载

 

模型的初始化与保存

 

oneflow.train.CheckPoint 类构造的对象,可以用于模型的初始化、保存与加载。 在训练过程中,我们可以通过  init 方法初始化模型,通过  save 方法保存模型。如下例:

 

if __name__ == '__main__':
  check_point = flow.train.CheckPoint()
  check_point.save('./lenet_models_1')

 

保存成功后,我们将得到名为 “lenet_models_1” 的 目录 ,该目录中包含了与模型参数对应的子目录及文件。

 

模型的加载

 

在校验或者预测过程中,我们可以通过 oneflow.train.CheckPoint.load 方法加载现有的模型参数。如下例:

 

if __name__ == '__main__':
  check_point = flow.train.CheckPoint()
  check_point.load("./lenet_models_1")

 

load 自动读取之前保存的模型,并加载。

 

模型的校验

 

校验作业函数与训练作业函数 几乎没有区别 ,不同之处在于校验过程中的模型参数来自于已经保存好的模型,因此不需要初始化,也不需要在迭代过程中更新模型参数。

 

校验作业函数的编写

 

@flow.global_function(type="predict")
    images: tp.Numpy.Placeholder((BATCH_SIZE, 1, 28, 28), dtype=flow.float),
    labels: tp.Numpy.Placeholder((BATCH_SIZE,), dtype=flow.int32),
) -> Tuple[tp.Numpy, tp.Numpy]:
with flow.scope.placement("gpu", "0:0"):
        logits = lenet(images, train=False)
        loss = flow.nn.sparse_softmax_cross_entropy_with_logits(
            labels, logits,

 

以上是校验训练作业函数的编写,声明了返回值类型是 Tuple[tp.Numpy, tp.Numpy] , 因此返回一个  tuple ,  tuple 中有 2 个元素,每个元素都是 1 个  numpy 对象。我们将调用训练作业函数,并根据返回结果计算准确率。

 

迭代校验

 

以下 acc 函数中统计样本的总数目,以及校验正确的总数目,我们将调用作业函数,得到  labels 与  logits

 

predictions = np.argmax(logits, 1)
    right_count = np.sum(predictions == labels)
    g_total += labels.shape[0]

 

调用校验作业函数:

 

if __name__ == "__main__":
    check_point = flow.train.CheckPoint()
    check_point.load("./lenet_models_1")
    (train_images, train_labels), (test_images, test_labels) = flow.data.load_mnist(
for i, (images, labels) in enumerate(zip(test_images, test_labels)):
            labels, logits = eval_job(images, labels)
    print("accuracy: {0:.1f}%".format(g_correct * 100 / g_total))

 

以上,循环调用校验函数,并且最终输出对于测试集的判断准确率。

 

预测图片

 

将以上校验代码修改,使得校验数据来自于原始的图片而不是现成的数据集,我们就可以使用模型进行图片预测。

 

im = Image.open(file).convert("L")
    im = im.resize((28, 28), Image.ANTIALIAS)
    im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32)
    im = (im - 128.0) / 255.0
    im.reshape((-1, 1, 1, im.shape[1], im.shape[2]))
    check_point = flow.train.CheckPoint()
    check_point.load("./lenet_models_1")
    image = load_image(sys.argv[1])
    logits = eval_job(image, np.zeros((1,)).astype(np.int32))
    prediction = np.argmax(logits, 1)
    print("prediction: {}".format(prediction[0]))
if __name__ == "__main__":

 

完整代码

 

训练模型

 

代码: lenet_train.py

 

import oneflow.typing as tp
def lenet(data, train=False):
    initializer = flow.truncated_normal(0.1)
    conv1 = flow.layers.conv2d(
        kernel_initializer=initializer,
    pool1 = flow.nn.max_pool2d(
        conv1, ksize=2, strides=2, padding="SAME", 
    conv2 = flow.layers.conv2d(
        kernel_initializer=initializer,
    pool2 = flow.nn.max_pool2d(
        conv2, ksize=2, strides=2, padding="SAME", 
    reshape = flow.reshape(pool2, [pool2.shape[0], -1])
    hidden = flow.layers.dense(
        kernel_initializer=initializer,
        hidden = flow.nn.dropout(hidden, rate=0.5, )
return flow.layers.dense(hidden, 10, kernel_initializer=initializer, )
@flow.global_function(type="train")
    images: tp.Numpy.Placeholder((BATCH_SIZE, 1, 28, 28), dtype=flow.float),
    labels: tp.Numpy.Placeholder((BATCH_SIZE,), dtype=flow.int32),
with flow.scope.placement("gpu", "0:0"):
        logits = lenet(images, train=True)
        loss = flow.nn.sparse_softmax_cross_entropy_with_logits(
            labels, logits, 
    lr_scheduler = flow.optimizer.PiecewiseConstantScheduler([], [0.1])
    flow.optimizer.SGD(lr_scheduler, momentum=0).minimize(loss)
if __name__ == "__main__":
    flow.config.gpu_device_num(1)
    check_point = flow.train.CheckPoint()
    (train_images, train_labels), (test_images, test_labels) = flow.data.load_mnist(
for i, (images, labels) in enumerate(zip(train_images, train_labels)):
            loss = train_job(images, labels)
    check_point.save("./lenet_models_1")

 

校验模型

 

代码: lenet_eval.py

 

预训练模型: lenet_models_1.zip

 

import oneflow.typing as tp
def lenet(data, train=False):
    initializer = flow.truncated_normal(0.1)
    conv1 = flow.layers.conv2d(
        kernel_initializer=initializer,
    pool1 = flow.nn.max_pool2d(
        conv1, ksize=2, strides=2, padding="SAME", 
    conv2 = flow.layers.conv2d(
        kernel_initializer=initializer,
    pool2 = flow.nn.max_pool2d(
        conv2, ksize=2, strides=2, padding="SAME", 
    reshape = flow.reshape(pool2, [pool2.shape[0], -1])
    hidden = flow.layers.dense(
        kernel_initializer=initializer,
        hidden = flow.nn.dropout(hidden, rate=0.5, )
return flow.layers.dense(hidden, 10, kernel_initializer=initializer, )
@flow.global_function(type="predict")
    images: tp.Numpy.Placeholder((BATCH_SIZE, 1, 28, 28), dtype=flow.float),
    labels: tp.Numpy.Placeholder((BATCH_SIZE,), dtype=flow.int32),
) -> Tuple[tp.Numpy, tp.Numpy]:
with flow.scope.placement("gpu", "0:0"):
        logits = lenet(images, train=False)
        loss = flow.nn.sparse_softmax_cross_entropy_with_logits(
            labels, logits, 
    predictions = np.argmax(logits, 1)
    right_count = np.sum(predictions == labels)
    g_total += labels.shape[0]
if __name__ == "__main__":
    check_point = flow.train.CheckPoint()
    check_point.load("./lenet_models_1")
    (train_images, train_labels), (test_images, test_labels) = flow.data.load_mnist(
for i, (images, labels) in enumerate(zip(test_images, test_labels)):
            labels, logits = eval_job(images, labels)
    print("accuracy: {0:.1f}%".format(g_correct * 100 / g_total))

 

数字预测

 

代码: lenet_test.py

 

预训练模型: lenet_models_1.zip

 

MNIST 数据集图片 mnist_raw_images.zip

 

import oneflow.typing as tp
        os.path.basename(sys.argv[0]), os.path.join(".", "9.png")
def lenet(data, train=False):
    initializer = flow.truncated_normal(0.1)
    conv1 = flow.layers.conv2d(
        kernel_initializer=initializer,
    pool1 = flow.nn.max_pool2d(
        conv1, ksize=2, strides=2, padding="SAME", 
    conv2 = flow.layers.conv2d(
        kernel_initializer=initializer,
    pool2 = flow.nn.max_pool2d(
        conv2, ksize=2, strides=2, padding="SAME", 
    reshape = flow.reshape(pool2, [pool2.shape[0], -1])
    hidden = flow.layers.dense(
        kernel_initializer=initializer,
        hidden = flow.nn.dropout(hidden, rate=0.5, )
return flow.layers.dense(hidden, 10, kernel_initializer=initializer, )
@flow.global_function(type="predict")
    images: tp.Numpy.Placeholder((BATCH_SIZE, 1, 28, 28), dtype=flow.float),
    labels: tp.Numpy.Placeholder((BATCH_SIZE,), dtype=flow.int32),
with flow.scope.placement("gpu", "0:0"):
        logits = lenet(images, train=False)
    im = Image.open(file).convert("L")
    im = im.resize((28, 28), Image.ANTIALIAS)
    im = np.array(im).reshape(1, 1, 28, 28).astype(np.float32)
    im = (im - 128.0) / 255.0
    im.reshape((-1, 1, 1, im.shape[1], im.shape[2]))
    check_point = flow.train.CheckPoint()
    check_point.load("./lenet_models_1")
    image = load_image(sys.argv[1])
    logits = eval_job(image, np.zeros((1,)).astype(np.int32))
    prediction = np.argmax(logits, 1)
    print("prediction: {}".format(prediction[0]))
if __name__ == "__main__":

 

3. 总结

 

可以看出 OneFlow 模型搭建和训练还是很简单易用的,迁移到此框架成本不大。笔者要息笔锻炼一下了,希望大家都保持个好身体(~~)。。

 

-1. 参考

 

-10.『王霸之路』从 0.1 到 2.0 一文看尽 TensorFlow 奋斗史 – 极简 AI· 小宋是呢的文章 – 知乎 zhuanlan.zhihu.com/p/85111240

 

-11. docs.oneflow.org/build_ship/…

Be First to Comment

发表回复

您的电子邮箱地址不会被公开。 必填项已用*标注