Fashion Praise Program Uses Fast, Qdrant

Promotion programs are everywhere. From Netflix and see Amazon. But what if you want to build a visual viewing engine? One looking at a picture, not just a title or tags? In this article, you will create a remuneration program. Will use photos and qdrate database. You will travel green photo data in real-time viewing recommendations.

The purpose of learning

• ModimentDings Rules represent visual content
• How to Use Vector Generation Faster
• How to save and search for veectors using QDRANT
• How to create a Compliment Engine Conducted by Feedback
• How to build a simple UI with streamlit

Apply trial: Views of T-Shirts and Polos

Think of a user clicking on the Stylish Shirt of Polo. Instead of using product tags, your fashion compliment system will recommend T-shirts and polos look like. It uses a picture itself to make that decision.

Let's explore how.

Step 1: Understanding Image Income

What does it mean to embark on a picture?

A rated state of a photo. In a list of numbers. These numbers show important features in the picture. The same two pictures have a close adjoining together in the vector area. This allows the program to measure the visual match.

For example, two different t-shirts can look different pixel smart. But their prevention will be near if they have the same colors, patterns and performance. This is an important skill for the complaint system.

How is the embryo made?

Most preaching models use a deep learning. CNNS (neural networks) issued patterns viewed. These patterns become part of the vector.

To our, we use quick. The recommended embodding model is: qdrant / Unicom-vit-B-32

from fastembed import ImageEmbedding
from typing import List
from dotenv import load_dotenv
import os

load_dotenv()
model = ImageEmbedding(os.getenv("IMAGE_EMBEDDING_MODEL"))

def compute_image_embedding(image_paths: List[str]) -> list[float]:
    return list(model.embed(image_paths))

This work takes a list of pictures. Returns veectors take the context of those pictures.

Step 2: Finding Dataset

We have used a dataset of 2000 male male fashions. You can find GGHle. Here's how we upload data:

import shutil, os, kagglehub
from dotenv import load_dotenv

load_dotenv()
kaggle_repo = os.getenv("KAGGLE_REPO")
path = kagglehub.dataset_download(kaggle_repo)
target_folder = os.getenv("DATA_PATH")

def getData():
    if not os.path.exists(target_folder):
        shutil.copytree(path, target_folder)

This document is viewing when the target folder is located. If not, copying the pictures there.

Step 3: Save and search the edge with QDRANT

Once we are imported, we need to keep and shower. This is where qdrant comes in. It is a quick vector vector vector.

Here's how you can connect to the QRENT VECTOR database:

from qdrant_client import QdrantClient

client = QdrantClient(
    url=os.getenv("QDRANT_URL"),
    api_key=os.getenv("QDRANT_API_KEY"),
)
This is how to insert the images paired with its embedding to a Qdrant collection:
class VectorStore:
    def __init__(self, embed_batch: int = 64, upload_batch: int = 32, parallel_uploads: int = 3):
        # ... (initializer code omitted for brevity) ...

    def insert_images(self, image_paths: List[str]):
        def chunked(iterable, size):
            for i in range(0, len(iterable), size):
                yield iterable[i:i + size]

        for batch in chunked(image_paths, self.embed_batch):
            embeddings = compute_image_embedding(batch)  # Batch embed
            points = [
                models.PointStruct(id=str(uuid.uuid4()), vector=emb, payload={"image_path": img})
                for emb, img in zip(embeddings, batch)
            ]

            # Batch upload each sub-batch
            self.client.upload_points(
                collection_name=self.collection_name,
                points=points,
                batch_size=self.upload_batch,
                parallel=self.parallel_uploads,
                max_retries=3,
                wait=True
            )

This code takes a list of pictures of photos, turning it into the batches in batches, and loading those embedding in the VDRANT group. It first checks if a collection is. Then process the images alike using threads to speed up items. Each picture receives a unique ID and wrapped in “point” in its embarking and the way. These points are then spelled in Qdrant on chunks.

Search the same pictures

def search_similar(query_image_path: str, limit: int = 5):
    emb_list = compute_image_embedding([query_image_path])
    hits = client.search(
        collection_name="fashion_images",
        query_vector=emb_list[0],
        limit=limit
    )
    return [{"id": h.id, "image_path": h.payload.get("image_path")} for h in hits]

He gives a picture of the question. The program returns pictures such as using the same cosline metrics.

Step 4: Create an answer engine for feedback

We now continue the step. What if the user likes other pictures and does not like others? Can a fashion policy program learn from this?

Yes. QRED allows us to give us upbuilding and wrong answer. Then it returns better, the desired consequences.

class RecommendationEngine:
    def get_recommendations(self, liked_images:List[str], disliked_images:List[str], limit=10):
        recommended = client.recommend(
            collection_name="fashion_images",
            positive=liked_images,
            negative=disliked_images,
            limit=limit
        )
        return [{"id": hit.id, "image_path": hit.payload.get("image_path")} for hit in recommended]

Here are you input work:

• Likes_Iages: Picture ID lists represent items for the user.
• Undoubted_Iages: Picture ID lists represent the items the user is unlikely.
• Limit (optional): Number number that describes a maximum amount of returning recommendations (default 10).

This will take the recommended clothes that use the variety of the Vector prevalent in the front.

This allows your system. Reads user preferences immediately.

Step 5: Create UI with streamlit

We use correction in the interface. It's easy, quick, and written in Python.

Users to:

• Browse to a blanket
• Like not like things
• View new, better recommendations

Here is a broadcast code:

import streamlit as st
from PIL import Image
import os

from src.recommendation.engine import RecommendationEngine
from src.vector_database.vectorstore import VectorStore
from src.data.get_data import getData

# -------------- Config --------------
st.set_page_config(page_title="🧥 Men's Fashion Recommender", layout="wide")
IMAGES_PER_PAGE = 12

# -------------- Ensure Dataset Exists (once) --------------
@st.cache_resource
def initialize_data():
    getData()
    return VectorStore(), RecommendationEngine()

vector_store, recommendation_engine = initialize_data()

# -------------- Session State Defaults --------------
session_defaults = {
    "liked": {},
    "disliked": {},
    "current_page": 0,
    "recommended_images": vector_store.points,
    "vector_store": vector_store,
    "recommendation_engine": recommendation_engine,
}

for key, value in session_defaults.items():
    if key not in st.session_state:
        st.session_state[key] = value

# -------------- Sidebar Info --------------
with st.sidebar:
    st.title("🧥 Men's Fashion Recommender")

    st.markdown("""
    **Discover fashion styles that suit your taste.**  
    Like 👍 or dislike 👎 outfits and receive AI-powered recommendations tailored to you.
    """)

    st.markdown("### 📦 Dataset")
    st.markdown("""
    - Source: [Kaggle – virat164/fashion-database](  
    - ~2,000 fashion images
    """)

    st.markdown("### 🧠 How It Works")
    st.markdown("""
    1. Images are embedded into vector space  
    2. You provide preferences via Like/Dislike  
    3. Qdrant finds visually similar images  
    4. Results are updated in real-time
    """)

    st.markdown("### ⚙️ Technologies")
    st.markdown("""
    - **Streamlit** UI  
    - **Qdrant** vector DB  
    - **Python** backend  
    - **PIL** for image handling  
    - **Kaggle API** for data
    """)

    st.markdown("---")
# -------------- Core Logic Functions --------------
def get_recommendations(liked_ids, disliked_ids):
    return st.session_state.recommendation_engine.get_recommendations(
        liked_images=liked_ids,
        disliked_images=disliked_ids,
        limit=3 * IMAGES_PER_PAGE
    )

def refresh_recommendations():
    liked_ids = list(st.session_state.liked.keys())
    disliked_ids = list(st.session_state.disliked.keys())
    st.session_state.recommended_images = get_recommendations(liked_ids, disliked_ids)

# -------------- Display: Selected Preferences --------------
def display_selected_images():
    if not st.session_state.liked and not st.session_state.disliked:
        return

    st.markdown("### 🧍 Your Picks")
    cols = st.columns(6)
    images = st.session_state.vector_store.points

    for i, (img_id, status) in enumerate(
        list(st.session_state.liked.items()) + list(st.session_state.disliked.items())
    ):
        img_path = next((img["image_path"] for img in images if img["id"] == img_id), None)
        if img_path and os.path.exists(img_path):
            with cols[i % 6]:
                st.image(img_path, use_container_width=True, caption=f"{img_id} ({status})")
                col1, col2 = st.columns(2)
                if col1.button("❌ Remove", key=f"remove_{img_id}"):
                    if status == "liked":
                        del st.session_state.liked[img_id]
                    else:
                        del st.session_state.disliked[img_id]
                    refresh_recommendations()
                    st.rerun()

                if col2.button("🔁 Switch", key=f"switch_{img_id}"):
                    if status == "liked":
                        del st.session_state.liked[img_id]
                        st.session_state.disliked[img_id] = "disliked"
                    else:
                        del st.session_state.disliked[img_id]
                        st.session_state.liked[img_id] = "liked"
                    refresh_recommendations()
                    st.rerun()

# -------------- Display: Recommended Gallery --------------
def display_gallery():
    st.markdown("### 🧠 Smart Suggestions")

    page = st.session_state.current_page
    start_idx = page * IMAGES_PER_PAGE
    end_idx = start_idx + IMAGES_PER_PAGE
    current_images = st.session_state.recommended_images[start_idx:end_idx]

    cols = st.columns(4)
    for idx, img in enumerate(current_images):
        with cols[idx % 4]:
            if os.path.exists(img["image_path"]):
                st.image(img["image_path"], use_container_width=True)
            else:
                st.warning("Image not found")

            col1, col2 = st.columns(2)
            if col1.button("👍 Like", key=f"like_{img['id']}"):
                st.session_state.liked[img["id"]] = "liked"
                refresh_recommendations()
                st.rerun()
            if col2.button("👎 Dislike", key=f"dislike_{img['id']}"):
                st.session_state.disliked[img["id"]] = "disliked"
                refresh_recommendations()
                st.rerun()

    # Pagination
    col1, _, col3 = st.columns([1, 2, 1])
    with col1:
        if st.button("⬅️ Previous") and page > 0:
            st.session_state.current_page -= 1
            st.rerun()
    with col3:
        if st.button("➡️ Next") and end_idx < len(st.session_state.recommended_images):
            st.session_state.current_page += 1
            st.rerun()

# -------------- Main Render Pipeline --------------
st.title("🧥 Men's Fashion Recommender")

display_selected_images()
st.divider()
display_gallery()

This UI closes the loop. It turns a function into a usable product.

Store

He just created a complete fashion plan. It sees pictures, understand the material factors, and make the smart suggestions.

Using Fastembod, qdrant, and correction, you now have a strong recommendation program. It works with T-shirts, polos and male garment but can be changed to any other recommendations based on the illustration.

Frequently Asked Questions