class AdvancedNeuralAgent:
   def __init__(self, input_size, hidden_layers=(64, 32), output_size=1, learning_rate=0.001):
       """Superior AI Agent with steady coaching and choice making capabilities"""
       self.lr = learning_rate
       self.initial_lr = learning_rate
       self.layers = ()
       self.reminiscence = ()
       self.performance_history = ()
       self.epsilon = 1e-8 
      
       layer_sizes = (input_size) + hidden_layers + (output_size)
       for i in vary(len(layer_sizes) - 1):
           fan_in, fan_out = layer_sizes(i), layer_sizes(i+1)
           restrict = np.sqrt(6.0 / (fan_in + fan_out))
          
           layer = {
               'weights': np.random.uniform(-limit, restrict, (layer_sizes(i), layer_sizes(i+1))),
               'bias': np.zeros((1, layer_sizes(i+1))),
               'momentum_w': np.zeros((layer_sizes(i), layer_sizes(i+1))),
               'momentum_b': np.zeros((1, layer_sizes(i+1)))
           }
           self.layers.append(layer)
  
   def activation(self, x, func="relu"):
       """Steady activation features with clipping"""
       x = np.clip(x, -50, 50) 
      
       if func == 'relu':
           return np.most(0, x)
       elif func == 'sigmoid':
           return 1 / (1 + np.exp(-x))
       elif func == 'tanh':
           return np.tanh(x)
       elif func == 'leaky_relu':
           return np.the place(x > 0, x, x * 0.01)
       elif func == 'linear':
           return x
  
   def activation_derivative(self, x, func="relu"):
       """Steady derivatives"""
       x = np.clip(x, -50, 50)
      
       if func == 'relu':
           return (x > 0).astype(float)
       elif func == 'sigmoid':
           s = self.activation(x, 'sigmoid')
           return s * (1 - s)
       elif func == 'tanh':
           return 1 - np.tanh(x)**2
       elif func == 'leaky_relu':
           return np.the place(x > 0, 1, 0.01)
       elif func == 'linear':
           return np.ones_like(x)
  
   def ahead(self, X):
       """Ahead move with gradient clipping"""
       self.activations = (X)
       self.z_values = ()
      
       current_input = X
       for i, layer in enumerate(self.layers):
           z = np.dot(current_input, layer('weights')) + layer('bias')
           z = np.clip(z, -50, 50) 
           self.z_values.append(z)
          
           if i < len(self.layers) - 1: 
               a = self.activation(z, 'leaky_relu')
           else: 
               a = self.activation(z, 'linear')
          
           self.activations.append(a)
           current_input = a
      
       return current_input
  
   def clip_gradients(self, gradients, max_norm=1.0):
       """Gradient clipping to forestall explosion"""
       grad_norm = np.linalg.norm(gradients)
       if grad_norm > max_norm:
           gradients = gradients * (max_norm / (grad_norm + self.epsilon))
       return gradients
  
   def backward(self, X, y, output):
       """Steady backpropagation with gradient clipping"""
       m = X.form(0)
      
       dz = (output - y.reshape(-1, 1)) / m
       dz = np.clip(dz, -10, 10)
      
       for i in reversed(vary(len(self.layers))):
           layer = self.layers(i)
          
           dw = np.dot(self.activations(i).T, dz)
           db = np.sum(dz, axis=0, keepdims=True)
          
           dw = self.clip_gradients(dw, max_norm=1.0)
           db = self.clip_gradients(db, max_norm=1.0)
          
           momentum = 0.9
           layer('momentum_w') = momentum * layer('momentum_w') + (1 - momentum) * dw
           layer('momentum_b') = momentum * layer('momentum_b') + (1 - momentum) * db
          
           weight_decay = 0.0001
           layer('weights') -= self.lr * (layer('momentum_w') + weight_decay * layer('weights'))
           layer('bias') -= self.lr * layer('momentum_b')
          
           if i > 0:
               activation_func="leaky_relu" if i > 1 else 'leaky_relu'
               dz = np.dot(dz, layer('weights').T) * self.activation_derivative(
                   self.z_values(i-1), activation_func)
               dz = np.clip(dz, -10, 10) 
  
   def adapt_learning_rate(self, epoch, performance_history):
       """Adaptive studying fee with performance-based adjustment"""
       if epoch > 10:
           recent_performance = performance_history(-10:)
           if len(recent_performance) >= 5:
               if recent_performance(-1) >= recent_performance(-5):
                   self.lr = max(self.lr * 0.95, self.initial_lr * 0.01)
               elif recent_performance(-1) < recent_performance(-5) * 0.98:
                   self.lr = min(self.lr * 1.02, self.initial_lr * 2)
  
   def calculate_loss(self, y_true, y_pred):
       """Steady loss calculation"""
       y_true = y_true.reshape(-1, 1)
       y_pred = np.clip(y_pred, -1e6, 1e6) 
      
       mse = np.imply((y_true - y_pred) ** 2)
       mae = np.imply(np.abs(y_true - y_pred))
      
       if not np.isfinite(mse):
           mse = 1e6
       if not np.isfinite(mae):
           mae = 1e6
          
       return mse, mae
  
   def store_experience(self, state, motion, reward, next_state):
       """Expertise replay for RL points"""
       expertise = {
           'state': state,
           'motion': motion,
           'reward': reward,
           'next_state': next_state,
           'timestamp': len(self.reminiscence)
       }
       self.reminiscence.append(expertise)
      
       if len(self.reminiscence) > 1000:
           self.reminiscence.pop(0)
  
   def make_decision(self, X, exploration_rate=0.1):
       """Steady choice making"""
       prediction = self.ahead(X)
      
       if np.random.random() < exploration_rate:
           noise_scale = np.std(prediction) * 0.1 if np.std(prediction) > 0 else 0.1
           noise = np.random.regular(0, noise_scale, prediction.form)
           prediction += noise
      
       return np.clip(prediction, -1e6, 1e6)
  
   def reset_if_unstable(self):
       """Reset community if coaching turns into unstable"""
       print(" Resetting community as a result of instability...")
       for i, layer in enumerate(self.layers):
           fan_in, fan_out = layer('weights').form
           restrict = np.sqrt(6.0 / (fan_in + fan_out))
           layer('weights') = np.random.uniform(-limit, restrict, (fan_in, fan_out))
           layer('bias') = np.zeros((1, fan_out))
           layer('momentum_w') = np.zeros((fan_in, fan_out))
           layer('momentum_b') = np.zeros((1, fan_out))
       self.lr = self.initial_lr
  
   def practice(self, X, y, epochs=500, batch_size=32, validation_split=0.2, verbose=True):
       """Strong coaching with stability checks"""
       y_mean, y_std = np.imply(y), np.std(y)
       y_normalized = (y - y_mean) / (y_std + self.epsilon)
      
       X_trn, X_val, y_trn, y_val = train_test_split(
           X, y_normalized, test_size=validation_split, random_state=42)
      
       best_val_loss = float('inf')
       endurance = 30
       patience_counter = 0
      
       train_losses, val_losses = (), ()
       reset_count = 0
      
       for epoch in vary(epochs):
           if epoch > 0 and (not np.isfinite(train_losses(-1)) or train_losses(-1) > 1e6):
               if reset_count < 2: 
                   self.reset_if_unstable()
                   reset_count += 1
                   proceed
               else:
                   print(" Coaching unstable, stopping...")
                   break
          
           indices = np.random.permutation(len(X_train))
           X_train_shuffled = X_train(indices)
           y_train_shuffled = y_train(indices)
          
           epoch_loss = 0
           batches = 0
           for i in vary(0, len(X_trn), batch_size):
               batch_X = X_train_shuffled(i:i+batch_size)
               batch_y = y_train_shuffled(i:i+batch_size)
              
               if len(batch_X) == 0:
                   proceed
              
               output = self.ahead(batch_X)
               self.backward(batch_X, batch_y, output)
              
               loss, _ = self.calculate_loss(batch_y, output)
               epoch_loss += loss
               batches += 1
          
           avg_train_loss = epoch_loss / max(batches, 1)
          
           val_output = self.ahead(X_val)
           val_loss, val_mae = self.calculate_loss(y_val, val_output)
          
           train_losses.append(avg_train_loss)
           val_losses.append(val_loss)
           self.performance_history.append(val_loss)
          
           if val_loss < best_val_loss:
               best_val_loss = val_loss
               patience_counter = 0
           else:
               patience_counter += 1
          
           if patience_counter >= endurance:
               if verbose:
                   print(f" Early stopping at epoch {epoch}")
               break
          
           if epoch > 0:
               self.adapt_learning_rate(epoch, self.performance_history)
          
           if verbose and (epoch % 50 == 0 or epoch < 10):
               print(f"Epoch {epoch:3d}: Practice Loss = {avg_train_loss:.4f}, "
                     f"Val Loss = {val_loss:.4f}, LR = {self.lr:.6f}")
      
       self.y_mean, self.y_std = y_mean, y_std
       return train_losses, val_losses
  
   def predict(self, X):
       """Make predictions with denormalization"""
       normalized_pred = self.ahead(X)
       if hasattr(self, 'y_mean') and hasattr(self, 'y_std'):
           return normalized_pred * self.y_std + self.y_mean
       return normalized_pred
  
   def evaluate_performance(self, X, y):
       """Complete efficiency analysis"""
       predictions = self.predict(X)
       mse, mae = self.calculate_loss(y, predictions)
      
       y_mean = np.imply(y)
       ss_tot = np.sum((y - y_mean) ** 2)
       ss_res = np.sum((y.reshape(-1, 1) - predictions) ** 2)
       r2 = 1 - (ss_res / (ss_tot + self.epsilon))
      
       return {
           'mse': float(mse) if np.isfinite(mse) else float('inf'),
           'mae': float(mae) if np.isfinite(mae) else float('inf'),
           'r2': float(r2) if np.isfinite(r2) else -float('inf'),
           'predictions': predictions.flatten()
       }
  
   def visualize_training(self, train_losses, val_losses):
       """Visualize coaching progress"""
       plt.determine(figsize=(15, 5))
      
       plt.subplot(1, 3, 1)
       plt.plot(train_losses, label="Coaching Loss", alpha=0.8)
       plt.plot(val_losses, label="Validation Loss", alpha=0.8)
       plt.title('Coaching Progress')
       plt.xlabel('Epoch')
       plt.ylabel('Loss')
       plt.legend()
       plt.grid(True, alpha=0.3)
       plt.yscale('log')
      
       plt.subplot(1, 3, 2)
       if len(self.performance_history) > 0:
           plt.plot(self.performance_history)
           plt.title('Efficiency Historical past')
           plt.xlabel('Epoch')
           plt.ylabel('Validation Loss')
           plt.grid(True, alpha=0.3)
           plt.yscale('log')
      
       plt.subplot(1, 3, 3)
       if hasattr(self, 'lr_history'):
           plt.plot(self.lr_history)
           plt.title('Studying Charge Schedule')
           plt.xlabel('Epoch')
           plt.ylabel('Studying Charge')
           plt.grid(True, alpha=0.3)
      
       plt.tight_layout()
       plt.present()

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

