Obsidian/ChatGPT/AMD Ryzen AI Max+ 395/deepseek.md

Terviklik lahendus AMD Ryzen AI Max+ 395 (Ryzen AI 9 HX 370?) platvormil Linuxis teadustööks PDF-töötlusega

Arvestades teie võimsat uut AI-protsessorit (mis sisaldab spetsiaalseid NPU kiirendiid), Linuxi kasutamist ja vajadust isoleeritud LLM-i järele, on oluline valida rakendused, mis:

1. Kasutavad ära AI-kiirendust (NPU/GPU).
2. On stabilised Linuxi jaoks.
3. Ei dubleeri funktsioone.
4. Toetavad teadustööd ja PDF-töövoogu.

1. PDF-i haldus ja märgendamine

• Okular (KDE osa): Parim PDF-lugeja/kommenteerija Linuxis. Toetab teksti esiletõstmist, märkuste lisamist, sisukorra vaatamist. Integreerub hästi teiste KDE rakendustega, isegi kui kasutate teist DE.
• Master PDF Editor (tasuline, kuid väga võimas): Kui vajate PDF-ide redigeerimist (teksti/piltide muutmist), vormide täitmist, digiallkirjastamist. Saadaval ka Linuxile.

2. Dokumendihaldus ja viited

• Zotero: Teaduslike allikate halduse kuldne standard. Kogub, korraldab, sünkroniseerib ja genereerib viiteid. Kasutage veebipõhist versiooni või officiaalse desktop versiooniga (mitte Flatpak) saab integreerida Firefox/Chrome brauseriga.
• Calibre: Raamatukogu haldur, mis sobib ka suuremate PDF-kogude korrastamiseks, metaandmete muutmiseks ja formaatide konverteerimiseks.

3. LLM (isoleeritud ja kohalik)

Sinu Ryzen AI Max+ toetab kohalikku AI-töötlust NPU kaudu (XDNA2). Soovitan järgmisi valikuid:

• Ollama: Lihtne, tõhus platvorm kohalike LLM-de käivitamiseks. Toetab NPU-d AMD Ryzen AI kaudu (kuid vajab spetsiaalseid draivereid ja tugi on arendamisel). Võimaldab isoleerida täielikult (töötab kohapeal).
  • Mudelid: Llama 3.2, Mistral, Qwen2.5 (vali ~7B parameetrit, et mahutada mälupiirangutesse).
  • Kasutusalad: Keeleline analüüs, kokkuvõtete tegemine PDF-idest (teksti ekstraktimise järel), koodi genereerimine.
• GPT4All: Alternatiivne GUI-põhine lahendus Ollamale. Sobib hästi, kui eelistad graafilist liidest mudelite haldamiseks ja vestluseks.
• Isoleerimine: Kasuta Dockerit või Podmanit Ollama konteinerite jaoks, et eraldada LLM põhisüsteemist. Näiteks: docker run -d -v ollama:/root/.ollama -p 11434:11434 --name ollama ollama/ollama.

4. AI-põhised PDF-analüüsi tööriistad

• Difract: AI abil PDF-ide analüüs (tekst, tabelid, joonised). Pakub CLI ja GUI-d, toetab mudeleid nagu LLaVA.
• LLM-ga integreeritud lahendused: Kui ekstraheerid PDF-idest teksti (Okular või pdftotext), saad seda tekstifaili Ollama API kaudu analüüsida. Võid kirjutada lihtsa skripti (Pythonis requests teek), mis saadab teksti sinu isoleeritud LLM-ile ja tagastab kokkuvõtte.

5. Süsteemi tarkvara ja AI-tugi

• Distro: Ubuntu 24.04 LTS või Fedora Workstation 40+ – need toetavad uusimaid draivereid ja AI-stäke paremini.
• Draiverid: Veendu, et on paigaldatud AMD ROCm (GPU-tugi AI jaoks) ja Ryzen AI S/W pakett (NPU jaoks). AMD on hiljuti avaldanud Linuxi draiverid NPU jaoks (vaata ryzenai GitHubi lehelt).
• Kontainerid: Docker või Podman LLM-i isoleerimiseks ja reprodutseeritavuse tagamiseks.
• Turvalisus: Firejail või AppArmor rakenduste isoleerimiseks, kui LLM ei käivitata Dockeris.

6. Abitööriistad

