# Einführung

Die meisten Groups stellen fest, dass sie eine benötigen Characteristic-Retailer auf die harte Tour. Ein Betrugsmodell arbeitet im Pocket book und bringt nonetheless und leise die Produktion zum Erliegen. Ein Supportmitarbeiter gibt eine allgemeine Antwort, da er keine Ahnung hat, wer der Benutzer ist. Eine Empfehlungspipeline dupliziert dieselbe Berechnung der „30-Tage-Ausgaben“ für drei Jobs, und zwei davon sind anderer Meinung.

Ein Characteristic Retailer ist das Teil davon Infrastruktur das behebt diese Probleme. Es definiert Funktionen einmal, speichert sie in zwei Formen (eine zum Coaching, eine zum Servieren) und hält beide synchron. Wir werden ein Minimalmodell von Grund auf neu bauen Pythonverwenden DuckDB, Parkett, RedisUnd FastAPI. Dann schauen wir uns an, wie KI-Anwendungen das verändern, wofür wir sie tatsächlich nutzen.

Der vollständige Code ist kurz genug, dass wir jede Komponente durchgehen können.

# Was ein Characteristic Retailer tatsächlich löst

Der klassische Pitch ist der Trainings-Serving-Skew: Das SQL, das Ihren Trainingssatz erstellt hat, ist nicht derselbe Codepfad, der bei der Inferenz ausgeführt wird, sodass die Werte abweichen. Dieses Downside ist actual und die Trennung von Offline und On-line ist die Standardlösung.

Das moderne Spielfeld ist breiter. Giant Language Mannequin (LLM)-Agenten und Retrieval-Augmented Era (RAG)-Pipelines benötigen einen strukturierten Benutzerkontext zur Inferenzzeit, bei jeder Anfrage, in weniger als 10 ms. Ein LLM hat keine Erinnerung daran, wer der Benutzer ist. Wenn wir eine personalisierte Ausgabe wünschen, müssen wir die Planstufe des Benutzers, die letzte Aktivität und den Kontostatus in die Eingabeaufforderung einfügen, und wir brauchen ein System, das diese Werte schnell und konsistent zurückgeben kann. Genau das bieten uns der On-line-Store und die Abruf-API eines Characteristic-Shops.

Deshalb bauen wir für beides. Die gleichen fünf Komponenten behandeln den Anwendungsfall des prädiktiven maschinellen Lernens und den LLM-Kontext-Anwendungsfall.

# Die fünf Komponenten

• Eine Characteristic-Registrierung, die Options als Code definiert.
• Ein Offline-Store auf Parquet, abgefragt mit DuckDB, für Schulungen und Auffüllungen.
• Ein On-line-Store auf Redis für Nachschlagevorgänge mit geringer Latenz.
• Eine Materialisierungspipeline, die die neuesten Werte von offline nach on-line überträgt.
• Ein FastAPI-Dienst, der eine typisierte Abruf-API verfügbar macht.

# Laufbeispiel: Ein personalisierter LLM-Empfehler

Wir betreiben einen Streamingdienst. Wenn ein Benutzer die App öffnet, generiert ein LLM eine kurze, personalisierte Nachricht „Was Sie als Nächstes ansehen sollten“. Das LLM benötigt drei Dinge über den Benutzer:

Das Wesen ist user_id. Wir werden diese drei Funktionen registrieren, materialisieren und sie dem LLM auf Anfrage zur Verfügung stellen.

// 1. Definieren der Characteristic Registry

Eine Registrierung ist lediglich ein Ort, an dem Options einmalig mit ihrer Entität, ihrem Dtype und ihrer Quelle deklariert werden. Wir verwenden eine Datenklasse.

from dataclasses import dataclass
from typing import Literal

@dataclass(frozen=True)
class Characteristic:
    title: str
    entity: str
    dtype: Literal("int", "float", "str")
    supply: str  # path to a Parquet file or a SQL view

REGISTRY: dict(str, Characteristic) = {
    "user_segment": Characteristic("user_segment", "user_id", "str", "information/user_segment.parquet"),
    "watch_count_30d": Characteristic("watch_count_30d", "user_id", "int", "information/watch_count_30d.parquet"),
    "last_genre": Characteristic("last_genre", "user_id", "str", "information/last_genre.parquet"),
}

Den vollständigen Code finden Sie hier Hier.

Wenn Sie es ausführen, wird in der Ausgabe Folgendes angezeigt:

Registered options:
user_segment  entity=user_id  dtype=str  supply=information/user_segment.parquet
watch_count_30d  entity=user_id  dtype=int  supply=information/watch_count_30d.parquet
last_genre  entity=user_id  dtype=str  supply=information/last_genre.parquet

Das ist der Vertrag. Jede andere Komponente liest aus REGISTRYsodass das Umbenennen eines Options, das Ändern seines D-Typs oder das Verweisen auf eine neue Quelle an einer Stelle erfolgt. In Produktionssystemen wäre dies der Fall YAML oder ein in ein Git-Repository eingechecktes Python-Modul mit Codeüberprüfung bei jeder Änderung.

// 2. Aufbau des Offline-Retailers mit DuckDB und Parquet

Der Offline-Store speichert den vollständigen Verlauf jedes Merkmalswerts. Wir verwenden Parquet-Dateien als Speicherschicht und DuckDB als Abfrage-Engine. DuckDB liest Parquet direkt, was bedeutet, dass keine separate Datenbank ausgeführt werden muss.

Hier ist ein Beispiel des Codes:

import duckdb
import pandas as pd

def get_historical_features(
    entity_df: pd.DataFrame, options: record(str)
) -> pd.DataFrame:
    con = duckdb.join()
    con.register("entities", entity_df)
    base = "SELECT * FROM entities"
    for fname in options:
        f = REGISTRY(fname)
        src = f.supply.change("'", "''")
        con.execute(f"CREATE VIEW {fname}_src AS SELECT * FROM '{src}'")
        base = f"""
            SELECT t.*, s.{fname}
            FROM ({base}) t
            ASOF LEFT JOIN {fname}_src s
              ON t.user_id = s.user_id
             AND t.event_timestamp >= s.event_timestamp
        """
    return con.execute(base).df()

Den vollständigen Code finden Sie hier Hier.

Wenn Sie es ausführen, wird in der Ausgabe Folgendes angezeigt:

Der AsOf beitreten ist der Level-in-Time-Be part of. Für jede Entitätszeile wird der aktuellste Featurewert ausgewählt, bei dem der Zeitstempel des Options beim oder vor dem Ereigniszeitstempel liegt. Dadurch wird Leckage verhindert – wenn eine Trainingszeile mit einem Merkmalswert erstellt wird, der zu dem Zeitpunkt, für den wir die Vorhersage treffen, noch nicht vorhanden conflict.

Level-in-Time-Joins sind immer noch die richtige Antwort für jedes Modell, das wir trainieren oder verfeinern möchten. Für einen reinen Inferenzzeit-LLM-Anwendungsfall rufen wir diese Funktion möglicherweise nie auf. Wir wollen weiterhin den Offline-Retailer, da dort Backfills, Bewertungsdatensätze und Audits herkommen.

// 3. Einrichten des On-line-Retailers auf Redis

Der On-line-Store speichert nur den neuesten Wert professional Entität. Redis ist die Standardwahl, da Hash-Suchvorgänge weniger als eine Millisekunde dauern.

import json
import fakeredis  # use redis.Redis() in opposition to an actual server in manufacturing

r = fakeredis.FakeRedis(decode_responses=True)

def write_online(entity: str, entity_id: str, values: dict) -> None:
    r.hset(
        f"{entity}:{entity_id}",
        mapping={okay: json.dumps(v) for okay, v in values.gadgets()},
    )

def read_online(entity: str, entity_id: str, options: record(str)) -> dict:
    uncooked = r.hmget(f"{entity}:{entity_id}", options)
    return {f: json.masses(v) if v else None for f, v in zip(options, uncooked)}

Den vollständigen Code finden Sie hier Hier.

Wenn Sie es ausführen, wird in der Ausgabe Folgendes angezeigt:

read_online -> {'user_segment': 'power_user', 'watch_count_30d': 47, 'last_genre': 'documentary'}
lacking key -> {'user_segment': None}

Die Schlüsselform ist entity:entity_id. Der Wert ist ein Hash mit einem Feld professional Characteristic. Eine Single HMGET gibt alle von uns gewünschten Funktionen in einem Rundlauf zurück. Auf einer lokalen Redis-Instanz mit drei Funktionen ist dies in deutlich unter 1 ms erledigt.

// 4. Ausführen der Materialisierungspipeline

Durch die Materialisierung werden Werte von offline nach on-line verschoben. In einem realen System läuft dies nach einem Zeitplan (Airflow, Cron, ein Streaming-Job). Hier ist es eine Funktion.

def materialize(options: record(str)) -> None:
    by_entity: dict(str, dict) = {}
    for fname in options:
        f = REGISTRY(fname)
        src = f.supply.change("'", "''")
        df = duckdb.sql(f"""
            SELECT {f.entity}, {fname}
            FROM '{src}'
            QUALIFY ROW_NUMBER() OVER (
                PARTITION BY {f.entity}
                ORDER BY event_timestamp DESC
            ) = 1
        """).df()
        for _, row in df.iterrows():
            by_entity.setdefault(row(f.entity), {})(fname) = row(fname)
    for entity_id, values in by_entity.gadgets():
        write_online("user_id", entity_id, values)

Den vollständigen Code finden Sie hier Hier.

Wenn Sie es ausführen, wird in der Ausgabe Folgendes angezeigt:

user_id:8a2f -> {'user_segment': 'power_user', 'watch_count_30d': 47, 'last_genre': 'documentary'}
user_id:b13c -> {'user_segment': 'informal', 'watch_count_30d': 5, 'last_genre': 'thriller'}

Der QUALIFY Die Klausel behält die neueste Zeile professional Entität bei. Wir gruppieren alle Funktionen für denselben Benutzer in einem Redis-Schreibvorgang, um Roundtrips zu vermeiden. Führen Sie dies mit der Kadenz aus, die jede Funktion benötigt: stündlich für watch_count_30dnahezu in Echtzeit für last_genretäglich für user_segment. Die Registrierung ist der richtige Ort, um diesen Rhythmus in einer realen Implementierung zu kodieren.

// 5. Offenlegung des FastAPI Retrieval Service

Der Abrufdienst ist die Produktionsfläche. Es ist das, was die LLM-Anwendung aufruft.

f = resp.json()("options")
print("nPrompt the LLM would obtain:")
print(
    f"  System: You advocate reveals for a streaming service.n"
    f"  Person context: section={f('user_segment')}, "
    f"watched {f('watch_count_30d')} titles in final 30 days, "
    f"final style watched: {f('last_genre')}.n"
    f"  Activity: recommend 3 titles in a pleasant, brief message."
)

Den vollständigen Code finden Sie hier Hier.

Wenn Sie es ausführen, wird in der Ausgabe Folgendes angezeigt:

POST /get-online-features -> 200
physique: {'user_id': '8a2f', 'options': {'user_segment': 'power_user', 'watch_count_30d': 47, 'last_genre': 'documentary'}}
Immediate the LLM would obtain:
  System: You advocate reveals for a streaming service.
  Person context: section=power_user, watched 47 titles in final 30 days, final style watched: documentary.
  Activity: recommend 3 titles in a pleasant, brief message.

Der Characteristic Retailer ist der Teil, der „Benutzer 8a2f“ in einen strukturierten Kontext umwandelt, den das LLM verwenden kann.

# Wo der Characteristic Retailer endet und die Vektordatenbank beginnt

Eine Vektordatenbank (Tannenzapfen, Weben, pgvector) ist kein Characteristic Retailer, auch wenn beide bei der Schlussfolgerung vor einem Modell stehen. Sie lösen verschiedene Retrieval-Probleme.

Ein echter LLM-Stack nutzt beides. Die Vektordatenbank gibt die drei ähnlichsten vergangenen Betrachtungssitzungen zurück. Der Characteristic Retailer gibt das Phase des Benutzers und die letzten Zählungen zurück. Die Eingabeaufforderung kombiniert sie.

# Gängige Anti-Patterns

Einige Muster, die wir immer wieder beobachten, scheitern:

• Rechenfunktionen innerhalb des Modelldienstes. Die gleiche Logik landet im Trainingsnotizbuch und in der API, und die beiden Definitionen weichen innerhalb eines Quartals voneinander ab.
• Den On-line-Store als Quelle der Wahrheit betrachten. Redis verliert Daten bei einem fehlerhaften Neustart. Der Offline-Store ist kanonisch; Der On-line-Store ist ein Cache.
• Überspringen der Registrierung. Drei Groups definieren unabhängig voneinander active_user und die Dashboards stimmen nicht mehr mit dem Modell überein.
• Eine Vektordatenbank als Characteristic Retailer bezeichnen. Es können keine strukturierten Suchvorgänge mit Entitätsschlüssel durchgeführt werden, und eine Eingabeaufforderung, die beides benötigt, wird ohnehin mit zwei Systemen verbunden sein.
• Auffüllen ohne Level-in-Time-Joins. Das Trainingsset sieht großartig aus, das Serienmodell sieht kaputt aus und die Lücke ist das Leck.

# Vergleich mit Feast, Tecton und Databricks

Unsere ca. 200 Linien erledigen die gleiche Aufgabe im Miniaturformat.

Fest ist der naheliegendste Vergleich, wenn wir nach dem gleichen Muster weitergehen wollen: selbst gehostet. Tecton Und Datenbausteine sind die verwalteten Pfade und verfügen über explizite LLM-Funktionen (Tectons Characteristic Retrieval API für LLMs, Databricks Characteristic Serving für zusammengesetzte generative KI-Systeme). Die Wahl zwischen ihnen hängt hauptsächlich davon ab, wie viel wir selbst betreiben möchten und ob der Relaxation unseres Stacks bereits in Databricks lebt.

# Abschluss

Ein funktionierender Characteristic Retailer besteht aus fünf Komponenten: einer Registrierung, einem Offline-Retailer, einem On-line-Retailer, einem Materialisierungsschritt und einer Abruf-API. Wenn wir es einmal bauen, erfahren wir, warum die Produktionssysteme so aussehen, wie sie aussehen. Es zeigt auch, wo sich das Design für KI ändert: Der On-line-Abrufpfad ist die Oberfläche, auf die das LLM trifft, Level-in-Time-Joins sind wichtig, wenn wir trainieren oder auswerten, und die Vektordatenbank befindet sich neben dem Characteristic Retailer und nicht darin.

Sobald wir diese Teile haben, ist der Austausch unserer Minimalversion gegen Feast, Tecton oder Databricks größtenteils eine Migration der Registrierung. Die Kind des Methods bleibt gleich.

