伊藤  直子

伊藤 直子

1654168680

Gradioを使用して機械学習モデルをWebアプリとしてデプロイする

99%の精度で機械学習モデルを構築し、今では恍惚状態になっています。あなたはyaaaaaaaaayのようです!私のモデルはうまく機能しました。

それからあなたは一時停止しました、そしてあなたは次のようでした–今何ですか?

まず、コードをGitHubにアップロードして、Jupyterノートブックファイルを他の人に見せることを考えたかもしれません。これは、Seabornを使用して作成したゴージャスな外観の視覚化、非常に強力なアンサンブルモデル、および評価指標に合格する方法などで構成されています。

しかし、あなたは誰もそれと相互作用していないことに気づきました。

さて、私の友人、非技術者もモデルと対話できるように、モデルをWebアプリとしてデプロイしてみませんか?あなたのようなプログラマーだけがその最初のアプローチを理解するでしょう。

モデルをデプロイする方法はいくつかありますが、この記事ではそのうちの1つであるGradioの使用に焦点を当てます。私はあなたが興奮していると言うことができます。さて、これはエキサイティングな乗り物になるので、リラックスして楽しんでください。

前提条件

この旅を始める前に、私はあなたが次の知識を持っていると思います:

  1. Pythonでユーザー定義関数を作成する方法を知っています
  2. MLモデルを構築して適合させることができます
  3. 環境はすべてセットアップされています

グラディオとは?

Gradioは無料のオープンソースPythonライブラリであり、誰でもどこでも使用できる、機械学習モデル用の使いやすいカスタマイズ可能なコンポーネントデモを開発できます。

Gradioは、Scikit-learn、PyTorch、NumPy、seaborn、pandas、TensorFlowなどの最も人気のあるPythonライブラリと統合されています。

その利点の1つは、JupyterまたはColabノートブックで現在開発しているWebアプリと対話できることです。これには、ユーザーが対話できるWebアプリを構築するのに役立つ多くの独自の機能があります。

Gradioのインストール方法

Gradioを使用するには、最初にそのライブラリをローカルPCにインストールする必要があります。したがって、Conda PowerShellまたはターミナルに移動して、次のコマンドを実行します。Google Colabを使用している場合は、次のように入力することもできます。

pip install gradio

これで、GradioがローカルPCにインストールされました。ライブラリに精通できるように、Gradioの基本をいくつか見ていきましょう。

まず、ライブラリをノートブックまたはIDEのどちらを使用しているかにインポートする必要があります。これを行うには、次のコマンドを入力します。

import gradio as gr

最初のWebアプリを作成する方法

このチュートリアルでは、Gradioの基本に慣れるための挨拶アプリの例を作成します。

そのためには、GradioがPythonユーザー定義関数で動作するため、挨拶関数を作成する必要があります。その結果、挨拶関数は次のようになります。

def greet_user(name):
	return "Hello " + name + " Welcome to Gradio!😎"

次に、Python関数をGradioにデプロイして、Webアプリとして機能できるようにする必要があります。これを行うには、次のように入力します。

app =  gr.Interface(fn = greet_user, inputs="text", outputs="text")
app.launch()

実行する前に、上記のコードで何が起こっているのかを見ていきましょう。

gr.Interface:この属性は、Gradioのあらゆるものの基盤として機能します。Webに表示されるすべてのコンポーネントを表示するのはユーザーインターフェイスです。

パラメータfn:これは、作成したPython関数であり、Gradioに提供します。

パラメータ:これらは、inputs単語、画像、数字、音声など、作成した関数に渡したいコンポーネントです。この例では、作成した関数に必要なテキストがあるため、入力パラメーターに入力しました。

パラメータ:これは、output表示したいインターフェイスにコンポーネントを表示できるようにするパラメータです。この例で作成した関数はテキストを表示する必要があるため、テキストコンポーネントをoutputsパラメーターに提供します。

app.launchアプリを起動するために使用されます。上記のコードを実行すると、次のようになります。

alt_text

Gradioインターフェースが表示されたら、名前を入力して送信を押します。次に、上記で作成した関数に結果を出力します。これで完了です。モデルのデプロイ方法を学習する前に、Gradioでもう1つ説明します。

