Wie baue ich einen Lappen mit QWEN3?

Kürzlich kamen zwei neue QWEN-Modelle heraus-die QWEN3-4B-Instruct-2507 und Qwen3-4B-Dinking-2507. Beide QWEN3 -Modelle haben eine gute Kontextlänge von 256 Okay. und ich dachte mir: „Warum nicht einen Lappen machen, um die Kontextlänge intestine zu nutzen?“. Es ist erwähnenswert, dass die QWEN3 -Familie eine große Auswahl an Modellen hat, die zum Codieren, Denken, Einbettungen und Umbauten bestimmt sind. Um unseren Lappen bestmöglich zu machen, werden wir das Einbettungsmodell und das Reranker -Modell von QWEN3 verwenden.

Mach dir keine Sorgen, wir werden nicht damit beginnen, den Lappen zu bauen! Wir werden uns zuerst diese Modelle individuell ansehen und dann den Lappen bauen.

QWEN3 -Modelle: Hintergrund

Entwickelt von Alibaba Cloud, Mehrere QWEN3 -Modelle wurden gestartet Vor ein paar Monaten. Als Verbesserung dieser Modelle wurden kürzlich in drei Größen zwei neue Modelle, QWEN3-Instruct-2507 und Qwen3-Considering-257, in drei Größen eingeführt: 235B-A22B, 30B-A3B und 4B. Beachten Sie, dass wir uns in erster Linie auf die 4B-Variante von ‚Qwen3-Instruct-2507‘ für diesen Artikel konzentrieren werden. Alle diese Modelle sind Open-Supply und sind bei Umarmung und Kaggle leicht erhältlich. Es ist auch erwähnenswert, dass die QWEN3 -Modelle mehrsprachige Unterstützung haben, insbesondere 119 Sprachen und Dialekte. Lassen Sie uns einige der QWEN3 -Modelle in Aktion sehen und später den Lappen bauen, für den wir hier sind.

QWEN3 Fashions Demo

Beginnen wir mit dem Modellgenerierungsmodell, aber vorher stellen wir sicher, dass Holen Sie sich Ihr Umarmungs -Gesichts -Zugangs -Token von hier aus.

Hinweis: Wir werden diese Demo in Google Colab durchführen. Stellen Sie nach dem Öffnen eines neuen Notizbuchs das Zugangs -Token als hf_token in der Registerkarte Secrets and techniques hyperlinks hinzu. Stellen Sie sicher, dass Sie den Zugriff auf das Notizbuch aktivieren.

Qwen3-4b-Instruct-2507

Dies ist eine aktualisierte Model des QWEN3-4B-Nicht-Denken-Modus und hat eine fleischige Kontextlänge von 256 Okay. Wie Sie aus dem Namen selbst erkennen können, hat dieses Modell 4 Milliarden Parameter, was relativ leicht und für Colab zu verwenden ist. Lassen Sie uns dieses Modell mit den umarmenden Gesichtstransformatoren anfeuern und es in Aktion sehen.

Hinweis: Ändern Sie den Laufzeittyp in T4 GPU, um das Modell zu verarbeiten.

# Setup and Dependencies
import torch
import torch.nn.purposeful as F
from transformers import AutoModelForCausalLM, AutoTokenizer, AutoModel

# Instruct Mannequin (Textual content Technology)
tokenizer = AutoTokenizer.from_pretrained("Qwen/Qwen3-4B-Instruct-2507")
mannequin = AutoModelForCausalLM.from_pretrained(
   "Qwen/Qwen3-4B-Instruct-2507",
   torch_dtype="auto",
   device_map="auto"
)


immediate = "Clarify what machine studying is in easy phrases."
messages = ({"position": "consumer", "content material": immediate})


textual content = tokenizer.apply_chat_template(
   messages,
   tokenize=False,
   add_generation_prompt=True,
   enable_thinking=False
)


model_inputs = tokenizer((textual content), return_tensors="pt").to(mannequin.machine)


generated_ids = mannequin.generate(
   **model_inputs,
   max_new_tokens=256
)


output_ids = generated_ids(0)(len(model_inputs.input_ids(0)):).tolist()
response = tokenizer.decode(output_ids, skip_special_tokens=True)
print(response)