Nate Rosidi ist Datenwissenschaftler und in der Produktstrategie tätig. Er ist außerdem außerordentlicher Professor für Analytik und Gründer von StrataScratch, einer Plattform, die Datenwissenschaftlern hilft, sich mit echten Interviewfragen von High-Unternehmen auf ihre Interviews vorzubereiten. Nate schreibt über die neuesten Developments auf dem Karrieremarkt, gibt Ratschläge zu Vorstellungsgesprächen, stellt Knowledge-Science-Projekte vor und behandelt alles rund um SQL.

eventualities = (
   {
       "title": "Secure database learn",
       "device": research_db,
       "kwargs": {
           "desk": "prospects",
           "operation": "choose",
           "kind": "choose",
           "sensitivity": "medium"
       }
   },
   {
       "title": "Blocked harmful database motion",
       "device": research_db,
       "kwargs": {
           "desk": "prospects",
           "operation": "drop",
           "kind": "drop_table",
           "sensitivity": "crucial"
       }
   },
   {
       "title": "Exterior e mail requiring approval",
       "device": research_email,
       "kwargs": {
           "to": "(e mail protected)",
           "recipient_domain": "instance.com",
           "topic": "Quarterly replace",
           "physique": "Sharing a non-confidential quarterly replace.",
           "kind": "send_email",
           "sensitivity": "medium"
       }
   },
   {
       "title": "Exterior e mail denied attributable to approval rejection",
       "device": research_email,
       "kwargs": {
           "to": "(e mail protected)",
           "recipient_domain": "instance.com",
           "topic": "Confidential technique",
           "physique": "This incorporates confidential technique.",
           "kind": "send_email",
           "sensitivity": "crucial"
       }
   },
   {
       "title": "Secure sandbox shell command",
       "device": ops_shell,
       "kwargs": {
           "command": "echo Agent governance is lively",
           "kind": "shell_exec",
           "sensitivity": "low"
       }
   },
   {
       "title": "Harmful shell command blocked",
       "device": ops_shell,
       "kwargs": {
           "command": "rm -rf /content material/one thing",
           "kind": "shell_exec",
           "sensitivity": "crucial"
       }
   },
   {
       "title": "Low-trust agent blocked from delicate information",
       "device": shadow_db,
       "kwargs": {
           "desk": "executive_compensation",
           "operation": "choose",
           "kind": "choose",
           "sensitivity": "crucial"
       }
   },
   {
       "title": "Monetary switch requiring approval",
       "device": finance_transfer,
       "kwargs": {
           "quantity": 2500,
           "vacation spot": "vendor-123",
           "kind": "transfer_money",
           "sensitivity": "excessive"
       }
   },
   {
       "title": "Giant monetary switch rejected",
       "device": finance_transfer,
       "kwargs": {
           "quantity": 15000,
           "vacation spot": "vendor-999",
           "kind": "transfer_money",
           "sensitivity": "crucial"
       }
   },
)
outcomes = ()
for state of affairs in eventualities:
   strive:
       output = state of affairs("device")(**state of affairs("kwargs"))
       outcomes.append({
           "state of affairs": state of affairs("title"),
           "standing": "executed",
           "output": output
       })
   besides Exception as e:
       outcomes.append({
           "state of affairs": state of affairs("title"),
           "standing": "blocked_or_pending",
           "error": str(e)
       })
audit_df = audit_log.to_dataframe()
display_cols = (
   "timestamp",
   "agent_name",
   "tool_name",
   "choice",
   "matched_rule",
   "severity",
   "cause",
   "record_hash"
)
show(audit_df(display_cols))
test_cases = (
   {
       "title": "drop_table should be denied",
       "id": research_agent,
       "tool_name": "query_database",
       "motion": {"kind": "drop_table", "sensitivity": "crucial", "autonomous": True},
       "anticipated": "deny"
   },
   {
       "title": "secure choose ought to be allowed",
       "id": research_agent,
       "tool_name": "query_database",
       "motion": {"kind": "choose", "sensitivity": "low", "autonomous": True},
       "anticipated": "enable"
   },
   {
       "title": "exterior e mail ought to require approval",
       "id": research_agent,
       "tool_name": "send_email",
       "motion": {
           "kind": "send_email",
           "recipient_domain": "instance.com",
           "sensitivity": "medium",
           "autonomous": True
       },
       "anticipated": "require_approval"
   },
   {
       "title": "low belief delicate entry denied",
       "id": unknown_agent,
       "tool_name": "query_database",
       "motion": {"kind": "choose", "sensitivity": "crucial", "autonomous": True},
       "anticipated": "deny"
   },
   {
       "title": "shell command ought to enter sandbox",
       "id": ops_agent,
       "tool_name": "shell_exec",
       "motion": {
           "kind": "shell_exec",
           "command": "echo whats up",
           "sensitivity": "low",
           "autonomous": True
       },
       "anticipated": "sandbox"
   },
)
test_results = ()
for check in test_cases:
   choice = engine.consider(
       id=check("id"),
       tool_name=check("tool_name"),
       motion=check("motion")
   )
   handed = choice.choice == check("anticipated")
   test_results.append({
       "check": check("title"),
       "anticipated": check("anticipated"),
       "precise": choice.choice,
       "handed": handed,
       "matched_rule": choice.matched_rule
   })
test_df = pd.DataFrame(test_results)
show(test_df)
engine.activate_kill_switch()
strive:
   research_db(
       desk="prospects",
       operation="choose",
       kind="choose",
       sensitivity="low"
   )
besides Exception as e:
   move
engine.deactivate_kill_switch()
audit_df = audit_log.to_dataframe()
abstract = (
   audit_df
   .groupby(("choice", "severity"), dropna=False)
   .measurement()
   .reset_index(title="depend")
   .sort_values("depend", ascending=False)
)
show(abstract)
agent_summary = (
   audit_df
   .groupby(("agent_name", "choice"))
   .measurement()
   .reset_index(title="depend")
   .sort_values(("agent_name", "depend"), ascending=(True, False))
)
show(agent_summary)
decision_counts = audit_df("choice").value_counts()
plt.determine(figsize=(8, 5))
decision_counts.plot(form="bar")
plt.title("Governance Selections Throughout Agent Actions")
plt.xlabel("Choice")
plt.ylabel("Depend")
plt.xticks(rotation=30)
plt.tight_layout()
plt.present()
severity_counts = audit_df("severity").fillna("none").value_counts()
plt.determine(figsize=(8, 5))
severity_counts.plot(form="bar")
plt.title("Governance Occasions by Severity")
plt.xlabel("Severity")
plt.ylabel("Depend")
plt.xticks(rotation=30)
plt.tight_layout()
plt.present()
G = nx.DiGraph()
for _, row in audit_df.iterrows():
   agent_node = f"Agent: {row('agent_name')}"
   tool_node = f"Instrument: {row('tool_name')}"
   decision_node = f"Choice: {row('choice')}"
   rule_node = f"Rule: {row('matched_rule')}" if pd.notna(row("matched_rule")) else "Rule: default"
   G.add_node(agent_node, node_type="agent")
   G.add_node(tool_node, node_type="device")
   G.add_node(decision_node, node_type="choice")
   G.add_node(rule_node, node_type="rule")
   G.add_edge(agent_node, tool_node, relation="calls")
   G.add_edge(tool_node, decision_node, relation="produces")
   G.add_edge(decision_node, rule_node, relation="matched")
plt.determine(figsize=(14, 9))
pos = nx.spring_layout(G, seed=42, okay=0.8)
nx.draw_networkx_nodes(G, pos, node_size=1800)
nx.draw_networkx_edges(G, pos, arrows=True, arrowstyle="->", arrowsize=15)
nx.draw_networkx_labels(G, pos, font_size=8)
plt.title("Agent Governance Graph: Brokers, Instruments, Selections, and Coverage Guidelines")
plt.axis("off")
plt.tight_layout()
plt.present()
EXPORT_DIR = "/content material/agt_tutorial_outputs"
os.makedirs(EXPORT_DIR, exist_ok=True)
audit_json_path = os.path.be a part of(EXPORT_DIR, "tamper_evident_audit_log.json")
audit_csv_path = os.path.be a part of(EXPORT_DIR, "governance_audit_log.csv")
policy_copy_path = os.path.be a part of(EXPORT_DIR, "advanced_agent_policy.yaml")
test_results_path = os.path.be a part of(EXPORT_DIR, "policy_test_results.csv")
with open(audit_json_path, "w") as f:
   json.dump((asdict(r) for r in audit_log.data), f, indent=2, default=str)
audit_df.to_csv(audit_csv_path, index=False)
test_df.to_csv(test_results_path, index=False)
shutil.copy(POLICY_PATH, policy_copy_path)

Obwohl kontinuierliche Variablen in realen Datensätzen detaillierte Informationen liefern, sind sie nicht immer die effektivste Type für die Modellierung und Interpretation. Hier kommt die Variablendiskretisierung ins Spiel.

Das Verständnis der Variablendiskretisierung ist für Studenten der Datenwissenschaft, die solide ML-Grundlagen aufbauen, und für KI-Ingenieure, die interpretierbare Systeme entwerfen, von entscheidender Bedeutung.

Zu Beginn meiner datenwissenschaftlichen Reise habe ich mich hauptsächlich auf die Optimierung von Hyperparametern, das Experimentieren mit verschiedenen Algorithmen und die Optimierung von Leistungsmetriken konzentriert.

Als ich mit Variablendiskretisierungsmethoden experimentierte, bemerkte ich, dass bestimmte ML-Modelle stabiler und interpretierbarer wurden. Deshalb habe ich beschlossen, diese Methoden in diesem Artikel zu erklären.

ist Variablendiskretisierung?

Einige arbeiten besser mit diskreten Variablen. Wenn wir beispielsweise ein Entscheidungsbaummodell anhand eines Datensatzes mit kontinuierlichen Variablen trainieren möchten, ist es besser, diese Variablen in diskrete Variablen umzuwandeln, um die Modelltrainingszeit zu verkürzen.

Bei der Variablendiskretisierung handelt es sich um den Prozess der Umwandlung kontinuierlicher Variablen in diskrete Variablen durch Erstellen Mülleimerdie eine Menge kontinuierlicher Intervalle sind.

Vorteile der Variablendiskretisierung

• Entscheidungsbäume und Naive-Bayes-Modelle funktionieren besser mit diskreten Variablen.
• Diskrete Funktionen sind leicht zu verstehen und zu interpretieren.
• Durch Diskretisierung können die Auswirkungen verzerrter Variablen und Ausreißer in Daten verringert werden.

Zusammenfassend vereinfacht die Diskretisierung die Daten und ermöglicht ein schnelleres Coaching der Modelle.

Nachteile der Variablendiskretisierung

Der Hauptnachteil der Variablendiskretisierung ist der Informationsverlust, der durch die Bildung von Bins entsteht. Wir müssen die minimale Anzahl von Behältern finden, ohne dass es zu einem erheblichen Informationsverlust kommt. Der Algorithmus kann diese Nummer selbst nicht finden. Der Benutzer muss die Anzahl der Bins als Modellhyperparameter eingeben. Anschließend findet der Algorithmus die Schnittpunkte, die der Anzahl der Bins entsprechen.

Überwachte und unüberwachte Diskretisierung

Die Hauptkategorien der Diskretisierungsmethoden sind überwachte und unbeaufsichtigte Methoden. Unüberwachte Methoden bestimmen die Grenzen der Klassen, indem sie die zugrunde liegende Verteilung der Variablen verwenden, während überwachte Methoden Grundwahrheitswerte verwenden, um diese Grenzen zu bestimmen.

Arten der Variablendiskretisierung

Wir werden die folgenden Arten der Variablendiskretisierung diskutieren.

• Diskretisierung gleicher Breite
• Gleichfrequenzdiskretisierung
• Diskretisierung beliebiger Intervalle
• Ok-bedeutet Clustering-basierte Diskretisierung
• Entscheidungsbaumbasierte Diskretisierung

Diskretisierung gleicher Breite

Wie der Identify schon sagt, erstellt diese Methode Behälter gleicher Größe. Die Breite eines Abschnitts wird berechnet, indem der Wertebereich einer Variablen geteilt wird. Xnach der Anzahl der Behälter, ok.

Breite = {Max(X) — Min(X)} / ok

Hier, ok ist ein vom Benutzer definierter Hyperparameter.

Wenn beispielsweise die Werte von X Wenn der Bereich zwischen 0 und 50 und ok=5 liegt, erhalten wir 10 als Klassenbreite und die Klassen sind 0–10, 10–20, 20–30, 30–40 und 40–50. Wenn ok=2, beträgt die Klassenbreite 25 und die Klassen sind 0–25 und 25–50. Die Bin-Breite unterscheidet sich additionally je nach Wert des ok Hyperparameter. Bei der Diskretisierung gleicher Breite wird jedem Bin eine unterschiedliche Anzahl von Datenpunkten zugeordnet. Die Behälterbreiten sind gleich.

Lassen Sie uns die Diskretisierung gleicher Breite implementieren unter Verwendung des Iris-Datensatzes. technique='uniform' In KBinsDiscretizer() Erstellt Behälter mit gleicher Breite.

# Import libraries
import pandas as pd
import matplotlib.pyplot as plt
from sklearn.datasets import load_iris
from sklearn.preprocessing import KBinsDiscretizer

# Load the Iris dataset
iris = load_iris()
df = pd.DataFrame(iris.information, columns=iris.feature_names)

# Choose one characteristic
characteristic = 'sepal size (cm)'
X = df((characteristic))

# Initialize
equal_width = KBinsDiscretizer(
    n_bins=15,
    encode='ordinal',
    technique='uniform'
)

bins_equal_width = equal_width.fit_transform(X)

plt.hist(bins_equal_width, bins=15)
plt.title("Equal Width Discretization")
plt.xlabel(characteristic)
plt.ylabel("Depend")
plt.present()

Das Histogramm zeigt Bins mit gleicher Bereichsbreite.

Gleichfrequenzdiskretisierung

Diese Methode ordnet die Werte der Variablen den Bins zu, die eine ähnliche Anzahl von Datenpunkten enthalten. Die Behälterbreiten sind nicht gleich. Die Bin-Breite wird durch Quantile bestimmt, die die Daten in vier gleiche Teile unterteilen. Auch hier wird die Anzahl der Bins vom Benutzer als Hyperparameter definiert.

Der Hauptnachteil der Gleichfrequenzdiskretisierung besteht darin, dass es viele leere Bins oder Bins mit wenigen Datenpunkten gibt, wenn die Verteilung der Datenpunkte schief ist. Dies führt zu einem erheblichen Informationsverlust.

Lassen Sie uns die Diskretisierung gleicher Breite implementieren unter Verwendung des Iris-Datensatzes. technique='quantile' In KBinsDiscretizer() schafft ausgewogene Behälter. Jeder Abschnitt hat (ungefähr) die gleiche Anzahl an Datenpunkten.

# Import libraries
import pandas as pd
from sklearn.datasets import load_iris

