请检查整个程序有没有问题

#!/usr/bin/env python
# -*- coding: utf-8 -*-
' a test module '

__author__ = 'Michael Liao'

import os
from PIL import Image
import numpy as np
import paddle
import paddle.fluid as fluid
"""
这是一个分类器
Softmax回归：只通过一层简单的以softmax为激活函数的全连接层，就可以得到分类的结果。
"""
def softmax_regression():
img = fluid.layers.data(name='img',shape=[1,28,28],dtype='float32')
predict = fluid.layers.fc(input=img,size=10,act='softmax')
return predict

"""
这也是一个分类器
多层感知器：下面代码实现了一个含有两个隐藏层（即全连接层）的多层感知器。其中两个隐藏层的激活函数均采用ReLU，输出层的激活函数用Softmax。
"""
def multilayer_perceptron():
img = fluid.layers.data(name='img',shap=[1,28,28],dtype='float32')
#第一个全连接层，激活函数为ReLU
hidden = fluid.layers.fc(input=img,size=200,act='relu')
#第二个全连接层，激活函数为ReLU
hidden = fluid.layers.fc(input=hidden,size=200,act='relu')
#以softmax为激活函数的全链接输出层，输入层的大小必须为数字的个数10
prediction = fluid.layers.fc(input=hidden,size=10,act='softmax')
return prediction

'''
这还是一个分类器
卷积神经网络LeNet-5: 输入的二维图像，首先经过两次卷积层到池化层，再经过全连接层，最后使用以softmax为激活函数的全连接层作为输出层。
'''
def convolutional_neural_network():
img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
# 第一个卷积-池化层
conv_pool_1 = fluid.nets.simple_img_conv_pool(input=img,
filter_size=5,
num_filters=20,
pool_size=2,
pool_stride=2,
act="relu")
conv_pool_1 = fluid.layers.batch_norm(conv_pool_1)
# 第二个卷积-池化层
conv_pool_2 = fluid.nets.simple_img_conv_pool(input=conv_pool_1,
filter_size=5,
num_filters=50,
pool_size=2,
pool_stride=2,
act="relu")
# 以softmax为激活函数的全连接输出层，输出层的大小必须为数字的个数10
prediction = fluid.layers.fc(input=conv_pool_2, size=10, act='softmax')
return prediction

#Train Program 配置
'''
然后我们需要设置训练程序 train_program。它首先从分类器中进行预测。 在训练期间，它将从预测中计算 avg_cost。
注意: 训练程序应该返回一个数组，第一个返回参数必须是 avg_cost。训练器使用它来计算梯度。
请随意修改代码，测试 Softmax 回归 softmax_regression, MLP 和 卷积神经网络 convolutional neural network 分类器之间的不同结果。
这是一个训练程序
'''
def train_program():
label = fluid.layers.data(name='label', shape=[1], dtype='int64')

# 在这里我们可以用不同的方式构建预测网络
# predict = softmax_regression() # Softmax回归
# predict = multilayer_perceptron() # MLP多层感知器
predict = convolutional_neural_network() # LeNet5卷积神经网络

# 从预测和标签中计算成本。
cost = fluid.layers.cross_entropy(input=predict, label=label)
avg_cost = fluid.layers.mean(cost)
acc = fluid.layers.accuracy(input=predict, label=label)
return [avg_cost, acc]
#该模型运行于单个CPU上

#Optimizer Function 配置
'''
在下面的 Adam optimizer，learning_rate 是训练的速度，与网络的训练收敛速度有关系。
这是一个优化器
'''
def optimizer_program():
return fluid.optimizer.Adam(learning_rate=0.001)

'''
下一步，我们开始训练过程。paddle.dataset.movielens.train()和paddle.dataset.movielens.test()分别做训练和测试数据集。
这两个函数各自返回一个reader——PaddlePaddle中的reader是一个Python函数，每次调用的时候返回一个Python yield generator。
下面shuffle是一个reader decorator，它接受一个reader A，返回另一个reader B —— reader B 每次读入buffer_size条训练数据到一个buffer里，然后随机打乱其顺序，并且逐条输出。
batch是一个特殊的decorator，它的输入是一个reader，输出是一个batched reader —— 在PaddlePaddle里，一个reader每次yield一条训练数据，而一个batched reader每次yield一个minibatch。
'''
def main():
#数据集 Feeders 配置
train_reader = paddle.batch(paddle.reader.shuffle(paddle.dataset.mnist.train(), buf_size=500),
batch_size=64)

