Bangun stylist AI dengan Granite dan watsonx.ai

Dalam tutorial ini, Anda akan dipandu melalui cara membangun stylist pribadi bertenaga AI generatif. Tutorial ini memanfaatkan model bahasa besar (LLM) IBM Granite™ Vision 3.2 untuk memproses input gambar dan Granite 3.2 dengan kemampuan penalaran terbaru yang ditingkatkan untuk merumuskan ide pakaian yang dapat disesuaikan.

Pendahuluan

Seberapa sering Anda mendapati diri Anda berpikir, “Apa yang harus saya pakai hari ini? Saya bahkan tidak tahu harus mulai dari mana dengan memilih barang-barang dari lemari saya!” Dilema ini adalah salah satu yang banyak dari kita berbagi. Dengan menggunakan model kecerdasan buatan (AI) mutakhir, ini tidak perlu lagi menjadi hal yang menakutkan.

AI styling: Cara kerjanya

Solusi berbasis AI kami terdiri dari tahapan berikut:

Pengguna mengunggah gambar lemari pakaian mereka saat ini atau bahkan item dalam daftar keinginan mereka, satu item pada satu waktu.
Pengguna memilih kriteria berikut:

Kesempatan: santai atau formal.
Waktu hari: pagi, siang, atau sore hari.
Musim dalam setahun: musim dingin, musim semi, musim panas atau musim gugur.
Lokasi (misalnya, kedai kopi).

3. Setelah penyerahan input, model Granite Vision 3.2 multimodal mengulang daftar gambar dan mengembalikan output berikut:

Deskripsi item.
Kategori: kemeja, celana, atau sepatu.
Kesempatan: santai atau formal.

4. Model Granite 3.2 dengan penalaran yang ditingkatkan kemudian berfungsi sebagai penata gaya busana. LLM menggunakan output model Vision untuk memberikan rekomendasi pakaian yang sesuai untuk acara pengguna.

5. Saran pakaian, bingkai data item yang diunggah pengguna, dan gambar dalam rekomendasi pribadi yang dijelaskan semuanya dikembalikan ke pengguna.

Prasyarat

Anda memerlukan akun IBM Cloud® untuk membuat proyek watsonx.ai™ .

Langkah-langkah

Untuk menggunakan antarmuka pemrograman aplikasi (API) watsonx, Anda harus menyelesaikan langkah-langkah berikut. Perhatikan, Anda juga dapat mengakses tutorial ini di GitHub.

Langkah 1. Siapkan lingkungan Anda

Masuk ke watsonx.ai dengan menggunakan akun IBM Cloud Anda.
Buat proyek watsonx.ai.

Anda bisa mendapatkan ID proyek dari dalam proyek Anda. Klik tab Kelola . Kemudian, salin ID proyek dari bagian Detail di halaman Umum . Anda memerlukan ID ini untuk tutorial ini.

Langkah 2. Siapkan layanan waktu proses watsonx.ai dan kunci API

Buat instans layanan watsonx.ai Runtime (pilih paket Lite, yang merupakan instans gratis).
Buat Kunci API.
Kaitkan layanan watsonx.ai Runtime ke proyek yang Anda buat di watsonx.ai.

Langkah 3. Buat kloning repositori (opsional)

Untuk pengalaman yang lebih interaktif saat menggunakan alat AI ini, kloning repositori GitHub dan ikuti instruksi pengaturan di file README.md dalam proyek AI stylist untuk meluncurkan aplikasi Streamlit di mesin lokal Anda. Jika tidak, jika Anda lebih suka mengikuti langkah demi langkah, buat Jupyter Notebook dan Lanjutkan dengan tutorial ini.

Langkah 3. Instal dan impor pustaka yang relevan dan atur kredensial Anda

Kita membutuhkan beberapa pustaka dan modul untuk tutorial ini. Pastikan untuk mengimpor yang berikut ini; jika tidak diinstal, Anda dapat menyelesaikan masalah ini dengan instalasi pip cepat.

# Install required packages
!pip install -q image ibm-watsonx-ai