# Load the Iris dataset
iris = load_iris()
df = pd.DataFrame(iris.information, columns=iris.feature_names)

# Choose one characteristic
characteristic = 'sepal size (cm)'
X = df((characteristic))

# Initialize
equal_freq = KBinsDiscretizer(
    n_bins=3,
    encode='ordinal',
    technique='quantile'
)

bins_equl_freq = equal_freq.fit_transform(X)

Diskretisierung beliebiger Intervalle

Bei dieser Methode ordnet der Benutzer die Datenpunkte einer Variablen sinnvoll (willkürlich) in Bins ein. Beispielsweise können Sie die Werte der Variablen zuweisen Temperatur in Behältern darstellend „kalt“, „Regular“ Und „heiß“. Der allgemeine Sinn steht im Vordergrund. Es ist nicht erforderlich, die gleiche Bin-Breite oder die gleiche Anzahl von Datenpunkten in einem Bin zu haben.

Hier definieren wir manuell Bin-Grenzen basierend auf Domänenwissen.

# Import libraries
import pandas as pd
from sklearn.datasets import load_iris

# Load the Iris dataset
iris = load_iris()
df = pd.DataFrame(iris.information, columns=iris.feature_names)

# Choose one characteristic
characteristic = 'sepal size (cm)'
X = df((characteristic))

# Outline customized bins
custom_bins = (4, 5.5, 6.5, 8)

df('arbitrary') = pd.lower(
    df(characteristic),
    bins=custom_bins,
    labels=(0,1,2)
)

Ok-bedeutet Clustering-basierte Diskretisierung

Beim Ok-Means-Clustering geht es darum, ähnliche Datenpunkte in Clustern zu gruppieren. Diese Funktion kann zur Variablendiskretisierung verwendet werden. Bei dieser Methode sind Bins die vom Ok-Means-Algorithmus identifizierten Cluster. Auch hier müssen wir die Anzahl der Cluster definieren, okals Modellhyperparameter. Es gibt verschiedene Methoden, um den optimalen Wert zu bestimmen ok. Lesen Das Artikel, um diese Methoden zu lernen.

Hier verwenden wir KMeans Algorithmus zum Erstellen von Gruppen, die als diskretisierte Kategorien fungieren.

# Import libraries
import pandas as pd
from sklearn.cluster import KMeans
from sklearn.datasets import load_iris

# Load the Iris dataset
iris = load_iris()
df = pd.DataFrame(iris.information, columns=iris.feature_names)

# Choose one characteristic
characteristic = 'sepal size (cm)'
X = df((characteristic))

kmeans = KMeans(n_clusters=3, random_state=42)

df('kmeans') = kmeans.fit_predict(X)

Entscheidungsbaumbasierte Diskretisierung

Der auf Entscheidungsbäumen basierende Diskretisierungsprozess verwendet Entscheidungsbäume, um die Grenzen der Klassen zu ermitteln. Im Gegensatz zu anderen Methoden findet diese Methode automatisch die optimale Anzahl an Behältern. Daher muss der Benutzer die Anzahl der Bins nicht als Hyperparameter definieren.

Die bisher besprochenen Diskretisierungsmethoden sind überwachte Methoden. Allerdings handelt es sich bei dieser Methode um eine unbeaufsichtigte Methode, d. h. wir verwenden auch Zielwerte, jum die Grenzen zu bestimmen.

# Import libraries
import pandas as pd
from sklearn.cluster import KMeans
from sklearn.datasets import load_iris
from sklearn.tree import DecisionTreeClassifier

# Load the Iris dataset
iris = load_iris()
df = pd.DataFrame(iris.information, columns=iris.feature_names)

# Choose one characteristic
characteristic = 'sepal size (cm)'
X = df((characteristic))

# Get the goal values
y = iris.goal

tree = DecisionTreeClassifier(
    max_leaf_nodes=3,
    random_state=42
)

tree.match(X, y)

# Get leaf node for every pattern
df('decision_tree') = tree.apply(X)

tree = DecisionTreeClassifier(
    max_leaf_nodes=3,
    random_state=42
)

tree.match(X, y)

Dies ist die Übersicht über variable Diskretisierungsmethoden. Die Implementierung jeder Methode wird in separaten Artikeln besprochen.

Dies ist das Ende des heutigen Artikels.

Bitte lassen Sie mich wissen, wenn Sie Fragen oder Suggestions haben.

Wie wäre es mit einem KI-Kurs?

Wir sehen uns im nächsten Artikel. Viel Spaß beim Lernen!

Informationen zum Iris-Datensatz

