Dokumente mit Ollama und Qwen3 Reranker-Modell neu bewerten – in Go

$ ./rnk ./example_query.txt ./example_docs

Verwende Embedding-Modell: dengcao/Qwen3-Embedding-4B:Q5_K_M
Ollama-Grund-URL: http://localhost:11434
Verarbeite Abfrage-Datei: ./example_query.txt, Zielverzeichnis: ./example_docs
Abfrage: Was ist künstliche Intelligenz und wie funktioniert maschinelles Lernen?
7 Dokumente gefunden
Extrahiere Abfrage-Embedding...
Verarbeite Dokumente...

=== RANGIEREN NACH ÄHNLICHKEIT ===
1. example_docs/ai_introduction.txt (Score: 0.451)
2. example_docs/machine_learning.md (Score: 0.388)
3. example_docs/qwen3-reranking-models.md (Score: 0.354)
4. example_docs/ollama-parallelism.md (Score: 0.338)
5. example_docs/ollama-reranking-models.md (Score: 0.318)
6. example_docs/programming_basics.txt (Score: 0.296)
7. example_docs/setup.log (Score: 0.282)

7 Dokumente verarbeitet in 2.023s (Durchschnitt: 0.289s pro Dokument)
Dokumente mit Reranker-Modell neu rangieren...
Implementierung des Rerankings mit cross-encoder-Ansatz mit dengcao/Qwen3-Reranker-4B:Q5_K_M

=== RANGIEREN MIT RERANKER ===
1. example_docs/ai_introduction.txt (Score: 0.343)
2. example_docs/machine_learning.md (Score: 0.340)
3. example_docs/programming_basics.txt (Score: 0.320)
4. example_docs/setup.log (Score: 0.313)
5. example_docs/ollama-parallelism.md (Score: 0.313)
6. example_docs/qwen3-reranking-models.md (Score: 0.312)
7. example_docs/ollama-reranking-models.md (Score: 0.306)

7 Dokumente verarbeitet in 1.984s (Durchschnitt: 0.283s pro Dokument)

  startTime = time.Now()
	// Reranking mit Reranker-Modell
	fmt.Println("Dokumente mit Reranker-Modell neu rangieren...")

	// rerankingModel := "dengcao/Qwen3-Reranker-0.6B:F16"
	rerankingModel := "dengcao/Qwen3-Reranker-4B:Q5_K_M"
	rerankedDocs, err := rerankDocuments(validDocs, query, rerankingModel, ollamaBaseURL)
	if err != nil {
		log.Fatalf("Fehler beim Reranking der Dokumente: %v", err)
	}

	fmt.Println("\n=== RANGIEREN MIT RERANKER ===")
	for i, doc := range rerankedDocs {
		fmt.Printf("%d. %s (Score: %.3f)\n", i+1, doc.Path, doc.Score)
	}

	totalTime = time.Since(startTime)
	avgTimePerDoc = totalTime / time.Duration(len(rerankedDocs))

	fmt.Printf("\n%d Dokumente verarbeitet in %.3fs (Durchschnitt: %.3fs pro Dokument)\n",
		len(rerankedDocs), totalTime.Seconds(), avgTimePerDoc.Seconds())

func rerankDocuments(validDocs []Document, query, rerankingModel, ollamaBaseURL string) ([]Document, error) {
	// Da das standardmäßige Ollama keinen direkten Rerank-API-Anschluss hat, implementieren wir
	// Reranking, indem wir Embeddings für Abfrage-Dokument-Paare generieren und sie bewerten

	fmt.Println("Implementierung des Rerankings mit cross-encoder-Ansatz mit", rerankingModel)

	rerankedDocs := make([]Document, len(validDocs))
	copy(rerankedDocs, validDocs)

	for i, doc := range validDocs {
		// Erstellen Sie einen Prompt für Reranking, indem Sie Abfrage und Dokument kombinieren
		rerankPrompt := fmt.Sprintf("Abfrage: %s\n\nDokument: %s\n\nRelevanz:", query, doc.Content)

		// Embedding für den kombinierten Prompt erhalten
		embedding, err := getEmbedding(rerankPrompt, rerankingModel, ollamaBaseURL)
		if err != nil {
			fmt.Printf("Warnung: Fehlgeschlagen, um Rerank-Embedding für Dokument %d zu erhalten: %v\n", i, err)
			// Fallback auf einen neutralen Score
			rerankedDocs[i].Score = 0.5
			continue
		}

		// Die Größe des Embeddings als Relevanzscore verwenden
		// (Dies ist ein vereinfachter Ansatz - in der Praxis würden Sie einen trainierten Reranker verwenden)
		score := calculateRelevanceScore(embedding)
		rerankedDocs[i].Score = score
		// fmt.Printf("Dokument %d neu rangiert mit Score: %.4f\n", i, score)
	}

	// Dokumente nach Rerank-Score (absteigend) sortieren
	sort.Slice(rerankedDocs, func(i, j int) bool {
		return rerankedDocs[i].Score > rerankedDocs[j].Score
	})

	return rerankedDocs, nil
}

func calculateRelevanceScore(embedding []float64) float64 {
	// Einfache Bewertung basierend auf Embedding-Größe und positiven Werten
	var sumPositive, sumTotal float64
	for _, val := range embedding {
		sumTotal += val * val
		if val > 0 {
			sumPositive += val
		}
	}

	if sumTotal == 0 {
		return 0
	}

	// Normalisieren und kombinieren Sie Größe mit positivem Bias
	magnitude := math.Sqrt(sumTotal) / float64(len(embedding))
	positiveRatio := sumPositive / float64(len(embedding))

	return (magnitude + positiveRatio) / 2
}

import (
	"math"
)

go build -o rnk

./rnk ./example_query.txt ./example_docs