Hier ist die Ausgabe, die ich für meine Frage zu „Erklären Sie, was maschinelles Lernen in einfachen Worten ist“. :

Positive! In easy phrases, **machine studying** is a method for computer systems to be taught from information and enhance at doing duties with out being explicitly programmed to take action.

Think about you've got a robotic that learns to acknowledge cats in photographs. As an alternative of writing step-by-step directions like "search for a spherical face, large eyes, and a nostril," you simply present it many footage of cats and footage of canines. Over time, the robotic begins to determine what makes a cat completely different from a canine — it learns by itself by way of examples.

That’s machine studying: the pc appears to be like at information (like footage, numbers, or textual content), finds patterns, and will get higher at making predictions or choices primarily based on these patterns.

Consider it like how a baby learns to determine completely different animals by seeing them again and again. The machine does one thing related — it learns from expertise (information) and will get smarter with time.

So, briefly:  
**Machine studying = instructing computer systems to be taught from information and enhance on their very own.** 😊

Qwen3-embedding-0,6b

Das ist ein Einbettungsmodell Wird verwendet, um Textual content in dichte Vektordarstellungen umzuwandeln, um die Beziehung zwischen Texten zu verstehen. Dies ist ein wesentlicher Bestandteil des Lappen, den wir später bauen werden. Das Einbettungsmodell bildet das Herz des Retrievers in der Abruf Augmented Technology (LAG).

Lassen Sie uns eine Funktion zur Wiederverwendbarkeit definieren und die Einbettung finden, um die Ähnlichkeit zwischen den Texten zu finden. Ich übertrage 4 Saiten (Textual content) in die Liste der „Texte“.

# Qwen3-Embedding-0.6B (Textual content Embeddings)
def last_token_pool(last_hidden_states, attention_mask):
   left_padding = (attention_mask(:, -1).sum() == attention_mask.form(0))
   if left_padding:
       return last_hidden_states(:, -1)
   else:
       sequence_lengths = attention_mask.sum(dim=1) - 1
       batch_size = last_hidden_states.form(0)
       return last_hidden_states(torch.arange(batch_size, machine=last_hidden_states.machine), sequence_lengths)


tokenizer = AutoTokenizer.from_pretrained('Qwen/Qwen3-Embedding-0.6B', padding_side="left")
mannequin = AutoModel.from_pretrained('Qwen/Qwen3-Embedding-0.6B')


texts = (
   "Machine studying is a subset of synthetic intelligence.",
   "Python is a well-liked programming language.",
   "The climate is sunny right this moment.",
   "Synthetic intelligence is remodeling industries."
)


batch_dict = tokenizer(
   texts,
   padding=True,
   truncation=True,
   max_length=8192,
   return_tensors="pt",
)


outputs = mannequin(**batch_dict)
embeddings = last_token_pool(outputs.last_hidden_state, batch_dict('attention_mask'))
embeddings = F.normalize(embeddings, p=2, dim=1)
scores = (embeddings @ embeddings.T)
print(scores.tolist())

Ausgabe:

((1.0, 0.4834885597229004, 0.3609130382537842, 0.6805511713027954), (0.4834885597229004, 1.0000001192092896, 0.44289979338645935, 0.4494439363479614), (0.3609130382537842, 0.44289979338645935, 1.0000001192092896, 0.4508340656757355), (0.6805511713027954, 0.4494439363479614, 0.4508340656757355, 1.0))

Dies ist eine Matrix, die wir berechnet haben, indem wir die Ähnlichkeitswerte von Texten untereinander finden. Schauen wir uns einfach die erste Reihe der Matrix an, um das Verständnis zu erleichtern. Wie Sie sehen können, beträgt die Ähnlichkeit derselben Texte immer 1, der nächste unmittelbare höchste Wert von 0,68, was zwischen einem Satz über KI und einem Satz über ML liegt, und die Ähnlichkeit zwischen einer Aussage über Wetter und KI ist nicht sehr hoch, was sinnvoll ist.

Qwen3-leranker-0.6b

