Edited requirements.txt

README.md

@@ -4,7 +4,7 @@ emoji: "🏀"
 colorFrom: "blue"
 colorTo: "yellow"
 sdk: "gradio"  # Change to "streamlit" if you're using Streamlit instead of Gradio
-sdk_version: "4.19.2"  # Replace with the Gradio version you are using
+sdk_version: "5.4.0"  # Replace with the Gradio version you are using
 app_file: app.py  # Update this to the main file of your app if it’s named differently
 pinned: false
 ---

app_faster.py

@@ -1,216 +0,0 @@
-import os
-import torch
-import torch.nn.functional as F
-from sentence_transformers import SentenceTransformer
-import pickle
-import streamlit as st
-import gdown
-import requests
-from llama_cpp import Llama
-from tqdm import tqdm
-import time
-from functools import lru_cache
-
-def download_file_with_progress(url: str, filename: str):
-    """Download a file with progress bar using requests"""
-    response = requests.get(url, stream=True)
-    total_size = int(response.headers.get('content-length', 0))
-    
-    with open(filename, 'wb') as file, tqdm(
-        desc=filename,
-        total=total_size,
-        unit='iB',
-        unit_scale=True,
-        unit_divisor=1024,
-    ) as progress_bar:
-        for data in response.iter_content(chunk_size=1024):
-            size = file.write(data)
-            progress_bar.update(size)
-
-@st.cache_resource
-def initialize_llama_model(model_path: str):
-    """Initialize model with CPU-optimized settings"""
-    try:
-        if not os.path.exists(model_path):
-            direct_url = "https://huggingface.co/TheBloke/Mistral-7B-v0.1-GGUF/resolve/main/mistral-7b-v0.1.Q4_K_M.gguf"
-            download_file_with_progress(direct_url, model_path)
-
-        if os.path.getsize(model_path) < 1000000:
-            raise ValueError("Model file appears corrupted")
-
-        # CPU-optimized settings
-        llm = Llama(
-            model_path=model_path,
-            n_ctx=512,            # Reduced context window
-            n_threads=8,          # Optimal for most CPUs
-            n_batch=8,            # Small batch size for CPU
-            n_gpu_layers=0,       # CPU only
-            verbose=False,
-            rope_freq_scale=0.5,
-            seed=42
-        )
-        return llm
-
-    except Exception as e:
-        st.error(f"Error initializing model: {str(e)}")
-        raise
-
-class SentenceTransformerRetriever:
-    def __init__(self, model_name: str = "sentence-transformers/all-MiniLM-L6-v2", cache_dir: str = "embeddings_cache"):
-        self.device = torch.device("cpu")
-        self.model = SentenceTransformer(model_name, device=str(self.device))
-        self.doc_embeddings = None
-        self.cache_dir = cache_dir
-        os.makedirs(cache_dir, exist_ok=True)
-        
-    def load_specific_cache(self, cache_filename: str, drive_link: str) -> dict:
-        cache_path = os.path.join(self.cache_dir, cache_filename)
-        
-        if not os.path.exists(cache_path):
-            print(f"Cache file not found. Downloading from Google Drive...")
-            try:
-                gdown.download(drive_link, cache_path, quiet=False)
-            except Exception as e:
-                raise Exception(f"Failed to download cache file: {str(e)}")
-            
-        print(f"Loading cache from: {cache_path}")
-        with open(cache_path, 'rb') as f:
-            return pickle.load(f)
-
-    @lru_cache(maxsize=128)
-    def encode(self, text: str) -> torch.Tensor:
-        embeddings = self.model.encode([text], convert_to_tensor=True, show_progress_bar=False)
-        return F.normalize(embeddings, p=2, dim=1)
-
-    def store_embeddings(self, embeddings: torch.Tensor):
-        self.doc_embeddings = embeddings
-
-    def search(self, query_embedding: torch.Tensor, k: int):
-        if self.doc_embeddings is None:
-            raise ValueError("No document embeddings stored!")
-
-        similarities = F.cosine_similarity(query_embedding, self.doc_embeddings)
-        scores, indices = torch.topk(similarities, k=min(k, similarities.shape[0]))
-        
-        return indices.cpu(), scores.cpu()
-
-class RAGPipeline:
-    def __init__(self, cache_filename: str, cache_drive_link: str, k: int = 3):
-        self.cache_filename = cache_filename
-        self.cache_drive_link = cache_drive_link
-        self.k = k
-        self.retriever = SentenceTransformerRetriever()
-        self.documents = []
-        self.model_path = "mistral-7b-v0.1.Q4_K_M.gguf"
-        # Initialize model using cached function
-        self.llm = initialize_llama_model(self.model_path)
-        
-        # Performance metrics
-        self.retrieval_time = 0
-        self.inference_time = 0
-
-    def load_cached_embeddings(self):
-        try:
-            cache_data = self.retriever.load_specific_cache(self.cache_filename, self.cache_drive_link)
-            self.documents = cache_data['documents']
-            self.retriever.store_embeddings(cache_data['embeddings'])
-            return True
-        except Exception as e:
-            st.error(f"Error loading cache: {str(e)}")
-            return False
-
-    def _get_response(self, prompt_str: str) -> tuple[str, float]:
-        """Generate response with timing"""
-        start_time = time.time()
-        response = self.llm(
-            prompt_str,
-            max_tokens=256,          # Reduced max tokens
-            temperature=0.1,         # Lower temperature for faster inference
-            top_p=0.1,              # More focused sampling
-            echo=False,
-            stop=["Question:", "\n\n"],
-            top_k=10,
-            repeat_penalty=1.1,
-            stream=False
-        )
-        inference_time = time.time() - start_time
-        return response['choices'][0]['text'].strip(), inference_time
-
-    def process_query(self, query: str) -> tuple[str, dict]:
-        """Process query and return response with timing metrics"""
-        try:
-            # Measure retrieval time
-            retrieval_start = time.time()
-            query_embedding = self.retriever.encode(query)
-            indices, _ = self.retriever.search(query_embedding, self.k)
-        
-            # Limit context size
-            relevant_docs = [self.documents[idx] for idx in indices.tolist()][:2]
-            context = " ".join(relevant_docs)[:800]  # Further reduced context length
-            
-            # Simplified prompt
-            prompt = f"Context: {context}\nQ: {query}\nA:"
-            
-            self.retrieval_time = time.time() - retrieval_start
-
-            # Get response with timing
-            response, self.inference_time = self._get_response(prompt)
-
-            # Prepare timing metrics
-            metrics = {
-                "retrieval_time": f"{self.retrieval_time:.2f}s",
-                "inference_time": f"{self.inference_time:.2f}s",
-                "total_time": f"{(self.retrieval_time + self.inference_time):.2f}s"
-            }
-
-            return response, metrics
-
-        except Exception as e:
-            return f"An error occurred: {str(e)}", {"error": str(e)}
-
-def main():
-    st.set_page_config(page_title="Sport Chatbot", layout="wide")
-    
-    if "rag" not in st.session_state:
-        with st.spinner("Loading model... (this may take a minute)"):
-            cache_filename = "embeddings_2296.pkl"
-            cache_drive_link = "https://drive.google.com/uc?id=1LuJdnwe99C0EgvJpyfHYCKzUvj94FWlC"
-            st.session_state.rag = RAGPipeline(cache_filename, cache_drive_link)
-            st.session_state.rag.load_cached_embeddings()
-
-    st.title("Sport Chatbot")
-    
-    with st.container():
-        query = st.text_input("Enter your question:", key="query_input")
-        
-        if query:
-            if "history" not in st.session_state:
-                st.session_state.history = []
-            
-            with st.spinner("Processing..."):
-                response, metrics = st.session_state.rag.process_query(query)
-                st.session_state.history.append((query, response, metrics))
-            
-            # Display metrics
-            col1, col2, col3 = st.columns(3)
-            with col1:
-                st.metric("Retrieval Time", metrics["retrieval_time"])
-            with col2:
-                st.metric("Inference Time", metrics["inference_time"])
-            with col3:
-                st.metric("Total Time", metrics["total_time"])
-            
-            # Display response
-            st.write("### Answer:")
-            st.write(response)
-            
-            # Display history (last 3 interactions)
-            if len(st.session_state.history) > 1:
-                st.write("### Previous Interactions:")
-                for q, r, m in list(st.session_state.history[:-1])[-3:]:
-                    with st.expander(f"Q: {q[:50]}..."):
-                        st.write(f"**A:** {r}")
-                        st.write(f"*Timing: Total {m['total_time']}*")
-
-if __name__ == "__main__":
-    main()

