Adding project files

.gitignore

@@ -0,0 +1 @@
+.env

.idea/.gitignore

@@ -0,0 +1,8 @@
+# Default ignored files
+/shelf/
+/workspace.xml
+# Editor-based HTTP Client requests
+/httpRequests/
+# Datasource local storage ignored files
+/dataSources/
+/dataSources.local.xml

.idea/Motager-AI-Product-Helper.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,16 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="bayesnet.model.Node" />
+          <option value="bayesnet.model.DiscreteDistribution" />
+          <option value="bayesnet.model.ConditionalProbabilityTable" />
+          <option value="bayesnet.model.BayesianNetwork" />
+          <option value="bluetooth" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/Motager-AI-Product-Helper.iml" filepath="$PROJECT_DIR$/.idea/Motager-AI-Product-Helper.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="" vcs="Git" />
+  </component>
+</project>

API_main.py

@@ -0,0 +1,228 @@
+from fastapi import FastAPI, HTTPException, Request
+from fastapi.responses import JSONResponse
+from fastapi.exceptions import RequestValidationError
+from fastapi.middleware.cors import CORSMiddleware
+from pydantic import BaseModel
+from typing import List
+import asyncio
+import os
+from concurrent.futures import ThreadPoolExecutor
+from dotenv import load_dotenv
+from Generate_caption import load_model_from_path, tokenizer_load
+from Color_extraction import extract_colors
+from Generate_productName_description import generate_product_name, generate_description, clean_response
+from huggingface_hub import hf_hub_download
+import tempfile
+
+app = FastAPI()
+
+# CORS Middleware
+app.add_middleware(
+    CORSMiddleware,
+    allow_origins=["http://localhost:3000"],
+    allow_credentials=True,
+    allow_methods=["*"],
+    allow_headers=["*"],
+)
+
+# Load environment variables
+load_dotenv()
+API_KEY = os.getenv("API_KEY")
+if not API_KEY:
+    raise ValueError("API_KEY not set. Please configure your .env file or system environment.")
+
+# Global variables for models and ThreadPool
+vgg16_model = None
+fifth_version_model = None
+tokenizer = None
+executor = ThreadPoolExecutor(max_workers=4)
+
+# Ensure ONNX model path is set
+os.environ["XDG_CACHE_HOME"] = "models/u2net.onnx"
+
+async def download_model_from_hf(repo_id: str, filename: str) -> str:
+    try:
+        # Create a temporary directory for model files
+        model_dir = os.path.join(tempfile.gettempdir(), "hf_models")
+        os.makedirs(model_dir, exist_ok=True)
+
+        # Download model
+        model_path = hf_hub_download(
+            repo_id=repo_id,
+            filename=filename,
+            cache_dir=model_dir,
+            local_dir=model_dir,
+            force_download=True
+        )
+        print(f"Downloaded {filename} to {model_path}")
+        return model_path
+    except Exception as e:
+        print(f"Error downloading {filename}: {str(e)}")
+        raise
+
+
+async def load_models():
+    global vgg16_model, fifth_version_model, tokenizer
+    if not all([vgg16_model, fifth_version_model, tokenizer]):
+        print("Downloading and loading models from Hugging Face Hub...")
+
+        try:
+            # Download models in parallel
+            vgg16_path, model_path, tokenizer_path = await asyncio.gather(
+                download_model_from_hf("abdallah-03/AI_product_helper_models", "vgg16_feature_extractor.keras"),
+                download_model_from_hf("abdallah-03/AI_product_helper_models", "fifth_version_model.keras"),
+                download_model_from_hf("abdallah-03/AI_product_helper_models", "tokenizer.pkl")
+            )
+
+            # Load models using the downloaded paths
+            vgg16_task = asyncio.to_thread(load_model_from_path, vgg16_path)
+            fifth_version_task = asyncio.to_thread(load_model_from_path, model_path)
+            tokenizer_task = asyncio.to_thread(tokenizer_load, tokenizer_path)
+
+            vgg16_model, fifth_version_model, tokenizer = await asyncio.gather(
+                vgg16_task, fifth_version_task, tokenizer_task
+            )
+            print("Models loaded successfully!")
+
+        except Exception as e:
+            print(f"Error loading models: {str(e)}")
+            raise
+
+
+@app.on_event("startup")
+async def startup_event():
+    asyncio.create_task(load_models())
+
+
+# Pydantic Models
+class ImagePathsRequest(BaseModel):
+    image_paths: List[str]
+
+
+class GenerateProductRequest(ImagePathsRequest):
+    Brand_name: str
+
+
+class GenerateDescriptionRequest(BaseModel):
+    product_name: str
+
+
+class AIproducthelper(ImagePathsRequest):
+    Brand_name: str
+
+
+# Exception Handlers
+@app.exception_handler(Exception)
+async def global_exception_handler(request: Request, exc: Exception):
+    return JSONResponse(
+        status_code=500,
+        content={"success": False, "message": "Internal Server Error", "error": repr(exc)},
+    )
+
+
+@app.exception_handler(HTTPException)
+async def http_exception_handler(request: Request, exc: HTTPException):
+    return JSONResponse(
+        status_code=exc.status_code,
+        content={"success": False, "message": exc.detail},
+    )
+
+
+@app.exception_handler(RequestValidationError)
+async def validation_exception_handler(request: Request, exc: RequestValidationError):
+    return JSONResponse(
+        status_code=422,
+        content={"success": False, "message": "Validation Error", "errors": exc.errors()},
+    )
+
+
+# Endpoints
+@app.get("/")
+async def read_root():
+    return {"message": "Hello from our API, models are loading in the background!"}
+
+
+@app.get("/status/")
+async def check_status():
+    if all([vgg16_model, fifth_version_model, tokenizer]):
+        return {
+            "success": True,
+            "message": "Models are ready!",
+            "models_loaded": {
+                "vgg16": vgg16_model is not None,
+                "fifth_version": fifth_version_model is not None,
+                "tokenizer": tokenizer is not None
+            }
+        }
+    return {
+        "success": False,
+        "message": "Models are still loading...",
+        "models_loaded": {
+            "vgg16": vgg16_model is not None,
+            "fifth_version": fifth_version_model is not None,
+            "tokenizer": tokenizer is not None
+        }
+    }
+
+
+@app.post("/extract-colors/")
+async def extract_colors_endpoint(request: ImagePathsRequest):
+    if not request.image_paths:
+        raise HTTPException(status_code=400, detail="Image list cannot be empty.")
+
+    try:
+        colors = await asyncio.get_event_loop().run_in_executor(executor, extract_colors, request.image_paths)
+        return {"success": True, "colors": colors}
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Error extracting colors: {repr(exc)}")
+
+
+@app.post("/generate-product-name/")
+async def generate_product_name_endpoint(request: GenerateProductRequest):
+    if not request.image_paths:
+        raise HTTPException(status_code=400, detail="Image list cannot be empty.")
+
+    try:
+        product_name = await asyncio.get_event_loop().run_in_executor(
+            executor, generate_product_name, request.image_paths, request.Brand_name,
+            vgg16_model, fifth_version_model, tokenizer, API_KEY
+        )
+        return {"success": True, "product_name": product_name}
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Error generating product name: {repr(exc)}")
+
+
+@app.post("/generate-description/")
+async def generate_description_endpoint(request: GenerateDescriptionRequest):
+    try:
+        description = await asyncio.get_event_loop().run_in_executor(
+            executor, generate_description, API_KEY, request.product_name,
+            vgg16_model, fifth_version_model, tokenizer
+        )
+        return {"success": True, "description": description}
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Error generating description: {repr(exc)}")
+
+
+@app.post("/AI-product_help/")
+async def ai_product_help_endpoint(request: AIproducthelper):
+    if not request.image_paths:
+        raise HTTPException(status_code=400, detail="Image list cannot be empty.")
+
+    try:
+        product_name = await asyncio.get_event_loop().run_in_executor(
+            executor, generate_product_name, request.image_paths, request.Brand_name,
+            vgg16_model, fifth_version_model, tokenizer, API_KEY
+        )
+        product_name = clean_response(product_name)
+
+        description = await asyncio.get_event_loop().run_in_executor(
+            executor, generate_description, API_KEY, product_name,
+            vgg16_model, fifth_version_model, tokenizer
+        )
+        description = clean_response(description)
+
+        return {"success": True, "product_name": product_name, "description": description}
+
+    except Exception as exc:
+        raise HTTPException(status_code=500, detail=f"Error in AI product helper: {repr(exc)}")