test_reader = paddle.batch(paddle.dataset.mnist.test(), batch_size=64)
#Trainer 配置
'''
现在，我们需要配置 Trainer。Trainer 需要接受训练程序 train_program, place 和优化器 optimizer。
'''
use_cuda = False # 设置为true则运行在GPU
place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
trainer = fluid.Trainer(train_func=train_program, optimizer_func=optimizer_program, place=place)

'''
Event Handler 配置
Fluid API 在训练期间为回调函数提供了一个钩子。用户能够通过机制监控培训进度。 我们将在这里演示两个 event_handler 程序。请随意修改 Jupyter 笔记本 ，看看有什么不同。
event_handler 用来在训练过程中输出训练结果
'''
# Save the parameter into a directory. The Inferencer can load the
# parameters from it to do infer将参数保存到目录中。推理者可以从它加载参数来进行推断
params_dirname = "recognize_digits_network.inference.model"

lists = []

def event_handler(event):
if isinstance(event, fluid.EndStepEvent):
if event.step % 100 == 0:
# event.metrics maps with train program return arguments.
# event.metrics[0] will yeild avg_cost and event.metrics[1]
# will yeild acc in this example.
print "Pass %d, Batch %d, Cost %f" % (event.step, event.epoch,
event.metrics[0])

if isinstance(event, fluid.EndEpochEvent):
avg_cost, acc = trainer.test(reader=test_reader, feed_order=['img', 'label'])

print("Test with Epoch %d, avg_cost: %s, acc: %s" % (event.epoch, avg_cost, acc))

# save parameters
trainer.save_params(params_dirname)
lists.append((event.epoch, avg_cost, acc))

# 开始训练模型
trainer.train(num_epochs=5,
event_handler=event_handler,
reader=train_reader,
feed_order=['img', 'label'])

# 找到最好的传递
best = sorted(lists, key=lambda list: float(list[1]))[0]
print 'Best pass is %s, testing Avgcost is %s' % (best[0], best[1])
print 'The classification accuracy is %.2f%%' % (float(best[2]) * 100)

#应用模型
'''
可以使用训练好的模型对手写体数字图片进行分类，下面程序展示了如何使用 fluid.Inferencer 接口进行推断。
'''

#生成预测输入数据
'''
infer_3.png 是数字 3 的一个示例图像。把它变成一个 numpy 数组以匹配数据馈送格式。
'''
def load_image(file):
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 / 255.0 * 2.0 - 1.0
return im

cur_dir = os.path.dirname(os.path.realpath(__file__))
img = load_image(cur_dir + '/image/infer_3.png')
#Inference 配置
'''
Inference 需要一个 infer_func 和 param_path 来设置网络和经过训练的参数。 我们可以简单地插入在此之前定义的分类器。
'''
inferencer = fluid.Inferencer(# infer_func=softmax_regression, # uncomment for softmax regression
# infer_func=multilayer_perceptron, # uncomment for MLP
infer_func=convolutional_neural_network, # uncomment for LeNet5
param_path=params_dirname,
place=place)

#预测
'''
现在我们准备做预测
'''
results = inferencer.infer({'img': img})
lab = np.argsort(results) # probs and lab are the results of one batch data
print "Label of image/infer_3.png is: %d" % lab[0][0][-1]

if __name__ == '__main__':
main()

程序应该没错吧

#!/usr/bin/env python
# -*- coding: utf-8 -*-
' a test module '

__author__ = 'Michael Liao'

import os
from PIL import Image
import numpy as np
import paddle
import paddle.fluid as fluid
"""
这是一个分类器
Softmax回归：只通过一层简单的以softmax为激活函数的全连接层，就可以得到分类的结果。
"""
def softmax_regression():
    img = fluid.layers.data(name='img',shape=[1,28,28],dtype='float32')
    predict = fluid.layers.fc(input=img,size=10,act='softmax')
    return predict


