initial commit

.gitattributes

@@ -0,0 +1,2 @@
+*.csv filter=lfs diff=lfs merge=lfs -text
+*.csv filter=lfs diff=lfs merge=lfs -text

.gitignore

@@ -0,0 +1,207 @@
+# Byte-compiled / optimized / DLL files
+__pycache__/
+*.py[codz]
+*$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
+.ipynb_checkpoints
+
+# IPython
+profile_default/
+ipython_config.py
+
+# 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
+
+# UV
+#   Similar to Pipfile.lock, it is generally recommended to include uv.lock in version control.
+#   This is especially recommended for binary packages to ensure reproducibility, and is more
+#   commonly ignored for libraries.
+#uv.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
+#poetry.toml
+
+# pdm
+#   Similar to Pipfile.lock, it is generally recommended to include pdm.lock in version control.
+#   pdm recommends including project-wide configuration in pdm.toml, but excluding .pdm-python.
+#   https://pdm-project.org/en/latest/usage/project/#working-with-version-control
+#pdm.lock
+#pdm.toml
+.pdm-python
+.pdm-build/
+
+# pixi
+#   Similar to Pipfile.lock, it is generally recommended to include pixi.lock in version control.
+#pixi.lock
+#   Pixi creates a virtual environment in the .pixi directory, just like venv module creates one
+#   in the .venv directory. It is recommended not to include this directory in version control.
+.pixi
+
+# 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
+.envrc
+.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/
+
+# Abstra
+# Abstra is an AI-powered process automation framework.
+# Ignore directories containing user credentials, local state, and settings.
+# Learn more at https://abstra.io/docs
+.abstra/
+
+# Visual Studio Code
+#  Visual Studio Code specific template is maintained in a separate VisualStudioCode.gitignore 
+#  that can be found at https://github.com/github/gitignore/blob/main/Global/VisualStudioCode.gitignore
+#  and can be added to the global gitignore or merged into this file. However, if you prefer, 
+#  you could uncomment the following to ignore the entire vscode folder
+# .vscode/
+
+# Ruff stuff:
+.ruff_cache/
+
+# PyPI configuration file
+.pypirc
+
+# Cursor
+#  Cursor is an AI-powered code editor. `.cursorignore` specifies files/directories to
+#  exclude from AI features like autocomplete and code analysis. Recommended for sensitive data
+#  refer to https://docs.cursor.com/context/ignore-files
+.cursorignore
+.cursorindexingignore
+
+# Marimo
+marimo/_static/
+marimo/_lsp/
+__marimo__/

README.md

@@ -0,0 +1,40 @@
+---
+pretty_name: Book Recommender Dataset (Emotions & Categories)
+task_categories:
+  - tabular-classification
+  - retrieval
+  - recommendation
+tags:
+  - books
+  - embeddings
+  - emotions
+  - categories
+license: mit
+size_categories:
+  - 10K<n<100K
+---
+
+# Book Recommender Dataset
+
+CSV exports from my Book Recommender pipeline. Includes cleaned metadata, category labels, emotion tags, and a tagged description file.
+
+## Files
+- `books_cleaned.csv`: Core cleaned book metadata.
+- `books_with_categories.csv`: Adds multi-label `categories` column.
+- `books_with_emotions.csv`: Adds `emotion_*` columns (one-hot or scores).
+- `tagged_description.txt`: Preprocessed descriptions (one per line, or TSV).
+
+## Column Schema (example)
+- `book_id` (str)
+- `title` (str)
+- `author` (str)
+- `description` (str)
+- `categories` (list[str] or pipe-separated str)
+- `emotion_joy` (float), `emotion_sadness` (float), ...
+
+## How to load
+ ⁠python
+from datasets import load_dataset
+ds = load_dataset("<your-username>/book-recommender-dataset", data_files="data/books_with_emotions.csv")
+ds["train"][0]
+

data/books_cleaned.csv

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

data/books_with_categories.csv

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

data/books_with_emotions.csv

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

requirments.txt

@@ -0,0 +1,13 @@
+numpy 
+pandas 
+kagglehub 
+python-dotenv 
+langchain-community 
+langchain-openai 
+transformers 
+torch 
+chromadb 
+streamlit 
+gradio 
+ipykernel 
+ipywidgets

src/dataset_cleaning.py