Der Agent SDK von OpenAI hat mit der Veröffentlichung seiner Sprachagent-Funktion eine Stufe aufgenommen, mit der Sie intelligente, in Echtzeit-sprachgetriebene Anwendungen erstellen können. Egal, ob Sie einen Sprachlehrer, einen virtuellen Assistenten oder einen Assist-Bot erstellen, diese neue Fähigkeit bringt eine ganz neue Interaktionsebene mit sich-natürlich, dynamisch und menschlich. Lassen Sie es uns aufschlüsseln und durchgehen, was es ist, wie es funktioniert und wie Sie selbst einen mehrsprachigen Sprachagenten aufbauen können.

Was ist ein Sprachagent?

Ein Sprachagent ist ein System, das Ihre Stimme hört, versteht, was Sie sagen, denkt über eine Antwort und antwortet dann laut. Die Magie wird durch eine Kombination aus Sprach-Textual content, Sprachmodellen und Textual content-zu-Sprache-Technologien angetrieben.

Der Openai Agent SDK macht dies unglaublich zugänglich über etwas, das als Voicepipeline bezeichnet wird-ein strukturierter 3-Stufen-Prozess:

1. Sprache zu Textual content (STT): Erfasst und konvertiert Ihre gesprochenen Wörter in Textual content.
2. Agentenlogik: Dies ist Ihr Code (oder Ihr Agent), der die entsprechende Antwort ermittelt.
3. Textual content-to-Speech (TTS): Umwandelt die Textantwort des Agenten in Audio zurück, das laut gesprochen wird.