# Required imports
import getpass, os, base64, json
from ibm_watsonx_ai import Credentials
from ibm_watsonx_ai.foundation_models import ModelInference
from PIL import Image

Untuk mengatur kredensial, kita memerlukan WATSONX_APIKEY dan WATSONX_PROJECT_ID Anda membuat di langkah 1. Kami juga akan mengaturURL berfungsi sebagai titik akhir API.

WATSONX_APIKEY = getpass.getpass("Please enter your watsonx.ai Runtime API key (hit enter): ")
WATSONX_PROJECT_ID = getpass.getpass("Please enter your project ID (hit enter): ")
URL = "https://us-south.ml.cloud.ibm.com"

Kita bisa menggunakan Credentials kelas untuk merangkum kredensial yang kita berikan.

credentials = Credentials(
url=URL,
api_key=WATSONX_APIKEY
)

Langkah 5. Siapkan permintaan API untuk model Granite Vision

Metode augment_api_request_body fungsi mengambil kueri pengguna dan gambar sebagai parameter dan menambah isi permintaan API. Kami akan menggunakan fungsi ini di setiap iterasi menyimpulkan model Visi.

def augment_api_request_body(user_query, image):
    messages = [
        {
            "role": "user",
            "content": [{
                "type": "text",
                "text": user_query
            },
            {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{image}"
                }
            }]
        }
    ]
return messages

Kita juga dapat membuat instans antarmuka model dengan menggunakan ModelInference kelas.

model = ModelInference(
    model_id="ibm/granite-vision-3-2-2b",
    credentials=credentials,
    project_id=WATSONX_PROJECT_ID,
    params={
        "max_tokens": 400,
        "temperature": 0
    }
)

Langkah 6. Enkode gambar

Untuk mengkodekan gambar kita dengan cara yang dapat dicerna untuk LLM, kita akan mengkodekannya ke byte yang kemudian kita decode ke representasi UTF-8. Dalam hal ini, gambar kami terletak di direktori gambar lokal. Anda dapat menemukan contoh gambar di direktori stylist AI di repositori GitHub kami.

directory = "images" #directory name
images = []
filenames = []
for filename in os.listdir(directory):
    if filename.endswith(".jpeg") or filename.endswith(".png"):
        filepath = directory + '/' + filename
        with open(filepath, "rb") as f:
            images.append(base64.b64encode(f.read()).decode('utf-8'))
        filenames.append(filename)

Langkah 7. Kategorikan input dengan model Vision

Sekarang kita telah memuat dan mengkodekan gambar kita, kita dapat menanyakan model Vision. Prompt kami khusus untuk output yang kami inginkan untuk membatasi kreativitas model saat kami mencari output JSON yang valid. Kami akan menyimpan deskripsi, kategori, dan kesempatan setiap gambar dalam daftar yang disebut closet .

user_query = """Provide a description, category, and occasion for the clothing item or shoes in this image.
                Classify the category as shirt, pants, or shoes.
                Classify the occasion as casual or formal.
                Ensure the output is valid JSON. Do not create new categories or occasions. Only use the allowed classifications.
                Your response should be in this schema:
                {
                    "description": "<description>",
                    "category": "<category>",
                    "occasion": "<occasion>"
                }
                """

image_descriptions = []
for i in range(len(images)):
    image = images[i]
    message = augment_api_request_body(user_query, image)
    response = model.chat(messages=message)
result = response['choices'][0]['message']['content']
    print(result)
image_descriptions.append(result)

Output:

{
    "description": "A pair of polished brown leather dress shoes with a brogue detailing on the toe box and a classic oxford design.",
    "category": "shoes",
    "occasion": "formal"
}
{
    "description": "A pair of checkered trousers with a houndstooth pattern, featuring a zippered pocket and a button closure at the waist.",
    "category": "pants",
"occasion": "casual"
}
{
    "description": "A light blue, button-up shirt with a smooth texture and a classic collar, suitable for casual to semi-formal occasions.",
    "category": "shirt",
    "occasion": "casual"
}
{
    "description": "A pair of khaki pants with a buttoned waistband and a button closure at the front.",
    "category": "pants",
    "occasion": "casual"
}
{
    "description": "A blue plaid shirt with a collar and long sleeves, featuring chest pockets and a button-up front.",
    "category": "shirt",
    "occasion": "casual"
}
{
    "description": "A pair of bright orange, short-sleeved t-shirts with a crew neck and a simple design.",
    "category": "shirt",
    "occasion": "casual"
}
{
    "description": "A pair of blue suede sneakers with white laces and perforations, suitable for casual wear.",
    "category": "shoes",
    "occasion": "casual"
}

