搭建flaskweb服务器

① 如何用python搭建一个网站

Python搭建网站，利用现成的框架还是挺简单的。在这滑咐里举一个例子-利用Flask搭建一个网站。

Flask

Flask是一个使用Python编写的轻量级Web应用框架。其WSGI工具箱采用Werkzeug，模板引擎则使用Jinja2。Flask创建一个应用很简单，只需要一行代码就可以创建一个应用。一个最小的应用看起来像这样:

直接执行pythonhello.py，就可以看到页面就可以访问了，这只是官方给出的一个示例，方便学习。

应用初始化

所有Flask程序都必须创建一个程序实例。Web服务器使用一种名为Web服务器网关接口（WebServerGatewayInterface，WSGI）的协议，把接收自客户端的所有请求都转交给这个对象处理。程序实例是Flask类的对象，经常使用下述代码创建：

Flask类的构造函数只有一个必须指定的参数，即程序主模块或包的名字。在大多数程序中，Python的__name__变量就是所需的值。

路由和视图函数

客户端（例如Web浏览器）把请求发送给Web服务器，Web服务器再把请求发送给Flask程序实例。程备余序实例需要知道对每个URL请求运行哪些代码，所以保存了一个URL到Python函数的映射关系。处理URL和函数之间关系的程序称为路由。在Flask程序中定义仿让滚路由的最简便方式，是使用程序实例提供的app.route修饰器，把修饰的函数注册为路由。下面的例子说明了如何使用这个修饰器声明路由：

index()函数注册为程序根地址的处理程序。如果部署程序的服务器域名为，在浏览器中访问p>

启动服务器

程序实例用run方法启动Flask集成的开发Web服务器：

__name__=='__main__'是Python的惯常用法，在这里确保直接执行这个脚本时才启动开发Web服务器。如果这个脚本由其他脚本引入，程序假定父级脚本会启动不同的服务器，因此不会执行app.run()。服务器启动后，会进入轮询，等待并处理请求。轮询会一直运行，直到程序停止，比如按Ctrl-C键。

Flask开发的网站实例

本示例中网站的结构如下

启动服务器界面

访问WEB页面

整个是利用Flask自己搭建的一个WEB页面，数据库试过mysql和mongodb都可以正常访问。整体感觉Flask的学习成本会比Django低，而且也比Django更灵活。

② python flask 怎么组织程序

1.初始化

所有的flask程序都必须创建一个程序实例

web服务器使用wsgi接口协议，把接收客户端的请求都转发给这个程序实例来进行处理。这个程序实例就是flask对象

from flask import Flask
app = Flask(__name__)
#__name__决定程序的根目录，以便以后能找到相对于程序根目录的资源文件位置

2.路由和视图函数

程序实例需要知道接收请求后，需要知道url请求应该运行哪些代码。所以保存了一个url和python函数的映射关系；这个映射关系就叫做路由

flask程序中路由的写法：

2.1#使用app.route装饰器，把修饰的函数注册为路由。例如

@app.route('/')def index(): return "<h1>Hello World</h1>"

#函数的名字不是必须写index的,只是和装饰器关联的时候写的函数名而已

#把index函数注册为程序根路径的处理程序。函数的返回值称为响应，是客户端接收的内容。

像index这样的函数称为试图函数，试图函数返回的响应可以是包含html的简单字符串，也可以是复杂的东西

2.2#可变url部分映射，使用特定的装饰器语法就可以

@app.route('/user/<name>')def user(name): return "<h1>hello %s</h1>"%(name)

装饰器中的<name>指定可变内容为name，name对user(name)函数中的传递参数，这2个部分内容必须一致

调用试图函数时候，flask会自动的将动态部分作为参数传入参数，这个函数中，参数用于生成个人的欢迎信息

#备注：路由中的动态部分默认使用字符串类型，可以使用int,float,path来定义；例如<int:id>;path类型也是字符串，但不把斜线视作分隔符，而将其当做动态片段的一部分

3.启动服务器

调用程序实例app的run方法启动flask集成开发的web服务器

if __name__ == "__main__":
app.run(debug=True)

debug=True代表的是调试模式，这个flask自带的run方法开启的服务器不适合在生产中使用，此处只用来测试

4.一个完整的Flask程序

啥也不说，先上例子hello.py

③ 阿里云服务器部署flask项目

当我们执行下面的hello.py时，使用的flask自带的服务器，完成了web服务的启动。在生产环境中，flask自带的服务器，无法满足性能要求，我们这里采用Gunicorn做wsgi容器，来部署flask程序。Gunicorn（绿色独角兽）是一个Python WSGI的HTTP服务器。从Ruby的独角兽（Unicorn ）项目移植。该Gunicorn服务器与各种Web框架兼容，实现非常简单，轻量级的资源消耗。Gunicorn直接用命令启动，不需要编写配置文件，相对uWSGI要容易很多。

