Upload 10 files

.gitignore

@@ -0,0 +1,4 @@
+/kitpotproduct
+/uploads
+/__pycache__
+res_vector_embeddings.pkl

README.md

@@ -0,0 +1,32 @@
+# Image Retrieval System using ResNet50 and Nearest Neighbors
+
+This repository contains code for an image retrieval system built using ResNet50, a pre-trained convolutional neural network, and Nearest Neighbors algorithm to find similar images based on feature embeddings.
+
+## Overview
+
+The system leverages ResNet50, a powerful deep learning model pre-trained on ImageNet, for extracting image features. These features are stored as embeddings in a pickle file, along with associated filenames.
+
+### Files Included
+
+- `app.py`: Python script implementing the image retrieval system.
+- `res_vector_embeddings`: Pickle file containing feature embeddings of images.
+- `filenames.pkl`: Pickle file storing filenames corresponding to the image embeddings.
+
+## Getting Started
+
+### Prerequisites
+
+- Python 3.10
+- Dependencies: Keras, NumPy, scikit-learn
+
+You can install the dependencies via:
+
+Requirements installation
+```bash
+pip install -r requirements.txt
+```
+Run the Model
+
+```bash
+python app.py
+```

app.py

@@ -0,0 +1,91 @@
+from flask import Flask, request, jsonify
+from model import load_model, find_similar_images,extract_filenames
+import os
+import difflib
+import pandas as pd
+from flask_cors import CORS
+import json
+
+app = Flask(__name__)
+CORS(app)
+data = pd.read_csv('kitpot.categoriesNew.csv', encoding='ISO-8859-1')
+titles = data['DATA'].tolist()
+
+lowercase_titles = [str(title).lower() if isinstance(title, str) else '' for title in titles]
+data = list(filter(None, lowercase_titles))
+
+def find_closest_match(input_word, data):
+    if input_word in data:
+        return [input_word]
+
+    closest_match = difflib.get_close_matches(input_word, data)
+    return closest_match
+
+def process_search_term(search_term, data):
+    words = search_term.split(' ')
+    processed_words = []
+
+    for word in words:
+        
+        if word.lower() in data:
+            processed_words.append(word)
+        else:
+            closest_match = find_closest_match(word.lower(), data)
+            processed_words.append(closest_match[0] if closest_match else word)
+
+    processed_sentence = ' '.join(processed_words)
+    return processed_sentence
+
+@app.route('/get_closest_match', methods=['GET'])
+def get_closest_match():
+    search_term = request.args.get('search_key', default='', type=str)
+    
+    if not search_term:
+        response = {
+            'message': 'Search term is empty.',
+        }
+        return jsonify(response)
+
+    processed_sentence = process_search_term(search_term, data)
+    
+    if processed_sentence:
+        response = {
+            'result': processed_sentence,
+        }
+    else:
+        response = {
+            'message': 'No similar words found.',
+        }
+
+    return jsonify(response)
+
+
+@app.route('/similar_images', methods=['POST'])
+def get_similar_images():
+    if 'imageSearch' not in request.files:
+        return jsonify({'error': 'No file part'})
+
+    file = request.files['imageSearch']
+    if file.filename == '':
+        return jsonify({'error': 'No selected file'})
+
+    if file:
+        filename = file.filename
+        upload_folder = 'uploads'
+        if not os.path.exists(upload_folder):
+            os.makedirs(upload_folder)
+        filepath = os.path.join(upload_folder, filename)
+        file.save(filepath)
+
+        similar_images = find_similar_images(filepath)
+        actualFormatedData=extract_filenames(similar_images)
+        # actualFormatedData = convert_file_paths(similar_images)
+        os.remove(filepath)
+        
+        return jsonify({'result': actualFormatedData})
+    else:
+        return jsonify({'error': 'File format not supported'})
+
+if __name__ == '__main__':
+    app.run(host='0.0.0.0',port=5000,debug=True)
+

kitpot.searchingdata14.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b4fe84ab190f6bb0a662807ef09d6d9b501c4a3398348e9e402550d90aae4a97
+size 6132294

model.py