{
    "description": "A pair of red canvas sneakers with white laces, isolated on a white background.",
    "category": "shoes",
    "occasion": "casual"
}
{
    "description": "A pair of grey dress pants with a smooth texture and a classic design, suitable for formal occasions.",
    "category": "pants",
    "occasion": "formal"
}
{
    "description": "A plain white T-shirt with short sleeves and a crew neck, displayed from the front and back.",
    "category": "shirt",
    "occasion": "casual"
}
{
    "description": "A black short-sleeved t-shirt with a crew neck and a simple design.",
    "category": "shirt",
    "occasion": "casual"
}
{
    "description": "Black pants with a zippered pocket and a buttoned fly, showing the waistband and pocket details.",
    "category": "pants",
    "occasion": "casual"
}
{
    "description": "A pair of tan leather boots with a chunky sole and a high-top design, suitable for casual wear.",
    "category": "shoes",
    "occasion": "casual"
}

Langkah 8. Buat pakaian dengan model penalaran

Sekarang kita memiliki setiap item pakaian dan sepatu yang dikategorikan, akan jauh lebih mudah bagi model penalaran untuk menghasilkan pakaian untuk acara yang dipilih. Mari kita buat instans dan bertanya kepada model penalarannya.

reasoning_model = ModelInference(
    model_id="ibm/granite-3-2-8b-instruct",
    credentials=credentials,
    project_id=WATSONX_PROJECT_ID
)

Untuk menyelaraskan nama file dengan deskripsi gambar, kita dapat menghitung daftar deskripsi gambar dan membuat daftar kamus di mana kita menyimpan deskripsi, kategori, kejadian, dan nama file setiap item di bidang masing-masing.

# Add filenames to the image descriptions
closet = []
for i, desc in enumerate(image_descriptions):
    desc_dict = json.loads(desc)
    desc_dict['filename'] = filenames[i]
    image_descriptions[i] = json.dumps(desc_dict)

closet = [json.loads(js) for js in image_descriptions]

Sekarang, mari kita gunakan model Granite 3.2 dengan kemampuan penalaran untuk menghasilkan outfit sesuai dengan kriteria yang telah ditentukan menggunakan closet daftar.

occasion = input("Enter the occasion") #casual or formal (e.g. "casual")
time_of_day = input("Enter the time of day") #morning, afternoon or evening (e.g. "morning")
location = input("Enter the location") #any location (e.g. "park")
season = input("Enter the season") #spring, summer, fall or winter (e.g. "fall")

prompt = f"""Use the description, category, and occasion of the clothes in my closet to put together an outfit for a {occasion} {time_of_day} at the {location}. The event takes place in the {season} season. Make sure to return only one shirt, bottoms, and shoes. Use the description, category, and occasion provided. Do not classify the items yourself. Include the file name of each image in your output along with the file extension. Here are the items in my closet: {closet}"""

messages = [
        {"role": "control",
        "content": "thinking"},
        {"role": "user",
        "content": [
                {"type": "text",
"text": f"{prompt}"}
]}
        ]
outfit = reasoning_model.chat(messages=messages)['choices'][0]['message']['content']
print(outfit)

Output:

Inilah proses berpikir saya:
- Pakaian harus cocok untuk pagi santai di taman selama musim gugur.
- Saya akan memilih satu kemeja, satu celana, dan sepasang sepatu yang sesuai dengan kategori acara 'kasual'.
- Saya akan menghindari barang-barang formal atau terlalu resmi dan memilih yang nyaman untuk kegiatan taman.