Wir können die abgerufenen Stücke übergeben, die durch Vektorsuche mit dem Einbettungsmodell erhalten werden können. Das Reranker -Modell bewertet jeden Chunk gegen die Abfrage, um die Liste der Dokumente zu bestellen und Priorität zuzuweisen, oder verwenden Sie diese Bewertungen, um die abgerufenen Brocken zu untermengen. Wir werden dieses Modell im kommenden Abschnitt direkt in Aktion sehen, um ein besseres Verständnis zu erhalten.

Erstellen eines Lappen mit den QWEN -Modellen

Wir werden einen Lappen aufbauen Analytics Vidhya Blogs (~ 40 Blogs) Verwenden der drei angegebenen QWEN3 -Modelle. Wir werden die Daten nacheinander verarbeiten und die Modelle verwenden. Für die effiziente Verarbeitung laden/entladen wir das Modell für die Nutzung, um den Speicher zu erhalten. Schauen wir uns die Schritte an und tauchen in das Skript ein.

• Schritt 1: Laden Sie die Daten herunter. Hier ist der Hyperlink zu meinem Repository wo Sie die Daten und die Skripte finden können.
• Schritt 2: Installieren Sie die Anforderungen:
  ! PIP Installieren Sie FAISS-CPU PYPDF2
• Schritt 3: Entpacken Sie die Daten in einen Ordner:
  ! Unzipp information.zip
• Schritt 4: Für die einfachere Ausführung können Sie einfach das Skript qwen_rag.py in die Colab -Umgebung hinzufügen und das Skript mit:
  ! Python qwen_rag.py

Das Drehbuch aufbrechen:

• Wir verwenden die PYPDF2 -Bibliothek, um den Inhalt der Artikel im PDF -Format zu laden. Eine Funktion wird definiert, um Weblog -Inhalte in .txt- oder .pdf -Formaten zu lesen.
• Wir tauchen den Inhalt in Stücke von Größe 800 und eine Überlappung von 100, um die Kontextrelevanz in aufeinanderfolgenden Dokumenten aufrechtzuerhalten.
• Wir verwenden FAISS, um einen Vektor-Retailer zu erstellen, und reichen mit Hilfe unserer Abfrage die High-15-Dokumente basierend auf Ähnlichkeit.
• Jetzt verwenden wir den Reranker für diese 15 Dokumente, um die High-3 mithilfe dieser Funktion zu erhalten:

def rerank_documents(question, candidates, k_rerank=3):
   """Rerank paperwork utilizing reranker mannequin"""
   print("Reranking paperwork...")
   tokenizer, mannequin = load_reranker_model()
  
   # Put together inputs
   pairs = ()
   for doc, _ in candidates:
       pair = f"<Instruct>: Given an online search question, retrieve related passages that reply the queryn<Question>: {question}n<Doc>: {doc('content material')}"
       pairs.append(pair)
  
   # Tokenize
   inputs = tokenizer(pairs, padding=True, truncation=True, max_length=8192, return_tensors="pt").to(machine)
  
   # Get scores
   with torch.no_grad():
       outputs = mannequin(**inputs)
       logits = outputs.logits(:, -1, :)
      
       # Get sure/no token scores
       token_false_id = tokenizer.convert_tokens_to_ids("no")
       token_true_id = tokenizer.convert_tokens_to_ids("sure")
      
       true_scores = logits(:, token_true_id)
       false_scores = logits(:, token_false_id)
      
       batch_scores = torch.stack((false_scores, true_scores), dim=1)
       batch_scores = torch.nn.purposeful.log_softmax(batch_scores, dim=1)
       scores = batch_scores(:, 1).exp().tolist()
  
   # Unload reranker mannequin
   del tokenizer, mannequin
   clear_memory()
   print("Reranker mannequin unloaded")
  
   # Kind by rating
   paperwork = (doc for doc, _ in candidates)
   doc_scores = record(zip(paperwork, scores))
   doc_scores.type(key=lambda x: x(1), reverse=True)
  
   return doc_scores(:k_rerank)

• Sobald wir diese 3 High -Dokumente haben, übergeben wir sie an das Anweisungsmodell, um unsere endgültige Ausgabe vom Abruf Augmented Generator zu erhalten.

Ausgabe:

Query: What's the distinction between LoRA and QLoRA?

