keras如何一次测试两张图片

Ⅰ 如何在后台部署深度学习模型

搭建深度学习后台服务器

我们的Keras深度学习REST API将能够批量处理图像，扩展到多台机器(包括多台web服务器和Redis实例)，并在负载均衡器之后进行循环调度。

为此，我们将使用:

• KerasRedis(内存数据结构存储)

• Flask (Python的微web框架)

• 消息队列和消息代理编程范例

本篇文章的整体思路如下：

我们将首先简要讨论Redis数据存储，以及如何使用它促进消息队列和消息代理。然后，我们将通过安装所需的Python包来配置Python开发环境，以构建我们的Keras深度学习REST API。一旦配置了开发环境，就可以使用Flask web框架实现实际的Keras深度学习REST API。在实现之后，我们将启动Redis和Flask服务器，然后使用cURL和Python向我们的深度学习API端点提交推理请求。最后，我们将以对构建自己的深度学习REST API时应该牢记的注意事项的简短讨论结束。

第一部分：简要介绍Redis如何作为REST API消息代理/消息队列



测试和原文的命令一致。




第三部分：配置Python开发环境以构建Keras REST API

文章中说需要创建新的虚拟环境来防止影响系统级别的python项目（但是我没有创建），但是还是需要安装rest api所需要依赖的包。以下为所需要的包。





第四部分：实现可扩展的Keras REST API

首先是Keras Redis Flask REST API数据流程图

让我们开始构建我们的服务器脚本。为了方便起见，我在一个文件中实现了服务器，但是它可以按照您认为合适的方式模块化。为了获得最好的结果和避免复制/粘贴错误，我建议您使用本文的“下载”部分来获取相关的脚本和图像。

为了简单起见，我们将在ImageNet数据集上使用ResNet预训练。我将指出在哪里可以用你自己的模型交换ResNet。flask模块包含flask库(用于构建web API)。redis模块将使我们能够与redis数据存储接口。从这里开始，让我们初始化将在run_keras_server.py中使用的常量.




我们将向服务器传递float32图像，尺寸为224 x 224，包含3个通道。我们的服务器可以处理一个BATCH_SIZE = 32。如果您的生产系统上有GPU(s)，那么您需要调优BATCH_SIZE以获得最佳性能。我发现将SERVER_SLEEP和CLIENT_SLEEP设置为0.25秒(服务器和客户端在再次轮询Redis之前分别暂停的时间)在大多数系统上都可以很好地工作。如果您正在构建一个生产系统，那么一定要调整这些常量。

让我们启动我们的Flask app和Redis服务器:





在这里你可以看到启动Flask是多么容易。在运行这个服务器脚本之前，我假设Redis服务器正在运行(之前的redis-server)。我们的Python脚本连接到本地主机6379端口(Redis的默认主机和端口值)上的Redis存储。不要忘记将全局Keras模型初始化为None。接下来我们来处理图像的序列化:





Redis将充当服务器上的临时数据存储。图像将通过诸如cURL、Python脚本甚至是移动应用程序等各种方法进入服务器，而且，图像只能每隔一段时间(几个小时或几天)或者以很高的速率(每秒几次)进入服务器。我们需要把图像放在某个地方，因为它们在被处理前排队。我们的Redis存储将作为临时存储。

为了将图像存储在Redis中，需要对它们进行序列化。由于图像只是数字数组，我们可以使用base64编码来序列化图像。使用base64编码还有一个额外的好处，即允许我们使用JSON存储图像的附加属性。

base64_encode_image函数处理序列化。类似地，在通过模型传递图像之前，我们需要反序列化图像。这由base64_decode_image函数处理。

预处理图片





我已经定义了一个prepare_image函数，它使用Keras中的ResNet50实现对输入图像进行预处理，以便进行分类。在使用您自己的模型时，我建议修改此函数，以执行所需的预处理、缩放或规范化。

