Upload 11 files

.gitattributes

@@ -33,3 +33,4 @@ saved_model/**/* filter=lfs diff=lfs merge=lfs -text
 *.zip filter=lfs diff=lfs merge=lfs -text
 *.zst filter=lfs diff=lfs merge=lfs -text
 *tfevents* filter=lfs diff=lfs merge=lfs -text
+NLP-Based-Chatbot/embeddings_chatbot.csv filter=lfs diff=lfs merge=lfs -text

NLP-Based-Chatbot/NLP_Based_Chatbot/.gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

NLP-Based-Chatbot/NLP_Based_Chatbot/README.md

@@ -0,0 +1,78 @@
+---
+language: en
+tags:
+  - chatbot
+  - natural language processing
+license: mit
+---
+
+Model Card: NLP-Based Chatbot
+
+Overview
+
+The NLP-Based Chatbot is designed to explore Science & Technology topics. It utilizes a combination of semantic search and summarization techniques to provide relevant and concise responses to user queries.
+
+Model Details
+
+- Model Name: NLP-Based Chatbot
+- Model Type: Natural Language Processing (NLP) Chatbot
+- Framework: Gradio Blocks Interface, spaCy, Transformers
+
+Components
+
+1. Semantic Search
+
+The chatbot employs semantic search to retrieve relevant information from a preprocessed dataset (Dronealexa.csv). The search is based on a TF-IDF vectorizer and cosine similarity calculations.
+
+2. Summarization
+
+A summarization pipeline is used to generate concise summaries of the retrieved information. The Hugging Face Transformers library is utilized for summarization tasks.
+
+3. Custom Embeddings
+
+The model incorporates custom text embeddings using spaCy and pre-trained word embeddings. These embeddings enhance the understanding of user queries and contribute to the semantic search.
+
+4. Gradio Blocks Interface
+
+The chatbot's frontend is built using Gradio Blocks Interface, providing an interactive and user-friendly platform for users to input queries and receive responses.
+
+5. Model Card Generation
+
+The model card generation involves constructing prompts based on search results and utilizing a summarization pipeline to produce model card content.
+
+Intended Use
+
+The NLP-Based Chatbot is intended for users interested in exploring Science & Technology topics. It can be used to obtain information from the provided dataset, and users are encouraged to provide feedback for continuous improvement.
+
+Training Data
+
+The model is trained on a custom dataset (Dronealexa.csv) containing Science & Technology-related information. The dataset has been preprocessed to handle missing values and ensure efficient semantic search.
+
+
+Evaluation Metrics
+
+- Semantic Search: TF-IDF Vectorizer, Cosine Similarity
+- Summarization: Hugging Face Transformers Pipeline
+
+
+Ethical Considerations
+
+The chatbot aims to provide accurate and relevant information. However, users are advised to critically evaluate the responses and understand that the model's knowledge is based on the training data.
+
+
+Usage Instructions
+
+1. Input your query in the provided textbox.
+2. Click the "Send" button to receive a response.
+3. Optionally, submit feedback using the "Submit Feedback" button.
+
+
+License
+
+This model is released under the Apache 2.0 License.
+
+
+Contact Information
+
+For inquiries or issues, please contact [email protected].
+

NLP-Based-Chatbot/README.md

@@ -0,0 +1,48 @@
+### NLP Powered Chatbot to Explore Science and Technologies
+
+Project URL : https://060d8e72c0a548cb38.gradio.live
+
+Screenshots : 
+<img width="1552" alt="image" src="https://github.com/dhawansolanki/NLP-Chatbot-Hackaphasia/assets/91565429/d3066564-ae96-44c9-8507-64ee7b4f0a14">
+
+
+<img width="1552" alt="image" src="https://github.com/dhawansolanki/NLP-Chatbot-Hackaphasia/assets/91565429/4fe19f0c-8fe5-4f9f-af71-a3e7cd5f3138">
+
+Tech Stack : Python, NLP, Gradio
+
+#How to Run
+
+1. Frontend : (Gradio)
+    1. Create Environment :
+            python -m venv envname
+    2. Install Dependencies :
+            pip install -qU openai==0.28 transformers plotly scikit-learn transformers
+    3. python frontend.py
+
+2. Backend : (Python)
+    3. python backend.py
+
+
+
+Dummy Input Data : 
+
+User Input (Dummy) : 
+
+```
+In the realm of drone technology, a groundbreaking feature has emerged with the integration of an advanced voice command recognition system. This system is meticulously configured to capture and process an audio stream, discerning voice commands from the operator in real-time. What sets this innovation apart is its ability to not only identify the operator's voice within a cacophony of ambient sounds but also to exclusively recognize and act upon the commands issued by the authorized operator. This heightened level of personalization and security is further complemented by the inclusion of a directional camera, which automatically focuses on the operator, providing a continuous and detailed video stream. This video stream not only aids in documentation and monitoring but also plays a pivotal role in disambiguating different voice streams, ensuring that the drone responds with precision in complex and dynamic environments. In essence, this drone system represents a leap forward in human-machine interaction, offering a seamless and efficient mode of control through voice commands.
+Question:
+How does the integration of a directional camera enhance the functionality of the drone's voice command recognition system, and what specific benefits does it bring to the disambiguation of voice streams in dynamic operational environments?
+```
+
+
+Feedback Input (Dummy): 
+```
+How does the integration of a directional camera enhance the functionality of the drone's voice command recognition system, and what specific benefits does it bring to the disambiguation of voice streams in dynamic operational environments?
+```
+ 
+
+
+
+
+
+    