Auswahl der richtigen Architektur

Abhängig von Ihrem Anwendungsfall möchten Sie eines von zwei von OpenAI unterstützten Kernarchitekturen auswählen:

1. Sprach-zu-Sprach (multimodal) Architektur

Dies ist der Echtzeit-All-Audio-Ansatz mit Modellen wie GPT-4O-RealTime-Präview. Anstatt in Textual content hinter den Kulissen zu übersetzen, verarbeitet und generiert das Modell direkt.

Warum das nutzen?

• Niedrige Latenz, Echtzeit-Interaktion
• Emotion und Vokal -Tonverständnis
• Glatter, natürlicher Gesprächsfluss

Perfekt für:

• Sprachunterricht
• Stay -Konversationsmittel
• Interaktive Storytelling- oder Lern ​​-Apps

Stärken	Am besten für
Geringe Latenz	Interaktiver, unstrukturierter Dialog
Multimodales Verständnis (Stimme, Ton, Pausen)	Echtzeit Engagement
Emotionsbewusste Antworten	Kundenbetreuung, virtuelle Begleiter

Dieser Ansatz lässt Gespräche flüssig und menschlich anfühlen, benötigen jedoch möglicherweise mehr Aufmerksamkeit in Randfällen wie Protokollierung oder exakte Transkripte.

2. Kettenarchitektur

Die verkettete Methode ist traditioneller: Sprache wird in Textual content verwandelt, die LLM -Prozesse, die diesen Textual content verarbeitet, und dann wird die Antwort wieder in Sprache umgewandelt. Die empfohlenen Modelle hier sind:

• GPT-4O-Transcribe (für STT)
• GPT-4O (für Logik)
• GPT-4-MINI-TTS (für TTs)

Warum das nutzen?

• Benötigen Sie Transkripte für Audit/Protokollierung
• Haben strukturierte Workflows wie Kundendienst oder Leitqualifikation
• Wollen vorhersehbares, kontrollierbares Verhalten

Perfekt für:

• Bots unterstützen
• Vertriebsmitarbeiter
• Aufgabenspezifische Assistenten

