| # 🚀 Minimalne LLM + Własny Model - Kompletny Guide |
|
|
| ## 🎯 **CZĘŚĆ 1: Uruchomienie w 2 minuty** |
|
|
| ### Szybki start (minimalne rozwiązanie) |
| ```bash |
| # 1. Sklonuj pliki |
| git clone <your-repo> |
| cd minimal-llm |
| |
| # 2. Uruchom wszystko jedną komendą |
| chmod +x quick-start.sh |
| ./quick-start.sh |
| |
| # 3. Otwórz przeglądarkę |
| # http://localhost:8501 - Streamlit UI |
| # http://localhost:11434 - Ollama API |
| ``` |
|
|
| ### Co się dzieje pod spodem? |
| - **Ollama** - pobiera i uruchamia Mistral 7B |
| - **Streamlit** - prosty chat interface |
| - **Docker** - wszystko w kontenerach |
| - **Minimalne zależności** - tylko 3 pakiety Python! |
|
|
| ## 📁 **Struktura projektu (minimalna)** |
| ``` |
| minimal-llm/ |
| ├── docker-compose.yml # 1 plik - cała infrastruktura |
| ├── Dockerfile # Minimalne image |
| ├── requirements.txt # 3 pakiety |
| ├── quick-start.sh # 1 komenda = pełny setup |
| └── app/ |
| └── main.py # 50 linijek = pełny chat |
| ``` |
|
|
| ## 🎯 **CZĘŚĆ 2: Stwórz własny model LLM** |
|
|
| ### Krok 1: Przygotowanie środowiska |
| ```bash |
| # Instalacja zależności do fine-tuningu |
| pip install -r model_requirements.txt |
| |
| # Login do Hugging Face (do publikacji) |
| huggingface-cli login |
| ``` |
|
|
| ### Krok 2: Przygotowanie danych |
| ```bash |
| python create_custom_model.py |
| # Wybierz opcję 1: Stwórz sample dataset |
| ``` |
|
|
| Przykład danych treningowych: |
| ```json |
| [ |
| { |
| "instruction": "Jak nazywa się stolica Polski?", |
| "input": "", |
| "output": "Stolica Polski to Warszawa." |
| }, |
| { |
| "instruction": "Wyjaśnij czym jest sztuczna inteligencja", |
| "input": "", |
| "output": "Sztuczna inteligencja (AI) to dziedzina informatyki..." |
| } |
| ] |
| ``` |
|
|
| ### Krok 3: Fine-tuning modelu |
| ```bash |
| # Uruchom fine-tuning (wymaga GPU) |
| python create_custom_model.py |
| # Wybierz opcję 2: Fine-tune model |
| |
| # Lub pełny pipeline |
| python create_custom_model.py |
| # Wybierz opcję 6: Pełny pipeline |
| ``` |
|
|
| **Optymalizacje dla RTX 3050:** |
| - 4-bit quantization |
| - LoRA (Low-Rank Adaptation) |
| - Batch size = 1 |
| - Gradient accumulation = 4 |
| - Mixed precision (FP16) |
|
|
| ### Krok 4: Konwersja do GGUF |
| ```bash |
| # Automatycznie generowany skrypt |
| ./convert_to_gguf.sh |
| ``` |
|
|
| ### Krok 5: Stworzenie modelu w Ollama |
| ```bash |
| # Utwórz Modelfile |
| python create_custom_model.py # wybierz opcję 4 |
| |
| # Stwórz model w Ollama |
| ollama create wronai -f Modelfile |
| |
| # Uruchom model |
| ollama run wronai |
| ``` |
|
|
| ### Uruchamianie skryptu |
| Skrypt `create_custom_model.py` oferuje interaktywne menu z następującymi opcjami: |
|
|
| ```bash |
| python create_custom_model.py |
| ``` |
|
|
| Dostępne opcje: |
| 1. Stwórz przykładowy dataset |
| 2. Wykonaj fine-tuning modelu |
| 3. Konwertuj model do formatu GGUF |
| 4. Utwórz Modelfile dla Ollama |
| 5. Opublikuj model na Hugging Face |
| 6. Wykonaj pełny pipeline (1-5) |
|
|
| ### Wymagania wstępne |
| - Python 3.8+ |
| - PyTorch z obsługą CUDA (zalecane) |
| - Biblioteki wymienione w `model_requirements.txt` |
| - Konto na [Hugging Face](https://huggingface.co/) (do publikacji modelu) |
|
|
| ### Rozwiązywanie problemów |
|
|
| #### Błąd składni w skrypcie |
| Jeśli napotkasz błąd składni, upewnij się, że: |
| 1. Używasz Pythona 3.8 lub nowszego |
| 2. Wszystkie zależności są zainstalowane |
| 3. Plik nie został uszkodzony podczas pobierania |
|
|
| #### Problemy z zależnościami |
| ```bash |
| # Utwórz i aktywuj środowisko wirtualne |
| python -m venv .venv |
| source .venv/bin/activate # Linux/Mac |
| .venv\Scripts\activate # Windows |
| |
| # Zainstaluj zależności |
| pip install -r model_requirements.txt |
| ``` |
|
|
| #### Brakujące uprawnienia |
| Jeśli napotkasz problemy z uprawnieniami, spróbuj: |
| ```bash |
| # Nadaj uprawnienia do wykonywania skryptów |
| chmod +x *.sh |
| |
| # Uruchom z uprawnieniami administratora (jeśli potrzebne) |
| sudo python create_custom_model.py |
| ``` |
|
|
| ### Kontrybucja |
| Zapraszamy do zgłaszania problemów i propozycji zmian poprzez Issues i Pull Requests. |
|
|
| # Test modelu |
| ollama run wronai "Cześć! Kim jesteś?" |
| ``` |
| |
| ### Krok 6: Publikacja modelu |
| |
| #### **Opcja A: Ollama Registry** |
| ```bash |
| # Push do Ollama Library |
| ollama push wronai |
|
|
| # Teraz każdy może użyć: |
| ollama pull your-username/wronai |
| ``` |
| |
| #### **Opcja B: Hugging Face Hub** |
| ```bash |
| # Publikacja na HF |
| python publish_to_hf.py |
|
|
| # Model dostępny na: |
| # https://huggingface.co/your-username/my-custom-mistral-7b |
| ``` |
| |
| #### **Opcja C: Docker Registry** |
| ```bash |
| # Spakuj do Docker image |
| docker build -t my-custom-llm . |
| docker tag my-custom-llm your-registry/my-custom-llm |
| docker push your-registry/my-custom-llm |
| ``` |
| |
| ## 🎯 **CZĘŚĆ 3: Gotowe alternatywy (zero kodu)** |
| |
| ### **1. Najprostsze - Ollama** |
| ```bash |
| # Instalacja |
| curl -fsSL https://ollama.ai/install.sh | sh |
|
|
| # Uruchomienie modelu |
| ollama run mistral:7b-instruct |
|
|
| # API automatycznie na localhost:11434 |
| ``` |
| |
| ### **2. Hugging Face Inference API** |
| ```python |
| import requests |
|
|
| headers = {"Authorization": "Bearer YOUR_HF_TOKEN"} |
| response = requests.post( |
| "https://api-inference.huggingface.co/models/mistralai/Mistral-7B-Instruct-v0.1", |
| headers=headers, |
| json={"inputs": "Hello!"} |
| ) |
| ``` |
| |
| ### **3. Groq (ultra szybkie)** |
| ```python |
| from openai import OpenAI |
| |
| client = OpenAI( |
| api_key="YOUR_GROQ_KEY", |
| base_url="https://api.groq.com/openai/v1" |
| ) |
| |
| response = client.chat.completions.create( |
| model="mistral-7b-instruct", |
| messages=[{"role": "user", "content": "Hello!"}] |
| ) |
| ``` |
|
|
| ### **4. Together.ai** |
| ```python |
| from openai import OpenAI |
| |
| client = OpenAI( |
| api_key="YOUR_TOGETHER_KEY", |
| base_url="https://api.together.xyz/v1" |
| ) |
| |
| # Kompatybilne z OpenAI API |
| ``` |
|
|
| ### **5. Modal.com (serverless GPU)** |
| ```python |
| import modal |
| |
| stub = modal.Stub("llm-api") |
| |
| @stub.function(gpu="T4") |
| def generate(prompt: str): |
| # Twój kod modelu |
| return model.generate(prompt) |
| |
| # Deploy jedną komendą |
| # modal deploy |
| ``` |
|
|
| ## 🎯 **CZĘŚĆ 4: Frontend opcje** |
|
|
| ### **1. Streamlit (Python)** |
| ```python |
| import streamlit as st |
| |
| st.title("My LLM Chat") |
| prompt = st.text_input("Message:") |
| if st.button("Send"): |
| response = generate(prompt) |
| st.write(response) |
| ``` |
|
|
| ### **2. Gradio (Python)** |
| ```python |
| import gradio as gr |
| |
| def chat(message, history): |
| response = generate(message) |
| history.append([message, response]) |
| return "", history |
| |
| gr.ChatInterface(chat).launch() |
| ``` |
|
|
| ### **3. Next.js + Vercel AI SDK** |
| ```tsx |
| import { useChat } from 'ai/react' |
| |
| export default function Chat() { |
| const { messages, input, handleInputChange, handleSubmit } = useChat() |
| |
| return ( |
| <div> |
| {messages.map(m => <div key={m.id}>{m.content}</div>)} |
| <form onSubmit={handleSubmit}> |
| <input value={input} onChange={handleInputChange} /> |
| </form> |
| </div> |
| ) |
| } |
| ``` |
|
|
| ## 🎯 **CZĘŚĆ 5: Porównanie rozwiązań** |
|
|
| | Rozwiązanie | Setup Time | Kód | Hosting | GPU | |
| |-------------|------------|-----|---------|-----| |
| | **Ollama + Streamlit** | 2 min | 50 linijek | Local/Docker | Optional | |
| | **Hugging Face API** | 30 sec | 5 linijek | Cloud | No | |
| | **Groq API** | 1 min | 5 linijek | Cloud | No | |
| | **Modal.com** | 5 min | 20 linijek | Serverless | Auto | |
| | **Custom Fine-tuning** | 2 hours | 200 linijek | Self-hosted | Required | |
|
|
| ## 🛠️ **Debugging & Tips** |
|
|
| ### Typowe problemy |
| ```bash |
| # Model nie ładuje się |
| docker logs ollama-engine |
| |
| # Brak GPU |
| docker run --rm --gpus all nvidia/cuda:11.8-base nvidia-smi |
| |
| # Port zajęty |
| sudo netstat -tlnp | grep 11434 |
| |
| # Restart wszystkiego |
| docker compose down && docker compose up -d |
| ``` |
|
|
| ### Optymalizacje RTX 3050 |
| ```python |
| # W fine-tuningu |
| model = AutoModelForCausalLM.from_pretrained( |
| model_name, |
| load_in_4bit=True, # 4-bit quantization |
| torch_dtype=torch.float16 # Half precision |
| ) |
| |
| # Training args |
| TrainingArguments( |
| per_device_train_batch_size=1, # Mały batch |
| gradient_accumulation_steps=4, # Gradients accumulation |
| fp16=True # Mixed precision |
| ) |
| ``` |
|
|
| ### Monitoring zasobów |
| ```bash |
| # GPU monitoring |
| watch -n 1 nvidia-smi |
| |
| # Container resources |
| docker stats |
| |
| # Model memory usage |
| docker exec -it ollama-engine ollama ps |
| ``` |
|
|
| ## 🎯 **Następne kroki** |
|
|
| ### Dla nauki: |
| 1. **Eksperymentuj z różnymi modelami** - Llama, CodeLlama, Phi-3 |
| 2. **Testuj różne techniki fine-tuningu** - LoRA, QLoRA, Full fine-tuning |
| 3. **Dodaj RAG** - Retrieval Augmented Generation |
| 4. **Stwórz multi-agent system** |
|
|
| ### Dla produkcji: |
| 1. **Przejdź na managed service** - Groq, Together.ai |
| 2. **Setup monitoring** - LangSmith, Weights & Biases |
| 3. **Dodaj cache** - Redis dla odpowiedzi |
| 4. **Implement rate limiting** |
|
|
| ### Dla biznesu: |
| 1. **Fine-tune na własnych danych** |
| 2. **Setup A/B testing** różnych modeli |
| 3. **Dodaj feedback loop** od użytkowników |
| 4. **Monetize API** |
|
|
| ## 🎉 **Podsumowanie** |
|
|
| **Wybierz opcję według potrzeb:** |
|
|
| - **Demo/nauka**: Ollama + Streamlit (to rozwiązanie) |
| - **Prototyp**: Hugging Face API + Gradio |
| - **MVP**: Groq API + Next.js |
| - **Produkcja**: Modal/RunPod + custom frontend |
| - **Enterprise**: Fine-tuned model + własna infrastruktura |
|
|
| **Minimalne rozwiązanie = 5 plików, 50 linijek kodu, 2 minuty setup!** |
|
|
|
|