"""
这也是一个分类器
多层感知器：下面代码实现了一个含有两个隐藏层（即全连接层）的多层感知器。其中两个隐藏层的激活函数均采用ReLU，输出层的激活函数用Softmax。
"""
def multilayer_perceptron():
    img = fluid.layers.data(name='img',shap=[1,28,28],dtype='float32')
    #第一个全连接层，激活函数为ReLU
    hidden = fluid.layers.fc(input=img,size=200,act='relu')
    #第二个全连接层，激活函数为ReLU
    hidden = fluid.layers.fc(input=hidden,size=200,act='relu')
    #以softmax为激活函数的全链接输出层，输入层的大小必须为数字的个数10
    prediction = fluid.layers.fc(input=hidden,size=10,act='softmax')
    return prediction


'''
这还是一个分类器
卷积神经网络LeNet-5: 输入的二维图像，首先经过两次卷积层到池化层，再经过全连接层，最后使用以softmax为激活函数的全连接层作为输出层。
'''
def convolutional_neural_network():
    img = fluid.layers.data(name='img', shape=[1, 28, 28], dtype='float32')
    # 第一个卷积-池化层
    conv_pool_1 = fluid.nets.simple_img_conv_pool(input=img,
        filter_size=5,
        num_filters=20,
        pool_size=2,
        pool_stride=2,
        act="relu")
    conv_pool_1 = fluid.layers.batch_norm(conv_pool_1)
    # 第二个卷积-池化层
    conv_pool_2 = fluid.nets.simple_img_conv_pool(input=conv_pool_1,
        filter_size=5,
        num_filters=50,
        pool_size=2,
        pool_stride=2,
        act="relu")
    # 以softmax为激活函数的全连接输出层，输出层的大小必须为数字的个数10
    prediction = fluid.layers.fc(input=conv_pool_2, size=10, act='softmax')
    return prediction



#Train Program 配置
'''
然后我们需要设置训练程序 train_program。它首先从分类器中进行预测。 在训练期间，它将从预测中计算 avg_cost。
注意: 训练程序应该返回一个数组，第一个返回参数必须是 avg_cost。训练器使用它来计算梯度。
请随意修改代码，测试 Softmax 回归 softmax_regression, MLP 和 卷积神经网络 convolutional neural network 分类器之间的不同结果。
这是一个训练程序
'''
def train_program():
    label = fluid.layers.data(name='label', shape=[1], dtype='int64')

    # 在这里我们可以用不同的方式构建预测网络
    # predict = softmax_regression() # Softmax回归
    # predict = multilayer_perceptron() # MLP多层感知器
    predict = convolutional_neural_network()  #  LeNet5卷积神经网络

    # 从预测和标签中计算成本。
    cost = fluid.layers.cross_entropy(input=predict, label=label)
    avg_cost = fluid.layers.mean(cost)
    acc = fluid.layers.accuracy(input=predict, label=label)
    return [avg_cost, acc]
#该模型运行于单个CPU上


#Optimizer Function 配置
'''
在下面的 Adam optimizer，learning_rate 是训练的速度，与网络的训练收敛速度有关系。
这是一个优化器
'''
def optimizer_program():
    return fluid.optimizer.Adam(learning_rate=0.001)