NLP-Based-Chatbot/backend.py

@@ -0,0 +1,291 @@
+import openai
+import pandas as pd
+import numpy as np
+# from openai.embeddings_utils import get_embedding
+from transformers import GPT2TokenizerFast
+from tqdm.auto import tqdm
+import os
+
+
+
+tqdm.pandas()
+
+import spacy
+# import numpy as np
+
+# Load spaCy model with GloVe embeddings
+import en_core_web_sm
+
+nlp = en_core_web_sm.load()
+
+def custom_embedding(text, model_name="text-embedding-ada-002"):
+    # Process the text with spaCy
+    doc = nlp(text)
+
+    # Extract word embeddings and average them to get the text embedding
+    word_embeddings = [token.vector for token in doc if token.has_vector]
+    
+    if not word_embeddings:
+        return None  # No embeddings found for any word in the text
+
+    text_embedding = np.mean(word_embeddings, axis=0)
+
+    # Create a response dictionary
+    response = {
+        "data": [
+            {
+                "embedding": text_embedding.tolist(),
+                "index": 0,
+                "object": "embedding"
+            }
+        ],
+        "model": model_name,
+        "object": "list",
+        "usage": {
+            "prompt_tokens": len(text.split()),
+            "total_tokens": len(text.split())
+        }
+    }
+
+    return response
+
+# Example usage
+text = "Rome"
+response = custom_embedding(text)
+
+if response["data"][0]["embedding"] is not None:
+    print(f"Custom Embedding for '{text}': {response['data'][0]['embedding']}")
+else:
+    print(f"No embeddings found for words in '{text}'.")
+
+print(response)
+
+
+# import spacy
+# import numpy as np
+
+# Load spaCy model with GloVe embeddings
+# import en_core_web_sm
+
+nlp = en_core_web_sm.load()
+
+def custom_embedding(text_list, model_name="text-embedding-ada-002"):
+    embeddings = []
+
+    for text in text_list:
+        # Process the text with spaCy
+        doc = nlp(text)
+
+        # Extract word embeddings and average them to get the text embedding
+        word_embeddings = [token.vector for token in doc if token.has_vector]
+        
+        if not word_embeddings:
+            embeddings.append(None)  # No embeddings found for any word in the text
+        else:
+            text_embedding = np.mean(word_embeddings, axis=0)
+            embeddings.append(text_embedding.tolist())
+
+    # Create a response dictionary
+    response = {
+        "data": [
+            {
+                "embedding": emb,
+                "index": idx,
+                "object": "embedding"
+            }
+            for idx, emb in enumerate(embeddings)
+        ],
+        "model": model_name,
+        "object": "list",
+        "usage": {
+            "prompt_tokens": sum(len(text.split()) for text in text_list),
+            "total_tokens": sum(len(text.split()) for text in text_list)
+        }
+    }
+
+    return response
+
+# Example usage
+text = ["She is running", "Fitness is good", "I am hungry", "Basketball is healthy"]
+response = custom_embedding(text)
+
+for idx, embedding in enumerate(response["data"]):
+    if embedding["embedding"] is not None:
+        print(f"Custom Embedding for '{text[idx]}': {embedding['embedding']}")
+    else:
+        print(f"No embeddings found for words in '{text[idx]}'.")
+
+print(response)
+
+emb1 = response['data'][0]['embedding']
+emb2 = response['data'][1]['embedding']
+emb3 = response['data'][2]['embedding']
+emb4 = response['data'][3]['embedding']
+
+np.dot(emb1, emb2)
+np.dot(emb2, emb4)
+
+df = pd.read_csv('Dronealexa.csv')
+df = df.dropna()
+df.info()
+df.head()
+df['combined'] = "Title: " + df['Title'].str.strip() + "; URL: " + df['URL'].str.strip() + "; Publication Year: " + df['Publication Year'].astype(str).str.strip() + "; Abstract: " + df['Abstract'].str.strip()
+df.head()
+
+tokenizer = GPT2TokenizerFast.from_pretrained("gpt2")
+
+df['n_tokens'] = df.combined.progress_apply(lambda x: len(tokenizer.encode(x)))
+df = df[df.n_tokens < 8000]
+df.info()
+df.head()
+
+
+# import spacy
+# import numpy as np
+
+# Load spaCy model with GloVe embeddings
+# import en_core_web_sm
+
+nlp = en_core_web_sm.load()
+
+def get_embeddings(text, model):
+    # Process the text with spaCy
+    doc = model(text)
+
+    # Extract word embeddings and average them to get the text embedding
+    word_embeddings = [token.vector for token in doc if token.has_vector]
+    
+    if not word_embeddings:
+        return None  # No embeddings found for any word in the text
+
+    text_embedding = np.mean(word_embeddings, axis=0)
+
+    # Create a response dictionary
+    response = {
+        "data": [
+            {
+                "embedding": text_embedding.tolist(),
+                "index": 0,
+                "object": "embedding"
+            }
+        ],
+        "model": model.meta["name"],
+        "object": "list",
+        "usage": {
+            "prompt_tokens": len(text.split()),
+            "total_tokens": len(doc)
+        }
+    }
+
+    return response
+
+# Example usage
+input_text = "Your input text goes here"
+custom_model = nlp  # You can replace this with any other spaCy model
+
+# Renaming 'input_text' to avoid conflict with the built-in 'input' function
+text_to_process = input_text  
+
+response = get_embeddings(text_to_process, custom_model)
+
+if response["data"][0]["embedding"] is not None:
+    print(f"Custom Embedding for '{text_to_process}': {response['data'][0]['embedding']}")
+else:
+    print(f"No embeddings found for words in '{text_to_process}'.")
+
+print(response)
+
+from tqdm import tqdm
+
+batch_size = 2000
+model_name = 'text-embedding-ada-002'
+
+# Assuming df is your DataFrame
+for i in tqdm(range(0, len(df.combined), batch_size)):
+    # find end of batch
+    i_end = min(i + batch_size, len(df.combined))
+    
+    # Get embeddings for the current batch
+    batch_text = list(df.combined)[i:i_end]
+    
+    # Initialize an empty list to store the embeddings for each text in the batch
+    batch_embeddings = []
+    
+    # Process each text in the batch and get embeddings
+    for text in batch_text:
+        response = get_embeddings(text, nlp)
+        
+        # Check if embeddings were found
+        if response and response["data"][0]["embedding"] is not None:
+            batch_embeddings.append(response["data"][0]["embedding"])
+        else:
+            # Handle the case where no embeddings are found for a text
+            batch_embeddings.append(None)
+
+    # Update the DataFrame with the embeddings
+    for j in range(i, i_end):
+        df.loc[j, 'ada_vector'] = str(batch_embeddings[j - i])
+        
+df.head()
+df.info()
+df['ada_vector'] = df.ada_vector.progress_apply(eval).progress_apply(np.array)
+df.to_csv('embeddings_chatbot.csv',index=False)
+df=pd.read_csv('embeddings_chatbot.csv')
+
+user_query = input("Enter query - ")
+
+query_response = get_embeddings(user_query, nlp)
+
+if query_response["data"][0]["embedding"] is not None:
+    print(f"Embedding for '{user_query}': {query_response['data'][0]['embedding']}")
+else:
+    print(f"No embeddings found for words in '{user_query}'.")
+    
+searchvector = get_embeddings(user_query, custom_model)["data"][0]["embedding"]
+
+
+
+from sklearn.metrics.pairwise import cosine_similarity
+
+# Assuming df['ada_vector'] contains the vectors you want to compare
+
+# Ensure 'ada_vector' column contains valid numeric arrays
+df['ada_vector'] = df['ada_vector'].apply(lambda x: np.array(x) if isinstance(x, (list, np.ndarray)) else x)
+
+# Filter out rows where 'ada_vector' is not a valid numeric array
+valid_rows = df['ada_vector'].apply(lambda x: isinstance(x, np.ndarray))
+
+# Calculate cosine similarity only for valid rows
+df.loc[valid_rows, 'similarities'] = df.loc[valid_rows, 'ada_vector'].apply(
+    lambda x: cosine_similarity([x], [searchvector])[0][0]
+)
+
+# If you are using the 'progress_apply' from the 'tqdm' library
+# You can keep it as follows:
+# df.loc[valid_rows, 'similarities'] = df.loc[valid_rows, 'ada_vector'].progress_apply(
+#     lambda x: cosine_similarity([x], [searchvector])[0][0]
+# )
+
+df.head()
+df.sort_values('similarities', ascending = False)
+result = df.sort_values('similarities', ascending = False).head(3)
+
+result.head()
+
+xc = list(result.combined)
+
+def construct_prompt(query, xc):
+  context = ''
+  for i in range(3):
+    context += xc[i] + "\n"
+  header = """Answer the question as truthfully as possible using the provided context, and if the answer is not contained within the text below, say "I don't know."\n\nContext:\n"""
+  header += context + "\n\n Q: " + query + "\n A:"
+  return header
+
+
+
+from transformers import pipeline
+
+summarizer = pipeline("summarization")
+Fresult = construct_prompt(user_query, xc)
+summarizer("\n".join(xc), max_length=130, min_length=30, do_sample=False)

