1641005280
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.
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
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 jsonify
métodos de Flask solo devuelven datos json ficticios.
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'}
.
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 .
Cree un nuevo archivo torch_utils.py en la carpeta de la aplicación . Aquí hacemos tres cosas:
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()
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)
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
En el archivo main.py , predict
có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_name
es el mismo que. Normalmente, debe hacer el mapeo del índice al nombre real de la clase aquí.
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
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/
1641005280
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.
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
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 jsonify
métodos de Flask solo devuelven datos json ficticios.
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'}
.
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 .
Cree un nuevo archivo torch_utils.py en la carpeta de la aplicación . Aquí hacemos tres cosas:
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()
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)
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
En el archivo main.py , predict
có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_name
es el mismo que. Normalmente, debe hacer el mapeo del índice al nombre real de la clase aquí.
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
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/
1596686520
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
1639760160
Automatic Flask cache configuration on Heroku.
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 :)
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.
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.
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.
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
1592723950
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
1622190649
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