• Zitat: Dua, D. und Graff, C. (2019). UCI Machine Studying Repository (http://archive.ics.uci.edu/ml). Irvine, CA: College of California, Faculty of Data and Laptop Science.
• Quelle: https://archive.ics.uci.edu/ml/datasets/iris
• Lizenz: RA Fisher besitzt das Urheberrecht an diesem Datensatz. Michael Marshall hat diesen Datensatz der Öffentlichkeit im Rahmen des gespendet Artistic Commons Public Area Widmungslizenz (CC0). Erfahren Sie mehr über die verschiedenen Arten von Datensatzlizenzen Hier.

Entworfen und geschrieben von:
Rukshan Pramoditha

2025–03–04

Zeitreihendaten treiben Prognosen in den Bereichen Finanzen, Einzelhandel, Gesundheitswesen und Energie voran. Im Gegensatz zu typischen Problemen des maschinellen Lernens muss die chronologische Reihenfolge gewahrt bleiben. Das Ignorieren dieser Struktur führt zu Datenlecks und irreführenden Leistungsschätzungen, wodurch die Modellbewertung unzuverlässig wird. Die Kreuzvalidierung von Zeitreihen behebt dieses Drawback, indem sie die zeitliche Integrität während des Trainings und Exams aufrechterhält. In diesem Artikel behandeln wir wesentliche Techniken, die praktische Implementierung mit ARIMA und TimeSeriesSplit sowie häufige Fehler, die es zu vermeiden gilt.

Was ist Kreuzvalidierung?

Die Kreuzvalidierung dient als grundlegende Technik, mit der maschinelle Lernmodelle ihre Leistung bewerten. Das Verfahren erfordert die Aufteilung der Daten in verschiedene Trainingssätze und Testsätze, um zu bestimmen, wie intestine das Modell mit neuen Daten funktioniert. Die k-fache Kreuzvalidierungsmethode erfordert die Aufteilung der Daten in okay gleiche Abschnitte, die als Falten bezeichnet werden. Der Testsatz verwendet eine Falte, während die übrigen Faltungen den Trainingssatz bilden. Der Testsatz verwendet eine Falte, während die übrigen Faltungen den Trainingssatz bilden.

Bei der herkömmlichen Kreuzvalidierung müssen Datenpunkte unabhängigen und identischen Verteilungsmustern folgen, einschließlich Randomisierung. Die Standardmethoden können nicht auf sequentielle Zeitreihendaten angewendet werden, da die zeitliche Reihenfolge beibehalten werden muss.

Mehr lesen: Kreuzvalidierungstechniken

Grundlegendes zur Kreuzvalidierung von Zeitreihen

Die Kreuzvalidierung von Zeitreihen passt den Normal-CV an sequentielle Daten an, indem die chronologische Reihenfolge der Beobachtungen erzwungen wird. Die Methode generiert durch ihren Prozess mehrere Prepare-Check-Splits, die jeden Satz nach den entsprechenden Trainingsperioden testen. Die frühesten Zeitpunkte können nicht als Testsatz dienen, da das Modell keine vorherigen Daten zum Trainieren hat. Bei der Bewertung der Prognosegenauigkeit werden zeitbasierte Faltungen verwendet, um Metriken zu mitteln, die durch ihre Messung MSE einbeziehen.

Die obige Abbildung zeigt ein grundlegendes Kreuzvalidierungssystem mit rollierendem Ursprung, das die Modellleistung durch Coaching auf blauen Daten bis zur Zeit testet T und Testen am nachfolgenden orangefarbenen Datenpunkt. Das Trainingsfenster „rollt dann vorwärts“ und wiederholt sich. Der Stroll-Ahead-Ansatz simuliert tatsächliche Prognosen, indem das Modell anhand historischer Daten trainiert und an kommenden Daten getestet wird. Durch die Verwendung mehrerer Falten erhalten wir mehrere Fehlermessungen, einschließlich MSE-Ergebnissen aus jeder Falte, die wir zur Bewertung und zum Vergleich verschiedener Modelle verwenden können.

Modellbildung und Evaluierung

Sehen wir uns ein praktisches Beispiel mit an Python. Wir verwenden Pandas, um unsere Trainingsdaten aus der Datei zu laden practice.csv während TimeSeriesSplit von scikit-learn sequentielle Faltungen erstellt und wir Statistikmodelle verwenden. ARIMA ein Prognosemodell zu entwickeln. In diesem Beispiel sagen wir die tägliche Durchschnittstemperatur (meantemp) in unserer Zeitreihe voraus. Der Code enthält Kommentare, die die Funktion jedes Programmierabschnitts beschreiben.

import pandas as pd
from sklearn.model_selection import TimeSeriesSplit
from statsmodels.tsa.arima.mannequin import ARIMA
from sklearn.metrics import mean_squared_error
import numpy as np

# Load time sequence knowledge (day by day information with a datetime index)
knowledge = pd.read_csv('practice.csv', parse_dates=('date'), index_col="date")

# Give attention to the goal sequence: imply temperature
sequence = knowledge('meantemp')

# Outline variety of splits (folds) for time sequence cross-validation
n_splits = 5
tscv = TimeSeriesSplit(n_splits=n_splits)

Der Code zeigt, wie eine Kreuzvalidierung durchgeführt wird. Das ARIMA-Modell wird für jede Falte im Trainingsfenster trainiert und zur Vorhersage des nächsten Zeitraums verwendet, was die Berechnung von MSE ermöglicht. Der Prozess führt zu fünf MSE-Werten, die wir durch Mittelung der fünf MSE-Werte aus jeder Aufteilung berechnen. Die Prognosegenauigkeit für die zurückgehaltenen Daten verbessert sich, wenn der MSE-Wert sinkt.

Nach Abschluss der Kreuzvalidierung können wir ein endgültiges Modell anhand der vollständigen Trainingsdaten trainieren und seine Leistung an einem neuen Testdatensatz testen. Das endgültige Modell kann mit diesen Schritten erstellt werden: final_model = ARIMA(sequence, order=(5,1,0)).match() und dann forecast = final_model.forecast(steps=len(take a look at)) was nutzt take a look at.csv Daten.

# Initialize a listing to retailer the MSE for every fold
mse_scores = ()

# Carry out time sequence cross-validation
for train_index, test_index in tscv.cut up(sequence):
    train_data = sequence.iloc(train_index)
    test_data = sequence.iloc(test_index)

    # Match an ARIMA(5,1,0) mannequin to the coaching knowledge
    mannequin = ARIMA(train_data, order=(5, 1, 0))
    fitted_model = mannequin.match()

    # Forecast the take a look at interval (len(test_data) steps forward)
    predictions = fitted_model.forecast(steps=len(test_data))

    # Compute and report the Imply Squared Error for this fold
    mse = mean_squared_error(test_data, predictions)
    mse_scores.append(mse)

    print(f"Imply Squared Error for present cut up: {mse:.3f}")

# In any case folds, compute the common MSE
average_mse = np.imply(mse_scores)
print(f"Common Imply Squared Error throughout all splits: {average_mse:.3f}")

Bedeutung für Prognosen und maschinelles Lernen

Die ordnungsgemäße Implementierung von Kreuzvalidierungsmethoden ist eine wesentliche Voraussetzung für genaue Zeitreihenprognosen. Die Methode testet die Fähigkeiten des Modells, um bevorstehende Informationen vorherzusagen, auf die das Modell noch nicht gestoßen ist. Der Prozess der Modellauswahl durch Kreuzvalidierung ermöglicht es uns, das Modell zu identifizieren, das bessere Fähigkeiten zur Verallgemeinerung seiner Leistung aufweist. Der Zeitreihen-CV liefert mehrere Fehlerbewertungen, die im Vergleich zu einer einzelnen Zugtestaufteilung unterschiedliche Leistungsmuster zeigen.

Der Prozess der Stroll-Ahead-Validierung erfordert, dass das Modell bei jeder Faltung neu trainiert wird, was als Probe für den tatsächlichen Systembetrieb dient. Das System testet die Modellstärke durch geringfügige Änderungen in den Eingabedaten, während konsistente Ergebnisse über mehrere Falten hinweg die Systemstabilität zeigen. Die Kreuzvalidierung von Zeitreihen liefert genauere Bewertungsergebnisse und unterstützt gleichzeitig die optimale Identifizierung von Modellen und Hyperparametern im Vergleich zu einer Standardmethode zur Datenaufteilung.

Herausforderungen bei der Kreuzvalidierung in Zeitreihen

Die Kreuzvalidierung von Zeitreihen bringt ihre eigenen Herausforderungen mit sich. Es fungiert als wirksames Erkennungsinstrument. Nichtstationarität (Konzeptdrift) stellt eine weitere Herausforderung dar, da sich die Modellleistung über verschiedene Falten hinweg ändert, wenn das zugrunde liegende Muster Regimeverschiebungen erfährt. Der Kreuzvalidierungsprozess zeigt dieses Muster durch die Demonstration steigender Fehler während der späteren Faltungen.

Weitere Herausforderungen sind:

• Begrenzte Daten in frühen Falten: Die ersten Falten verfügen über sehr wenige Trainingsdaten, was dazu führen kann, dass erste Vorhersagen unzuverlässig sind.
• Überlappung zwischen den Falten: Die Trainingssätze in jeder aufeinanderfolgenden Falte nehmen an Größe zu, was zu Abhängigkeit führt. Die Fehlerschätzungen zwischen den Falten zeigen eine Korrelation, was zu einer Unterschätzung der tatsächlichen Unsicherheit führt.
• Rechenaufwand: Zeitreihen-CV erfordert, dass das Modell für jede Falte neu trainiert wird, was bei komplizierten Modellen oder umfangreichen Datensätzen kostspielig wird.
• Saisonalität und Fensterwahl: Ihre Daten erfordern bestimmte Fenstergrößen und Aufteilungspunkte, da sie sowohl starke saisonale Muster als auch strukturelle Veränderungen aufweisen.

Abschluss

Die Kreuzvalidierung von Zeitreihen liefert genaue Bewertungsergebnisse, die die tatsächliche Modellleistung widerspiegeln. Die Methode behält die chronologische Abfolge der Ereignisse bei, stoppt die Datenextraktion und simuliert tatsächliche Systemnutzungssituationen. Das Testverfahren führt dazu, dass fortgeschrittene Modelle ausfallen, weil sie neues Testmaterial nicht verarbeiten können.

Sie können durch Stroll-Ahead-Validierung und geeignete Metrikauswahl starke Prognosesysteme erstellen und gleichzeitig Funktionsverluste verhindern. Maschinelles Lernen von Zeitreihen erfordert eine ordnungsgemäße Validierung, unabhängig davon, ob Sie ARIMA oder verwenden LSTM oder Gradientenverstärkung Modelle.

Häufig gestellte Fragen

Hallo! Ich bin Vipin, ein leidenschaftlicher Fanatic für Datenwissenschaft und maschinelles Lernen mit fundierten Kenntnissen in Datenanalyse, Algorithmen für maschinelles Lernen und Programmierung. Ich verfüge über praktische Erfahrung in der Modellerstellung, der Verwaltung unübersichtlicher Daten und der Lösung realer Probleme. Mein Ziel ist es, datengesteuerte Erkenntnisse anzuwenden, um praktische Lösungen zu schaffen, die zu Ergebnissen führen. Ich bin bestrebt, meine Fähigkeiten in einer kollaborativen Umgebung einzubringen und gleichzeitig weiterhin in den Bereichen Information Science, maschinelles Lernen und NLP zu lernen und mich weiterzuentwickeln.

Agentische KI geht über das Experimentieren hinaus und findet Eingang in echte Unternehmensabläufe. Im Gegensatz zu herkömmlichen KI-Modellen, die lediglich Vorhersagen generieren, können Agenten-KI-Systeme schlussfolgern, Werkzeuge koordinieren, Arbeitsabläufe auslösen und autonom innerhalb definierter Leitplanken agieren. Doch für mittelständische Unternehmen, die die Einführung evaluieren, bleibt eine große Frage: Was kostet die Implementierung eigentlich?

Die kurze Antwort lautet: Es hängt vom Umfang, der Integrationstiefe und der betrieblichen Komplexität ab. Wir können jedoch realistische grobe Spannen angeben, um die Erwartungen zu orientieren.

Was treibt die Kosten der Agenten-KI an?

Für ein mittelständisches Unternehmen (typischerweise 200–1.500 Mitarbeiter) werden die Kosten für die Implementierung einer Agenten-KI von fünf Hauptfaktoren beeinflusst:

1. Komplexität des Anwendungsfalls

Ein einfacher interner Workflow-Automatisierungsagent (z. B. Rechnungsvalidierung oder IT-Ticketweiterleitung) kostet deutlich weniger als ein Orchestrierungssystem mit mehreren Agenten, das CRM-, ERP-, Finanz- und Compliance-Systeme umfasst.

2. Systemintegrationen

Agentische KI arbeitet selten isoliert. Integration mit:

CRM-Plattformen

ERP-Systeme

Knowledge Warehouses

APIs und Legacy-Datenbanken

erhöht die Entwicklungs- und Testzeit.

3. Datenbereitschaft

Wenn Ihre Daten strukturiert, zugänglich und sauber sind, erfolgt die Implementierung schneller. Wenn Daten fragmentiert oder isoliert sind, steigen die Datenentwicklungskosten.

4. Sicherheits- und Compliance-Anforderungen

Für regulierte Branchen (Finanzen, Gesundheitswesen, Fertigung) erhöhen Governance-Ebenen wie Prüfpfade, Erklärbarkeitsmodule und rollenbasierte Zugriffskontrollen den Implementierungsaufwand.

5. Bereitstellungsmodell

Cloud-native Bereitstellungen sind im Allgemeinen kosteneffizienter als stark angepasste On-Premise-Umgebungen.

Grobe Kostenspannen für mittelständische Unternehmen

Während die genauen Zahlen variieren, finden Sie hier einen praktischen Schätzrahmen:

Part 1: AI PoC oder MVP

Grober Bereich: 40.000 – 120.000 US-Greenback

Dazu gehört:

Use-Case-Design

Einrichtung der Agentenarchitektur

Begrenzte Integrationen

Kontrollierter Piloteinsatz

Grundlegende Leistungsüberwachung

In dieser Part werden Machbarkeit und ROI vor der Skalierung validiert.

Part 2: Produktionsbereitstellung (einzelne Abteilung)

Grober Bereich: 120.000 – 350.000 US-Greenback

Dazu gehören typischerweise:

Multisystemintegrationen

Sicherheits- und Governance-Ebenen

Workflows zur Agenten-Orchestrierung

Überwachungs-Dashboards

Leistungsoptimierung

In dieser Part arbeiten die KI-Agenten in Reside-Workflows mit messbarer Wirkung.

Part 3: Agentisches Ökosystem im Unternehmensmaßstab

Grober Bereich: 350.000 $ – 900.000 $+

Für Unternehmen, die Folgendes bereitstellen:

Abteilungsübergreifende Koordination mehrerer Agenten

Autonome Entscheidungsweiterleitung

Umgebungsübergreifende Bereitstellung (Entwicklung, Staging, Produktion)

Kontinuierliche Lernpipelines

Erweiterte Compliance- und Audit-Frameworks

Die Kosten steigen mit zunehmender Autonomie, Zuverlässigkeit und Größe.

Zu berücksichtigende laufende Kosten

Über die anfängliche Implementierung hinaus sollten mittelständische Unternehmen Folgendes einplanen:

Cloud-Infrastruktur und API-Nutzung (LLM-Kosten können je nach Nutzungsvolumen variieren)

Überwachung und AgentOps-Administration

Kontinuierliche Modellumschulung

Sicherheitsüberprüfungen und Governance-Updates

Die Betriebskosten liegen typischerweise zwischen 15–25 % der ursprünglichen Baukosten professional Jahrabhängig von Systemkomplexität und Nutzungsvolumen.

Welcher ROI kann die Investition ausgleichen?

Agentische KI rechtfertigt ihre Kosten oft durch:

20–40 % Reduzierung der manuellen Bearbeitungszeit

Schnellere Entscheidungszyklen

Geringere Fehlerquoten

Reduzierte Compliance-Gefährdung

Verbesserte Skalierbarkeit ohne proportionales Personalwachstum

Bei mittelständischen Unternehmen ist der ROI in der Regel innerhalb von 6–12 Monaten sichtbar, wenn Anwendungsfälle klar definiert und mit betrieblichen Kennzahlen verknüpft sind.

Letzte Perspektive

Die Implementierung einer Agenten-KI ist eher eine strategische Investition als ein einfacher Softwarekauf. Für mittelständische Unternehmen bietet ein stufenweiser Rollout – beginnend mit einem fokussierten MVP und Skalierung nach messbarem Erfolg – ​​die beste Stability zwischen Kostenkontrolle und langfristiger Wirkung.

Organisationen, die die Umsetzung mit einer strukturierten Roadmap, einer starken Governance und messbaren Zielen angehen, sind diejenigen, die echten Unternehmenswert erschließen. Unternehmen mögen Intellectyxbekannt für KI-Beratung auf Unternehmensniveau und Bereitstellung von Agentensystemen, hilft Unternehmen beim Übergang vom Experimentieren zur skalierbaren intelligenten Automatisierung mit kontrolliertem Risiko und vorhersehbaren Investitionen.

Die eigentliche Frage ist nicht nur, wie viel die Agenten-KI kostet, sondern auch, wie viel betriebliche Effizienz und Wettbewerbsvorteile Ihr Unternehmen durch die strategische Implementierung erzielen kann.

Die GraphRAG-Implementierung von Microsoft warfare eines der ersten Systeme und führte viele revolutionary Funktionen ein. Es kombiniert sowohl die Indizierungsphase, in der Entitäten, Beziehungen und hierarchische Gemeinschaften extrahiert und zusammengefasst werden, mit erweiterten Abfragezeitfunktionen. Dieser Ansatz ermöglicht es dem System, umfassende, thematische Fragen zu beantworten, indem es vorberechnete Entitäts-, Beziehungs- und Group-Zusammenfassungen nutzt und so über die herkömmlichen Einschränkungen beim Abrufen von Dokumenten von Commonplace-RAG-Systemen hinausgeht.

Ich habe die Indizierungsphase sowie globale und lokale Suchmechanismen in früheren Blogbeiträgen behandelt (Hier Und Hier), daher überspringen wir diese Particulars in dieser Diskussion. Allerdings haben wir es noch nicht erkundet DRIFT-Suchedas im Mittelpunkt dieses Blogbeitrags stehen wird. DRIFT ist ein neuerer Ansatz, der Merkmale sowohl globaler als auch lokaler Suchmethoden kombiniert. Die Technik beginnt mit der Nutzung von Group-Informationen durch Vektorsuche, um einen breiten Ausgangspunkt für Abfragen zu schaffen, und nutzt diese Group-Einblicke dann, um die ursprüngliche Frage in detaillierte Folgeabfragen zu verfeinern. Dadurch kann DRIFT den Wissensgraphen dynamisch durchlaufen, um spezifische Informationen über Entitäten, Beziehungen und andere lokalisierte Particulars abzurufen und so Recheneffizienz mit umfassender Antwortqualität in Einklang zu bringen.

Die Implementierung verwendet LlamaIndex-Workflows um den DRIFT-Suchprozess durch mehrere Schlüsselschritte zu orchestrieren. Es beginnt mit HyDE-GenerierungErstellen einer hypothetischen Antwort basierend auf einem Beispiel-Group-Bericht, um die Abfragedarstellung zu verbessern.

Der Group-Suchschritt Anschließend wird die Vektorähnlichkeit verwendet, um die relevantesten Group-Berichte zu identifizieren und so einen breiten Kontext für die Abfrage bereitzustellen. Das System analysiert diese Ergebnisse, um eine erste Zwischenantwort und eine Reihe von Folgeabfragen für eine tiefergehende Untersuchung zu generieren.

Diese Folgeabfragen werden während des Prozesses parallel ausgeführt Lokale Suchphaseum gezielte Informationen, einschließlich Textblöcke, Entitäten, Beziehungen und zusätzliche Group-Berichte, aus dem Wissensgraphen abzurufen. Dieser Prozess kann bis zu einer maximalen Tiefe iterieren, wobei jede Runde möglicherweise neue Folgeabfragen hervorbringt.

Schließlich ist die Antwortgenerierungsschritt fasst alle während des Prozesses gesammelten Zwischenantworten zusammen und kombiniert umfassende Erkenntnisse auf Group-Ebene mit detaillierten lokalen Erkenntnissen, um eine umfassende Antwort zu erstellen. Dieser Ansatz gleicht Breite und Tiefe aus, indem er weitestgehend mit dem Group-Kontext beginnt und nach und nach auf Einzelheiten eingeht.

Dies ist meine Implementierung der DRIFT-Suche, angepasst für LlamaIndex-Workflows und Neo4j. Ich habe den Ansatz rückentwickelt, indem ich den GraphRAG-Code von Microsoft untersucht habe, daher kann es einige Unterschiede zur ursprünglichen Implementierung geben.

Der Code ist verfügbar unter GitHub.

Datensatz

Für diesen Blogbeitrag verwenden wir Alices Abenteuer im Wunderland von Lewis Carroll, ein klassischer Textual content, der frei erhältlich ist bei Projekt Gutenberg. Dieser reichhaltige erzählerische Datensatz mit seinen miteinander verbundenen Charakteren, Orten und Ereignissen macht ihn zu einer hervorragenden Wahl für die Demonstration der Fähigkeiten von GraphRAG.

Einnahme

Für den Aufnahmeprozess verwenden wir die wieder Implementierung der Microsoft GraphRAG-Indizierung Ich habe für a entwickelt vorheriger Blogbeitragangepasst an einen LlamaIndex-Workflow.

Die Aufnahmepipeline folgt dem Commonplace-GraphRAG-Ansatz mit drei Hauptphasen:

class MSGraphRAGIngestion(Workflow):
    @step
    async def entity_extraction(self, ev: StartEvent) -> EntitySummarization:
        chunks = splitter.split_text(ev.textual content)
        await ms_graph.extract_nodes_and_rels(chunks, ev.allowed_entities)
        return EntitySummarization()

    @step
    async def entity_summarization(
        self, ev: EntitySummarization
    ) -> CommunitySummarization:
        await ms_graph.summarize_nodes_and_rels()
        return CommunitySummarization()

    @step
    async def community_summarization(
        self, ev: CommunitySummarization
    ) -> CommunityEmbeddings:
        await ms_graph.summarize_communities()
        return CommunityEmbeddings()

Der Workflow extrahiert Entitäten und Beziehungen aus Textblöcken, generiert Zusammenfassungen sowohl für Knoten als auch für Beziehungen und erstellt dann hierarchische Group-Zusammenfassungen.

Nach der Zusammenfassung generieren wir Vektoreinbettungen sowohl für Communities als auch für Entitäten, um eine Ähnlichkeitssuche zu ermöglichen. Hier ist der Schritt zur Group-Einbettung:

@step
    async def community_embeddings(self, ev: CommunityEmbeddings) -> EntityEmbeddings:
        # Fetch all communities from the graph database
        communities = ms_graph.question(
            """
    MATCH (c:__Community__)
    WHERE c.abstract IS NOT NULL AND c.score > $min_community_rating
    RETURN coalesce(c.title, "") + " " + c.abstract AS community_description, c.id AS community_id
    """,
            params={"min_community_rating": MIN_COMMUNITY_RATING},
        )
        if communities:
            # Generate vector embeddings from group descriptions
            response = await shopper.embeddings.create(
                enter=(c("community_description") for c in communities),
                mannequin=TEXT_EMBEDDING_MODEL,
            )
            # Retailer embeddings within the graph and create vector index
            embeds = (
                {
                    "community_id": group("community_id"),
                    "embedding": embedding.embedding,
                }
                for group, embedding in zip(communities, response.knowledge)
            )
            ms_graph.question(
                """UNWIND $knowledge as row
            MATCH (c:__Community__ {id: row.community_id})
            CALL db.create.setNodeVectorProperty(c, 'embedding', row.embedding)""",
                params={"knowledge": embeds},
            )
            ms_graph.question(
                "CREATE VECTOR INDEX group IF NOT EXISTS FOR (c:__Community__) ON c.embedding"
            )
        return EntityEmbeddings()

Der gleiche Prozess wird auf Entitätseinbettungen angewendet, um die Vektorindizes zu erstellen, die für den ähnlichkeitsbasierten Abruf der DRIFT-Suche erforderlich sind.

DRIFT-Suche

Die DRIFT-Suche ist ein intuitiver Ansatz zum Abrufen von Informationen: Beginnen Sie damit, das Gesamtbild zu verstehen, und gehen Sie dann bei Bedarf in die Einzelheiten ein. Anstatt sofort nach genauen Übereinstimmungen auf Dokument- oder Entitätsebene zu suchen, konsultiert DRIFT zunächst Group-Zusammenfassungen, bei denen es sich um Übersichten auf hoher Ebene handelt, die die Hauptthemen und Themen innerhalb des Wissensgraphen erfassen.

Sobald DRIFT relevante Informationen auf höherer Ebene identifiziert, generiert es auf intelligente Weise Folgeabfragen, um genaue Informationen zu bestimmten Entitäten, Beziehungen und Quelldokumenten abzurufen. Dieser zweiphasige Ansatz spiegelt die natürliche Informationssuche des Menschen wider: Wir orientieren uns zunächst mit einem allgemeinen Überblick und stellen dann gezielte Fragen, um die Particulars zu ergänzen. Durch die Kombination der umfassenden Abdeckung der globalen Suche mit der Präzision der lokalen Suche erreicht DRIFT sowohl Breite als auch Tiefe, ohne dass der Rechenaufwand für die Verarbeitung jedes Group-Berichts oder Dokuments anfällt.

Lassen Sie uns jede Section der Implementierung durchgehen.

Der Code ist verfügbar unter GitHub.

Group-Suche

DRIFT verwendet HyDE (Hypothetical Doc Embeddings), um die Genauigkeit der Vektorsuche zu verbessern. Anstatt die Anfrage des Benutzers direkt einzubetten, generiert HyDE zunächst eine hypothetische Antwort und verwendet diese dann für die Ähnlichkeitssuche. Dies funktioniert, weil hypothetische Antworten semantisch näher an tatsächlichen Group-Zusammenfassungen liegen als reine Abfragen.

@step
async def hyde_generation(self, ev: StartEvent) -> CommunitySearch:
    # Fetch a random group report to make use of as a template for HyDE era
    random_community_report = driver.execute_query(
        """
    MATCH (c:__Community__)
    WHERE c.abstract IS NOT NULL
    RETURN coalesce(c.title, "") + " " + c.abstract AS community_description""",
        result_transformer_=lambda r: r.knowledge(),
    )
    # Generate a hypothetical reply to enhance question illustration
    hyde = HYDE_PROMPT.format(
        question=ev.question, template=random_community_report(0)("community_description")
    )
    hyde_response = await shopper.responses.create(
        mannequin="gpt-5-mini",
        enter=({"function": "person", "content material": hyde}),
        reasoning={"effort": "low"},
    )
    return CommunitySearch(question=ev.question, hyde_query=hyde_response.output_text)

Als nächstes betten wir die HyDE-Abfrage ein und rufen die fünf relevantesten Group-Berichte über Vektorähnlichkeit ab. Anschließend wird das LLM aufgefordert, aus diesen Berichten eine Zwischenantwort zu generieren und Folgefragen für eine tiefergehende Untersuchung zu identifizieren. Die Zwischenantwort wird gespeichert und alle Folgeanfragen werden parallel für die lokale Suchphase versendet.

@step
async def community_search(self, ctx: Context, ev: CommunitySearch) -> LocalSearch:
    # Create embedding from the HyDE-enhanced question
    embedding_response = await shopper.embeddings.create(
        enter=ev.hyde_query, mannequin=TEXT_EMBEDDING_MODEL
    )
    embedding = embedding_response.knowledge(0).embedding
    
    # Discover high 5 most related group studies by way of vector similarity
    community_reports = driver.execute_query(
        """
    CALL db.index.vector.queryNodes('group', 5, $embedding) YIELD node, rating
    RETURN 'community-' + node.id AS source_id, node.abstract AS community_summary
    """,
        result_transformer_=lambda r: r.knowledge(),
        embedding=embedding,
    )
    
    # Generate preliminary reply and establish what additional information is required
    initial_prompt = DRIFT_PRIMER_PROMPT.format(
        question=ev.question, community_reports=community_reports
    )
    initial_response = await shopper.responses.create(
        mannequin="gpt-5-mini",
        enter=({"function": "person", "content material": initial_prompt}),
        reasoning={"effort": "low"},
    )
    response_json = json_repair.hundreds(initial_response.output_text)
    print(f"Preliminary intermediate response: {response_json('intermediate_answer')}")
    
    # Retailer the preliminary reply and put together for parallel native searches
    async with ctx.retailer.edit_state() as ctx_state:
        ctx_state("intermediate_answers") = (
            {
                "intermediate_answer": response_json("intermediate_answer"),
                "rating": response_json("rating"),
            }
        )
        ctx_state("local_search_num") = len(response_json("follow_up_queries"))
    
    # Dispatch follow-up queries to run in parallel
    for local_query in response_json("follow_up_queries"):
        ctx.send_event(LocalSearch(question=ev.question, local_query=local_query))
    return None

Dies legt den Kernansatz von DRIFT fest: Beginnen Sie breit mit der durch HyDE erweiterten Group-Suche und gehen Sie dann mit gezielten Folgeabfragen weiter in die Tiefe.

Lokale Suche

In der lokalen Suchphase werden parallel Folgeabfragen ausgeführt, um einen Drilldown zu bestimmten Particulars durchzuführen. Jede Abfrage ruft den Zielkontext über eine entitätsbasierte Vektorsuche ab und generiert dann eine Zwischenantwort und möglicherweise weitere Folgeabfragen.

@step(num_workers=5)
async def local_search(self, ev: LocalSearch) -> LocalSearchResults:
    print(f"Operating native question: {ev.local_query}")
    
    # Create embedding for the native question
    response = await shopper.embeddings.create(
        enter=ev.local_query, mannequin=TEXT_EMBEDDING_MODEL
    )
    embedding = response.knowledge(0).embedding
    
    # Retrieve related entities and collect their related context:
    # - Textual content chunks the place entities are talked about
    # - Group studies the entities belong to
    # - Relationships between the retrieved entities
    # - Entity descriptions
    local_reports = driver.execute_query(
        """
CALL db.index.vector.queryNodes('entity', 5, $embedding) YIELD node, rating
WITH acquire(node) AS nodes
WITH
acquire {
  UNWIND nodes as n
  MATCH (n)<-(:MENTIONS)->(c:__Chunk__)
  WITH c, rely(distinct n) as freq
  RETURN {chunkText: c.textual content, source_id: 'chunk-' + c.id}
  ORDER BY freq DESC
  LIMIT 3
} AS text_mapping,
acquire {
  UNWIND nodes as n
  MATCH (n)-(:IN_COMMUNITY*)->(c:__Community__)
  WHERE c.abstract IS NOT NULL
  WITH c, c.score as rank
  RETURN {abstract: c.abstract, source_id: 'community-' + c.id}
  ORDER BY rank DESC
  LIMIT 3
} AS report_mapping,
acquire {
  UNWIND nodes as n
  MATCH (n)-(r:SUMMARIZED_RELATIONSHIP)-(m)
  WHERE m IN nodes
  RETURN {descriptionText: r.abstract, source_id: 'relationship-' + n.identify + '-' + m.identify}
  LIMIT 3
} as insideRels,
acquire {
  UNWIND nodes as n
  RETURN {descriptionText: n.abstract, source_id: 'node-' + n.identify}
} as entities
RETURN {Chunks: text_mapping, Experiences: report_mapping,
   Relationships: insideRels,
   Entities: entities} AS output
""",
        result_transformer_=lambda r: r.knowledge(),
        embedding=embedding,
    )
    
    # Generate reply based mostly on the retrieved context
    local_prompt = DRIFT_LOCAL_SYSTEM_PROMPT.format(
        response_type=DEFAULT_RESPONSE_TYPE,
        context_data=local_reports,
        global_query=ev.question,
    )
    local_response = await shopper.responses.create(
        mannequin="gpt-5-mini",
        enter=({"function": "person", "content material": local_prompt}),
        reasoning={"effort": "low"},
    )
    response_json = json_repair.hundreds(local_response.output_text)
    
    # Restrict follow-up queries to forestall exponential progress
    response_json("follow_up_queries") = response_json("follow_up_queries")(:LOCAL_TOP_K)
    
    return LocalSearchResults(outcomes=response_json, question=ev.question)

Der nächste Schritt orchestriert den iterativen Vertiefungsprozess. Es wartet darauf, dass alle parallelen Suchvorgänge mit abgeschlossen werden collect_eventsund entscheidet dann, ob der Drilldown fortgesetzt werden soll. Wenn die aktuelle Tiefe nicht das Most erreicht hat (wir verwenden maximale Tiefe = 2), werden Folgeabfragen aus allen Ergebnissen extrahiert, die Zwischenantworten gespeichert und die nächste Runde paralleler Suchvorgänge gestartet.

@step
async def local_search_results(
    self, ctx: Context, ev: LocalSearchResults
) -> LocalSearch | FinalAnswer:
    local_search_num = await ctx.retailer.get("local_search_num")
    
    # Await all parallel searches to finish
    outcomes = ctx.collect_events(ev, (LocalSearchResults) * local_search_num)
    if outcomes is None:
        return None
        
    intermediate_results = (
        {
            "intermediate_answer": occasion.outcomes("response"),
            "rating": occasion.outcomes("rating"),
        }
        for occasion in outcomes
    )
    current_depth = await ctx.retailer.get("local_search_depth", default=1)
    question = (ev.question for ev in outcomes)(0)

    # Proceed drilling down if we have not reached max depth
    if current_depth < MAX_LOCAL_SEARCH_DEPTH:
        await ctx.retailer.set("local_search_depth", current_depth + 1)
        follow_up_queries = (
            question
            for occasion in outcomes
            for question in occasion.outcomes("follow_up_queries")
        )
        
        # Retailer intermediate solutions and dispatch subsequent spherical of searches
        async with ctx.retailer.edit_state() as ctx_state:
            ctx_state("intermediate_answers").lengthen(intermediate_results)
            ctx_state("local_search_num") = len(follow_up_queries)

        for local_query in follow_up_queries:
            ctx.send_event(LocalSearch(question=question, local_query=local_query))
        return None
    else:
        return FinalAnswer(question=question)

Dadurch entsteht eine iterative Verfeinerungsschleife, in der jede Tiefenebene auf früheren Erkenntnissen aufbaut. Sobald die maximale Tiefe erreicht ist, wird die endgültige Antwortgenerierung ausgelöst.

Endgültige Antwort

Im letzten Schritt werden alle während des DRIFT-Suchprozesses gesammelten Zwischenantworten zu einer umfassenden Antwort zusammengefasst. Dazu gehören die erste Antwort aus der Group-Suche und alle Antworten, die während der lokalen Suchiterationen generiert wurden.

@step
async def final_answer_generation(self, ctx: Context, ev: FinalAnswer) -> StopEvent:
    # Retrieve all intermediate solutions collected all through the search course of
    intermediate_answers = await ctx.retailer.get("intermediate_answers")
    
    # Synthesize all findings right into a complete ultimate response
    answer_prompt = DRIFT_REDUCE_PROMPT.format(
        response_type=DEFAULT_RESPONSE_TYPE,
        context_data=intermediate_answers,
        global_query=ev.question,
    )
    answer_response = await shopper.responses.create(
        mannequin="gpt-5-mini",
        enter=(
            {"function": "developer", "content material": answer_prompt},
            {"function": "person", "content material": ev.question},
        ),
        reasoning={"effort": "low"},
    )

    return StopEvent(outcome=answer_response.output_text)

Zusammenfassung

Die DRIFT-Suche stellt eine interessante Strategie dar, um die Breite der globalen Suche mit der Präzision der lokalen Suche in Einklang zu bringen. Indem mit dem Kontext auf Group-Ebene begonnen und schrittweise iterative Folgeabfragen durchgeführt werden, wird der Rechenaufwand für die Verarbeitung aller Group-Berichte vermieden und gleichzeitig eine umfassende Abdeckung gewährleistet.

Es gibt jedoch Raum für mehrere Verbesserungen. Die aktuelle Implementierung behandelt alle Zwischenantworten gleich, aber eine Filterung basierend auf ihren Konfidenzwerten könnte die Qualität der endgültigen Antworten verbessern und Rauschen reduzieren. Ebenso könnten Folgeanfragen vor der Ausführung nach Relevanz oder potenziellem Informationsgewinn geordnet werden, um sicherzustellen, dass die vielversprechendsten Leads zuerst verfolgt werden.

Eine weitere vielversprechende Verbesserung wäre die Einführung eines Abfrageverfeinerungsschritts, der mithilfe eines LLM alle generierten Folgeabfragen analysiert, ähnliche gruppiert, um redundante Suchvorgänge zu vermeiden, und Abfragen herausfiltert, die wahrscheinlich keine nützlichen Informationen liefern. Dies könnte die Anzahl lokaler Suchen erheblich reduzieren und gleichzeitig die Antwortqualität beibehalten.

Die vollständige Implementierung ist verfügbar unter GitHub für diejenigen, die daran interessiert sind, mit diesen Verbesserungen zu experimentieren oder DRIFT für ihre eigenen Anwendungsfälle anzupassen.

Einführung

ist ein einfaches praktisches Projekt, das Python-Übung auf Schleifen, Bedingungen usw. ermöglicht. Das Projekt ist unkompliziert. Wir haben eine Kaffeemaschine mit unterschiedlichen Kaffeetypen, die ein Benutzer zusammen mit den Zutaten bestellen kann, die für die Herstellung erforderlich sind, und deren Preisschild. Ein Benutzer bestellt ein Kaffeetränk, zahlt Münzen aus, die Maschine berechnet die Gesamtsumme, und wenn die Zahlung abgeschlossen ist, gibt es den Kaffee aus. Für ein besseres Verständnis dieses Projekts finden Sie meinen bereits veröffentlichten Artikel in Richtung Knowledge Science: Implementierung der Kaffeemaschine in Python

In diesem Artikel werden wir die OOP -Model der Kaffeemaschine in Python erstellen.

Was ist OOP?

Die objektorientierte Programmierung ist ein Programmierkonzept, das auf dem Erstellen von Klassen und Objekten basiert. In einfachen Worten a Klasse ist eine Vorlage oder eine Blaupause, eine definierte breite Kategorie, und Objekte sind die einzelnen Strukturen, die aus diesen Klassen geschaffen werden. Die Klasse in OOP definiert bestimmte Merkmale, die alle Objekte, die aus dieser Klasse stammen, diese genannt werden Attribute. Darüber hinaus definierte die Klasse auch bestimmte Funktionen, die sie bewirken kann. In der OOP -Terminologie werden diese genannt Methoden.

Angenommen, wir definieren eine Klasse „Katzen“. Dies ist eine breite Kategorie und enthält alle Arten von Katzen als Objekte: meine Katze Figaro, die Katzen -Simba des Nachbarn usw. Jede Katze hat einige individuelle Eigenschaften wie ihren Namen, ihre Augenfarbe, ihre Rasse usw. Diese werden als ihre Attribute codiert. Darüber hinaus werden sie auch spezifische Funktionen haben, wie in der Lage zu sein, zu jagen, zu schlafen, zu spielen, Miau usw. zu sein. Diese werden als ihre Methoden codiert.

Im Folgenden werden Klassen und Objekte codiert:

class Cat:
    def __init__(self, identify, eye_color, fur_color, breed, age, size):
        self.identify = identify 
        self.eye_color = age 
        self.fur_color = fur_color
        self.breed = breed
        self.age = age
        self.size = size
  

    def hunt(self, animal):
        print(f"My cat {self.identify} is searching a {animal}")


my_cat = Cat("Figaro", "blue", "black and white", "Persian", "2", "48")
print(my_cat.identify)

neighbour_cat = Cat("Simba", "hazel", "brown", "Siamese", "3", "50")
neighbour_cat.hunt("mouse")

Wir werden das obige Konzept und die obige Funktionalität verwenden, um eine OOP -Model einer Kaffeemaschine zu erstellen.

Projektarbeit

In meinem vorherigen Artikel über die Kaffeemaschine habe ich die Arbeit des Projekts gründlich erklärt. Dieses Projekt wird in seiner Arbeit ähnlich sein, außer dass wir objektorientierte Programmierungen verwenden, um die gleichen Ergebnisse zu erzielen. Insgesamt haben wir die folgenden Schritte:

Definieren von Kursen für unsere Kaffeemaschine

Der erste Schritt in diesem Projekt besteht darin, unsere Klassen nacheinander zu definieren, und dann werden wir diese Blaupausen verwenden, um Objekte zu definieren, die während des gesamten Projekts benötigt werden.

Definition der „Menuitem“ -Klasse

Erstens werden wir die definieren MenuItem Klasse, das jedes Aspect in unserem Menü modelliert und die daraus erstellten Objekte in der nächsten Klasse verwendet, die wir erstellen werden Menu.

class MenuItem:
    def __init__(self, identify, water, milk, espresso, value):
        self.identify = identify
        self.value = value
        self.elements = {
            "water": water,
            "milk": milk,
            "espresso": espresso
        }

Angenommen, wir wollen ein Objekt erstellen menuitem der Klasse MenuItem. In diesem Fall müssen wir ihm die folgenden Parameter geben: Identify des Artikels, die Menge an Wasser, die für die Herstellung dieses Menüpunkts erforderlich ist, die Menge an Milch, die für die Herstellung dieses Menüpunkts erforderlich ist, die Menge an Kaffee, die für die Herstellung dieses Menüpunkts erforderlich ist, und die Kosten für diesen Menüpunkt.

Diese MeniItem -Klasse wird verwendet, um Objekte später zu initialisieren.

Definieren Sie die „Menü“ -Klasse

Lassen Sie uns als nächstes eine Klasse definieren Menu Dies enthält die Particulars jedes Parts, die bestellt werden können. Das Objekt menu kann mit dem folgenden Konstruktor initialisiert werden, und das Menüattribut dieser Klasse ist eine Liste der 3 als Objekte aus der von uns konstruierten Klasse konstruierten Elemente MenuItem. Wir werden 3 Objekte aus dieser Klasse mit ihren definierten Parametern konstruieren. Zum Beispiel benötigt der Objekt Latte 200 ml Wasser, 150 ml Milch und 24 g Kaffee, und die Kosten betragen 2,5 USD. All dies wird im Klassenkonstruktor von modelliert Menumit der Objekte dieser Klasse initialisiert werden. Die __init__ -Methode wird immer aufgerufen, wenn wir ein Objekt erstellen.

class Menu:
    def __init__(self):
        self.menu = (
            MenuItem(identify="latte", water=200, milk=150, espresso=24, value=2.5),
            MenuItem(identify="espresso", water=50, milk=0, espresso=18, value=1.5),
            MenuItem(identify="cappuccino", water=250, milk=50, espresso=24, value=3),
        )

Jetzt haben wir die Menüattribute, wir werden auch zwei Methoden darin definieren. Eine davon ist, die Namen der verfügbaren Menüelemente zurückzugeben get_itemsund die zweite Methode find_drinksoll das Getränk finden, das der Benutzer durch die Eingabefunktion auswählt.

class Menu:
...

    def get_items(self):
        choices = ""
        for merchandise in self.menu:
            choices += f"{merchandise.identify}/"
        return choices

    def find_drink(self, order_name):
        for merchandise in self.menu:
            if merchandise.identify == order_name:
                return merchandise
        print("Sorry that merchandise just isn't out there.")

Erstellen eines Objekts aus der Klasse „Menü“

Um diese Klasse und ihre zugehörigen Attribute und Methoden zu verwenden, werden wir zunächst ein Objekt initialisieren menu der Klasse Menu. Wir werden dann die Methode verwenden get_items Um dem Benutzer die Elemente anzuzeigen, die wir in unserem Menü haben.

menu = Menu()
drinks = menu.get_items()
drink_selected = enter(f"Choose your drink {drinks}: ")

menu.find_drink(drink_selected)

Sobald der Benutzer sein Getränk eingegeben hat, prüfen wir, ob es im Menüobjekt mit dem vorhanden ist Menu Klasse find_drink Verfahren. Diese Methode prüft, ob die Benutzereingabe im Menü vorhanden ist, sie wird dieses Aspect zurückgegeben. Andernfalls wird er an den Benutzer ausgedruckt, dass das Getränk nicht verfügbar ist.

Wenn wir additionally eine Bestellung eines Vanille -Shake geben, druckt das Programm einfach aus, dass der Artikel nicht verfügbar ist. Wenn das Eingabetränk in unserem definierten Menü vorhanden ist, ist die Methode find_drink Gibt den Artikel zurück. Jetzt können wir diesen Aspect in unserer Codierung im Voraus verwenden.

Definieren der Kaffeemaschinenklasse

Unser nächster Schritt ist, die zu definieren CoffeeMaker Klasse. Der CoffeeMaker Die Klasse speichert die zuvor angegebenen Ressourcen und verfügt über 3 Methoden, die ihre Objekte verwendet werden können:

1. report Methode: Diese Methode ermöglicht es dem Administration, die Ressourcen in der Kaffeemaschine durch Drucken eines Berichts über alle Ressourcen zu überprüfen.
2. is_resources_sufficient Methode: Diese Methode prüft, ob die Ressourcen in der Kaffeemaschine ausreichen, um das gewünschte Getränk herzustellen. Es wird zurückkehren True Wenn Ressourcen ausreichen; Andernfalls wird der Benutzer wissen, welche Ressource nicht ausreicht.
3. make_coffee Methode: Die letzte Methode wird aufgerufen, wenn die Anforderungen des Programms erfüllt wurden, und wir müssen den Kaffee herstellen. Dieser Code wird die Ressourcen abziehen und Kaffee abgeben.

class CoffeeMaker:
    def __init__(self):
        self.assets = {
            "water": 1000,
            "milk": 1000,
            "espresso": 200,
        }

    def report(self):
        print(f"Water: {self.assets('water')}ml")
        print(f"Milk: {self.assets('milk')}ml")
        print(f"Espresso: {self.assets('espresso')}g")

    def is_resource_sufficient(self, drink):
        can_make = True
        for merchandise in drink.elements:
            if drink.elements(merchandise) > self.assets(merchandise):
                print(f"Sorry there's not sufficient {merchandise}.")
                can_make = False
        return can_make

    def make_coffee(self, order):
        for merchandise so as.elements:
            self.assets(merchandise) -= order.elements(merchandise)
        print(f"Right here is your {order.identify} . Take pleasure in!")

Definieren der Klasse „MoneyMachine“

Lassen Sie uns schließlich auch die Klasse definieren MoneyMachine. Diese Klasse wird für das Geldmanagement verantwortlich sein. Es wird Münzen verarbeitet, um zu prüfen, ob die Zahlung erfolgt, und das Geld zur Geldbank hinzuzufügen.

Der MoneyMachine Die Klasse hat die folgenden Methoden:

1. report Methode: Diese Methode druckt, wie viel Geld wir auf unserem Konto haben
2. process_coins Methode: Diese Methode verarbeitet die Zahlung in Type von Münzen von Nickern, Dimes, Quartieren und Pennies und berechnet die Gesamtsumme.
3. make_payment Methode: Diese Methode wird verwendet, um zu prüfen, ob die Zahlung erfolgt, ist abgeschlossen oder ob der Benutzer überbezahlt hat. Es wird die Änderung zurückgeben.

class MoneyMachine:
    CURRENCY = "$"
    COIN_VALUES = {
        "quarters": 0.25,
        "dimes": 0.10,
        "nickles": 0.05,
        "pennies": 0.01
    }

    def __init__(self):
        self.revenue = 0
        self.money_received = 0

    def report(self):
        print(f"Cash: {self.CURRENCY}{self.revenue}")

    def process_coins(self):
        "Please insert cash.")
        for coin in self.COIN_VALUES:
            self.money_received += int(enter(f"What number of {coin}?: ")) * self.COIN_VALUES(coin)
        return self.money_received

    def make_payment(self, value):
        self.process_coins()
        if self.money_received >= value:
            change = spherical(self.money_received - value, 2)
            print(f"Right here is {self.CURRENCY}{change} in change.")
            self.revenue += value
            self.money_received = 0
            return True
        else:
            print("Sorry that is not sufficient cash. Cash refunded.")
            self.money_received = 0
            return False