Color_extraction.py

@@ -0,0 +1,53 @@
+from PIL import Image
+from rembg import remove
+import numpy as np
+import requests
+from io import BytesIO
+from sklearn.cluster import KMeans
+from concurrent.futures import ThreadPoolExecutor
+
+
+def download_image(image_url):
+    try:
+        response = requests.get(image_url, stream=True, timeout=5)
+        response.raise_for_status()
+        return Image.open(BytesIO(response.content)).convert("RGBA")
+    except requests.exceptions.RequestException as e:
+        raise ValueError(f"Error downloading image: {e}")
+
+
+def load_image(image_path_or_url):
+    return download_image(image_path_or_url) if image_path_or_url.startswith("http") else Image.open(image_path_or_url).convert("RGBA")
+
+
+def process_image(image):
+    output_image = remove(image)
+    mask = np.array(output_image)[:, :, 3] > 0 if output_image.mode == 'RGBA' else np.ones(output_image.size[::-1], dtype=bool)
+    return output_image, mask
+
+
+def extract_dominant_colors(image, mask, color_count=2):
+    img_array = np.array(image)
+    product_pixels = img_array[mask][:, :3] if img_array.shape[-1] == 4 else img_array[mask]
+
+    if len(product_pixels) == 0:
+        return None  # No valid pixels found
+
+    kmeans = KMeans(n_clusters=color_count, random_state=42, n_init="auto")  # Auto-tuned for efficiency
+    kmeans.fit(product_pixels)
+    return ['#{:02x}{:02x}{:02x}'.format(*map(int, color)) for color in kmeans.cluster_centers_]
+
+
+def process_single_image(image_path_or_url, color_count):
+    try:
+        image = load_image(image_path_or_url)
+        processed_image, mask = process_image(image)
+        return extract_dominant_colors(processed_image, mask, color_count)[0]  # Return first dominant color
+    except Exception as e:
+        print(f"Error processing image {image_path_or_url}: {e}")
+        return None
+
+
+def extract_colors(images_list, color_count=2):
+    with ThreadPoolExecutor() as executor:
+        return list(executor.map(lambda img: process_single_image(img, color_count), images_list))