区分几个概念 ：

WSGI：全称是Web Server Gateway Interface（web服务器网关接口），它是一种规范，它是web服务器和web应用程序之间的接口。它的作用就像是桥梁，连接在web服务器和web应用框架之间。

uwsgi：是一种传输协议，用于定义传输信息的类型。

uWSGI：是实现了uwsgi协议WSGI的web服务器。

我们的部署方式： nginx + gunicorn + flask

web开发中，部署方式大致类似。简单来说，前端代理使用Nginx主要是为了实现分流、转发、负载均衡，以及分担服务器的压力。Nginx部署简单，内存消耗少，成本低。Nginx既可以做正向代理，也可以做反向代理。

正向代理 ：请求经过代理服务器从局域网发出，然后到达互联网上的服务器。

特点 ：服务端并不知道真正的客户端是谁。

反向代理 ：请求从互联网发出，先进入代理服务器，再转发给局域网内的服务器。

特点 ：客户端并不知道真正的服务端是谁。

区别 ：正向代理的对象是客户端。反向代理的对象是服务端。

查看命令行选项 ： 安装gunicorn成功后，通过命令行的方式可以查看gunicorn的使用信息。

直接运行 ：

指定进程和端口号 ： -w: 表示进程(worker)。 -b：表示绑定ip地址和端口号(bind)。--access-logfile：表示指定log文件的路径

作为守护进程后台运行 ：

阿里云服务器默认安装到 /user/sbin/ 目录，进入目录，启动 ngnix:

Ubuntu 上配置 Nginx 也是很简单，不要去改动默认的 nginx.conf 只需要将/etc/nginx/sites-available/default文件替换掉就可以了。
新建一个 default 文件，添加以下内容:

修改完成后重启nginx即可。

Ubuntu 上配置 Nginx 另一种方法，cd 到 /etc/nginx/conf.d 文件夹，新建 xxx.conf 文件(xxx 可以是项目名，只要是 .conf 文件即可)，写入以下内容：

需要监听 https 请求时，写入以下内容：

④ 干货分享!Python三大web框架简单介绍

1、Django

Django是一个开放源代码的Web应用框架，由Python写成。采用了MTV的框架模式，即模型M，模板T和视图V。它最初是被开发来用于管理劳伦斯出版集团旗下的一些以新闻内容为主的网站的，即是CMS(内容管理系统)软件。

2、Flask

Flask是一个使用 Python 编写的轻量级 Web 应用框架。其 WSGI 工具箱采用 Werkzeug ，模板引擎则使用 Jinja2 。Flask使用 BSD 授权。

Flask也被称为 “microframework” ，因为它使用简单的核心，用 extension 增加其他功能。Flask没有默认使用的数据库、窗体验证工具。

Flask 很轻，花很少的成本就能够开发一个简单的网站。非常适合初学者学习。Flask 框架学会以后，可以考虑学习插件的使用。例如使用 WTForm + Flask-WTForm 来验证表单数据，用 SQLAlchemy + Flask-SQLAlchemy 来对你的数据库进行控制。

3、Tornado

Tornado是一种 Web 服务器软件的开源版本。Tornado 和现在的主流 Web 服务器框架(包括大多数 Python 的框架)有着明显的区别：它是非阻塞式服务器，而且速度相当快。

得利于其 非阻塞的方式和对epoll的运用，Tornado 每秒可以处理数以千计的连接，因此 Tornado 是实时 Web 服务的一个 理想框架。

关于干货分享!Python三大web框架简单介绍，环球青藤小编就和大家分享到这里了，学习是永无止境的，学习一项技能更是受益终身，所以，只要肯努力学，什么时候开始都不晚。如果您还想继续了解关于python编程的学习方法及素材等内容，可以点击本站其他文章学习。

⑤ 怎么使用python flask搭建静态服务器

Frozen-Flask freezes aFlaskapplication into a set of static files. The result can be hosted without any server-side software other than a traditional web server.

Note:This project used to be called Flask-Static.

Installation

Install the extension with one of the following commands:

$ easy_install Frozen-Flask

or alternatively if you have pip installed:

$ pip install Frozen-Flask

or you can get thesource code from github.

Context

This documentation assumes that you already have a workingFlaskapplication. You can run it and test it with the development server:

from myapplication import appapp.run(debug=True)

Frozen-Flask is only about deployment: instead of installing Python, a WGSI server and Flask on your server, you can use Frozen-Flask tofreezeyour application and only have static HTML files on your server.