Stärken	Am besten für
Hohe Kontrolle und Transparenz	Strukturierte Workflows
Zuverlässige textbasierte Verarbeitung	Apps, die Transkripte benötigen
Vorhersehbare Ausgänge	Kundendebauende Skriptströme

Dies ist einfacher zu debuggen und ein großartiger Ausgangspunkt, wenn Sie neu für Sprachagenten sind.

Wie funktioniert Sprachagent?

Wir richten a ein VoicePipeline mit einem benutzerdefinierten Workflow. Dieser Workflow führt einen Agenten aus, kann aber auch spezielle Antworten auslösen, wenn Sie ein geheimes Wort sagen.

Hier ist, was passiert, wenn Sie sprechen:

1. Audio geht zur VoicePipeline, während Sie sprechen.
2. Wenn Sie aufhören zu sprechen, beginnt die Pipeline.
3. Die Pipeline dann:
   • Transkribiert Ihre Rede in Textual content.
   • Sendet die Transkription an den Workflow, der die Agentenlogik ausführt.
   • Streams die Antwort des Agenten auf ein TTS-Modell (Textual content-to-Speech).
   • Spielt das generierte Audio zurück an Sie.

Es ist Echtzeit, interaktiv und klug genug, um anders zu reagieren, wenn Sie in einer versteckten Phrase ausrutschen.

Konfigurieren einer Pipeline

Beim Einrichten einer Sprachpipeline können Sie einige Schlüsselkomponenten anpassen:

• Workflow: Dies ist die Logik, die jedes Mal ausgeführt wird, wenn ein neues Audio transkribiert wird. Es definiert, wie der Agent verarbeitet und reagiert.
• STT- und TTS -Modelle: Wählen Sie aus, welche Sprach- und Textual content-zu-Sprach-Modelle Ihre Pipeline verwenden wird.
• Konfigurationseinstellungen: Hier verhalten Sie sich intestine, wie sich Ihre Pipeline verhält:
  • Modellanbieter: Ein Zuordnungssystem, das Modellnamen mit tatsächlichen Modellinstanzen verknüpft.
  • Tracing -Optionen: Steuern Sie, ob die Verfolgung aktiviert ist, ob Audiodateien hochladen, Workflow -Namen, Hint -IDs und mehr zuweisen.
  • Modellspezifische Einstellungen: Passen Sie Eingabeaufforderungen, Sprachpräferenzen und unterstützte Datentypen für TTS- und STT -Modelle an.

Ausführen einer Sprachpipeline

Um eine Sprachpipeline zu starten, verwenden Sie die run() Verfahren. Es akzeptiert Audioeingaben in einer von zwei Formularen, je nachdem, wie Sie mit Sprache umgehen:

• Audioinput ist superb, wenn Sie bereits einen vollständigen Audioclip oder Transkript haben. Es ist perfekt für Fälle, in denen Sie wissen, wann der Lautsprecher fertig ist, wie bei vorgezeichneten Audio- oder Push-to-Speak-Setups. Keine Notwendigkeit für Stay -Aktivitätserkennung hier.
• Streamedaudioinput ist für Echtzeit, dynamische Eingabe. Sie füttern Audio -Stücke, sobald sie erfasst werden, und die Sprachpipeline ermittelt automatisch, wann die Agentenlogik mithilfe einer sogenannten Aktivitätserkennung ausgelöst werden soll. Dies ist tremendous praktisch, wenn Sie sich mit offenen Mikrofonen oder Freisprechinteraktion befassen, bei denen es nicht offensichtlich ist, wenn der Sprecher fertig ist.

Die Ergebnisse verstehen

Sobald Ihre Pipeline ausgeführt wird, gibt sie eine Streamedaudioresult zurück, mit der Sie Ereignisse in Echtzeit streamen können, wenn sich die Interaktion entfaltet. Diese Ereignisse kommen in einigen Geschmacksrichtungen:

• Voicestreameventaudio – Enthält Teile der Audioausgabe (dh, was der Agent sagt).
• VoicestreamEventlifecycle – Markiert wichtige Lebenszyklusereignisse wie der Beginn oder das Ende einer Gesprächswende.
• VoicestreameVentError – signalisiert, dass etwas schief gelaufen ist.

Praktischer Sprachagent mit OpenAI-Agent SDK

Hier ist eine sauberere, intestine strukturierte Model Ihres Leitfadens zum Einrichten eines praktischen Sprachagents mit OpenAI-Agent SDK mit detaillierten Schritten, Gruppierung und Klarheitsverbesserungen. Es ist alles immer noch lässig und praktisch, aber lesbarer und umsetzbarer:

1. Richten Sie Ihr Projektverzeichnis ein

mkdir my_project
cd my_project

2. Erstellen und aktivieren Sie eine virtuelle Umgebung

Erstellen Sie die Umgebung:

python -m venv .venv

Aktivieren Sie es:

supply .venv/bin/activate

3. Installieren Sie OpenAI Agent SDK

pip set up openai-agent

4. Stellen Sie eine OpenAI -API -Schlüssel ein

export OPENAI_API_KEY=sk-...

5. Klonen Sie das Beispiel -Repository klonen