Der endgültige Code

Nachdem wir unsere Klassen definiert haben, werden wir den endgültigen Code schreiben, der den Benutzer nach seiner Bestellung auffordert, überprüft, ob die Ressourcen ausreichen, die Münzen und Zahlungen verarbeiten und die Getränke ausgeben, wenn die Bedingungen erfüllt sind. All dies erfolgt durch Initialisierung von Objekten.

money_machine = MoneyMachine()
coffee_maker = CoffeeMaker()
menu = Menu()

is_on = True

whereas is_on:
    choices = menu.get_items()
    selection = enter(f"What would you want {choices}: ")
    if selection == 'off':
        is_on = False
    elif selection == 'report':
        coffee_maker.report()
        money_machine.report()
    else:
        drink = menu.find_drink(selection)
        if coffee_maker.is_resource_sufficient(drink) and money_machine.make_payment(drink.value):
            coffee_maker.make_coffee(drink)

In unserem endgültigen Code haben wir eine Weile geschaffen, die kontinuierlich ausgeführt wird, es sei denn, jemand von Administration befiehlt es, um zu stoppen. Wir haben dies mit dem getan is_on boolesche Variable, die sich ändert zu False Wenn die Verwaltung als Eingabe für die Auftragsaufforderung „ausgeht“.