Generate_caption.py

@@ -0,0 +1,121 @@
+import os
+import pickle
+import requests
+os.environ['TF_ENABLE_ONEDNN_OPTS'] = '0'
+os.environ['TF_CPP_MIN_LOG_LEVEL'] = '3'
+import numpy as np
+from keras.src.utils import pad_sequences
+from matplotlib import pyplot as plt
+from keras.models import load_model
+from tensorflow.keras.applications.vgg16 import VGG16, preprocess_input
+from tensorflow.keras.preprocessing.image import load_img, img_to_array
+from tensorflow.keras.preprocessing.text import Tokenizer
+from PIL import Image
+
+def load_model_from_path(model_path):
+    model_link=os.path.abspath(model_path)
+    if os.path.exists(model_link):
+        try:
+            model = load_model(model_link)
+            print(f"Model from {model_link} loaded successfully!")
+            return model
+        except Exception as e:
+            print(f"Error loading model from {model_link}: {e}")
+    else:
+        print(f"File not found: {model_link}")
+    return None
+
+def tokenizer_load(path):
+    with open(path, 'rb') as file:
+         tokenizer = pickle.load(file)
+    return tokenizer
+
+def download_image(url, save_path):
+    try:
+        response = requests.get(url, stream=True, timeout=10)
+        response.raise_for_status()  # Raise an error for bad responses (4xx and 5xx)
+        with open(save_path, 'wb') as file:
+            for chunk in response.iter_content(1024):
+                file.write(chunk)
+        return save_path
+    except Exception as e:
+        print(f"Error downloading image {url}: {e}")
+        return None
+
+
+def extract_image_features_one(model, img_path):
+    try:
+        if img_path.startswith("http"):
+            temp_path = "temp_image.jpg"
+            img_path = download_image(img_path, temp_path)
+            if img_path is None:
+                return None
+
+        if not os.path.exists(img_path):
+            print(f"Error: Image path does not exist - {img_path}")
+            return None
+
+        image = load_img(img_path, target_size=(224, 224))
+        img_array = img_to_array(image)
+        img_array = np.expand_dims(img_array, axis=0)
+        img_array = preprocess_input(img_array)
+
+        feature = model.predict(img_array, verbose=0)
+
+        if feature is None:
+            print(f"Error: Model returned None for image - {img_path}")
+
+        return feature
+    except Exception as e:
+        print(f"Exception in feature extraction: {e}")
+        return None
+    finally:
+        if temp_path and os.path.exists(temp_path):
+            os.remove(temp_path)
+
+
+def idx_to_word(integer,tokenizer):
+    for word ,index in tokenizer.word_index.items():
+        if index == integer:
+            return word
+    return None
+
+def extract_captions(mapping):
+    captions_list = []
+    for key in mapping:
+        captions_list.extend(mapping[key])
+    return captions_list
+
+
+def prepare_tokenizer(captions_list):
+    tokenizer = Tokenizer()
+    tokenizer.fit_on_texts(captions_list)
+    vocab_size = len(tokenizer.word_index) + 1
+    return tokenizer, vocab_size
+
+
+def calculate_max_length(captions_list):
+    return max(len(caption.split()) for caption in captions_list)
+
+def predict_caption(model, image, tokenizer, max_length):
+        in_text = 'startseq'
+        for i in range(max_length):
+            sequence = tokenizer.texts_to_sequences([in_text])[0]
+            sequence = pad_sequences([sequence], maxlen=max_length, padding='post')
+            yhat = model.predict([image, sequence], verbose=0)
+            yhat = np.argmax(yhat)
+            word = idx_to_word(yhat, tokenizer)
+            if word is None:
+                break
+            in_text += " " + word
+            if word == 'endseq':
+                break
+        return in_text
+
+def generate_caption(image_path,vgg16_model,model,tokenizer):
+    features_image = extract_image_features_one(vgg16_model, image_path)
+    if features_image is None:
+       print("Error: No features extracted from the image.")
+    y_pred = predict_caption(model, features_image, tokenizer, 18)
+    return y_pred
+

