Bild vom Autor

# Einführung

Arbeiten mit JSON in Python ist oft eine Herausforderung. Das Grundlegende json.hundreds() bringt dich nur so weit.

API-Antworten, Konfigurationsdateien und Datenexporte enthalten häufig JSON, das chaotisch oder schlecht strukturiert ist. Sie müssen verschachtelte Objekte reduzieren und Werte ohne sie sicher extrahieren Schlüsselfehler Ausnahmen, mehrere JSON-Dateien zusammenführen oder zwischen JSON und anderen Formaten konvertieren. Diese Aufgaben fallen beim Internet Scraping, der API-Integration und der Datenverarbeitung ständig an. Dieser Artikel führt Sie durch fünf praktische Funktionen zur Handhabung gängiger JSON-Parsing- und -Verarbeitungsaufgaben.

Den Code für diese Funktionen finden Sie unter GitHub.

# 1. Verschachtelte Werte sicher extrahieren

JSON-Objekte sind oft mehrere Ebenen tief verschachtelt. Der Zugriff auf tief verschachtelte Werte mit Klammernotation wird schnell zu einer Herausforderung. Sollte ein Schlüssel fehlen, erhalten Sie einen Schlüsselfehler.

Hier ist eine Funktion, mit der Sie mithilfe der Punktnotation auf verschachtelte Werte zugreifen können, mit einem Fallback für fehlende Schlüssel:

def get_nested_value(information, path, default=None):
    """
    Safely extract nested values from JSON utilizing dot notation.

    Args:
        information: Dictionary or JSON object
        path: Dot-separated string like "person.profile.e-mail"
        default: Worth to return if path does not exist

    Returns:
        The worth on the path, or default if not discovered
    """
    keys = path.cut up('.')
    present = information

    for key in keys:
        if isinstance(present, dict):
            present = present.get(key)
            if present is None:
                return default
        elif isinstance(present, checklist):
            strive:
                index = int(key)
                present = present(index)
            besides (ValueError, IndexError):
                return default
        else:
            return default

    return present

Testen wir es mit einer komplexen verschachtelten Struktur:

# Pattern JSON information
user_data = {
    "person": {
        "id": 123,
        "profile": {
            "title": "Allie",
            "e-mail": "allie@instance.com",
            "settings": {
                "theme": "darkish",
                "notifications": True
            }
        },
        "posts": (
            {"id": 1, "title": "First Publish"},
            {"id": 2, "title": "Second Publish"}
        )
    }
}

# Extract values
e-mail = get_nested_value(user_data, "person.profile.e-mail")
theme = get_nested_value(user_data, "person.profile.settings.theme")
first_post = get_nested_value(user_data, "person.posts.0.title")
lacking = get_nested_value(user_data, "person.profile.age", default=25)

print(f"Electronic mail: {e-mail}")
print(f"Theme: {theme}")
print(f"First put up: {first_post}")
print(f"Age (default): {lacking}")

Ausgabe:

Electronic mail: allie@instance.com
Theme: darkish
First put up: First Publish
Age (default): 25

Die Funktion teilt die Pfadzeichenfolge in Punkte auf und durchläuft die Datenstruktur Schlüssel für Schlüssel. Auf jeder Ebene wird geprüft, ob der aktuelle Wert ein Wörterbuch oder eine Liste ist. Für Wörterbücher verwendet es .get(key)was zurückkommt None für fehlende Schlüssel, anstatt einen Fehler auszulösen. Bei Hear wird versucht, den Schlüssel in einen ganzzahligen Index umzuwandeln.

Der default Der Parameter bietet einen Fallback, wenn ein Teil des Pfads nicht vorhanden ist. Dies verhindert, dass Ihr Code abstürzt, wenn Sie unvollständige oder inkonsistente JSON-Daten von APIs verarbeiten.

Dieses Muster ist besonders nützlich bei der Verarbeitung von API-Antworten, bei denen einige Felder non-compulsory sind oder nur unter bestimmten Bedingungen vorhanden sind.

# 2. Reduzieren von verschachteltem JSON in einstufige Wörterbücher

Modelle für maschinelles Lernen, CSV-Exporte und Datenbankeinfügungen erfordern häufig flache Datenstrukturen. Aber API-Antworten und Konfigurationsdateien verwenden verschachteltes JSON. Das Konvertieren verschachtelter Objekte in flache Schlüssel-Wert-Paare ist eine häufige Aufgabe.

Hier ist eine Funktion, die verschachteltes JSON mit anpassbaren Trennzeichen flacher macht:

def flatten_json(information, parent_key='', separator="_"):
    """
    Flatten nested JSON right into a single-level dictionary.

    Args:
        information: Nested dictionary or JSON object
        parent_key: Prefix for keys (utilized in recursion)
        separator: String to affix nested keys

    Returns:
        Flattened dictionary with concatenated keys
    """
    gadgets = ()

    if isinstance(information, dict):
        for key, worth in information.gadgets():
            new_key = f"{parent_key}{separator}{key}" if parent_key else key

            if isinstance(worth, dict):
                # Recursively flatten nested dicts
                gadgets.lengthen(flatten_json(worth, new_key, separator).gadgets())
            elif isinstance(worth, checklist):
                # Flatten lists with listed keys
                for i, merchandise in enumerate(worth):
                    list_key = f"{new_key}{separator}{i}"
                    if isinstance(merchandise, (dict, checklist)):
                        gadgets.lengthen(flatten_json(merchandise, list_key, separator).gadgets())
                    else:
                        gadgets.append((list_key, merchandise))
            else:
                gadgets.append((new_key, worth))
    else:
        gadgets.append((parent_key, information))

    return dict(gadgets)

Lassen Sie uns nun eine komplexe verschachtelte Struktur reduzieren:

# Complicated nested JSON
product_data = {
    "product": {
        "id": 456,
        "title": "Laptop computer",
        "specs": {
            "cpu": "Intel i7",
            "ram": "16GB",
            "storage": {
                "sort": "SSD",
                "capability": "512GB"
            }
        },
        "opinions": (
            {"ranking": 5, "remark": "Glorious"},
            {"ranking": 4, "remark": "Good worth"}
        )
    }
}

flattened = flatten_json(product_data)

for key, worth in flattened.gadgets():
    print(f"{key}: {worth}")

Ausgabe:

product_id: 456
product_name: Laptop computer
product_specs_cpu: Intel i7
product_specs_ram: 16GB
product_specs_storage_type: SSD
product_specs_storage_capacity: 512GB
product_reviews_0_rating: 5
product_reviews_0_comment: Glorious
product_reviews_1_rating: 4
product_reviews_1_comment: Good worth

Die Funktion verwendet Rekursion, um beliebige Verschachtelungstiefen zu verarbeiten. Wenn es auf ein Wörterbuch stößt, verarbeitet es jedes Schlüssel-Wert-Paar und erstellt den abgeflachten Schlüssel, indem es die übergeordneten Schlüssel mit dem Trennzeichen verkettet.

Bei Hear wird der Index als Teil des Schlüssels verwendet. Dadurch können Sie die Reihenfolge und Struktur der Array-Elemente in der reduzierten Ausgabe beibehalten. Das Muster reviews_0_rating sagt Ihnen, dass dies die Bewertung aus der ersten Bewertung ist.

Der separator Mit dem Parameter können Sie das Ausgabeformat anpassen. Verwenden Sie je nach Bedarf Punkte für die Punktnotation, Unterstriche für „snake_case“ oder Schrägstriche für pfadähnliche Schlüssel.

Diese Funktion ist besonders nützlich, wenn Sie JSON-API-Antworten in Datenrahmen oder CSV-Zeilen konvertieren müssen, in denen jede Spalte einen eindeutigen Namen benötigt.

# 3. Deep Merge mehrerer JSON-Objekte

Für die Konfigurationsverwaltung müssen häufig mehrere JSON-Dateien zusammengeführt werden, die Standardeinstellungen, umgebungsspezifische Konfigurationen, Benutzereinstellungen und mehr enthalten. Ein einfaches dict.replace() Behandelt nur die oberste Ebene. Sie benötigen eine tiefe Zusammenführung, die verschachtelte Strukturen rekursiv kombiniert.

Hier ist eine Funktion, die JSON-Objekte tief zusammenführt:

def deep_merge_json(base, override):
    """
    Deep merge two JSON objects, with override taking priority.

    Args:
        base: Base dictionary
        override: Dictionary with values to override/add

    Returns:
        New dictionary with merged values
    """
    end result = base.copy()

    for key, worth in override.gadgets():
        if key in end result and isinstance(end result(key), dict) and isinstance(worth, dict):
            # Recursively merge nested dictionaries
            end result(key) = deep_merge_json(end result(key), worth)
        else:
            # Override or add the worth
            end result(key) = worth

    return end result

Versuchen wir, Beispielkonfigurationsinformationen zusammenzuführen:

import json

# Default configuration
default_config = {
    "database": {
        "host": "localhost",
        "port": 5432,
        "timeout": 30,
        "pool": {
            "min": 2,
            "max": 10
        }
    },
    "cache": {
        "enabled": True,
        "ttl": 300
    },
    "logging": {
        "stage": "INFO"
    }
}

# Manufacturing overrides
prod_config = {
    "database": {
        "host": "prod-db.instance.com",
        "pool": {
            "min": 5,
            "max": 50
        }
    },
    "cache": {
        "ttl": 600
    },
    "monitoring": {
        "enabled": True
    }
}

merged = deep_merge_json(default_config, prod_config)

print(json.dumps(merged, indent=2))

Ausgabe:

{
  "database": {
    "host": "prod-db.instance.com",
    "port": 5432,
    "timeout": 30,
    "pool": {
      "min": 5,
      "max": 50
    }
  },
  "cache": {
    "enabled": true,
    "ttl": 600
  },
  "logging": {
    "stage": "INFO"
  },
  "monitoring": {
    "enabled": true
  }
}

Die Funktion führt verschachtelte Wörterbücher rekursiv zusammen. Wenn sowohl die Foundation als auch die Überschreibung Wörterbücher mit demselben Schlüssel enthalten, werden diese Wörterbücher zusammengeführt, anstatt sie vollständig zu ersetzen. Dadurch bleiben Werte erhalten, die nicht explizit überschrieben werden.

Beachten Sie, wie database.port Und database.timeout bleiben von der Standardkonfiguration, während database.host wird überschrieben. Die Pooleinstellungen werden additionally auf der verschachtelten Ebene zusammengeführt min Und max beide werden aktualisiert.

Die Funktion fügt auch neue Schlüssel hinzu, die in der Basiskonfiguration nicht vorhanden sind, wie z monitoring Abschnitt in der Produktionsüberschreibung.

Sie können mehrere Zusammenführungen zu Layer-Konfigurationen verketten:

final_config = deep_merge_json(
    deep_merge_json(default_config, prod_config),
    user_preferences
)

Dieses Muster kommt häufig in der Anwendungskonfiguration vor, wo Sie über Standardwerte, umgebungsspezifische Einstellungen und Laufzeitüberschreibungen verfügen.

# 4. JSON nach Schema oder Whitelist filtern

APIs geben oft mehr Daten zurück, als Sie benötigen. Große JSON-Antworten erschweren die Lesbarkeit Ihres Codes. Manchmal möchten Sie nur bestimmte Felder oder müssen vor der Protokollierung vertrauliche Daten entfernen.

Hier ist eine Funktion, die JSON filtert, um nur bestimmte Felder beizubehalten:

def filter_json(information, schema):
    """
    Filter JSON to maintain solely fields laid out in schema.

    Args:
        information: Dictionary or JSON object to filter
        schema: Dictionary defining which fields to maintain
                Use True to maintain a discipline, nested dict for nested filtering

    Returns:
        Filtered dictionary containing solely specified fields
    """
    if not isinstance(information, dict) or not isinstance(schema, dict):
        return information

    end result = {}

    for key, worth in schema.gadgets():
        if key not in information:
            proceed

        if worth is True:
            # Maintain this discipline as-is
            end result(key) = information(key)
        elif isinstance(worth, dict):
            # Recursively filter nested object
            if isinstance(information(key), dict):
                filtered_nested = filter_json(information(key), worth)
                if filtered_nested:
                    end result(key) = filtered_nested
            elif isinstance(information(key), checklist):
                # Filter every merchandise within the checklist
                filtered_list = ()
                for merchandise in information(key):
                    if isinstance(merchandise, dict):
                        filtered_item = filter_json(merchandise, worth)
                        if filtered_item:
                            filtered_list.append(filtered_item)
                    else:
                        filtered_list.append(merchandise)
                if filtered_list:
                    end result(key) = filtered_list

    return end result

Lassen Sie uns eine Beispiel-API-Antwort filtern:

import json
# Pattern API response
api_response = {
    "person": {
        "id": 789,
        "username": "Cayla",
        "e-mail": "cayla@instance.com",
        "password_hash": "secret123",
        "profile": {
            "title": "Cayla Smith",
            "bio": "Software program developer",
            "avatar_url": "https://instance.com/avatar.jpg",
            "private_notes": "Inside notes"
        },
        "posts": (
            {
                "id": 1,
                "title": "Hi there World",
                "content material": "My first put up",
                "views": 100,
                "internal_score": 0.85
            },
            {
                "id": 2,
                "title": "Python Suggestions",
                "content material": "Some ideas",
                "views": 250,
                "internal_score": 0.92
            }
        )
    },
    "metadata": {
        "request_id": "abc123",
        "server": "web-01"
    }
}

# Schema defining what to maintain
public_schema = {
    "person": {
        "id": True,
        "username": True,
        "profile": {
            "title": True,
            "avatar_url": True
        },
        "posts": {
            "id": True,
            "title": True,
            "views": True
        }
    }
}

filtered = filter_json(api_response, public_schema)

print(json.dumps(filtered, indent=2))

Ausgabe:

{
  "person": {
    "id": 789,
    "username": "Cayla",
    "profile": {
      "title": "Cayla Smith",
      "avatar_url": "https://instance.com/avatar.jpg"
    },
    "posts": (
      {
        "id": 1,
        "title": "Hi there World",
        "views": 100
      },
      {
        "id": 2,
        "title": "Python Suggestions",
        "views": 250
      }
    )
  }
}

