Presentamos el Modelo PyTorch usando Flask y Heroku

Cree e implemente su primera aplicación de aprendizaje profundo. En este tutorial de PyTorch, aprenderá a implementar un modelo de PyTorch usando Flask y Heroku. Cree una aplicación Flask simple utilizando la API REST que devuelve el resultado como datos json e impleméntelo en Heroku. Como ejemplo de la aplicación PytTorch, puede clasificar números, dibujar sus propios números al final y hacer predicciones en la aplicación de ejecución en vivo.

Configuración

Cree un proyecto en un entorno virtual (los comandos pueden variar ligeramente en Windows).

$ mkdir pytorch-deploy
$ cd pytorch-deploy
$ python3 -m venv venv

Activarlo

$ . venv/bin/activate

O para Windows

venv\Scripts\activate

Instalar Flask y PyTorch

$ pip install Flask
$ pip install torch torchvision

Crea una aplicación

Cree una nueva aplicación de directorio e inserte lo siguiente dentro de este archivo main.py :

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    if request.method == 'POST':
        return jsonify({'test': 'test_result'})

Solo se requiere un punto final @app.route('/predict'). Aquí tomamos una imagen, la predecimos con un modelo de PyTorch y devolvemos el resultado como datos json. Por ahora, los jsonifymétodos de Flask solo devuelven datos json ficticios.

Ejecuta y prueba la aplicación

Correr

$ export FLASK_APP=app/main.py
$ export FLASK_ENV=development
$ flask run

Cree una carpeta de prueba test e insértela dentro del archivo test.py.

import requests 

resp = requests.post("http://localhost:5000/predict")

print(resp.text)

Ejecute el archivo test.py en la segunda terminal (es posible que deba instalar la solicitud :)pip install requests . Si todo funciona correctamente, esto generará datos json ficticios {'test': 'test_result'}.

Entrena y guarda tu modelo.

Aquí se obtiene el código de mi PyTorch supuesto que . Esta es una red neuronal de retroalimentación simple entrenada en el conjunto de datos MNIST y utilizada para clasificar números. El único cambio que hacemos es agregar otra transformación de conjunto de datos. Esto se debe a que queremos mostrar que la aplicación necesita la misma conversión. Por lo tanto, primero use esta transformación para aplicarla a su conjunto de datos.

transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,),(0.3081,))])

# MNIST dataset 
train_dataset = torchvision.datasets.MNIST(root='./data', 
                                           train=True, 
                                           transform=transform,  
                                           download=True)

test_dataset = torchvision.datasets.MNIST(root='./data', 
                                          train=False, 
                                          transform=transform)

Esto es solo una normalización con la media global y la desviación estándar del conjunto de datos MNIST.

Inserte esta línea al final del archivo para guardar el modelo después del entrenamiento.

torch.save(model.state_dict(), "mnist_ffn.pth")

Luego ejecute este archivo. Esto entrena el modelo, lo imprime con alta precisión y guarda el modelo en el archivo especificado. Obtén este archivo y cópialo en tu carpeta de aplicaciones .

Crear una función de utilidad PyTorch

Cree un nuevo archivo torch_utils.py en la carpeta de la aplicación . Aquí hacemos tres cosas:

  • Cargar el modelo
  • Preprocese la imagen y conviértala en un tensor de antorcha
  • Haz una predicción

Cargar el modelo

Consulte también este curso de PyTorch para guardar y cargar . Cree el mismo modelo que el archivo original, cargue el diccionario de estado y configúrelo en modo. Aquí solo se utiliza la versión de la CPU. De lo contrario, el paquete es demasiado grande para Heroku. Por lo tanto, si se entrenó en la GPU, asegúrese de que se cargue correctamente. También puede encontrar este código en el tutorial de guardar / cargar. Puede eliminar todas las llamadas de su código. No te preocupes. La CPU funciona lo suficientemente rápido como para inferir el modelo en esta aplicación.eval.to(device)

import io
import torch 
import torch.nn as nn 
import torchvision.transforms as transforms 
from PIL import Image