git clone https://github.com/openai/openai-agents-python.git

6. Ändern Sie den Beispielcode für Hindi Agent und Audio -Speichern

Navigieren Sie zur Beispieldatei:

cd openai-agents-python/examples/voice/static

Jetzt bearbeiten Sie Foremost.py:

Sie werden zwei wichtige Dinge tun:

1. Fügen Sie einen Hindi -Agenten hinzu
2. Aktivieren Sie Audiosparen nach der Wiedergabe

Ersetzen Sie den gesamten Inhalt in important.py. Dies ist der endgültige Code hier:

import asyncio
import random

from brokers import Agent, function_tool
from brokers.extensions.handoff_prompt import prompt_with_handoff_instructions
from brokers.voice import (
    AudioInput,
    SingleAgentVoiceWorkflow,
    SingleAgentWorkflowCallbacks,
    VoicePipeline,
)

from .util import AudioPlayer, record_audio

@function_tool
def get_weather(metropolis: str) -> str:
    print(f"(debug) get_weather referred to as with metropolis: {metropolis}")
    selections = ("sunny", "cloudy", "wet", "snowy")
    return f"The climate in {metropolis} is {random.selection(selections)}."

spanish_agent = Agent(
    identify="Spanish",
    handoff_description="A spanish talking agent.",
    directions=prompt_with_handoff_instructions(
        "You are chatting with a human, so be well mannered and concise. Communicate in Spanish.",
    ),
    mannequin="gpt-4o-mini",
)

hindi_agent = Agent(
    identify="Hindi",
    handoff_description="A hindi talking agent.",
    directions=prompt_with_handoff_instructions(
        "You are chatting with a human, so be well mannered and concise. Communicate in Hindi.",
    ),
    mannequin="gpt-4o-mini",
)

agent = Agent(
    identify="Assistant",
    directions=prompt_with_handoff_instructions(
        "You are chatting with a human, so be well mannered and concise. If the consumer speaks in Spanish, handoff to the spanish agent. If the consumer speaks in Hindi, handoff to the hindi agent.",
    ),
    mannequin="gpt-4o-mini",
    handoffs=(spanish_agent, hindi_agent),
    instruments=(get_weather),
)

class WorkflowCallbacks(SingleAgentWorkflowCallbacks):
    def on_run(self, workflow: SingleAgentVoiceWorkflow, transcription: str) -> None:
        print(f"(debug) on_run referred to as with transcription: {transcription}")

async def important():
    pipeline = VoicePipeline(
        workflow=SingleAgentVoiceWorkflow(agent, callbacks=WorkflowCallbacks())
    )

    audio_input = AudioInput(buffer=record_audio())

    outcome = await pipeline.run(audio_input)

    # Create an inventory to retailer all audio chunks
    all_audio_chunks = ()

    with AudioPlayer() as participant:
        async for occasion in outcome.stream():
            if occasion.sort == "voice_stream_event_audio":
                audio_data = occasion.information
                participant.add_audio(audio_data)
                all_audio_chunks.append(audio_data)
                print("Acquired audio")
            elif occasion.sort == "voice_stream_event_lifecycle":
                print(f"Acquired lifecycle occasion: {occasion.occasion}")
    
    # Save the mixed audio to a file
    if all_audio_chunks:
        import wave
        import os
        import time

        os.makedirs("output", exist_ok=True)
        filename = f"output/response_{int(time.time())}.wav"

        with wave.open(filename, "wb") as wf:
            wf.setnchannels(1)
            wf.setsampwidth(2)
            wf.setframerate(16000)
            wf.writeframes(b''.be part of(all_audio_chunks))

        print(f"Audio saved to {filename}")

if __name__ == "__main__":
    asyncio.run(important())

6. Führen Sie den Sprachagenten aus

Stellen Sie sicher, dass Sie im richtigen Verzeichnis sind:

cd openai-agents-python

Starten Sie es dann:

python -m examples.voice.static.important

Ich fragte den Agenten zwei Dinge, einen auf Englisch und einen in Hindi:

1. Voice -Eingabeaufforderung: Hey, Voice Agent, was ist ein großes Sprachmodell?
2. Stimme Eingabeaufforderung: „मुझे दिल्ली के बाे में बताओ

Hier ist das Terminal:

Ausgabe

Englische Antwort:

Hindi -Antwort:

Zusätzliche Ressourcen

Willst du tiefer graben? Überprüfen Sie diese:

Lesen Sie auch: Die Audiomodelle von OpenAI: Zugriff, Funktionen, Anwendungen und mehr

Abschluss

Der Aufbau eines Sprachagents mit dem OpenAI -Agenten SDK ist jetzt viel zugänglicher – Sie müssen nicht mehr eine Menge Werkzeuge zusammenfügen. Wählen Sie einfach die richtige Architektur aus, richten Sie Ihre VoicePipeline ein und lassen Sie den SDK das schwere Heben durchführen.

