leichter – chatgpz.de – KI-Tools & Praxiswissen

Eine Codierungsimplementierung eines OpenAI-unterstützten, datenschutzerhaltenden föderierten Betrugserkennungssystems von Grund auf unter Verwendung leichter PyTorch-Simulationen

admin — Wed, 31 Dec 2025 07:15:48 +0000

[ad_1]

In diesem Tutorial zeigen wir, wie wir mithilfe von Federated Studying ein datenschutzschonendes Betrugserkennungssystem simulieren, ohne auf schwere Frameworks oder komplexe Infrastruktur angewiesen zu sein. Wir bauen ein sauberes, CPU-freundliches Setup auf, das zehn unabhängige Banken nachahmt, von denen jede ein lokales Betrugserkennungsmodell anhand ihrer eigenen, stark unausgewogenen Transaktionsdaten trainiert. Wir koordinieren diese lokalen Aktualisierungen über eine einfache FedAvg-Aggregationsschleife, wodurch wir ein globales Modell verbessern und gleichzeitig sicherstellen können, dass keine rohen Transaktionsdaten jemals einen Kunden verlassen. Darüber hinaus integrieren wir OpenAI, um die Analyse nach dem Coaching und risikoorientierte Berichterstattung zu unterstützen und zu demonstrieren, wie föderierte Lernergebnisse in entscheidungsreife Erkenntnisse umgesetzt werden können. Schauen Sie sich das an Vollständige Codes hier.

!pip -q set up torch scikit-learn numpy openai


import time, random, json, os, getpass
import numpy as np
import torch
import torch.nn as nn
from torch.utils.information import DataLoader, TensorDataset
from sklearn.datasets import make_classification
from sklearn.model_selection import train_test_split
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import roc_auc_score, average_precision_score, accuracy_score
from openai import OpenAI


SEED = 7
random.seed(SEED); np.random.seed(SEED); torch.manual_seed(SEED)


DEVICE = torch.gadget("cpu")
print("Gadget:", DEVICE)

Wir richten die Ausführungsumgebung ein und importieren alle erforderlichen Bibliotheken für die Datengenerierung, Modellierung, Auswertung und Berichterstattung. Wir korrigieren auch zufällige Seeds und die Gerätekonfiguration, um sicherzustellen, dass unsere Verbundsimulation deterministisch und auf der CPU reproduzierbar bleibt. Schauen Sie sich das an Vollständige Codes hier.

X, y = make_classification(
   n_samples=60000,
   n_features=30,
   n_informative=18,
   n_redundant=8,
   weights=(0.985, 0.015),
   class_sep=1.5,
   flip_y=0.01,
   random_state=SEED
)


X = X.astype(np.float32)
y = y.astype(np.int64)


X_train_full, X_test, y_train_full, y_test = train_test_split(
   X, y, test_size=0.2, stratify=y, random_state=SEED
)


server_scaler = StandardScaler()
X_train_full_s = server_scaler.fit_transform(X_train_full).astype(np.float32)
X_test_s = server_scaler.rework(X_test).astype(np.float32)


test_loader = DataLoader(
   TensorDataset(torch.from_numpy(X_test_s), torch.from_numpy(y_test)),
   batch_size=1024,
   shuffle=False
)

Wir generieren einen äußerst unausgewogenen, kreditkartenähnlichen Betrugsdatensatz und teilen ihn in Trainings- und Testsätze auf. Wir standardisieren die serverseitigen Daten und bereiten einen globalen Testloader vor, der es uns ermöglicht, das aggregierte Modell nach jeder Verbundrunde konsistent auszuwerten. Schauen Sie sich das an Vollständige Codes hier.

def dirichlet_partition(y, n_clients=10, alpha=0.35):
   lessons = np.distinctive(y)
   idx_by_class = (np.the place(y == c)(0) for c in lessons)
   client_idxs = (() for _ in vary(n_clients))
   for idxs in idx_by_class:
       np.random.shuffle(idxs)
       props = np.random.dirichlet(alpha * np.ones(n_clients))
       cuts = (np.cumsum(props) * len(idxs)).astype(int)
       prev = 0
       for cid, minimize in enumerate(cuts):
           client_idxs(cid).prolong(idxs(prev:minimize).tolist())
           prev = minimize
   return (np.array(ci, dtype=np.int64) for ci in client_idxs)


NUM_CLIENTS = 10
client_idxs = dirichlet_partition(y_train_full, NUM_CLIENTS, 0.35)