• OCR: Ocrmypdf – teeb PDF-idest otsitavad (lisades teksti kihi skannitud PDF-idele). Vajalik ajalooliste dokumentide jaoks.
• Tekstiredaktor: VS Code või Kate – skriptide kirjutamiseks, noteerimiseks.
• Terminal: Kitty või Alacritty – kiired GPU-arendatud terminalid, mis toetavad paremini AI-rakendusi.

Kokkuvõtlik nimekiri (minimaalne, mitte dubleeriv)

1. Okular – PDF lugemine/märgendamine.
2. Zotero – viidete haldus.
3. Ollama (Dockeris) – isoleeritud LLM.
4. Difract või kohandatud skript – AI-põhine PDF-analüüs.
5. Ocrmypdf – OCR tööriist.
6. Calibre – PDF-kogude haldus (kui palju PDF-faile).

Töövoog näide

1. Kogud PDF-id Zoterosse (automaatselt metaandmetega).
2. Avad PDF Okularis, teed märkusi.
3. Kasutad Ocrmypdf OCR-i skannitud PDF-idele.
4. Ekstraktid teksti (Okularist või pdftotext).
5. Saadad teksti Ollama LLM-ile (Dockeris isoleeritud) kokkuvõtte saamiseks.
6. Kasutad Difracti keerukate PDF-ide (tabelite, diagrammide) analüüsiks.

Olulised märkused

• Ryzen AI NPU tugi Linuxis: AMD on avaldanud Ryzen AI tarkvara, kuid täielik tugi sõltub kerneli versioonist (>6.10). Kontrolli uusimaid dokumente.
• Isoleerimine: LLM-i puhul kasuta alati Dockerit/Podmanit, et vältida sõltuvuste konflikte ja turvaohte.
• Mälupiirangud: Ryzen AI 395 NPU-l on piiratud mälu (~16-32GB jagatud). Vali LLM mudeleid vastavalt sellele (nt 7B parameetrit kvantiseerituna).

See süsteem on tasakaalustatud, võimas ja keskendunud, kasutades ära teie riistvara AI-potentsiaali, säilitades samas lihtsuse ja isoleerituse.

llama.cpp vs Ollama: põhjalik võrdlus Linuxi AI-töövoogude jaoks

Ülevaade

Aspekt	llama.cpp	Ollama
Olemus	C++ raamistik LLM-de jooksutamiseks	Kõrgetasemeline rakendus/majutaja LLM-de jaoks
Liides	Primäärselt CLI, API, C++ teek	CLI + REST API + kergem GUI (Ollama WebUI)
Paigaldus	Käsitsi kompileerimine või eelkoostatud binaar	Üks käsk (curl või Docker), automaatne
Mudelid	GGUF formaat (väga lai valik)	Modelfile süsteem (kasutajasõbralik)
Riistvara tugi	CPU, CUDA, ROCm, Metal, Vulkan	CPU, CUDA, ROCm (NPU tugi areneb)
Isoleerimine	Käsitsi Docker/singularity	Sisseehitatud Docker tugi, lihtsam isoleerida
Seadistamine	Palju parameetreid, täpsem kontroll	Lihtsam, vähem seadistusi

Detailne võrdlus teie kasutusjuhtumi jaoks

llama.cpp

Tugevused:

1. Maksimaalne kontroll - Saad täpselt seadistada konteksti, partisioone, kiive jne
2. Lai riistvaratugi - Toetab AMD ROCm (teie GPU jaoks) hästi läbi -ngl parameetri
3. Optimeeritud jõudlus - Eriti GGUF kvantiseeritud mudelitel
4. Aktiivne arendus - Uued funktsioonid (nagu NPU tugi) ilmuvad kiiresti
5. Serverrežiim - --server võimaldab REST API-d, sarnaselt Ollamale

Nõrkused:

1. Keerulisem seadistus - Vajab rohkem tehnilist teadmist
2. Mudelihaldus puudub - Pead ise haldama GGUF faile ja teadma nende asukohti
3. Vähem kasutajasõbralik - Rohkem käsureaparameetreid

Ollama

Tugevused:

1. Lihtne kasutus - ollama run llama3.2 ja kohe töötab
2. Automaatne mudelihaldus - Laeb alla, uuendab, hoiab korraldatult
3. Modelfile süsteem - Saad kohandada mudeleid ilma tehniliste teadmisteta
4. Integratsioonid - Hea tugi teiste rakendustega (Open WebUI, Continue.dev jne)
5. Docker toetus - Valmis pildid, lihtne isoleerida