2つの入力を受け入れ、1つの出力を提供するGradioアプリを作成します。このアプリはあなたの名前と値を尋ねるだけで、あなたの名前と入力した値の倍数を出力します。これを行うには、次のコードを入力するだけです。

def return_multiple(name, number):
    result = "Hi {}! 😎. The Mulitple of {} is {}".format(name, number, round(number**2, 2))
    return result

app = gr.Interface(fn = return_multiple, inputs=["text", gr.Slider(0, 50)], outputs="text")
app.launch()

alt_text

これで、ここで行った、慣れていない可能性のあるいくつかのことを簡単に見ていきましょう。

入力パラメーター:入力パラメーターで、テキストとスライダーの2つのコンポーネントを含むリストを作成しました。スライダーは、指定された範囲をスライドしたときにフロート値を返すGradioの属性の1つでもあります。これを使用したのは、作成した関数でテキストと値を期待しているためです。

上記で作成した関数で属性を並べ替える方法で、入力パラメーターのコンポーネントを並べ替える必要があります。つまり、番号の前に最初にテキストを入力します。したがって、出力に期待しているのは実際には文字列です。上記の関数でいくつかのフォーマットを実行しました。

Gradioの基本のいくつかに慣れてきたので、展開するモデルを作成しましょう。

機械学習モデルをGradioにデプロイする方法

このセクションでは、以前にトレーニングしてピクルスファイルに保存した分類モデルを使用します。

トレーニングに時間がかかるモデルを作成する場合、それを処理するための最も効果的なアプローチは、モデルのトレーニングのストレスを経験する必要がないように、トレーニングが終了したらピクルスファイルに保存することです。また。

モデルをピクルスファイルとして保存する場合は、その方法を説明します。最初にpickleライブラリをインポートしてから、以下のコードを入力します。次のようなモデルを適合させたいとしましょう。

import pickle
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train) 

# If you've fitted the model just type this to save it: Remember to change the file name
with open("filename.pkl", "wb") as f:
pickle.dump(clf, f)  

ロードしたい場合は、次のコードも入力できます。

with open("filename.pkl", "rb") as f:
	clf  = pickle.load(f)

これを理解したので、予測を行うことができるようにGradioに渡すことができる関数を作成しましょう。

def make_prediction(age, employment_status, bank_name, account_balance):
    with open("filename.pkl", "rb") as f:
        clf  = pickle.load(f)
        preds = clf.predict([[age, employment_status, bank_name, account_balance]])
    if preds == 1:
            return "You are eligible for the loan"
    return "You are not eligible for the loan"

#Create the input component for Gradio since we are expecting 4 inputs

age_input = gr.Number(label = "Enter the Age of the Individual")
employment_input = gr.Number(label= "Enter Employement Status {1:For Employed, 2: For Unemployed}")
bank_input = gr.Textbox(label = "Enter Bank Name")
account_input = gr.Number(label = "Enter your account Balance:")
# We create the output
output = gr.Textbox()


app = gr.Interface(fn = make_prediction, inputs=[age_input, employment_input, bank_input, account_input], outputs=output)
app.launch()

alt_text

それでは、上記の内容をアンラップしましょう。

入力コンポーネントを作成したところから始めます。でコンポーネントを作成することを選択できますgr.Interfaceが、次のコードでは、コンポーネントをの外部で直接ビルドしてgr.Interfaceから、変数をに提供しましたgr.Interface

したがって、数値を受け取り、を使用しgr.Number、作成した出力変数からコンポーネントを作成する場合は、最初のアプリで以前に行ったようにテキストを渡すことができます(「text」文字列は、テキストボックスの省略形です。属性を明示的に宣言したい)。

また、ユーザーが何をすべきかがわかるように、各コンポーネントでlabelパラメーターを使用しました。上記の他のコードについては、すでによく知っています。これで、モデルがデプロイされました。🎉🎉😎🥳🥳。

結論

このチュートリアルをお読みいただきありがとうございます。この記事では多くのことを取り上げました。Gradioの学習はここで止まらないことを覚えておいてください-あなたは彼らのウェブサイトでもっとチェックすることができます。Webアプリの作成方法に関する非常に直感的なドキュメントがあります。

このストーリーは、もともとhttps://www.freecodecamp.org/news/how-to-deploy-your-machine-learning-model-as-a-web-app-using-gradio/で公開されました。

#machinelearning #gradio 