从那里我们将定义我们的分类方法





classify_process函数将在它自己的线程中启动，我们将在下面的__main__中看到这一点。该函数将从Redis服务器轮询图像批次，对图像进行分类，并将结果返回给客户端。

在model = ResNet50(weights="imagenet")这一行中，我将这个操作与终端打印消息连接起来——根据Keras模型的大小，加载是即时的，或者需要几秒钟。

加载模型只在启动这个线程时发生一次——如果每次我们想要处理一个映像时都必须加载模型，那么速度会非常慢，而且由于内存耗尽可能导致服务器崩溃。

加载模型后，这个线程将不断轮询新的图像，然后将它们分类（注意这部分代码应该时尚一部分的继续）





在这里，我们首先使用Redis数据库的lrange函数从队列(第79行)中获取最多的BATCH_SIZE图像。

从那里我们初始化imageIDs和批处理(第80和81行)，并开始在第84行开始循环队列。

在循环中，我们首先解码对象并将其反序列化为一个NumPy数组image(第86-88行)。

接下来，在第90-96行中，我们将向批处理添加图像(或者如果批处理当前为None，我们将该批处理设置为当前图像)。

我们还将图像的id附加到imageIDs(第99行)。

让我们完成循环和函数

在这个代码块中，我们检查批处理中是否有图像(第102行)。如果我们有一批图像，我们通过模型(第105行)对整个批进行预测。从那里，我们循环一个图像和相应的预测结果(110-122行)。这些行向输出列表追加标签和概率，然后使用imageID将输出存储在Redis数据库中(第116-122行)。

我们使用第125行上的ltrim从队列中删除了刚刚分类的图像集。最后，我们将睡眠设置为SERVER_SLEEP时间并等待下一批图像进行分类。下面我们来处理/predict我们的REST API端点





稍后您将看到，当我们发布到REST API时，我们将使用/predict端点。当然，我们的服务器可能有多个端点。我们使用@app。路由修饰符以第130行所示的格式在函数上方定义端点，以便Flask知道调用什么函数。我们可以很容易地得到另一个使用AlexNet而不是ResNet的端点，我们可以用类似的方式定义具有关联函数的端点。你懂的，但就我们今天的目的而言，我们只有一个端点叫做/predict。

我们在第131行定义的predict方法将处理对服务器的POST请求。这个函数的目标是构建JSON数据，并将其发送回客户机。如果POST数据包含图像(第137和138行)，我们将图像转换为PIL/Pillow格式，并对其进行预处理(第141-143行)。

在开发这个脚本时，我花了大量时间调试我的序列化和反序列化函数，结果发现我需要第147行将数组转换为C-contiguous排序(您可以在这里了解更多)。老实说，这是一个相当大的麻烦事，但我希望它能帮助你站起来，快速跑。

如果您想知道在第99行中提到的id，那么实际上是使用uuid(通用唯一标识符)在第151行生成的。我们使用UUID来防止hash/key冲突。

接下来，我们将图像的id和base64编码附加到d字典中。使用rpush(第153行)将这个JSON数据推送到Redis db非常简单。

让我们轮询服务器以返回预测

我们将持续循环，直到模型服务器返回输出预测。我们开始一个无限循环，试图得到157-159条预测线。从这里，如果输出包含预测，我们将对结果进行反序列化，并将结果添加到将返回给客户机的数据中。我们还从db中删除了结果(因为我们已经从数据库中提取了结果，不再需要将它们存储在数据库中)，并跳出了循环(第163-172行)。

否则，我们没有任何预测，我们需要睡觉，继续投票(第176行)。如果我们到达第179行，我们已经成功地得到了我们的预测。在本例中，我们向客户机数据添加True的成功值(第179行)。注意:对于这个示例脚本，我没有在上面的循环中添加超时逻辑，这在理想情况下会为数据添加一个False的成功值。我将由您来处理和实现。最后我们称烧瓶。jsonify对数据，并将其返回给客户端(第182行)。这就完成了我们的预测函数。