def make_client_split(X, y, idxs):
   Xi, yi = X(idxs), y(idxs)
   if len(np.distinctive(yi)) < 2:
       different = np.the place(y == (1 - yi(0)))(0)
       add = np.random.selection(different, measurement=min(10, len(different)), substitute=False)
       Xi = np.concatenate((Xi, X(add)))
       yi = np.concatenate((yi, y(add)))
   return train_test_split(Xi, yi, test_size=0.15, stratify=yi, random_state=SEED)


client_data = (make_client_split(X_train_full, y_train_full, client_idxs(c)) for c in vary(NUM_CLIENTS))


def make_client_loaders(Xtr, ytr, Xva, yva):
   sc = StandardScaler()
   Xtr_s = sc.fit_transform(Xtr).astype(np.float32)
   Xva_s = sc.rework(Xva).astype(np.float32)
   tr = DataLoader(TensorDataset(torch.from_numpy(Xtr_s), torch.from_numpy(ytr)), batch_size=512, shuffle=True)
   va = DataLoader(TensorDataset(torch.from_numpy(Xva_s), torch.from_numpy(yva)), batch_size=512)
   return tr, va


client_loaders = (make_client_loaders(*cd) for cd in client_data)

Wir simulieren realistisches Nicht-IID-Verhalten, indem wir die Trainingsdaten mithilfe einer Dirichlet-Verteilung auf zehn Purchasers verteilen. Anschließend erstellen wir unabhängige Trainings- und Validierungslader auf Kundenebene und stellen so sicher, dass jede simulierte Financial institution mit ihren eigenen lokal skalierten Daten arbeitet. Schauen Sie sich das an Vollständige Codes hier.

class FraudNet(nn.Module):
   def __init__(self, in_dim):
       tremendous().__init__()
       self.internet = nn.Sequential(
           nn.Linear(in_dim, 64),
           nn.ReLU(),
           nn.Dropout(0.1),
           nn.Linear(64, 32),
           nn.ReLU(),
           nn.Dropout(0.1),
           nn.Linear(32, 1)
       )
   def ahead(self, x):
       return self.internet(x).squeeze(-1)


def get_weights(mannequin):
   return (p.detach().cpu().numpy() for p in mannequin.state_dict().values())


def set_weights(mannequin, weights):
   keys = listing(mannequin.state_dict().keys())
   mannequin.load_state_dict({ok: torch.tensor(w) for ok, w in zip(keys, weights)}, strict=True)


@torch.no_grad()
def consider(mannequin, loader):
   mannequin.eval()
   bce = nn.BCEWithLogitsLoss()
   ys, ps, losses = (), (), ()
   for xb, yb in loader:
       logits = mannequin(xb)
       losses.append(bce(logits, yb.float()).merchandise())
       ys.append(yb.numpy())
       ps.append(torch.sigmoid(logits).numpy())
   y_true = np.concatenate(ys)
   y_prob = np.concatenate(ps)
   return {
       "loss": float(np.imply(losses)),
       "auc": roc_auc_score(y_true, y_prob),
       "ap": average_precision_score(y_true, y_prob),
       "acc": accuracy_score(y_true, (y_prob >= 0.5).astype(int))
   }


def train_local(mannequin, loader, lr):
   decide = torch.optim.Adam(mannequin.parameters(), lr=lr)
   bce = nn.BCEWithLogitsLoss()
   mannequin.prepare()
   for xb, yb in loader:
       decide.zero_grad()
       loss = bce(mannequin(xb), yb.float())
       loss.backward()
       decide.step()

Wir definieren das neuronale Netzwerk, das zur Betrugserkennung verwendet wird, zusammen mit Hilfsfunktionen für Coaching, Bewertung und Gewichtsaustausch. Wir implementieren eine leichte lokale Optimierung und Metrikberechnung, um clientseitige Aktualisierungen effizient und leicht nachvollziehbar zu halten. Schauen Sie sich das an Vollständige Codes hier.

def fedavg(weights, sizes):
   whole = sum(sizes)
   return (
       sum(w(i) * (s / whole) for w, s in zip(weights, sizes))
       for i in vary(len(weights(0)))
   )


ROUNDS = 10
LR = 5e-4


global_model = FraudNet(X_train_full.form(1))
global_weights = get_weights(global_model)