Wenn Sie einen qualitativ hochwertigen Konversationsfluss haben, gehen Sie multimodal. Wenn Sie Struktur und Kontrolle wünschen, gehen Sie gekettet. In jedem Fall ist diese Technologie mächtig und es wird nur besser. Wenn Sie einen erstellen, teilen Sie mir im Kommentarbereich unten wissen.

Ich habe viel über Rag- und AI -Agenten gelesen, aber mit der Veröffentlichung neuer Modelle wie Deepseek V3 und Deepseek R1 scheint es, dass die Möglichkeit, effiziente Rag -Systeme zu bauen skalierbare Architekturen für reale Anwendungen. Die Integration von ausgefeilteren Abrufmechanismen, verbesserten Feinabstimmungsoptionen und multimodalen Funktionen verändern die Artwork und Weise, wie KI-Agenten mit Daten interagieren. Es wirft Fragen auf, ob traditionelle Lappenansätze immer noch der beste Weg nach vorne sind oder ob neuere Architekturen effizientere und kontextbezogene Lösungen bieten können.

REMAINAL-AUGENTED-Era (LAG) Die Systeme haben die Artwork und Weise revolutioniert, wie KI-Modelle mit Daten interagieren, indem sie abrufbasierte und generative Ansätze kombiniert werden, um genauere und kontextbewusstere Antworten zu erzielen. Mit dem Aufkommen von Deepseek R1Ein Open-Supply-Modell, das für Effizienz und Kosteneffizienz bekannt ist und ein effektives Lappensystem aufgebaut ist, ist zugänglicher und praktischer geworden. In diesem Artikel bauen wir ein Lappensystem mit Deepseek R1 auf.

Was ist Deepseek R1?

Deepseek R1 ist ein Open-Supply-KI-Modell mit dem Ziel, qualitativ hochwertige Argumentations- und Abruffunktionen zu einem Bruchteil der Kosten für proprietäre Modelle wie OpenAIs Angebote bereitzustellen. Es verfügt über eine MIT -Lizenz, wodurch es kommerziell rentabel und für eine Vielzahl von Anwendungen geeignet ist. Außerdem können Sie dieses mächtige Modell das Kinderbett sehen, aber die OpenAI O1- und O1-Mini zeigen kein Argumentations-Token.

Um zu wissen, wie Deepseek R1 das OpenAI O1 -Modell herausfordert: Deepseek R1 gegen OpenAI O1: Welches ist schneller, billiger und schlauer?

Vorteile der Verwendung von Deepseek R1 für RAG -System

Der Aufbau eines RAG-Methods (Retrieval-Augmented Era) mit Deepseek-R1 bietet mehrere bemerkenswerte Vorteile:

1. Fortgeschrittene Argumentationsfunktionen: Deepseek-R1 wurde entwickelt, um das menschliche Argumentation durch Analysieren und Verarbeitung von Informationen Schritt für Schritt nach vor der Analyse und Verarbeitung von Schlussfolgerungen zu emulieren. Dieser Ansatz verbessert die Fähigkeit des Methods, komplexe Abfragen zu bewältigen, insbesondere in Bereichen, die logische Inferenz, mathematisches Denken und Codierungsaufgaben erfordern.

2. Open-Supply-Zugänglichkeit: Deepseek-R1 veröffentlicht unter der MIT-Lizenz und ermöglicht den uneingeschränkten Zugang zu seinem Modell vollständig offen. Diese Offenheit erleichtert die Anpassung, Feinabstimmung und Integration in verschiedene Anwendungen ohne die häufig mit proprietären Modellen verbundenen Einschränkungen.

3.. Wettbewerbsleistung: Benchmark-Exams zeigen, dass Deepseek-R1 mit oder sogar übertrifft oder sogar übertrifft Modelle wie OpenAs O1 in Aufgaben, die Argumentation, Mathematik und Codierung beinhalten. Diese Leistungsstufe stellt sicher, dass ein mit Deepseek-R1 erstellter Lappensystem qualitativ hochwertige, genaue Reaktionen für verschiedene und herausfordernde Fragen liefern kann.

4. Transparenz im Denkprozess: Deepseek-R1 verwendet eine „Kette der Gedanken“ -Methodik und macht seine Argumentationsschritte während der Inferenz sichtbar. Diese Transparenz hilft nicht nur beim Debuggen und Verfeinern des Methods, sondern baut auch das Vertrauen der Benutzer auf, indem sie klare Einblicke in die Erreichung der Schlussfolgerungen liefern.

5. Kosteneffizienz: Die Open-Supply-Natur von Deepseek-R1 beseitigt Lizenzgebühren, und seine effiziente Architektur verringert die Anforderungen an die Rechenressourcen. Diese Faktoren tragen zu einer kostengünstigeren Lösung für Organisationen bei, die anspruchsvolle RAG-Systeme implementieren möchten, ohne erhebliche Ausgaben zu erfüllen.

Die Integration von Deepseek-R1 in ein Lag-System bietet eine starke Kombination aus fortschrittlichen Argumentationsfähigkeiten, Transparenz, Leistung und Kosteneffizienz, was es zu einer überzeugenden Wahl für Entwickler und Organisationen macht, die ihre KI-Fähigkeiten verbessern möchten.