Nõrkused:

1. Piiratud mudelivalik - Toetab peamiselt populaarseid mudeleid (kuigi valik laieneb)
2. Vähem kontrolli - Kõrgema taseme seadistused keerulisemad
3. Riistvaratugi - ROCm tugi on olemas, kuid NPU toetus alles areneb

Teie konkreetse kasutusjuhtumi soovitus

Vali Ollama, kui:

1. Soovid kiiret ja lihtsat alustamist
2. Vajad automaatset mudelihaldust
3. Isoleerimine on oluline (Ollama Dockeris on lihtne)
4. Ei vaja erilisi, eksperimentaalseid mudeleid
5. Soovid lihtsat REST API-d teiste rakenduste jaoks

Vali llama.cpp, kui:

1. Vajad maksimaalset jõudlust ja kontrolli
2. Soovid kasutada erilisi mudeleid (vanemaid või kohandatud GGUF faile)
3. AMD ROCm/GPU kiirendus on kriitiline (Ollama toetab ka, kuid llama.cpp võib olla efektiivsem)
4. Tehniline seadistamine ei hirmuta
5. Vajad NPU kiirendust (AMD Ryzen AI Max+ puhul on tugi veel arenevas staadiumis mõlemas)

Praktiline lahendus teie süsteemile

Hübriidlahendus (soovitan):

Kasuta mõlemat, erinevatel eesmärkidel:

1. Ollama - Peamine LLM-i kasutajaliides

   • Lihtne API PDF-analüüsirakendustele
   • Docker konteinerina isoleeritud
   • Kiire alustamine uute mudelitega

2. llama.cpp - Spetsiaalsed/jõudluskriitilised ülesanded

   • Kui vajad maksimaalset kiirust suurte dokumentidega
   • Spetsiaalsete mudelite jaoks
   • Kui AMD NPU tugi saab täielikult kättesaadavaks

Paigaldusnäited:

Ollama (Dockeris isoleeritud):

docker run -d -v ollama_data:/root/.ollama -p 11434:11434 --name ollama --restart always ollama/ollama
docker exec ollama ollama pull llama3.2:7b
# API päring: curl http://localhost:11434/api/generate -d '{"model":"llama3.2:7b", "prompt":"..."}'

llama.cpp (otsene seadistus):

# Kompileeri ROCm toega
git clone https://github.com/ggerganov/llama.cpp
cd llama.cpp
make LLAMA_HIPBLAS=1
# Laadi GGUF mudel
./server -m models/llama-3.2-7b.Q4_K_M.gguf --port 8080

AMD Ryzen AI Max+ kontekst

1. NPU tugi:

   • llama.cpp: Arenevas staadiumis, PR-d aktiivsed
   • Ollama: AMD Ryzen AI draiverite kaudu, kui need saadavad
     

2. GPU (ROCm) tugi:

   • Mõlemad toetavad, kuid llama.cpp võib pakuda paremat jõudlust täpsete seadistustega

3. Praegune soovitus: Kuna NPU tugi on veel arenevas staadiumis Linuxis, alusta Ollamaga, mis pakub:

   • Lihtsust
   • Hea ROCm tugi läbi Docker
   • Lihtsa isoleerimise
     

Kui NPU tugi stabiliseerub, hinnaku uuesti - llama.cpp võib saada esivalikuks NPU kasutamiseks.

Lõplik soovitus

Kasuta Ollamat järgmistel põhjustel:

1. Teie esmane vajadus on isoleeritud LLM - Ollama Dockeris on lihtsam
2. PDF töötluseks ei vaja tihti maksimaalset jõudlust, vaid stabilisust
3. Teadustöös on oluline reprodutseeritavus - Ollama Modelfile'id on lihtsam jagada
4. Integratsioon teiste rakendustega on lihtsam (REST API)

llama.cpp hoidke varuvariandina juhuks, kui:

1. Tekivad spetsiifilised jõudlusnõuded
2. Vajate eksperimentaalseid mudeleid
3. AMD NPU tugi saab täielikult kättesaadavaks ja stabiliseerub