for r in vary(1, ROUNDS + 1):
   client_weights, client_sizes = (), ()
   for cid in vary(NUM_CLIENTS):
       native = FraudNet(X_train_full.form(1))
       set_weights(native, global_weights)
       train_local(native, client_loaders(cid)(0), LR)
       client_weights.append(get_weights(native))
       client_sizes.append(len(client_loaders(cid)(0).dataset))
   global_weights = fedavg(client_weights, client_sizes)
   set_weights(global_model, global_weights)
   metrics = consider(global_model, test_loader)
   print(f"Spherical {r}: {metrics}")

Wir orchestrieren den föderierten Lernprozess, indem wir lokale Kundenmodelle iterativ trainieren und ihre Parameter mithilfe von FedAvg aggregieren. Wir bewerten das globale Modell nach jeder Runde, um die Konvergenz zu überwachen und zu verstehen, wie kollektives Lernen die Leistung der Betrugserkennung verbessert. Schauen Sie sich das an Vollständige Codes hier.

OPENAI_API_KEY = getpass.getpass("Enter OPENAI_API_KEY (enter hidden): ").strip()


if OPENAI_API_KEY:
   os.environ("OPENAI_API_KEY") = OPENAI_API_KEY
   shopper = OpenAI()


   abstract = {
       "rounds": ROUNDS,
       "num_clients": NUM_CLIENTS,
       "final_metrics": metrics,
       "client_sizes": (len(client_loaders(c)(0).dataset) for c in vary(NUM_CLIENTS)),
       "client_fraud_rates": (float(client_data(c)(1).imply()) for c in vary(NUM_CLIENTS))
   }


   immediate = (
       "Write a concise inside fraud-risk report.n"
       "Embrace government abstract, metric interpretation, dangers, and subsequent steps.nn"
       + json.dumps(abstract, indent=2)
   )


   resp = shopper.responses.create(mannequin="gpt-5.2", enter=immediate)
   print(resp.output_text)

Wir überführen die technischen Ergebnisse mithilfe eines externen Sprachmodells in einen prägnanten Analysebericht. Wir akzeptieren den API-Schlüssel sicher per Tastatureingabe und generieren entscheidungsorientierte Erkenntnisse, die Leistung, Risiken und empfohlene nächste Schritte zusammenfassen.

Abschließend haben wir gezeigt, wie man föderiertes Lernen nach den ersten Prinzipien in einem Colab-Notizbuch umsetzen und dabei stabil, interpretierbar und realistisch bleiben kann. Wir haben beobachtet, wie excessive Datenheterogenität zwischen Purchasers die Konvergenz beeinflusst und warum eine sorgfältige Aggregation und Auswertung in Betrugserkennungsumgebungen von entscheidender Bedeutung sind. Wir haben den Arbeitsablauf außerdem durch die Erstellung eines automatisierten Risikoteamberichts erweitert, der zeigt, wie Analyseergebnisse in entscheidungsreife Erkenntnisse umgesetzt werden können. Abschließend haben wir einen praktischen Entwurf für das Experimentieren mit föderierten Betrugsmodellen vorgestellt, bei dem Datenschutzbewusstsein, Einfachheit und Relevanz für die Praxis im Vordergrund stehen.

Schauen Sie sich das an Vollständige Codes hier. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Asif Razzaq ist CEO von Marktechpost Media Inc.. Als visionärer Unternehmer und Ingenieur setzt sich Asif dafür ein, das Potenzial der künstlichen Intelligenz für das soziale Wohl zu nutzen. Sein jüngstes Unterfangen ist die Einführung einer Medienplattform für künstliche Intelligenz, Marktechpost, die sich durch eine ausführliche Berichterstattung über maschinelles Lernen und Deep-Studying-Nachrichten auszeichnet, die sowohl technisch fundiert als auch für ein breites Publikum leicht verständlich ist. Die Plattform verfügt über mehr als 2 Millionen monatliche Aufrufe, was ihre Beliebtheit beim Publikum verdeutlicht.

[ad_2]

Wie entwirft man ein autonomes Multi-Agent-Daten- und Infrastrukturstrategiesystem unter Verwendung leichter Qwen-Modelle für effiziente Pipeline-Intelligence?

admin — Fri, 31 Oct 2025 04:44:19 +0000

[ad_1]