为了演示我们的Keras REST API，我们需要一个__main__函数来实际启动服务器

第186-196行定义了__main__函数，它将启动classify_process线程(第190-192行)并运行Flask应用程序(第196行)。

第五部分：启动可伸缩的Keras REST API

要测试我们的Keras深度学习REST API，请确保使用本文的“下载”部分下载源代码示例图像。从这里，让我们启动Redis服务器，如果它还没有运行:

• redis-server



然后，在另一个终端中，让我们启动REST API Flask服务器:

• python run_keras_server.py



另外，我建议在向服务器提交请求之前，等待您的模型完全加载到内存中。现在我们可以继续使用cURL和Python测试服务器。

第七部分：使用cURL访问Keras REST API

使用cURL来测试我们的Keras REST API服务器。这是我的家庭小猎犬Jemma。根据我们的ResNet模型，她被归类为一只拥有94.6%自信的小猎犬。

• curl -X POST -F [email protected] 'http://localhost:5000/predict'



你会在你的终端收到JSON格式的预测:

• {"predictions": [{"label": "beagle","probability": 0.9461546540260315},{"label": "bluetick","probability": 0.031958919018507004},{"label": "redbone","probability": 0.006617196369916201},{"label": "Walker_hound","probability": 0.0033879687543958426},{"label": "Greater_Swiss_Mountain_dog","probability": 0.0025766862090677023}],"success": true}



第六部分：使用Python向Keras REST API提交请求

如您所见，使用cURL验证非常简单。现在，让我们构建一个Python脚本，该脚本将发布图像并以编程方式解析返回的JSON。

让我们回顾一下simple_request.py

• # import the necessary packagesimport requests# initialize the Keras REST API endpoint URL along with the input# image pathKERAS_REST_API_URL = "http://localhost:5000/predict"IMAGE_PATH = "jemma.png"



我们在这个脚本中使用Python请求来处理向服务器提交数据。我们的服务器运行在本地主机上，可以通过端口5000访问端点/predict，这是KERAS_REST_API_URL变量(第6行)指定的。

我们还定义了IMAGE_PATH(第7行)。png与我们的脚本在同一个目录中。如果您想测试其他图像，请确保指定到您的输入图像的完整路径。

让我们加载图像并发送到服务器:

• # load the input image and construct the payload for the requestimage = open(IMAGE_PATH, "rb").read()payload = {"image": image}# submit the requestr = requests.post(KERAS_REST_API_URL, files=payload).json()# ensure the request was sucessfulif r["success"]: # loop over the predictions and display them for (i, result) in enumerate(r["predictions"]): print("{}. {}: {:.4f}".format(i + 1, result["label"], result["probability"]))# otherwise, the request failedelse: print("Request failed")



我们在第10行以二进制模式读取图像并将其放入有效负载字典。负载通过请求发送到服务器。在第14行发布。如果我们得到一个成功消息，我们可以循环预测并将它们打印到终端。我使这个脚本很简单，但是如果你想变得更有趣，你也可以使用OpenCV在图像上绘制最高的预测文本。

第七部分：运行简单的请求脚本

编写脚本很容易。打开终端并执行以下命令(当然，前提是我们的Flask服务器和Redis服务器都在运行)。

• python simple_request.py



使用Python以编程方式使用我们的Keras深度学习REST API的结果

第八部分：扩展深度学习REST API时的注意事项

如果您预期在深度学习REST API上有较长一段时间的高负载，那么您可能需要考虑一种负载平衡算法，例如循环调度，以帮助在多个GPU机器和Redis服务器之间平均分配请求。

记住，Redis是内存中的数据存储，所以我们只能在队列中存储可用内存中的尽可能多的图像。

使用float32数据类型的单个224 x 224 x 3图像将消耗602112字节的内存。

