Upload 9 files

.gitignore

@@ -0,0 +1,285 @@
+# Created by https://www.toptal.com/developers/gitignore/api/python,jupyternotebooks,jetbrains+all
+# Edit at https://www.toptal.com/developers/gitignore?templates=python,jupyternotebooks,jetbrains+all
+
+### JetBrains+all ###
+# Covers JetBrains IDEs: IntelliJ, RubyMine, PhpStorm, AppCode, PyCharm, CLion, Android Studio, WebStorm and Rider
+# Reference: https://intellij-support.jetbrains.com/hc/en-us/articles/206544839
+
+# User-specific stuff
+.idea/**/workspace.xml
+.idea/**/tasks.xml
+.idea/**/usage.statistics.xml
+.idea/**/dictionaries
+.idea/**/shelf
+
+# AWS User-specific
+.idea/**/aws.xml
+
+# Generated files
+.idea/**/contentModel.xml
+
+# Sensitive or high-churn files
+.idea/**/dataSources/
+.idea/**/dataSources.ids
+.idea/**/dataSources.local.xml
+.idea/**/sqlDataSources.xml
+.idea/**/dynamic.xml
+.idea/**/uiDesigner.xml
+.idea/**/dbnavigator.xml
+
+# Gradle
+.idea/**/gradle.xml
+.idea/**/libraries
+
+# Gradle and Maven with auto-import
+# When using Gradle or Maven with auto-import, you should exclude module files,
+# since they will be recreated, and may cause churn.  Uncomment if using
+# auto-import.
+# .idea/artifacts
+# .idea/compiler.xml
+# .idea/jarRepositories.xml
+# .idea/modules.xml
+# .idea/*.iml
+# .idea/modules
+# *.iml
+# *.ipr
+
+# CMake
+cmake-build-*/
+
+# Mongo Explorer plugin
+.idea/**/mongoSettings.xml
+
+# File-based project format
+*.iws
+
+# IntelliJ
+out/
+
+# mpeltonen/sbt-idea plugin
+.idea_modules/
+
+# JIRA plugin
+atlassian-ide-plugin.xml
+
+# Cursive Clojure plugin
+.idea/replstate.xml
+
+# SonarLint plugin
+.idea/sonarlint/
+
+# Crashlytics plugin (for Android Studio and IntelliJ)
+com_crashlytics_export_strings.xml
+crashlytics.properties
+crashlytics-build.properties
+fabric.properties
+
+# Editor-based Rest Client
+.idea/httpRequests
+
+# Android studio 3.1+ serialized cache file
+.idea/caches/build_file_checksums.ser
+
+### JetBrains+all Patch ###
+# Ignore everything but code style settings and run configurations
+# that are supposed to be shared within teams.
+
+.idea/*
+
+!.idea/codeStyles
+!.idea/runConfigurations
+.idea/
+
+### JupyterNotebooks ###
+# gitignore template for Jupyter Notebooks
+# website: http://jupyter.org/
+
+.ipynb_checkpoints
+*/.ipynb_checkpoints/*
+
+# IPython
+profile_default/
+ipython_config.py
+
+# Remove previous ipynb_checkpoints
+#   git rm -r .ipynb_checkpoints/
+
+# Dataset
+data/
+scraping/*/
+scraping/*.zip
+
+# Machine Learning
+log/
+models/
+
+### Python ###
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[cod]
+*$py.class
+
+# C extensions
+*.so
+
+# Distribution / packaging
+.Python
+build/
+develop-eggs/
+dist/
+downloads/
+eggs/
+.eggs/
+lib/
+lib64/
+parts/
+sdist/
+var/
+wheels/
+share/python-wheels/
+*.egg-info/
+.installed.cfg
+*.egg
+MANIFEST
+
+# PyInstaller
+#  Usually these files are written by a python script from a template
+#  before PyInstaller builds the exe, so as to inject date/other infos into it.
+*.manifest
+*.spec
+
+# Installer logs
+pip-log.txt
+pip-delete-this-directory.txt
+
+# Unit test / coverage reports
+htmlcov/
+.tox/
+.nox/
+.coverage
+.coverage.*
+.cache
+nosetests.xml
+coverage.xml
+*.cover
+*.py,cover
+.hypothesis/
+.pytest_cache/
+cover/
+
+# Translations
+*.mo
+*.pot
+
+# Django stuff:
+*.log
+local_settings.py
+db.sqlite3
+db.sqlite3-journal
+
+# Flask stuff:
+instance/
+.webassets-cache
+
+# Scrapy stuff:
+.scrapy
+
+# Sphinx documentation
+docs/_build/
+
+# PyBuilder
+.pybuilder/
+target/
+
+# Jupyter Notebook
+
+# IPython
+
+# pyenv
+#   For a library or package, you might want to ignore these files since the code is
+#   intended to run in multiple environments; otherwise, check them in:
+# .python-version
+
+# pipenv
+#   According to pypa/pipenv#598, it is recommended to include Pipfile.lock in version control.
+#   However, in case of collaboration, if having platform-specific dependencies or dependencies
+#   having no cross-platform support, pipenv may install dependencies that don't work, or not
+#   install all needed dependencies.
+#Pipfile.lock
+
+# poetry
+#   Similar to Pipfile.lock, it is generally recommended to include poetry.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#   https://python-poetry.org/docs/basic-usage/#commit-your-poetrylock-file-to-version-control
+#poetry.lock
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#pdm.lock
+#   pdm stores project-wide configurations in .pdm.toml, but it is recommended to not include it
+#   in version control.
+#   https://pdm.fming.dev/#use-with-ide
+.pdm.toml
+
+# PEP 582; used by e.g. github.com/David-OConnor/pyflow and github.com/pdm-project/pdm
+__pypackages__/
+
+# Celery stuff
+celerybeat-schedule
+celerybeat.pid
+
+# SageMath parsed files
+*.sage.py
+
+# Environments
+.env
+.venv
+env/
+venv/
+ENV/
+env.bak/
+venv.bak/
+
+# Spyder project settings
+.spyderproject
+.spyproject
+
+# Rope project settings
+.ropeproject
+
+# mkdocs documentation
+/site
+
+# mypy
+.mypy_cache/
+.dmypy.json
+dmypy.json
+
+# Pyre type checker
+.pyre/
+
+# pytype static type analyzer
+.pytype/
+
+# Cython debug symbols
+cython_debug/
+
+# PyCharm
+#  JetBrains specific template is maintained in a separate JetBrains.gitignore that can
+#  be found at https://github.com/github/gitignore/blob/main/Global/JetBrains.gitignore
+#  and can be added to the global gitignore or merged into this file.  For a more nuclear
+#  option (not recommended) you can uncomment the following to ignore the entire idea folder.
+#.idea/
+
+### Python Patch ###
+# Poetry local configuration file - https://python-poetry.org/docs/configuration/#local-configuration
+poetry.toml
+
+# ruff
+.ruff_cache/
+
+# LSP config files
+pyrightconfig.json
+
+# End of https://www.toptal.com/developers/gitignore/api/python,jupyternotebooks,jetbrains+all

LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2023 Tuong-Minh (Mike) Vo
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

README.md

@@ -1,3 +1,215 @@
+# BloomSage Machine Learning & MLOps Backend Component
+
 ---
-license: mit
+
+
+## Project Structure
+
+
+```
+.
+├── font/
+├── notebooks/
+│   ├── images/
+│   ├── Step1.EDA.ipynb
+│   ├── Step2.DataPrep.ipynb
+│   └── Step3.Classifier-BaselineModel.ipynb
+├── scraping/
+│   └── scrape.py
+├── classify.py
+├── recommend.py
+├── requirements.txt
+├── .gitignore
+├── project-statement.md
+├── README.md
+└── LICENSE
+```
+
+1. `font/`: This folder contains the fonts used in our client script's GUI mode.
+2. `notebooks/`: This folder contains all Jupyter Notebooks for this project and their exported plots in `notebooks/images/`.
+3. `scrape/`: This folder contains a scraping script to get more images from the internet for our dataset. All downloaded images will also be in this folder.
+4. `classify.py`: Client script for classifying flower images using trained models.
+5. `recommend.py`: Client script for recommending flower images using trained models.
+6. `requirements.txt`: Text file for `pip` installation of necessary packages for development environment.
+7. `.gitignore`: This file contains ignore VCS ignore rules.
+8. `README.md`: A text file containing useful reference information about this project, including how to run the algorithm.
+9. `LICENSE`: MIT
+
+
+Additionally, these folders will be created during dataset fetching and model training:
+
+1. `data/`: This folder contains out datasets.
+2. `log/`: This folder contains training logs exported from training our models.
+3. `models/`: This folder contains trained models exported after training.
+
 ---
+
+
+## Getting Started 🚀
+
+Clone this repository:
+
+```bash
+git clone https://github.com/rmit-denominator/bloomsage-ml.git
+```
+
+
+### Development Environment
+
+To set up the necessary packages for this project, run:
+
+```bash
+pip install -r requirements.txt
+```
+
+Refer to [requirements.txt](requirements.txt) for package dependencies and their versions.
+
+<span style="color:gold">**NOTE:**</span> It is recommended that you use a Python virtual environment to avoid conflict with your global packages, and to keep your global Python installation clean. This is because we require specific versions of Numpy, Tensorflow and Keras in our code to maintain backward compatibility and compatibility between trained models and client code.
+
+
+### Download Dataset
+
+The dataset for this project is available on [Kaggle](https://kaggle.com/datasets/979207e9d5e6d91d26e8eb340941ae176c82fbdb2a25b4a436c273895ab96bb1). Follow these steps to download and set it up for training and testing:
+
+1. Navigate to project's root directory.
+
+2. Clean all existing files in the `data/` folders (if exists) before downloading or updating this dataset:
+
+    ```bash
+    rm -r ./data/*
+    ```
+
+3. Download and **extract contents of** the `.zip` from [Kaggle](https://kaggle.com/datasets/979207e9d5e6d91d26e8eb340941ae176c82fbdb2a25b4a436c273895ab96bb1) into `data/raw` folder.
+
+   Alternatively, use the [Kaggle CLI](https://github.com/Kaggle/kaggle-api):
+
+    ```bash
+    kaggle datasets download -d miketvo/rmit-flowers -p ./data/raw/ --unzip
+    ```
+   
+    The resulting folder structure should look like this:
+    
+    ```
+    .
+    ├── data/
+    │   └── raw/
+    │       ├── Baby/
+    │       ├── Calimerio/
+    │       ├── Chrysanthemum/
+    │       ...
+    │       └── Tana/
+    │
+    ...
+    ```
+    
+    where each folder corresponds to a flower class, and contains images of only that class.
+
+4. Setup for training and testing: Run [notebooks/Step2.DataPrep.ipynb](notebooks/Step2.DataPrep.ipynb) and [Step5.Recommender.ipynb](notebooks/Step5.Recommender.ipynb). They will clean, process, and split the raw dataset and the resulting train and test set into `data/train/` and `data/test/`, respectively. They will also generate a database for our image recommendation system in `data/recommender-database/`, along with `data/recommender-database.csv` that contains the feature vectors for all images in the recommender database, in addition to exporting two helper models `models/fe-cnn` and `models/clu-kmeans.model` for the recommendation system. **Note:** Clean these folders and files before you run these two notebook:
+
+    ```bash
+    rmdir -r ./data/train
+    rmdir -r ./data/test
+    rmdir -r ./data/recommender-database
+    rm ./data/recommender-database.csv
+    ```
+   
+    **<span style="color:red">Important:</span>** Clean and rerun this step every time you modify the raw dataset to get the most updated train dataset, test dataset, and recommender database.
+
+
+### Training
+
+Skip this step if you just want to use on of the pre-trained model packages available from [Releases](https://github.com/miketvo/rmit2023a-cosc2753-assignment2/releases).
+
+- Run each Jupyter Notebook in `notebooks/` in their prefixed order starting `Step1.`, `Step2.`, `Step3.`, and so on, <span style="color:red">**one file at a time**</span>.
+- Skip [Step2.DataPrep.ipynb](notebooks/Step2.DataPrep.ipynb) if you have already run it after downloading the raw dataset in the step above.
+- Skip [Step5.Recommender.ipynb](notebooks/Step5.Recommender.ipynb) if you have already run it after downloading the raw dataset in the step above.
+- The resulting models are exported into `models/` folder. Their training logs are stored in `log/` folder.
+
+**Note:** Beware: any existing model with conflicting name in `models/` will be replaced with newly trained models.
+
+
+### Using Trained Models
+
+If you are using one of our pre-trained model packages, download your desired version from [Releases](https://github.com/miketvo/rmit2023a-cosc2753-assignment2/releases) (.zip archives) and extract its contents into this project's root directory using your preferred zip program. Make sure to check and clean `models/` folder (if exists) to avoid naming conflict with existing trained model before the extraction.
+
+These trained models can then be loaded into your code with:
+
+```python
+import tensorflow as tf
+
+model = tf.keras.models.load_model('path/to/model')
+```
+
+Additionally, two Python files, `classify.py` and `recommend.py`, are provided as simple front-ends to our trained model. You can either run them as standalone script in the terminal or import them as Python module in your own Python script or Jupyter Notebook to programmatically classify multiple images and recommend similar images for each of them.
+
+To use them as standalone script, see instruction below:
+
+On your terminal, make sure that you have the environment activated for the client script to have access to all required packages:
+
+- Python Virtualenv:
+
+   ```bash
+   ./venv/Scripts/activate
+   ```
+
+- Conda:
+
+   ```bash
+   conda activate ./envs
+   ```
+
+#### Classifying Flower Images
+
+Use the `classify.py` client script. Its syntax is as follows:
+
+```text
+usage: classify.py [-h] -f FILE [-c CLASSIFIER] [-g] [-v {0,1,2}]
+
+options:
+  -h, --help                                show this help message and exit
+  -f FILE, --file FILE                      the image to be classified
+  -c CLASSIFIER, --classifier CLASSIFIER    the machine learning model used for classification, defaults: models/clf-cnn
+  -g, --gui                                 show classification result using GUI
+  -v {0,1,2}, --verbose-level {0,1,2}       verbose level, default: 0
+```
+
+Example use:
+
+```text
+$ python ./classify.py -f path/to/your/your/image.png -c ./models/clf -v=1
+Image image.png is classified as "Chrysanthemum" (model: "clf")
+```
+
+It also has a rudimentary GUI mode using Matplotlib, which will display the image with a caption of what flower type it is classified as:
+
+```bash
+python ./classify.py --gui -f path/to/your/your/image.png -m ./models/clf
+```
+
+**Note:** Alternatively, you can import its `classify.classify()` function into your own script or notebook to programmatically classify multiple images (see its docstring for instruction on how to use).
+
+
+#### Recommending Flower Images
+
+Use the `recommend.py` client script. Its syntax is as follows:
+
+```text
+usage: recommend.py [-h] -f FILE [-d DATABASE] [-c CLASSIFIER] [-e FEATURE_EXTRACTOR] [-k CLUSTERING_MODEL] [-n NUM]
+
+options:
+  -h, --help                                                        show this help message and exit
+  -f FILE, --file FILE                                              reference image
+  -d DATABASE, --database DATABASE                                  the database containing the images to be recommended, default: data/recommender-database
+  -c CLASSIFIER, --classifier CLASSIFIER                            the machine learning model used for image classification, default: models/clf-cnn
+  -e FEATURE_EXTRACTOR, --feature-extractor FEATURE_EXTRACTOR       the machine learning model used for image feature extraction, default: models/fe-cnn
+  -k CLUSTERING_MODEL, --clustering-model CLUSTERING_MODEL          the machine learning model used for image clustering, default: models/clu-kmeans.model
+  -n NUM, --num NUM                                                 number of recommendations, default: 10
+```
+
+Example:
+
+```bash
+python ./recommend.py -f path/to/your/your/image.png
+```
+
+When executed, the code above will display 10 similar flower images (GUI mode) of the same type, taken from the recommender database in `data/recommender-database/`, based on your reference image, using the default classifier, feature extractor, and clustering model

classify.py

@@ -0,0 +1,79 @@
+import os
+import argparse
+
+import matplotlib.pyplot as plt
+from PIL import Image
+import tensorflow as tf
+from keras.engine.training import Model
+
+from utils.glob import TARGET_IMG_SIZE
+from utils.glob import CLASS_LABELS
+import utils.data_manip as manip
+
+
+def classify(image_path: str, classifier_path: str, verbose: bool = False, return_original: bool = True) -> tuple:
+    """
+    Uses a trained machine learning model to classify an image loaded from disk.
+
+    :param image_path: Path to the image to be classified.
+    :param classifier_path: Path to the classifier model to be used.
+    :param verbose: Verbose output.
+    :param return_original: Whether to return the original image or the processed image.
+    :return: The original/processed image (PIL.image) and its classification (str).
+    """
+
+    im_original = Image.open(image_path)
+    im_processed = manip.remove_transparency(im_original)
+    im_processed = manip.resize_crop(im_processed, TARGET_IMG_SIZE, TARGET_IMG_SIZE)
+    im_processed = manip.normalize_pixels(im_processed)
+    im_processed = tf.expand_dims(im_processed, axis=0)
+
+    model: Model = tf.keras.models.load_model(classifier_path)
+    pred = model.predict(im_processed, verbose=1 if verbose else 0)
+
+    pred_class_idx = tf.argmax(pred, axis=1).numpy()[0]
+    pred_class_label = CLASS_LABELS[pred_class_idx]
+
+    if return_original:
+        return im_original, pred_class_label
+    else:
+        return im_processed, pred_class_label
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser()
+    ap.add_argument('-f', '--file', required=True, help='the image to be classified')
+    ap.add_argument('-c', '--classifier', default='models/clf-cnn', help='the machine learning model used for classification, defaults: models/clf-cnn')
+    ap.add_argument('-g', '--gui', action='store_true', help='show classification result using GUI')
+    ap.add_argument('-v', '--verbose-level', choices=['0', '1', '2'], default='0', help="verbose level, default: 0")
+    args = vars(ap.parse_args())
+    verbose_level = int(args['verbose_level'])
+
+    img = os.path.abspath(args['file'])
+    clf = os.path.abspath(args['classifier'])
+    image, predicted_label = classify(img, clf, False if verbose_level < 2 else True)
+
+    if args['gui']:
+        fig, ax = plt.subplots(1, 1, num='Flower Image Classifier')
+        ax.imshow(image)
+        ax.set_title(
+            f'{predicted_label}',
+            fontsize=12,
+            weight='bold'
+        )
+        ax.text(
+            0.5, -0.08, f'{os.path.relpath(img)}',
+            horizontalalignment='center',
+            verticalalignment='center_baseline',
+            transform=ax.transAxes,
+            fontsize=8,
+        )
+        ax.axis('off')
+        plt.show()
+    else:
+        if verbose_level == 0:
+            print(predicted_label)
+        else:
+            print(
+                f'Image {os.path.basename(img)} is classified as "{predicted_label}" (model: "{os.path.basename(clf)}")'
+            )

project-statement.md

@@ -0,0 +1,42 @@
+# Project: Classify Images of Flowers
+
+Assume you are a team of machine learning engineers working for an ecommerce flower shop, where users can order flowers. Before users buy flowers, the systems should have a functionality to help users navigate to the type of flowers that users want to buy. In most of the current online flower shops, users should type the name of the flowers and browse from the list of the results. However, to enhance the quality of the searching results, our shop provides an image based searching function, where the users can upload the images of the flowers that they are looking for. The system will accomplish an image search and return the list of flowers which are similar to the input image from users.
+
+In the dataset, there are 08 types of flowers:
+
+- Baby
+- Calimero
+- Chrysanthemum
+- Hydrangeas
+- Lisianthus
+- Pingpong
+- Rosy
+- Tana
+
+
+## Goals
+
+1. Classify images according to flower type above.
+2. Recommend 10 flower images in the dataset which is similar to the input flower image from users.
+
+
+## Dataset
+
+The dataset for this project is available on [Kaggle](https://kaggle.com/datasets/979207e9d5e6d91d26e8eb340941ae176c82fbdb2a25b4a436c273895ab96bb1).
+
+
+## Requirements
+
+- You are required to do the pre-processing step on the Flower dataset, including extra collection if necessary.
+- You must investigate at least one machine learning algorithms for each of the two tasks. That is, you must build at least one model capable of predicting the type of flower images, and at least one model capable of showing 10 similar images.
+- You must submit two models (one for each task).
+- You are not required to use separate type(s) of machine learning algorithms, however, a thorough investigation should consider different types of algorithms.
+- You are required to fully train your own algorithms. You may not use pre-trained systems which are trained on other datasets (not given to you as part of this assignment).
+- For higher grades (HD/DI) you must explore how the current status of the data will affect to the result of the models, how we can improve the models, and implement your suggestion to improve the models.
+- Your final report must conduct an analysis and comparison between different model results, not only just one model.
+
+
+## Independent Evaluation
+
+- Your independent evaluation is to research other works that have the same goals. Then you must compare and contrast your results to those other works.
+- Using data collected completely outside the scope of your original training and evaluation.

recommend.py

@@ -0,0 +1,108 @@
+import argparse
+import os.path
+import joblib
+import numpy as np
+import pandas as pd
+import tensorflow as tf
+from PIL import Image
+from matplotlib import pyplot as plt
+from sklearn.metrics.pairwise import cosine_similarity
+
+from classify import classify
+
+
+def recommend(
+        ref_path: str, num_recommendations: int,
+        data_path: str, clf_path: str, fe_path: str, clu_path: str,
+) -> list:
+    """
+    Recommends similar images based on a reference image.
+
+    :param ref_path: Path to the reference image.
+    :param num_recommendations: Number of recommended images to return.
+    :param data_path: Path to the .csv data file containing recommender database image feature vectors. This file must be generated using the same feature extractor specified in fe_path.
+    :param clf_path: Path to the classifier model file.
+    :param fe_path: Path to the feature extraction model file.
+    :param clu_path: Path to the clustering model file.
+    :return: List of paths to the recommended images.
+    """
+    if num_recommendations < 1:
+        raise ValueError('Number of recommendations cannot be smaller than 1.')
+
+    df_rec = pd.read_csv(data_path)
+    fe = tf.keras.models.load_model(fe_path)
+    clu = joblib.load(clu_path)
+    clu.set_params(n_clusters=int(np.sqrt(len(df_rec) / num_recommendations)))
+
+    ref_processed, ref_class = classify(ref_path, classifier_path=clf_path, return_original=False, verbose=False)
+    recommendations = df_rec[df_rec['Class'] == ref_class]
+
+    # Extract reference image feature vector
+    ref_processed = np.squeeze(ref_processed)
+    ref_feature_vector = fe.predict(
+        tf.expand_dims(ref_processed, axis=0),
+        verbose=0
+    )
+    ref_feature_vector = ref_feature_vector.astype(float)
+    ref_feature_vector = ref_feature_vector.reshape(1, -1)
+
+    # Cluster reference image
+    clu.fit(recommendations.drop(['ImgPath', 'Class'], axis='columns').values)
+    ref_cluster = clu.predict(ref_feature_vector)
+    ref_cluster_indices = np.where(clu.labels_ == ref_cluster)[0]
+    recommendations = recommendations.iloc[ref_cluster_indices]
+
+    # Rank cluster and produce top cosine similarity recommendations
+    cosine_similarities = cosine_similarity(
+        ref_feature_vector,
+        recommendations.drop(['ImgPath', 'Class'], axis='columns')
+    )
+    sorted_ref_cluster_indices = np.argsort(-cosine_similarities.flatten())
+    if num_recommendations > len(sorted_ref_cluster_indices):
+        raise ValueError('Number of recommendations too large. Insufficient database size.')
+    top_ref_cluster_indices = sorted_ref_cluster_indices[:num_recommendations]
+    recommendations = recommendations.iloc[top_ref_cluster_indices]
+
+    return list(recommendations['ImgPath'].values)
+
+
+if __name__ == '__main__':
+    ap = argparse.ArgumentParser()
+    ap.add_argument('-f', '--file', required=True, help='reference image')
+    ap.add_argument('-d', '--database', default='data/recommender-database', help='the database containing the images to be recommended, default: data/recommender-database')
+    ap.add_argument('-c', '--classifier', default='models/clf-cnn', help='the machine learning model used for image classification, default: models/clf-cnn')
+    ap.add_argument('-e', '--feature-extractor', default='models/fe-cnn', help='the machine learning model used for image feature extraction, default: models/fe-cnn')
+    ap.add_argument('-k', '--clustering-model', default='models/clu-kmeans.model', help='the machine learning model used for image clustering, default: models/clu-kmeans.model')
+    ap.add_argument('-n', '--num', required=False, default='10', help="number of recommendations, default: 10")
+    args = vars(ap.parse_args())
+    num = int(args['num'])
+
+    fig, axes = plt.subplots(max([1, num // 5]) + 1, 5, figsize=(16, 16), num='Flower Image Recommender')
+    axes = axes.ravel()
+
+    ref = Image.open(args['file'])
+    _, ref_class = classify(args['file'], classifier_path=args['classifier'], return_original=False, verbose=False)
+    axes[2].imshow(ref)
+    axes[2].set_title(
+        f'Reference Image - "{ref_class}"',
+        fontsize=10,
+        weight='bold'
+    )
+    axes[2].text(
+        0.5, -0.08, f'{os.path.relpath(args["file"])}',
+        horizontalalignment='center',
+        verticalalignment='center_baseline',
+        transform=axes[2].transAxes,
+        fontsize=8,
+    )
+    for i, rec_path in enumerate(recommend(
+        args['file'], int(args['num']),
+        args['database'] + '.csv', args['classifier'], args['feature_extractor'], args['clustering_model']
+    ), start=5):
+        with Image.open(f'{args["database"]}/{rec_path}') as rec:
+            axes[i].imshow(rec)
+
+    for ax in axes:
+        ax.axis('off')
+
+    plt.show()

requirements.txt

@@ -0,0 +1,20 @@
+jupyter
+tqdm
+ipython
+numpy==1.23.5
+matplotlib
+graphviz
+pydot
+pandas
+seaborn
+scikit-learn==1.2.2
+scikit-image==0.20.0
+imagehash==4.3.1
+tensorflow==2.12.0
+tensorflow-addons==0.20.0
+keras==2.12.0
+keras-tuner==1.3.5
+icrawler
+pillow==9.5.0
+joblib
+huggingface-hub