In diesem Tutorial erstellen wir ein Agentic Knowledge and Infrastructure Technique-System unter Verwendung des leichtgewichtigen Qwen2.5-0.5B-Instruct-Modells für eine effiziente Ausführung. Wir beginnen mit der Erstellung eines flexiblen LLM-Agenten-Frameworks und entwickeln dann spezialisierte Agenten, die verschiedene Ebenen der Datenverwaltung verwalten, von der Aufnahme und Qualitätsanalyse bis hin zur Infrastrukturoptimierung. Wir integrieren diese Agenten in einen Orchestrator, der ihre Interaktionen koordiniert und so eine reibungslose Zusammenarbeit mehrerer Agenten in der gesamten Datenpipeline gewährleistet. Anhand praktischer Beispiele wie E-Commerce und IoT-Pipelines untersuchen wir, wie autonome Entscheidungsfindung komplexe Datenvorgänge rationalisieren kann. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

!pip set up -q transformers torch speed up datasets huggingface_hub
import torch
from transformers import AutoModelForCausalLM, AutoTokenizer
import json, time
from typing import Listing, Dict, Any
from dataclasses import dataclass
from datetime import datetime
import pandas as pd


class LightweightLLMAgent:
   def __init__(self, function: str, model_name: str = "Qwen/Qwen2.5-0.5B-Instruct"):
       self.function = function
       self.model_name = model_name
       self.gadget = "cuda" if torch.cuda.is_available() else "cpu"
       print(f"Loading {model_name} for {function} agent on {self.gadget}...")
       self.tokenizer = AutoTokenizer.from_pretrained(model_name)
       self.mannequin = AutoModelForCausalLM.from_pretrained(
           model_name,
           torch_dtype=torch.float16 if self.gadget == "cuda" else torch.float32,
           device_map="auto"
       )
       self.conversation_history = ()


   def generate_response(self, immediate: str, max_tokens: int = 150) -> str:
       messages = (
           {"function": "system", "content material": f"You're a {self.function} agent in a knowledge infrastructure system."},
           {"function": "consumer", "content material": immediate}
       )
       textual content = self.tokenizer.apply_chat_template(messages, tokenize=False, add_generation_prompt=True)
       model_inputs = self.tokenizer((textual content), return_tensors="pt").to(self.gadget)
       with torch.no_grad():
           generated_ids = self.mannequin.generate(
               model_inputs.input_ids,
               max_new_tokens=max_tokens,
               temperature=0.7,
               do_sample=True,
               top_p=0.95
           )
       generated_ids = (output_ids(len(input_ids):) for input_ids, output_ids in zip(model_inputs.input_ids, generated_ids))
       response = self.tokenizer.batch_decode(generated_ids, skip_special_tokens=True)(0)
       self.conversation_history.append({"immediate": immediate, "response": response})
       return response

Wir beginnen mit der Einrichtung der leichtgewichtigen LLM-Agenten-Infrastruktur mithilfe des Qwen2.5-0.5B-Instruct-Modells. Wir laden das Modell und den Tokenizer und definieren eine Basisagentenklasse, die kontextbezogene Konversationen abwickeln und intelligente Antworten generieren kann. Dies bildet die zentrale Grundlage für die effiziente Arbeit unserer spezialisierten Agenten innerhalb von Colab. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class DataIngestionAgent(LightweightLLMAgent):
   def __init__(self):
       tremendous().__init__(function="Knowledge Ingestion Specialist")
   def analyze_data_source(self, source_info: Dict) -> Dict:
       immediate = f"""Analyze this knowledge supply and supply ingestion technique:
Supply Sort: {source_info.get('kind', 'unknown')}
Quantity: {source_info.get('quantity', 'unknown')}
Frequency: {source_info.get('frequency', 'unknown')}
Present a quick technique specializing in: 1) Ingestion methodology, 2) Key issues."""
       technique = self.generate_response(immediate, max_tokens=100)
       return {"supply": source_info, "technique": technique, "timestamp": datetime.now().isoformat()}


class DataQualityAgent(LightweightLLMAgent):
   def __init__(self):
       tremendous().__init__(function="Knowledge High quality Analyst")
   def assess_data_quality(self, data_sample: Dict) -> Dict:
       immediate = f"""Assess knowledge high quality for this pattern:
Completeness: {data_sample.get('completeness', 'N/A')}%
Consistency: {data_sample.get('consistency', 'N/A')}%
Points Discovered: {data_sample.get('points', 0)}
Present transient high quality evaluation and high 2 suggestions."""
       evaluation = self.generate_response(immediate, max_tokens=100)
       return {"evaluation": evaluation, "severity": self._calculate_severity(data_sample), "timestamp": datetime.now().isoformat()}
   def _calculate_severity(self, data_sample: Dict) -> str:
       completeness = data_sample.get('completeness', 100)
       consistency = data_sample.get('consistency', 100)
       avg_score = (completeness + consistency) / 2
       if avg_score >= 90: return "LOW"
       elif avg_score >= 70: return "MEDIUM"
       else: return "HIGH"

