import io import ast import json import base64 import spaces import requests import numpy as np import gradio as gr from PIL import Image from io import BytesIO import face_recognition from turtle import title from openai import OpenAI from collections import Counter from transformers import pipeline import urllib.request from transformers import YolosImageProcessor, YolosForObjectDetection import torch import matplotlib.pyplot as plt from torchvision.transforms import ToTensor, ToPILImage client = OpenAI() pipe = pipeline("zero-shot-image-classification", model="patrickjohncyh/fashion-clip") color_file_path = 'color_config.json' attributes_file_path = 'attributes_config.json' import os OPENAI_API_KEY = os.getenv("OPENAI_API_KEY") # Open and read the COLOR JSON file with open(color_file_path, 'r') as file: color_data = json.load(file) # Open and read the ATTRIBUTES JSON file with open(attributes_file_path, 'r') as file: attributes_data = json.load(file) COLOURS_DICT = color_data['color_mapping'] ATTRIBUTES_DICT = attributes_data['attribute_mapping'] def shot(input, category, level): output_dict = {} if level == 'variant': subColour, mainColour, score = get_colour(ast.literal_eval(str(input)), category) openai_parsed_response = get_openAI_tags(ast.literal_eval(str(input))) face_embeddings = get_face_embeddings(ast.literal_eval(str(input))) cropped_images = get_cropped_images(ast.literal_eval(str(input)), category) # Ensure all outputs are JSON serializable output_dict['colors'] = { "main": mainColour, "sub": subColour, "score": score } output_dict['image_mapping'] = openai_parsed_response output_dict['face_embeddings'] = face_embeddings output_dict['cropped_images'] = cropped_images if level == 'product': common_result = get_predicted_attributes(ast.literal_eval(str(input)), category) output_dict['attributes'] = common_result output_dict['subcategory'] = category # # Convert the dictionary to a JSON-serializable format # try: # serialized_output = json.dumps(output_dict) # except TypeError as e: # print(f"Serialization Error: {e}") # return {"error": "Serialization failed"} return json.dumps(output_dict) # @spaces.GPU # def get_colour(image_urls, category): # colourLabels = list(COLOURS_DICT.keys()) # for i in range(len(colourLabels)): # colourLabels[i] = colourLabels[i] + " clothing: " + category # responses = pipe(image_urls, candidate_labels=colourLabels) # # Get the most common colour # mainColour = responses[0][0]['label'].split(" clothing:")[0] # if mainColour not in COLOURS_DICT: # return None, None, None # # Add category to the end of each label # labels = COLOURS_DICT[mainColour] # for i in range(len(labels)): # labels[i] = labels[i] + " clothing: " + category # # Run pipeline in one go # responses = pipe(image_urls, candidate_labels=labels) # subColour = responses[0][0]['label'].split(" clothing:")[0] # return subColour, mainColour, responses[0][0]['score'] @spaces.GPU def get_colour(image_urls, category): # Prepare color labels colourLabels = [f"{color} clothing: {category}" for color in COLOURS_DICT.keys()] print("Colour Labels:", colourLabels) # Debug: Print colour labels print("Image URLs:", image_urls) # Debug: Print image URLs # Split labels into two batches mid_index = len(colourLabels) // 2 first_batch = colourLabels[:mid_index] second_batch = colourLabels[mid_index:] # Process the first batch responses_first_batch = pipe(image_urls, candidate_labels=first_batch) # Get the top 3 from the first batch top3_first_batch = sorted(responses_first_batch[0], key=lambda x: x['score'], reverse=True)[:3] # Process the second batch responses_second_batch = pipe(image_urls, candidate_labels=second_batch) # Get the top 3 from the second batch top3_second_batch = sorted(responses_second_batch[0], key=lambda x: x['score'], reverse=True)[:3] # Combine the top 3 from each batch combined_top6 = top3_first_batch + top3_second_batch # Get the final top 3 from the combined list final_top3 = sorted(combined_top6, key=lambda x: x['score'], reverse=True)[:3] mainColour = final_top3[0]['label'].split(" clothing:")[0] if mainColour not in COLOURS_DICT: return None, None, None # Get sub-colors for the main color labels = [f"{label} clothing: {category}" for label in COLOURS_DICT[mainColour]] print("Labels for pipe:", labels) # Debug: Confirm labels are correct responses = pipe(image_urls, candidate_labels=labels) subColour = responses[0][0]['label'].split(" clothing:")[0] return subColour, mainColour, responses[0][0]['score'] @spaces.GPU def get_predicted_attributes(image_urls, category): # Assuming ATTRIBUTES_DICT and pipe are defined outside this function attributes = list(ATTRIBUTES_DICT.get(category, {}).keys()) # Mapping of possible values per attribute common_result = [] for attribute in attributes: values = ATTRIBUTES_DICT.get(category, {}).get(attribute, []) if len(values) == 0: continue # Adjust labels for the pipeline to be in format: "{attr}: {value}, clothing: {category}" attribute_formatted = attribute.replace("colartype", "collar").replace("sleevelength", "sleeve length").replace("fabricstyle", "fabric") values_formatted = [f"{attribute_formatted}: {value}, clothing: {category}" for value in values] # Get the predicted values for the attribute responses = pipe(image_urls, candidate_labels=values_formatted) result = [response[0]['label'].split(", clothing:")[0] for response in responses] # If attribute is details, then get the top 2 most common labels if attribute_formatted == "details": result += [response[1]['label'].split(", clothing:")[0] for response in responses] common_result.append(Counter(result).most_common(2)) else: common_result.append(Counter(result).most_common(1)) # Clean up the results into one long string for i, result in enumerate(common_result): common_result[i] = ", ".join([f"{x[0]}" for x in result]) result = {} # Iterate through the list and split each item into key and value for item in common_result: # Split by ': ' to separate the key and value key, value = item.split(': ', 1) if key == "details": details_split = value.split(" , ") if len(details_split) == 2: result["details1"] = details_split[0].lower() result["details2"] = details_split[1].lower() else: result["details1"] = value.lower() # If there's only one detail, assign it to details 1 else: result[key.lower().replace("collar", "colartype").replace("sleeve length", "sleevelength").replace("fabric", "fabricstyle")] = value.lower() return result def get_openAI_tags(image_urls): # Create list containing JSONs of each image URL imageList = [] for image in image_urls: imageList.append({"type": "image_url", "image_url": {"url": image}}) try: openai_response = client.chat.completions.create( model="gpt-4o", messages=[ { "role": "system", "content": [ { "type": "text", "text": "You're a tagging assistant, you will help label and tag product pictures for my online e-commerce platform. Your tasks will be to return which angle the product images were taken from. You will have to choose from 'full-body', 'half-body', 'side', 'back', or 'zoomed' angles. You should label each of the images with one of these labels depending on which you think fits best (ideally, every label should be used at least once, but only if there are 5 or more images), and should respond with an unformatted dictionary where the key is a string representation of the url index of the url and the value is the assigned label." } ] }, { "role": "user", "content": imageList }, ], temperature=1, max_tokens=500, top_p=1, frequency_penalty=0, presence_penalty=0 ) response = json.loads(openai_response.choices[0].message.content) return response except Exception as e: print(f"OpenAI API Error: {e}") return {} @spaces.GPU def get_face_embeddings(image_urls): # Initialize a dictionary to store the face encodings or errors results = {} # Loop through each image URL for index, url in enumerate(image_urls): try: # Try to download the image from the URL response = requests.get(url) # Raise an exception if the response is not successful response.raise_for_status() # Load the image using face_recognition image = face_recognition.load_image_file(BytesIO(response.content)) # Get the face encodings for all faces in the image face_encodings = face_recognition.face_encodings(image) # If no faces are detected, store an empty list if not face_encodings: results[str(index)] = [] else: # Otherwise, store the first face encoding as a list results[str(index)] = face_encodings[0].tolist() except Exception as e: # If any error occurs during the download or processing, store the error message results[str(index)] = f"Error processing image: {str(e)}" return results # new ACCURACY_THRESHOLD = 0.86 def open_image_from_url(url): # Fetch the image from the URL response = requests.get(url, stream=True) response.raise_for_status() # Check if the request was successful # Open the image using PIL image = Image.open(BytesIO(response.content)) return image # Add the main data to the session state main = [['Product Id', 'Sku', 'Color', 'Images', 'Status', 'Category', 'Text']] # This is the order of the categories list. NO NOT CHANGE. Just for visualization purposes cats = ['shirt, blouse', 'top, t-shirt, sweatshirt', 'sweater', 'cardigan', 'jacket', 'vest', 'pants', 'shorts', 'skirt', 'coat', 'dress', 'jumpsuit', 'cape', 'glasses', 'hat', 'headband, head covering, hair accessory', 'tie', 'glove', 'watch', 'belt', 'leg warmer', 'tights, stockings', 'sock', 'shoe', 'bag, wallet', 'scarf', 'umbrella', 'hood', 'collar', 'lapel', 'epaulette', 'sleeve', 'pocket', 'neckline', 'buckle', 'zipper', 'applique', 'bead', 'bow', 'flower', 'fringe', 'ribbon', 'rivet', 'ruffle', 'sequin', 'tassel'] filter = ['dress', 'jumpsuit', 'cape', 'glasses', 'hat', 'headband, head covering, hair accessory', 'tie', 'glove', 'watch', 'belt', 'leg warmer', 'tights, stockings', 'sock', 'shoe', 'scarf', 'umbrella', 'hood', 'collar', 'lapel', 'epaulette', 'sleeve', 'pocket', 'neckline', 'buckle', 'zipper', 'applique', 'bead', 'bow', 'flower', 'fringe', 'ribbon', 'rivet', 'ruffle', 'sequin', 'tassel'] # 0 for full body, 1 for upper body, 2 for lower body, 3 for over body (jacket, coat, etc), 4 for accessories yolo_mapping = { 'shirt, blouse': 3, 'top, t-shirt, sweatshirt' : 1, 'sweater': 1, 'cardigan': 1, 'jacket': 3, 'vest': 1, 'pants': 2, 'shorts': 2, 'skirt': 2, 'coat': 3, 'dress': 0, 'jumpsuit': 0, 'bag, wallet': 4 } # First line full body, second line upper body, third line lower body, fourth line over body, fifth line accessories label_mapping = [ ['women-dress-mini', 'women-dress-dress', 'women-dress-maxi', 'women-dress-midi', 'women-playsuitsjumpsuits-playsuit', 'women-playsuitsjumpsuits-jumpsuit', 'women-coords-coords', 'women-swimwear-onepieces', 'women-swimwear-bikinisets'], ['women-sweatersknits-cardigan', 'women-top-waistcoat', 'women-top-blouse', 'women-sweatersknits-blouse', 'women-sweatersknits-sweater', 'women-top-top', 'women-loungewear-hoodie', 'women-top-camistanks', 'women-top-tshirt', 'women-top-croptop', 'women-loungewear-sweatshirt', 'women-top-body'], ['women-loungewear-joggers', 'women-bottom-trousers', 'women-bottom-leggings', 'women-bottom-jeans', 'women-bottom-shorts', 'women-bottom-skirt', 'women-loungewear-activewear', 'women-bottom-joggers'], ['women-top-shirt', 'women-outwear-coatjacket', 'women-outwear-blazer', 'women-outwear-coatjacket', 'women-outwear-kimonos'], ['women-accessories-bags'] ] MODEL_NAME = "valentinafeve/yolos-fashionpedia" feature_extractor = YolosImageProcessor.from_pretrained('hustvl/yolos-small') model = YolosForObjectDetection.from_pretrained(MODEL_NAME) def get_category_index(category): # Find index of label mapping for i, labels in enumerate(label_mapping): if category in labels: break return i def get_yolo_index(category): # Find index of yolo mapping return yolo_mapping[category] def fix_channels(t): """ Some images may have 4 channels (transparent images) or just 1 channel (black and white images), in order to let the images have only 3 channels. I am going to remove the fourth channel in transparent images and stack the single channel in back and white images. :param t: Tensor-like image :return: Tensor-like image with three channels """ if len(t.shape) == 2: return ToPILImage()(torch.stack([t for i in (0, 0, 0)])) if t.shape[0] == 4: return ToPILImage()(t[:3]) if t.shape[0] == 1: return ToPILImage()(torch.stack([t[0] for i in (0, 0, 0)])) return ToPILImage()(t) def idx_to_text(i): return cats[i] # Random colors used for visualization COLORS = [[0.000, 0.447, 0.741], [0.850, 0.325, 0.098], [0.929, 0.694, 0.125], [0.494, 0.184, 0.556], [0.466, 0.674, 0.188], [0.301, 0.745, 0.933]] # for output bounding box post-processing def box_cxcywh_to_xyxy(x): x_c, y_c, w, h = x.unbind(1) b = [(x_c - 0.5 * w), (y_c - 0.5 * h), (x_c + 0.5 * w), (y_c + 0.5 * h)] return torch.stack(b, dim=1) def rescale_bboxes(out_bbox, size): img_w, img_h = size b = box_cxcywh_to_xyxy(out_bbox) b = b * torch.tensor([img_w, img_h, img_w, img_h], dtype=torch.float32) return b def plot_results(pil_img, prob, boxes): plt.figure(figsize=(16,10)) plt.imshow(pil_img) ax = plt.gca() colors = COLORS * 100 i = 0 crops = [] crop_classes = [] for p, (xmin, ymin, xmax, ymax), c in zip(prob, boxes.tolist(), colors): cl = p.argmax() # Save each box as an image box_img = pil_img.crop((xmin, ymin, xmax, ymax)) crops.append(box_img) crop_classes.append(idx_to_text(cl)) ax.add_patch(plt.Rectangle((xmin, ymin), xmax - xmin, ymax - ymin, fill=False, color=c, linewidth=3)) ax.text(xmin, ymin, idx_to_text(cl), fontsize=10, bbox=dict(facecolor=c, alpha=0.8)) i += 1 # Remove white padding all around the image plt.axis('off') plt.subplots_adjust(left=0, right=1, top=1, bottom=0) output_img = plt.gcf() plt.close() return output_img, crops, crop_classes def visualize_predictions(image, outputs, threshold=0.8): # Keep only predictions with confidence >= threshold probas = outputs.logits.softmax(-1)[0, :, :-1] keep = probas.max(-1).values > threshold # Convert predicted boxes from [0; 1] to image scales bboxes_scaled = rescale_bboxes(outputs.pred_boxes[0, keep].cpu(), image.size) # Get filtered probabilities and boxes based on the filter list filter_set = set(filter) filtered_probas_boxes = [ (proba, box) for proba, box in zip(probas[keep], bboxes_scaled) if idx_to_text(proba.argmax()) not in filter_set ] # If there is a jumpsuit or dress detected, remove them if there are other clothes detected contains_jumpsuit_or_dress = any(idx_to_text(proba.argmax()) in ["jumpsuit", "dress"] for proba, _ in filtered_probas_boxes) if contains_jumpsuit_or_dress and len(filtered_probas_boxes) > 1: filtered_probas_boxes = [ (proba, box) for proba, box in filtered_probas_boxes if idx_to_text(proba.argmax()) not in ["jumpsuit", "dress"] ] # Remove duplicates: Only keep one box per class unique_classes = set() unique_filtered_probas_boxes = [] for proba, box in filtered_probas_boxes: class_text = idx_to_text(proba.argmax()) if class_text not in unique_classes: unique_classes.add(class_text) unique_filtered_probas_boxes.append((proba, box)) # If there are remaining filtered probabilities, plot results output_img = None crops = None crop_classes = None if unique_filtered_probas_boxes: final_probas, final_boxes = zip(*unique_filtered_probas_boxes) output_img, crops, crop_classes = plot_results(image, list(final_probas), torch.stack(final_boxes)) # Return the classes of the detected objects return [proba.argmax().item() for proba, _ in unique_filtered_probas_boxes], output_img, crops, crop_classes @spaces.GPU def get_objects(image, threshold=0.8): class_counts = {} image = fix_channels(ToTensor()(image)) image = image.resize((600, 800)) inputs = feature_extractor(images=image, return_tensors="pt") outputs = model(**inputs) detected_classes, output_img, crops, crop_classes = visualize_predictions(image, outputs, threshold=threshold) for cl in detected_classes: class_name = idx_to_text(cl) if class_name not in class_counts: class_counts[class_name] = 0 class_counts[class_name] += 1 if crop_classes is not None: crop_classes = [get_yolo_index(c) for c in crop_classes] return class_counts, output_img, crops, crop_classes def encode_images_to_base64(cropped_list): base64_images = [] for image in cropped_list: with io.BytesIO() as buffer: image.convert('RGB').save(buffer, format='JPEG') base64_image = base64.b64encode(buffer.getvalue()).decode('utf-8') base64_images.append(base64_image) return base64_images # def get_cropped_images(images,category): # cropped_list = [] # resultsPerCategory = {} # for num, image in enumerate(images): # image = open_image_from_url(image) # class_counts, output_img, cropped_images, cropped_classes = get_objects(image, 0.37) # if not class_counts: # continue # # Get the inverse category as any other mapping label except the current one corresponding category # inverse_category = [label for i, labels in enumerate(label_mapping) for label in labels if i != get_category_index(category) and i != 0] # # If category is a cardigan, we don't recommend category indices 1 and 3 # if category == 'women-sweatersknits-cardigan': # inverse_category = [label for i, labels in enumerate(label_mapping) for label in labels if i != get_category_index(category) and i != 1 and i != 3] # for i, image in enumerate(cropped_images): # cropped_category = cropped_classes[i] # print(cropped_category, cropped_classes[i], get_category_index(category)) # specific_category = label_mapping[cropped_category] # if cropped_category == get_category_index(category): # continue # cropped_list.append(image) # base64_images = encode_images_to_base64(cropped_list) # return base64_images def get_cropped_images(images, category): cropped_list = [] resultsPerCategory = {} for num, image in enumerate(images): try: image = open_image_from_url(image) class_counts, output_img, cropped_images, cropped_classes = get_objects(image, 0.37) if not class_counts: continue for i, image in enumerate(cropped_images): cropped_list.append(image) except Exception as e: print(f"Error processing image {num}: {e}") return [] # Convert cropped images to base64 strings base64_images = encode_images_to_base64(cropped_list) return base64_images # Define the Gradio interface with the updated components iface = gr.Interface( fn=shot, inputs=[ gr.Textbox(label="Image URLs (starting with http/https) comma seperated "), gr.Textbox(label="Category"), gr.Textbox(label="Level; accepted 'variant' or 'product'") ], outputs="text", examples=[ [['https://d2q1sfov6ca7my.cloudfront.net/eyJidWNrZXQiOiAiaGljY3VwLWltYWdlLWhvc3RpbmciLCAia2V5IjogIlc4MDAwMDAwMTM0LU9SL1c4MDAwMDAwMTM0LU9SLTEuanBnIiwgImVkaXRzIjogeyJyZXNpemUiOiB7IndpZHRoIjogODAwLCAiaGVpZ2h0IjogMTIwMC4wLCAiZml0IjogIm91dHNpZGUifX19', 'https://d2q1sfov6ca7my.cloudfront.net/eyJidWNrZXQiOiAiaGljY3VwLWltYWdlLWhvc3RpbmciLCAia2V5IjogIlc4MDAwMDAwMTM0LU9SL1c4MDAwMDAwMTM0LU9SLTIuanBnIiwgImVkaXRzIjogeyJyZXNpemUiOiB7IndpZHRoIjogODAwLCAiaGVpZ2h0IjogMTIwMC4wLCAiZml0IjogIm91dHNpZGUifX19', 'https://d2q1sfov6ca7my.cloudfront.net/eyJidWNrZXQiOiAiaGljY3VwLWltYWdlLWhvc3RpbmciLCAia2V5IjogIlc4MDAwMDAwMTM0LU9SL1c4MDAwMDAwMTM0LU9SLTMuanBnIiwgImVkaXRzIjogeyJyZXNpemUiOiB7IndpZHRoIjogODAwLCAiaGVpZ2h0IjogMTIwMC4wLCAiZml0IjogIm91dHNpZGUifX19'], "women-top-shirt","variant"]], description="Add an image URL (starting with http/https) or upload a picture, and provide a list of labels separated by commas.", title="Full product flow" ) # Launch the interface iface.launch()