Giới thiệu về Gradio

Gradio là cách để trình diễn mô hình máy học của bạn với giao diện web thân thiện với người dùng, để mọi người có thể sử dụng nó ở bất cứ đâu. Gradio là một gói Python mã nguồn mở cho phép bạn nhanh chóng xây dựng một bản demo hoặc ứng dụng web cho mô hình máy học của bạn, API, hoặc bất kỳ hàm Python nào. Bạn có thể chia sẻ liên kết đến bản demo hoặc ứng dụng web của mình bằng các tính năng chia sẻ tích hợp của Gradio. Không cần kinh nghiệm về JavaScript, CSS, hoặc một nơi lưu trữ web.

English

Mục tiêu

Sau khi đọc bài viết này, bạn sẽ có thể:

Giải thích những điều cơ bản về Gradio
Minh họa một ví dụ về triển khai phân loại hình ảnh trong PyTorch

Tại sao nên sử dụng Gradio?

Gradio hữu ích vì nhiều lý do:

Dễ sử dụng: Gradio cho phép tạo các giao diện cho các mô hình chỉ với vài dòng mã.
Linh hoạt: Gradio hỗ trợ nhiều đầu vào và đầu ra khác nhau, như văn bản, hình ảnh, tệp, và nhiều hơn nữa.
Chia sẻ và cộng tác: Các giao diện có thể được chia sẻ với người khác thông qua các URL duy nhất, tạo điều kiện thuận lợi cho việc cộng tác và thu thập phản hồi.

Bắt đầu với Gradio

Để bắt đầu sử dụng Gradio, trước tiên bạn cần cài đặt thư viện. Bạn có thể cài đặt Gradio bằng pip:

pip install gradio

Tạo Giao Diện Gradio Đầu Tiên của Bạn

Bạn có thể chạy Gradio trong trình chỉnh sửa mã yêu thích của mình, Jupyter notebook, Google Colab, hoặc bất cứ đâu bạn viết mã Python. Hãy viết ứng dụng Gradio đầu tiên của bạn:


import gradio as gr
def greet(name, intensity):
  return "Hello, " + name + "!" * int(intensity)
demo = gr.Interface(
  fn=greet,
  inputs=["text", "slider"],
  outputs=["text"],
)
demo.launch()

Nếu chạy từ một tệp, bản demo dưới đây sẽ mở trong trình duyệt tại địa chỉ http://localhost:7860. Nếu bạn đang chạy trong một notebook, bản demo sẽ xuất hiện được nhúng bên trong notebook.

Nhập tên của bạn vào ô văn bản bên trái, kéo thanh trượt, và sau đó nhấn nút Gửi. Bạn sẽ thấy một lời chào thân thiện ở bên phải.

Hiểu về lớp Interface

Lưu ý rằng để tạo demo đầu tiên của bạn, bạn đã tạo một instance của lớp gr.Interface. Lớp Interface được thiết kế để tạo các bản demo cho các mô hình học máy nhận một hoặc nhiều đầu vào và trả về một hoặc nhiều đầu ra.

Lớp Interface có ba tham số chính:

fn: Hàm cần bao quanh bằng giao diện người dùng (UI)
inputs: Thành phần Gradio để sử dụng cho đầu vào. Số lượng thành phần phải khớp với số lượng tham số trong hàm của bạn.
outputs: Thành phần Gradio để sử dụng cho đầu ra. Số lượng thành phần phải khớp với số lượng giá trị trả về từ hàm của bạn.
Tham số fn rất linh hoạt — bạn có thể truyền bất kỳ hàm Python nào bạn muốn bao quanh bằng UI. Trong ví dụ trên, bạn đã thấy một hàm tương đối đơn giản, nhưng hàm đó có thể là bất kỳ thứ gì từ trình tạo nhạc đến máy tính thuế đến hàm dự đoán của một mô hình học máy đã được huấn luyện trước.

Các tham số inputs và outputs nhận một hoặc nhiều thành phần Gradio. Như chúng ta sẽ thấy, Gradio bao gồm hơn 30 thành phần tích hợp sẵn (chẳng hạn như gr.Textbox(), gr.Image(), and gr.HTML()) được thiết kế cho các ứng dụng học máy.

Nếu hàm của bạn nhận nhiều hơn một tham số, như trong ví dụ trên, hãy truyền một danh sách các thành phần đầu vào tới inputs, với mỗi thành phần đầu vào tương ứng với một tham số của hàm theo thứ tự. Điều này cũng áp dụng nếu hàm của bạn trả về nhiều giá trị: chỉ cần truyền một danh sách các thành phần tới outputs. Tính linh hoạt này làm cho lớp Interface trở thành một cách rất mạnh mẽ để tạo các bản demo.