Das Schema fungiert als Whitelist. Ein Feld festlegen auf True schließt es in die Ausgabe ein. Mithilfe eines verschachtelten Wörterbuchs können Sie verschachtelte Objekte filtern. Die Funktion wendet das Schema rekursiv auf verschachtelte Strukturen an.

Bei Arrays gilt das Schema für jedes Aspect. Im Beispiel wird das Posts-Array gefiltert, sodass jeder Publish nur Folgendes enthält: id, titleUnd viewswährend content material Und internal_score sind ausgeschlossen.

Beachten Sie, wie sensibel Felder sind password_hash Und private_notes erscheinen nicht in der Ausgabe. Dies macht die Funktion nützlich, um Daten vor der Protokollierung oder dem Senden an Frontend-Anwendungen zu bereinigen.

Sie können verschiedene Schemata für verschiedene Anwendungsfälle erstellen, z. B. ein Minimalschema für Listenansichten, ein detailliertes Schema für Einzelelementansichten und ein Admin-Schema, das alles umfasst.

# 5. Konvertieren von JSON in und aus der Punktnotation

Einige Systeme verwenden flache Schlüsselwertspeicher, Sie möchten jedoch mit verschachteltem JSON in Ihrem Code arbeiten. Dies lässt sich durch die Konvertierung zwischen flachen Punktnotationsschlüsseln und verschachtelten Strukturen erreichen.

Hier ist ein Funktionspaar für die bidirektionale Konvertierung.

// Konvertieren von JSON in Punktnotation

def json_to_dot_notation(information, parent_key=''):
    """
    Convert nested JSON to flat dot-notation dictionary.

    Args:
        information: Nested dictionary
        parent_key: Prefix for keys (utilized in recursion)

    Returns:
        Flat dictionary with dot-notation keys
    """
    gadgets = {}

    if isinstance(information, dict):
        for key, worth in information.gadgets():
            new_key = f"{parent_key}.{key}" if parent_key else key

            if isinstance(worth, dict):
                gadgets.replace(json_to_dot_notation(worth, new_key))
            else:
                gadgets(new_key) = worth
    else:
        gadgets(parent_key) = information

    return gadgets

// Konvertieren der Punktnotation in JSON

def dot_notation_to_json(flat_data):
    """
    Convert flat dot-notation dictionary to nested JSON.

    Args:
        flat_data: Dictionary with dot-notation keys

    Returns:
        Nested dictionary
    """
    end result = {}

    for key, worth in flat_data.gadgets():
        elements = key.cut up('.')
        present = end result

        for i, half in enumerate(elements(:-1)):
            if half not in present:
                present(half) = {}
            present = present(half)

        present(elements(-1)) = worth

    return end result

Testen wir die Spherical-Journey-Konvertierung:

import json
# Authentic nested JSON
config = {
    "app": {
        "title": "MyApp",
        "model": "1.0.0"
    },
    "database": {
        "host": "localhost",
        "credentials": {
            "username": "admin",
            "password": "secret"
        }
    },
    "options": {
        "analytics": True,
        "notifications": False
    }
}

# Convert to dot notation (for atmosphere variables)
flat = json_to_dot_notation(config)
print("Flat format:")
for key, worth in flat.gadgets():
    print(f"  {key} = {worth}")

print("n" + "="*50 + "n")

# Convert again to nested JSON
nested = dot_notation_to_json(flat)

print("Nested format:")
print(json.dumps(nested, indent=2))

Ausgabe:

Flat format:
  app.title = MyApp
  app.model = 1.0.0
  database.host = localhost
  database.credentials.username = admin
  database.credentials.password = secret
  options.analytics = True
  options.notifications = False

==================================================

Nested format:
{
  "app": {
    "title": "MyApp",
    "model": "1.0.0"
  },
  "database": {
    "host": "localhost",
    "credentials": {
      "username": "admin",
      "password": "secret"
    }
  },
  "options": {
    "analytics": true,
    "notifications": false
  }
}

Der json_to_dot_notation Die Funktion flacht die Struktur ab, indem sie rekursiv durch verschachtelte Wörterbücher geht und Schlüssel mit Punkten verbindet. Im Gegensatz zur früheren Flatten-Funktion verarbeitet diese keine Arrays; Es ist für Konfigurationsdaten optimiert, bei denen es sich ausschließlich um Schlüsselwerte handelt.

Der dot_notation_to_json Funktion kehrt den Prozess um. Es teilt jeden Schlüssel in Punkte auf und baut die verschachtelte Struktur auf, indem es nach Bedarf Zwischenwörterbücher erstellt. Die Schleife verarbeitet alle Teile außer dem letzten und erstellt Verschachtelungsebenen. Dann weist es den Wert dem letzten Schlüssel zu.

Durch diesen Ansatz bleibt Ihre Konfiguration lesbar und wartbar, während gleichzeitig die Einschränkungen flacher Schlüsselwertsysteme eingehalten werden.

# Zusammenfassung

Die JSON-Verarbeitung geht über das Grundlegende hinaus json.hundreds(). In den meisten Projekten benötigen Sie Werkzeuge zum Navigieren in verschachtelten Strukturen, zum Transformieren von Formen, zum Zusammenführen von Konfigurationen, zum Filtern von Feldern und zum Konvertieren zwischen Formaten.

Die Techniken in diesem Artikel lassen sich auch auf andere Datenverarbeitungsaufgaben übertragen. Sie können diese Muster für XML, YAML oder benutzerdefinierte Datenformate ändern.

Beginnen Sie mit der sicheren Zugriffsfunktion, um KeyError-Ausnahmen in Ihrem Code zu verhindern. Fügen Sie die anderen hinzu, wenn Sie auf spezifische Anforderungen stoßen. Viel Spaß beim Codieren!

Bala Priya C ist ein Entwickler und technischer Redakteur aus Indien. Sie arbeitet gerne an der Schnittstelle von Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Zu ihren Interessen- und Fachgebieten gehören DevOps, Datenwissenschaft und Verarbeitung natürlicher Sprache. Sie liebt es zu lesen, zu schreiben, zu programmieren und Kaffee zu trinken! Derzeit arbeitet sie daran, zu lernen und ihr Wissen mit der Entwickler-Group zu teilen, indem sie Tutorials, Anleitungen, Meinungsbeiträge und mehr verfasst. Bala erstellt außerdem ansprechende Ressourcenübersichten und Programmier-Tutorials.

Bild vom Herausgeber

# Einführung

Dask ist eine Reihe von Paketen, die parallele Rechenfunktionen nutzen – äußerst nützlich bei der Verarbeitung großer Datenmengen oder beim Erstellen effizienter, datenintensiver Anwendungen wie fortschrittlicher Analyse- und maschineller Lernsysteme. Zu den hervorstechendsten Vorteilen gehört die nahtlose Integration von Dask in bestehende Python-Frameworks, einschließlich der Unterstützung für die gleichzeitige Verarbeitung großer Datenmengen scikit-lernen Module durch parallelisierte Arbeitsabläufe. In diesem Artikel erfahren Sie, wie Sie Dask für eine skalierbare Datenverarbeitung nutzen können, selbst unter begrenzten {Hardware}-Einschränkungen.

# Schritt-für-Schritt-Anleitung

Obwohl es nicht besonders massiv ist, ist das Datensatz zum kalifornischen Wohnungsbau ist relativ groß und daher eine gute Wahl für ein einfaches, anschauliches Codierungsbeispiel, das zeigt, wie Dask und scikit-learn gemeinsam für die Datenverarbeitung in großem Maßstab genutzt werden können.

Dask bietet eine dataframe Modul, das viele Aspekte der Pandas nachahmt DataFrame Objekte zur Verarbeitung großer Datenmengen, die möglicherweise nicht vollständig in den Speicher passen. Wir werden dieses Dask verwenden DataFrame Struktur zum Laden unserer Daten aus einer CSV in ein GitHub-Repository wie folgt:

import dask.dataframe as dd

url = "https://uncooked.githubusercontent.com/gakudo-ai/open-datasets/refs/heads/major/housing.csv"
df = dd.read_csv(url)

df.head()

Hier ein wichtiger Hinweis. Wenn Sie die „Type“ des Datensatzes sehen möchten – die Anzahl der Zeilen und Spalten – ist die Methode etwas schwieriger als nur die Verwendung df.form. Stattdessen sollten Sie Folgendes tun:

num_rows = df.form(0).compute()
num_cols = df.form(1)
print(f"Variety of rows: {num_rows}")
print(f"Variety of columns: {num_cols}")

Ausgabe:

Variety of rows: 20640
Variety of columns: 10

Beachten Sie, dass wir Dasks verwendet haben compute() um träge die Anzahl der Zeilen zu berechnen, aber nicht die Anzahl der Spalten. Die Metadaten des Datensatzes ermöglichen es uns, die Anzahl der Spalten (Merkmale) sofort zu ermitteln, wohingegen die Bestimmung der Anzahl der Zeilen in einem Datensatz, die (hypothetisch) größer als der Speicher – und somit partitioniert – sein könnten, eine verteilte Berechnung erfordert: etwas, das compute() wickelt für uns clear ab.

Datenvorverarbeitung ist meist ein vorheriger Schritt zum Aufbau eines Modells oder Schätzers für maschinelles Lernen. Bevor wir zu diesem Teil übergehen und da der Schwerpunkt dieses praktischen Artikels darauf liegt, zu zeigen, wie Dask zur Verarbeitung von Daten verwendet werden kann, bereinigen und bereiten wir es vor.

Ein häufiger Schritt bei der Datenaufbereitung ist Umgang mit fehlenden Werten. Mit Dask ist der Prozess so nahtlos, als ob wir nur Pandas verwenden würden. Der folgende Code entfernt beispielsweise Zeilen für Instanzen, die fehlende Werte in einem ihrer Attribute enthalten:

df = df.dropna()

num_rows = df.form(0).compute()
num_cols = df.form(1)
print(f"Variety of rows: {num_rows}")
print(f"Variety of columns: {num_cols}")

Jetzt wurde der Datensatz um über 200 Instanzen reduziert und umfasst insgesamt 20433 Zeilen.

Als Nächstes können wir einige numerische Merkmale im Datensatz skalieren, indem wir Scikit-Learns integrieren StandardScaler oder irgendein anderes geeignetes Skalierungsmethode:

from sklearn.preprocessing import StandardScaler

numeric_df = df.select_dtypes(embrace=("quantity"))
X_pd = numeric_df.drop("median_house_value", axis=1).compute()

scaler = StandardScaler()
X_scaled = scaler.fit_transform(X_pd)

Beachten Sie vor allem, dass wir in Dask eine Folge von datensatzintensiven Vorgängen ausführen, z. B. das Löschen von Zeilen mit fehlenden Werten und das anschließende Löschen der Zielspalte "median_house_value"müssen wir hinzufügen compute() am Ende der Folge verketteter Operationen. Das liegt daran Datensatztransformationen in Dask werden träge durchgeführt. Einmal compute() aufgerufen wird, wird das Ergebnis der verketteten Transformation des Datensatzes als Pandas materialisiert DataFrame (Dask hängt von Pandas ab, daher müssen Sie die Pandas-Bibliothek nicht explizit in Ihren Code importieren, es sei denn, Sie rufen direkt eine Pandas-exklusive Funktion auf.)

Was ist, wenn wir wollen? Trainieren Sie ein Modell für maschinelles Lernen? Dann sollten wir die Zielvariable extrahieren "median_house_value" und wenden Sie dasselbe Prinzip an, um es in ein Pandas-Objekt zu konvertieren:

y = df("median_house_value")
y_pd = y.compute()

Von nun an besteht der Prozess darin, den Datensatz in Trainings- und Testsätze aufzuteilen und ein Regressionsmodell zu trainieren RandomForestRegressorund die Bewertung seines Fehlers anhand der Testdaten ähnelt vollständig einem traditionellen Ansatz, bei dem Pandas und Scikit-Be taught auf orchestrierte Weise verwendet werden. Da baumbasierte Modelle unempfindlich gegenüber der Function-Skalierung sind, können Sie entweder die unskalierten Options (X_pd) oder die skalierten (X_scaled). Im Folgenden fahren wir mit den oben berechneten skalierten Merkmalen fort:

from sklearn.model_selection import train_test_split
from sklearn.ensemble import RandomForestRegressor
from sklearn.metrics import mean_squared_error
import numpy as np

# Use the scaled function matrix produced earlier
X_train, X_test, y_train, y_test = train_test_split(X_scaled, y_pd, test_size=0.2, random_state=42)

mannequin = RandomForestRegressor(n_estimators=100, random_state=42, n_jobs=-1)
mannequin.match(X_train, y_train)

y_pred = mannequin.predict(X_test)
mse = mean_squared_error(y_test, y_pred)
rmse = np.sqrt(mse)
print(f"RMSE: {rmse:.2f}")

Ausgabe:

# Zusammenfassung

Dask und scikit-learn können zusammen verwendet werden, um skalierbare, parallelisierte Datenverarbeitungsabläufe zu nutzen, um beispielsweise große Datensätze für die Erstellung von Modellen für maschinelles Lernen effizient vorzuverarbeiten. In diesem Artikel wurde gezeigt, wie man Daten mit Dask lädt, bereinigt, vorbereitet und transformiert und anschließend Commonplace-Scikit-Be taught-Instruments für die Modellierung maschinellen Lernens anwendet – und das alles bei gleichzeitiger Optimierung der Speichernutzung und Beschleunigung der Pipeline bei der Verarbeitung großer Datenmengen.

Iván Palomares Carrascosa ist führend, Autor, Redner und Berater in den Bereichen KI, maschinelles Lernen, Deep Studying und LLMs. Er schult und leitet andere darin, KI in der realen Welt zu nutzen.

Bild von Editor | Chatgpt

# Einführung

Natürliche Sprachverarbeitung (NLP) ist ein Studienbereich, das sich auf die Verarbeitung und Verständnis menschlicher Textdaten konzentriert. NLP ist seit langem eine beliebte Anwendung des maschinellen Lernens, aber seine Popularität nahm mit dem Aufstieg der generativen KI, insbesondere der transformatorbasierten Sprachmodelle, erheblich zu.