@@ -0,0 +1,430 @@
+print('hello world')
+
+# %%
+import numpy as np
+import pandas as pd
+
+# %%
+import kagglehub
+
+# Download latest version
+path = kagglehub.dataset_download("dylanjcastillo/7k-books-with-metadata")
+
+print("Path to dataset files:", path)
+
+# %%
+import socket
+
+print(socket.gethostbyname("www.kaggle.com"))
+
+
+# %%
+import warnings
+warnings.filterwarnings("ignore")
+
+# %%
+import pandas as pd
+import numpy as np
+import matplotlib.pyplot as plt
+
+# %%
+books = pd.read_csv(f"{path}/books.csv")
+
+# %%
+books
+
+# %%
+books.isnull().sum()
+
+# %%
+import pandas as pd
+
+def dataset_summary(df):
+    summary = pd.DataFrame({
+        "column": df.columns,
+        "missing": df.isnull().sum().values,
+        "count": df.count().values,
+        "distinct": df.nunique().values
+    })
+
+    # Get top frequency and value for each column
+    top_freqs = []
+    top_values = []
+
+    for col in df.columns:
+        if df[col].nunique(dropna=False) > 0:
+            most_common = df[col].value_counts(dropna=False).idxmax()
+            freq = df[col].value_counts(dropna=False).max()
+        else:
+            most_common = None
+            freq = 0
+        top_values.append(most_common)
+        top_freqs.append(freq)
+
+    summary["top_value"] = top_values
+    summary["top_frequency"] = top_freqs
+
+    return summary
+
+# Usage
+summary_df = dataset_summary(books)
+print(summary_df)
+
+
+# %%
+books["missing_description"] = np.where(books["description"].isna(), 1, 0)# put 1 if missing else 0 in the mentioned column
+books['age_of_book']= 2025-books['published_year'] #age of book
+
+# %%
+import seaborn as sns
+import matplotlib.pyplot as plt
+
+# %%
+columns_of_interest = ["num_pages", "age_of_book", "missing_description", "average_rating"]
+
+correlation_matrix = books[columns_of_interest].corr(method = "spearman")
+
+sns.set_theme(style="white")
+plt.figure(figsize=(8, 6))
+heatmap = sns.heatmap(correlation_matrix, annot=True, fmt=".2f", cmap="coolwarm",
+                      cbar_kws={"label": "Spearman correlation"})
+heatmap.set_title("Correlation heatmap")
+plt.show()
+
+
+# %% [markdown]
+# # checking if missing_description have a correlation with any other column.Clearly from above we can see it does not.
+
+# %% [markdown]
+# #How much is it gonna cost us to drop the missing values.
+
+# %%
+book_missing = books[
+    books["description"].notna() &
+    books["num_pages"].notna() &
+    books["average_rating"].notna() &
+    books["published_year"].notna()
+]
+
+
+# %% [markdown]
+# Sure! Let's break down your code step by step:
+# 
+# ```python
+# book_missing = books[~(books["description"].isna()) &
+#                      ~(books["num_pages"].isna()) &
+#                      ~(books["average_rating"].isna()) &
+#                      ~(books["published_year"].isna())]
+# ```
+# 
+# ---
+# 
+# ### 🔍 What This Code Does
+# 
+# This line **filters the `books` DataFrame** to only include rows (i.e. books) that **have no missing values** in four specific columns:
+# 
+# * `description`
+# * `num_pages`
+# * `average_rating`
+# * `published_year`
+# 
+# It stores the result in a new DataFrame called `book_missing`.
+# 
+# ---
+# 
+# ### 🧠 Breakdown of Logic
+# 
+# #### 1. **`books["description"].isna()`**
+# 
+# * Checks which rows have missing (`NaN`) values in the `description` column.
+# * Returns a boolean Series: `True` where missing, `False` where present.
+# 
+# #### 2. **`~(books["description"].isna())`**
+# 
+# * The tilde `~` is a **bitwise NOT operator**, which inverts the boolean Series.
+# * So now it returns `True` for rows **where `description` is present**.
+# 
+# #### 3. **Repeat for other columns**:
+# 
+# The same logic is applied to:
+# 
+# * `num_pages`
+# * `average_rating`
+# * `published_year`
+# 
+# #### 4. **Combining Conditions with `&` (AND)**
+# 
+# * All four conditions are combined using the `&` operator, meaning:
+# 
+#   > Only keep rows where **all four columns are not missing**.
+# 
+# ---
+# 
+# ### ✅ Result
+# 
+# * `book_missing` contains **only the books** where all of the following are available:
+# 
+#   * A description
+#   * Number of pages
+#   * Average rating
+#   * Published year
+# 
+# ---
+# 
+# ### 📌 Optional: More Readable Version
+# 
+# For readability, you can rewrite it using `notna()` instead of `~.isna()`:
+# 
+# ```python
+# book_missing = books[
+#     books["description"].notna() &
+#     books["num_pages"].notna() &
+#     books["average_rating"].notna() &
+#     books["published_year"].notna()
+# ]
+# ```
+# 
+# Let me know if you want to also **analyze** or **count** how many books were excluded or included.
+# 
+
+# %%
+book_missing
+
+# %%
+category_counts = book_missing["categories"].value_counts().reset_index().sort_values("count", ascending=False)
+
+# %%
+import matplotlib.pyplot as plt
+import seaborn as sns
+
+# Step 1: Count categories
+category_counts = book_missing["categories"].value_counts().reset_index()
+
+# Step 2: Rename columns
+category_counts.columns = ["categories", "count"]
+
+# Step 3: Sort and select top 10
+top_10_categories = category_counts.sort_values("count", ascending=False).head(10)
+
+# Step 4: Plot
+plt.figure(figsize=(10, 6))
+sns.barplot(data=top_10_categories, x="count", y="categories", palette="viridis")
+
+plt.title("Top 10 Book Categories by Count")
+plt.xlabel("Count")
+plt.ylabel("Category")
+plt.tight_layout()
+plt.show()
+
+
+# %% [markdown]
+# # Asyou can see the class is heavily imbalanced
+
+# %% [markdown]
+# ## We have long tailed problem
+
+# %%
+book_missing
+
+# %%
+book_missing["words_in_description"] = book_missing["description"].str.split().str.len()
+
+# %% [markdown]
+# # This would split the words by spance and tehn count it, tells us how many words are there
+
+# %%
+book_missing
+
+# %%
+
+
+# Ensure the column exists
+book_missing["words_in_description"] = book_missing["description"].str.split().str.len()
+
+# Plot histogram
+plt.figure(figsize=(10, 6))
+sns.histplot(data=book_missing, x="words_in_description", bins=100, kde=True, color="skyblue")
+
+plt.title("Distribution of Word Counts in Book Descriptions")
+plt.xlabel("Number of Words in Description")
+plt.ylabel("Frequency")
+plt.tight_layout()
+plt.show()
+
+
+# %%
+
+
+# Optional: filter to only include descriptions with ≤ 500 words
+filtered = book_missing[book_missing["words_in_description"] <= 500]
+
+# Plot
+plt.figure(figsize=(12, 6))
+sns.histplot(data=filtered, x="words_in_description", bins=50, kde=True, color="skyblue")
+
+# Set x-axis limits and custom ticks
+plt.xlim(0, 500)
+plt.xticks(ticks=list(range(0, 510, 30)))  # Ticks every 30 units
+
+plt.title("Distribution of Word Counts in Book Descriptions")
+plt.xlabel("Number of Words in Description")
+plt.ylabel("Frequency")
+plt.tight_layout()
+plt.show()
+
+
+# %%
+book_missing.loc[book_missing["words_in_description"].between(1, 4), "description"]
+
+
+# %% [markdown]
+# What it does:
+# 
+# book_missing
+# This is your DataFrame — likely contains book data including descriptions.
+# 
+# book_missing["words_in_description"]
+# This accesses the column that contains the number of words in each book description.
+# 
+# # .between(1, 4)
+# # This returns a boolean Series that's True for rows where the word count is between 1 and 4 (inclusive).
+# # So it selects books with very short descriptions (1–4 words long).
+# 
+# book_missing.loc[ ... , "description"]
+# This uses .loc[rows, column] to:
+# 
+# Select rows where the description is between 1 and 4 words.
+# 
+# Return the description column for just those rows.
+
+# %%
+book_missing.loc[book_missing["words_in_description"].between(5, 14), "description"]
+
+# %%
+
+book_missing.loc[book_missing["words_in_description"].between(15, 24), "description"]
+
+# %%
+book_missing.loc[book_missing["words_in_description"].between(25, 34), "description"]
+
+# %%
+book_missing_25_words = book_missing[book_missing["words_in_description"] >= 25]
+
+# %%
+book_missing_25_words
+
+# %%
+book_missing_25_words["title_and_subtitle"] = (
+    np.where(book_missing_25_words["subtitle"].isna(), 
+             book_missing_25_words["title"],
+             book_missing_25_words[["title", "subtitle"]].astype(str).agg(": ".join, axis=1))
+)
+
+
+# %% [markdown]
+# What it does:
+# 
+# -This line creates a new column called "title_and_subtitle" in the book_missing_25_words DataFrame.
+# It combines the title and subtitle into one string, but only if a subtitle exists.
+# 
+# # Step-by-step explanation:
+# 
+# - book_missing_25_words["subtitle"].isna()
+# 
+# Checks which rows have NaN (missing) values in the subtitle column.
+# 
+# Returns a Boolean Series: True for missing subtitles, False otherwise.
+# 
+# - np.where(condition, value_if_true, value_if_false)
+# 
+# A vectorized way to write an if-else statement across all rows.
+# 
+# # Here’s how it works:
+# 
+# If subtitle is missing → use only the title.
+# 
+# If subtitle is present → join title and subtitle with ": " in between.
+# 
+# book_missing_25_words[["title", "subtitle"]].astype(str)
+# 
+# Selects the two columns (title and subtitle) and converts them to string format (to handle any non-string values safely).
+# 
+# .agg(": ".join, axis=1)
+# 
+# Aggregates (joins) the title and subtitle row-wise (across columns), using ": " as the separator.
+# 
+# So "My Book" and "A Guide" → becomes "My Book: A Guide".
+# 
+# The result of np.where(...)
+# 
+# A Series containing either just the title (if subtitle is missing) or "title: subtitle" (if subtitle is present).
+# 
+# Assignment to title_and_subtitle
+# 
+# Stores the result in a new column.
+
+# %% [markdown]
+# 
+# 
+# ---
+# 
+# ###  `book_missing_25_words["subtitle"].isna()`
+# 
+# ---
+# 
+# ### What it does:
+# 
+# `.isna()` is a **Pandas method** used to detect **missing (NaN)** values.
+# 
+# returns a **Boolean Series** — one `True` or `False` for each row:
+# 
+# * `True` → the subtitle is **missing** (`NaN`)
+# * `False` → the subtitle is **present**
+# 
+# ###  Why we use `.isna()` inside `np.where`
+# 
+# `np.where(condition, if_true, if_false)` needs a **Boolean condition** to decide:
+# 
+# * Which value to use **if the condition is True**
+# * Which value to use **if the condition is False**
+# 
+# So in your case:
+# means:
+# 
+# > If the subtitle is **missing** → use just the `title`;
+# > Otherwise → use `title: subtitle`.
+# 
+# 
+# * `.isna()` (or its alias `.isnull()`) is the **correct, safe, and standard** way to check for missing data in Pandas.
+# 
+# ---
+# 
+# ### TL;DR
+# 
+# * `.isna()` returns `True` for missing subtitles.
+# * You need that `True/False` Series in `np.where()` to control what value to insert.
+# * It ensures you're only combining title + subtitle **when subtitle actually exists**.
+# 
+# 
+
+# %%
+book_missing_25_words
+
+# %%
+book_missing_25_words["tagged_description"] = book_missing_25_words[["isbn13", "description"]].astype(str).agg(" ".join, axis=1)
+
+# %%
+book_missing_25_words
+
+# %%
+(
+    book_missing_25_words
+    .drop(["subtitle", "missing_description", "age_of_book", "words_in_description"], axis=1)
+    .to_csv("books_cleaned.csv", index = False)
+)
+
+# %% [markdown]
+# # Save it to a csv
+
+
+