Gradioを使用して機械学習モデルをWebアプリとしてデプロイする

Cómo Implementar Un Modelo De Aprendizaje Automático Usando Gradio

Construyó su modelo de aprendizaje automático con un 99 % de precisión y ahora está extasiado. ¡Eres como yaaaaaaaaay! Mi modelo funcionó bien.

Luego hiciste una pausa y dijiste: ¿y ahora qué?

Bueno, primero, es posible que haya pensado en cargar su código en GitHub y mostrarle a la gente su archivo de cuaderno Jupyter. Comprende esas visualizaciones de aspecto magnífico que creó con Seaborn, esos modelos de conjunto extremadamente poderosos, y cómo pueden pasar sus métricas de evaluación, etc.

Pero luego notó que nadie está interactuando con él.

Bueno, mi amigo, ¿por qué no intenta implementar el modelo como una aplicación web para que los no expertos en tecnología también puedan interactuar con el modelo? Porque solo los programadores como usted probablemente entenderán ese primer enfoque.

Existen varios métodos para implementar su modelo, pero nos centraremos en uno de ellos en este artículo: usar Gradio. Puedo decir que estás emocionado. Bueno, relájate y disfruta, porque este va a ser un viaje emocionante.

requisitos previos

Antes de comenzar este viaje, asumo que tienes los siguientes conocimientos:

  1. Sabes cómo crear una función definida por el usuario en Python
  2. Puede construir y ajustar un modelo ML
  3. Su entorno está todo configurado

¿Qué es Gradio?

Gradio es una biblioteca de Python gratuita y de código abierto que le permite desarrollar una demostración de componentes personalizables y fáciles de usar para su modelo de aprendizaje automático que cualquiera puede usar en cualquier lugar.

Gradio se integra con las bibliotecas de Python más populares, incluidas Scikit-learn, PyTorch, NumPy, seaborn, pandas, Tensor Flow y otras.

Una de sus ventajas es que te permite interactuar con la aplicación web que estás desarrollando actualmente en tu cuaderno Jupyter o Colab. Tiene muchas características únicas que pueden ayudarlo a construir una aplicación web con la que los usuarios pueden interactuar.

Cómo instalar Gradio

Para usar Gradio, primero debemos instalar su biblioteca en nuestra PC local. Así que vaya a su Conda PowerShell o terminal y ejecute el siguiente comando. Si está utilizando Google Colab, también puede escribir lo siguiente:

pip install gradio

Ahora tenemos Gradio instalado en nuestra PC local. Repasemos algunos de los fundamentos de Gradio para que podamos familiarizarnos con la biblioteca.

Para comenzar, debemos importar la biblioteca a nuestro cuaderno o IDE, cualquiera que esté usando. Esto lo podemos hacer escribiendo el siguiente comando:

import gradio as gr

Cómo crear su primera aplicación web

En este tutorial, crearemos una aplicación de saludo de ejemplo para familiarizarnos con los fundamentos de Gradio.

Para hacerlo, necesitaremos escribir una función de saludo porque Gradio funciona con funciones definidas por el usuario de Python. Como resultado, nuestra función de saludo se ve así:

def greet_user(name):
	return "Hello " + name + " Welcome to Gradio!😎"

Ahora necesitamos implementar la función de Python en Gradio para que pueda actuar como una aplicación web. Para ello tecleamos:

app =  gr.Interface(fn = greet_user, inputs="text", outputs="text")
app.launch()

Analicemos y asimilamos lo que está sucediendo en el código anterior antes de ejecutarlo.

gr.Interface: Este atributo sirve como base de cualquier cosa en Gradio. Es la interfaz de usuario que muestra todos los componentes que se mostrarán en la web.

El parámetro fn: esta es la función de Python que creó y desea proporcionar a Gradio.

El inputsparámetro: estos son los componentes que desea pasar a la función que creó, como palabras, imágenes, números, audio, etc. En nuestro caso, la función que creamos requería texto, así que lo ingresamos en los parámetros de entrada.

El outputparámetro: este es un parámetro que le permite mostrar el componente en la interfaz que desea ver. Debido a que la función que creamos en este ejemplo necesita mostrar texto, proporcionamos el componente de texto al parámetro de salidas.

app.launchse utiliza para iniciar la aplicación. Debería tener algo como esto cuando ejecute el código anterior:

texto alternativo

Una vez que aparezca la interfaz de Gradio, simplemente escriba su nombre y presione enviar. Luego genera el resultado en la función que creamos anteriormente. Ahora que hemos terminado con eso, repasemos una cosa más en Gradio antes de aprender cómo implementar nuestro modelo.

Crearemos una aplicación Gradio que pueda aceptar dos entradas y proporcione una salida. Esta aplicación solo solicita su nombre y un valor y luego genera sus nombres, así como múltiplos del valor que ingresó. Para hacer eso, simplemente escriba el siguiente código:

def return_multiple(name, number):
    result = "Hi {}! 😎. The Mulitple of {} is {}".format(name, number, round(number**2, 2))
    return result

app = gr.Interface(fn = return_multiple, inputs=["text", gr.Slider(0, 50)], outputs="text")
app.launch()

texto alternativo

Ahora que lo hemos hecho, repasemos rápidamente algunas de las cosas que hicimos aquí con las que quizás no esté familiarizado.

Parámetro de entrada: en el parámetro de entrada creamos una lista que involucra dos componentes, el texto y el control deslizante. El control deslizante también es uno de los atributos de Gradio que devuelve un valor flotante cuando se desliza por un rango determinado. Usamos esto porque en la función que creamos estamos esperando un texto y un valor.

Tenemos que ordenar el componente en el parámetro de entrada de la forma en que se ordenan nuestros atributos en la función que creamos anteriormente. Es decir, envía un mensaje de texto antes del número. Entonces, lo que esperamos para la salida es en realidad una cadena. Acabamos de formatear en la función anterior.

Ahora que nos hemos familiarizado con algunos de los conceptos básicos de Gradio, creemos un modelo que implementaremos.

Cómo implementar un modelo de aprendizaje automático en Gradio

En esta sección, usaré un modelo de clasificación que he entrenado previamente y guardado en un archivo pickle.

Cuando crea un modelo que toma mucho tiempo para entrenar, el enfoque más efectivo para manejarlo es guardarlo en un archivo pickle una vez que haya terminado de entrenar para que no tenga que pasar por el estrés de entrenar el modelo. otra vez.

Si desea guardar un modelo como un archivo pickle, permítame mostrarle cómo puede hacerlo. Primero importe la biblioteca pickle y luego escriba el código a continuación. Digamos que solo quiero ajustar un modelo como este:

import pickle
from sklearn.ensemble import RandomForestClassifier
clf = RandomForestClassifier(random_state=42)
clf.fit(X_train, y_train) 

# If you've fitted the model just type this to save it: Remember to change the file name
with open("filename.pkl", "wb") as f:
pickle.dump(clf, f)  

Ahora, si desea cargarlo, también puede escribir el siguiente código:

with open("filename.pkl", "rb") as f:
	clf  = pickle.load(f)

Ahora que hemos entendido eso, creemos una función que podamos pasar a Gradio para que pueda hacer las predicciones.

def make_prediction(age, employment_status, bank_name, account_balance):
    with open("filename.pkl", "rb") as f:
        clf  = pickle.load(f)
        preds = clf.predict([[age, employment_status, bank_name, account_balance]])
    if preds == 1:
            return "You are eligible for the loan"
    return "You are not eligible for the loan"

#Create the input component for Gradio since we are expecting 4 inputs

age_input = gr.Number(label = "Enter the Age of the Individual")
employment_input = gr.Number(label= "Enter Employement Status {1:For Employed, 2: For Unemployed}")
bank_input = gr.Textbox(label = "Enter Bank Name")
account_input = gr.Number(label = "Enter your account Balance:")
# We create the output
output = gr.Textbox()


app = gr.Interface(fn = make_prediction, inputs=[age_input, employment_input, bank_input, account_input], outputs=output)
app.launch()

texto alternativo

Así que vamos a desenvolver lo que tenemos arriba:

Comenzaremos en el punto donde creamos el componente de entrada. Puede optar por crear el componente en el gr.Interface, pero en el siguiente código, lo construí directamente fuera del gr.Interfacey luego proporcioné la variable en el gr.Interface.

Entonces, si desea crear un componente que reciba números, use gr.Number, y luego desde la variable de salida que creé, puede pasar texto como lo hicimos anteriormente en nuestra primera aplicación (la cadena de "texto" es una forma abreviada de cuadro de texto si no No quiero declarar el atributo explícitamente).

