%pip install openai --quiet
%pip install tenacity --quiet
%pip install tqdm --quiet
%pip install numpy --quiet
%pip install typing --quiet
%pip install tiktoken --quiet
%pip install concurrent --quiet

import pandas as pd
import numpy as np
import json
import ast
import tiktoken
import concurrent
from openai import OpenAI
from tqdm import tqdm
from tenacity import retry, wait_random_exponential, stop_after_attempt
from IPython.display import Image, display, HTML
from typing import List
 
client = OpenAI()
 
GPT_MODEL = "gpt-4-vision-preview"
EMBEDDING_MODEL = "text-embedding-3-large"
EMBEDDING_COST_PER_1K_TOKENS = 0.00013

styles_filepath = "data/sample_clothes/sample_styles.csv"
styles_df = pd.read_csv(styles_filepath, on_bad_lines='skip')
print(styles_df.head())
print("データセットを正常に開きました。データセットには{}個の洋服アイテムがあります。".format(len(styles_df)))

## バッチ埋め込みロジック
 
# テキストオブジェクトのリストを入力として受け取り、埋め込みのリストとして返すシンプルな関数
@retry(wait=wait_random_exponential(min=1, max=40), stop=stop_after_attempt(10))
def get_embeddings(input: List):
    response = client.embeddings.create(
        input=input,
        model=EMBEDDING_MODEL
    ).data
    return [data.embedding for data in response]
 
 
# イテラブルをサイズnのバッチに分割する関数
def batchify(iterable, n=1):
    l = len(iterable)
    for ndx in range(0, l, n):
        yield iterable[ndx : min(ndx + n, l)]
     
 
# バッチ処理と並列処理のための関数
def embed_corpus(
    corpus: List[str],
    batch_size=64,
    num_workers=8,
    max_context_len=8191,
):
    # エンコードされたコーパスを生成し、max_context_lenに切り詰める
    encoding = tiktoken.get_encoding("cl100k_base")
    encoded_corpus = [
        encoded_article[:max_context_len] for encoded_article in encoding.encode_batch(corpus)
    ]
 
    # コーパスの統計情報（入力の数、トークンの総数、埋め込みの推定コスト）を計算する
    num_tokens = sum(len(article) for article in encoded_corpus)
    cost_to_embed_tokens = num_tokens / 1000 * EMBEDDING_COST_PER_1K_TOKENS
    print(
        f"num_articles={len(encoded_corpus)}, num_tokens={num_tokens}, est_embedding_cost={cost_to_embed_tokens:.2f} USD"
    )
 
    # コーパスを埋め込む
    with concurrent.futures.ThreadPoolExecutor(max_workers=num_workers) as executor:
        
        futures = [
            executor.submit(get_embeddings, text_batch)
            for text_batch in batchify(encoded_corpus, batch_size)
        ]
 
        with tqdm(total=len(encoded_corpus)) as pbar:
            for _ in concurrent.futures.as_completed(futures):
                pbar.update(batch_size)
 
        embeddings = []
        for future in futures:
            data = future.result()
            embeddings.extend(data)
 
        return embeddings
    
# DataFrameの指定された列のための埋め込みを生成する関数
def generate_embeddings(df, column_name):
    # 埋め込みを格納するための空のリストを初期化する
    descriptions = df[column_name].astype(str).tolist()
    embeddings = embed_corpus(descriptions)
 
    # 埋め込みをDataFrameに新しい列として追加する
    df['embeddings'] = embeddings
    print("埋め込みが正常に作成されました。")

generate_embeddings(styles_df, 'productDisplayName')
print("埋め込みをファイルに書き込んでいます...")
styles_df.to_csv('data/sample_clothes/sample_styles_with_embeddings.csv', index=False)
print("埋め込みがsample_styles_with_embeddings.csvに正常に保存されました。")

# styles_df = pd.read_csv('data/sample_clothes/sample_styles_with_embeddings.csv', on_bad_lines='skip')
 
# # 'embeddings'列を文字列のリストから実際のfloatのリストに変換する
# styles_df['embeddings'] = styles_df['embeddings'].apply(lambda x: ast.literal_eval(x))
 
print(styles_df.head())
print("データセットを正常に開きました。データセットには{}個の洋服アイテムがあり、埋め込みも含まれています。".format(len(styles_df)))