Getting started

Create aFreezerinstance with yourappobject and call itsfreeze()method. Put that in afreeze.pyscript (or call it whatever you like):

from flask_frozen import Freezerfrom myapplication import appfreezer = Freezer(app)if __name__ == '__main__':
freezer.freeze()

This will create abuilddirectory next to your application’, with your application’s content frozen into static files.

Note

Frozen-Flask considers it “owns” its build directory. By default, it willsilently overwritefiles in that directory, andremovethose it did not create.

Theconfigurationallows you to change the destination directory, or control what files are removed if at all.

This build will most likely be partial since Frozen-Flask can only guess so much about your application.

Finding URLs

Frozen-Flask works by simulating requests at the WSGI level and writing the responses to aptly named files. So it needs to find out which URLs exist in your application.

The following URLs can be found automatically:

• Static files handled by Flask for your application or any of itsblueprints.

• Views with no variable parts in the URL, if they accept theGETmethod.

• New in version 0.6:Results of calls toflask.url_for()made by your application in the request for another URL. In other words, if you useurl_for()to create links in your application, these links will be “followed”.

This means that if your application has an index page at the URL/(without parameters) and every other page can be found from there by recursively following links built withurl_for(), then Frozen-Flask can discover all URLs automatically and you’re done.

Otherwise, you may need to write URL generators.

URL generators

Let’s say that your application looks like this:

• @app.route('/')def procts_list():


• return render_template('index.html', procts=models.Proct.all())@app.route('/proct_<int:proct_id>/')def proct_details():


• proct = models.Proct.get_or_404(id=proct_id)


• return render_template('proct.html', proct=proct)



If, for some reason, some procts pages are not linked from another page (or these links are not built byurl_for()), Frozen-Flask will not find them.

To tell Frozen-Flask about them, write an URL generator and put it after creating yourFreezerinstance and before callingfreeze():

• @freezer.register_generatordef proct_details():


• for proct in models.Proct.all():


• yield {'proct_id': proct.id}



Frozen-Flask will find the URL by callingurl_for(endpoint,**values)whereendpointis the name of the generator function andvaluesis each dict yielded by the function.

You can specify a different endpoint by yielding a(endpoint,values)tuple instead of justvalues, or you can by-passurl_forand simply yield URLs as strings.

Also, generator functions do not have to bePython generatorsusingyield, they can be any callable and return any iterable object.

All of these are thus equivalent:

• @freezer.register_generatordef proct_details(): # endpoint defaults to the function name


• # `values` dicts


• yield {'proct_id': '1'}


• yield {'proct_id': '2'}@freezer.register_generatordef proct_url_generator(): # Some other function name


• # `(endpoint, values)` tuples


• yield 'proct_details', {'proct_id': '1'}


• yield 'proct_details', {'proct_id': '2'}@freezer.register_generatordef proct_url_generator():


• # URLs as strings


• yield '/proct_1/'


• yield '/proct_2/'@freezer.register_generatordef proct_url_generator():


• # Return a list. (Any iterable type will do.)


• return [


• '/proct_1/',


• # Mixing forms works too.


• ('proct_details', {'proct_id': '2'}),


• ]



Generating the same URL more than once is okay, Frozen-Flask will build it only once. Having different functions with the same name is generally a bad practice, but still work here as they are only used by their decorators. In practice you will probably have a mole for your views and another one for the freezer and URL generators, so having the same name is not a problem.

Testing URL generators

The idea behind Frozen-Flask is that you canuse Flask directlyto develop and test your application. However, it is also useful to test yourURL generatorsand see that nothing is missing, before deploying to a proction server.

You can open the newly generated static HTML files in a web browser, but links probably won’t work. TheFREEZER_RELATIVE_URLSconfigurationcan fix this, but adds a visibleindex.htmlto the links. Alternatively, use therun()method to start an HTTP server on the build result, so you can check that everything is fine before uploading:

• if __name__ == '__main__':


• freezer.run(debug=True)



Freezer.run()will freeze your application before serving and when the reloader kicks in. But the reloader only watches Python files, not templates or static files. Because of that, you probably want to useFreezer.run()only for testing the URL generators. For everything else use the usualapp.run().

Flask-Scriptmay come in handy here.

Controlling What Is Followed

Frozen-Flask follows links automatically or with some help from URL generators. If you want to control what gets followed, then URL generators should be used with the Freezer’swith_no_argument_rulesandlog_url_forflags. Disabling these flags will force Frozen-Flask to use URL generators only. The combination of these three elements determines how much Frozen-Flask will follow.

Configuration

Frozen-Flask can be configured using Flask’sconfiguration system. The following configuration values are accepted:

• FREEZER_BASE_URL

• Full URL your application is supposed to be installed at. This affects the output offlask.url_for()for absolute URLs (with_external=True) or if your application is not at the root of its domain name. Defaults to'http://localhost/'.

• FREEZER_RELATIVE_URLS

• If set toTrue, Frozen-Flask will patch the Jinja environment so thaturl_for()returns relative URLs. Defaults toFalse. Python code is not affected unless you userelative_url_for()explicitly. This enables the frozen site to be browsed without a web server (opening the files directly in a browser) but appends a visibleindex.htmlto URLs that would otherwise end with/.

  New in version 0.10.

• FREEZER_DEFAULT_MIMETYPE

• The MIME type that is assumed when it can not be determined from the filename extension. If you’re using the Apache web server, this should match theDefaultTypevalue of Apache’s configuration. Defaults toapplication/octet-stream.

  New in version 0.7.

• FREEZER_IGNORE_MIMETYPE_WARNINGS

• If set toTrue, Frozen-Flask won’t show warnings if the MIME type returned from the server doesn’t match the MIME type derived from the filename extension. Defaults toFalse.

  New in version 0.8.

• FREEZER_DESTINATION

• Path to the directory where to put the generated static site. If relative, interpreted as relative to the application root, next to . Defaults tobuild.

• FREEZER_REMOVE_EXTRA_FILES

• If set toTrue(the default), Frozen-Flask will remove files in the destination directory that were not built ring the current freeze. This is intended to clean up files generated by a previous call toFreezer.freeze()that are no longer needed. Setting this toFalseis equivalent to settingFREEZER_DESTINATION_IGNOREto['*'].

  New in version 0.5.

• FREEZER_DESTINATION_IGNORE

• A list (defaults empty) offnmatchpatterns. Files or directories in the destination that match any of the patterns are not removed, even ifFREEZER_REMOVE_EXTRA_FILESis true. As in.gitignorefiles, patterns apply to the whole path if they contain a slash/, to each slash-separated part otherwise. For example, this could be set to['.git

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

搭建深度学习后台服务器

我们的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字节的内存。

⑦ python轻量框架--Flask(入门教程）

1.建立： F:Pythonflask文件夹路径
2.安装virtualenv,在此路径下打开命令行窗口输入：

3.新建一个目录，并在里边创建virtualenv环境，在DOS下

如图：

这时你创建的myproject文件夹里面就多了一个venv文件夹：

4.激活虚拟环境

现在命令行前面多了个(venv)表示你在venv环境内

5.在virtualenv里安装Flask

完成。如图：

6.验证是否安装，你可以进入 Python 解释器，尝试导入 Flask：

如果没有报错，那么就安装成功了~如图：

1.在myproject文件夹下打开命令行：

cd app #进入app文件夹
mkdir static
mkdir templates

我们的应用程序包是放置于 app 文件夹中。子文件夹 static 是我们存放静态文件像图片，JS文件以及样式文件。子文件夹 templates 显然是存放模板文件。

2.为我们的 app 包(文件 app/ init .py )创建一个简单的初始化脚本:

上面的脚本简单地创建应用对象，接着导入视图模块，该模块我们暂未编写。

视图是响应来自网页浏览器的请求的处理器。在 Flask 中，视图是编写成 Python 函数。每一个视图函数是映射到一个或多个请求的 URL。

3.让我们编写第一个视图函数(文件 app/views.py ):

其实这个视图是非常简单，它只是返回一个字符串，在客户端的网页浏览器上显示。两个 route 装饰器创建了从网址 / 以及 /index 到这个函数的映射。

4.能够完整工作的 Web 应用程序的最后一步是创建一个脚本，启动我们的应用程序的开发 Web 服务器。让我们称这个脚本为 run.py，并把它置于根目录:

这个脚本简单地从我们的 app 包中导入 app 变量并且调用它的 run 方法来启动服务器。请记住 app 变量中含有我们在之前创建的 Flask 实例。

5.要启动应用程序，您只需运行此脚本（run.py）

如图：

6.在服务器初始化后，它将会监听 5000 端口等待着连接。现在打开你的网页浏览器输入如下 URL:

另外你也可以使用这个 URL:

你看清楚了路由映射是如何工作的吗？第一个 URL 映射到 /，而第二个 URL 映射到 /index。这两个路由都关联到我们的视图函数，因此它们的作用是一样的。如果你输入其它的网址，你将会获得一个错误，因为只有这两个 URL 映射到视图函数。

你可以通过 Ctrl-C 来终止服务器

入门就到这里，比较简单的。
下一章：
python轻量框架--Flask(模板详细版）