Generate_productName_description.py

@@ -0,0 +1,23 @@
+from Generating_prompt import generate_product_name_prompt , generate_description_prompt
+import google.generativeai as genai
+
+def clean_response(text: str) -> str:
+    return text.replace("\n", " ").strip()
+
+
+def generate_product_name(image_path_list, Brand_name, vgg16_model, model, tokenizer, api_key):
+    prompt = generate_product_name_prompt(image_path_list, Brand_name, vgg16_model, model, tokenizer)
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel("gemini-2.0-flash")
+    response = model.generate_content(prompt)
+
+    return str(response.text) if response.text else ""
+
+
+def generate_description(api_key, product_name, vgg16_model, model, tokenizer):
+    prompt = generate_description_prompt(product_name, vgg16_model, model, tokenizer)
+    genai.configure(api_key=api_key)
+    model = genai.GenerativeModel("gemini-2.0-flash")
+    response = model.generate_content(prompt)
+    return str(response.text) if response.text else ""
+

Generating_prompt.py

@@ -0,0 +1,63 @@
+import time
+from concurrent.futures import ThreadPoolExecutor
+from Generate_caption import generate_caption
+from Color_extraction import extract_colors
+from soupsieve.util import lower
+
+
+def generate_product_name_prompt(image_path,Brand_name,vgg16_model,model,tokenizer):
+    caption = generate_caption(image_path[0],vgg16_model,model,tokenizer)
+    if (str(Brand_name).lower()) == "none" or str(Brand_name).lower()=="generic":
+        statment = (f"Generate a product title name based on the caption {caption} as following information."
+                )
+    else:
+        statment = (f"Generate a product title name based on the caption {caption} and {Brand_name} as following information."
+                    f"Replace the brand name with {Brand_name}. if it is not 'none' or 'None' or 'Generic'"
+                    f"remember if {Brand_name} is 'none' or 'None' or 'Generic' do not depend on it and exclude it from product name"
+                    f" Ensure the product title follows this format:<{Brand_name}>  <Product Details>. "
+                    )
+    prompt = (f"{statment}"
+              f"reformat the {caption} to be professional product title like in the Amazon for website"
+              f"Ensure that is only one product title"
+              f"The product details should include features like product type and it must be somthing popular, series name, purpose "
+              f"and any relevant specifics"
+              f"Do NOT use escape characters or newline (\n)."
+              f"excluding those words (startseq) and (endseq) removing any extra spaces."
+              f"excluding any color and brand name from the product title without any(:) and (,)."
+              f"example: 'Adidas T-Shirts Round Neck Cotton Full Sleeve'"
+              f"do not say specific model number for the product title."
+       
+              f"example if brand name is Apple and caption is smartphone provide that it is iphone but do not provide it's model number as (15 pro max) "
+              f"examples: iphone [no] pro max , Samsung S[no] ultra , Samsung A[no] get the model but not be very specific"
+              f"do not generate none or generic in product name"
+
+                  )
+    return prompt
+
+
+def generate_description_prompt(product_name, vgg16_model, model, tokenizer):
+    prompt = (
+        f'Generate a product description with the following sections: "About this item" and "Product description".'
+        f'Based on this information:'
+        f'Product Title: {product_name}'
+        f'Important Requirements:'
+        f'1. Limit the description to exactly 150 words.'
+        f'2. Extract the brand name from the Product Title below and use it to reference the product within the description.'
+        f'3. Follow the structure provided below for "About this item" and "Product description".'
+        f'4. Ensure each line in the description contains two sentences, removing unnecessary spaces after periods (.).'
+        f'5. Do NOT use escape characters or newline (\n).'
+
+        f'Expected Output Format:'
+
+        f'About this item Genuine leather construction for lasting durability.Multiple card slots and compartments for organization.Sleek and sophisticated design for a polished look.Compact size for easy carrying in pockets or bags.Secure closure to protect your valuables.Product Description.The polo leather wallet offers a premium feel and functionality. It\'s crafted from high-quality leather, ensuring both style and longevity.Its thoughtful design includes ample space for cards and cash. The compact size makes it ideal for everyday use.This polo leather wallet is a perfect blend of practicality and sophistication. It’s designed for the modern gentleman who appreciates quality.'
+        f'Remember to:'
+        f'remove any ("\n") in response'
+        f'Each bullet in "About this item" should only have a maximum of 6 words.'
+        f'Ensure each line in the description contains two sentences.'
+        f'Remove and exclude extra spaces after (.).'
+    )
+
+    return prompt
+
+
+