Ⅱ 基于keras框架编写的图片分类模型，训练结果识别率98%以上，为什么单张识别图片类型会出错

预测时你是怎么做的？一般来讲你的model训练好了之后，参数就已经固定好了，此时直接调用model.predict就是在用训练好的模型做预测，如果你不重新跑训练过程，参数是不会变的。或者你可以model.save下次再model.load加载也可以。至于你说有时训练acc是0，一般是在什么情况下出现的？

Ⅲ 如何用Keras自定义层

lambda层是没有参数学习的功能的，你要做的就是将每张图片上像素的最大值和最小值的函数包装进lambda层。你的输入是（batch,224,224,3），写一个在每个通道上提取空间特征的最大最小值的函数。假设为spatial_max(input)和spatial_min(input)，那么新层你可以直接写为new_layer1=Lambda(spatial_max, x : x)(input)
new_layer2=Lambda(spatial_min, x : x)(input)

Ⅳ 求助keras的imagedatagenerator使用

一个稍微讲究一点的办法是，利用在大规模数据集上预训练好的网络。这样的网络在多数的计算机视觉问题上都能取得不错的特征，利用这样的特征可以让我们获得更高的准确率。
我们将使用vgg-16网络，该网络在ImageNet数据集上进行训练，这个模型我们之前提到过了。因为ImageNet数据集包含多种“猫”类和多种“狗”类，这个模型已经能够学习与我们这个数据集相关的特征了。事实上，简单的记录原来网络的输出而不用bottleneck特征就已经足够把我们的问题解决的不错了。不过我们这里讲的方法对其他的类似问题有更好的推广性，包括在ImageNet中没有出现的类别的分类问题。
VGG-16的网络结构如下：

我们的方法是这样的，我们将利用网络的卷积层部分，把全连接以上的部分抛掉。然后在我们的训练集和测试集上跑一遍，将得到的输出（即“bottleneck feature”，网络在全连接之前的最后一层激活的feature map）记录在两个numpy array里。然后我们基于记录下来的特征训练一个全连接网络。
我们将这些特征保存为离线形式，而不是将我们的全连接模型直接加到网络上并冻结之前的层参数进行训练的原因是处于计算效率的考虑。运行VGG网络的代价是非常高昂的，尤其是在CPU上运行，所以我们只想运行一次。这也是我们不进行数据提升的原因。

我们不再赘述如何搭建vgg-16网络了，这件事之前已经说过，在keras的example里也可以找到。但让我们看看如何记录bottleneck特征。
generator = datagen.flow_from_directory(
'data/train',
target_size=(150, 150),
batch_size=32,
class_mode=None, # this means our generator will only yield batches of data, no labels
shuffle=False) # our data will be in order, so all first 1000 images will be cats, then 1000 dogs
# the predict_generator method returns the output of a model, given
# a generator that yields batches of numpy data
bottleneck_features_train = model.predict_generator(generator, 2000)
# save the output as a Numpy array
np.save(open('bottleneck_features_train.npy', 'w'), bottleneck_features_train)

generator = datagen.flow_from_directory(
'data/validation',
target_size=(150, 150),
batch_size=32,
class_mode=None,
shuffle=False)
bottleneck_features_validation = model.predict_generator(generator, 800)
np.save(open('bottleneck_features_validation.npy', 'w'), bottleneck_features_validation)

记录完毕后我们可以将数据载入，用于训练我们的全连接网络：
train_data = np.load(open('bottleneck_features_train.npy'))
# the features were saved in order, so recreating the labels is easy
train_labels = np.array([0] * 1000 + [1] * 1000)

validation_data = np.load(open('bottleneck_features_validation.npy'))
validation_labels = np.array([0] * 400 + [1] * 400)

model = Sequential()
model.add(Flatten(input_shape=train_data.shape[1:]))
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='rmsprop',
loss='binary_crossentropy',
metrics=['accuracy'])