Hãy tạo một giao diện đơn giản cho một mô hình chú thích ảnh. Mô hình BLIP (Bootstrapped Language Image Pretraining) có thể tạo chú thích cho ảnh. Đây là cách bạn có thể tạo một giao diện Gradio cho mô hình BLIP.

pip install transformers


import gradio as gr
from transformers import BlipProcessor, BlipForConditionalGeneration
from PIL import Image

processor = BlipProcessor.from_pretrained("Salesforce/blip-image-captioning-base")
model = BlipForConditionalGeneration.from_pretrained("Salesforce/blip-image-captioning-base")

def generate_caption(image):
    # Now directly using the PIL Image object
    inputs = processor(images=image, return_tensors="pt")
    outputs = model.generate(**inputs)
    caption = processor.decode(outputs[0], skip_special_tokens=True)
    return caption

def caption_image(image):
    """
    Takes a PIL Image input and returns a caption.
    """
    try:
        caption = generate_caption(image)
        return caption
    except Exception as e:
        return f"An error occurred: {str(e)}"

iface = gr.Interface(
    fn=caption_image,
    inputs=gr.Image(type="pil"),
    outputs="text",
    title="Image Captioning with BLIP",
    description="Upload an image to generate a caption."
)

iface.launch()

Dưới đây, chúng ta sử dụng BlipProcessor và BlipForConditionalGeneration từ thư viện transformers để thiết lập một mô hình chú thích ảnh. Ví dụ này minh họa việc tạo một giao diện web bằng Gradio, trong đó tham số đầu vào chỉ định một hình ảnh và đầu ra là chú thích văn bản được tạo ra. Các tham số tiêu đề và mô tả cải thiện giao diện bằng cách cung cấp bối cảnh và hướng dẫn cho người dùng.

Trường hợp sử dụng: Chú thích Hình ảnh

Các mô hình chú thích hình ảnh như BLIP là công cụ vô cùng mạnh mẽ trong nhiều lĩnh vực, từ việc giúp người khiếm thị hiểu nội dung hình ảnh đến tổ chức và tìm kiếm hiệu quả qua các thư viện ảnh lớn. Việc tạo giao diện Gradio cho một mô hình như vậy giúp người dùng không có kỹ thuật cũng có thể tương tác và tận dụng công nghệ này. Ví dụ, các nhiếp ảnh gia hoặc người quản lý tài sản kỹ thuật số có thể sử dụng ứng dụng của bạn để tự động tạo tên mô tả cho hình ảnh của họ, nâng cao tính sử dụng và khả năng tìm kiếm của thư viện kỹ thuật số của họ.

Phân loại Hình ảnh trong PyTorch

Phân loại hình ảnh là một nhiệm vụ trung tâm trong thị giác máy tính. Xây dựng các bộ phân loại tốt hơn để xác định đối tượng nào có trong một bức ảnh là một lĩnh vực nghiên cứu đang hoạt động, vì nó có các ứng dụng từ phương tiện tự hành đến hình ảnh y tế.

Các mô hình như vậy rất phù hợp để sử dụng với thành phần đầu vào hình ảnh của Gradio. Trong hướng dẫn này, chúng ta sẽ xây dựng một bản demo web để phân loại hình ảnh bằng cách sử dụng Gradio. Chúng ta có thể xây dựng toàn bộ ứng dụng web trong Python.

Bước 1: Thiết lập mô hình phân loại hình ảnh

Trước tiên, chúng ta sẽ cần một mô hình phân loại hình ảnh. Trong hướng dẫn này, chúng ta sẽ sử dụng mô hình Resnet-18 đã được huấn luyện trước, vì nó có thể dễ dàng tải xuống từ PyTorch Hub. Bạn có thể sử dụng một mô hình đã được huấn luyện trước khác hoặc tự huấn luyện mô hình của riêng mình.

import torch
model = torch.hub.load('pytorch/vision:v0.6.0', 'resnet18', pretrained=True).eval()

Bước 2: Khởi tạo hàm dự đoán

Tiếp theo, chúng ta cần định nghĩa một hàm nhận đầu vào từ người dùng, trong trường hợp này là một hình ảnh, và trả về dự đoán. Dự đoán sẽ được trả về dưới dạng một từ điển với các key là tên lớp và các giá trị là xác suất tự tin. Chúng ta sẽ tải các tên lớp từ tệp văn bản này.

Trong trường hợp này mô hình được huấn luyện trước của chúng ta sẽ trông như bên dưới:

import requests
from PIL import Image
from torchvision import transforms

# Download human-readable labels for ImageNet.
response = requests.get("https://git.io/JJkYN")
labels = response.text.split("\n")