Wir entwerfen die Datenaufnahme- und Datenqualitätsagenten so, dass sie sich auf die strukturierte Analyse von Datenpipelines konzentrieren. Wir lassen den Aufnahmeagenten den besten Ansatz für den Datenfluss bestimmen, während der Qualitätsagent die Vollständigkeit, Konsistenz und Probleme der Daten bewertet, um umsetzbare Erkenntnisse zu liefern. Gemeinsam bilden sie die ersten beiden Schichten des autonomen Datenmanagements. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class InfrastructureOptimizationAgent(LightweightLLMAgent):
   def __init__(self):
       tremendous().__init__(function="Infrastructure Optimization Specialist")
   def optimize_resources(self, metrics: Dict) -> Dict:
       immediate = f"""Analyze infrastructure metrics and counsel optimizations:
CPU Utilization: {metrics.get('cpu_usage', 0)}%
Reminiscence Utilization: {metrics.get('memory_usage', 0)}%
Storage: {metrics.get('storage_used', 0)}GB / {metrics.get('storage_total', 0)}GB
Question Latency: {metrics.get('query_latency', 0)}ms
Present 2 optimization suggestions."""
       suggestions = self.generate_response(immediate, max_tokens=100)
       return {"current_metrics": metrics, "suggestions": suggestions, "precedence": self._calculate_priority(metrics), "timestamp": datetime.now().isoformat()}
   def _calculate_priority(self, metrics: Dict) -> str:
       cpu = metrics.get('cpu_usage', 0)
       reminiscence = metrics.get('memory_usage', 0)
       if cpu > 85 or reminiscence > 85: return "CRITICAL"
       elif cpu > 70 or reminiscence > 70: return "HIGH"
       else: return "NORMAL"

Wir entwickeln den Infrastructure Optimization Agent, um wichtige Kennzahlen wie CPU-, Arbeitsspeicher- und Speicherauslastung kontinuierlich zu analysieren. Daraus generieren wir intelligente Optimierungsvorschläge, die uns helfen, eine hohe Leistung und Ressourceneffizienz aufrechtzuerhalten. Dieser Agent stellt sicher, dass unsere Infrastruktur während der Datenoperationen reaktionsfähig und skalierbar bleibt. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

class AgenticDataOrchestrator:
   def __init__(self):
       print("n" + "="*70)
       print("Initializing Agentic Knowledge Infrastructure System")
       print("="*70 + "n")
       self.ingestion_agent = DataIngestionAgent()
       self.quality_agent = DataQualityAgent()
       self.optimization_agent = InfrastructureOptimizationAgent()
       self.execution_log = ()
   def process_data_pipeline(self, pipeline_config: Dict) -> Dict:
       outcomes = {"pipeline_id": pipeline_config.get("id", "unknown"), "start_time": datetime.now().isoformat(), "phases": ()}
       print("n(Stage 1) Knowledge Ingestion Evaluation")
       ingestion_result = self.ingestion_agent.analyze_data_source(pipeline_config.get("supply", {}))
       print(f"Technique: {ingestion_result('technique')(:150)}...")
       outcomes("phases").append({"stage": "ingestion", "consequence": ingestion_result})
       print("n(Stage 2) Knowledge High quality Evaluation")
       quality_result = self.quality_agent.assess_data_quality(pipeline_config.get("quality_metrics", {}))
       print(f"Evaluation: {quality_result('evaluation')(:150)}...")
       print(f"Severity: {quality_result('severity')}")
       outcomes("phases").append({"stage": "high quality", "consequence": quality_result})
       print("n(Stage 3) Infrastructure Optimization")
       optimization_result = self.optimization_agent.optimize_resources(pipeline_config.get("infrastructure_metrics", {}))
       print(f"Suggestions: {optimization_result('suggestions')(:150)}...")
       print(f"Precedence: {optimization_result('precedence')}")
       outcomes("phases").append({"stage": "optimization", "consequence": optimization_result})
       outcomes("end_time") = datetime.now().isoformat()
       outcomes("standing") = "accomplished"
       self.execution_log.append(outcomes)
       return outcomes
   def generate_summary_report(self) -> pd.DataFrame:
       if not self.execution_log: return pd.DataFrame()
       summary_data = ()
       for log in self.execution_log:
           summary_data.append({"Pipeline ID": log("pipeline_id"), "Begin Time": log("start_time"), "Standing": log("standing"), "Levels Accomplished": len(log("phases"))})
       return pd.DataFrame(summary_data)