Minimaalne seadistus: Alusta Ollamaga Dockeris. Kui jõudlus ei rahulda, proovi llama.cpp ROCm toega.

Täielikult piisavad - täpselt see, mida vajad! Weaviate integreerimine muudab sinu süsteemi tõeliselt võimsaks teadustööks. Siin on terviklik lahendus sinu eesmärgiks:

Täiustatud arhitektuur Weaviate'iga

PDF-d → Tekstiekstraktor → Chunking → Embeddings → Weaviate → RAG → LLM → Vastus

1. Weaviate paigaldus ja seadistus

Valikud:

• Kohalik Docker (soovitan): Isoleeritud, täielik kontroll
• Weaviate Cloud (WCD): Hõlpsam, kuid tasuline
• Asustatud server (VM): Parem jõudlus

Docker-põhine lahendus:

# Weaviate + tekstivektoriseerimise moodul
docker run -d \
  --name weaviate \
  -p 8080:8080 \
  -p 50051:50051 \
  -e QUERY_DEFAULTS_LIMIT=25 \
  -e AUTHENTICATION_ANONYMOUS_ACCESS_ENABLED=true \
  -e PERSISTENCE_DATA_PATH=/var/lib/weaviate \
  -e ENABLE_MODULES=text2vec-transformers \
  -e TRANSFORMERS_INFERENCE_API=http://t2v-transformers:8080 \
  --volume weaviate_data:/var/lib/weaviate \
  semitechnologies/weaviate:1.24.0

# Transformers konteiner embeddingute jaoks
docker run -d \
  --name t2v-transformers \
  -p 8081:8080 \
  -e ENABLE_CUDA=1 \
  semitechnologies/transformers-inference:sentence-transformers-all-MiniLM-L12-v2

2. Sinu töövoog 1000+ artikliga

A. PDF-ist tekstiekstraheerimine

# Paigalda: pip install pymupdf python-multipart weaviate-client
import fitz  # PyMuPDF

def extract_text_from_pdf(pdf_path):
    doc = fitz.open(pdf_path)
    text = ""
    for page in doc:
        text += page.get_text()
    return text

B. Tark chunking (lõikudeks jagamine)

from langchain.text_splitter import RecursiveCharacterTextSplitter

text_splitter = RecursiveCharacterTextSplitter(
    chunk_size=1000,
    chunk_overlap=200,
    length_function=len,
    separators=["\n\n", "\n", ". ", " ", ""]
)

chunks = text_splitter.split_text(extracted_text)

C. Weaviatesse lisamine

import weaviate
from weaviate.embedded import EmbeddedOptions

client = weaviate.Client(
    embedded_options=EmbeddedOptions()
)

# Skema loomine
class_obj = {
    "class": "ResearchPaper",
    "vectorizer": "text2vec-transformers",
    "properties": [
        {
            "name": "title",
            "dataType": ["string"]
        },
        {
            "name": "content",
            "dataType": ["text"]
        },
        {
            "name": "chunk_index",
            "dataType": ["int"]
        },
        {
            "name": "source_pdf",
            "dataType": ["string"]
        }
    ]
}

client.schema.create_class(class_obj)

# Andmete lisamine
for i, chunk in enumerate(chunks):
    client.data_object.create(
        data_object={
            "title": pdf_title,
            "content": chunk,
            "chunk_index": i,
            "source_pdf": pdf_filename
        },
        class_name="ResearchPaper"
    )

3. Olemasolevate tööriistade täiendamine

Ollama + Weaviate RAG süsteem:

import ollama
import weaviate

class ResearchAssistant:
    def __init__(self):
        self.weaviate = weaviate.Client("http://localhost:8080")
        self.model = "llama3.2:7b"
    
    def search_papers(self, query, limit=5):
        # Vektorotsing Weaviates
        result = self.weaviate.query.get(
            "ResearchPaper", ["content", "title", "source_pdf"]
        ).with_near_text({
            "concepts": [query]
        }).with_limit(limit).do()
        
        return result
    
    def ask_question(self, question):
        # 1. Otsi relevantseid lõike
        relevant_chunks = self.search_papers(question)
        
        # 2. Koosta kontekst
        context = "\n\n".join([
            f"[{chunk['title']}]: {chunk['content']}"
            for chunk in relevant_chunks
        ])
        
        # 3. Saada LLM-ile
        prompt = f"""Vastad teaduslikule küsimusele alloleva konteksti põhjal.
        
        Kontekst:
        {context}
        
        Küsimus: {question}
        
        Vasta täpselt ja viita allikatele."""
        
        response = ollama.chat(model=self.model, messages=[
            {"role": "user", "content": prompt}
        ])
        
        return {
            "answer": response['message']['content'],
            "sources": relevant_chunks
        }