Schritte zum Erstellen eines Lappensystems mit Deepseek R1

Das Drehbuch ist eine RAG-Pipeline (Abruf-Augmented Era), die:

• Ladet und verarbeitet ein PDF -Dokument Indem Sie es in Seiten aufspalten und Textual content extrahieren.
• Speichert vektorisierte Darstellungen des Textes in einer Datenbank (Chromadb).
• Ruft relevante Inhalte ab Verwenden der Ähnlichkeitssuche, wenn eine Abfrage gefragt wird.
• Verwendet ein LLM (Deepseek -Modell) Um Antworten basierend auf dem abgerufenen Textual content zu generieren.

Voraussetzungen installieren

curl -fsSL https://ollama.com/set up.sh | sh

Danach ziehen Sie die Deepseek R1: 1,5B mit:

ollama pull deepseek-r1:1.5b

Der Herunterladen wird einen Second dauern:

ollama pull deepseek-r1:1.5b

pulling manifest
pulling aabd4debf0c8... 100% ▕████████████████▏ 1.1 GB                         
pulling 369ca498f347... 100% ▕████████████████▏  387 B                         
pulling 6e4c38e1172f... 100% ▕████████████████▏ 1.1 KB                         
pulling f4d24e9138dd... 100% ▕████████████████▏  148 B                         
pulling a85fe2a2e58e... 100% ▕████████████████▏  487 B                         
verifying sha256 digest 
writing manifest 
success 

Öffnen Sie danach Ihr Jupyter -Notizbuch und beginnen Sie mit dem Codierungsteil:

1. Installieren Sie Abhängigkeiten

Vor dem Ausführen installiert das Skript die erforderlichen Python -Bibliotheken:

• langchain → Ein Rahmen zum Erstellen von Anwendungen mit großer Sprachmodellen (LLMs).
• langchain-openai → Bietet Integration mit OpenAI -Diensten.
• langchain-community → Fügt Unterstützung für verschiedene Dokumentenlader und Dienstprogramme hinzu.
• langchain-chroma → Ermöglicht die Integration mit Chromadb, einer Vektor -Datenbank.

2. Geben Sie die OpenAI -API -Schlüssel ein

Um auf das Einbettungsmodell von OpenAI zuzugreifen, fordert das Skript den Benutzer auf Geben Sie sicher ihren API -Schlüssel ein Verwendung getpass(). Dies verhindert, dass Anmeldeinformationen im Klartext aufgedeckt werden.

3. Einrichten von Umgebungsvariablen

Das Skript speichert die API -Schlüssel als Umgebungsvariable. Dadurch können andere Teile des Codes auf OpenAI -Dienste zugreifen Ohne hartnäckige Anmeldeinformationenwas die Sicherheit verbessert.

V.

Das Skript initialisiert ein OpenAI -Einbettungsmodell namens "text-embedding-3-small". Dieses Modell Konvertiert Textual content in Vektor -Einbettungendie hochdimensionale numerische Darstellungen der Bedeutung des Textes sind. Diese Einbettungen werden später gewohnt Vergleichen und abrufen ähnliche Inhalte.

5. Ein PDF -Dokument laden und teilen

Eine PDF -Datei (AgenticAI.pdf) Ist geladen und in Seiten aufgeteilt. Der Textual content jeder Seite wird extrahiert, was erlaubt kleinere und überschaubare Textbrocken Anstatt das gesamte Dokument als einzelne Einheit zu verarbeiten.

6. Erstellen und speichern Sie eine Vektordatenbank

• Der extrahierte Textual content aus dem PDF ist in Vektor -Einbettungen umgewandelt.
• Diese Einbettungen sind Speichern in Chromadbeine Hochleistungs Vektordatenbank.
• Die Datenbank ist für die Verwendung konfiguriert Kosinusähnlichkeitwas sicherstellt, dass der Textual content mit einem hohen Maß an semantischer Ähnlichkeit effizient abgerufen wird.

7. Rufen Sie ähnliche Texte mit einer Ähnlichkeitsschwelle ab

A Retriever wird mit Chromadb erstellt, das:

• Suche nach den High 3 am ähnlichsten Dokumente basierend auf einer bestimmten Abfrage.
• Filterergebnisse mit einer Ähnlichkeitsschwelle von 0,3 (dh Dokumente müssen mindestens 30% Ähnlichkeit haben, um als related angesehen zu werden).

8. Abfrage nach ähnlichen Dokumenten

Es werden zwei Testfragen verwendet:

1. "What's the outdated capital of India?"
   • Es wurden keine Ergebnisse gefundenwas angibt, dass die gespeicherten Dokumente keine relevanten Informationen enthalten.
2. "What's Agentic AI?"
   • Ruft erfolgreich relevanten Textual content abund zeigen, dass das System einen sinnvollen Kontext holen kann.

9. Bauen Sie einen Lappen-Ketten (retrieval-augmented Era)