def cosine_similarity_manual(vec1, vec2):
    """2つのベクトル間のコサイン類似度を計算します。"""
    vec1 = np.array(vec1, dtype=float)
    vec2 = np.array(vec2, dtype=float)
 
 
    dot_product = np.dot(vec1, vec2)
    norm_vec1 = np.linalg.norm(vec1)
    norm_vec2 = np.linalg.norm(vec2)
    return dot_product / (norm_vec1 * norm_vec2)
 
 
def find_similar_items(input_embedding, embeddings, threshold=0.5, top_k=2):
    """コサイン類似度に基づいて最も類似したアイテムを見つけます。"""
    
    # 入力の埋め込みと他のすべての埋め込みの間のコサイン類似度を計算する
    similarities = [(index, cosine_similarity_manual(input_embedding, vec)) for index, vec in enumerate(embeddings)]
    
    # しきい値以下の類似度をフィルタリングする
    filtered_similarities = [(index, sim) for index, sim in similarities if sim >= threshold]
    
    # 類似度スコアでフィルタリングされた類似度をソートする
    sorted_indices = sorted(filtered_similarities, key=lambda x: x[1], reverse=True)[:top_k]
 
    # 上位k個の最も類似したアイテムを返す
    return sorted_indices

def find_matching_items_with_rag(df_items, item_descs):
   """入力のアイテムの説明を取り、コサイン類似度に基づいて最も類似したアイテムを見つけます。"""
   
   # DataFrameから埋め込みを選択する
   embeddings = df_items['embeddings'].tolist()
 
   
   similar_items = []
   for desc in item_descs:
      
      # 入力アイテムの埋め込みを生成する
      input_embedding = get_embeddings([desc])
    
      # コサイン類似度に基づいて最も類似したアイテムを見つける
      similar_indices = find_similar_items(input_embedding, embeddings, threshold=0.6)
      similar_items += [df_items.iloc[i] for i in similar_indices]
    
   return similar_items

def analyze_image(image_base64, subcategories):
    response = client.chat.completions.create(
        model=GPT_MODEL,
        messages=[
            {
            "role": "user",
            "content": [
                {
                "type": "text",
                "text": """洋服のアイテムの画像が与えられた場合、アイテムを分析し、「items」、「category」、「gender」というフィールドを持つJSON出力を生成します。
                           ファッションのトレンド、スタイル、性別の傾向を理解して、元のコーディネートに合う正確で関連性の高い提案を提供します。
                           itemsフィールドは、元の画像のアイテムと一緒に合うアイテムのタイトルのリストで、スタイル、色、性別を含んでいる必要があります。
                           カテゴリは、このリストのタイプから選択する必要があります：{subcategories}。
                           性別は、このリストから選択する必要があります：[Men, Women, Boys, Girls, Unisex]。
                           画像の説明を含めないでください。出力に```json```タグを含めないでください。
                           
                           例：黒のレザージャケットを表す画像が与えられた場合。
 
                           出力例：{"items": ["フィットした白い女性用Tシャツ", "白いキャンバススニーカー", "女性用の黒いスキニージーンズ"], "category": "ジャケット", "gender": "Women"}
                           """,
                },
                {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{image_base64}",
                },
                }
            ],
            }
        ],
        max_tokens=300,
    )
    # 応答から関連する特徴を抽出する
    features = response.choices[0].message.content
    return features

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

# 画像のパスを設定し、テスト画像を選択します
image_path = "data/sample_clothes/sample_images/"
test_images = ["2133.jpg", "7143.jpg", "4226.jpg"]
 
# テスト画像をベース64にエンコードします
reference_image = image_path + test_images[0]
encoded_image = encode_image_to_base64(reference_image)

# DataFrameから一意のサブカテゴリを選択します
unique_subcategories = styles_df['articleType'].unique()
 
# 画像を分析し、結果を返します
analysis = analyze_image(encoded_image, unique_subcategories)
image_analysis = json.loads(analysis)
 
# 画像と分析結果を表示します
display(Image(filename=reference_image))
print(image_analysis)

import requests
import openai_secret_manager
 
# Get your OpenAI API key
openai_secret_manager.set_secret_name("openai")
api_key = openai_secret_manager.get_secret() 
 