'''
下一步，我们开始训练过程。paddle.dataset.movielens.train()和paddle.dataset.movielens.test()分别做训练和测试数据集。
这两个函数各自返回一个reader——PaddlePaddle中的reader是一个Python函数，每次调用的时候返回一个Python yield generator。
下面shuffle是一个reader decorator，它接受一个reader A，返回另一个reader B —— reader B 每次读入buffer_size条训练数据到一个buffer里，然后随机打乱其顺序，并且逐条输出。
batch是一个特殊的decorator，它的输入是一个reader，输出是一个batched reader —— 在PaddlePaddle里，一个reader每次yield一条训练数据，而一个batched reader每次yield一个minibatch。
'''
def main():
    #数据集 Feeders 配置
    train_reader = paddle.batch(paddle.reader.shuffle(paddle.dataset.mnist.train(), buf_size=500),
        batch_size=64)

    test_reader = paddle.batch(paddle.dataset.mnist.test(), batch_size=64)
    #Trainer 配置
    '''
    现在，我们需要配置 Trainer。Trainer 需要接受训练程序 train_program, place 和优化器 optimizer。
    '''
    use_cuda = False # 设置为true则运行在GPU
    place = fluid.CUDAPlace(0) if use_cuda else fluid.CPUPlace()
    trainer = fluid.Trainer(train_func=train_program, optimizer_func=optimizer_program, place=place)

    '''
    Event Handler 配置
    Fluid API 在训练期间为回调函数提供了一个钩子。用户能够通过机制监控培训进度。 我们将在这里演示两个 event_handler 程序。请随意修改 Jupyter 笔记本 ，看看有什么不同。
    event_handler 用来在训练过程中输出训练结果
    '''
    # Save the parameter into a directory.  The Inferencer can load the
    # parameters from it to do infer将参数保存到目录中。推理者可以从它加载参数来进行推断
    params_dirname = "recognize_digits_network.inference.model"

    lists = []

    def event_handler(event):
        if isinstance(event, fluid.EndStepEvent):
            if event.step % 100 == 0:
                # event.metrics maps with train program return arguments.
                # event.metrics[0] will yeild avg_cost and event.metrics[1]
                # will yeild acc in this example.
                print "Pass %d, Batch %d, Cost %f" % (event.step, event.epoch,
                                                      event.metrics[0])

        if isinstance(event, fluid.EndEpochEvent):
            avg_cost, acc = trainer.test(reader=test_reader, feed_order=['img', 'label'])

            print("Test with Epoch %d, avg_cost: %s, acc: %s" % (event.epoch, avg_cost, acc))

            # save parameters
            trainer.save_params(params_dirname)
            lists.append((event.epoch, avg_cost, acc))

    # 开始训练模型
    trainer.train(num_epochs=5,
        event_handler=event_handler,
        reader=train_reader,
        feed_order=['img', 'label'])

    # 找到最好的传递
    best = sorted(lists, key=lambda list: float(list[1]))[0]
    print 'Best pass is %s, testing Avgcost is %s' % (best[0], best[1])
    print 'The classification accuracy is %.2f%%' % (float(best[2]) * 100)






    #应用模型
    '''
    可以使用训练好的模型对手写体数字图片进行分类，下面程序展示了如何使用 fluid.Inferencer 接口进行推断。
    '''


    #生成预测输入数据
    '''
    infer_3.png 是数字 3 的一个示例图像。把它变成一个 numpy 数组以匹配数据馈送格式。
    '''
    def load_image(file):
        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 / 255.0 * 2.0 - 1.0
        return im

    cur_dir = os.path.dirname(os.path.realpath(__file__))
    img = load_image(cur_dir + '/image/infer_3.png')
    #Inference 配置
    '''
    Inference 需要一个 infer_func 和 param_path 来设置网络和经过训练的参数。 我们可以简单地插入在此之前定义的分类器。
    '''
    inferencer = fluid.Inferencer(# infer_func=softmax_regression, # uncomment for softmax regression
        # infer_func=multilayer_perceptron, # uncomment for MLP
        infer_func=convolutional_neural_network,  # uncomment for LeNet5
        param_path=params_dirname,
        place=place)

    #预测
    '''
    现在我们准备做预测
    '''
    results = inferencer.infer({'img': img})
    lab = np.argsort(results)  # probs and lab are the results of one batch data
    print "Label of image/infer_3.png is: %d" % lab[0][0][-1]

if __name__ == '__main__':
    main()

坐等大神回复解决

我也遇到同类问题,还是在官方平台AiStudio

请问是用的哪个版本的Paddle呢？

大哥，你用的是0.13.0版本吧，文档是0.14.0的文档。0.14.0优化器的函数就是optimizer_func,0.13.0的优化器函数我记得是optimizer.

是版本问题，应该是paddle 0.14.0