También usé el parámetro de etiqueta en cada componente para que el usuario sepa qué hacer. Ya estamos familiarizados con el otro código mencionado anteriormente. Y ahora que lo hemos hecho, nuestro modelo está desplegado. 🎉🎉😎🥳🥳.

Conclusión

Gracias por leer este tutorial. Cubrimos mucho en este artículo. Solo recuerde que el aprendizaje de Gradio no se detiene aquí: puede consultar más en su sitio web . Tienen documentación bastante intuitiva sobre cómo puede crear su aplicación web.

Esta historia se publicó originalmente en https://www.freecodecamp.org/news/how-to-deploy-your-machine-learning-model-as-a-web-app-using-gradio/

 #machinelearning #gradio 

Cómo Implementar Un Modelo De Aprendizaje Automático Usando Gradio
Aida  Stamm

Aida Stamm

1648024059

Building Machine Learning Apps and Demos with Python

Building Machine Learning Apps and Demos with Python

How can you show what a Machine Learning model does once it's trained? In this talk, you're going to learn how to create Machine Learning apps and demos using Streamlit and Gradio, Python libraries for this purpose. Additionally, you'll see how to share them with the rest of the Open Source ecosystem. Learning to create graphic interfaces for models is extremely useful for sharing with other people interesting with them.

#machinelearning #python #datascience #streamlit #gradio

Building Machine Learning Apps and Demos with Python
Brielle  Maggio

Brielle Maggio

1645186860

Gradio App Sharing with Login Authentication Page for ML UI

Gradio App Sharing with Login Authentication Page | Gradio ML UI Beginners Course

#machine-learning #ui #authentication #gradio 

Gradio App Sharing with Login Authentication Page for ML UI
Brielle  Maggio

Brielle Maggio

1645172340

How to Improve Gradio UI UX (Themes & CSS) for ML UI

Improving Gradio UI UX (Themes & CSS) | Gradio ML UI Beginners Course

#machine-learning #ui #ux #css #gradio 

How to Improve Gradio UI UX (Themes & CSS) for ML UI
Brielle  Maggio

Brielle Maggio

1645157880

Gradio ML UI Course: Gradio Multiple Inputs Outputs

Gradio Multiple Inputs Outputs | Gradio ML UI Beginners Course

#machine-learning #gradio 

Gradio ML UI Course: Gradio Multiple Inputs Outputs
Brielle  Maggio

Brielle Maggio

1645143420

Gradio ML UI Course: Debugging & Flagging

Gradio Debugging & Flagging | Gradio ML UI Beginners Course

#machine-learning #gradio 

Gradio ML UI Course: Debugging & Flagging
Brielle  Maggio

Brielle Maggio

1645128960

Gradio ML UI Course: Gradio Mulitple Components (Text, Image, Tabular)

Gradio Mulitple Components (Text, Image, Tabular) | Gradio ML UI Beginner's Course

#gradio #machine-learning 

Gradio ML UI Course: Gradio Mulitple Components (Text, Image, Tabular)
Brielle  Maggio

Brielle Maggio

1645114468

How to Get Started with Gradio for ML UI Development

Getting started with Gradio for ML UI Development | Gradio ML App Course

#machine-learning #gradio 

How to Get Started with Gradio for ML UI Development
Brielle  Maggio

Brielle Maggio

1645100006

What Is Gradio and Its Advantages?

Learn What is Gradio? Advantages of Gradio | ML UI Beginners Full Playlist

#gradio #machine-learning 

What Is Gradio and Its Advantages?
Code  Camp

Code Camp

1642554091

Create User Interfaces for Machine Learning Models with Gradio

Gradio Course - Create User Interfaces for Machine Learning Models

Gradio is a python library that makes it super easy for machine learning engineers to create user interfaces. This complete course coverw all aspects of Gradio, including deployment.

⭐️ Course Contents ⭐️
💻 (0:00:20) Welcome to this ML App Course
💻 (0:03:15) What's the problem with current ML prototyping  
💻 (0:14:08) What's Gradio & Advantages of Gradio    
💻 (0:26:05) Getting started with Gradio        
💻 (0:35:15) Gradio Components        
💻 (0:46:52) Gradio Multiple inputs        
💻 (1:04:08) Debugging & Flagging        
💻 (1:13:58) Improving UI + UX        
💻 (1:29:36) Gradio Sharing + Auth        
💻 (1:38:04) Deploying DL Gradio App  with Hugging Face Spaces        
💻 (1:50:10) Course Finish-up Summary

