搭建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(模板詳細版）