4. CLI tööriist massiliseks importimiseks

#!/bin/bash
# import_papers.sh

for pdf in ./papers/*.pdf; do
    echo "Töötlen: $pdf"
    python3 -c "
import sys
from paper_importer import PaperImporter

importer = PaperImporter()
importer.import_paper('$pdf')
print(f'Lisatud: {sys.argv[1]}')
"
done

5. Grafiline liides (valikuline)

Streamlit rakendus:

# app.py
import streamlit as st
from research_assistant import ResearchAssistant

st.title("Teaduslik Uurimisassistent")
assistant = ResearchAssistant()

question = st.text_input("Esita küsimus oma artiklite kohta:")

if question:
    with st.spinner("Otsin vastust..."):
        result = assistant.ask_question(question)
        
    st.markdown("### Vastus:")
    st.write(result["answer"])
    
    st.markdown("### Allikad:")
    for source in result["sources"]:
        with st.expander(f"{source['title']}"):
            st.write(source['content'])

6. Täiendatud arhitektuuri skeem

Sinna süsteem:
┌─────────────────┐
│   1000+ PDF-d   │
└────────┬────────┘
         │
┌────────▼────────┐
│  PyMuPDF ekstrak│
└────────┬────────┘
         │
┌────────▼────────┐
│  Text Splitter  │
│  (chunking)     │
└────────┬────────┘
         │
┌────────▼────────┐
│ Weaviate Client │
│ + embeddings    │
└────────┬────────┘
         │
    ┌────┴────┐
    │Weaviate │
    │VektorDB │
    └────┬────┘
         │
┌────────▼────────┐
│   RAG Süsteem   │
│  (Ollama API)   │
└────────┬────────┘
         │
┌────────▼────────┐
│     Vastus      │
└─────────────────┘

7. Soovituslikud täiendused

Performance optimeerimine:

1. Paralleelne importimine:

   from concurrent.futures import ThreadPoolExecutor
   
   with ThreadPoolExecutor(max_workers=4) as executor:
   executor.map(import_paper, pdf_files)
   

2. Vahemälu embeddingutele - väldi dubleerivaid arvutusi

3. Indekseerimise ajastamine - cron job ööseseks importimiseks

Spetsiifilised teadustöö funktsioonid:

# Viidete ekstraheerimine
def extract_citations(text):
    # Kasuta regex või spetsiaalseid teeke
    pass

# Autorite ja institutsioonide tuvastamine
def extract_authors(text):
    pass

# Kokkuvõtete automaatne genereerimine
def generate_summaries(papers):
    pass

8. Paigaldusjuhised

# 1. Paigalda Docker
sudo apt install docker.io docker-compose

# 2. Käivita Weaviate
docker-compose up -d

# 3. Paigalda Pythoni teegid
pip install weaviate-client pymupdf langchain ollama streamlit

# 4. Seadista Ollama
docker run -d -p 11434:11434 ollama/ollama
docker exec ollama ollama pull llama3.2:7b

# 5. Importi andmed
python import_all_papers.py /path/to/pdf/folder

Kokkuvõte

Jah, sinu tööriistad on täielikult piisavad! Weaviate integreerimine:

1. Suurendab otsingutäpsust - semantiline otsing vs tavaline tekst
2. Võimaldab RAG-i (Retrieval-Augmented Generation) - täpsemad vastused
3. Skaaleerub hästi - 1000+ artiklit on lihtne haldada
4. Säilitab isoleerituse - kõik kohapeal

Eelised sinu praeguse süsteemi peal:

• Ollama pakub LLM-i jõudluse
• Weaviate pakub kiire ja täpse otsingu
• Kõik töötab Dockeris (isoleeritult)
• Python API võimaldab täpset kontrolli

Soovitan alustada väiksema testkoguga (50-100 artiklit), et optimeerida chunking ja embedding parameetreid enne kogu 1000+ artikli importimist.

Kas soovid konkreetsemat koodinäidet mõne etapiga?