Reply: LoRA (Low-Rank Adaptation) and QLoRA (Quantized Low-Rank Adaptation) are each parameter-efficient fine-tuning strategies used to adapt giant language fashions (LLMs) to particular duties. Whereas they share similarities, they differ of their strategy and effectivity.

1. **LoRA (Low-Rank Adaptation)**:

- LoRA introduces low-rank matrices (A and B) into the self-attention module of every layer within the pre-trained mannequin. These matrices act as adapters that enable the mannequin to adapt and specialize for particular duties whereas minimizing the variety of extra parameters wanted.

- LoRA reduces parameter overhead by specializing in optimizing trainable low-rank matrices as a substitute of fine-tuning all parameters. This makes it far more memory-efficient and computationally cheaper.

- LoRA permits the pre-trained mannequin to be shared throughout a number of duties, facilitating environment friendly task-switching throughout deployment.

- LoRA doesn't introduce any extra inference latency in comparison with absolutely fine-tuned fashions, making it appropriate for real-time functions.

2. **QLoRA (Quantized Low-Rank Adaptation)**:

- QLoRA is an extension of LoRA that additional introduces quantization to boost parameter effectivity throughout fine-tuning. It builds on the rules of LoRA whereas introducing 4-bit NormalFloat (NF4) quantization and Double Quantization strategies.

- NF4 quantization leverages the inherent distribution of pre-trained neural community weights, remodeling all weights to a hard and fast distribution that matches throughout the vary of NF4 (-1 to 1). This permits for efficient quantization with out the necessity for costly quantile estimation algorithms.

- Double Quantization addresses the reminiscence overhead of quantization constants by quantizing the quantization constants themselves. This considerably reduces the reminiscence footprint with out compromising efficiency.

- QLoRA achieves even increased reminiscence effectivity by introducing quantization, making it significantly invaluable for deploying giant fashions on resource-constrained units.

- Regardless of its parameter-efficient nature, QLoRA retains excessive mannequin high quality, acting on par and even higher than absolutely fine-tuned fashions on numerous downstream duties.

In abstract, whereas LoRA focuses on lowering the variety of trainable parameters by way of low-rank adaptation, QLoRA additional enhances this effectivity by incorporating quantization strategies, making it extra appropriate for deployment on units with restricted computational sources.

Sources: fine_tuning.txt, Parameter-Environment friendly Positive-Tuning of Massive Language Fashions with LoRA and QLoRA.pdf, Parameter-Environment friendly Positive-Tuning of Massive Language Fashions with LoRA and QLoRA.pdf

Hinweis: Sie können auf die Protokolldatei ‚rag_retrieval_log.txt‘ verweisen, um weitere Informationen zu den abgerufenen Dokumenten und der Ähnlichkeitsbewertung mit der Abfrage und den Reranker -Bewertungen zu erhalten.

Abschluss

Durch die Kombination von QWEN3 -Modellen von Anweisungen, Einbetten und Reranker haben wir eine praktische Lag -Pipeline gebaut, die ihre Stärken voll ausnutzt. Mit einer Kontextlänge von 256K und mehrsprachiger Unterstützung erweist sich die QWEN-Familie für reale Aufgaben vielseitig. Für die nächsten Schritte können Sie versuchen, die an das Anweisungsmodell übergebenen Dokumente zu erhöhen oder ein Denkmodell für einen anderen Anwendungsfall zu verwenden. Die Ausgänge scheinen auch vielversprechend zu sein. Ich schlage vor, Sie versuchen, den Lappen auf Metriken wie Treue und Relevanz zu bewerten, um sicherzustellen, dass die LLM für Ihre Aufgabe/Ihren Anwendungsfall größtenteils frei von Halluzinationen ist.

Häufig gestellte Fragen

Leidenschaft für Technologie und Innovation, Absolvent des Vellore Institute of Know-how. Derzeit arbeitet er als Knowledge Science Trainee und konzentriert sich auf die Datenwissenschaft. Es ist sehr interessiert an tiefem Lernen und generativen KI, bestrebt, modernste Techniken zu erforschen, um komplexe Probleme zu lösen und wirkungsvolle Lösungen zu schaffen.