# Create a Vision model using GPT-4
def create_vision_model():
    response = requests.post(
        "https://api.openai.com/v1/models",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        },
        json={
            "nlp": "image-detection",
            "model": "gpt-4.0-vision-preview",
        },
    )
    return response.json()
 
# Create the Vision model
model_info = create_vision_model()
print(model_info)

{
  "id": "gpt-4.0-vision-preview-davinci",
  "object": "model",
  "created": 1677649428,
  "model_version": {
    "id": "gpt-4.0-vision-preview-davinci:1",
    "object": "version",
    "created": 1677649428
  }
}

import base64
 
def encode_image_to_base64(image_path):
    with open(image_path, "rb") as image_file:
        encoded_string = base64.b64encode(image_file.read()).decode("utf-8")
    return encoded_string

def analyze_image(image_base64, model):
    response = requests.post(
        f"https://api.openai.com/v1/models/{model}/completions",
        headers={
            "Authorization": f"Bearer {api_key}",
            "Content-Type": "application/json",
        },
        json={
            "nlp": "image-detection",
            "gpt_model": model,
            "inputs": {
                "images": [{"image": image_base64}],
            },
            "num_outputs": 1,
        },
    )
    return response.json()
 
# Encode the image to base64
encoded_image = encode_image_to_base64("path_to_image.jpg")
 
# Analyze the image using the GPT-4 Vision model
analysis = analyze_image(encoded_image, model_info["id"])
print(analysis)

import pandas as pd
 
# Load the fashion dataset
styles_df = pd.read_csv("path_to_styles.csv")
 
# Find matching items based on the input item description
def find_matching_items_with_rag(data, descriptions):
    #...
    return matching_items
 
# Extract the relevant features from the analysis
item_descs = image_analysis['items']
item_category = image_analysis['category']
item_gender = image_analysis['gender']
 
# Filter data such that we only look through the items of the same gender (or unisex) and different category
filtered_items = styles_df.loc[styles_df['gender'].isin([item_gender, 'Unisex'])]
filtered_items = filtered_items[filtered_items['articleType'] != item_category]
print(str(len(filtered_items)) + " Remaining Items")
 
# Find the most similar items based on the input item descriptions
matching_items = find_matching_items_with_rag(filtered_items, item_descs)
 
# Display the matching items (this will display 2 items for each description in the image analysis)
html = ""
paths = []
for i, item in enumerate(matching_items):
    item_id = item['id']
        
    # Path to the image file
    image_path = f'data/sample_clothes/sample_images/{item_id}.jpg'
    paths.append(image_path)
    html += f'<img src="{image_path}" style="display:inline;margin:1px"/>'
 
# Print the matching item description as a reminder of what we are looking for
print(item_descs)
# Display the image
display(HTML(html))

def check_match(reference_image_base64, suggested_image_base64):
    response = client.chat.completions.create(
        model=GPT_MODEL,
        messages=[
            {
            "role": "user",
            "content": [
                {
                "type": "text",
                "text": """ You will be given two images of two different items of clothing.
                            Your goal is to decide if the items in the images would work in an outfit together.
                            The first image is the reference item (the item that the user is trying to match with another item).
                            You need to decide if the second item would work well with the reference item.
                            Your response must be a JSON output with the following fields: "answer", "reason".
                            The "answer" field must be either "yes" or "no", depending on whether you think the items would work well together.
                            The "reason" field must be a short explanation of your reasoning for your decision. Do not include the descriptions of the 2 images.
                            Do not include the ```json ``` tag in the output.
                           """,
                },
                {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{reference_image_base64}",
                },
                },
                {
                "type": "image_url",
                "image_url": {
                    "url": f"data:image/jpeg;base64,{suggested_image_base64}",
                },
                }
            ],
            }
        ],
        max_tokens=300,
    )
    # Extract relevant features from the response
    features = response.choices[0].message.content
    return features

# Select the unique paths for the generated images
paths = list(set(paths))
 
for path in paths:
    # Encode the test image to base64
    suggested_image = encode_image_to_base64(path)
    
    # Check if the items match
    match = json.loads(check_match(encoded_image, suggested_image))
    
    # Display the image and the analysis results
    if match["answer"] == 'yes':
        display(Image(filename=path))
        print("The items match!")
        print(match["reason"])