Inilah tanggapan saya:

Untuk pagi hari yang santai di taman pada musim gugur, saya sarankan pakaian berikut ini:

1. **Kemeja**: Kemeja kotak-kotak biru dengan kerah dan lengan panjang (file: 'image13.jpeg')
- Pola kotak-kotak klasik untuk musim gugur dan cocok dengan suasana taman yang kasual. Lengan panjang menawarkan perlindungan terhadap suhu pagi yang lebih dingin.

2. **Celana**: Celana Khaki dengan ikat pinggang kancing dan penutup kancing di bagian depan (file: 'image7.jpeg')
- Khaki adalah pilihan serbaguna yang dapat mencocokkan suasana kasual dan juga memberikan keseimbangan yang bagus dengan kemeja kotak-kotak. Praktis dan nyaman untuk berjalan-jalan.

3. **Sepatu**: Sepasang sepatu bot kulit cokelat dengan sol tebal dan desain tinggi (file: 'image3.jpeg')
- Sepatu bot kulit cokelat menawarkan pilihan yang bergaya namun nyaman. Sol yang tebal memberikan cengkeraman dan dukungan yang baik, ideal untuk menavigasi jalan setapak taman atau tanah yang tidak rata.

Kombinasi ini memberikan tampilan santai dan berpadu yang cocok untuk tamasya pagi yang santai, sambil juga mempertimbangkan kenyamanan dan kepraktisan.

Dengan deskripsi pakaian yang dihasilkan ini, kami juga dapat menampilkan item pakaian yang direkomendasikan oleh model! Untuk melakukannya, kita cukup mengekstrak nama file. Jika model menyebutkan nama file yang sama dua kali, penting untuk memeriksa apakah gambar belum ditampilkan saat kami mengulangi daftar gambar. Kita dapat melakukannya dengan menyimpan gambar yang ditampilkan di selected_items daftar. Akhirnya, kita dapat menampilkan item yang dipilih.

selected_items = []
#extract the images of clothing that the model recommends
for item, uploaded_file in zip(closet, images):
    if item['filename'].lower() in outfit.lower() and not any(key['filename'] == item['filename'] for key in selected_items):
        selected_items.append({
            'image': uploaded_file,
            'category': item['category'],
            'filename': item['filename']
        })

#display the selected clothing items
if len(selected_items) > 0:
    for item in selected_items:
        display(Image.open(directory + '/' + item['filename']))

Kesimpulan

Dalam tutorial ini, Anda membangun sistem yang menggunakan AI untuk memberikan saran gaya untuk acara spesifik pengguna. Menggunakan foto atau tangkapan layar pakaian pengguna, pakaian disesuaikan untuk memenuhi kriteria yang ditentukan. Model Granite-vision-3-2-2b sangat penting untuk memberi label dan mengkategorikan setiap item. Selain itu, model Granite-3-2-8B-Instruct memanfaatkan kemampuan penalarannya untuk menghasilkan ide pakaian yang dipersonalisasi.

Beberapa langkah selanjutnya untuk membangun aplikasi ini dapat meliputi:

Menyesuaikan pakaian dengan gaya pribadi pengguna, tipe tubuh, palet warna pilihan, dan banyak lagi.
Memperluas kriteria untuk memasukkan jaket dan aksesori. Misalnya, sistem mungkin mengusulkan blazer untuk pengguna yang menghadiri konferensi formal selain kemeja, celana, dan sepatu yang dipilih.
Berfungsi sebagai pembelanja pribadi dengan memberikan rekomendasi produk e-commerce dan harga yang selaras dengan gaya dan anggaran unik pengguna.
Menambahkan fungsi chatbot untuk mengajukan pertanyaan LLM tentang setiap pakaian.
Memberikan pengalaman uji coba virtual yang menggunakan selfie pengguna untuk mensimulasikan tampilan akhir.

Buka kekuatan AI + ML generatif

Pelajari cara menggabungkan AI generatif dan machine learning dengan percaya diri ke dalam bisnis Anda.

Bangun stylist AI dengan IBM Granite menggunakan watsonx.ai