class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(NeuralNet, self).__init__()
        self.input_size = input_size
        self.l1 = nn.Linear(input_size, hidden_size) 
        self.relu = nn.ReLU()
        self.l2 = nn.Linear(hidden_size, num_classes)  
    
    def forward(self, x):
        out = self.l1(x)
        out = self.relu(out)
        out = self.l2(out)
        # no activation and no softmax at the end
        return out

input_size = 784 # 28x28
hidden_size = 500 
num_classes = 10
model = NeuralNet(input_size, hidden_size, num_classes)

PATH = "mnist_ffn.pth"
model.load_state_dict(torch.load(PATH))
model.eval()

Cargar y convertir imágenes

Aquí nos aseguramos de que el tensor tenga las mismas propiedades que el conjunto de datos MNIST. Por lo tanto, aplique las mismas conversiones que el archivo original. Además, cambie el tamaño de la imagen a (28,28) y conviértala en una imagen en escala de grises. Agregue esta función al archivo torch_utils.py .

def transform_image(image_bytes):
    transform = transforms.Compose([transforms.Grayscale(num_output_channels=1),
                                    transforms.Resize((28,28)),
                                    transforms.ToTensor(),
                                    transforms.Normalize((0.1307,),(0.3081,))])

    image = Image.open(io.BytesIO(image_bytes))
    return transform(image).unsqueeze(0)

predecir

Ahora use el mismo código que el archivo original para predecir la imagen y devolver la predicción con la nueva función auxiliar.

def get_prediction(image_tensor):
    images = image_tensor.reshape(-1, 28*28)
    outputs = model(images)
        # max returns (value ,index)
    _, predicted = torch.max(outputs.data, 1)
    return predicted

Poner todo junto

En el archivo main.py , predictcómo importar estas funciones auxiliares y ejecutarlas todas juntas . Además, también incluye algunas comprobaciones de errores, permitiendo solo ciertos archivos.

from flask import Flask, request, jsonify

from torch_utils import transform_image, get_prediction

app = Flask(__name__)

ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg'}
def allowed_file(filename):
    # xxx.png
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS


@app.route('/predict', methods=['POST'])
def predict():
    if request.method == 'POST':
        file = request.files.get('file')
        if file is None or file.filename == "":
            return jsonify({'error': 'no file'})
        if not allowed_file(file.filename):
            return jsonify({'error': 'format not supported'})

        try:
            img_bytes = file.read()
            tensor = transform_image(img_bytes)
            prediction = get_prediction(tensor)
            data = {'prediction': prediction.item(), 'class_name': str(prediction.item())}
            return jsonify(data)
        except:
            return jsonify({'error': 'error during prediction'})

Tenga en cuenta que en este conjunto de datos prediction, class_namees el mismo que. Normalmente, debe hacer el mapeo del índice al nombre real de la clase aquí.

Prueba el modelo

Luego, tome algunas imágenes de muestra o use un programa de pintura simple para dibujar su propia imagen. En mi caso, en el Mac se usó pincel para crear una nueva imagen de tamaño 100x100, rellenar el fondo con negro, se dibujó números en blanco. Guarde como png o jpg y copie el archivo a la carpeta de prueba . Luego, incluye esta imagen en tu solicitud de publicación. Por ejemplo, Eight.Png la imagen que utilice usted.

import requests 

resp = requests.post("http://localhost:5000/predict", files={'file': open('eight.png', 'rb')})

print(resp.text)

Esto debe imprimirse {'prediction': 8, 'class_name': 8}. enhorabuena! Ahora tiene una aplicación web PyTorch en ejecución. Como paso final, implemente en Heroku

Implementar en Heroku

La producción en el medio ambiente , el servidor Web apropiado es tan necesario, Gunicorn instalar que .

$ pip install gunicorn

Todos los siguientes archivos deben agregarse al directorio base. Primero, cree un archivo wsgi.py e inserte esta línea

from app.main import app

Procfile cree un, esto e inserte el.

web: gunicorn wsgi:app

Cambie el nombre de la ruta para basarla en el paquete de su aplicación .

