|
--- |
|
license: apache-2.0 |
|
language: |
|
- en |
|
base_model: |
|
- HuggingFaceTB/SmolLM2-135M |
|
library_name: transformers |
|
--- |
|
# SmolLM2-135M-Instruct-GGUF |
|
|
|
All right reserved to the original owners of the model. |
|
For more data refer to the original model card. |
|
https://huggingface.co/HuggingFaceTB |
|
|
|
## Introduction |
|
SmolLM2 is a family of compact language models available in three size: 135M, 360M, and 1.7B parameters. They are capable of solving a wide range of tasks while being lightweight enough to run on-device. |
|
|
|
|
|
## Quickstart |
|
SmolLM2-135M-Instruct-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 |
|
import os |
|
from PyQt5.QtWidgets import (QApplication, QWidget, QLabel, QPushButton, |
|
QLineEdit, QTextEdit, QVBoxLayout, QHBoxLayout, |
|
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) |
|
|
|
def __init__(self, model, messages, max_tokens): |
|
super().__init__() |
|
self.model = model |
|
self.messages = messages |
|
self.max_tokens = max_tokens |
|
|
|
def run(self): |
|
try: |
|
response = self.model.create_chat_completion( |
|
messages=self.messages, |
|
max_tokens=self.max_tokens, |
|
temperature=0.7, |
|
stream=True |
|
) |
|
|
|
total_tokens = 0 |
|
full_response = "" |
|
for chunk in response: |
|
if "choices" in chunk: |
|
content = chunk["choices"][0]["delta"].get("content", "") |
|
full_response += content |
|
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__() |
|
self.setWindowTitle("Chatbot GUI") |
|
self.resize(800, 600) |
|
|
|
self.model = None |
|
self.messages = [ |
|
{"role": "system", "content": "You are a helpful AI assistant."} |
|
] |
|
self.thread_count = 12 |
|
self.pdf_content = "" |
|
|
|
self.initUI() |
|
|
|
def initUI(self): |
|
# Model loading section |
|
model_label = QLabel("Model: No model loaded") |
|
load_button = QPushButton("Load GGUF Model") |
|
load_button.clicked.connect(self.load_model) |
|
|
|
model_layout = QHBoxLayout() |
|
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) |
|
self.chat_display.setContextMenuPolicy(Qt.CustomContextMenu) |
|
self.chat_display.customContextMenuRequested.connect(self.show_context_menu) |
|
|
|
# User input |
|
self.user_input = QLineEdit() |
|
self.user_input.returnPressed.connect(self.send_message) |
|
send_button = QPushButton("Send") |
|
send_button.clicked.connect(self.send_message) |
|
|
|
input_layout = QHBoxLayout() |
|
input_layout.addWidget(self.user_input) |
|
input_layout.addWidget(send_button) |
|
|
|
# Progress bar |
|
self.progress_bar = QProgressBar() |
|
self.progress_bar.hide() |
|
|
|
# Clear conversation button |
|
clear_button = QPushButton("Clear Conversation") |
|
clear_button.clicked.connect(self.clear_conversation) |
|
|
|
# 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) |
|
main_layout.addWidget(clear_button) |
|
|
|
self.setLayout(main_layout) |
|
|
|
def load_model(self): |
|
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, 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!") |
|
except Exception as e: |
|
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: |
|
self.messages.append({"role": "user", "content": user_message}) |
|
self.update_chat_display(f"You: {user_message}") |
|
self.user_input.clear() |
|
|
|
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) |
|
self.worker.start() |
|
|
|
def on_response_finished(self, assistant_message): |
|
self.progress_bar.hide() |
|
self.messages.append({"role": "assistant", "content": assistant_message}) |
|
self.update_chat_display(f"Assistant: {assistant_message}") |
|
|
|
# Python Code Download |
|
if assistant_message.startswith("```python") and assistant_message.endswith("```"): |
|
self.offer_code_download(assistant_message) |
|
|
|
def on_response_progress(self, current_tokens, total_tokens): |
|
self.progress_bar.setValue(current_tokens) |
|
|
|
def offer_code_download(self, code): |
|
reply = QMessageBox.question(self, "Download Code", |
|
"The assistant generated Python code. Do you want to download it?", |
|
QMessageBox.Yes | QMessageBox.No) |
|
if reply == QMessageBox.Yes: |
|
file_path, _ = QFileDialog.getSaveFileName(self, "Save Python Code", "code.py", "Python Files (*.py)") |
|
if file_path: |
|
try: |
|
with open(file_path, "w") as f: |
|
f.write(code.strip("```python").strip("```")) |
|
QMessageBox.information(self, "Success", "Code saved successfully!") |
|
except Exception as e: |
|
QMessageBox.critical(self, "Error", f"Error saving code: {str(e)}") |
|
|
|
def update_chat_display(self, message): |
|
self.chat_display.append(message + "\n") |
|
self.chat_display.verticalScrollBar().setValue(self.chat_display.verticalScrollBar().maximum()) |
|
|
|
def clear_conversation(self): |
|
self.messages = [ |
|
{"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) |
|
copy_action = menu.addAction("Copy") |
|
copy_action.triggered.connect(self.copy_text) |
|
menu.exec_(self.chat_display.mapToGlobal(point)) |
|
|
|
def copy_text(self): |
|
cursor = self.chat_display.textCursor() |
|
if cursor.hasSelection(): |
|
text = cursor.selectedText() |
|
QApplication.clipboard().setText(text) |
|
|
|
|
|
if __name__ == "__main__": |
|
app = QApplication(sys.argv) |
|
gui = ChatbotGUI() |
|
gui.show() |
|
sys.exit(app.exec_()) |
|
``` |