#machinelearning #python #gradio 

 

Create User Interfaces for Machine Learning Models with Gradio

Chih- Yu Lin

1630570854

Building and Deploying a Simple Image Classification Web App in Python

In this video, we will be building and deploying a simple image classification web app in Python using the Gradio library. In essence, it only takes 3 lines of code to build a web app using Gradio: 1) Import the libraries, 2) Create a custom function of the model and 3) Creating the web app interface by specifying the 3 input arguments (function name, input and output).

👉 Thanks to Gradio for sponsoring this video https://gradio.app/ 
- Gradio Hosted https://gradio.app/introducing-hosted/ 

- Demo of the image classifier app https://gradio.app/g/dataprofessor/imageclassifierapp/ 
- Code of the image classifier app https://github.com/dataprofessor/imageclassifierapp/ 
- Cartoon illustration of model deployment https://twitter.com/thedataprof/status/1431268104978370561?s=20 

#gradio #datascience  #machinelearning  #dataprofessor #python 

Building and Deploying a Simple Image Classification Web App in Python
Vicky  Graham

Vicky Graham

1625051700

Build a Grammar Correction Python App with Gramformer and Gradio

My grammar sucks at the best of times.

Enter Gramformer.

Gramformer is a deep learning model built using Transformers and PyTorch that allows you to improve your grammar. It takes a malformed sentence as an input and returns a sentence with corrected grammar.

What’s even better is that it’s easy to get up and started with and the creator is adding on a grammar highlighter and error detector as well! Anyway, we’ll go through it all in the vid!

In this video you’ll learn how to:

  1. Install Gramformer
  2. Use the Gramformer model for grammar correction
  3. Deploy it as an application using Gradio

Get the code:
https://github.com/nicknochnack/GramformerApp

Chapters
0:00 - Start
0:24 - Gameplan
1:03 - How it Works
1:38 - Tutorial Start
2:50 - 1. Install and Import Dependencies
7:04 - 2. Instantiate Gramformer
9:30 - 3. Correct Grammar Using Gramformer
14:36 - 4. Build Gradio App

Oh, and don’t forget to connect with me!
LinkedIn: https://bit.ly/324Epgo
Facebook: https://bit.ly/3mB1sZD
GitHub: https://bit.ly/3mDJllD
Patreon: https://bit.ly/2OCn3UW
Join the Discussion on Discord: https://bit.ly/3dQiZsV

Happy coding!
Nick

P.s. Let me know how you go and drop a comment if you need a hand!

#gradio #gramformer #python

Build a Grammar Correction Python App with Gramformer and Gradio

Gradio Library-Interfaces for your Machine Learning Models

Gradio generates an easy-to-use UI for your ML model, function, or API with only a few lines of code. Integrate directly into your Python notebook, or share a link with anyone.

Code Example: https://www.gradio.app/ml_examples

Subscribe: https://www.youtube.com/user/krishnaik06/featured

#gradio #machine-learning

Gradio Library-Interfaces for your Machine Learning Models
Arno  Bradtke

Arno Bradtke

1602429969

Guide To Gradio - Create Web-Based GUI Applications For Machine Learning

While creating ML models, our end goal is the deployment that takes it to the production which can take input and give an output of business models. The easiest form of deployment would be a GUI (Graphical User Interface).

Gradio helps in building a web-based GUI in a few lines of code which is very handy for showing demonstrations of the model performance. It is fast, easy to set up, and ready to use and shareable as the public link which anyone can access remotely and parallelly run the model in your machine. Gradio works with all kinds of media- text, images, video, and audio. Apart from ML models, it can be used as normal python code embeddings.

Gradio is a customizable UI that is integrated with Tensorflow or Pytorch models. It is free and an open-source framework makes it readily available to anyone.

In this article, we will discuss gradio with its implementation. First, we will use it in finding the largest word in a sentence, and then we will implement it to predict the name of apparele

#developers corner #gradio #graphical user interfaces #gui #machine learning

Guide To Gradio - Create Web-Based GUI Applications For Machine Learning