NLP-Based-Chatbot/config.json

@@ -0,0 +1,12 @@
+{
+    "model": {
+        "repository": "https://github.com/VarsaGupta/NLP_Based_Chatbot.git",
+        "subfolder": "",
+        "files": ["model_card.md", "embeddings_chatbot.csv", "backend.py", "feedback_data.csv", "frontend.py", "README.txt", "Dronealexa.csv", "config.json"]
+    },
+    "card": {
+        "repository": "https://github.com/VarsaGupta/NLP_Based_Chatbot.git",
+        "subfolder": "",
+        "files": ["model_card.md"]
+    }
+}

NLP-Based-Chatbot/embeddings_chatbot.csv

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

NLP-Based-Chatbot/feedback_data.csv

@@ -0,0 +1,2 @@
+hello,aerial drone companion device is autonomously oriented such that an image capture device faces the first user in response to detecting the first voice command . a second voice command is detected while the image captured device faces a first user . the task signal is transmitted by the computer based on the second voice commands .,when i say "hello" chatbot should say "hi"
+hai,aerial drone companion device is autonomously oriented such that an image capture device faces the first user in response to detecting the first voice command . a second voice command is detected while the image captured device faces a first user . the task signal is transmitted by the computer based on the second voice commands .,when i say "hai" you should say "hai"