Derzeit befinden wir uns in einer Part, in der NLP von Transformatoren und Sprachmodellen dominiert wird. Im Jahr 2026 wird das Gespräch jedoch mehr als nur diese umfassen. Wir werden eine Verschiebung zu neuen Ideen sehen.

In diesem Artikel diskutieren wir fünf modernste NLP-Traits, die 2026 beeinflussen.

# 1. Effiziente Aufmerksamkeitsmechanismen

Der Transformator -Development in NLP hat die Szene dank seines Erfolgs in Sprachmodellen dominiert. Die größte Schwäche der Transformatoren bleibt jedoch die hohe Berechnung und den Gedächtnisverbrauch der Selbstbekämpfung. Wenn die Eingangssequenzen länger wachsen, skalieren die Anforderungen schnell, sodass es schwierig ist, größere Eingänge zu verarbeiten. Deshalb werden effiziente Aufmerksamkeitsmechanismen zu einem Development, den Sie 2026 nicht verpassen sollten.

Effiziente Aufmerksamkeitsmethoden verändern, wie die Triebwerke durch Verringerung der Komplexität miteinander umgehen. Es wurden Ansätze wie lineare Aufmerksamkeit und spärliche Aufmerksamkeit entwickelt, um diesen Bereich voranzutreiben. Diese Ansätze zielen darauf ab, Modelle viel längere Kontexte zu verarbeiten, ohne durch Hardwarebeschränkungen Engpässe zu erzielen.

Zu den Forschungsbereichen für effiziente Aufmerksamkeit, die es wert ist, erkunden zu werden, gehören LinformatorAnwesend RedegineUnd HYDRAREC. Diese Studien zeigen, dass mehrere Ansätze die Aufmerksamkeit effizienter machen können.

Insgesamt verbessert sich effiziente Aufmerksamkeitsmechanismen schnell und werden 2026 etwas zu beobachten. Ihre Anwendung wird einen großflächigen NLP erschwinglicher und nachhaltiger machen und gleichzeitig durch die Kosten begrenzte Durchbrüche ermöglichen.

# 2. Autonome Sprachagenten

Autonome Sprachmittel sind KI-Systeme, die mit minimaler Aufsicht planen, Maßnahmen ergreifen und mehrstufige Aufgaben erledigen können. Dies stieg im Jahr 2025 an und wird wahrscheinlich die NLP-Landschaft im Jahr 2026 prägen. Da diese Agenten Gedächtnis, Argumentation und Instruments kombinieren, um Ziele von Finish-to-Finish zu erreichen, sollen sie von Unternehmen weit verbreitet werden.

Wenn wir beispielsweise einen Agenten auffordern, eine Abfrage wie „Umsatz analysieren und den Bericht des letzten Quartals analysieren“ zu bearbeiten, kann dies Verkaufsdaten abrufen, Berechnungen ausführen, Diagramme erstellen und eine schriftliche Zusammenfassung erstellen. Im Gegensatz zu frühen statischen Chatbots können die heutigen Agenten unabhängig mit der Initiative arbeiten.

Ein paar Frameworks, die zu wissen sind Microsoft’s AutogenAnwesend LanggraphUnd Kamel-ai. Es gibt viele autonome Agent -Frameworks, die Unternehmen helfen, Aufgaben effektiv auszuführen. Forscher untersuchen auch Multi-Agent-Systeme, bei denen mehrere spezialisierte Agenten wie ein menschliches Staff zusammenarbeiten, für die viele dieser Frameworks Funktionen bieten.

Insgesamt sind autonome Sprachmittel ein Development in NLP, den wir 2026 nicht ignorieren können.

# 3. Weltmodelle

NLP-Technologien haben sich traditionell auf Textual content auf Oberflächenebene konzentriert, aber im Jahr 2026 sollten wir uns auf den aufstrebenden Development von Systemen, die auf Weltmodellen aufgebaut sind, achten. Dies sind Systeme, die eine interne Darstellung der Umgebung schaffen, in der sie arbeiten. Anstatt das nächste Wort allein vorherzusagen, simuliert ein Weltmodell, wie sich die Zustände im Laufe der Zeit verändern und Kontinuität, Ursache und Wirkung und geerdete Argumentation ermöglichen. Deshalb sind Weltmodelle ein Development, den Sie 2026 nicht verpassen sollten.

Weltmodelle integrieren die Wahrnehmung (was das System wahrnimmt oder liest), Gedächtnis (was bereits passiert ist) und Vorhersage (was als nächstes auftreten könnte). Sie stammen aus Robotik- und Verstärkungslernen und ermöglichen es KI, sich zukünftige Zustände der Welt vorzustellen und Handlungen entsprechend zu planen. Dies bedeutet, dass wir nicht nur Sätze zusammenhalten, sondern auch ein konsistentes mentales Modell von Menschen, Objekten und Ereignissen während einer Interaktion aufrechterhalten.

Beispiele für Modelle und Forschung umfassen DeepMind Dreamerv3Anwesend Deepmind Genie 2Und Sozioverseforschung. Diese Experimente zeigen, wie interne Simulationen Systeme über den Kontext argumentieren und kohärenter sind.

Weltmodelle sind immer noch ein Nischenfeld, aber wir können erwarten, dass sie im Jahr 2026 auf bestimmte Bereiche anwenden. Es ist ein Schritt in Richtung Technologie, die Aspekte der Zukunft simulieren kann.

# 4. Neurosymbolische NLP- und Wissensgrafiken

Während viele NLP -Systeme die Sprache immer noch als unstrukturiertes Textual content behandeln, konvertieren Information Graphs (KGS) Textual content in miteinander verbundene, abfragefähige Kenntnisse. Ein KG verwandelt Entitäten (Menschen, Organisationen, Produkte), ihre Attribute und Beziehungen in eine Grafik. Dies verleiht NLP -Systemen wiederum einen Speicher und einen Weg, um mit Fakten und nicht nur Muster zu argumentieren. Deshalb sind Wissensgrafiken ein Development, den Sie 2026 nicht verpassen sollten.

Wissensgrafiken helfen, weil sie drei Dinge bereitstellen, die NLP-Systeme in der realen Welt häufig verpassen: Kontext, Rückverfolgbarkeit und Konsistenz.