# in the main.py file:
from app.torch_utils import get_prediction, transform_image

# in the torch_utils.py file
PATH = "app/mnist_ffn.pth"

Cree runtime.txt e inserte la versión de Python que está utilizando .

python-3.8.3

Asegúrese de estar nuevamente en la carpeta raíz del paquete. Luego, todos los paquetes con los siguientes requisitos.txt y agregarlo al archivo pip freeze.

$ pip freeze > requirements.txt

Solo está disponible la versión de CPU, así que modifique el archivo de esta manera para usar la versión de PyTorch solo para CPU. Puede obtener la versión del comando solo para CPU en esta guía de instalación de PyTorch . Seleccione Linux, pip y no CUDA. Puede agregar el comando de descarga como la primera línea en el archivo requirements.txt .

-f https://download.pytorch.org/whl/torch_stable.html
torch==1.6.0+cpu
torchvision==0.7.0+cpu

El .gitignore te agrega . Esta versión de Python es, GitHub se puede obtener de usted . Además, agregue una carpeta de prueba para que la primera línea del archivo contenga la siguiente línea:

test/

# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
...

Crea una aplicación Heroku. Para hacer esto, necesita instalar Heroku CLI. Aquí usted puede conseguir que . Inicie sesión y cree una nueva aplicación con el nombre que desee.

$ heroku login -i
$ heroku create your-app-name

Pruebe su aplicación localmente.

$ heroku local

Luego agregue un repositorio de git, confirme todos los archivos y envíelos a Heroku.

git init
heroku git:remote -a your-app-name
git add .
git commit -m "initial commit"
git push heroku master

Esto implementará su aplicación en Heroku y le mostrará un enlace a la aplicación que se ejecuta en vivo. Luego use esta URL en su archivo test.py de la siguiente manera:

import requests

resp = requests.post("https://your-app-name.herokuapp.com/predict",
                     files={"file": open('eight.png','rb')})

print(resp.text)

enhorabuena! Ahora tiene una aplicación de ejecución en vivo con un modelo de PyTorch que puede realizar la clasificación de números. Tenga en cuenta que si solo usa el nivel gratuito, Heroku deberá activar su aplicación primero, por lo que puede tomar unos segundos enviar su primera solicitud.

¿Has disfrutado de este tutorial?

Enlace: https://www.python-engineer.com/posts/pytorch-model-deployment-with-flask/

#pytorch  #flask #heroku 

What is GEEK

Buddha Community

Presentamos el Modelo PyTorch usando Flask y Heroku

Presentamos el Modelo PyTorch usando Flask y Heroku

Cree e implemente su primera aplicación de aprendizaje profundo. En este tutorial de PyTorch, aprenderá a implementar un modelo de PyTorch usando Flask y Heroku. Cree una aplicación Flask simple utilizando la API REST que devuelve el resultado como datos json e impleméntelo en Heroku. Como ejemplo de la aplicación PytTorch, puede clasificar números, dibujar sus propios números al final y hacer predicciones en la aplicación de ejecución en vivo.

Configuración

Cree un proyecto en un entorno virtual (los comandos pueden variar ligeramente en Windows).

$ mkdir pytorch-deploy
$ cd pytorch-deploy
$ python3 -m venv venv

Activarlo

$ . venv/bin/activate

O para Windows

venv\Scripts\activate

Instalar Flask y PyTorch

$ pip install Flask
$ pip install torch torchvision

Crea una aplicación

Cree una nueva aplicación de directorio e inserte lo siguiente dentro de este archivo main.py :

from flask import Flask, jsonify
app = Flask(__name__)

@app.route('/predict', methods=['POST'])
def predict():
    if request.method == 'POST':
        return jsonify({'test': 'test_result'})

Solo se requiere un punto final @app.route('/predict'). Aquí tomamos una imagen, la predecimos con un modelo de PyTorch y devolvemos el resultado como datos json. Por ahora, los jsonifymétodos de Flask solo devuelven datos json ficticios.

Ejecuta y prueba la aplicación