model.fit(train_data, train_labels,
nb_epoch=50, batch_size=32,
validation_data=(validation_data, validation_labels))
model.save_weights('bottleneck_fc_model.h5')

因为特征的size很小，模型在CPU上跑的也会很快，大概1s一个epoch，最后我们的准确率是90%~91%，这么好的结果多半归功于预训练的vgg网络帮助我们提取特征。

下面是代码：

[python] view plain
import os
import h5py
import numpy as np
from keras.preprocessing.image import ImageDataGenerator
from keras.models import Sequential
from keras.layers import Convolution2D, MaxPooling2D, ZeroPadding2D
from keras.layers import Activation, Dropout, Flatten, Dense

import sys
defaultencoding = 'utf-8'
if sys.getdefaultencoding() != defaultencoding:
reload(sys)
sys.setdefaultencoding(defaultencoding)

# path to the model weights file.
weights_path = '../weights/vgg16_weights.h5'
top_model_weights_path = 'bottleneck_fc_model.h5'
# dimensions of our images.
img_width, img_height = 150, 150

train_data_dir = '../data/train'
validation_data_dir = '../data/validation'
nb_train_samples = 2000
nb_validation_samples = 800
nb_epoch = 50

def save_bottlebeck_features():
datagen = ImageDataGenerator(rescale=1./255)

# build the VGG16 network
model = Sequential()
model.add(ZeroPadding2D((1, 1), input_shape=(3, img_width, img_height)))

model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(64, 3, 3, activation='relu', name='conv1_2'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))

model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(128, 3, 3, activation='relu', name='conv2_2'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))

model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(256, 3, 3, activation='relu', name='conv3_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))

model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv4_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))

model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_1'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_2'))
model.add(ZeroPadding2D((1, 1)))
model.add(Convolution2D(512, 3, 3, activation='relu', name='conv5_3'))
model.add(MaxPooling2D((2, 2), strides=(2, 2)))

# load the weights of the VGG16 networks
# (trained on ImageNet, won the ILSVRC competition in 2014)
# note: when there is a complete match between your model definition
# and your weight savefile, you can simply call model.load_weights(filename)
assert os.path.exists(weights_path), 'Model weights not found (see "weights_path" variable in script).'
f = h5py.File(weights_path)
for k in range(f.attrs['nb_layers']):
if k >= len(model.layers):
# we don't look at the last (fully-connected) layers in the savefile
break
g = f['layer_{}'.format(k)]
weights = [g['param_{}'.format(p)] for p in range(g.attrs['nb_params'])]
model.layers[k].set_weights(weights)
f.close()
print('Model loaded.')

generator = datagen.flow_from_directory(
train_data_dir,
target_size=(img_width, img_height),
batch_size=32,
class_mode=None,
shuffle=False)

print('generator ok.')
bottleneck_features_train = model.predict_generator(generator, nb_train_samples)
print('predict ok.')

np.save(open('bottleneck_features_train.npy', 'wb'), bottleneck_features_train)

generator = datagen.flow_from_directory(
validation_data_dir,
target_size=(img_width, img_height),
batch_size=32,
class_mode=None,
shuffle=False)
bottleneck_features_validation = model.predict_generator(generator, nb_validation_samples)
np.save(open('bottleneck_features_validation.npy', 'wb'), bottleneck_features_validation)
print('save_bottlebeck_features ok')

def train_top_model():
train_data = np.load(open('bottleneck_features_train.npy'))
train_labels = np.array([0] * (nb_train_samples / 2) + [1] * (nb_train_samples / 2))

validation_data = np.load(open('bottleneck_features_validation.npy'))
validation_labels = np.array([0] * (nb_validation_samples / 2) + [1] * (nb_validation_samples / 2))

model = Sequential()
model.add(Flatten(input_shape=train_data.shape[1:]))
model.add(Dense(256, activation='relu'))
model.add(Dropout(0.5))
model.add(Dense(1, activation='sigmoid'))