• Kontext: Sie klären mehrdeutige Begriffe wie „Jaguar“, „Apple“ oder „GA“, um genau das zu bedeuten, was Sie beabsichtigen (z.
• Rückverfolgbarkeit: Sie haben eine Aufzeichnung der Quelle der einzelnen Tatsachen, sodass Sie sie später überprüfen können
• Konsistenz: Sie befolgen klare Regeln darüber, was Sinn macht (z. B. kann nur ein Unternehmen ein anderes Unternehmen erwerben), was widersprüchliche Ergebnisse an verschiedenen Orten verhindert.

Ein paar bemerkenswerte Werkzeuge, die Sie wissen sollten Neo4jAnwesend TigergraphUnd Openie. Diese Instruments haben im NLP -Bereich fortgeschrittene KGs und werden im kommenden Jahr sicherlich wichtig sein.

Wir können erwarten, dass KGs 2026 in die Kerninfrastruktur der Unternehmen eingebettet werden. KGs machen Sprachanwendungen genauer, was in jedem KI-gesteuerten Unternehmen von wesentlicher Bedeutung ist.

# 5. On-Gadget NLP

Wenn NLP-Systeme in das tägliche Leben eingebettet werden-von Smartphones bis Wearables-ist einer der am schnellsten wachsenden Traits im Jahr 2026 NLP, auch als Tinyml bekannt. Anstatt jede Eingabe an die Cloud zu senden, werden die Modelle komprimiert und optimiert, um direkt auf Geräten auszuführen. Dies gewährleistet schnellere Reaktionen und stärkere Schutzmaßnahmen für die Datenprivität.

On-Gadget-NLP verwendet Modellkompressionstechniken wie Quantisierung, Beschneidung und Destillation, um große Architekturen in leichte Formen zu verkleinern. Diese winzigen Modelle können weiterhin Aufgaben wie Spracherkennung oder Textklassifizierung ausführen, jedoch mit viel kleineren Speicher Fußabdrücken.

Ein paar Frameworks für On-Gadget-NLP umfassen Google LitertAnwesend Qualcomms neuronaler Verarbeitung SDKUnd Randimpuls. Diese Frameworks unterstützen bereits winzige NLP -Modelle und können im kommenden Jahr Commonplace werden.

# Einpacken

NLP ist zur Grundlage für viele Fortschritte in der Technologie weltweit durch Durchbrüche wie Transformers und Sprachmodelle. Der technologische Fortschritt stellt jedoch sicher, dass wir uns noch weiter bewegen. In diesem Artikel haben wir fünf modernste NLP-Traits untersucht, die 2026 beeinflussen, von der effizienten Aufmerksamkeit bis hin zu Weltmodellen bis hin zu Wissensgrafiken und darüber hinaus.

Ich hoffe das hat geholfen!

Cornellius Yudha Wijaya ist ein Information Science Assistant Supervisor und Datenautor. Während er in Vollzeit bei Allianz Indonesien arbeitet, liebt er es, Python- und Datentipps über soziale Medien und das Schreiben von Medien zu teilen. Cornellius schreibt über eine Vielzahl von KI- und maschinellen Lernthemen.

Bild von Autor | Ideogramm

# Einführung

Die meisten Anwendungen stützen sich stark auf JSON für Datenaustausch, Konfigurationsmanagement und API -Kommunikation.

Das integrierte JSON-Modul von Python in Kombination mit Hear-Verständnissen und Wörterbuchoperationen ermöglicht es, komplexe JSON-Manipulationen mit überraschend prägnantem Code durchzuführen. Diese Einzeiler helfen Ihnen dabei, aussagekräftige Informationen aus JSON-Daten effizient zu analysieren, zu transformieren und zu extrahieren.

# Erstellen von Beispieldaten

Lassen Sie uns realistische JSON-Datensätze erstellen, die gemeinsame Szenarien darstellen, denen Sie in realen Anwendungen begegnen werden:

import json
from collections import defaultdict, Counter

# Pattern product catalog
merchandise = (
    {"id": 1, "title": "Laptop computer", "value": 999.99, "class": "Electronics", "inventory": 25, "ranking": 4.5},
    {"id": 2, "title": "Espresso Maker", "value": 79.99, "class": "Home equipment", "inventory": 15, "ranking": 4.2},
    {"id": 3, "title": "Smartphone", "value": 699.99, "class": "Electronics", "inventory": 50, "ranking": 4.7},
    {"id": 4, "title": "Desk Chair", "value": 159.99, "class": "Furnishings", "inventory": 8, "ranking": 4.1},
    {"id": 5, "title": "Headphones", "value": 199.99, "class": "Electronics", "inventory": 30, "ranking": 4.6}
)

# Pattern worker information
workers = (
    {"title": "Alice Johnson", "division": "Engineering", "wage": 95000, "initiatives": ("API", "Database")},
    {"title": "Bob Smith", "division": "Advertising", "wage": 65000, "initiatives": ("Marketing campaign", "Analytics")},
    {"title": "Carol Davis", "division": "Engineering", "wage": 105000, "initiatives": ("Frontend", "Testing")},
    {"title": "David Wilson", "division": "Gross sales", "wage": 75000, "initiatives": ("Outreach", "CRM")}
)

# Pattern nested API response
api_response = {
    "standing": "success",
    "information": {
        "orders": (
            {"id": "ORD001", "buyer": {"title": "John Doe", "electronic mail": "john@instance.com"}, "objects": ({"product": "Laptop computer", "amount": 1})},
            {"id": "ORD002", "buyer": {"title": "Jane Smith", "electronic mail": "jane@instance.com"}, "objects": ({"product": "Mouse", "amount": 2})}
        ),
        "total_orders": 2
    }
}

In den folgenden Beispielen habe ich die Druckaussagen weggelassen und mich nur auf die Einzeiler selbst konzentriert.

# 1. Extrahieren Sie alle Werte für einen bestimmten Schlüssel

Bei der Arbeit mit JSON -Arrays müssen Sie häufig alle Werte für ein bestimmtes Feld über mehrere Objekte hinweg extrahieren. Dieser Ein-Liner-Spucks spreizt spezifische Werte aus verschachtelten Strukturen effizient, was es perfekt zum Erstellen von Zusammenfassungslisten oder zur Vorbereitung von Daten zur weiteren Analyse macht.

product_names = (merchandise('title') for merchandise in merchandise)

Diese Liste durch Verständnis durch jedes Wörterbuch in der Produktliste und extrahiert das Feld „Title“. Die Sq. -Bracket -Notation greift direkt auf den Schlüssel zu und erstellt eine neue Liste, die nur die gewünschten Werte enthält, während die ursprüngliche Reihenfolge beibehalten wird.

('Laptop computer', 'Espresso Maker', 'Smartphone', 'Desk Chair', 'Headphones')

# 2. Filterung von JSON -Objekten nach Bedingung

Die Datenfilterung ist bei der Arbeit mit großen JSON -Datensätzen unerlässlich. Dieser One-Liner kombiniert das Listenverständnis mit einer bedingten Logik, um nur Objekte zu extrahieren, die bestimmte Kriterien erfüllen und die Erstellung der Schnelldaten-Untergruppe ohne komplexe Schleifen ermöglichen.

expensive_products = (merchandise for merchandise in merchandise if merchandise('value') > 200)

Der bedingte Ausdruck bewertet das Preisfeld jedes Produkts und umfasst nur diejenigen Objekte, bei denen die Bedingung wahr ist.

({'id': 1,
  'title': 'Laptop computer',
  'value': 999.99,
  'class': 'Electronics',
  'inventory': 25,
  'ranking': 4.5},
 {'id': 3,
  'title': 'Smartphone',
  'value': 699.99,
  'class': 'Electronics',
  'inventory': 50,
  'ranking': 4.7})

# 3. Gruppieren Sie JSON -Objekte nach Feldwert

Die Kategorisierung von Daten nach bestimmten Attributen ist eine häufige Anforderung bei der Datenverarbeitung. Dieser One-Liner erstellt ein Wörterbuch, bei dem Schlüssel eindeutige Feldwerte und -werte darstellen, die Hear von Objekten enthalten, die dieses Attribut teilen und eine effiziente Datenorganisation und -analyse ermöglichen.

products_by_category = {ok: (merchandise for merchandise in merchandise if merchandise('class') == ok) for ok in set(merchandise('class') for merchandise in merchandise)}

Das Wörterbuchverständnis erstellt zunächst eine Reihe eindeutiger Kategorienwerte und filtert dann für jede Kategorie die Produktliste so, dass sie nur übereinstimmende Elemente enthält.

{'Furnishings': ({'id': 4,
   'title': 'Desk Chair',
   'value': 159.99,
   'class': 'Furnishings',
   'inventory': 8,
   'ranking': 4.1}),
 'Home equipment': ({'id': 2,
   'title': 'Espresso Maker',
   'value': 79.99,
   'class': 'Home equipment',
   'inventory': 15,
   'ranking': 4.2}),
 'Electronics': ({'id': 1,
   'title': 'Laptop computer',
   'value': 999.99,
   'class': 'Electronics',
   'inventory': 25,
   'ranking': 4.5},
  {'id': 3,
   'title': 'Smartphone',
   'value': 699.99,
   'class': 'Electronics',
   'inventory': 50,
   'ranking': 4.7},
  {'id': 5,
   'title': 'Headphones',
   'value': 199.99,
   'class': 'Electronics',
   'inventory': 30,
   'ranking': 4.6})}

# 4. Berechnung der Aggregatstatistiken von JSON

Die schnelle statistische Analyse von JSON -Daten hilft bei der Identifizierung von Tendencies und Mustern. Dieser One-Liner berechnet gleichzeitig mehrere Aggregatfunktionen und liefert umfassende Einblicke in die numerischen Eigenschaften Ihres Datensatzes, ohne separate Berechnungsschleifen zu schreiben.

price_stats = {'min': min(merchandise('value') for merchandise in merchandise), 'max': max(merchandise('value') for merchandise in merchandise), 'avg': sum(merchandise('value') for merchandise in merchandise) / len(merchandise)}

Das Wörterbuchverständnis wendet unterschiedliche Aggregatfunktionen auf dieselben extrahierten Werte an, wobei Generatorausdrücke für die Speichereffizienz verwendet werden.

{'min': 79.99, 'max': 999.99, 'avg': 427.98999999999995}

# 5. JSON -Struktur transformieren

Die Umstrukturierung von JSON -Daten zu unterschiedlichen Schemas oder API -Anforderungen ist häufig erforderlich. Dieser Einzeiler erstellt neue Objekte mit modifizierten Feldnamen, berechneten Werten oder filtrierten Attributen, wodurch eine nahtlose Datenumwandlung zwischen verschiedenen Systemformaten ermöglicht wird.

simplified_products = ({'title': merchandise('title'), 'value': merchandise('value'), 'out there': merchandise('inventory') > 0} for merchandise in merchandise)

Das Listenverständnis erstellt neue Wörterbücher mit transformierten Feldnamen und berechneten booleschen Werten. Dieser Ansatz ermöglicht die Umbenennung von Feldzügen, Typ -Konvertierung und berechnete Attribute in einem einzigen Ausdruck, während sauberer, lesbarer Code beibehalten wird.

({'title': 'Laptop computer', 'value': 999.99, 'out there': True},
 {'title': 'Espresso Maker', 'value': 79.99, 'out there': True},
 {'title': 'Smartphone', 'value': 699.99, 'out there': True},
 {'title': 'Desk Chair', 'value': 159.99, 'out there': True},
 {'title': 'Headphones', 'value': 199.99, 'out there': True})

# 6. sicheres Extrahieren verschachtelter Werte sicher extrahieren

Verschachtete JSON -Daten müssen sorgfältig alle fehlenden Schlüssel behandeln, um Fehler zu vermeiden. Dieser One-Liner verwendet die GET-Methode mit Standardwerten, um verschachtelte Informationen sicher zu extrahieren, um einen robusten Code zu gewährleisten, der auch unvollständige oder missgebildete Daten behandelt.

customer_emails = (order.get('buyer', {}).get('electronic mail', 'N/A') for order in api_response('information')('orders'))

Die geketteten .get() Methoden liefern Standardwerte auf jeder Ebene, die verhindern KeyErrorAusnahmen beim Zugriff auf verschachtelte Strukturen. Dieser Ansatz ist für die Arbeit mit externen APIs oder von Benutzer erstellten Daten von wesentlicher Bedeutung, bei denen die Präsenz der Feldwäsche nicht garantiert wird.

('john@instance.com', 'jane@instance.com')

# 7. Zählen der Ereignisse der Feldwerte

Um Datenverteilungsmuster zu verstehen, müssen Sie zählen, wie häufig bestimmte Werte in Ihrem Datensatz angezeigt werden. Dieser Einzeiler erstellt eine Frequenzkarte der Feldwerte, die sofortige Einblicke in die Datenzusammensetzung bietet und hilfreiche Mustern oder Ausreißer identifiziert.

category_counts = Counter(merchandise('class') for merchandise in merchandise)

Der Counter Die Klasse ist automatisch das Auftreten jedes einzigartigen Wertes aus dem Generatorausdruck. Dieser Ansatz ist effizienter als manuelle Zählschleifen.

Counter({'Electronics': 3, 'Home equipment': 1, 'Furnishings': 1})

# 8. Zusammenführen mehrerer JSON -Objekte

Die Kombination von Daten aus mehreren JSON -Quellen ist häufig bei der Arbeit mit Microservices oder Federated Programs. Dieser One-Liner verschmilzt Objekte, indem sie Schlüsseln abgleichen und konsolidierte Datensätze erstellen, die Informationen aus verschiedenen Quellen enthalten.

enhanced_products = ({**product, 'total_value': product('value') * product('inventory')} for product in merchandise)

Das Wörterbuchpackung packt die vorhandenen Felder aus und fügt gleichzeitig neue berechnete Werte hinzu.

({'id': 1,
  'title': 'Laptop computer',
  'value': 999.99,
  'class': 'Electronics',
  'inventory': 25,
  'ranking': 4.5,
  'total_value': 24999.75},
 {'id': 2,
  'title': 'Espresso Maker',
  'value': 79.99,
  'class': 'Home equipment',
  'inventory': 15,
  'ranking': 4.2,
  'total_value': 1199.85},
...
 {'id': 5,
  'title': 'Headphones',
  'value': 199.99,
  'class': 'Electronics',
  'inventory': 30,
  'ranking': 4.6,
  'total_value': 5999.700000000001})

# 9. Objekte mit maximalen/minimalen Werten finden

Das Identifizieren von Datensätzen mit extremen Werten ist für die Datenanalyse und die Qualitätskontrolle von wesentlicher Bedeutung. Dieser Einzeiler findet Objekte, die die höchsten oder niedrigsten Werte für bestimmte Felder enthalten und die schnelle Identifizierung von Ausreißern, High-Künstlern oder Kanten in Ihrem Datensatz ermöglichen.

highest_rated = max(merchandise, key=lambda x: x('ranking'))

Der max Funktion mit a key Der Parameter gibt das Objekt mit dem maximalen Wert für den angegebenen Schlüssel zurück. Dieser Ansatz ist lesbarer als manuelle Iteration und funktioniert mit einem vergleichbaren Feldtyp, einschließlich Zeichenfolgen und Daten.

{'id': 3,
 'title': 'Smartphone',
 'value': 699.99,
 'class': 'Electronics',
 'inventory': 50,
 'ranking': 4.7}

# 10. Abflachende verschachtelte JSON -Arrays

Komplexe JSON -Strukturen enthalten häufig verschachtelte Arrays, die für die Analyse oder Verarbeitung abgeflacht werden müssen. Dieser Einzeiler extrahiert und kombiniert Elemente aus verschachtelten Hear und erzeugt eine einzige flache Struktur, mit der in nachfolgenden Operationen einfacher zu arbeiten sind.

projects_list = (venture for worker in workers for venture in worker('initiatives'))

Das verschachtelte Listenverständnis iteriert zunächst die Mitarbeiter, dann über die Projektliste der einzelnen Mitarbeiter und erstellt eine abgeflachte Reihe aller Projektnamen. Diese Doppel-Loop-Struktur behandelt effizient verschärfete Arrays mit variabler Länge.

('API',
 'Database',
 'Marketing campaign',
 'Analytics',
 'Frontend',
 'Testing',
 'Outreach',
 'CRM')

# Abschluss

Diese Python-Einzeiler zeigen, wie nützlich Python für die Manipulation von JSON-Daten ist.

Der Schlüssel ist, die integrierten Funktionen, Verständnisse und die Flexibilität von Wörterbuchoperationen von Python zu verstehen.

Mit diesen können Sie wahrscheinlich die API -Antworten verarbeiten, Daten zwischen verschiedenen Formaten transformieren und nützliche Informationen aus komplexen JSON -Strukturen extrahieren.

Bala Priya c ist ein Entwickler und technischer Schriftsteller aus Indien. Sie arbeitet gern an der Schnittstelle zwischen Mathematik, Programmierung, Datenwissenschaft und Inhaltserstellung. Ihre Interessensgebiete und Fachgebiete umfassen DevOps, Information Science und natürliche Sprachverarbeitung. Sie liest gerne, schreibt, codieren und Kaffee! Derzeit arbeitet sie daran, ihr Wissen mit der Entwicklergemeinschaft zu lernen und zu teilen, indem sie Tutorials, Anleitungen, Meinungsstücke und vieles mehr autorisiert. Bala erstellt auch ansprechende Ressourcenübersichten und Codierungs -Tutorials.

Falls Sie es noch nicht wussten: Python verfügt über einige unglaublich leistungsstarke Instruments, mit denen Sie Leistung erbringen können Verarbeitung natürlicher Sprache (NLP) auf Textdaten. In diesem Tutorial erfahren Sie, wie Sie mit Python in NLP einsteigen.

Blick auf die Daten

Wir werden mit einem Datensatz arbeiten, der aus Unterlektionen zu besteht Hacker-Information von 2006 bis 2015. Die Daten stammen aus Hier. Arnaud Drizard nutzte die Hacker Information API, um es zu kratzen. Wir haben probiert 10000 Zeilen aus den Daten zufällig ausgewählt und alle überflüssigen Spalten entfernt. Unsere Daten bestehen nur aus vier Spalten:

• sublesson_time: als die Geschichte eingereicht wurde.
• url: die Foundation-URL der Unterlektion.
• upvotes: Anzahl der Upvotes, die die Unterlektion erhalten hat.
• headline: die Überschrift der Unterlektion.

Wir werden die Schlagzeilen verwenden, um die Anzahl der Upvotes vorherzusagen. Die Daten werden im gespeichert sublessons Variable.

Verarbeitung natürlicher Sprache mit Python – Erste Schritte

Wir möchten schließlich einen Algorithmus für maschinelles Lernen trainieren, um eine Überschrift aufzunehmen und uns mitzuteilen, wie viele Upvotes sie erhalten würde. Allerdings verstehen Algorithmen des maschinellen Lernens nur Zahlen, keine Wörter. Wie übersetzen wir unsere Schlagzeilen in etwas, das ein Algorithmus verstehen kann?

Der erste Schritt besteht darin, eine sogenannte Bag-of-Phrases-Matrix zu erstellen. Eine Tüte Wortmatrix gibt uns eine numerische Darstellung, welche Wörter in welchen Schlagzeilen vorkommen. Um eine Bag-of-Wort-Matrix zu erstellen, suchen wir zunächst die eindeutigen Wörter in der gesamten Schlagzeilengruppe. Dann erstellen wir eine Matrix, in der jede Zeile eine Überschrift und jede Spalte eines der eindeutigen Wörter ist. Dann tragen wir in jede Zelle ein, wie oft dieses Wort in dieser Überschrift vorkommt. Dies führt zu einer Matrix, in der viele Zellen den Wert Null haben, es sei denn, das Vokabular wird größtenteils von den Überschriften übernommen.

from collections import Counter

headlines = (
    "PretzelBros, airbnb for individuals who like pretzels, raises $2 million",
    "High 10 the reason why Go is best than no matter language you utilize.",
    "Why working at apple stole my soul (I nonetheless adore it although)",
    "80 issues I feel you must do instantly when you use python.",
    "Present HN: carjack.me: Uber meets GTA"
)

# Discover all of the distinctive phrases within the headlines.
unique_words = checklist(set(" ".be part of(headlines).break up(" ")))
def make_matrix(headlines, vocab):
    matrix = ()
    for headline in headlines:
        # Depend every phrase within the headline, and make a dictionary.
        counter = Counter(headline)
        # Flip the dictionary right into a matrix row utilizing the vocab.
        row = (counter.get(w, 0) for w in vocab)
        matrix.append(row)
    df = pandas.DataFrame(matrix)
    df.columns = unique_words
    return df

print(make_matrix(headlines, unique_words))

.  why  HN:  for  folks  instantly  like  I  Go  80  meets  ...   my  who  
0    0    0    0       0            0     0  0   0   0      0  ...    0    0   
1    0    0    0       0            0     0  0   0   0      0  ...    0    0   
2    0    0    0       0            0     0  1   0   0      0  ...    0    0   
3    0    0    0       0            0     0  1   0   0      0  ...    0    0   
4    0    0    0       0            0     0  0   0   0      0  ...    0    0   

   PretzelBros,  no matter  language  do  $2  nonetheless  than  soul  
0             0         0         0   0   0      0     0     0  
1             0         0         0   0   0      0     0     0  
2             0         0         0   0   0      0     0     0  
3             0         0         0   0   0      0     0     0  
4             0         0         0   0   0      0     0     0  

(5 rows x 51 columns)

Satzzeichen entfernen

Die Matrix, die wir gerade erstellt haben, ist sehr dünn besetzt – das bedeutet, dass viele Werte Null sind. Dies ist bis zu einem gewissen Grad unvermeidlich, da die Schlagzeilen nicht viel gemeinsames Vokabular enthalten. Wir können jedoch einige Schritte unternehmen, um das Drawback zu beheben. Im Augenblick Why Und whyUnd use Und use. werden als unterschiedliche Entitäten behandelt, aber wir wissen, dass sie sich auf dasselbe Wort beziehen. Wir können dem Parser dabei helfen, zu erkennen, dass diese tatsächlich gleich sind, indem wir jedes Wort kleinschreiben und alle Satzzeichen entfernen.

import re

# Lowercase, then substitute any non-letter, area, or digit character within the headlines.
new_headlines = (re.sub(r'(^wsd)','',h.decrease()) for h in headlines)
# Exchange sequences of whitespace with an area character.
new_headlines = (re.sub("s+", " ", h) for h in new_headlines)

unique_words = checklist(set(" ".be part of(new_headlines).break up(" ")))
# We have lowered the variety of columns within the matrix a bit.
print(make_matrix(new_headlines, unique_words))

.  2  why  high  hn  for  folks  instantly  like  python  80  ...   ought to  
0  1    0    0   0    0       0            0     0       0   0  ...        0   
1  0    0    0   0    0       0            0     0       0   0  ...        0   
2  0    0    0   0    0       0            0     0       0   0  ...        0   
3  0    0    0   0    0       0            0     0       0   0  ...        0   
4  0    0    0   0    0       0            0     0       0   0  ...        0   

   my  who  go  no matter  language  do  nonetheless  than  soul  
0   0    0   0         0         0   0      0     0     0  
1   0    0   0         0         0   0      0     0     0  
2   0    0   0         0         0   0      0     0     0  
3   0    0   0         0         0   0      0     0     0  
4   0    0   0         0         0   0      0     0     0  

(5 rows x 47 columns)

Stoppwörter entfernen

Bestimmte Wörter helfen Ihnen nicht dabei, zwischen guten und schlechten Schlagzeilen zu unterscheiden. Wörter wie the, aUnd additionally kommen in allen Zusammenhängen so häufig vor, dass sie uns nicht wirklich viel darüber verraten, ob etwas intestine ist oder nicht. Im Allgemeinen ist die Wahrscheinlichkeit, dass sie sowohl in guten als auch in schlechten Schlagzeilen auftauchen, gleich groß. Indem wir diese entfernen, können wir die Größe der Matrix reduzieren und das Coaching eines Algorithmus beschleunigen.

# Learn in and break up the stopwords file.
with open("stop_words.txt", 'r') as f:
    stopwords = f.learn().break up("n")

# Do the identical punctuation alternative that we did for the headlines, # so we're evaluating the fitting issues.
stopwords = (re.sub(r'(^wsd)','',s.decrease()) for s in stopwords)

unique_words = checklist(set(" ".be part of(new_headlines).break up(" ")))

# Take away stopwords from the vocabulary.unique_words = (w for w in unique_words if w not in stopwords)

# We're all the way down to 34 columns, which is means higher!
print(make_matrix(new_headlines, unique_words))

   
.  2  high  hn  folks  instantly  like  python  80  meets  pretzels  ...   
0  1    0   0       0            0     0       0   0      0         0  ...    
1  0    0   0       0            0     0       0   0      0         0  ...    
2  0    0   0       0            0     0       0   0      0         0  ...    
3  0    0   0       0            0     0       0   0      0         0  ...    
4  0    0   0       0            0     0       0   0      0         0  ...    

   gta  10  uber  raises  pretzelbros  go  no matter  language  nonetheless  soul  
0    0   0     0       0            0   0         0         0      0     0  
1    0   0     0       0            0   0         0         0      0     0  
2    0   0     0       0            0   0         0         0      0     0  
3    0   0     0       0            0   0         0         0      0     0  
4    0   0     0       0            0   0         0         0      0     0  

(5 rows x 34 columns)

Generieren einer Matrix für alle Schlagzeilen

Nachdem wir nun die Grundlagen kennen, können wir eine Wortmatrix für die gesamten Schlagzeilen erstellen. Wir möchten nicht jedes Mal alles manuell codieren müssen, deshalb verwenden wir eine Klasse von scikit-lernen um es automatisch zu tun. Mit der Vektorisierer Von Scikit-Study bis zum Erstellen Ihrer Wortsammlung mit Matrizen wird der Prozess viel einfacher und schneller.

from sklearn.feature_extraction.textual content import CountVectorizer

# Assemble a bag of phrases matrix.
# It will lowercase the whole lot, and ignore all punctuation by default.
# It should additionally take away cease phrases.
vectorizer = CountVectorizer(lowercase=True, stop_words="english")

matrix = vectorizer.fit_transform(headlines)
# We created our bag of phrases matrix with far fewer instructions.
print(matrix.todense())

# Let's apply the identical methodology to all of the headlines in all 100000 sublessons.
# We'll additionally add the url of the sublesson to the top of the headline so we will take it under consideration.
sublessons('full_test') = sublessons("headline") + " " + sublessons("url")
full_matrix = vectorizer.fit_transform(sublessons("headline"))
print(full_matrix.form)

((0 0 1 0 0 0 0 0 0 0 1 0 0 1 1 1 1 0 1 0 0 0 0 0 0 0 0)
 (1 0 0 0 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 1 0 0 0 0 0 1 0)
 (0 0 0 1 0 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 1 0 0 0 0 1)
 (0 1 0 0 0 0 0 0 1 0 0 0 0 0 0 0 0 1 0 0 0 0 1 1 0 1 0)
 (0 0 0 0 0 1 1 1 0 0 0 0 1 0 0 0 0 0 0 0 0 0 0 0 1 0 0))
(9356, 13631)

Reduzierung der Dimensionalität

Wir haben eine Matrix erstellt, aber jetzt ist sie da 13631 eindeutige Wörter oder Spalten. Es wird sehr lange dauern, damit Vorhersagen zu treffen. Wir wollen es beschleunigen, additionally müssen wir die Spaltenanzahl irgendwie reduzieren. Eine Möglichkeit, dies zu erreichen, besteht darin, eine Teilmenge der Spalten auszuwählen, die am informativsten sind – additionally die Spalten, die am besten zwischen guten und schlechten Schlagzeilen unterscheiden.

Eine gute Möglichkeit, die informativsten Spalten herauszufinden, ist die Verwendung von a Chi-Quadrat prüfen. Ein Chi-Quadrat-Check findet die Wörter, die am meisten zwischen stark positiv bewerteten Posts und Posts, die nicht positiv bewertet wurden, unterscheiden. Dabei kann es sich um Wörter handeln, die in Beiträgen mit hohem Upvote häufig vorkommen, in Posts ohne Upvotes jedoch überhaupt nicht, oder um Wörter, die in Posts mit hohem Upvote häufig, aber nicht in Posts mit Upvote vorkommen. Ein Chi-Quadrat-Check funktioniert nur bei Binärwerten, daher machen wir unsere Upvotes-Spalte binär, indem wir alles mit mehr Upvotes als dem Durchschnitt auf setzen 1 und alles mit weniger Upvotes als der Durchschnitt 0. Ein Nachteil dabei ist, dass wir Wissen aus dem Datensatz nutzen, um Options auszuwählen, und somit eine gewisse Überanpassung einführen. Wir könnten die Überanpassung in der „realen Welt“ umgehen, indem wir eine Teilmenge der Daten für die Merkmalsauswahl und eine andere Teilmenge für das Coaching des Algorithmus verwenden. Wir machen es vorerst etwas einfacher und überspringen diesen Schritt.

from sklearn.feature_selection import SelectKBest
from sklearn.feature_selection import chi2

# Convert the upvotes variable to binary so it really works with a chi-squared take a look at.
col = sublessons("upvotes").copy(deep=True)
col_mean = col.imply()
col(col < col_mean) = 0
col((col > 0) & (col > col_mean)) = 1

# Discover the 1000 most informative columns
selector = SelectKBest(chi2, ok=1000)
selector.match(full_matrix, col)
top_words = selector.get_support().nonzero()

# Choose solely essentially the most informative columns within the knowledge.
chi_matrix = full_matrix(:,top_words(0))

Wenn wir die „Meta“-Merkmale der Schlagzeilen ignorieren, entgehen uns viele gute Informationen. Zu diesen Merkmalen gehören Dinge wie Länge, Anzahl der Satzzeichen, durchschnittliche Wortlänge und andere satzspezifische Merkmale. Durch das Hinzufügen dieser Elemente kann die Vorhersagegenauigkeit erheblich erhöht werden. Um sie hinzuzufügen, durchlaufen wir unsere Überschriften und wenden auf jede einzelne eine Funktion an. Einige Funktionen zählen die Länge der Überschrift in Zeichen, andere erledigen komplexere Aufgaben, wie z. B. das Zählen der Anzahl der Ziffern.

# Our checklist of capabilities to use.
transform_functions = (
    lambda x: len(x),
    lambda x: x.depend(" "),
    lambda x: x.depend("."),
    lambda x: x.depend("!"),
    lambda x: x.depend("?"),
    lambda x: len(x) / (x.depend(" ") + 1),
    lambda x: x.depend(" ") / (x.depend(".") + 1),
    lambda x: len(re.findall("d", x)),
    lambda x: len(re.findall("(A-Z)", x)),
)

# Apply every operate and put the outcomes into a listing.
columns = ()
for func in transform_functions:
    columns.append(sublessons("headline").apply(func))
    # Convert the meta options to a numpy array.
meta = numpy.asarray(columns).T

Weitere Funktionen hinzufügen

Es gibt mehr Funktionen, mit denen wir arbeiten können als nur Textfunktionen. Wir haben eine Kolumne namens sublesson_timedas uns sagt, wann eine Geschichte eingereicht wurde, und könnte weitere Informationen hinzufügen. Wenn Sie die Verarbeitung natürlicher Sprache mit Python durchführen, können Sie häufig externe Funktionen hinzufügen, die Ihre Vorhersagen erheblich verbessern. Einige Algorithmen für maschinelles Lernen können herausfinden, wie diese Funktionen mit Ihren Textfunktionen interagieren (z. B. „Ein Beitrag um Mitternacht mit dem Wort „Tacos“ in der Überschrift führt zu einem Beitrag mit hoher Punktzahl“).

columns = ()

# Convert the sublesson dates column to datetime.

sublesson_dates = pandas.to_datetime(sublessons("sublesson_time"))

# Remodel capabilities for the datetime column.
transform_functions = (
    lambda x: x.12 months,
    lambda x: x.month,
    lambda x: x.day,
    lambda x: x.hour,
    lambda x: x.minute
)

# Apply all capabilities to the datetime column.
for func in transform_functions:
    columns.append(sublesson_dates.apply(func))

# Convert the meta options to a numpy array.
non_nlp = numpy.asarray(columns).T

# Concatenate the options collectively.
options = numpy.hstack((non_nlp, meta, chi_matrix.todense()))

Vorhersagen treffen

Da wir nun Wörter in Zahlen übersetzen können, können wir mithilfe eines Algorithmus Vorhersagen treffen. Wir werden nach dem Zufallsprinzip auswählen 7500 Schlagzeilen als Trainingssatz verwenden und dann die Leistung des Algorithmus anhand des Testsatzes bewerten 2500 Schlagzeilen. Die Vorhersage der Ergebnisse auf demselben Satz, auf dem wir trainieren, wird zu Folgendem führen: Überanpassungwenn Ihr Algorithmus übermäßig für den Trainingssatz optimiert ist – wir denken, dass die Fehlerrate intestine ist, aber bei neuen Daten könnte sie tatsächlich viel höher sein. Für den Algorithmus verwenden wir Gratregression. Im Vergleich zur gewöhnlichen linearen Regression führt die Ridge-Regression zu einer Strafe für die Koeffizienten, die verhindert, dass sie zu groß werden. Dies kann dazu beitragen, dass es mit einer großen Anzahl von Prädiktoren (Spalten) funktioniert, die wie bei uns miteinander korreliert sind.

from sklearn.linear_model 
import Ridge
import numpy
import random

train_rows = 7500
# Set a seed to get the identical "random" shuffle each time.
random.seed(1)

# Shuffle the indices for the matrix.
indices = checklist(vary(options.form(0)))
random.shuffle(indices)

# Create practice and take a look at units.
practice = options(indices(:train_rows), :)
take a look at = options(indices(train_rows:), :)
train_upvotes = sublessons("upvotes").iloc(indices(:train_rows))
test_upvotes = sublessons("upvotes").iloc(indices(train_rows:))
practice = numpy.nan_to_num(practice)

# Run the regression and generate predictions for the take a look at set.
reg = Ridge(alpha=.1)
reg.match(practice, train_upvotes)
predictions = reg.predict(take a look at)

Bewertung des Fehlers

Wir haben jetzt Vorhersagen, aber wie bestimmen wir, wie intestine sie sind? Eine Möglichkeit besteht darin, die Fehlerrate zwischen den Vorhersagen für den Testsatz und den tatsächlichen Upvote-Zählungen für den Testsatz zu berechnen. Wir möchten auch, dass ein Basel den Fehler vergleicht, um zu sehen, ob die Ergebnisse intestine sind. Wir können dies erreichen, indem wir eine einfache Methode verwenden, um Basisschätzungen für den Testsatz vorzunehmen, und die Fehlerrate unserer Vorhersagen mit der Fehlerrate der Basisschätzungen vergleichen.

Eine sehr einfache Grundlinie besteht darin, die durchschnittliche Anzahl der Upvotes professional Unterlektion im Trainingssatz zu nehmen und diese als Vorhersage für jede Unterlektion zu verwenden. Wir werden verwenden mittlerer absoluter Fehler als Fehlermetrik. Es ist ganz einfach: Subtrahieren Sie einfach den tatsächlichen Wert von der Vorhersage, nehmen Sie den absoluten Wert der Differenz und ermitteln Sie dann den Mittelwert aller Differenzen.

# We will use imply absolute error as an error metric.
# Our error is about 13.6 upvotes, which signifies that, on common, 
# our prediction is 13.6 upvotes away from the precise variety of upvotes.
print(sum(abs(predictions - test_upvotes)) / len(predictions))

# As a baseline, we'll use the common variety of upvotes# throughout all sublessons.
# The error right here is 17.2―our estimate is best, however not massively so.
# There both is not a ton of predictive worth encoded within the 
# knowledge now we have, or we aren't extracting it nicely.
average_upvotes = sum(test_upvotes)/len(test_upvotes)
print(sum(abs(average_upvotes - test_upvotes)) / len(predictions))

13.6606593988
17.2759421912

Nächste Schritte

Diese Methode funktionierte bei diesem Datensatz einigermaßen, aber nicht besonders intestine. Wir haben festgestellt, dass die Überschriften und anderen Spalten einen gewissen Vorhersagewert haben. Wir könnten diesen Ansatz verbessern, indem wir einen anderen Vorhersagealgorithmus verwenden, beispielsweise einen Zufallswald oder ein neuronales Netzwerk. Wir könnten auch Ngramme wie Bigramme und Trigramme verwenden, wenn wir unsere Wortbeutelmatrix erstellen.

Versuche ein Tf-idf Eine Transformation auf der Matrix könnte ebenfalls hilfreich sein – scikit-learn verfügt über eine Klasse, die dies automatisch erledigt. Wir könnten auch andere Daten berücksichtigen, etwa den Benutzer, der den Artikel eingereicht hat, und Funktionen generieren, die Dinge wie das Karma des Benutzers und die jüngsten Aktivitäten des Benutzers angeben. Andere Statistiken zur übermittelten URL, wie die durchschnittliche Anzahl der von dieser URL erhaltenen Upvotes-Unterlektionen, wären möglicherweise ebenfalls nützlich.

Achten Sie dabei darauf, nur Informationen zu berücksichtigen, die vor der Unterlektion, für die Sie eine Vorhersage treffen, vorhanden waren. Die Ausführung aller dieser Ergänzungen wird viel länger dauern als bisher, aber sie werden die Fehlerquote reduzieren. Hoffentlich haben Sie etwas Zeit, sie auszuprobieren! Wenn Sie mehr über NLP mit Python erfahren möchten, können Sie sich unsere interaktiven Übungen ansehen Verarbeitung natürlicher Sprache für Deep Studying Kurs. Es endet mit einem Projekt zum Thema Klassifizierung katastrophenbezogener Tweets als echt oder gefälscht Dies stellt eine hervorragende Ergänzung Ihres Projektportfolios dar.

Haben Sie jemals mit einem virtuellen Assistenten wie Siri oder Alexa gesprochen und sich gewundert, wie sie zu verstehen scheinen, was Sie sagen? Oder haben Sie einen Chatbot genutzt, um einen Flug zu buchen oder Essen zu bestellen, und waren erstaunt, dass die Maschine genau weiß, was Sie wollen? Diese Erfahrungen basieren auf einer Technologie namens Pure Language Understanding, kurz NLU.

Mit dem Aufkommen von Chatbots, virtuellen Assistenten und Sprachassistenten ist die Notwendigkeit, dass Maschinen natürliche Sprache verstehen, immer wichtiger geworden. Und hier kommt Pure Language Understanding (NLU) ins Spiel. In diesem Artikel befassen wir uns eingehender mit dem Verstehen natürlicher Sprache und erkunden einige seiner aufregenden Möglichkeiten.

Was ist Pure Language Understanding (NLU)?

Pure Language Understanding (NLU) ist ein Teilgebiet von Verarbeitung natürlicher Sprache (NLP), das sich mit dem Computerverständnis menschlicher Sprache befasst. Dabei geht es um die Verarbeitung der menschlichen Sprache, um daraus relevante Bedeutungen zu extrahieren. Diese Bedeutung könnte in Kind einer Absicht, benannter Entitäten oder anderer Aspekte der menschlichen Sprache vorliegen.

NLP zielt darauf ab, den geschriebenen Inhalt eines Textes zu untersuchen und zu verstehen, während NLU die Fähigkeit ermöglicht, sich mit einem Laptop in natürlicher Sprache zu unterhalten.

Wie funktioniert Pure Language Understanding (NLU)?

NLU verarbeitet große Datensätze menschlicher Sprache mithilfe von Modellen des maschinellen Lernens (ML). Diese Modelle werden anhand relevanter Trainingsdaten trainiert, die ihnen helfen, Muster in der menschlichen Sprache zu erkennen.

Die für NLU-Modelle verwendeten Trainingsdaten umfassen typischerweise gekennzeichnete Beispiele menschlicher Sprachen, wie z. B. Kundensupport-Tickets, Chat-Protokolle oder andere Formen von Textdaten.

Der erste Schritt in NLU besteht darin, die Textdaten vorzuverarbeiten, um sie für die Analyse vorzubereiten. Dazu können Aufgaben wie die Tokenisierung gehören, bei der der Textual content in einzelne Wörter oder Phrasen zerlegt wird, oder das Tagging von Wortarten, bei dem jedes Wort mit seiner grammatikalischen Rolle gekennzeichnet wird.

Nach der Vorverarbeitung verwenden NLU-Modelle verschiedene ML-Techniken, um Bedeutung aus dem Textual content zu extrahieren. Ein gängiger Ansatz ist die Absichtserkennung, bei der der Zweck oder das Ziel eines bestimmten Textes identifiziert wird. Beispielsweise könnte ein NLU-Modell erkennen, dass es sich bei der Nachricht eines Benutzers um eine Anfrage zu einem Produkt oder einer Dienstleistung handelt.

Schauen wir uns ein Beispiel für NLU in Aktion genauer an.

Stellen Sie sich vor, Sie fragen Siri nach dem Weg zu einem nahegelegenen Café. Sie könnten sagen: „Hey Siri, wo ist das nächste Café?“

Ohne NLU würde Siri Ihre Worte mit vorprogrammierten Antworten abgleichen und möglicherweise den Weg zu einem Café weisen, das nicht mehr in Betrieb ist. Aber mit NLU kann Siri die Absicht hinter Ihren Worten verstehen und dieses Verständnis nutzen, um eine relevante und genaue Antwort zu geben. In diesem Artikel werden wir uns eingehender mit der Funktionsweise dieser Technologie befassen und einige ihrer aufregenden Möglichkeiten erkunden.

Anwendungen zum Verstehen natürlicher Sprache

1. IVR und Nachrichtenrouting

   
   Interactive Voice Response (IVR)-Systeme sind automatisierte Telefonsysteme, die über vorab aufgezeichnete Sprachansagen und Menüs mit Kunden interagieren. IVR-Systeme nutzen NLU, um gesprochene Antworten zu erkennen und Anrufer an die entsprechende Abteilung oder den entsprechenden Agenten weiterzuleiten.

   NLU hilft IVR-Systemen auch dabei, Eingaben in natürlicher Sprache zu verstehen, sodass Kunden ihre Fragen sprechen können, anstatt durch Menüs zu navigieren.

2. Kundensupport

   
   NLU hat das Kundensupport-Erlebnis verändert und es schneller und effizienter gemacht. Chatbots und virtuelle Assistenten können viele Kundenanfragen bearbeiten und rund um die Uhr sofortige Antworten geben.

   Durch die Verarbeitung natürlicher Sprache und maschinelles Lernen können Chatbots Kundenanfragen verstehen und relevante Antworten geben. Diese Technologie ermöglicht es Chatbots auch, aus Kundeninteraktionen zu lernen und so ihre Antworten zu verbessern.

3. Maschinelle Übersetzung

   
   NLU spielt eine entscheidende Rolle bei der maschinellen Übersetzung (einem Zweig der KI), bei der Texte mithilfe von Computern von einer Sprache in eine andere übersetzt werden.

   NLU hat die maschinelle Übersetzung revolutioniert, indem es die Entwicklung neuronaler maschineller Übersetzungsmodelle (NMT) ermöglicht hat.

   NLU ist in NMT-Modellen von wesentlicher Bedeutung, da es dazu beiträgt, die Qualität maschineller Übersetzungen zu verbessern. Es verbessert die Fähigkeit des Modells, die Bedeutung und Absicht hinter dem Quelltext zu verstehen.

   Wenn ein Benutzer beispielsweise ein automatisches Sprachtool wie ein Wörterbuch zum Übersetzen von Informationen verwendet, werden die Wörter einfach eins zu eins ersetzt. Bei der maschinellen Übersetzung hingegen untersucht das System die Wörter in ihrem richtigen Kontext und erleichtert so die Erstellung einer präziseren Übersetzung.

Die Bedeutung von klinischem NLP im Gesundheitswesen

Mehrere Gesundheitseinrichtungen und Fachleute erkennen das Potenzial der klinischen Verarbeitung natürlicher Sprache (NLP) und integrieren deren Systeme in ihre Abläufe. Mithilfe der Informationsextraktion kann ein NLP-fähiges System nützliche Informationen hervorheben, und semantische Interpretationen können dabei helfen, die Bedeutung von handgeschriebenem Textual content zu verstehen. NLP geht noch einen Schritt weiter, um die Verbindung zwischen verschiedenen Informationen zu finden.

Mithilfe dieser Konzepte kann ein KI-NLP dabei helfen, die Stimmung der bereitgestellten Daten einzuschätzen. Neben der subjektiven Darstellung von Daten kann NLP auch dazu beitragen, die medizinische Abrechnung auf der Grundlage klinischer Notizen zu automatisieren und so die Genauigkeit und Geschwindigkeit zu erhöhen.

Darüber hinaus a Ein intestine trainiertes NLP-System kann prädiktive Analysen liefern basierend auf der Geschichte des Patienten und seinem Verständnis des menschlichen Körpers. Unter Berücksichtigung der klinischen Notizen, Patientendaten und Daten kann eine NLP-Lösung einer Gesundheitseinrichtung dabei helfen, Krankenhauseinweisungen und Krankheitsausbrüche zu extrapolieren.

Schlüsselanwendungen von klinischem NLP im Gesundheitswesen

NLP im Gesundheitswesen bietet zahlreiche Anwendungsmöglichkeiten, die es medizinischem Fachpersonal ermöglichen, ihre Arbeit zu verbessern und bessere Ergebnisse zu erzielen. Hier sind einige Anwendungen von NLP im Gesundheitswesen.

• Medizinische Kodierung: Pc-Assisted Coding (CAC) steht auf einem hohen Podest, wobei klinisches NLP Einzug hält. Unter Berücksichtigung der Datenextraktionsfunktionen von NLP können medizinische Informationen, klinische Begriffe, Verfahren, Medikamente, Diagnosen, Dienstleistungen und Geräte konvertiert werden. Der standardisierte Code kann bei der medizinischen Abrechnung, Qualitätskontrolle, medizinischen Forschung und Überwachungssystemen für die öffentliche Gesundheit hilfreich sein. Dadurch kann die Gesundheitsbranche enorm von höherer Effizienz, Genauigkeit und Geschwindigkeit profitieren.

• Klinische Entscheidungsunterstützung: Unter Berücksichtigung der prädiktiven Analysefähigkeiten von NLP können Ärzte damit bessere klinische Entscheidungen treffen. Mit dem Potenzial, medizinische Fehler zu reduzieren, können wir die computergestützte Infektionserkennung vorantreiben. Mithilfe von Daten aus klinischen Aufzeichnungen und seinen Algorithmen kann ein NLP-System für Ärzte und Ärztinnen zu einem wichtigen Werkzeug für eine gezielte Behandlung werden.

• Bevölkerungsgesundheitsmanagement: Die Fähigkeit von NLP, unstrukturierte Daten zu sortieren und zu organisieren, trägt durch sorgfältige Überwachung und Analyse zu Gesundheitsergebnissen bei. Mithilfe von Risikostratifizierungstechniken kann ein NLP-System Patientenakten auswerten, um Hochrisikopatienten zu identifizieren.

Darüber hinaus kann ein NLP-System mit der Analyse gesundheitlicher Ungleichheiten dabei helfen, gesundheitliche Ungleichheiten in der Bevölkerung zu erkennen. Auf dieser Grundlage können wir die gesundheitlichen Probleme und Bedenken bestimmter demografischer Gruppen identifizieren.

Zusätzlich zu diesen Anwendungen kann auch ein NLP-System helfen Arzneimittelentdeckung. NLP kann gezielt zielgerichtet helfen Patientenidentifizierung, Screening von Arzneimittelverbindungen, Gestaltung klinischer Studienverfahren und Rekrutierung von Patienten für Studien. Wir können NLP auch nutzen, um Chatbots zu betreiben, um Kunden virtuelle Assistenten zur Verfügung zu stellen.

Die Rolle medizinischer NLP-Datensätze

Daten sind heute allgegenwärtig, aber fragmentiert und vielfältig. Ein NLP-System kann unstrukturierte Daten verstehen, die Daten müssen jedoch eingespeist werden. Für das Kontextverständnis benötigt ein NLP-Modell Zugriff auf medizinische Datensätze. Diese Daten werden zum Parsen und Lesen zwischen den Zeilen verwendet.

Um einen NLP-Datensatz zu erstellen, müssen wir zunächst Etiketten erstellen. Fahren Sie zunächst mit der zügigen Erstellung der Etiketten anhand der vorgelegten Daten fort. Sobald Sie fertig sind, können Sie die Beschriftungen verfeinern und sie dann testen, um geeignete Verbindungen zu finden.

Befolgen Sie den gleichen Prozess, bis Sie verfeinerte, aber unstrukturierte Daten mit genauer Beschriftung haben. Apropos Kennzeichnung: Dies ist eine große Herausforderung bei der Erstellung medizinischer NLP-Datensätze. Zum einen benötigen wir angesichts der Komplexität des medizinischen Bereichs Fachwissen in der Kennzeichnung medizinischer Daten.

Eine weitere Herausforderung stellt die Annotation dar, insbesondere die Unstimmigkeiten bei der Datenkennzeichnung. Bei subjektiven Aufgaben und Elementen ist die Annotation komplexer, was zu Meinungsverschiedenheiten führen kann.

Das Scientific Pure Language Processing (NLP)-System ist für die biomedizinische Datenverarbeitung und deren effektive Analyse von wesentlicher Bedeutung. Durch die Integration von NLP in die Gesundheitsbranche können wir eine bessere Patientenversorgung, gezielte Behandlungen und präzisere Ergebnisse erzielen. Bei Insights AI arbeiten wir im KI-Bereich des Gesundheitswesens, um große Datensätze zu sammeln, zu kommentieren und zu de-identifizieren, um den NLP-Modellentwicklungsprozess zu vereinfachen.

Die NLP-Technologie gewinnt immer mehr an Bedeutung. Die Kombination von Informatik, Informationstechnik und künstlicher Intelligenz kann möglicherweise Sprachbarrieren beseitigen. Mit der NLP-Technologie können alle Parteien unabhängig von der für die Kommunikation verwendeten Sprache die Informationen in der ihnen bekannten Sprache anhören und lesen.

Pure Language Processing (NLP) trainiert Laptop, menschliche Sprachen zu verstehen. Es nutzt maschinelles Lernen, um kontinuierlich zu lernen und mehr Wissen zu erlangen. Dadurch wird die NLP-KI-Kombination immer intelligenter. Durch die Nutzung seiner Fähigkeiten, die ebenfalls zunehmend zunehmen, wird es leistungsfähiger und fortschrittlicher werden.

Was ist Pure Language Processing (NLP)?

Die Verarbeitung natürlicher Sprache ist ein Zweig der künstlichen Intelligenz, der seine Fähigkeiten nutzt, um Linguistik zu verstehen und intelligente Computerprogramme zu erstellen. Diese Programme sind in der Lage, Textual content und gesprochene Kommunikation wie Menschen zu verstehen. Aber die NLP-Technologie ist in der Lage, mehrere Sprachen gleichzeitig zu lernen und zu verstehen und sie in die Sprache Ihrer Wahl zu übersetzen.

Der NLP-Technologie kombiniert Computerlinguistik und regelbasierte Modellierung der Sprache mit maschinellem Lernen und Deep Studying. Auf diese Weise kann ein Laptop den Textual content oder das Audio verstehen, um ihn dann in eine andere Sprache zu übersetzen.

Auch heute noch haben wir mehrere Beispiele für NLP in der Praxis, z Siri, Google Assistant, Google Übersetzer, und einige Autosuggestions-Instruments. Die von Grammarly beim Schreiben von E-Mails oder in Suchmaschinen bereitgestellten Vorschläge werden alle mit der NLP-Technologie aktiviert.

Wie funktioniert die NLP-Technologie?

Die NLP-Technologie ermöglicht es einem Computerprogramm, menschliche Texte und Sprache zu verstehen. Da Laptop nur die binäre Sprache verstehen, die aus Nullen und Einsen besteht, brauchten wir ein System, um einen Laptop zunächst dazu zu bringen, Wörter zu verstehen.

Hierzu wird die Wortdarstellung genutzt, bei der Wörter in die Computersprache kodiert werden. Zu diesem Zweck werden mehrere Techniken verwendet, und One-Sizzling ist eine dieser Techniken.

Darüber hinaus wird eine Reihe von NLP-Techniken verwendet, um einem Laptop zu helfen, die menschliche Sprache zu verstehen. Dazu gehören:

• Stemming: Ein Prozess, bei dem ähnliche Wörter von Remaining auf ihr Ursprungswort gekürzt werden, z. B. Finalize, indem Alphabete nacheinander entfernt werden.
• Lemmatisierung: Hierbei handelt es sich um eine Technik, bei der die Wörter ausgehöhlt werden, um ihre bedeutungsvolle Grundstruktur zu finden.
• Tokenisierung: Bei dieser Technik werden Sätze in kleinere Blöcke zerlegt, um daraus Wörter, Symbole und Zahlen zu identifizieren.
• Stimmungsanalyse: Hierbei versucht ein Laptop, den Ton und die Emotion hinter dem Satz zu identifizieren.
• Begriffsklärung: Diese Technik wird verwendet, um festzustellen, ob dasselbe Wort unterschiedliche Bedeutungen hat, wenn es in verschiedenen Kontexten verwendet wird.
• Wortart-Tagging (POS): POS-Tagging wird verwendet, um jedes Wort im Textual content mit Anmerkungen zu versehen. Dazu gehört die Identifizierung von Verben, Adverbien, Substantiven, Adjektiven und allen anderen Wortarten.

Zusätzlich zu diesen Techniken verwendet ein NLP-Programm auch Algorithmen zum Verstehen von Textual content und Sprache, die von Menschen erstellt wurden. Das regelbasierte System wird verwendet, um die Regeln für die Linguistik zur Datenanalyse festzulegen.

Maschinelles Lernen ist ein wichtiger Teil des NLP, da es dazu dient, Trainingsdaten in das Computerprogramm einzuspeisen. Anhand dieser Daten kann das NLP-Programm seine Textual content- und Spracherkennungsmuster anpassen.

(Lesen Sie auch: Die 15 besten NLP-Datensätze zum Trainieren Ihrer NLP-Modelle)

Maschinelle Übersetzung für den Aufbau von NLP

Können Sie sich vorstellen, wie führende Persönlichkeiten der Welt an Treffen teilnehmen können, bei denen jeder seine Sprache spricht? Diese Treffen verfügen über ein Simultandolmetschersystem, das heißt, Computerprogramme und menschliche Dolmetscher arbeiten zusammen, um die Rede zu übersetzen und sie dann bei Bedarf in andere Sprachen umzuwandeln.

Während die Beseitigung aller Sprachbarrieren derzeit das ultimative Ziel der NLP-Technologie sein magazine, wächst und schreitet diese Technologie immer noch voran. Die NLP-Technologie macht dies durch den Einsatz maschineller Übersetzung möglich, bei der im Wesentlichen ein Computerprogramm zum Übersetzen von Textual content und Sprache verwendet wird.

Ausgehend von einer Section, in der Ungenauigkeiten im Vordergrund standen, hat die maschinelle Übersetzung durch Neural Machine Translation (NMT) Verbesserungen erfahren. NMT hat die Funktionsweise von NLP weiter verbessert und dadurch seine Übersetzungsfähigkeiten verbessert.

Hier sind die Vorteile der maschinellen Übersetzung im NLP:

• NLP-Programme können jetzt Bücher, Web sites und Produktdetails in Sekundenschnelle lesen und übersetzen.
• Es hat die Kosten und den Aufwand für die Übersetzung erheblich reduziert.
• Auch die Genauigkeit hat sich durch den Einsatz maschineller Lernalgorithmen erhöht.
• Unternehmen können den Übersetzungsprozess jetzt an ihre Anforderungen anpassen.

Dies ist möglich, weil NMT Deep-Studying-Methoden wie rekurrente neuronale Netze (RNN) und Aufmerksamkeitsmechanismen nutzt. Diese verbessern die Fähigkeiten eines NLP-Programms und erhöhen dessen Verständnis für sprachliche Regeln, Muster und die Verarbeitungsgeschwindigkeit für lange Sätze und Sätze mit komplexen Strukturen.

NMT hilft einem Programm, Wörter in Vektoren umzuwandeln und semantisch ähnliche Wörter zusammenzufügen. Das Programm generiert eine Folge von Vektoren oder Wörtern und generiert einen Satz. Von hier aus verwendet es das Encoder-Decoder-Framework, um den Eingabesatz in einem Vektorraum abzubilden, und der Decoder sendet den übersetzten Satz an die Schnittstelle.

Abschluss

Die Kombination von NLP, NMT, neuronalen Netzen und Deep-Studying-Mechanismen bringt erhebliche Verbesserungen bei der Textual content- und Spracherkennung und -übersetzung. Trotz aller Fortschritte in diesem Bereich sind menschliche Dolmetscher und Redakteure erforderlich, um das Gleichgewicht zu wahren. Für Unternehmen und Unternehmen, die ein eigenes Dolmetschersystem benötigen, wenden Sie sich an Shaip, um maßgeschneiderte KI-basierte Konversationslösungen mit NLP und maschineller Übersetzung zu erhalten.

Einführung

Pure Language Processing (NLP) ist der Prozess, durch den ein Laptop natürliche Sprache versteht. Die jüngsten Fortschritte in NLP bilden die Grundlage für die neue Era von Generative KI-Chatbots.

Die NLP-Architektur spielt im modernen Chatbot eine vielschichtige Rolle. Sie ermöglicht es diesen Chatbots, die von Ihnen gegebenen natürlichen Spracheingaben zu verstehen und hilft dem Chatbot, Wörter zu generieren. Diese neuen Fähigkeiten hängen von der Transformator Modell, ein neuartiges Modell, das 2017 von Google-Forschern entwickelt wurde.

Moderne Chatbots nutzen jedoch komplexe NLP-Algorithmen um Texte und Bilder zu verstehen. Lassen Sie uns diese Prozesse entschlüsseln, indem wir uns die Rolle von NLP ansehen.

Überblick:

• Die Rolle von NLP in modernen Chatbots: NLP spielt eine zentrale Rolle dabei, wie Chatbots Antworten verstehen und generieren. Dabei wird in hohem Maße auf Transformer-Modelle wie BERT und GPT für das Sprachverständnis, mehrstufige Konversationen und mehrsprachige Unterstützung zurückgegriffen.
• Kernkomponenten: Die aktuelle NLP-Landschaft umfasst Modelle zum Sprachverständnis (z. B. BERT, GPT), Mechanismen für mehrstufige Konversationen und mehrsprachige Unterstützung, die für globale Geschäftsanwendungen unverzichtbar ist.
• Herausforderungen in NLP: Trotz Fortschritten sind NLP-Modelle mit Einschränkungen im Umgang mit Umgangssprache, Rechtschreib-/Grammatikfehlern und ethischen Vorurteilen konfrontiert, was häufig zu Ungenauigkeiten oder verzerrten Ergebnissen führt.
• Bedeutung und Zukunftsaussichten: Während NLP-Technologien für die Chatbot-Funktionalität von entscheidender Bedeutung sind, müssen für weitere Fortschritte anhaltende Herausforderungen wie Voreingenommenheit, Halluzinationen und Fehlerbehandlung angegangen werden.

Rolle von NLP in modernen Chatbots

Moderne Chatbots nutzen Vektoreinbettungen um Textual content in Matrizen zu zerlegen, die dann zum Verstehen der von Ihnen gegebenen Eingabeaufforderungen verwendet werden können. Dies funktioniert folgendermaßen:

1. Ihre Eingabeaufforderungen werden tokenisiert: Tokenisierung ist ein maschineller Lernprozess, der eine große Datenmenge in kleinere Teile zerlegt. Im Fall Ihrer Eingabeaufforderungen werden Ihre Sätze in kleinere Teile zerlegt.

2. Diese Token werden dann mithilfe eines Transformatormodells verarbeitet: Modelle wie BERT Nehmen Sie die Eingabeaufforderung und vektorisieren Sie sie mithilfe eines „Self-Consideration“-Mechanismus.

3. Der Chatbot vergleicht Ihre Eingabe mit seinem eigenen Vektorraum: Laptop ermitteln virtuell die Distanz zwischen Ihrem immediate und ihre Trainingsdaten im Vektorraum, um die Wahrscheinlichkeit des nächsten Wortes in Ihrer Antwort zu berechnen.

4. Ihre Antwort wird generiert: Der Chatbot beantwortet dann Ihre Eingabe.

Es ist wichtig zu beachten, dass Chatbots zwar umfassend darauf abgestimmt sind, Antworten auf Ihre Fragen zu geben, die maschinelles Lernen (ML) Die Operation, die sie durchführen, ist die Vervollständigung. Sie nehmen Ihre Eingabeaufforderung entgegen und versuchen, das nächste Wort in der Sequenz basierend auf dem Kontext vorherzusagen.

Nachdem wir nun die grundlegenden NLP-Prozesse in unseren modernen Chatbots verstehen, wollen wir uns mit der aktuellen Architektur befassen, die wir für sie verwenden.

Die aktuelle NLP-Landschaft

Es gibt drei Hauptkomponenten der aktuellen NLP-Landschaft. Lassen Sie uns diese der Reihe nach untersuchen.

1. Sprachverständnis

BERT-Modelle: BERT-Modelle sind bidirektionale Modelle, die die Idee verwenden, dass Ihre Eingabe mit der Ausgabe verbunden ist, die sie generieren wird. Nachdem Ihr Eingabetext mithilfe eines Encoders vektorisiert wurde, konzentriert sich ein Decoder auf verschiedene Teile der Eingabe und gibt eine passende Anweisung aus. Diese Modelle verwenden den Selbstaufmerksamkeitsmechanismus aus dem Papier „Aufmerksamkeit ist alles, was Sie brauchen.”

GPT: GPT ist unidirektional und verwendet den Decoder aus der Transformer-Architektur. Dabei wird maskierte Selbstaufmerksamkeit verwendet, die Token in die Aufmerksamkeitsberechnung einbezieht, während zukünftige Token basierend auf ihrer Place in der Sequenz ignoriert werden.

Das Modell achtet additionally auf Ihre Eingabeaufforderung und geht bis zum letzten vorhergesagten Wort und sagt auf der Grundlage dieser Eingabe das folgende Wort in der Sequenz voraus.

XLNet und PaLM: Während das unidirektionale Modell der GPT mithilfe eines großen Datenkorpus viele Fragen beantworten konnte, fehlte ihm immer noch der bidirektionale Kontext, der zum Verständnis komplexer Daten erforderlich ist.

Die PaLM-Modelle erreichten dies, indem sie ein unidirektionales Modell verwendeten und dabei die Reihenfolge änderten, in der die Token gelesen werden, sodass das Modell Token je nach dynamischer Faktorisierung lesen konnte. Dies ermöglicht bidirektionales Verständnis in einem unidirektionalen Modell.

2. Multi-Flip-Gespräche

Mehrstufige Konversationen sind für unsere modernen Chatbots von entscheidender Bedeutung. Die Leute möchten längere Gespräche mit ChatGPT und Claude führen und sich an die Dinge erinnern, die sie zuvor gesagt haben.

Jetzt müssen Sie zwei Funktionen hinzufügen, damit Chatbots mehrstufige Konversationen ermöglichen.

Kontextuelles Verständnis

Wenn ein Benutzer seine ursprüngliche Anfrage im weiteren Verlauf des Gesprächs aktualisieren möchte, muss sich der Chatbot den Kontext des Gesprächs merken. Moderne Chatbots tun dies, indem sie jede vom Benutzer übermittelte Anfrage zu strukturierten Daten hinzufügen, um genaue Informationen zu liefern. Das heißt, sie nehmen alle Nachrichten des Benutzers auf, um eine einheitliche Datenstruktur zu erstellen. Wir haben diese Funktion kürzlich bei Kommunicate eingeführt und Das so funktioniert es.

Dialogrichtlinien

Manchmal fordert ein Benutzer einen Chatbot auf, etwas zu Spezielles zu tun, oder gibt eine Eingabeaufforderung ein, die nicht den Geschäftsrichtlinien des Chatbots entspricht. In diesem Fall bezieht sich der Chatbot auf einige interne Konversationsregeln oder Dialogrichtlinien. Im Geschäftsleben bedeutet dies häufig, dass der Chatbot eine Datenbank abfragt und dem Benutzer klärende Fragen stellt, bis die Anforderung seinen Geschäftsrichtlinien entspricht.

Mehrstufige Konversationen sind das Herzstück des Versprechens der Generativen KI. Sie ermöglichen Chatbots, längere Gespräche mit Benutzern zu führen und ihre Bedürfnisse besser zu erfüllen. Das ist auch der Grund, warum „Kontextlänge„“ ist seit einigen Jahren ein regelrechtes Schlagwort rund um LLMs.

3. Mehrsprachiger Assist

Da LLMs für allgemeine geschäftliche Anwendungsfälle entwickelt werden, ist die Integration von Mehrsprachigkeit unerlässlich. So können moderne Chatbots für globale Unternehmen eingesetzt werden, ohne dass zusätzliche Schulungen für bestimmte Standorte erforderlich sind.

Chatbots beantworten mehrsprachige Fragen nach dem folgenden Verfahren:

Eingabeaufforderung in Daten ändern: Der Chatbot nimmt die Eingabeaufforderung in jeder beliebigen Sprache entgegen und setzt sie in einen linguistischen Rahmen, den er versteht. Der grundlegende linguistische Rahmen für LLMs ist oft Englisch, daher übersetzt er die Eingabeaufforderung in Daten und analysiert diese Daten auf der Grundlage des englischen linguistischen Rahmens.

Aufgabenlösung: Der Chatbot denkt sich die Antwort auf die Eingabeaufforderung auf Englisch aus und integriert dabei Daten von mehrsprachigen Neuronen in das Modell. LLMs verwenden Self-Consideration- und Feedforward-Mechanismen, um zur Antwort zu gelangen.

Ausgabe generieren: Das LLM erhält seine Antwort in Kind von im linguistischen Rahmen angeordneten Daten und übersetzt diese anschließend zurück in die ursprüngliche Abfragesprache.

Mehrere Modelle, wie Coheres Aya-Modellezeichnen sich durch die Bereitstellung mehrsprachiger Unterstützung aus, da sie anhand von von Experten kuratierten mehrsprachigen Datensätzen mit einem „übermäßigen Schwerpunkt auf Dokumenten im akademischen Stil“ geschult wurden.

Mit diesen drei grundlegenden Funktionen bietet NLP den aktuellen LLM-Modellen umfangreiche Funktionalität. Die aktuelle NLP-Architektur weist jedoch noch einige Probleme auf. Lassen Sie uns diese Einschränkungen als Nächstes untersuchen.

Einschränkungen und Herausforderungen in der NLP

Trotz der rasanten Entwicklung von NLP-Modellen gibt es immer noch einige Einschränkungen in ihrer Funktionsweise. Diese sind:

1. Umgang mit Umgangssprache

Slang ist ein natürlicher Bestandteil menschlicher Konversation. Einige LLMs haben jedoch Schwierigkeiten, Slangausdrücke zu verstehen. Beispielsweise bedeutet „blazing“ in den USA „etwas Ausgezeichnetes“, in Großbritannien jedoch „Wut“ und die meisten LLMs kommen mit dieser Diskrepanz nicht klar.

Die größte Herausforderung beim Umgang mit Slang-Begriffen ist der Mangel an qualitativ hochwertigen Datensätzen, die ihre Bedeutung erklären. Selbst moderne Modelle wie ChatGPT 4 Es fehlen ausreichende Daten, um Slangausdrücke zu identifizieren.

2. Umgang mit Rechtschreib- und Grammatikfehlern

Neuere Chatbot-Modelle können zwar Fehler erkennen, haben aber Probleme, diese zu korrigieren. Das kann dazu führen, dass der LLM zwar versucht, eine Eingabesequenz zu korrigieren, dabei aber deren Bedeutung ändert und Ihnen mit seinen Antworten falsche Ergebnisse liefert.

Dies kann durch umfangreiche Feinabstimmung und Heuristik gelöst werden, was Anwendungen wie Grammarly und Google Search zuvor in anderen ML-Kontexten getan haben.

3. Ethische Voreingenommenheit und Unrichtigkeit

Halluzinationen und KI-Voreingenommenheit sind ein andauerndes Drawback. Im Wesentlichen könnten weniger bekannte Nuancen übersehen werden, da Trainingsdatensätze eine Voreingenommenheit gegenüber bestimmten Philosophien aufweisen könnten.

Wenn eine KI keine Antwort findet, versucht sie oft, eine Antwort zu finden und gibt falsche Informationen, indem sie halluziniert. Diese beiden Probleme werden derzeit intensiv erforscht, aber es gibt noch keine empirischen Lösungen.

Abschluss

NLP ist für die Funktion von Chatbots von zentraler Bedeutung. Es wird für alles verwendet, von der Tokenisierung und Vektorisierung Ihrer Eingabeaufforderungen bis hin zur Bereitstellung der vom Benutzer angeforderten Antworten.

Dies ist dank der aktuellen NLP-Architektur möglich, die mehrere Transformer-Modelle verwendet, um Sprache in all ihren Formen zu verstehen. Die Architektur unterstützt auch längere Kontextlängen und mehrsprachige Neuronen, die mehrstufige und mehrsprachige Konversationen ermöglichen.

Obwohl dieser Fortschritt beträchtlich ist, gibt es bei der NLP-Technologie immer noch vielschichtige Herausforderungen. Derzeit hat die Technologie Probleme mit der Rechtschreibprüfung, Grammatikfehlern und umgangssprachlichen Ausdrücken im Eingabetext. Die aktuelle NLP-Technologie ist immer noch anfällig für Halluzinationen und Voreingenommenheit.

Trotz dieser Herausforderungen ist NLP für das moderne Chatbot-Ökosystem von entscheidender Bedeutung und ermöglicht ihm, ein breites Aufgabenspektrum zu bewältigen.

Häufig gestellte Fragen

Bild vom Autor

Seit der Einführung bekannter Giant Language Fashions (LLMs) wie ChatGPT interessieren sich viele Menschen für den Sprachgebrauch. Wir sehen, wie stark sich diese LLMs auf unser tägliches Leben auswirken, und einige möchten in dieses boomende Feld wechseln.

Wenn Sie jedoch einen Berufswechsel planen, denken Sie zunächst über die Schritte nach, die erforderlich sind, um den Fuß in die Tür zu bekommen. Manchmal können diese Schritte sehr kostspielig sein. Möglicherweise müssen Sie zur Universität zurückkehren oder sich für anerkannte Kurse anmelden usw.

Es kann schwierig sein, seine Karriere voranzutreiben und seine Fähigkeiten zu verbessern, ohne auf die Kosten zu achten. Wenn Sie sich additionally für Pure Language Processing (NLP) interessieren, mehr darüber erfahren oder Ihre Karriere in diese Richtung lenken möchten, ist dieser Weblog genau das Richtige für Sie.

Spezialisierung „Grundlagen der Datenwissenschaft“

Verknüpfung: Spezialisierung „Grundlagen der Datenwissenschaft“
Niveau: Anfänger
Dauer: 1 Monat mit 10 Wochenstunden

Wenn Sie neu in der Welt der Datenwissenschaft sind oder Ihre Grundkenntnisse in diesem Sektor auffrischen möchten, sehen Sie sich diesen Spezialisierungskurs für Anfänger der College of California, Irvine an.

In diesem Kurs erhalten Sie einen Überblick über die Grundlagen der Datenwissenschaft und tauchen tief in die wichtigsten Fähigkeiten, Techniken und Konzepte der Datenwissenschaft ein. Der Kurs beginnt mit grundlegenden Konzepten wie der analytischen Taxonomie, dem branchenübergreifenden Standardprozess für Knowledge Mining und der Datendiagnose und vergleicht dann die Datenwissenschaft mit klassischen statistischen Techniken. Der Kurs bietet auch einen Überblick über die gängigsten Techniken der Datenwissenschaft, darunter Datenanalyse, statistische Modellierung, Datentechnik, Manipulation von Daten im großen Maßstab (Huge Knowledge), Algorithmen für Knowledge Mining, Datenqualität, Behebung und Konsistenzoperationen.

Einführung in die Verarbeitung natürlicher Sprache in Python

Verknüpfung: Einführung in die Verarbeitung natürlicher Sprache in Python
Niveau: Mittel
Dauer: 4 Stunden

Ein weiterer Kurs, wenn Sie sich die Grundlagen der NLP aneignen möchten, ist diese Einführung in NLP in Python von DataCamp.

In diesem Kurs lernen Sie die Grundlagen der NLP, z. B. wie Sie Wörter erkennen und trennen, Themen in einem Textual content extrahieren und Ihren eigenen Faux-Information-Klassifikator erstellen. Sie lernen auch, wie Sie grundlegende Bibliotheken wie NLTK sowie Bibliotheken verwenden, die Deep Studying nutzen, um gängige NLP-Probleme zu lösen. Dieser Kurs vermittelt Ihnen die Grundlagen zum Verarbeiten und Parsen von Texten, während Sie mit dem Erlernen von Python fortfahren.

Erstellen von KI-gestützten Chatbots ohne Programmierung

Verknüpfung: Erstellen von KI-gestützten Chatbots ohne Programmierung
Niveau: Anfänger
Dauer: 12 Stunden (ungefähr)

Wenn Sie sich mehr für NLP im Zusammenhang mit Chatbots interessieren, werden in diesem von IBM angebotenen Anfängerkurs die Vorteile von Chatbots und ihre Nützlichkeit bei Aufgaben wie dem Kundensupport erläutert. Sie lernen, wie Sie mit Watson Assistant einen nützlichen Chatbot erstellen, ohne Code zu schreiben, und wie Sie Verhalten und Ton angeben, um Ihren Chatbot zu verbessern und benutzerfreundlich zu gestalten. Entwickeln, testen und implementieren Sie einen Chatbot auf einer WordPress-Web site und interagieren Sie mit ihm.

Dieser Einzelkurs ist Teil von zwei Spezialisierungskursen: IBM AI Developer Skilled-Zertifikat Und Spezialisierung „KI-Grundlagen für alle“. Wenn Sie an einem ausführlicheren Kurs interessiert sind, schauen Sie sich diesen an.

Spezialisierung auf natürliche Sprachverarbeitung

Verknüpfung: Spezialisierung auf natürliche Sprachverarbeitung
Niveau: Mittel
Dauer: 3 Monate à 10 Wochenstunden

Wenn Sie über grundlegende Kenntnisse in NLP verfügen und bereit sind, Ihre Fähigkeiten zu verfeinern, sehen Sie sich diesen Spezialisierungskurs für Fortgeschrittene von DeepLearning.AI an.

In diesem Kurs verwenden Sie logistische Regression, naive Bayes und Wortvektoren, um Stimmungsanalysen durchzuführen, Analogien zu vervollständigen und Wörter zu übersetzen. Sie verwenden auch dynamische Programmierung, Hidden-Markov-Modelle und Wort-Embeddings, um Autokorrektur und Autovervollständigung zu implementieren und Wortarten-Tags für Wörter zu identifizieren. Damit ist es noch nicht getan – Sie verwenden rekurrierende neuronale Netzwerke, LSTMs, GRUs und siamesische Netzwerke in Trax für Stimmungsanalysen, Textgenerierung und Named-Entity-Erkennung sowie Encoder-Decoder, Kausal- und Selbstaufmerksamkeit, um ganze Sätze maschinell zu übersetzen, Texte zusammenzufassen, Chatbots zu erstellen und Fragen zu beantworten.

Verarbeitung natürlicher Sprache in der Google Cloud

Verknüpfung: Verarbeitung natürlicher Sprache in der Google Cloud
Niveau: Fortgeschritten
Dauer: 13 Stunden (ungefähr)

Wenn Sie bereit sind, auf die nächste Ebene zu gehen und einen Schritt weiter zu gehen, sehen Sie sich diesen NLP-Kurs von Google an. Dieser Kurs stellt die Produkte und Lösungen zur Lösung von NLP-Problemen in Google Cloud vor. Darüber hinaus werden die Prozesse, Techniken und Instruments zur Entwicklung eines NLP-Projekts mit neuronalen Netzwerken unter Verwendung von Vertex AI und TensorFlow untersucht.

Sie lernen außerdem die NLP-Produkte und -Lösungen in Google Cloud kennen und erstellen mithilfe von AutoML mit Vertex AI einen Finish-to-Finish-NLP-Workflow. Erfahren Sie, wie Sie mithilfe von TensorFlow verschiedene NLP-Modelle erstellen, darunter DNN, RNN, LSTM und GRU. Lernen Sie fortgeschrittene NLP-Modelle wie Encoder-Decoder, Aufmerksamkeitsmechanismen, Transformatoren und BERT kennen, verstehen Sie Transferlernen und wenden Sie vorab trainierte Modelle an, um NLP-Probleme zu lösen.

Dieser Kurs ist Teil des Spezialisierung „Erweitertes maschinelles Lernen in der Google Cloud“.

Einpacken

Ich hoffe, ich konnte Sie in diesem Weblog durch die verschiedenen Kurse führen, die Sie belegen können, wenn Sie sich für die NLP-Branche interessieren. Wenn Sie Kurse kennen, die Sie empfehlen würden, schreiben Sie sie in die Kommentare!

Nisha Arya ist Datenwissenschaftlerin, freiberufliche technische Redakteurin und Redakteurin und Neighborhood-Managerin für KDnuggets. Sie ist besonders daran interessiert, Karriereberatung oder Tutorials für die Datenwissenschaft sowie theoriebasiertes Wissen rund um die Datenwissenschaft bereitzustellen. Nisha deckt ein breites Themenspektrum ab und möchte die verschiedenen Möglichkeiten erkunden, wie künstliche Intelligenz die Langlebigkeit des menschlichen Lebens verbessern kann. Als eifrige Lernerin möchte Nisha ihr technisches Wissen und ihre Schreibfähigkeiten erweitern und gleichzeitig anderen helfen, Anleitung zu geben.