app_local.py

@@ -1,179 +0,0 @@
-import os
-import torch
-import torch.nn.functional as F
-from sentence_transformers import SentenceTransformer
-import pickle
-from llama_cpp import Llama
-import streamlit as st
-
-class SentenceTransformerRetriever:
-    def __init__(self, model_name: str = "sentence-transformers/all-MiniLM-L6-v2", cache_dir: str = "embeddings_cache"):
-        self.device = torch.device("cpu")
-        self.model = SentenceTransformer(model_name, device=str(self.device))
-        self.doc_embeddings = None
-        self.cache_dir = cache_dir
-        
-    def load_specific_cache(self, cache_filename: str) -> dict:
-        cache_path = os.path.join(self.cache_dir, cache_filename)
-        if not os.path.exists(cache_path):
-            raise FileNotFoundError(f"Cache file not found at {cache_path}")
-        
-        print(f"Loading cache from: {cache_path}")
-        with open(cache_path, 'rb') as f:
-            return pickle.load(f)
-
-    def encode(self, texts: list) -> torch.Tensor:
-        embeddings = self.model.encode(texts, convert_to_tensor=True, show_progress_bar=True)
-        return F.normalize(embeddings, p=2, dim=1)
-
-    def store_embeddings(self, embeddings: torch.Tensor):
-        self.doc_embeddings = embeddings
-
-    def search(self, query_embedding: torch.Tensor, k: int):
-        if self.doc_embeddings is None:
-            raise ValueError("No document embeddings stored!")
-
-        similarities = F.cosine_similarity(query_embedding, self.doc_embeddings)
-        scores, indices = torch.topk(similarities, k=min(k, similarities.shape[0]))
-        
-        return indices.cpu(), scores.cpu()
-
-class RAGPipeline:
-    def __init__(self, cache_filename: str, k: int = 10):
-        self.cache_filename = cache_filename
-        self.k = k
-        self.retriever = SentenceTransformerRetriever()
-        self.documents = []
-        
-        # Load the model
-        model_path = "mistral-7b-v0.1.Q4_K_M.gguf"
-        if not os.path.exists(model_path):
-            raise FileNotFoundError(f"Model file {model_path} not found!")
-
-        self.llm = Llama(
-            model_path=model_path,
-            n_ctx=4096,
-            n_gpu_layers=0,  # CPU only
-            verbose=False,
-        )
-
-    def load_cached_embeddings(self):
-        """Load embeddings from specific cache file"""
-        try:
-            cache_data = self.retriever.load_specific_cache(self.cache_filename)
-            self.documents = cache_data['documents']
-            self.retriever.store_embeddings(cache_data['embeddings'])
-            return True
-        except Exception as e:
-            st.error(f"Error loading cache: {str(e)}")
-            return False
-
-    def process_query(self, query: str) -> str:
-        MAX_ATTEMPTS = 5
-        SIMILARITY_THRESHOLD = 0.4
-        
-        for attempt in range(MAX_ATTEMPTS):
-            try:
-                print(f"\nAttempt {attempt + 1}/{MAX_ATTEMPTS}")
-                
-                # Get query embedding and search for relevant docs
-                query_embedding = self.retriever.encode([query])
-                indices, _ = self.retriever.search(query_embedding, self.k)
-            
-                relevant_docs = [self.documents[idx] for idx in indices.tolist()]
-                context = "\n".join(relevant_docs)
-                
-                prompt = f"""Context information is below in backticks:
-
-                ```
-                {context}
-                ```
-                
-                Given the context above, please answer the following question:
-                {query}
-
-                If you cannot answer it based on the context, please mention politely that you don't know the answer. 
-                Prefer to answer whatever information you can give to the user based on the context. 
-                Answer in a paragraph format. 
-                Answer using the information available in the context.
-                Please don't repeat any part of this prompt in the answer. Feel free to use this information to improve the answer.
-                Please avoid repetition.  
-                
-                Answer:"""
-
-                response = self.llm(
-                    prompt,
-                    max_tokens=1024,
-                    temperature=0.4,
-                    top_p=0.95,
-                    echo=False,
-                    stop=["Question:", "\n\n"]
-                )
-
-                answer = response['choices'][0]['text'].strip()
-                
-                # Check if response is empty or too short
-                if not answer or len(answer) < 2:
-                    print(f"Got empty or too short response: '{answer}'. Retrying...")
-                    continue
-                
-                # Validate response relevance by comparing embeddings
-                response_embedding = self.retriever.encode([answer])
-                response_similarity = F.cosine_similarity(query_embedding, response_embedding)
-                response_score = response_similarity.item()
-                print(f"Response relevance score: {response_score:.3f}")
-                
-                if response_score < SIMILARITY_THRESHOLD:
-                    print(f"Response: {answer}. Response relevance {response_score:.3f} below threshold {SIMILARITY_THRESHOLD}. Retrying...")
-                    continue
-                
-                print(f"Successful response generated on attempt {attempt + 1}")
-                return answer
-
-            except Exception as e:
-                print(f"Error on attempt {attempt + 1}: {str(e)}")
-                continue
-
-        return "I apologize, but after multiple attempts, I was unable to generate a satisfactory response. Please try rephrasing your question."
-
-
-@st.cache_resource
-def initialize_rag_pipeline(cache_filename: str):
-    """Initialize and load the RAG pipeline with cached embeddings"""
-    rag = RAGPipeline(cache_filename)
-    success = rag.load_cached_embeddings()
-    if not success:
-        st.error("Failed to load cached embeddings. Please check the cache file path.")
-        st.stop()
-    return rag
-
-def main():
-    st.title("The Sport Chatbot")
-    st.subheader("Using ESPN API")
-
-    st.write("Hey there! 👋 I can help you with information on Ice Hockey, Baseball, American Football, Soccer, and Basketball. With access to the ESPN API, I'm up to date with the latest details for these sports up until October 2024.")
-    st.write("Got any general questions? Feel free to ask—I'll do my best to provide answers based on the information I've been trained on!")
-
-    # Use the specific cache file we know exists
-    cache_filename = "embeddings_2296.pkl"
-    
-    try:
-        rag = initialize_rag_pipeline(cache_filename)
-    except Exception as e:
-        st.error(f"Error initializing the application: {str(e)}")
-        st.stop()
-
-    # Query input
-    query = st.text_input("Enter your question:")
-
-    if st.button("Get Answer"):
-        if query:
-            with st.spinner("Searching for information..."):
-                response = rag.process_query(query)
-                st.write("### Answer:")
-                st.write(response)
-        else:
-            st.warning("Please enter a question!")
-
-if __name__ == "__main__":
-    main()