model.compile(optimizer='rmsprop', loss='binary_crossentropy', metrics=['accuracy'])

model.fit(train_data, train_labels,
nb_epoch=nb_epoch, batch_size=32,
validation_data=(validation_data, validation_labels))
model.save_weights(top_model_weights_path)
print('train_top_model ok')

save_bottlebeck_features()
train_top_model()

Ⅳ keras训练完模型，为什么对训练集进行evaluate和训练时的loss完全不一样白训练了吗

问题简述：
在keras框架下使用model.fit得到的训练准确率和损失表现都非常好，但是在相同的训练集上使用model.evaluate得到的准确率和损失都非常差
keras中的model.fit和model.evaluate在同样的数据集上的准确率acc和损失值loss存在巨大的差异
https://github.com/keras-team/keras/issues/6977
上面的github链接讨论了多种可能，
1.model.fit和model.evaluate的batch_size不匹配：model.fit时若指定了batch_size，在使用model.evaluate时的batch_size默认为16，而使用model.evaluate时并未设置与使用model.fit时同样的batch_size。解释大概为不同的batch_size的BatchNormalizaiton会产生不同的效果不同(当然在神经网络中存在BatchNormalization层时）
结果：匹配batch_size了也无效
2.dropout,batchnorm的影响：model.fit时的dropout层是设置dropout参数的，比如说0.5，而model.evaluate设置的dropout参数为1，keras在使用这两个function的时候会呈现两种模式

Ⅵ 如何修改keras已经训练好的模型的input shape

对于一个预测图片类别的模型来说，输入必须是一个4D tensor，比如VGG16在训练的时候输入的数据格式为（batch size,224,224,3）。在用训练好的VGG16模型预测一张图片时，只不过batch size为1。下面是VGG16预测一张图片时做的预处理，就是为输入数据多扩展一个维度。

Ⅶ Python如何图像识别

Python图片文本识别使用的工具是PIL和pytesser。因为他们使用到很多的python库文件，为了避免一个个工具的安装，建议使用pythonxy
pytesser是OCR开源项目的一个模块，在Python中导入这个模块即可将图片中的文字转换成文本。pytesser调用了tesseract。当在Python中调用pytesser模块时，pytesser又用tesseract识别图片中的文字。pytesser的使用步骤如下：

首先，安装Python2.7版本，这个版本比较稳定，建议使用这个版本。
其次，安装pythoncv。
然后，安装PIL工具，pytesser的使用需要PIL库的支持。
接着下载pytesser
最后，将pytesser解压，这个是免安装的，可以将解压后的文件cut到Python安装目录的Lib\site-packages下直接使用，比如我的安装目录是：C:\Python27\Lib\site-packages，同时把这个目录添加到环境变量之中。
完成以上步骤之后，就可以编写图片文本识别的Python脚本了。参考脚本如下：
from pytesser import *
import ImageEnhance
image = Image.open('D:\\workspace\\python\\5.png')
#使用ImageEnhance可以增强图片的识别率
enhancer = ImageEnhance.Contrast(image)
image_enhancer = enhancer.enhance(4)
print image_to_string(image_enhancer)

tesseract是谷歌的一个对图片进行识别的开源框架，免费使用，现在已经支持中文，而且识别率非常高，这里简要来个helloworld级别的认识
下载之后进行安装，不再演示。
在tesseract目录下，有个tesseract.exe文件，主要调用这个执行文件，用cmd运行到这个目录下，在这个目录下同时放置一张需要识别的图片，这里是123.jpg
然后运行:tesseract 123.jpg result
会把123.jpg自动识别并转换为txt文件到result.txt
但是此时中文识别不好
然后找到tessdata目录，把eng.traineddata替换为chi_sim.traineddata,并且把chi_sim.traineddata重命名为eng.traineddata
ok,现在中文识别基本达到90%以上了

Ⅷ keras 如何输出softmax分类结果属于某一类的概率

softmax是用于单标签输出，模型训练后，调用model.predict函数就可以输出结果为[0.5，0.4，0.1]（输出数量为最后一层隐藏层的neuron数）这样的矩阵，里面即为你所需的预测概率值，值得注意的是，softmax会限制输出的所有概率相加为1。

如果需要预测的是多个标签而不是单个标签，则需要使用sigmoid作为输出激活函数，那么输出就不再强制相加为1，可以得到每个分类的实际预测值，此时只需要设置一个致信的threshold则可以得到多个分类预测值。

每个激活函数的详细解释看这里网页链接

Ⅸ Python 用Keras训练卷积网络，提取的特征，如何保存，代码如下

可以用

np.savez('xxx.npz',train_labels=train_labels)

加载时用

np.load('xxx.npz')

Ⅹ 如何通过Python进行深度学习

作者 | Vihar Kurama

编译 | 荷叶

来源 | 云栖社区

摘要：深度学习背后的主要原因是人工智能应该从人脑中汲取灵感。本文就用一个小例子无死角的介绍一下深度学习！

人脑模拟

深度学习背后的主要原因是人工智能应该从人脑中汲取灵感。此观点引出了“神经网络”这一术语。人脑中包含数十亿个神经元，它们之间有数万个连接。很多情况下，深度学习算法和人脑相似，因为人脑和深度学习模型都拥有大量的编译单元（神经元），这些编译单元（神经元）在独立的情况下都不太智能，但是当他们相互作用时就会变得智能。

我认为人们需要了解到深度学习正在使得很多幕后的事物变得更好。深度学习已经应用于谷歌搜索和图像搜索，你可以通过它搜索像“拥抱”这样的词语以获得相应的图像。－杰弗里·辛顿

神经元

神经网络的基本构建模块是人工神经元，它模仿了人类大脑的神经元。这些神经元是简单、强大的计算单元，拥有加权输入信号并且使用激活函数产生输出信号。这些神经元分布在神经网络的几个层中。

inputs 输入 outputs 输出 weights 权值 activation 激活

人工神经网络的工作原理是什么？

深度学习由人工神经网络构成，该网络模拟了人脑中类似的网络。当数据穿过这个人工网络时，每一层都会处理这个数据的一方面，过滤掉异常值，辨认出熟悉的实体，并产生最终输出。

输入层：该层由神经元组成，这些神经元只接收输入信息并将它传递到其他层。输入层的图层数应等于数据集里的属性或要素的数量。输出层：输出层具有预测性，其主要取决于你所构建的模型类型。隐含层：隐含层处于输入层和输出层之间，以模型类型为基础。隐含层包含大量的神经元。处于隐含层的神经元会先转化输入信息，再将它们传递出去。随着网络受训练，权重得到更新，从而使其更具前瞻性。

神经元的权重

权重是指两个神经元之间的连接的强度或幅度。你如果熟悉线性回归的话，可以将输入的权重类比为我们在回归方程中用的系数。权重通常被初始化为小的随机数值，比如数值0-1。

前馈深度网络

前馈监督神经网络曾是第一个也是最成功的学习算法。该网络也可被称为深度网络、多层感知机（MLP）或简单神经网络，并且阐明了具有单一隐含层的原始架构。每个神经元通过某个权重和另一个神经元相关联。

该网络处理向前处理输入信息，激活神经元，最终产生输出值。在此网络中，这称为前向传递。

inputlayer 输入层 hidden layer 输出层 output layer 输出层

激活函数

激活函数就是求和加权的输入到神经元的输出的映射。之所以称之为激活函数或传递函数是因为它控制着激活神经元的初始值和输出信号的强度。

用数学表示为：

我们有许多激活函数，其中使用最多的是整流线性单元函数、双曲正切函数和solfPlus函数。

激活函数的速查表如下：

反向传播

在网络中，我们将预测值与预期输出值相比较，并使用函数计算其误差。然后，这个误差会传回这个网络，每次传回一个层，权重也会根绝其导致的误差值进行更新。这个聪明的数学法是反向传播算法。这个步骤会在训练数据的所有样本中反复进行，整个训练数据集的网络更新一轮称为一个时期。一个网络可受训练数十、数百或数千个时期。

prediction error 预测误差

代价函数和梯度下降

代价函数度量了神经网络对给定的训练输入和预期输出“有多好”。该函数可能取决于权重、偏差等属性。

代价函数是单值的，并不是一个向量，因为它从整体上评估神经网络的性能。在运用梯度下降最优算法时，权重在每个时期后都会得到增量式地更新。

兼容代价函数

用数学表述为差值平方和：

target 目标值 output 输出值

权重更新的大小和方向是由在代价梯度的反向上采取步骤计算出的。

其中η 是学习率

其中Δw是包含每个权重系数w的权重更新的向量，其计算方式如下：

target 目标值 output 输出值

图表中会考虑到单系数的代价函数

initial weight 初始权重 gradient 梯度 global cost minimum 代价极小值

在导数达到最小误差值之前，我们会一直计算梯度下降，并且每个步骤都会取决于斜率（梯度）的陡度。

多层感知器（前向传播）

这类网络由多层神经元组成，通常这些神经元以前馈方式（向前传播）相互连接。一层中的每个神经元可以直接连接后续层的神经元。在许多应用中，这些网络的单元会采用S型函数或整流线性单元（整流线性激活）函数作为激活函数。

现在想想看要找出处理次数这个问题，给定的账户和家庭成员作为输入

要解决这个问题，首先，我们需要先创建一个前向传播神经网络。我们的输入层将是家庭成员和账户的数量，隐含层数为1， 输出层将是处理次数。

将图中输入层到输出层的给定权重作为输入：家庭成员数为2、账户数为3。

现在将通过以下步骤使用前向传播来计算隐含层（i，j）和输出层（k）的值。

步骤：

1， 乘法－添加方法。

2， 点积（输入＊权重）。

3，一次一个数据点的前向传播。

4， 输出是该数据点的预测。

i的值将从相连接的神经元所对应的输入值和权重中计算出来。

i = (2 * 1) + (3* 1) → i = 5

同样地，j = (2 * -1) + (3 * 1) → j =1

K = (5 * 2) + (1* -1) → k = 9

Python中的多层感知器问题的解决

激活函数的使用

为了使神经网络达到其最大预测能力，我们需要在隐含层应用一个激活函数，以捕捉非线性。我们通过将值代入方程式的方式来在输入层和输出层应用激活函数。

这里我们使用整流线性激活（ReLU）:

用Keras开发第一个神经网络

关于Keras：

Keras是一个高级神经网络的应用程序编程接口，由Python编写，能够搭建在TensorFlow,CNTK,或Theano上。

使用PIP在设备上安装Keras,并且运行下列指令。

在keras执行深度学习程序的步骤

1，加载数据；

2，创建模型；

3，编译模型；

4，拟合模型；

5，评估模型。

开发Keras模型

全连接层用Dense表示。我们可以指定层中神经元的数量作为第一参数，指定初始化方法为第二参数，即初始化参数，并且用激活参数确定激活函数。既然模型已经创建，我们就可以编译它。我们在底层库（也称为后端）用高效数字库编译模型，底层库可以用Theano或TensorFlow。目前为止，我们已经完成了创建模型和编译模型，为进行有效计算做好了准备。现在可以在PIMA数据上运行模型了。我们可以在模型上调用拟合函数f（），以在数据上训练或拟合模型。

我们先从KERAS中的程序开始，

神经网络一直训练到150个时期，并返回精确值。