Das Skript legt a ein Lappenpipelinewas sicherstellt, dass:

• Textabnahme passiert, bevor er eine Antwort generiert.
• Die Antwort des Modells ist basierend auf abgerufenen InhaltenHalluzinationen verhindern.
• A Schnellvorlage wird verwendet, um das Modell zur Erzeugung strukturierter Reaktionen anzuweisen.

10. Lasten Sie eine Verbindung zu einem LLM (Deekseek -Modell)

Anstelle von Openais GPT das Skript Lädt Deepseek-R1 (1,5B-Parameter)ein leistungsstarker LLM, der für retrievalbasierte Aufgaben optimiert wurde.

11. Erstellen Sie eine Kette auf Lappenbasis

Langchains Abruf Modul wird verwendet, um:

• Relevante Inhalte holen aus der Vektordatenbank.
• Formatieren Sie eine strukturierte Reaktion Verwenden einer schnellen Vorlage.
• Generieren Sie eine kurze Antwort mit dem Deepseek -Modell.

12. Testen Sie die Lappenkette

Das Skript führt eine Testabfrage aus:
"Inform the Leaders’ Views on Agentic AI"

Der LLM erzeugt eine faktenbasierte Antwort Strikt mit dem abgerufenen Kontext.

Das System Ruft relevante Informationen aus der Datenbank ab.

Code zum Erstellen eines Lappensystems mit Deepseek R1

Hier ist der Code:

Installieren Sie OpenAI- und Langchain -Abhängigkeiten

!pip set up langchain==0.3.11
!pip set up langchain-openai==0.2.12
!pip set up langchain-community==0.3.11
!pip set up langchain-chroma==0.1.4

Geben Sie die offene AI -API -Schlüssel ein

from getpass import getpass
OPENAI_KEY = getpass('Enter Open AI API Key: ')

Setup -Umgebungsvariablen

import os
os.environ('OPENAI_API_KEY') = OPENAI_KEY

Offene KI -Einbettungsmodelle

from langchain_openai import OpenAIEmbeddings
openai_embed_model = OpenAIEmbeddings(mannequin="text-embedding-3-small")

Erstellen Sie einen Vektor -DB und bestehen auf der Festplatte

from langchain_community.document_loaders import PyPDFLoader
loader = PyPDFLoader('AgenticAI.pdf')
pages = loader.load_and_split()
texts = (doc.page_content for doc in pages)

from langchain_chroma import Chroma
chroma_db = Chroma.from_texts(
    texts=texts,
    collection_name="db_docs",
    collection_metadata={"hnsw:area": "cosine"},  # Set distance operate to cosine
embedding=openai_embed_model
)

Ähnlichkeit mit Schwellenwert Abruf

similarity_threshold_retriever = chroma_db.as_retriever(search_type="similarity_score_threshold",search_kwargs={"okay": 3,"score_threshold": 0.3})

question = "what's the outdated capital of India?"
top3_docs = similarity_threshold_retriever.invoke(question)
top3_docs

()

question = "What's Agentic AI?"
top3_docs = similarity_threshold_retriever.invoke(question)
top3_docs

Bauen Sie eine Lappenkette

from langchain_core.prompts import ChatPromptTemplate
immediate = """You might be an assistant for question-answering duties.
            Use the next items of retrieved context to reply the query.
            If no context is current or if you do not know the reply, simply say that you do not know.
            Don't make up the reply until it's there within the supplied context.
            Preserve the reply concise and to the purpose with regard to the query.
            Query:
            {query}
            Context:
            {context}
            Reply:
         """
prompt_template = ChatPromptTemplate.from_template(immediate)

Lastanschluss zu LLM laden

from langchain_community.llms import Ollama
deepseek = Ollama(mannequin="deepseek-r1:1.5b")

Langchain -Syntax für Lappenkette

from langchain.chains import Retrieval
rag_chain = Retrieval.from_chain_type(llm=deepseek,
                                           chain_type="stuff",
                                           retriever=similarity_threshold_retriever,
                                           chain_type_kwargs={"immediate": prompt_template})
question = "Inform the Leaders’ Views on Agentic AI"
rag_chain.invoke(question)
{'question': 'Inform the Leaders’ Views on Agentic AI',

Checkout in unseren detaillierten Artikeln über Deepseek Working und Vergleich mit ähnlichen Modellen:

Abschluss

Bauen eines Lappensystems mit Verwendung Deepseek R1 Bietet eine kostengünstige und leistungsstarke Möglichkeit, das Abrufen von Dokumenten und die Reaktionserzeugung zu verbessern. Mit seiner Open-Supply-Natur und ihren starken Argumentationsfähigkeiten ist es eine großartige Different zu proprietären Lösungen. Unternehmen und Entwickler können ihre Flexibilität nutzen, um KI-gesteuerte Anwendungen zu erstellen, die auf ihre Anforderungen zugeschnitten sind.

Möchten Sie Anwendungen mit Deepseek erstellen? Checkout unser Kostenloser Deepseek -Kurs Heute!