开发笔记:PaddlePaddle系列CIFAR10图像分类

def reader_creator(ROOT,istrain=True,cycle=False):
def load_CIFAR_batch(filename):
""" load single batch of cifar """
with open(filename,‘rb‘) as f:
datadict = Pickle.load(f)
X = datadict[‘data‘]
Y = datadict[‘labels‘]
""" (N C H W) transpose to (N H W C) """
X = X.reshape(10000,3,32,32).transpose(0,2,3,1).astype(‘float‘)
Y = np.array(Y)
return X,Y
def reader():
while True:
if istrain:
for b in range(1,6):
f = os.path.join(ROOT,‘data_batch_%d‘%(b))
X,Y = load_CIFAR_batch(f)
length = X.shape[0]
for i in range(length):
yield X[i],Y[i]
if not cycle:
break
else:
f = os.path.join(ROOT,‘test_batch‘)
X,Y = load_CIFAR_batch(f)
length = X.shape[0]
for i in range(length):
yield X[i],Y[i]
if not cycle:
break
return reader

def train_network():
predict = inference_network()
label = fluid.layers.data(name=‘label‘,shape=[1],dtype=‘int64‘)
cost = fluid.layers.cross_entropy(input=predict,label=label)
avg_cost = fluid.layers.mean(cost)
accuracy = fluid.layers.accuracy(input=predict,label=label)
return [avg_cost,accuracy]
def optimizer_program():
return fluid.optimizer.Adam(learning_rate=0.001)
def train(data_path,save_path):
BATCH_SIZE = 128
EPOCH_NUM = 2
train_reader = paddle.batch(
paddle.reader.shuffle(reader_creator(data_path),buf_size=50000),
batch_size = BATCH_SIZE)
test_reader = paddle.batch(
reader_creator(data_path,False),
batch_size=BATCH_SIZE)
def event_handler(event):
if isinstance(event, fluid.EndStepEvent):
if event.step % 100 == 0:
print("
Pass %d, Epoch %d, Cost %f, Acc %f" %
(event.step, event.epoch, event.metrics[0],
event.metrics[1]))
else:
sys.stdout.write(‘.‘)
sys.stdout.flush()
if isinstance(event, fluid.EndEpochEvent):
avg_cost, accuracy = trainer.test(
reader=test_reader, feed_order=[‘image‘, ‘label‘])
print(‘
Test with Pass {0}, Loss {1:2.2}, Acc {2:2.2}‘.format(
event.epoch, avg_cost, accuracy))
if save_path is not None:
trainer.save_params(save_path)
place = fluid.CUDAPlace(0)
trainer = fluid.Trainer(
train_func=train_network, optimizer_func=optimizer_program, place=place)
trainer.train(
reader=train_reader,
num_epochs=EPOCH_NUM,
event_handler=event_handler,
feed_order=[‘image‘, ‘label‘])

def infer(params_dir):
place = fluid.CUDAPlace(0)
inferencer = fluid.Inferencer(
infer_func=inference_network, param_path=params_dir, place=place)
# Prepare testing data.
from PIL import Image
import numpy as np
import os
def load_image(file):
im = Image.open(file)
im = im.resize((32, 32), Image.ANTIALIAS)
im = np.array(im).astype(np.float32)
"""transpose [H W C] to [C H W]"""
im = im.transpose((2, 0, 1))
im = im / 255.0
# Add one dimension, [N C H W] N=1
im = np.expand_dims(im, axis=0)
return im
cur_dir = os.path.dirname(os.path.realpath(__file__))
img = load_image(cur_dir + ‘/dog.png‘)
# inference
results = inferencer.infer({‘image‘: img})
print(results)
lab = np.argsort(results) # probs and lab are the results of one batch data
print("infer results: ", cifar_classes[lab[0][0][-1]])