NLP-Based-Chatbot/frontend.py

@@ -0,0 +1,79 @@
+import pandas as pd
+from sklearn.feature_extraction.text import TfidfVectorizer
+from sklearn.metrics.pairwise import cosine_similarity
+import gradio as gr
+from transformers import pipeline
+
+# Load the CSV file and preprocess it
+def load_csv_and_preprocess(csv_file):
+    df = pd.read_csv(csv_file)
+    df = df.dropna().head(100000)
+    
+    column_names = list(df.columns)
+    df['combined'] = df.apply(lambda x: "Title: " + '; '.join(x[column_names].astype(str)), axis=1)
+    df['combined'] = df['combined'].str.strip()
+
+    vectorizer = TfidfVectorizer()
+    embeddings = vectorizer.fit_transform(df['combined'])
+    
+    return df, vectorizer, embeddings
+
+# Initialize the summarization pipeline outside of the chatbot_response function
+summarizer = pipeline("summarization")
+
+# Perform semantic search for a given query
+def semantic_search(df, vectorizer, embeddings, query):
+    search_vector = vectorizer.transform([query])
+    similarities = cosine_similarity(search_vector, embeddings).flatten()
+    df['similarities'] = similarities
+    result = df.sort_values('similarities', ascending=False).head(3)
+    
+    return result['combined'].tolist()
+
+# Define the chatbot response function with summarization
+def chatbot_response(query, history):
+    if not query.strip():
+        return "", history
+    search_results = semantic_search(df, vectorizer, embeddings, query)
+    # Summarize the search results
+    summary = summarizer("\n".join(search_results), max_length=130, min_length=30, do_sample=False)[0]['summary_text']
+    # Format the summarized response and update the chat history
+    history = f"{history}User: {query}\nBot: {summary}\n\n"
+    return "", history  # Clear the input box after each message, update history
+
+# Load CSV and preprocess on server startup
+csv_file_path = "Dronealexa.csv"  # Update this to your CSV file path
+df, vectorizer, embeddings = load_csv_and_preprocess(csv_file_path)
+
+# Define a function to handle feedback
+def handle_feedback(feedback, response, history_box):
+    # Simple logic to prepend feedback to the user's query
+    # This could be replaced with more sophisticated logic or ML model updating
+    response = f"Based on your feedback ('{feedback}'): {response}"
+    history = history_box + "\nBot: " + response + "\n"
+    return "", history  # Update the history with the feedback-aware response
+
+
+# Gradio Blocks Interface
+with gr.Blocks() as blocks_app:
+    gr.Markdown("<h1 style='text-align: center;'>Explore Science & Technology with Chatbot</h1>")
+    history_box = gr.Textbox(label="", value="", interactive=False, lines=20)
+    with gr.Row():
+        query_input = gr.Textbox(show_label=False, placeholder="Type your message here...", lines=1)
+    with gr.Row():
+        send_button = gr.Button("Send")
+
+    send_button.click(
+        fn=chatbot_response,
+        inputs=[query_input, history_box],
+        outputs=[query_input, history_box]
+    )
+    feedback_input = gr.Textbox(show_label=False, placeholder="Type your feedback here...", lines=1)
+    feedback_button = gr.Button("Submit Feedback")
+
+    feedback_button.click(
+        fn=handle_feedback,
+        inputs=[feedback_input, history_box, history_box],
+        outputs=[query_input, history_box]
+    )
+blocks_app.launch(share=True)