@@ -0,0 +1,76 @@
+import os
+import pickle
+import sys
+import keras
+import numpy as np
+from keras.preprocessing import image
+from keras.layers import GlobalMaxPooling2D
+from keras.applications.resnet50 import ResNet50, preprocess_input
+from sklearn.neighbors import NearestNeighbors
+from numpy.linalg import norm
+
+model = None
+feature_list = None
+filenames = None
+
+def load_model():
+    global model, feature_list, filenames
+    if model is None:
+        model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
+        model.trainable = False
+        model = keras.Sequential([
+            model,
+            GlobalMaxPooling2D()
+        ])
+    
+    script_dir = os.path.dirname(os.path.abspath(__file__))
+    embeddings_path = os.path.join(script_dir, 'res_vector_embeddings.pkl')
+    filenames_path = os.path.join(script_dir, 'res_filenames.pkl')
+
+    try:
+        with open(embeddings_path, 'rb') as emb_file, open(filenames_path, 'rb') as name_file:
+            feature_list = pickle.load(emb_file)
+            filenames = pickle.load(name_file)
+    except FileNotFoundError as e:
+        print(f"Error: {e}. Check if the required files exist in the specified path.")
+        sys.exit(1)
+    except Exception as e:
+        print(f"Error loading pickle files: {e}")
+        sys.exit(1)
+
+def find_similar_images(image_path):
+    if model is None or feature_list is None or filenames is None:
+        load_model()
+
+    try:
+        query_img = image.load_img(image_path, target_size=(224, 224))
+        query_img_array = image.img_to_array(query_img)
+        expanded_query_img_array = np.expand_dims(query_img_array, axis=0)
+        preprocessed_query_img = preprocess_input(expanded_query_img_array)
+        query_result = model.predict(preprocessed_query_img).flatten()
+        normalized_query_result = query_result / norm(query_result)
+
+        neighbors = NearestNeighbors(n_neighbors=100, algorithm='brute', metric='euclidean')
+        neighbors.fit(feature_list)
+
+        distances, indices = neighbors.kneighbors([normalized_query_result])
+
+        similar_image_paths = [filenames[idx] for idx in indices[0][1:]]
+        return similar_image_paths
+    except FileNotFoundError as e:
+        print(f"Error: {e}. Check if the specified image file exists.")
+        return []
+    except Exception as e:
+        print(f"An error occurred: {e}")
+        return []
+
+# def convert_file_paths(array_data):
+#     base_path = "uploads/catalog/product/"
+#     transformed_paths = [base_path + path.replace("\\", "/") for path in array_data]
+    
+#     # Remove the "kitpotproduct/" prefix from each path
+#     transformed_paths = [path.replace("uploads/catalog/product/kitpotproduct/", "uploads/catalog/product/") for path in transformed_paths]
+    
+#     return transformed_paths
+def extract_filenames(paths):
+    return [path.split("\\")[-1] for path in paths]

requirements.txt

@@ -0,0 +1,5 @@
+scikit-image==0.22.0
+scikit-learn==1.3.2
+keras
+Flask
+tenserflow

res_filenames.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:ed291de01c088dabe36e0117743b160ba631f9fa122adb15d828207c00f9a0cc
+size 1078046

res_vector_embeddings.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:9181e1a6f91c09f4fbf34bf612c1a37f1240f3f8ce0d8d7cf17814c212c303ea
+size 115122306

rest_train.py

@@ -0,0 +1,48 @@
+import os
+import numpy as np
+import pickle
+import tensorflow as tf
+from tqdm import tqdm
+from keras.preprocessing import image
+from keras.layers import GlobalMaxPooling2D
+from keras.applications.resnet50 import ResNet50, preprocess_input
+from numpy.linalg import norm
+
+model = ResNet50(weights='imagenet', include_top=False, input_shape=(224, 224, 3))
+model.trainable = False
+
+model = tf.keras.Sequential([
+    model,
+    GlobalMaxPooling2D()
+])
+
+def extract_features(img_path, model):
+    img = image.load_img(img_path, target_size=(224, 224))
+    img_array = image.img_to_array(img)
+    expanded_img_array = np.expand_dims(img_array, axis=0)
+    preprocessed_img = preprocess_input(expanded_img_array)
+    result = model.predict(preprocessed_img).flatten()
+    normalized_result = result / norm(result)
+    return normalized_result
+
+root_folder = 'kitpotproduct'
+feature_list = []
+filenames = []
+
+for root, dirs, files in os.walk(root_folder):
+    for file in tqdm(files):
+        if file.lower().endswith(('.png', '.jpg', '.jpeg','PNG','JPG','JPEG')):
+            img_path = os.path.join(root, file)
+            try:
+                img = image.load_img(img_path, target_size=(224, 224))
+                filenames.append(img_path)
+                feature_list.append(extract_features(img_path, model))
+            except (OSError, IOError, ValueError, Exception) as e:
+                print(f"Error processing file: {img_path}")
+                print(f"Error message: {str(e)}")
+                continue
+with open('res_vector_embeddings.pkl', 'wb') as f:
+    pickle.dump(feature_list, f)
+
+with open('res_filenames.pkl', 'wb') as f:
+    pickle.dump(filenames, f)