使用已经得到的keras模型识别自己手写的数字方式_Python

环境：Python+keras，后端为Tensorflow

训练集：MNIST

对于如何训练一个识别手写数字的神经网络，网上资源十分丰富，并且能达到相当高的精度。但是很少有人涉及到如何将图片输入到网络中并让已经训练好的模型惊醒识别，下面来说说实现方法及注意事项。

首先import相关库，这里就不说了。

然后需要将训练好的模型导入，可通过该语句实现：

model = load_model('cnn_model_2.h5') （cnn_model_2.h5替换为你的模型名）

之后是导入图片，需要的格式为28*28。可用opencv导入：

img = cv2.imread('temp3.png', 0) （temp3.png替换为你手写的图片）

然后reshape一下以符合模型的输入要求：

img = (img.reshape(1,1,28,28)).astype("float32")/255

之后就可以用模型识别了：

predict = model.predict_classes(img)

最后print一下predict即可。

下面划重点：因为MNIST使用的是黑底白字的图片，所以你自己手写数字的时候一定要注意把得到的图片也改成黑底白字的，否则会识别错（至少我得到的结论是这样的，之前用白底黑字的图总是识别出错）

源码一览：

									import cv2

									import numpy as np

									from keras.models import load_model

									model = load_model('cnn_model_2.h5')

									image = cv2.imread('temp3.png', 0)

									img = cv2.imread('temp3.png', 0)

									img = (img.reshape(1,1,28,28)).astype("float32")/255

									predict = model.predict_classes(img)

									print ('识别为：')

									print (predict)

									cv2.imshow("Image1", image)

									cv2.waitKey(0)

效果图：

使用已经得到的keras模型识别自己手写的数字方式

补充知识：keras编写自定义的层

写在前面的话

keras已经有很多封装好的库供我们调用，但是有些时候我们需要的操作keras并没有，这时就需要学会自定义keras层了

1.Lambda

这个东西很方便，但是只能完成简单、无状态的自定义操作，而不能建立含有可训练权重的自定义层。

									from keras.layers import Input,Lambda

									from keras import Model

									import tensorflow as tf

									input=Input(shape=(224,224,3))

									input.shape #Input第一个维度为batchsize维度

									output=Lambda(lambda x: x[...,1])(input) #取最后一个维度的数据,...表示前面所有的维度

									Model=Model(inputs=input,outputs=output)

									Model.output

2.keras_custom

学习自keras中文文档

									2.自定义keras层（带有可训练权重）

									① build：定义权重，且self.build=True，可以通过迪奥哟经super([layer],self).build()完成

									② call:功能逻辑实现

									③ compute_output_shape:计算输出张量的shape

									import keras.backend as K

									from keras.engine.topology import Layer #这里的Layer是一个父类，下面的MyLayer将会继承Layer 

									class MyLayer(Layer): #自定义一个keras层类

									 def __init__(self,output_dim,**kwargs): #初始化方法

									  self.output_dim=output_dim

									  super(MyLayer,self).__init__(**kwargs) #必须要的初始化自定义层

									 def build(self,input_shape): #为Mylayer建立一个可训练的权重

									  #通过add_weight的形式来为Mylayer创建权重矩阵

									  self.kernel=self.add_weight(name='kernel',

									         shape=(input_shape[1],self.output_dim), #这里就是建立一个shape大小的权重矩阵

									         initializer='uniform',

									         trainable=True)

									  super(MyLayer,self).build(input_shape) #一定要用，也可以用下面一行

									  #self.build=True

									 def call(self,x): #call函数里就是定义了对x张量的计算图，且x只是一个形式，所以不能被事先定义

									  return K.dot(x,self.kernel) #矩阵乘法

									 def compute_output_shape(self,input_shape):

									  return (input_shape[0],self.output_dim) #这里是自己手动计算出来的output_shape

									--------------------------------------------------------------------------------

									class Mylayer(Layer):

									 def __init__(self,output_dim,**kwargs):

									  self.output_dim=output_dim

									  super(MyLayer,self).__init__(**kwargs)

									 def build(self,input_shape):

									  assert isinstance(input_shape,list) #判断input_shape是否是list类型的

									  self.kernel=self.add_weight(name='kernel',

									         shape=(input_shape[0][1],self.output_dim), #input_shape应该长得像[(2,2),(3,3)]

									         initializer='uniform',

									         trainable=True)

									  super(MyLayer,self).build(input_shape)

									 def call(self,x):

									  assert isinstance(x,list)

									  a,b=x #从这里可以看出x应该是一个类似[(2,2),(3,3)]的list,a=(2,2),b=(3,3)

									  return [K.dot(a,self.kernel)+b,K.mean(b,axis=-1)]