Correr

$ export FLASK_APP=app/main.py
$ export FLASK_ENV=development
$ flask run

Cree una carpeta de prueba test e insértela dentro del archivo test.py.

import requests 

resp = requests.post("http://localhost:5000/predict")

print(resp.text)

Ejecute el archivo test.py en la segunda terminal (es posible que deba instalar la solicitud :)pip install requests . Si todo funciona correctamente, esto generará datos json ficticios {'test': 'test_result'}.

Entrena y guarda tu modelo.

Aquí se obtiene el código de mi PyTorch supuesto que . Esta es una red neuronal de retroalimentación simple entrenada en el conjunto de datos MNIST y utilizada para clasificar números. El único cambio que hacemos es agregar otra transformación de conjunto de datos. Esto se debe a que queremos mostrar que la aplicación necesita la misma conversión. Por lo tanto, primero use esta transformación para aplicarla a su conjunto de datos.

transform = transforms.Compose([transforms.ToTensor(),
                                transforms.Normalize((0.1307,),(0.3081,))])

# MNIST dataset 
train_dataset = torchvision.datasets.MNIST(root='./data', 
                                           train=True, 
                                           transform=transform,  
                                           download=True)

test_dataset = torchvision.datasets.MNIST(root='./data', 
                                          train=False, 
                                          transform=transform)

Esto es solo una normalización con la media global y la desviación estándar del conjunto de datos MNIST.

Inserte esta línea al final del archivo para guardar el modelo después del entrenamiento.

torch.save(model.state_dict(), "mnist_ffn.pth")

Luego ejecute este archivo. Esto entrena el modelo, lo imprime con alta precisión y guarda el modelo en el archivo especificado. Obtén este archivo y cópialo en tu carpeta de aplicaciones .

Crear una función de utilidad PyTorch

Cree un nuevo archivo torch_utils.py en la carpeta de la aplicación . Aquí hacemos tres cosas:

  • Cargar el modelo
  • Preprocese la imagen y conviértala en un tensor de antorcha
  • Haz una predicción

Cargar el modelo

Consulte también este curso de PyTorch para guardar y cargar . Cree el mismo modelo que el archivo original, cargue el diccionario de estado y configúrelo en modo. Aquí solo se utiliza la versión de la CPU. De lo contrario, el paquete es demasiado grande para Heroku. Por lo tanto, si se entrenó en la GPU, asegúrese de que se cargue correctamente. También puede encontrar este código en el tutorial de guardar / cargar. Puede eliminar todas las llamadas de su código. No te preocupes. La CPU funciona lo suficientemente rápido como para inferir el modelo en esta aplicación.eval.to(device)

import io
import torch 
import torch.nn as nn 
import torchvision.transforms as transforms 
from PIL import Image


class NeuralNet(nn.Module):
    def __init__(self, input_size, hidden_size, num_classes):
        super(NeuralNet, self).__init__()
        self.input_size = input_size
        self.l1 = nn.Linear(input_size, hidden_size) 
        self.relu = nn.ReLU()
        self.l2 = nn.Linear(hidden_size, num_classes)  
    
    def forward(self, x):
        out = self.l1(x)
        out = self.relu(out)
        out = self.l2(out)
        # no activation and no softmax at the end
        return out

input_size = 784 # 28x28
hidden_size = 500 
num_classes = 10
model = NeuralNet(input_size, hidden_size, num_classes)

PATH = "mnist_ffn.pth"
model.load_state_dict(torch.load(PATH))
model.eval()

Cargar y convertir imágenes

Aquí nos aseguramos de que el tensor tenga las mismas propiedades que el conjunto de datos MNIST. Por lo tanto, aplique las mismas conversiones que el archivo original. Además, cambie el tamaño de la imagen a (28,28) y conviértala en una imagen en escala de grises. Agregue esta función al archivo torch_utils.py .

def transform_image(image_bytes):
    transform = transforms.Compose([transforms.Grayscale(num_output_channels=1),
                                    transforms.Resize((28,28)),
                                    transforms.ToTensor(),
                                    transforms.Normalize((0.1307,),(0.3081,))])

    image = Image.open(io.BytesIO(image_bytes))
    return transform(image).unsqueeze(0)