src/semantic_analysis.py

@@ -0,0 +1,98 @@
+# # Emotional classification - we are gonna do a fine tuning in order to get an llm that will do emotional classification and how it does that? check and understand in the video
+
+# %%
+import pandas as pd
+
+books = pd.read_csv("books_with_categories.csv")
+
+# %%
+from transformers import pipeline
+classifier = pipeline("text-classification",
+                      model="j-hartmann/emotion-english-distilroberta-base",
+                      top_k = None,
+                      device=0)
+classifier("I love this!")
+
+# %%
+books["description"][0]
+
+# %%
+classifier(books["description"][0])
+
+# %%
+classifier(books["description"][0].split("."))
+
+# %%
+sentences = books["description"][0].split(".")
+predictions = classifier(sentences)
+sentences[0]
+
+# %%
+predictions[0]
+
+# %%
+sentences[3]
+
+# %%
+predictions[3]
+
+# %%
+predictions
+
+# %%
+sorted(predictions[0], key=lambda x: x["label"])
+
+# %%
+import numpy as np
+
+emotion_labels = ["anger", "disgust", "fear", "joy", "sadness", "surprise", "neutral"]
+isbn = []
+emotion_scores = {label: [] for label in emotion_labels}
+
+def calculate_max_emotion_scores(predictions):
+    per_emotion_scores = {label: [] for label in emotion_labels}
+    for prediction in predictions:
+        sorted_predictions = sorted(prediction, key=lambda x: x["label"])
+        for index, label in enumerate(emotion_labels):
+            per_emotion_scores[label].append(sorted_predictions[index]["score"])
+    return {label: np.max(scores) for label, scores in per_emotion_scores.items()}
+
+# %%
+for i in range(10):
+    isbn.append(books["isbn13"][i])
+    sentences = books["description"][i].split(".")
+    predictions = classifier(sentences)
+    max_scores = calculate_max_emotion_scores(predictions)
+    for label in emotion_labels:
+        emotion_scores[label].append(max_scores[label])
+emotion_scores
+
+# %%
+from tqdm import tqdm
+
+emotion_labels = ["anger", "disgust", "fear", "joy", "sadness", "surprise", "neutral"]
+isbn = []
+emotion_scores = {label: [] for label in emotion_labels}
+
+for i in tqdm(range(len(books))):
+    isbn.append(books["isbn13"][i])
+    sentences = books["description"][i].split(".")
+    predictions = classifier(sentences)
+    max_scores = calculate_max_emotion_scores(predictions)
+    for label in emotion_labels:
+        emotion_scores[label].append(max_scores[label])
+
+# %%
+emotions_df = pd.DataFrame(emotion_scores)
+emotions_df["isbn13"] = isbn
+emotions_df
+
+# %%
+books = pd.merge(books, emotions_df, on = "isbn13")
+books
+
+
+# %%
+books.to_csv("books_with_emotions.csv", index = False)
+
+