runtime.txt

@@ -0,0 +1 @@
+python-3.11

test.py

@@ -0,0 +1,25 @@
+from Color_extraction import extract_colors
+# from Generate_productName_description import generate_product_name, generate_description
+from dotenv import load_dotenv
+import os
+from Generate_caption import extract_image_features_one
+# from Generate_productName_description import clean_response
+# Load environment variables
+load_dotenv()
+API_KEY = os.getenv("API_KEY")
+
+if not API_KEY:
+    raise ValueError("API_KEY not set. Please configure your .env file or system environment.")
+
+# image_path_list = ['https://encrypted-tbn0.gstatic.com/images?q=tbn:ANd9GcRcbfffkBR71xadfZ38APy1tclW2zQ77c6--g&s']
+#
+# product_name = generate_product_name(image_path_list,'Samsung',API_KEY)
+# print(product_name)
+# text = "None"
+# print((text.lower()))
+# color_list = extract_colors(image_path_list)
+# print(color_list)
+# description = generate_description(image_path_list,API_KEY,product_name,color_list)
+# print(description)
+# image = url_to_cv2_image("https://duuw10jl1n.ufs.sh/f/URa8oGmtpSmeY9aosOAeRgyf9hO1udBMVQv2tTG7YlCD8XLi")
+# print(image)