predecir

Ahora use el mismo código que el archivo original para predecir la imagen y devolver la predicción con la nueva función auxiliar.

def get_prediction(image_tensor):
    images = image_tensor.reshape(-1, 28*28)
    outputs = model(images)
        # max returns (value ,index)
    _, predicted = torch.max(outputs.data, 1)
    return predicted

Poner todo junto

En el archivo main.py , predictcómo importar estas funciones auxiliares y ejecutarlas todas juntas . Además, también incluye algunas comprobaciones de errores, permitiendo solo ciertos archivos.

from flask import Flask, request, jsonify

from torch_utils import transform_image, get_prediction

app = Flask(__name__)

ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg'}
def allowed_file(filename):
    # xxx.png
    return '.' in filename and filename.rsplit('.', 1)[1].lower() in ALLOWED_EXTENSIONS


@app.route('/predict', methods=['POST'])
def predict():
    if request.method == 'POST':
        file = request.files.get('file')
        if file is None or file.filename == "":
            return jsonify({'error': 'no file'})
        if not allowed_file(file.filename):
            return jsonify({'error': 'format not supported'})

        try:
            img_bytes = file.read()
            tensor = transform_image(img_bytes)
            prediction = get_prediction(tensor)
            data = {'prediction': prediction.item(), 'class_name': str(prediction.item())}
            return jsonify(data)
        except:
            return jsonify({'error': 'error during prediction'})

Tenga en cuenta que en este conjunto de datos prediction, class_namees el mismo que. Normalmente, debe hacer el mapeo del índice al nombre real de la clase aquí.

Prueba el modelo

Luego, tome algunas imágenes de muestra o use un programa de pintura simple para dibujar su propia imagen. En mi caso, en el Mac se usó pincel para crear una nueva imagen de tamaño 100x100, rellenar el fondo con negro, se dibujó números en blanco. Guarde como png o jpg y copie el archivo a la carpeta de prueba . Luego, incluye esta imagen en tu solicitud de publicación. Por ejemplo, Eight.Png la imagen que utilice usted.

import requests 

resp = requests.post("http://localhost:5000/predict", files={'file': open('eight.png', 'rb')})

print(resp.text)

Esto debe imprimirse {'prediction': 8, 'class_name': 8}. enhorabuena! Ahora tiene una aplicación web PyTorch en ejecución. Como paso final, implemente en Heroku

Implementar en Heroku

La producción en el medio ambiente , el servidor Web apropiado es tan necesario, Gunicorn instalar que .

$ pip install gunicorn

Todos los siguientes archivos deben agregarse al directorio base. Primero, cree un archivo wsgi.py e inserte esta línea

from app.main import app

Procfile cree un, esto e inserte el.

web: gunicorn wsgi:app

Cambie el nombre de la ruta para basarla en el paquete de su aplicación .

# in the main.py file:
from app.torch_utils import get_prediction, transform_image

# in the torch_utils.py file
PATH = "app/mnist_ffn.pth"

Cree runtime.txt e inserte la versión de Python que está utilizando .

python-3.8.3

Asegúrese de estar nuevamente en la carpeta raíz del paquete. Luego, todos los paquetes con los siguientes requisitos.txt y agregarlo al archivo pip freeze.

$ pip freeze > requirements.txt

Solo está disponible la versión de CPU, así que modifique el archivo de esta manera para usar la versión de PyTorch solo para CPU. Puede obtener la versión del comando solo para CPU en esta guía de instalación de PyTorch . Seleccione Linux, pip y no CUDA. Puede agregar el comando de descarga como la primera línea en el archivo requirements.txt .

-f https://download.pytorch.org/whl/torch_stable.html
torch==1.6.0+cpu
torchvision==0.7.0+cpu

El .gitignore te agrega . Esta versión de Python es, GitHub se puede obtener de usted . Además, agregue una carpeta de prueba para que la primera línea del archivo contenga la siguiente línea:

test/

# Byte-compiled / optimized / DLL files
__pycache__/
*.py[cod]
*$py.class
...

Crea una aplicación Heroku. Para hacer esto, necesita instalar Heroku CLI. Aquí usted puede conseguir que . Inicie sesión y cree una nueva aplicación con el nombre que desee.

$ heroku login -i
$ heroku create your-app-name

Pruebe su aplicación localmente.

$ heroku local

Luego agregue un repositorio de git, confirme todos los archivos y envíelos a Heroku.

git init
heroku git:remote -a your-app-name
git add .
git commit -m "initial commit"
git push heroku master

Esto implementará su aplicación en Heroku y le mostrará un enlace a la aplicación que se ejecuta en vivo. Luego use esta URL en su archivo test.py de la siguiente manera:

import requests

resp = requests.post("https://your-app-name.herokuapp.com/predict",
                     files={"file": open('eight.png','rb')})

print(resp.text)

enhorabuena! Ahora tiene una aplicación de ejecución en vivo con un modelo de PyTorch que puede realizar la clasificación de números. Tenga en cuenta que si solo usa el nivel gratuito, Heroku deberá activar su aplicación primero, por lo que puede tomar unos segundos enviar su primera solicitud.

¿Has disfrutado de este tutorial?

Enlace: https://www.python-engineer.com/posts/pytorch-model-deployment-with-flask/

#pytorch  #flask #heroku 

Joel Kelly

Joel Kelly

1596686520

How to Deploy PyTorch Model with Flask and Heroku

Create and Deploy your first Deep Learning app! In this PyTorch tutorial we learn how to deploy our PyTorch model with Flask and Heroku.
We create a simple Flask app with a REST API that returns the result as json data, and then we deploy it to Heroku. As an example PytTorch app we do digit classification, and at the end I show you how I draw my own digits and then predict it with our live running app.

Code:
https://github.com/python-engineer/pytorch-examples

Links:
Flask installation:
https://flask.palletsprojects.com/en/1.1.x/installation/#installation

PyTorch code:
https://github.com/python-engineer/pytorchTutorial

PyTorch:
https://pytorch.org/

Heroku:
https://www.heroku.com/

#python #pytorch #heroku #flask #deep-learning

Flask Heroku Cacheify - Automatic Flask Cache Configuration on Heroku

flask-heroku-cacheify

Automatic Flask cache configuration on Heroku.

Thinking Man Sketch

Purpose

Configuring your cache on Heroku can be a time sink. There are lots of different caching addons available on Heroku (Redis, Memcached, etc.), and among those -- lots of competitors.

flask-heroku-cacheify makes your life easy by automatically configuring your Flask application to work with whatever caching addons you've got provisioned on Heroku, allowing you to easily swap out addon providers at will, without any trouble. And, just in case you don't have any suitable Heroku addons available, flask-heroku-cacheify will default back to using local memory for your cache!

Instead of looking through documentation, testing stuff out, etc., flask-heroku-cacheify will just do everything for you :)

Install

To install flask-heroku-cacheify, use pip.

$ pip install flask-heroku-cacheify

NOTE: If you're install flask-heroku-cacheify locally, you'll need to have libmemcached-dev installed on your OS (with SASL support).

Next, modify your requirements.txt file in your home directory, and add the following to the bottom of your file:

Flask-Heroku-Cacheify>=1.3
pylibmc>=1.2.3

The above will ensure that Heroku pulls in the required C header files (in case you decide to use memcached). This step is required.

Pick an Addon

Heroku has lots of available addons you can use for caching. flask-heroku-cacheify currently works with them all! That means no matter which option you choose, your cache will work out of the box, guaranteed!

Below is a list of the addons you can install to get started, you should have at least one of these activated on your Heroku app -- otherwise, your cache will be in 'local memory' only, and won't be very useful.

NOTE My favorite providers are MemCachier (for memcache), and openredis for redis. Both are equally awesome as cache providers. If you're in need of a stable cache provider for large applications, I'd recommend RedisGreen -- they use dedicated EC2 instances (which greatly improves your server power) and have an excellent interface.