src/text_classification.py

@@ -0,0 +1,147 @@
+# # Here we are gonns do zero shot text classification using llm
+
+# %%
+import pandas as pd
+
+books = pd.read_csv("books_cleaned.csv")
+
+# %%
+books["categories"].value_counts().reset_index()
+
+# %%
+
+books["categories"].value_counts().reset_index().query("count > 50")
+
+# %%
+books[books["categories"] == "Juvenile Fiction"]
+
+# %%
+
+
+books[books["categories"] == "Juvenile Nonfiction"]
+
+# %%
+category_mapping = {'Fiction' : "Fiction",
+ 'Juvenile Fiction': "Children's Fiction",
+ 'Biography & Autobiography': "Nonfiction",
+ 'History': "Nonfiction",
+ 'Literary Criticism': "Nonfiction",
+ 'Philosophy': "Nonfiction",
+ 'Religion': "Nonfiction",
+ 'Comics & Graphic Novels': "Fiction",
+ 'Drama': "Fiction",
+ 'Juvenile Nonfiction': "Children's Nonfiction",
+ 'Science': "Nonfiction",
+ 'Poetry': "Fiction"}
+
+books["simple_categories"] = books["categories"].map(category_mapping)
+
+# %%
+books
+
+# %%
+from transformers import pipeline
+
+# %%
+
+
+fiction_categories = ["Fiction", "Nonfiction"]
+
+pipe = pipeline("zero-shot-classification",
+                model="facebook/bart-large-mnli",
+                device=0) # use your first CUDA GPU
+
+# %%
+sequence = books.loc[books["simple_categories"] == "Fiction", "description"].reset_index(drop=True)[0]
+
+# %%
+pipe(sequence, fiction_categories)
+
+# %%
+import numpy as np
+
+max_index = np.argmax(pipe(sequence, fiction_categories)["scores"])
+max_label = pipe(sequence, fiction_categories)["labels"][max_index]
+max_label
+
+# %%
+def generate_predictions(sequence, categories):
+    predictions = pipe(sequence, categories)
+    max_index = np.argmax(predictions["scores"])
+    max_label = predictions["labels"][max_index]
+    return max_label
+
+# %%
+from tqdm import tqdm
+
+actual_cats = []
+predicted_cats = []
+
+for i in tqdm(range(0, 300)):
+    sequence = books.loc[books["simple_categories"] == "Fiction", "description"].reset_index(drop=True)[i]
+    predicted_cats += [generate_predictions(sequence, fiction_categories)]
+    actual_cats += ["Fiction"]
+
+# %%
+for i in tqdm(range(0, 300)):
+    sequence = books.loc[books["simple_categories"] == "Nonfiction", "description"].reset_index(drop=True)[i]
+    predicted_cats += [generate_predictions(sequence, fiction_categories)]
+    actual_cats += ["Nonfiction"]
+
+# %%
+predictions_df = pd.DataFrame({"actual_categories": actual_cats, "predicted_categories": predicted_cats})
+predictions_df
+
+# %%
+predictions_df["correct_prediction"] = (
+    np.where(predictions_df["actual_categories"] == predictions_df["predicted_categories"], 1, 0)
+)
+
+# %%
+predictions_df["correct_prediction"].sum() / len(predictions_df)
+
+# %%
+isbns = []
+predicted_cats = []
+
+missing_cats = books.loc[books["simple_categories"].isna(), ["isbn13", "description"]].reset_index(drop=True)
+
+# %%
+for i in tqdm(range(0, len(missing_cats))):
+    sequence = missing_cats["description"][i]
+    predicted_cats += [generate_predictions(sequence, fiction_categories)]
+    isbns += [missing_cats["isbn13"][i]]
+
+# %%
+missing_predicted_df = pd.DataFrame({"isbn13": isbns, "predicted_categories": predicted_cats})
+
+# %%
+missing_predicted_df
+
+# %%
+books = pd.merge(books, missing_predicted_df, on="isbn13", how="left")
+books["simple_categories"] = np.where(books["simple_categories"].isna(), books["predicted_categories"], books["simple_categories"])
+books = books.drop(columns = ["predicted_categories"])
+
+# %%
+books
+
+# %%
+books[books["categories"].str.lower().isin([
+    "romance",
+    "science fiction",
+    "scifi",
+    "fantasy",
+    "horror",
+    "mystery",
+    "thriller",
+    "comedy",
+    "crime",
+    "historical"
+])]
+
+# %%
+books.to_csv("books_with_categories.csv", index=False)
+
+
+