Wir haben einen Agentic Knowledge Orchestrator entwickelt, um alle spezialisierten Agenten im Rahmen eines einheitlichen Workflows zu koordinieren. Wir verwenden es, um die Finish-to-Finish-Pipeline-Ausführung zu verwalten und nacheinander Aufnahme, Qualitätsprüfungen und Optimierung auszulösen. Dadurch bringen wir Struktur, Zusammenarbeit und Automatisierung in das gesamte Multiagentensystem. Schauen Sie sich das an VOLLSTÄNDIGE CODES hier.

def important():
   orchestrator = AgenticDataOrchestrator()
   print("n" + "="*70)
   print("EXAMPLE 1: E-commerce Knowledge Pipeline")
   print("="*70)
   ecommerce_pipeline = {
       "id": "ecommerce_pipeline_001",
       "supply": {"kind": "REST API", "quantity": "10GB/day", "frequency": "real-time"},
       "quality_metrics": {"completeness": 87, "consistency": 92, "points": 15},
       "infrastructure_metrics": {"cpu_usage": 78, "memory_usage": 82, "storage_used": 450, "storage_total": 1000, "query_latency": 250}
   }
   result1 = orchestrator.process_data_pipeline(ecommerce_pipeline)
   print("nn" + "="*70)
   print("EXAMPLE 2: IoT Sensor Knowledge Pipeline")
   print("="*70)
   iot_pipeline = {
       "id": "iot_pipeline_002",
       "supply": {"kind": "Message Queue (Kafka)", "quantity": "50GB/day", "frequency": "streaming"},
       "quality_metrics": {"completeness": 95, "consistency": 88, "points": 8},
       "infrastructure_metrics": {"cpu_usage": 65, "memory_usage": 71, "storage_used": 780, "storage_total": 2000, "query_latency": 180}
   }
   result2 = orchestrator.process_data_pipeline(iot_pipeline)
   print("nn" + "="*70)
   print("EXECUTION SUMMARY REPORT")
   print("="*70 + "n")
   summary_df = orchestrator.generate_summary_report()
   print(summary_df.to_string(index=False))
   print("n" + "="*70)
   print("Tutorial Full!")
   print("="*70)
   print("nKey Ideas Demonstrated:")
   print("✓ Light-weight LLM agent structure")
   print("✓ Specialised brokers for various knowledge duties")
   print("✓ Multi-agent orchestration")
   print("✓ Infrastructure monitoring and optimization")
   print("✓ Autonomous decision-making in knowledge pipelines")


if __name__ == "__main__":
   important()

Wir demonstrieren unser komplettes System anhand von zwei realen Beispielen, einem E-Commerce- und einer IoT-Datenpipeline. Wir beobachten, wie jeder Agent seine Rolle autonom ausführt und gleichzeitig zu einem gemeinsamen Ziel beiträgt. Abschließend erstellen wir einen zusammenfassenden Bericht, der die Effizienz der Orchestrierung und die Leistungsfähigkeit der leichtgewichtigen Agentenintelligenz bestätigt.

Abschließend entwerfen und implementieren wir ein intelligentes Dateninfrastruktur-Framework mit mehreren Agenten, das auf einem kompakten Open-Supply-Modell basiert. Wir erleben, wie unabhängige und dennoch kooperative Agenten reale Datensysteme autonom analysieren, bewerten und optimieren können. Der gesamte Aufbau zeigt, wie leichtgewichtige LLMs Infrastrukturintelligenz effizient verarbeiten können, und verdeutlicht gleichzeitig, wie die agentische Orchestrierung herkömmliche Datenworkflows in adaptive, selbstoptimierende Systeme verwandelt, die für skalierbare Unternehmensanwendungen bereit sind.

Schauen Sie sich das an VOLLSTÄNDIGE CODES hier. Schauen Sie sich gerne bei uns um GitHub-Seite für Tutorials, Codes und Notebooks. Sie können uns auch gerne weiter folgen Twitter und vergessen Sie nicht, bei uns mitzumachen 100.000+ ML SubReddit und Abonnieren Unser E-newsletter. Warten! Bist du im Telegram? Jetzt können Sie uns auch per Telegram kontaktieren.

Folgen Sie MARKTECHPOST: Fügen Sie uns als bevorzugte Quelle bei Google hinzu.

[ad_2]