Usage

Using flask-heroku-cacheify is super easy! In your app.py (or wherever you define your Flask application), add the following:

from flask_cacheify import init_cacheify

app = Flask(__name__)
cache = init_cacheify(app)

Once you've got your cache global defined, you can use it anywhere in your Flask app:

>>> from app import cache
>>> cache.set('hi', 'there', 30)
>>> cache.get('hi')
'there'

How does this work? In the background, flask-heroku-cacheify is really just automatically configuring the popular Flask-Cache extension! This means, you can basically skip down to this part of their documentation, and begin using all the methods listed there, without worrying about setting up your caches! Neat, right?

For more information and examples of how to use your cache, don't forget to read the Flask-Cache documentation.

Changelog

1.6.1: 12-20-2017

- Update docs
- Updating code to support latest Flask release

1.6.0: 04-22-2017

- Upgrading to work with latest FLask release (thanks @mattstibbs).

v1.5: 06-20-2015

- Removing MyRedis addon support -- the addon has been shut down.

v1.4: 04-04-2015

- Fixing typos in README.
- Adding Python 3 compatibility.

v1.3: 05-31-2012

- Fixing bug with memcachier support (thanks @eriktaubeneck)!

v1.2: 04-18-2013

- Adding proper documentation.

v1.1: 04-18-2013

- Adding support for MyRedis.
- Adding support for Redis Cloud.
- Adding support for Redis To Go.
- Adding support for openredis.

v1.0: 04-18-2013

- Fixing bug with RedisGreen support.

v0.9: 04-18-2013

- First *real* release! Supports MemCachier and RedisGreen!

v0.8: 04-18-2013

- Pushing eigth release to PyPI (don't use this still!).

v0.7: 04-18-2013

- Pushing seventh release to PyPI (don't use this still!).

v0.6: 04-18-2013

- Pushing sixth release to PyPI (don't use this still!).

v0.5: 04-18-2013

- Pushing fifth release to PyPI (don't use this still!).

v0.4: 04-18-2013

- Pushing fourth release to PyPI (don't use this still!).

v0.3: 04-18-2013

- Pushing third release to PyPI (don't use this still!).

v0.2: 04-18-2013

- Pushing second release to PyPI (don't use this still!).

v0.1: 04-18-2013

- Pushing first release to PyPI (don't use this yet!).

v0.0: 04-14-2013

- Started work >:)

Download Details:
Author: rdegges
Source Code: https://github.com/rdegges/flask-heroku-cacheify
License:  Unlicense License

#flask #heroku #python 

Steve  Kunde

Steve Kunde

1592723950

Download a Flask template ready to plug in your business logic

Let’s assume after lots of hard work you have your machine learning model running the way it should. This model could be one which responds to a user’s request to classify a tweet sentiment or identify objects in an image or recommend a product or some other algorithm unique to your needs. You would now like to quickly deploy this model. The article below is an explanation of the template that I have created to get you up and running quickly.

#flask-framework #flask-python-appengine #flask-sqlalchemy #marshmallow #flask #programming

Web development with python and flask: part 3

In this part of the series, we will be taking a look at the HTTP protocol, request/response objects, their application in flask, properties, and their related methods. We will take steps to import it from the flask module, use its properties, and look at some of its related usages

Web applications implement one of the internet data and message exchange architectures that is based on HTTP protocol. The HTTP protocol is just one of the many application layers of TCP/IP. The TCP/IP(Transmission Control Protocol/Internet Protocol) is used as a standard for transmitting data over networks. In simple terms, HTTP has rules, properties, and methods that implement the transmission of messages in form of hyperlinks over the communication structures enforced by the TCP/IP.

.You must know that the internet is based on connected physical computational devices over either copper wires, fiber optical cables, wireless, and other media to form data transmission and retrieval systems across the globe. Trust me, that is a whole career field in itself and we are not interested in its elaborate ramblings in this post.

#flask #web developemnt #flask #flask requests #webdevelopment