src/vector_search.py

@@ -0,0 +1,93 @@
+from langchain_community.document_loaders import TextLoader
+
+# %%
+from langchain_text_splitters import CharacterTextSplitter
+from langchain_openai import OpenAIEmbeddings
+
+
+# %%
+from langchain_chroma import Chroma
+
+# %%
+from dotenv import load_dotenv
+
+load_dotenv()
+
+# %% [markdown]
+# It will show true when we have the keys for open ai and hugging face stored in the .env file and here dotenv will write them to the environment
+
+# %%
+import pandas as pd
+
+books = pd.read_csv("books_cleaned.csv")
+
+# %%
+books.head(5)
+
+# %%
+books["tagged_description"]
+
+# %% [markdown]
+# # We created the tagged description so that we can build our vector search which requires a unique identity.
+
+# %%
+books["tagged_description"].str.cat(sep='\n')
+with open("tagged_description.txt", "w") as f:
+    f.write(books["tagged_description"].str.cat(sep='\n'))
+
+
+# %% [markdown]
+# # In langchain it does not work with pandas dataframe so we need to save only the tag descriptions in the text file.
+
+# %% [markdown]
+# we did not use string match because it is not efficient and slow
+
+# %% [markdown]
+# # Ask for manshu explain the code
+
+# %%
+raw_documents = TextLoader("tagged_description.txt").load()
+text_splitter = CharacterTextSplitter(chunk_size=1, chunk_overlap=0, separator="\n")
+documents = text_splitter.split_documents(raw_documents)
+
+# %% [markdown]
+# # The rason we are setting it to chunk size 0 is because it first tries to look for the closest separator to the index number indicated by the chunks nad basically if this is more than one there's a chance it may not split on a new line it will split by chunk size so by setting it to zero we make sure that it priortize splitting on the separator rather than trying to split on the chunk size 
+
+# %% [markdown]
+# # Chunk size 0 did not work but it worked fine for chunk size=1
+
+# %%
+documents[0]
+
+# %%
+db_books = Chroma.from_documents(
+    documents,
+    embedding=OpenAIEmbeddings())
+
+# %%
+query = "A book to teach children about nature"
+docs = db_books.similarity_search(query, k = 10)
+docs
+
+# %%
+books[books["isbn13"] == int(docs[0].page_content.split()[0].strip())]
+
+# %%
+def retrieve_semantic_recommendations(
+        query: str,
+        top_k: int = 10,
+) -> pd.DataFrame:
+    recs = db_books.similarity_search(query, k = 50)
+
+    books_list = []
+
+    for i in range(0, len(recs)):
+        books_list += [int(recs[i].page_content.strip('"').split()[0])]
+
+    return books[books["isbn13"].isin(books_list)]
+retrieve_semantic_recommendations("A book to teach children about nature")
+
+# %%
+
+
+