train.py

@@ -0,0 +1,172 @@
+import os
+import random
+import numpy as np
+from tqdm import tqdm
+from Generate_caption import load_model
+from tensorflow.keras.preprocessing.image import load_img, img_to_array
+from tensorflow.keras.applications.vgg16 import preprocess_input
+from tensorflow.keras.preprocessing.text import Tokenizer
+from tensorflow.keras.utils import pad_sequences, to_categorical
+from tensorflow.keras.models import Model, load_model
+from tensorflow.keras.layers import Input, Dense, Dropout, BatchNormalization, Embedding, GRU, add, LayerNormalization
+from tensorflow.keras.optimizers import Adam
+from tensorflow.keras.callbacks import EarlyStopping, ReduceLROnPlateau
+
+
+def extract_image_features(model, image_folder):
+    features = {}
+    directory = os.path( image_folder)
+    for item in tqdm(os.listdir(directory), desc="Extracting Features"):
+        item_path = os.path.join(directory, item)
+        if os.path.isfile(item_path):
+            try:
+                image = load_img(item_path, target_size=(224, 224))
+                img_array = img_to_array(image)
+                img_array = img_array.reshape((1, img_array.shape[0], img_array.shape[1], img_array.shape[2]))
+                img_array = preprocess_input(img_array)
+                feature = model.predict(img_array, verbose=0)
+                image_id = item.split('.')[0]
+                features[image_id] = feature
+            except Exception as e:
+                print(f"Error processing image {item_path}: {e}")
+    return features
+
+
+def read_captions_file(file_path):
+    try:
+        with open(file_path, 'r') as file:
+            next(file)
+            captions = file.read()
+        return captions
+    except Exception as e:
+        raise RuntimeError(f"Error reading the file: {e}")
+
+
+def create_image_caption_mapping(captions):
+    mapping = {}
+    for line in tqdm(captions.split('\n'), desc="Processing Captions"):
+        tokens = line.split(',')
+        if len(tokens) < 2:
+            continue
+        image_id, caption = tokens[0], tokens[1:]
+        caption = " ".join(caption)
+        if image_id not in mapping:
+            mapping[image_id] = []
+        mapping[image_id].append(caption)
+    return mapping
+
+
+def preprocess_text(mapping):
+    for key, captions in mapping.items():
+        for i in range(len(captions)):
+            caption = captions[i].lower()
+            caption = caption.replace('[^A-Za-z]', ' ').replace('\s+', ' ')
+            caption = 'startseq ' + " ".join([word for word in caption.split() if len(word) > 1]) + ' endseq'
+            captions[i] = caption
+
+
+def extract_captions(mapping):
+    captions_list = []
+    for key in mapping:
+        captions_list.extend(mapping[key])
+    return captions_list
+
+
+def prepare_tokenizer(captions_list):
+    tokenizer = Tokenizer()
+    tokenizer.fit_on_texts(captions_list)
+    vocab_size = len(tokenizer.word_index) + 1
+    return tokenizer, vocab_size
+
+
+def calculate_max_length(captions_list):
+    return max(len(caption.split()) for caption in captions_list)
+
+
+def split(image_ids, train_ratio, val_ratio=None):
+    random.shuffle(image_ids)
+    total = len(image_ids)
+    train_split = int(total * train_ratio)
+    val_split = int(total * (train_ratio + val_ratio)) if val_ratio else train_split
+    train_ids = image_ids[:train_split]
+    val_ids = image_ids[train_split:val_split] if val_ratio else []
+    test_ids = image_ids[val_split:]
+    return train_ids, val_ids, test_ids
+
+
+def data_generator(data_keys, mapping, features, tokenizer, max_length, vocab_size, batch_size):
+    X1, X2, y = [], [], []
+    n = 0
+    while True:
+        for key in data_keys:
+            n += 1
+            captions = mapping[key]
+            for caption in captions:
+                seq = tokenizer.texts_to_sequences([caption])[0]
+                for i in range(1, len(seq)):
+                    in_seq, out_seq = seq[:i], seq[i]
+                    in_seq = pad_sequences([in_seq], maxlen=max_length, padding='post')[0]
+                    out_seq = to_categorical([out_seq], num_classes=vocab_size)[0]
+                    X1.append(features[key][0])
+                    X2.append(in_seq)
+                    y.append(out_seq)
+            if n == batch_size:
+                yield {"image": np.array(X1), "text": np.array(X2)}, np.array(y)
+                X1, X2, y = [], [], []
+                n = 0
+
+
+def build_model(vocab_size, max_length):
+    inputs1 = Input(shape=(4096,), name="image")
+    fe1 = Dropout(0.4)(inputs1)
+    fe2 = Dense(256, activation='relu')(fe1)
+    fe3 = BatchNormalization()(fe2)
+
+    inputs2 = Input(shape=(max_length,), name="text")
+    se1 = Embedding(vocab_size, 256, mask_zero=True)(inputs2)
+    se2 = Dropout(0.4)(se1)
+    se3 = GRU(256, recurrent_dropout=0.3, return_sequences=False)(se2)
+
+    decoder1 = add([fe3, se3])
+    decoder2 = LayerNormalization()(decoder1)
+    decoder3 = Dense(512, activation='relu')(decoder2)
+    decoder4 = Dropout(0.3)(decoder3)
+    outputs = Dense(vocab_size, activation='softmax')(decoder4)
+
+    model = Model(inputs=[inputs1, inputs2], outputs=outputs)
+    optimizer = Adam(learning_rate=0.001)
+    model.compile(loss='categorical_crossentropy', optimizer=optimizer)
+
+    return model
+
+
+def load_existing_or_new_model(vocab_size, max_length, model_path="seven_version_model.keras"):
+    if os.path.exists(model_path):
+        print("Loading existing model...")
+        return load_model(model_path)
+    else:
+        print("No existing model found. Creating a new one...")
+        return build_model(vocab_size, max_length)
+
+
+def continue_training(model, train, val, mapping, features, tokenizer, max_length, vocab_size, batch_size, epochs):
+    early_stopping = EarlyStopping(monitor='val_loss', patience=3, restore_best_weights=True, verbose=1)
+    lr_scheduler = ReduceLROnPlateau(monitor='val_loss', factor=0.5, patience=2, min_lr=1e-6, verbose=1)
+
+    steps = len(train) // batch_size
+
+    for i in range(epochs):
+        print(f"Epoch {i + 1}/{epochs}")
+        generator = data_generator(train, mapping, features, tokenizer, max_length, vocab_size, batch_size)
+        validation_generator = data_generator(val, mapping, features, tokenizer, max_length, vocab_size, batch_size)
+
+        model.fit(generator, validation_data=validation_generator, epochs=1, steps_per_epoch=steps,
+                  validation_steps=len(val) // batch_size, verbose=1, callbacks=[early_stopping, lr_scheduler])
+
+    model.save("seven_version_model.keras")
+    print("Updated model saved successfully.")
+
+#
+# model = load_existing_or_new_model(vocab_size, max_length)
+# continue_training(model, train_ids, val_ids, mapping, features, tokenizer, max_length, vocab_size, batch_size=64,
+#                   epochs=10)