Update README.md

README.md

@@ -14,6 +14,9 @@ AMD-Llama-135m is a language model trained on AMD MI250 GPUs. Based on LLaMA2 mo
 ## Quickstart
 AMD-Llama-135m-code-GGUF can be loaded and used via Llama.cpp, here is a program with GUI.
 
+```bash
+pip install PyQt5 llama-cpp-python pymupdf
+```
 
 ```python
 import sys
@@ -23,11 +26,11 @@ from PyQt5.QtWidgets import (QApplication, QWidget, QLabel, QPushButton,
                              QFileDialog, QProgressBar, QMessageBox, QMenu)
 from PyQt5.QtCore import Qt, QThread, pyqtSignal
 from llama_cpp import Llama
-
+import fitz  # For PDF processing
 
 class Worker(QThread):
     finished = pyqtSignal(str)
-    progress = pyqtSignal(int, int)  # Pass total tokens as well
+    progress = pyqtSignal(int, int)
 
     def __init__(self, model, messages, max_tokens):
         super().__init__()
@@ -50,13 +53,12 @@ class Worker(QThread):
                 if "choices" in chunk:
                     content = chunk["choices"][0]["delta"].get("content", "")
                     full_response += content
-                    total_tokens += 1  # Assume each chunk is 1 token (adjust if needed)
+                    total_tokens += 1
                     self.progress.emit(total_tokens, self.max_tokens)
             self.finished.emit(full_response)
         except Exception as e:
             self.finished.emit(f"Error generating response: {str(e)}")
 
-
 class ChatbotGUI(QWidget):
     def __init__(self):
         super().__init__()
@@ -67,6 +69,8 @@ class ChatbotGUI(QWidget):
         self.messages = [
             {"role": "system", "content": "You are a helpful AI assistant."}
         ]
+        self.thread_count = 12
+        self.pdf_content = ""
 
         self.initUI()
 
@@ -80,6 +84,27 @@ class ChatbotGUI(QWidget):
         model_layout.addWidget(model_label)
         model_layout.addWidget(load_button)
 
+        # PDF upload section
+        pdf_label = QLabel("PDF: No PDF loaded")
+        upload_pdf_button = QPushButton("Upload PDF")
+        upload_pdf_button.clicked.connect(self.upload_pdf)
+
+        pdf_layout = QHBoxLayout()
+        pdf_layout.addWidget(pdf_label)
+        pdf_layout.addWidget(upload_pdf_button)
+
+        # Thread count section
+        thread_label = QLabel(f"Thread Count: {self.thread_count}")
+        self.thread_input = QLineEdit()
+        self.thread_input.setPlaceholderText("Enter new thread count")
+        update_thread_button = QPushButton("Update Threads")
+        update_thread_button.clicked.connect(self.update_thread_count)
+
+        thread_layout = QHBoxLayout()
+        thread_layout.addWidget(thread_label)
+        thread_layout.addWidget(self.thread_input)
+        thread_layout.addWidget(update_thread_button)
+
         # Chat display
         self.chat_display = QTextEdit()
         self.chat_display.setReadOnly(True)
@@ -107,6 +132,8 @@ class ChatbotGUI(QWidget):
         # Main layout
         main_layout = QVBoxLayout()
         main_layout.addLayout(model_layout)
+        main_layout.addLayout(pdf_layout)  # PDF before threads
+        main_layout.addLayout(thread_layout) 
         main_layout.addWidget(self.chat_display)
         main_layout.addWidget(self.progress_bar)
         main_layout.addLayout(input_layout)
@@ -118,7 +145,7 @@ class ChatbotGUI(QWidget):
         model_path, _ = QFileDialog.getOpenFileName(self, "Load GGUF Model", "", "GGUF Files (*.gguf)")
         if model_path:
             try:
-                self.model = Llama(model_path=model_path, n_ctx=2048, n_gpu_layers=-1)
+                self.model = Llama(model_path=model_path, n_ctx=2048, n_gpu_layers=-1, n_threads=self.thread_count)
                 model_name = os.path.basename(model_path)
                 self.layout().itemAt(0).itemAt(0).widget().setText(f"Model: {model_name}")
                 QMessageBox.information(self, "Success", "Model loaded successfully!")
@@ -126,6 +153,34 @@ class ChatbotGUI(QWidget):
                 error_message = f"Error loading model: {str(e)}"
                 QMessageBox.critical(self, "Error", error_message)
 
+    def update_thread_count(self):
+        try:
+            new_thread_count = int(self.thread_input.text())
+            if new_thread_count > 0:
+                self.thread_count = new_thread_count
+                self.layout().itemAt(2).itemAt(0).widget().setText(f"Thread Count: {self.thread_count}")  # Updated index
+                self.thread_input.clear()
+                if self.model:
+                    self.model.set_thread_count(self.thread_count)
+                QMessageBox.information(self, "Success", f"Thread count updated to {self.thread_count}")
+            else:
+                raise ValueError("Thread count must be a positive integer")
+        except ValueError as e:
+            QMessageBox.warning(self, "Invalid Input", str(e))
+
+    def upload_pdf(self):
+        pdf_path, _ = QFileDialog.getOpenFileName(self, "Upload PDF", "", "PDF Files (*.pdf)")
+        if pdf_path:
+            try:
+                doc = fitz.open(pdf_path)
+                self.pdf_content = ""
+                for page in doc:
+                    self.pdf_content += page.get_text()
+                self.layout().itemAt(1).itemAt(0).widget().setText(f"PDF: {os.path.basename(pdf_path)}")  # Updated index
+                QMessageBox.information(self, "Success", "PDF loaded successfully!")
+            except Exception as e:
+                QMessageBox.critical(self, "Error", f"Error loading PDF: {str(e)}")
+
     def send_message(self):
         user_message = self.user_input.text()
         if user_message and self.model:
@@ -133,11 +188,15 @@ class ChatbotGUI(QWidget):
             self.update_chat_display(f"You: {user_message}")
             self.user_input.clear()
 
-            max_tokens = 500  # Set your desired max tokens here
+            max_tokens = 1000
             self.progress_bar.show()
             self.progress_bar.setRange(0, max_tokens)
             self.progress_bar.setValue(0)
 
+            # Add PDF content if available
+            if self.pdf_content:
+                self.messages.append({"role": "user", "content": self.pdf_content})
+
             self.worker = Worker(self.model, self.messages, max_tokens)
             self.worker.finished.connect(self.on_response_finished)
             self.worker.progress.connect(self.on_response_progress)
@@ -148,7 +207,7 @@ class ChatbotGUI(QWidget):
         self.messages.append({"role": "assistant", "content": assistant_message})
         self.update_chat_display(f"Assistant: {assistant_message}")
 
-        # Python Code Download (Check for triple backticks)
+        # Python Code Download
         if assistant_message.startswith("```python") and assistant_message.endswith("```"):
             self.offer_code_download(assistant_message)
 
@@ -178,6 +237,8 @@ class ChatbotGUI(QWidget):
             {"role": "system", "content": "You are a helpful AI assistant."}
         ]
         self.chat_display.clear()
+        self.pdf_content = ""  # Clear PDF content
+        self.layout().itemAt(1).itemAt(0).widget().setText("PDF: No PDF loaded")  # Updated index
 
     def show_context_menu(self, point):
         menu = QMenu(self)