NLP-Based-Chatbot/model_card.md.txt

@@ -0,0 +1,80 @@
+---
+language: en
+tags:
+  - chatbot
+  - natural language processing
+license: Apache 2.0
+datasets:
+  - Custom Dataset (Dronealexa)
+---
+
+Model Card: NLP-Based Chatbot
+
+Overview
+
+The NLP-Based Chatbot is designed to explore Science & Technology topics. It utilizes a combination of semantic search and summarization techniques to provide relevant and concise responses to user queries.
+
+Model Details
+
+- **Model Name:** NLP-Based Chatbot
+- **Model Type:** Natural Language Processing (NLP) Chatbot
+- **Framework:** Gradio Blocks Interface, spaCy, Transformers
+
+Components
+
+1. Semantic Search
+
+The chatbot employs semantic search to retrieve relevant information from a preprocessed dataset (Dronealexa.csv). The search is based on a TF-IDF vectorizer and cosine similarity calculations.
+
+2. Summarization
+
+A summarization pipeline is used to generate concise summaries of the retrieved information. The Hugging Face Transformers library is utilized for summarization tasks.
+
+3. Custom Embeddings
+
+The model incorporates custom text embeddings using spaCy and pre-trained word embeddings. These embeddings enhance the understanding of user queries and contribute to the semantic search.
+
+4. Gradio Blocks Interface
+
+The chatbot's frontend is built using Gradio Blocks Interface, providing an interactive and user-friendly platform for users to input queries and receive responses.
+
+5. Model Card Generation
+
+The model card generation involves constructing prompts based on search results and utilizing a summarization pipeline to produce model card content.
+
+Intended Use
+
+The NLP-Based Chatbot is intended for users interested in exploring Science & Technology topics. It can be used to obtain information from the provided dataset, and users are encouraged to provide feedback for continuous improvement.
+
+Training Data
+
+The model is trained on a custom dataset (Dronealexa.csv) containing Science & Technology-related information. The dataset has been preprocessed to handle missing values and ensure efficient semantic search.
+
+
+Evaluation Metrics
+
+- Semantic Search: TF-IDF Vectorizer, Cosine Similarity
+- Summarization: Hugging Face Transformers Pipeline
+
+
+Ethical Considerations
+
+The chatbot aims to provide accurate and relevant information. However, users are advised to critically evaluate the responses and understand that the model's knowledge is based on the training data.
+
+
+Usage Instructions
+
+1. Input your query in the provided textbox.
+2. Click the "Send" button to receive a response.
+3. Optionally, submit feedback using the "Submit Feedback" button.
+
+
+License
+
+This model is released under the Apache 2.0 License.
+
+
+Contact Information
+
+For inquiries or issues, please contact [email protected].
+