app_streamlit.py

@@ -1,243 +0,0 @@
-import os
-import torch
-import torch.nn.functional as F
-from sentence_transformers import SentenceTransformer
-import pickle
-import streamlit as st
-import gdown
-import requests
-from llama_cpp import Llama
-from tqdm import tqdm
-import time
-from functools import lru_cache
-
-def download_file_with_progress(url: str, filename: str):
-    """Download a file with progress bar using requests"""
-    response = requests.get(url, stream=True)
-    total_size = int(response.headers.get('content-length', 0))
-    
-    with open(filename, 'wb') as file, tqdm(
-        desc=filename,
-        total=total_size,
-        unit='iB',
-        unit_scale=True,
-        unit_divisor=1024,
-    ) as progress_bar:
-        for data in response.iter_content(chunk_size=1024):
-            size = file.write(data)
-            progress_bar.update(size)
-
-class SentenceTransformerRetriever:
-    def __init__(self, model_name: str = "sentence-transformers/all-MiniLM-L6-v2", cache_dir: str = "embeddings_cache"):
-        self.device = torch.device("cpu")
-        self.model = SentenceTransformer(model_name, device=str(self.device))
-        self.doc_embeddings = None
-        self.cache_dir = cache_dir
-        os.makedirs(cache_dir, exist_ok=True)
-        
-    def load_specific_cache(self, cache_filename: str, drive_link: str) -> dict:
-        cache_path = os.path.join(self.cache_dir, cache_filename)
-        
-        # Download cache file if it doesn't exist
-        if not os.path.exists(cache_path):
-            print(f"Cache file not found. Downloading from Google Drive...")
-            try:
-                gdown.download(drive_link, cache_path, quiet=False)
-            except Exception as e:
-                raise Exception(f"Failed to download cache file: {str(e)}")
-            
-            if not os.path.exists(cache_path):
-                raise FileNotFoundError(f"Failed to download cache file to {cache_path}")
-        
-        print(f"Loading cache from: {cache_path}")
-        with open(cache_path, 'rb') as f:
-            return pickle.load(f)
-
-    def encode(self, texts: list) -> torch.Tensor:
-        embeddings = self.model.encode(texts, convert_to_tensor=True, show_progress_bar=True)
-        return F.normalize(embeddings, p=2, dim=1)
-
-    def store_embeddings(self, embeddings: torch.Tensor):
-        self.doc_embeddings = embeddings
-
-    def search(self, query_embedding: torch.Tensor, k: int):
-        if self.doc_embeddings is None:
-            raise ValueError("No document embeddings stored!")
-
-        similarities = F.cosine_similarity(query_embedding, self.doc_embeddings)
-        scores, indices = torch.topk(similarities, k=min(k, similarities.shape[0]))
-        
-        return indices.cpu(), scores.cpu()
-
-class RAGPipeline:
-    def __init__(self, cache_filename: str, cache_drive_link: str, k: int = 10):
-        self.cache_filename = cache_filename
-        self.cache_drive_link = cache_drive_link
-        self.k = k
-        self.retriever = SentenceTransformerRetriever()
-        self.documents = []
-
-        # Model configuration
-        self.model_path = "mistral-7b-v0.1.Q4_K_M.gguf"
-
-        # Initialize model
-        self._initialize_model()
-
-    def _initialize_model(self):
-        """Initialize the model with proper error handling and verification"""
-        try:
-            if not os.path.exists(self.model_path):
-                direct_url = "https://huggingface.co/TheBloke/Mistral-7B-v0.1-GGUF/resolve/main/mistral-7b-v0.1.Q4_K_M.gguf"
-                download_file_with_progress(direct_url, self.model_path)
-
-            # Verify file exists and has content
-            if not os.path.exists(self.model_path):
-                raise FileNotFoundError(f"Model file {self.model_path} not found after download attempts")
-            
-            if os.path.getsize(self.model_path) < 1000000:  # Less than 1MB
-                os.remove(self.model_path)
-                raise ValueError("Downloaded model file is too small, likely corrupted")
-
-            # Initialize the model
-            self.llm = Llama(
-                model_path=self.model_path,
-                n_ctx=2048,            # Reduced context window
-                n_threads=8,          # Optimal for most CPUs
-                n_batch=8,            # Small batch size for CPU
-                n_gpu_layers=0,       # CPU only
-                verbose=False,
-                rope_freq_scale=0.5,
-                seed=42
-            )
-            st.success("Model loaded successfully!")
-
-        except Exception as e:
-            st.error(f"Error initializing model: {str(e)}")
-            raise
-
-    def load_cached_embeddings(self):
-        """Load embeddings from Google Drive cache file"""
-        try:
-            cache_data = self.retriever.load_specific_cache(self.cache_filename, self.cache_drive_link)
-            self.documents = cache_data['documents']
-            self.retriever.store_embeddings(cache_data['embeddings'])
-            return True
-        except Exception as e:
-            st.error(f"Error loading cache: {str(e)}")
-            return False
-
-    def process_query(self, query: str) -> str:
-        MAX_ATTEMPTS = 5
-        SIMILARITY_THRESHOLD = 0.3
-        
-        for attempt in range(MAX_ATTEMPTS):
-            try:
-                print(f"\nAttempt {attempt + 1}/{MAX_ATTEMPTS}")
-                
-                # Get query embedding and search for relevant docs
-                query_embedding = self.retriever.encode([query])
-                indices, _ = self.retriever.search(query_embedding, self.k)
-            
-                relevant_docs = [self.documents[idx] for idx in indices.tolist()]
-                context = "\n".join(relevant_docs)
-                
-                prompt = f"""Context information is below in backticks:
-
-                ```
-                {context}
-                ```
-                
-                Given the context above, please answer the following question:
-                {query}
-
-                If you cannot answer based on the context, mention politely that you don't know.
-                Answer in a paragraph format using only the context information.
-
-                Please don't repeat any part of this prompt in the answer. Feel free to use this information to improve the answer.
-                Please avoid repetition.  
-                
-                Answer:"""
-
-                start_time = time.time()
-
-                response = self.llm(
-                    prompt,
-                    max_tokens=512,          # Reduced max tokens
-                    temperature=0.1,         # Lower temperature for faster inference
-                    top_p=0.1,              # More focused sampling
-                    echo=False,
-                    stop=["Question:", "\n\n"],
-                    top_k=10,
-                    repeat_penalty=1.1,
-                    stream=False
-                )
-                
-                print('Inference Time:', time.time() - start_time)
-
-                answer = response['choices'][0]['text'].strip()
-                
-                # Check if response is empty or too short
-                if not answer or len(answer) < 2:
-                    print(f"Got empty or too short response: '{answer}'. Retrying...")
-                    continue
-                
-                # Validate response relevance by comparing embeddings
-                response_embedding = self.retriever.encode([answer])
-                response_similarity = F.cosine_similarity(query_embedding, response_embedding)
-                response_score = response_similarity.item()
-                print(f"Response relevance score: {response_score:.3f}")
-                
-                if response_score < SIMILARITY_THRESHOLD:
-                    print(f"Response: {answer}; Response relevance {response_score:.3f} below threshold {SIMILARITY_THRESHOLD}. Retrying...")
-                    continue
-                
-                print(f"Successful response generated on attempt {attempt + 1}")
-                return answer
-
-            except Exception as e:
-                print(f"Error on attempt {attempt + 1}: {str(e)}")
-                continue
-
-        return "I apologize, but after multiple attempts, I was unable to generate a satisfactory response. Please try rephrasing your question."
-
-@st.cache_resource
-def initialize_rag_pipeline(cache_filename: str, cache_drive_link: str):
-    """Initialize and load the RAG pipeline with cached embeddings from Google Drive"""
-    rag = RAGPipeline(cache_filename, cache_drive_link)
-    success = rag.load_cached_embeddings()
-    if not success:
-        st.error("Failed to load cached embeddings. Please check the cache file and drive link.")
-        st.stop()
-    return rag
-
-def main():
-    st.title("The Sport Chatbot")
-    st.subheader("Using ESPN API")
-
-    st.write("Hey there! 👋 I can help you with information on Ice Hockey, Baseball, American Football, Soccer, and Basketball. With access to the ESPN API, I'm up to date with the latest details for these sports up until October 2024.")
-    st.write("Got any general questions? Feel free to ask—I'll do my best to provide answers based on the information I've been trained on!")
-
-    # Cache file details
-    cache_filename = "embeddings_2296.pkl"
-    cache_drive_link = "https://drive.google.com/uc?id=1LuJdnwe99C0EgvJpyfHYCKzUvj94FWlC"  # Replace with your cache file's Google Drive link
-
-    try:
-        rag = initialize_rag_pipeline(cache_filename, cache_drive_link)
-    except Exception as e:
-        st.error(f"Error initializing the application: {str(e)}")
-        st.stop()
-
-    # Query input
-    query = st.text_input("Enter your question:")
-
-    if st.button("Get Answer"):
-        if query:
-            with st.spinner("Searching for information..."):
-                response = rag.process_query(query)
-                st.write("### Answer:")
-                st.write(response)
-        else:
-            st.warning("Please enter a question!")
-
-if __name__ == "__main__":
-    main()

requirements.txt

@@ -1,7 +1,7 @@
-gradio==4.19.2
-torch>=2.0.0
-sentence-transformers==2.5.1
-llama-cpp-python==0.2.56
-gdown==5.1.0
-tqdm==4.66.2
-requests==2.31.0
+gdown==5.2.0
+gradio==5.4.0
+Requests==2.32.3
+sentence_transformers==3.2.1
+llama_cpp_python==0.3.1
+torch==2.5.0
+tqdm==4.66.5