ترکیب GPT-4o با RAG - ساخت اپلیکیشن تطبیق لباس

1%pip install openai --quiet
2%pip install tenacity --quiet
3%pip install tqdm --quiet
4%pip install numpy --quiet
5%pip install typing --quiet
6%pip install tiktoken --quiet
7%pip install concurrent --quiet

 1import pandas as pd
 2import numpy as np
 3import json
 4import ast
 5import tiktoken
 6import concurrent
 7from openai import OpenAI
 8from tqdm import tqdm
 9from tenacity import retry, wait_random_exponential, stop_after_attempt
10from IPython.display import Image, display, HTML
11from typing import List
12
13client = OpenAI(
14    api_key=os.environ.get(("GILAS_API_KEY", "<کلید API خود را اینجا بسازید https://dashboard.gilas.io/apiKey>")), 
15    base_url="https://api.gilas.io/v1/" # Gilas APIs
16)
17
18GPT_MODEL = "gpt-4o"
19EMBEDDING_MODEL = "text-embedding-3-large"
20EMBEDDING_COST_PER_1K_TOKENS = 0.00013

1styles_filepath = "data/sample_clothes/sample_styles.csv"
2styles_df = pd.read_csv(styles_filepath, on_bad_lines='skip')
3print(styles_df.head())
4print("Opened dataset successfully. Dataset has {} items of clothing.".format(len(styles_df)))

 1## Batch Embedding Logic
 2
 3# Simple function to take in a list of text objects and return them as a list of embeddings
 4@retry(wait=wait_random_exponential(min=1, max=40), stop=stop_after_attempt(10))
 5def get_embeddings(input: List):
 6    response = client.embeddings.create(
 7        input=input,
 8        model=EMBEDDING_MODEL
 9    ).data
10    return [data.embedding for data in response]
11
12
13# Splits an iterable into batches of size n.
14def batchify(iterable, n=1):
15    l = len(iterable)
16    for ndx in range(0, l, n):
17        yield iterable[ndx : min(ndx + n, l)]
18     
19
20# Function for batching and parallel processing the embeddings
21def embed_corpus(
22    corpus: List[str],
23    batch_size=64,
24    num_workers=8,
25    max_context_len=8191,
26):
27    # Encode the corpus, truncating to max_context_len
28    encoding = tiktoken.get_encoding("cl100k_base")
29    encoded_corpus = [
30        encoded_article[:max_context_len] for encoded_article in encoding.encode_batch(corpus)
31    ]
32
33    # Calculate corpus statistics: the number of inputs, the total number of tokens, and the estimated cost to embed
34    num_tokens = sum(len(article) for article in encoded_corpus)
35    cost_to_embed_tokens = num_tokens / 1000 * EMBEDDING_COST_PER_1K_TOKENS
36    print(
37        f"num_articles={len(encoded_corpus)}, num_tokens={num_tokens}, est_embedding_cost={cost_to_embed_tokens:.2f} USD"
38    )
39
40    # Embed the corpus
41    with concurrent.futures.ThreadPoolExecutor(max_workers=num_workers) as executor:
42        
43        futures = [
44            executor.submit(get_embeddings, text_batch)
45            for text_batch in batchify(encoded_corpus, batch_size)
46        ]
47
48        with tqdm(total=len(encoded_corpus)) as pbar:
49            for _ in concurrent.futures.as_completed(futures):
50                pbar.update(batch_size)
51
52        embeddings = []
53        for future in futures:
54            data = future.result()
55            embeddings.extend(data)
56
57        return embeddings
58    
59
60# Function to generate embeddings for a given column in a DataFrame
61def generate_embeddings(df, column_name):
62    # Initialize an empty list to store embeddings
63    descriptions = df[column_name].astype(str).tolist()
64    embeddings = embed_corpus(descriptions)
65
66    # Add the embeddings as a new column to the DataFrame
67    df['embeddings'] = embeddings
68    print("Embeddings created successfully.")

1generate_embeddings(styles_df, 'productDisplayName')
2print("Writing embeddings to file ...")
3styles_df.to_csv('data/sample_clothes/sample_styles_with_embeddings.csv', index=False)
4print("Embeddings successfully stored in sample_styles_with_embeddings.csv")

1print(styles_df.head())
2print("Opened dataset successfully. Dataset has {} items of clothing along with their embeddings.".format(len(styles_df)))

 1def cosine_similarity_manual(vec1, vec2):
 2    """Calculate the cosine similarity between two vectors."""
 3    vec1 = np.array(vec1, dtype=float)
 4    vec2 = np.array(vec2, dtype=float)
 5
 6
 7    dot_product = np.dot(vec1, vec2)
 8    norm_vec1 = np.linalg.norm(vec1)
 9    norm_vec2 = np.linalg.norm(vec2)
10    return dot_product / (norm_vec1 * norm_vec2)
11
12
13def find_similar_items(input_embedding, embeddings, threshold=0.5, top_k=2):
14    """Find the most similar items based on cosine similarity."""
15    
16    # Calculate cosine similarity between the input embedding and all other embeddings
17    similarities = [(index, cosine_similarity_manual(input_embedding, vec)) for index, vec in enumerate(embeddings)]
18    
19    # Filter out any similarities below the threshold
20    filtered_similarities = [(index, sim) for index, sim in similarities if sim >= threshold]
21    
22    # Sort the filtered similarities by similarity score
23    sorted_indices = sorted(filtered_similarities, key=lambda x: x[1], reverse=True)[:top_k]
24
25    # Return the top-k most similar items
26    return sorted_indices

 1def find_matching_items_with_rag(df_items, item_descs):
 2   """Take the input item descriptions and find the most similar items based on cosine similarity for each description."""
 3   
 4   # Select the embeddings from the DataFrame.
 5   embeddings = df_items['embeddings'].tolist()
 6
 7   
 8   similar_items = []
 9   for desc in item_descs:
10      
11      # Generate the embedding for the input item
12      input_embedding = get_embeddings([desc])
13    
14      # Find the most similar items based on cosine similarity
15      similar_indices = find_similar_items(input_embedding, embeddings, threshold=0.6)
16      similar_items += [df_items.iloc[i] for i in similar_indices]
17    
18   return similar_items

 1def analyze_image(image_base64, subcategories):
 2    response = client.chat.completions.create(
 3        model=GPT_MODEL,
 4        messages=[
 5            {
 6            "role": "user",
 7            "content": [
 8                {
 9                "type": "text",
10                "text": """Given an image of an item of clothing, analyze the item and generate a JSON output with the following fields: "items", "category", and "gender". 
11                           Use your understanding of fashion trends, styles, and gender preferences to provide accurate and relevant suggestions for how to complete the outfit.
12                           The items field should be a list of items that would go well with the item in the picture. Each item should represent a title of an item of clothing that contains the style, color, and gender of the item.
13                           The category needs to be chosen between the types in this list: {subcategories}.
14                           You have to choose between the genders in this list: [Men, Women, Boys, Girls, Unisex]
15                           Do not include the description of the item in the picture. Do not include the ```json ``` tag in the output.
16                           
17                           Example Input: An image representing a black leather jacket.
18
19                           Example Output: {"items": ["Fitted White Women's T-shirt", "White Canvas Sneakers", "Women's Black Skinny Jeans"], "category": "Jackets", "gender": "Women"}
20                           """,
21                },
22                {
23                "type": "image_url",
24                "image_url": {
25                    "url": f"data:image/jpeg;base64,{image_base64}",
26                },
27                }
28            ],
29            }
30        ],
31        max_tokens=300,
32    )
33    # Extract relevant features from the response
34    features = response.choices[0].message.content
35    return features

1import base64
2
3def encode_image_to_base64(image_path):
4    with open(image_path, 'rb') as image_file:
5        encoded_image = base64.b64encode(image_file.read())
6        return encoded_image.decode('utf-8')

1# Set the path to the images and select a test image
2image_path = "data/sample_clothes/sample_images/"
3test_images = ["2133.jpg", "7143.jpg", "4226.jpg"]
4
5# Encode the test image to base64
6reference_image = image_path + test_images[0]
7encoded_image = encode_image_to_base64(reference_image)

 1# Select the unique subcategories from the DataFrame
 2unique_subcategories = styles_df['articleType'].unique()
 3
 4# Analyze the image and return the results
 5analysis = analyze_image(encoded_image, unique_subcategories)
 6image_analysis = json.loads(analysis)
 7
 8# Display the image and the analysis results
 9display(Image(filename=reference_image))
10print(image_analysis)

 1# Extract the relevant features from the analysis
 2item_descs = image_analysis['items']
 3item_category = image_analysis['category']
 4item_gender = image_analysis['gender']
 5
 6# Filter data such that we only look through the items of the same gender (or unisex) and different category
 7filtered_items = styles_df.loc[styles_df['gender'].isin([item_gender, 'Unisex'])]
 8filtered_items = filtered_items[filtered_items['articleType'] != item_category]
 9print(str(len(filtered_items)) + " Remaining Items")
10
11# Find the most similar items based on the input item descriptions
12matching_items = find_matching_items_with_rag(filtered_items, item_descs)
13
14# Display the matching items (this will display 2 items for each description in the image analysis)
15html = ""
16paths = []
17for i, item in enumerate(matching_items):
18    item_id = item['id']
19        
20    # Path to the image file
21    image_path = f'data/sample_clothes/sample_images/{item_id}.jpg'
22    paths.append(image_path)
23    html += f'<img src="{image_path}" style="display:inline;margin:1px"/>'
24
25# Print the matching item description as a reminder of what we are looking for
26print(item_descs)
27# Display the image
28display(HTML(html))

 1def check_match(reference_image_base64, suggested_image_base64):
 2    response = client.chat.completions.create(
 3        model=GPT_MODEL,
 4        messages=[
 5            {
 6            "role": "user",
 7            "content": [
 8                {
 9                "type": "text",
10                "text": """ You will be given two images of two different items of clothing.
11                            Your goal is to decide if the items in the images would work in an outfit together.
12                            The first image is the reference item (the item that the user is trying to match with another item).
13                            You need to decide if the second item would work well with the reference item.
14                            Your response must be a JSON output with the following fields: "answer", "reason".
15                            The "answer" field must be either "yes" or "no", depending on whether you think the items would work well together.
16                            The "reason" field must be a short explanation of your reasoning for your decision. Do not include the descriptions of the 2 images.
17                            Do not include the ```json ``` tag in the output.
18                           """,
19                },
20                {
21                "type": "image_url",
22                "image_url": {
23                    "url": f"data:image/jpeg;base64,{reference_image_base64}",
24                },
25                },
26                {
27                "type": "image_url",
28                "image_url": {
29                    "url": f"data:image/jpeg;base64,{suggested_image_base64}",
30                },
31                }
32            ],
33            }
34        ],
35        max_tokens=300,
36    )
37    # Extract relevant features from the response
38    features = response.choices[0].message.content
39    return features

 1# Select the unique paths for the generated images
 2paths = list(set(paths))
 3
 4for path in paths:
 5    # Encode the test image to base64
 6    suggested_image = encode_image_to_base64(path)
 7    
 8    # Check if the items match
 9    match = json.loads(check_match(encoded_image, suggested_image))
10    
11    # Display the image and the analysis results
12    if match["answer"] == 'yes':
13        display(Image(filename=path))
14        print("The items match!")
15        print(match["reason"])