def predict(inp):
 inp = transforms.ToTensor()(inp).unsqueeze(0)
 with torch.no_grad():
  prediction = torch.nn.functional.softmax(model(inp)[0], dim=0)
  confidences = {labels[i]: float(prediction[i]) for i in range(1000)}
 return confidences

Hãy cùng phân tích điều này. Hàm nhận một tham số là:

inp: the input image as a PIL image

Hàm chuyển đổi hình ảnh đầu vào thành một đối tượng PIL Image, sau đó chuyển đổi thành một tensor PyTorch. Sau khi xử lý tensor thông qua mô hình, nó trả về các dự đoán dưới dạng một từ điển có tên là confidences. Các khóa của từ điển là nhãn lớp, và các giá trị tương ứng là xác suất tin cậy tương ứng.

Trong phần này, chúng ta xác định hàm dự đoán xử lý hình ảnh đầu vào để trả về xác suất dự đoán. Trước tiên, hàm này chuyển đổi hình ảnh thành tensor PyTorch, sau đó chuyển tiếp hình ảnh đó qua mô hình được huấn luyện trước. Chúng ta sử dụng hàm softmax ở bước cuối cùng để tính xác suất của từng lớp. Hàm softmax rất quan trọng vì nó chuyển đổi nhật ký đầu ra thô từ mô hình, có thể là bất kỳ số thực nào, thành xác suất có tổng bằng 1. Điều này giúp dễ dàng diễn giải kết quả đầu ra của mô hình dưới dạng mức độ tin cậy cho từng lớp.

Bước 3: Tạo giao diện Gradio

Bây giờ khi chúng ta đã thiết lập được hàm dự đoán, chúng ta có thể tạo một giao diện cho Gradio.

Trong trường hợp này, thành phần đầu vào là thành phần hình ảnh kéo và thả. Để tạo thành phần này, chúng ta sử dụng Image(type=“pil”) để tạo thành phần và xử lý tiền xử lý để chuyển đổi thành hình ảnh PIL.

Thành phần đầu ra sẽ là một Label, hiển thị các nhãn hàng đầu dưới dạng đẹp mắt. Vì chúng ta không muốn hiển thị tất cả 1,000 nhãn lớp, chúng ta sẽ tùy chỉnh nó để chỉ hiển thị 3 hình ảnh hàng đầu bằng cách xây dựng nó như Label(num_top_classes=3).

Cuối cùng, chúng ta sẽ thêm một tham số nữa là các ví dụ, cho phép chúng ta điền sẵn giao diện của mình với vài ví dụ đã được xác định trước. Đoạn mã cho Gradio sẽ có dạng như sau:

import gradio as gr

gr.Interface(fn=predict,
       inputs=gr.Image(type="pil"),
       outputs=gr.Label(num_top_classes=3),
       examples=["/content/lion.jpg", "/content/cheetah.jpg"]).launch()

Các đường dẫn ví dụ cung cấp, /content/lion.jpg và /content/cheetah.jpg, chỉ là giá trị tạm thời. Bạn nên thay thế chúng bằng các đường dẫn thực tế đến các hình ảnh trên hệ thống hoặc máy chủ của bạn, nơi bạn đã lưu các hình ảnh mà bạn muốn sử dụng cho việc kiểm thử. Điều này đảm bảo rằng khi bạn hoặc người khác sử dụng giao diện Gradio, các ví dụ sẽ được tải và sử dụng đúng cách để minh họa chức năng của bộ phân loại hình ảnh của bạn.

Điều này tạo ra giao diện sau đây, mà bạn có thể thử trong trình duyệt (hãy tải lên các ví dụ của riêng bạn).

Và bạn đã hoàn thành! Đó là toàn bộ mã bạn cần để xây dựng một demo web cho một bộ phân loại hình ảnh. Nếu bạn muốn chia sẻ với người khác, hãy thử đặt share=True khi bạn launch() Interface!

Kết luận

Gradio đơn giản hóa quá trình xây dựng các web demo tương tác cho các mô hình học máy. Bằng cách tích hợp Gradio với các mô hình như BLIP để tạo chú thích hình ảnh, bạn có thể tạo ra các ứng dụng thực tế, thân thiện với người dùng, tận dụng sức mạnh của AI để giải quyết các vấn đề thực tế. Công cụ này không chỉ hỗ trợ trong việc giới thiệu khả năng của các mô hình của bạn mà còn trong việc thu thập các phản hồi quan trọng để cải thiện thêm.

Bạn có thể thử Gradio ngay bây giờ để xây dựng các ứng dụng demo cho các mô hình học máy của mình một cách dễ dàng nhưng hiệu quả.

Source: https://skills.network