Darüber hinaus haben wir wie in unserem Kaffeemaschineprojekt ohne OOP auch die Berichtsoption hinzugefügt, die den Bericht über alle Ressourcen in der Kaffeemaschine und das Geld auf dem Konto erstellt

Das Programm wird wie folgt ausgeführt: Es fordert den Benutzer auf, ein Getränk zu bestellen, indem die Menüelemente angezeigt werden. Wenn sich der vom Benutzer ausgewählte Artikel in der Liste befindet, prüft er zunächst, ob die Ressourcen ausreichen, und fragen Sie nach der Zahlung und prüfen Sie, ob die Zahlung abgeschlossen ist, und bearbeiten Sie dann die Bestellung. All dies wurde mit OOP -Konzepten von Klassen und Objekten durchgeführt.

Abschluss

Obwohl wir die Funktionen von OOP in diesem Projekt nicht vollständig untersucht haben, haben wir unsere Codezeilen erfolgreich verringert, indem wir Klassen einführen und Objekte daraus erstellen. Wenn es um komplexere Projekte mit einer Reihe verschiedener Objekte geht, die alle eine gemeinsame Blaupause teilen, ist die Einbeziehung von OOP -Konzepten wesentlich praktischer.

Trotzdem struggle dieses Kaffeemaschineprojekt mit OOP ein nützliches Tutorial, um die Grundlagen der objektorientierten Programmierung zu erfassen. Wenn Sie Vorschläge haben oder sich einen alternativen Aufgabenfluss für dieses Projekt vorstellen können, können Sie gerne teilen. Bis dahin genießen Sie Ihren Kaffee!

Carl Gauß conflict ein deutscher Mathematiker und Astronom, der auch als „Prinz der Mathematik“ bekannt ist. Er ist weithin für seine Beiträge in den Bereichen Naturwissenschaften und Mathematik wie Zahlentheorie, Geometrie, Algebra, Astronomie, Magnetismus usw. anerkannt. Noch heute werden eine Reihe von mathematischen und wissenschaftlichen Konzepten nach ihm benannt. Ein solches Konzept ist die Gaußsche Ergänzung, die wir heute untersuchen werden!

Es ist kein Wissen, sondern der Akt des Lernens, nicht in Besitz, sondern um den Akt des Ankommens, der den größten Genuss gewährt.

– Carl Friedrich Gauß

Gaußsche Ergänzung

Die Gaußsche Addition -Herausforderung ist ein interessantes Beispiel für das Denken außerhalb des Tellerrands, anstatt auf vorbestimmte Weise Aufgaben zu erledigen.

Als Carl Gauß ein Sort conflict, gab ihm sein Lehrer die Aufgabe, die Zahlen von 1 auf 100 hinzuzufügen. Jetzt eine solche Aufgabe, die die ersten 2 Zahlen hinzufügte und dann die nächste, dann die nächste Zeit dauern würde.

Aber Carl Gauß hatte eine schnellere und schlauere Möglichkeit, seine Aufgabe zu erledigen. Er verstand, dass die Zugabe von Zahlen von 1 zu 100 die gleiche wie die Zugabe von 50 Paaren entspricht, die auf 101 summieren würden, dh der ersten und der letzte 1 + 100 = 101, ähnlich der zweite und zweite letzte 2 + 99 = 101, das n^th und das n^th Der letzte Artikel in der Serie würde sich alle auf 101 betragen, und 50 solcher Paare würden gemacht. Dies bedeutet, dass insgesamt 5050 ohne mühsame Berechnungen leicht berechnet werden können.

Carl Gauß conflict clever; Er konnte eine intelligente Technik entwickeln, um die Summe zu berechnen, aber seien wir ehrlich. Keiner von uns ist so schlau: p. Obwohl wir nicht über das Gehirn von Gauß haben, haben wir sicherlich den Vorteil von Programmierung und Computern, die komplexe Berechnungen für uns durchführen. Lassen Sie uns das obige Drawback in Python codieren.

Code

Lassen Sie uns die Gaußsche Herausforderung lösen, während wir die zu verwendenden Python-Einbauten verstehen:

Reichweite

Das erste, was wir verstehen müssen, ist der Python vary Funktion. Diese Funktion wird verwendet, um eine Folge von Zahlen zu erstellen, die später in anderen Funktionen verwendet werden können, wie die for Schleife.

Die Syntax für die vary Funktion ist wie folgt.

Bereich = (Zahl, bei der die Sequenz beginnt, Zahl, bei der die Sequenz aufhört, Schritt)

Angenommen, wir müssen eine Folge von Zahlen von 1 bis 10 mit einem Schritt oder einer Differenz von 1 erstellen, sodass wir diese Bereichsfunktion wie folgt verwenden:

numbers = vary(1,11)
for i in numbers:
    print(i)

Beachten Sie, dass wir ’11‘ als die Zahl angegeben haben, bei der die Sequenz aufhört. Dies liegt daran, dass nach der Syntax die letzte Zahl innerhalb des Bereichs liegt, dh im obigen Beispiel weniger als 11 = 10.

Wenn wir die Variable drucken möchten numbersWir werden in der jeweiligen Sequenz keine Liste dieser Zahlen erhalten. Wir erhalten jedoch einen Reichweitedatenatyp. Dies liegt daran, dass der Bereich DataType die Sequenz im Speicher des Computer systems nicht so speichert, wie eine Liste ihre Elemente speichert. Wir können den Zahlenbereich nicht mit einer Liste gleichsetzen.

numbers = vary(1,11)
print(numbers)

Für Schleife

Als nächstes müssen wir diese Zahlen durchführen. Python Loops sind unsere Anlaufstelle für jede Artwork von Iteration. In diesem Tutorial erfahren wir die beiden Schleifen und erzielen das obige Ergebnis mit beiden.

Nun, da wir über den zuvor definierten Bereich iteriert werden, was in unserem Fall von 1 bis 100 liegen würde, mit dem Standardschritt von 1 (wir können das weglassen), werden wir die verwenden for Schleifen und diese zur Verfügung stellen vary. Aber zuerst werden wir eine Variable bezeichnet complete Damit wird die Summe der Zahlenfolge nach jeder Iteration gespeichert. Der Wert von complete wird anfangs 0 sein und mit jeder Iteration erhöht. In der ersten Iteration, wenn wir von 1 bis 100 schleifen, beträgt die Gesamtsumme 1. In der zweiten Iteration beträgt es 1 + 2 = 3. In der dritten Iteration beträgt es 3 + 3 = 6 und so weiter.

Wir werden den Wert ausdrucken complete Am Ende. Sehen Sie, es beträgt 5050, den gleichen Wert wie Gauß.

numbers = vary(1,101)
complete = 0
for i in numbers:
    complete = complete + i
print("Complete: ", complete)

Während der Schleife

Eine andere Möglichkeit, die obige Aufgabe zu erledigen, besteht darin, Python zu verwenden whereas Schleife. Der whereas Schleife funktioniert, bis eine bestimmte Bedingung falsch wird. In unserem Fall müssen wir eine Variable initialisieren iGeben Sie ihm den Startwert von 1 und erhöhen Sie ihn nur um 1, damit es die Liste durchschlägt, bis sie 101 erreicht. Bei i = 101, die whereas Loops Zustand wird falsch und wird so aufhören. Der Wert complete wird gedruckt.

numbers = vary(1,101)
complete = 0
i = 1
whereas i in numbers:
    complete = complete + i
    i = i + 1
print("Complete: ", complete)

Abschluss

In diesem kurzen Artikel haben wir die verwendet vary Funktionen Sie eine schnellere Möglichkeit, unsere Aufgabe zu überwinden, Zahlen von 1 bis 100 zu definieren. Wir haben dann beide verwendet for und die whereas Schleifen, um das Drawback der Addition zu lösen, und beide konnten uns das richtige Ergebnis geben.

Wie bei solchen Entscheidungen zu sehen ist, funktioniert eine Technik besser als die andere. Was conflict Ihrer Meinung nach besser in der Lösung der Gaußschen Herausforderung? whereas Schleife oder die for Schleife? Denken Sie in Bezug auf Komplexität, Zeit, Verwendungsgedächtnis und Klarheit nach. Eines ist eindeutig besser als der andere. Teilen Sie teilen, welcher Sie denken, was Sie für besser halten als das andere und warum. Ich freue mich auf Ihre Kommentare!

battle ein römischer Herrscher, der für seine militärischen Strategien und seine hervorragende Führung bekannt battle. Die nach ihm benannte Caesar -Chiffre ist eine faszinierende kryptografische Technik, die Julius Caesar verwendet hat, um seinem Militärpersonal geheime Signale und Nachrichten zu senden.

Die Caesar -Chiffre ist in seiner Arbeit sehr einfach. Es funktioniert, indem alle Buchstaben der Nachricht verschoben werden, um durch eine feste Anzahl von Orten, die als Schlüssel bezeichnet werden, verschlüsselt zu werden. Die Individual, die es erhält, ist sich des Schlüssels bewusst und verwendet ihn, um die Nachricht zu entschlüsseln, wodurch eine einfache und intelligente Möglichkeit zur Durchführung privater Korrespondenz bietet.

Das Projekt verstehen

In diesem Artikel lernen wir, wie die Caesar -Chiffre in Python implementiert werden kann. Dies ist ein anfängerfreundliches Projekt, bei dem wir bedingte Aussagen, Schleifen und Funktionen verwenden, um Benutzereingabedaten zu codieren und zu dekodieren.

So wird das Programm funktionieren: Das Programm fordert den Benutzer auf, dass eine Nachricht codiert oder dekodiert wird. Der Benutzer wählt entweder Verschlüsselung oder Entschlüsselung. Das Programm fragt nach dem Schlüssel, mit dem die Nachricht verschlüsselt wird. Sobald der Benutzer den Schlüssel angibt, konvertiert das Programm die Nachricht, indem jeder Buchstabe der Nachricht gemäß dem Schlüssel konvertiert wird, indem die Buchstaben bei der Codierung oder bei der Entschlüsselung rückwärts verschoben werden.

Definieren wir zunächst die Projektschritte mit Hilfe eines Flussdiagramms.

Schritt 1: Definieren der Alphabetliste

Zunächst werden wir die verwenden Liste Datentyp in Python, um eine Liste der Buchstaben im Alphabet zu erstellen. Python-Pay attention sind eine Abfolge von Elementen in einer bestimmten Reihenfolge und haben mehrere integrierte Funktionen. Das Programm verwendet diese Liste als Verweis auf Verschiebungsbuchstaben nach vorne oder rückwärts gemäß der Auswahl der Codierung oder Dekodierung. Lassen Sie uns die Liste definieren, alphabet.

alphabet = ('a', 'b', 'c', 'd', 'e', 'f', 'g', 'h', 'i', 'j', 'okay', 'l', 'm', 'n', 'o', 'p', 'q', 'r', 's', 't', 'u',
            'v', 'w', 'x', 'y', 'z')

Schritt 2: Fragen Sie die Benutzereingabe an

Der nächste Schritt besteht darin, die Eingabe des Benutzers zu übernehmen. Wir werden den Benutzer fragen:

1. Ob sie eine Nachricht codieren oder dekodieren möchten encode_or_decode
2. Die jeweilige Nachricht secret_message was sie codieren oder dekodieren wollen, und
3. Die Schichtzahl key durch die die Nachricht codiert oder dekodiert wird.

encode_or_decode = enter("Kind 'encode' to encrypt, sort 'decode' to decrypt:n").decrease()
secret_message = enter("Kind your message right here:n").decrease()
key = int(enter("Kind the important thing:n"))

Stellen Sie sicher, dass Sie das konvertieren key in ein int Datentyp, ansonsten können Sie ein Downside beim Verschieben des Buchstabens nach der Anzahl der Schlüssel, da Python die Eingabe als Zeichenfolge und nicht als Ganzzahltyp betrachtet. Denken Sie auch daran, die Benutzereingabe umzuwandeln secret_message Und encode_or_decode Um die Elemente in der Liste Alphabet und bedingte Aussage zu entsprechen, die vorhanden sind.

Schritt 3: Funktionen definieren und den Modulo -Operator verwenden

Der nächste Schritt besteht darin, beide zu definieren encode Und decode Funktionen, die später aufgerufen werden. Der encode Die Funktion wird aufgerufen, wenn der Benutzer in der „codieren“ wählt encode_or_decode Eingabeaufforderung und die decode Die Funktion wird aufgerufen, wenn der Benutzer in der „dekodieren“ encode_or_decode Eingabeaufforderung.

Beide Funktionen sind für den Code recht einfach. Es wird das nehmen secret_messageschaufeln Sie alle Buchstaben durch und für alle Buchstaben in der zuvor definierten Alphabetliste werden die Indexposition eingenommen. Fügen Sie die hinzu key zu ihm und geben Sie das shifted_position. Wir werden das verwenden shifted_position als Index der Buchstaben und fügen Sie sie dem hinzu output_text Welches wird die codierte oder dekodierte Nachricht sein.

Aber wir haben hier ein Downside! Was ist, wenn die Indexposition durch Verschiebung der Buchstaben aus der Alphabetliste verläuft? Nun, die Lösung hierfür ist es, einen interessanten Python -Operator namens ‚The‘ zu verwenden.Modulo‚. Der Modulo ist ein Bediener, der den Relaxation nach der Teilung gibt und durch ‚%‘ in Python symbolisiert wird. Additionally entspricht 8 % 5 3, da 3 der Relaxation nach 8 durch 5 ist.

Wir werden diesen Bediener in unseren Encode- und Dekodierungsfunktionen verwenden. In Anbetracht der Alphabetliste 26 Elemente, und wenn der Benutzer eine Nachricht zum Codieren von „Vampire“ und der Schlüssel als „10“ gibt, fügen wir die Schlüsselnummer der Indexposition von ‚V‘, 22 + 10 = 32 hinzu, wir haben einen Fehler, da in der 32. -Place in der Alphabet -Liste kein Aspect vorhanden ist. Wenn wir jedoch die Alphabetliste nach ‚z‘ von ‚a‘ neu starten möchten, würde das 32. Alphabet auf ‚f‘ fallen, dem 6. Aspect in der Alphabetliste. Der gleiche Buchstaben und die gleiche Indexposition können mit dem Modulo -Operator erreicht werden. Für einen verschobenen Wert von 32 befindet sich der Buchstaben auf der Place von 32 % 26 = 6. Place. Daher werden wir dieselbe Logik für die Codierung unserer Encode- und Dekodierungsfunktionen verwenden.

Hier ist die Encode -Funktion:

def encode(message, keynumber, operation):
    output_text = ""
    for letter in message:
        if letter in alphabet:
            shifted_position = alphabet.index(letter) + keynumber
            shifted_position = shifted_position % len(alphabet)
            output_text = output_text + alphabet(shifted_position)
        else:
            output_text += letter       
    print("Right here is the encoded textual content : ", output_text)

Wenn ich additionally „Ich habe eine Haustierkatze“ mit der Schlüsselnummer ‚6‘ codieren möchte, erhalte ich die folgende codierte Nachricht:

Für die Dekodierungsfunktion müssen wir, da wir dekodieren, die Buchstaben durch die Buchstaben verschieben key In umgekehrter Reihenfolge rückwärts. Wenn ich additionally die obige Nachricht dekodieren möchte: ‚O ngbk g vkz igz‘, muss ich die Schlüsselnummer mit -1 multiplizieren, so dass es anstatt den Schlüssel hinzuzufügen, das subtrahiert die keyund die shifted_position wird erreicht, indem die Indexposition rückwärts verschoben wird.

Definieren Sie die Decode -Funktion:

def decode(message, keynumber, operation):
    keynumber = keynumber * -1
    output_text = ""
    for letter in message:
        if letter in alphabet:
            shifted_position = alphabet.index(letter) + keynumber
            shifted_position = shifted_position % len(alphabet)
            output_text = output_text + alphabet(shifted_position)
        else:
            output_text += letter       
    print("Right here is the decoded textual content : ", output_text)

Hier ist unsere dekodierte Nachricht:

Schritt 4: Aufrufen von Funktionen

Sobald unsere Funktionen definiert sind, werden wir sie bei Bedarf anrufen. Wenn der Benutzer eine Nachricht verschlüsseln möchte, rufen wir das an encode Funktion, und wenn sie eine Nachricht entschlüsseln wollen, werden wir das aufrufen decode Funktion. Implementieren wir dies in unserem Code mit bedingten Anweisungen, wenn, elif und sonst:

if encode_or_decode == 'encode':
    encode(message=secret_message, keynumber=key, operation=encode_or_decode)
elif encode_or_decode == 'decode':
    decode(message=secret_message, keynumber=key, operation=encode_or_decode)
else:
    print("Error")

Schritt 5: Programm Kontinuität

Der letzte Schritt dieses Programms besteht darin, den Benutzer zu fragen, ob er das Programm der Verschlüsselung und Entschlüsselung oder des Endes fortsetzen möchte. Wir werden dies mit einer Variablen implementieren continue_program Das wird zu Beginn zutreffen und bleibt, wenn der Benutzer das Programm fortsetzen möchte. Wenn der Benutzer enden möchte, ändert sich die Variable in False und das Programm endet. Wir werden diesen Zustand in a aufnehmen whereas Schleife, die so lange läuft, wie die Variable bleibt True.

continue_program = True

whereas continue_program:

    encode_or_decode = enter("Kind 'encode' to encrypt, sort 'decode' to decrypt:n").decrease()
    secret_message = enter("Kind your message right here:n").decrease()
    key = int(enter("Kind the important thing:n"))

    if encode_or_decode == 'encode':
        encode(message=secret_message, keynumber=key, operation=encode_or_decode)
    elif encode_or_decode == 'decode':
        decode(message=secret_message, keynumber=key, operation=encode_or_decode)
    else:
        print("Error")
        
    restart = enter("Kind 'sure' if you wish to proceed with this system.nOtherwise, sort 'no'.n").decrease()
    if restart == "no":
        continue_program = False

Abschluss

Mit der Einbeziehung der whereas Schleife oben haben wir das Caesar -Cipher -Programm in Python erfolgreich implementiert. Dieses Projekt untersuchte bedingte Aussagen ifAnwesend elifUnd elseAnwesend for Und whereas Schleifen und Definieren und Anruffunktionen. Darüber hinaus haben wir den Modulo -Operator in dieses Programm eingeführt, um Ausnahmen zu bewältigen.

Sie finden den vollständigen Quellcode dieses Projekts Hier.

Wenn Sie Fragen haben oder einen anderen Ansatz teilen möchten, können Sie diesen Artikel gerne kommentieren. Ich werde mich darauf freuen. Completely happy Coding!

Hangman conflict ein wirklich lustiges Spiel in unserem Zuhause. Wir gingen einen Stift und Papier und wählten abwechselnd Wörter aus, damit der andere erraten konnte. Heute wird es in Klassenzimmer verwendet, um Kindern dabei zu helfen, ihre Schreibweisen zu üben, die strategische Entscheidungsfindung zu verstehen, indem es zuerst Vokale auswählt und mögliche Wörter aus Hinweisen aus dem Brainstorming ausgewählt wird.

In diesem Artikel werden wir das Hangman -Spiel durchlaufen, indem wir es in Python implementieren. Dies ist ein anfängerfreundliches Projekt, bei dem wir die Grundlagen der Python-Sprache lernen, z. B. Variablen, häufig verwendete Funktionen, Schleifen und bedingte Aussagen.

Das Projekt verstehen

Erstens werden wir das Spiel verstehen und uns in die Tiefe eingehen, wie unser Code funktionieren soll.

In einem typischen 2-Spieler-Hangman-Spiel wählt Participant 1 ein Wort, das es vor Spieler 2 versteckt und Blankchen erzeugt, die der Anzahl der Buchstaben in dem Wort, das er für das Erraten ausgewählt hat, entspricht. Spieler 2 muss das Wort erraten, indem er jeweils einen Buchstaben erraten. Spieler 2 hat zu Beginn eine definierte Anzahl von Leben, und mit jeder falschen Vermutung von Buchstaben verlieren sie ein Leben (bis zu dem Punkt, an dem der Mann gehängt ist). Mit jeder richtigen Vermutung bleiben das Leben das gleiche wie zuvor. Wenn Spieler 2 ihr ganzes Leben verliert, ohne das Wort zu erraten, ist das Spiel vorbei und sie verlieren. Wenn sie es schaffen, das Wort zu erraten, gewinnen sie das Spiel. Dies ist der Umriss des Spiels in seinem traditionellen Sinne.

In diesem Projekt ist der Pc Participant 1 und generiert das Wort, um zu erraten, während wir als Benutzer Participant 2 sein werden.

Das Zeichnen eines Flussdiagramms und die Definition jedes Schritts hilft dabei, unseren Denkprozess in Code zu verwandeln. Daher ist es immer eine gute Praxis, einen zu zeichnen. Beginnen wir nun mit der Codierung des Issues!

Schritt 1: Liste der Wörter und des zufälligen Moduls

Der erste Schritt in diesem Projekt besteht darin, dass der Pc ein zufälliges Wort auswählt, das der Benutzer erraten muss. Zu diesem Zweck benötigen wir sowohl eine Liste von Wörtern, aus denen der Pc ein Wort ausweichen soll, das zu erraten ist, als auch eine Python -Funktion, die als zufällig bezeichnet wird und dieses Wort zufällig aus der angegebenen Liste auswählt.

Um die Liste zu generieren, habe ich die 100 häufigsten Substantive in englischer Sprache gegoogelt und a gefunden Liste. Ich habe diese Wörter verwendet und eine Python -Liste erstellt, mit der sie in diesem Projekt verwendet werden soll.

Wie der Title schon sagt, a Python -Liste ist ein Datentyp, der in sich selbst eine Sammlung von Elementen speichert. Eine Liste von Farben wird in Python als definiert colours = ("purple", "yellow", "inexperienced", "blue", "pink"). Sie können die Listensyntax und zusätzliche Informationen von der offiziellen Seite von Python -Offizieller überprüfen Liste.

word_list = (
    "time",
    "yr",
    "individuals",
    "method",
    "day",
    "man",
    "factor",
    ...
    )

Sie können auf die Projektdateien von meinem zugreifen Github Repository. hangman_words.py ist die Python -Datei, die die Liste der Wörter enthält, aus denen der Pc nach dem Zufallsprinzip ein Wort für das Spiel auswählt.

Sobald unsere Liste erstellt wurde, benötigen wir den Pc, um ein zufälliges Wort aus der angegebenen Liste der Wörter auszuwählen word_list. Python hat ein Modul, insbesondere für diesen Zweck namens „zufällig“. Wir werden das Modul importieren und es verwenden, damit der Pc zufällig ein Wort auswählen kann word_to_guess Aus der Liste words_list. Sie können die drucken word_to_guess Während Sie das Projekt codieren, um das Verständnis zu verbessern, und es beim Spielen mit dem Pc aussprechen!

import random
word_to_guess = random.selection(word_list)
print(word_to_guess)

Weitere Informationen zur random.selection() Funktion, klicken Sie Hier.

Schritt 2: Erzeugen von Rohlingen

Der nächste Schritt besteht darin, Rohlinge zu erzeugen, die der Anzahl der Buchstaben in der Buchstaben entspricht word_to_guess Damit der Benutzer eine Vorstellung von der Anzahl der Buchstaben in dem Wort erhält, das er erraten muss. Dafür werden wir eine Variable definieren, die genannt wird blanks die als Container für die ungehörten Buchstaben des Wortes fungieren. Es enthält die Anzahl der „_“ entspricht der Anzahl der Buchstaben in der Buchstaben word_to_guess.

Berechnung der Anzahl der Buchstaben in der word_to_guess das wurde zufällig vom Pc aus dem ausgewählt words_listWir werden die Python -Funktion verwenden len()Das berechnet die Länge einer Zeichenfolge. Weitere Informationen zu dieser eingebauten Funktion können damit zugegriffen werden Hyperlink.

blanks = ""
word_length = len(word_to_guess)

Wie wir jetzt die Anzahl der Buchstaben in kennen word_to_guessWir werden diese Nummer verwenden, um eine gleiche Anzahl von „_“ in der Variablen hinzuzufügen blanks. Zu diesem Zweck werden wir die verwenden for Loop, eine Python -Funktionalität, die es uns ermöglicht, in einer Sequenz über Elemente zu iterieren, in unserem Fall die Zeichenfolge, die in der Variablen gespeichert ist word_to_guess. Klicken Hier mehr darüber erfahren for Schleife und seine Syntax.

for i in vary(word_length):
    blanks = blanks + " _"
print("Phrase to guess: " + blanks)

Der obige Codeblock wird über die Anzahl der Buchstaben in der Buchstaben iteriert word_to_guess String und generieren Sie für jeden Buchstaben einen Leerzeichen. Es wird so viele ausdrucken wie die Anzahl der Buchstaben, jede leere als Platzhalter für den Buchstaben des Wortes zu raten. Für das Wort „Zeit“ ist der auf dem Bildschirm gedruckte Ausgang: lautet:

Wort zu erraten: _ _ _ _

Schritt 3: fordert den Benutzer dazu auf, einen Transient zu erraten

Jetzt beginnt das Spiel tatsächlich! Der Pc hat ein Wort ausgewählt und leere Platzhalter für die Buchstaben in diesem Wort generiert. Jetzt ist die Zeit für den Benutzer, das Wort zu erraten, indem er jeweils einen Buchstaben erraten.

Um den Benutzer um einen Transient zu fragen, werden wir die verwenden enter Funktion in Python und speichern Sie es in der Variablen guess:

guess = enter("Guess a letter").decrease()

Klicken Hier Um mehr über die integrierte Python-integrierte Funktion zu erfahren enter().

Schritt 4: Überprüfen Sie, ob sich der Transient im Wort befindet

Sobald der Benutzer einen Transient erraten hat, werden wir überprüfen, ob der Benutzer ihn richtig erraten hat, und prüfen, ob er sich in der befindet word_to_guess.

Dazu werden wir a verwenden for Schleife. Darüber hinaus werden wir auch eine andere Variable erstellen, your_worddie mit den ersetztem Buchstaben und einer leeren Liste namens aktualisiert wird,letters_guessed Dies speichert die vom Benutzer ordnungsgemäß erratenen Buchstaben (dies wird nützlich sein, wie wir später sehen werden).

Wenn der Pc beispielsweise das Wort „Käsekuchen“ ausgewählt hat, im Laufe des Spiels und der Benutzer die Buchstaben „C“, „E“ und „A“ erraten hat, ist dies beides, was beides ist your_word Und letters_guessed würde aussehen wie:

your_word = c_ee_eca_e

letters_gued = („c“, „e“, „a“)

letters_guessed = ()
your_word = ""

for letter in word_to_guess:
    if letter == guess:
        your_word  = your_word + letter
        letters_guessed.append(guess)
    elif letter in letters_guessed:
        your_word  = your_word + letter
    else:
        your_word = your_word + "_"

Additionally im Grunde was die obige Schleife tut, ist, dass es durch die iteriert word_to_guess ein Buchstaben nach dem anderen und überprüft:

• Wenn der vom Benutzer erratene Transient erraten guess ist in der word_to_guessDer Code aktualisiert die Variable your_word um den Transient hinzuzufügen, der an seinem angemessenen Ort erraten wird. Wir müssen verstehen, dass in Python Strings tatsächlich eine Abfolge von Zeichen sind und viele Listenfunktionen auch für Zeichenfolgen anwendbar sind. Darüber hinaus werden wir diesen Buchstaben auch der Liste korrekt addieren letters_guessed.
• Wenn der Transient, den der Benutzer erraten hat, guessist in der letters_guessedDies bedeutet letters_guessedaber muss nur den Transient in die hinzufügen your_word an seinem geeigneten Ort.
• Ansonsten, wenn der vom Benutzer erratene Transient nicht in der ist word_to_guessund wird daher nicht in der sein letters_guessedWir werden einfach Blanks erzeugen.

Wenn der obige Code etwas überwältigend erscheint, können Sie einfach die oben genannten für die Schleife ausführen, während Sie die Variablen definieren und jede der Variablen drucken: word_to_guessAnwesend guessAnwesend guessed_lettersUnd your_word und drucken die Variablen, in denen sie geändert werden.

Schritt 5: Erstellen Sie die whilanside Schleife, die bis zum Ende des Spiels läuft

Lassen Sie uns auf das von uns erstellte Flussdiagramm zurückgreifen, um das Projekt zu verstehen. Um dieses Projekt zu codieren, müssen wir die folgenden Punkte berücksichtigen:

• Der Benutzer hat zu Beginn eine definierte Anzahl von Leben
• Für jeden Buchstaben wird das Leben um 1 reduziert
  • Wenn dem Benutzer das Leben ausgeht, verliert der Benutzer und das Spiel ist vorbei
  • Wenn der Benutzer Leben übrig hat, bittet der Pc den Benutzer, einen anderen Transient zu erraten
• Für jeden Buchstaben bleiben das Leben unverändert und eine Lücke wird durch einen Buchstaben im Platzhalter ersetzt blanks
  • Wenn die Variable your_word ist alles gefüllt, der Benutzer gewinnt das Spiel und das Spiel ist vorbei
  • Wenn die Variable <code>your_word Hat leere Leerzeichen übrig, dann wird der Pc den Benutzer erneut auffordert, den nächsten Transient zu erraten

Da haben wir das geschaffen for Zuvor ist die Schleife, die den ersetztem Transient richtet, jetzt die Zeit, die Idee des Lebens einzubeziehen und ihn zu reduzieren, wenn der Benutzer einen Transient falsch erraten hat.

Lassen Sie uns die Anzahl der Leben für den Benutzer mit der Variablen definieren number_of_lives. Der Benutzer hat 6 Chancen, den falschen Buchstaben vorzuschlagen, um das Wort zu erraten.

number_of_lives = 6

In Anbetracht der oben genannten Punkte benötigen wir nun auch eine Variable oder eine Bedingung, die uns aufweist, den Benutzer zu bitten, zu erraten, wann das Spiel vorbei ist. Lassen Sie es uns mit Hilfe einer booleschen Variablen codieren.

Einfach angeben, ein Boolescher ist ein Datenatyp in Python, der entweder True oder False speichert. Wir werden diese boolesche Variable verwenden, um das Spiel fortzusetzen, während es falsch ist und umgekehrt. Anfänglich, während das Spiel beginnt, wird diese Variable sein Falsewas bedeutet, dass das Spiel noch nicht vorbei ist.

game_over = False

Jetzt werden wir eine vorstellen whereas Schleifen Sie mit der Bedingung, dass es so lange läuft, wie das Spiel nicht vorbei ist, und wir werden die oben genannten Bedingungen in dieser Schleife enthalten. Schauen Sie sich mehr über die whereas Schleife aus der offiziellen Dokumentation von Python Hier.

whereas not recreation over:
     print("nYou have ", number_of_lives, " lives remaining!")
     guess = enter("Guess a letter: ").decrease()

     your_word = ""

     for letter in word_to_guess:
        if letter == guess:
            your_word  = your_word + letter
            letters_guessed.append(guess)
        elif letter in letters_guessed:
            your_word  = your_word + letter
        else:
            your_word = your_word + "_"
     print("Phrase to guess: ", your_word)

Im obigen Code haben wir sowohl die Eingabeanweisung als auch die Druckanweisung hinzugefügt, die die bisher gemessenen Buchstaben nach ihrer Place in der Ausgabe ausgibt word_to_guess.

Schritt 6: Umgangssituationen

Der letzte Schritt besteht darin, verschiedene Umstände zu bewältigen. Was passiert, wenn der Buchstabe, den der Benutzer erraten hat, vom Benutzer bereits vorgeschlagen wurde oder der Transient nicht im Wort ist? Was ist, wenn alle Briefe erraten wurden und es keine Blankchen mehr gibt your_word? Dies würde bedeuten, dass der Benutzer das Wort erraten und so gewonnen hat.

Wir werden diese Scenario im Code mit den folgenden Zeilen hinzufügen:

if guess in letters_guessed:
    print(f"nYou've already guessed {guess}")

if "_" not in your_word:
    game_over = True
    print("nYou have guessed the phrase! YOU WIN!")

Darüber hinaus, wenn der vom Benutzer erratene Transient nicht in der ist word_to_guessDie Vermutung des Benutzers ist falsch, dann wird ihr Leben um 1 reduziert, und wir werden den Benutzer darüber informieren, dass sein erratener Transient nicht im Wort ist. Wenn das Leben durch eine falsche Vermutung das Leben des Benutzers beendet, dann ist unsere booleale Variable game_over wird als True Und das Spiel endet, wobei der Benutzer das Spiel verliert.

if guess not in word_to_guess:
    number_of_lives -= 1
    print(f"nYou guessed {guess}, that is not within the phrase. You lose a life.")

    if number_of_lives == 0:
        game_over = True
        print(f"nIT WAS {word_to_guess}! YOU LOSE!")

Denken Sie daran, die oben genannten Codeblöcke in die hinzuzufügen whereas Schleife, die läuft, bis das Spiel noch nicht vorbei ist. Ein vollständiger Code zusammen mit wertvollen Kommentaren kann über dieses Github -Repository für ein besseres Verständnis zugegriffen werden.

Abschluss

Das obige Codierungsprojekt wurde mit den Grundlagen der Python -Sprache durchgeführt. Wir sind auf einige eingebaute Funktionen gestoßen print()Und enter()Wir haben die benutzt random Modul, um zufällige Wörter zu erraten und zu verwenden for Und whereas Schleifen in verschiedenen Iterationen nach Bedarf. Wir haben auch die bedingte durchgesehen ifAnwesend elif Und else Aussagen. Dies sind alle grundlegenden Werkzeuge, die jeder Anfänger kennen muss, bevor er in eine komplexe Codierung springen. Wir hätten auch Funktionen in diesem Programm definieren und aufgerufen haben, aber dies sollte eine anfängerfreundliche Einführung in die Python-Sprache sein. Wenn Sie ein Profi in Python sind, können Sie verschiedene andere Möglichkeiten teilen, die wir uns an dieses Projekt hätten wenden können!