trennen – chatgpz.de – KI-Tools & Praxiswissen

Trennen Sie Zahlen und Textual content mithilfe von Energy Question in einer Spalte

admin — Tue, 16 Dec 2025 23:26:07 +0000

[ad_1]

Dies ist ein typischer Fall für Self-Service BI mit Excel-Daten.

Vor ein paar Tagen stellte mir ein Kunde folgende Frage:

Ich habe eine Excel-Tabelle mit Zahlen und Textual content in einer Spalte. Ich möchte dieses Blatt in Energy BI importieren und eine Analyse der Zahlen in dieser Spalte durchführen.

Wie kann ich die Zahlen vom Textual content in dieser Spalte trennen?

Denken Sie daran, dass ich auch den Textual content in dieser Spalte benötige.

Ich struggle noch nie in dieser Scenario gewesen, additionally begann ich zunächst mit der Technik, die ich kannte.

Ich habe ein Dummy-Excel mit dem gleichen Drawback erstellt, das so aussieht:

Abbildung 1 – Beispieldaten in Excel (Abbildung vom Autor)

Um einen PoC zu erstellen, habe ich diese Daten zunächst in eine SQL Server-Datenbank geladen, um dort zu sehen, wie ich sie lösen kann.

Lösung des Issues mithilfe von SQL

T-SQL verfügt über zwei Funktionen, die in solchen Szenarien hilfreich sind:

TRY_CONVERT()
- Dieser versucht, einen Wert in einen Zieldatentyp umzuwandeln. Wenn dies fehlschlägt, wird NULL zurückgegeben.
ISNUMERIC()
- Prüft, ob ein Wert ein numerischer Wert ist. Wenn ja, wird 1 zurückgegeben. Andernfalls 0.

Basierend auf diesem Wissen habe ich eine Abfrage geschrieben, um die Werte in zwei Spalten aufzuteilen. Eines mit den Zahlen und eines mit dem Textual content:

SELECT (Values)

            ,TRY_CONVERT(decimal(18, 5), (Values))         AS    (Quantity)

            ,IIF(ISNUMERIC((Values)) = 0, (Values), NULL) AS    (Textual content)

  FROM (dbo).(MixedValues);

Das Ergebnis ist die folgende Tabelle:

Abbildung 2 – T-SQL-Abfrage zum Trennen der Zahlen vom Textual content (Abbildung vom Autor)

Wenn Sie genau hinschauen, sehen Sie, dass Zeile 17 als Textual content erkannt wird.

Dies liegt daran, dass die Nummer ein Leerzeichen enthält.

Ich werde später darauf zurückkommen.

Wechsel zu Energy Question – IsNaN() ausprobieren

Jetzt habe ich Excel in Energy Question geladen.

Ich habe die Spalte als Textual content definiert und mit der Arbeit an dieser Herausforderung begonnen.

Der erste Versuch verwendet die Quantity.IsNaN() Funktion.

Diese Funktion gibt true zurück, wenn der Wert NaN ist. „NaN“ ist ein Platzhalter für nicht zutreffend, beispielsweise aufgrund einer Division durch 0.

Ich habe dies versucht, um festzustellen, ob ein Textual content NaN entspricht.

Dies ist der M-Code für die berechnete Spalte:

if Quantity.IsNaN((Worth)) = true
then (Worth)
else null

Das Ergebnis hat mich überrascht:

Abbildung 3 – Ergebnis mit Quantity.IsNaN(). Warum erkennt diese Funktion keine Zahlen? (Abbildung vom Autor)

Das Ergebnis ist seltsamerweise, dass eine Zahl nicht in eine Zahl umgewandelt werden kann.

Ich nehme an, dass dies geschieht, weil der Datentyp der Spalte Textual content ist.

Dann habe ich versucht, die Spalte in eine Zahl umzuwandeln und die Funktion IsNaN() auf das Ergebnis anzuwenden:

if Quantity.IsNaN(Quantity.From((Worth))) = false
then Quantity.From((Worth))
else null

Jetzt werden die Zahlen in Zahlen umgewandelt, aber die Textwerte führen zu einem Fehler:

Abbildung 4 – Die Anwendung von IsNaN() auf die konvertierten Werte gibt die Zahlen zurück, aber einen Fehler für den Textual content (Abbildung vom Autor)

Jetzt funktioniert die Logik für Zahlen.

Die Konvertierung schlägt jedoch für die Zeilen fehl, die Textual content enthalten. Dies führt zu Zeilen mit Fehlern.

Versuchen Sie Worth.Is() in Energy Question

Versuchen wir es mit einer anderen Funktion: Worth.Is()

Diese Funktion prüft, ob ein Wert mit einem Datentyp kompatibel ist.

Dies sollte der oben gezeigten Funktion ISNUMERIC() entsprechen:

if Worth.Is((Worth), Quantity.Sort) = true
then Quantity.From((Worth))
else null

Leider konnte auch diese Funktion nicht das erwartete Ergebnis zurückgeben:

Abbildung 5 – Ergebnis beim Ausprobieren der Funktion Worth.Is() (Abbildung vom Autor)

Als ich den gleichen Ansatz wie oben ausprobierte, indem ich zuerst den Wert in eine Zahl umwandelte, erhielt ich das gleiche Ergebnis wie zuvor:

Abbildung 6 – Fehler beim Versuch, die Werte zunächst in eine Zahl umzuwandeln (Abbildung vom Autor)

Daher vermute ich, dass die Funktion Worth.Is() einen Zahlendatentyp erwartet, aber das ergibt für mich keinen Sinn.

Zu diesem Zeitpunkt hatte ich keine Zeit für tiefergehende Recherchen, da mir die Zeit knapp wurde.

Es struggle an der Zeit, den Ansatz zu ändern.

Schaltkonzept

Jetzt habe ich untersucht, wie man Fehler in Energy Question abfängt.

Meine Idee struggle: Was wäre, wenn ich den Konvertierungsfehler erkennen und diese Informationen nutzen könnte?

Ich habe diese Seite mit nützlichen Informationen gefunden: Fehler – PowerQuery M | Microsoft Study

Daraus leitete ich diesen Ausdruck ab:

attempt Quantity.From((Worth)))

Nachdem ich eine berechnete Spalte mit diesem Ausdruck hinzugefügt hatte, erhielt ich dieses Ergebnis:

Abbildung 7 – Ergebnis mit attempt (Abbildung vom Autor)

Ich struggle optimistisch, da mir kein Fehler unterlaufen ist.

Als nächstes galt es, die Datensätze zu erweitern:

Abbildung 8 – Erweitern Sie den Wert aus der Report-Ausgabe des Attempt-Aufrufs (Abbildung vom Autor)

Ich brauchte die Fehlerspalten nicht, sondern nur die Wertspalte.

Dies ist das Ergebnis nach der Erweiterung:

Abbildung 9 – Ergebnis nach der Erweiterung der Datensätze (Abbildung vom Autor)

Beachten Sie, dass ich die Spalten direkt in der Funktion ExpandRecordColumn() umbenannt habe.
Andernfalls hätte ich eine Spalte mit dem Namen (Wert.1) erhalten.

Dieses Ergebnis struggle das erste, bei dem ich keine Fehler erhielt.

Jetzt habe ich eine berechnete Spalte hinzugefügt, um zu überprüfen, ob die neue Spalte leer ist. Wenn ja, dann enthielt die ursprüngliche Wertspalte einen Textual content:

if (Numeric Worth) = null then (Worth) else null

Hier das Ergebnis:

Abbildung 10 – Ergebnis der erfolgreichen Trennung von Zahlen- und Textwerten aus einer Spalte (Abbildung vom Autor)

Nachdem ich die richtigen Datentypen festgelegt und die ursprüngliche Wertspalte entfernt hatte, erhielt ich diese Tabelle:

Abbildung 11 – Ergebnis nach der Bereinigung (Abbildung vom Autor)

Behandeln Sie die Nummer mit Leerzeichen

Aber wir haben immer noch Zeile 17, die eine Zahl mit einem Leerzeichen enthielt.

Wie bin ich damit umgegangen?

Der einfachste Ansatz bestand darin, alle Leerzeichen aus der Spalte „Wert“ zu entfernen:

Abbildung 12 – Fügen Sie einen Aufruf „Substitute Worth“ hinzu, um Leerzeichen aus den Daten zu entfernen (Abbildung vom Autor)

Aber ich musste diesen Schritt hinzufügen, bevor ich mit den Schritten zum Trennen der beiden Werttypen beginnen konnte:

Abbildung 13 – Fügen Sie den Schritt „Wert ersetzen“ an der richtigen Stelle hinzu (Abbildung vom Autor)

Nach dem Hinzufügen dieses Schritts wird Zeile 17 als Zahl erkannt und korrekt gespeichert.

Hier sind die Daten nach dem Laden in Energy BI:

Abbildung 14 – Bereinigen von Daten nach dem Laden in Energy BI (Abbildung vom Autor)

Dies funktionierte jedoch nur, wenn die Textwerte einzelne Wörter waren. Es funktionierte nicht, wenn dort Sätze oder mehrere Wörter gespeichert waren.

Abschluss

Dies struggle ein faszinierender Ausflug in die Funktionsweise von Energy Question oder der M-Sprache mit Datentypen.

Ich bin mir immer noch nicht sicher, was die Fehlerursachen sind.

Aber ich habe gelernt, wie man mit Fehlern umgeht oder wie man den Attempt-Aufruf verwendet und die Ausgabe verarbeitet.

Das struggle sehr hilfreich.

Wie Sie am Originalwert in Zeile 17 sehen können, ist die Datenqualität jedenfalls von größter Bedeutung.

Ich habe einen anderen Kunden, bei dem Benutzer aus verschiedenen Ländern an derselben Excel-Datei mit ihren eigenen Zahlenformaten arbeiten.

Das ist ein Albtraum, denn Excel ist gegenüber Datentypen äußerst tolerant. Es akzeptiert alles, auch wenn die Spalte als Zahl formatiert ist.

In dieser Scenario muss ich Benutzer dazu zwingen, die Formatierungsoptionen von Excel zu verwenden, um sicherzustellen, dass Zahlen konsistent als solche erkannt werden.

Ohne dies habe ich keine Likelihood, diese Daten ohne großen Aufwand zur Bereinigung der Zahlen in Energy BI zu importieren.

Und seien Sie versichert, dass Benutzer immer einen Weg finden, Zahlen in Excel durcheinander zu bringen.

Referenzen

Die Daten werden mit Zufallszahlen und Wörtern erstellt.

Hier ist die Referenz für die M-Sprache: Energy Question M-Formelsprachenreferenz – PowerQuery M | Microsoft Study

[ad_2]

Warum können wir YAML nicht von ML trennen?

admin — Tue, 19 Nov 2024 18:15:47 +0000

[ad_1]

Was das allseits beliebte Python vs. R vs. Julia vs. Scala betrifft …

Es ist bereits entschieden und die richtige Antwort ist YAML. Es hat jemals ML im Namen!

(Bild oder Einbettung)

— Alex Gude (@alexgude.com) 27. Oktober 2024 um 17:23 Uhr

Warum kann ich nicht einfach Code schreiben?

Mir stehen 10 Jahre und halb so viele Jobs in den Bereichen Datenwissenschaft und maschinelles Lernen bevor. Egal was passiert, in jeder Rolle erfinde ich eine Programmiersprache auf Foundation von YAML neu, um Modelle für maschinelles Lernen zu trainieren.

Am Anfang steht ein Drehbuch.

import pandas as pd
from sklearn.linear_model import LogisticRegression

df = pd.read_csv("dataset.csv", parse_dates=("timestamp"))
y = df("label")
ts = df("timestamp")
X = df.drop(columns=("label", "timestamp"))
train_mask = ts < "2022-01-01"
test_mask = ts >= "2022-01-01"

X_train, y_train = X(train_mask), y(train_mask)
X_test, y_test = X(test_mask), y(test_mask)

mannequin = LogisticRegression(C=10, random_state=666)
mannequin = mannequin.match(X_train, y_train)

Sie stellen fest, dass Sie Parameter im Code manuell ändern, additionally verschieben Sie die Parameter in eine Befehlszeilenschnittstelle (CLI).

import typer

app = typer.Typer()

@app.command()
def major(filename: str, start_date: str, end_date: str):
    df = pd.read_csv(filename, parse_dates=("timestamp"))
    y = df("label")
    ts = df("timestamp")
    X = df.drop(columns=("label", "timestamp"))
    train_mask = ts < start_date
    test_mask = ts >= end_date
    
    X_train, y_train = X(train_mask), y(train_mask)
    X_test, y_test = X(test_mask), y(test_mask)
    
    mannequin = LogisticRegression(C=10, random_state=666)
    mannequin = mannequin.match(X_train, y_train)


# if __name__ == "__main__":
#     app()

Sie stellen jedoch fest, dass Sie ständig Parameter hinzufügen und Schaltpunkte manuell entwerfen.

from sklearn.ensemble import RandomForestClassifier

def get_model(model_type: str):
    if model_type == "lr":
        return LogisticRegression(C=10, random_state=666)
    elif model_type == "rf":
        return RandomForestClassifier(random_state=666)

def get_train_data(train_start_date: str, train_end_date: str):
    ...

def get_test_data(test_start_date: str, test_end_date: str):
    ...

Sie haben jetzt zu viele CLI-Parameter, um sie im Kopf zu behalten, und Du kannst dich nicht erinnern Welche davon hast du gestern bei diesem Lauf verwendet? Sie kommen additionally auf die kluge Idee, alle Ihre Parameter in einer einzigen Konfigurationsdatei zusammenzufassen. Sie entscheiden sich für YAML, weil es einfacher zu verwenden ist als JSON, und Sie wissen immer noch nicht wirklich, was TOML ist.

Ihre von Hand entworfenen Schaltpunkte sind nun tatsächlich Knotenpunkte in einem großen Ganzen DAG. Sie möchten maximale Flexibilität und treiben die Konfigurationssprache mit benutzerdefinierten Konstruktoren an ihre Grenzen Python-Klassen dynamisch instanziieren Und Importieren Sie andere Yaml-Dateien.

Sie lehnen sich zurück und staunen über die Schönheit der deklarativen Konfiguration.

mannequin:
  !Load 
  cls: sklearn.ensemble.RandomForestClassifier
  params:
    n_estimators: 3000
    random_state: 666

information: 
  practice: !Embody ../information/train_config.yaml
  take a look at: !Embody ../information/test_config.yaml

Sie geben Ihr wunderschönes Konfigurations-Framework an den Relaxation des Groups weiter, und niemand hat eine Ahnung, was zum Teufel los ist.

Hoppla! Es stellt sich heraus, dass Sie eine vollwertige Programmiersprache ohne moderne Vorteile erstellt haben. Globale YAML-Knoten werden in mehreren Dateien verwendet, ohne dass Referenzen nachverfolgt werden können. Die Typvalidierung ist minimal. Die IDE und mypy sind sich all dieser Python-Referenzen, die in YAML lauern, nicht bewusst. Und am Ende schreiben wir nicht-pythonischen Code, der für die Arbeit mit YAML gezwungen wurde.

Vor ein paar Jahren habe ich angefangen, die ganze Sache mitzureden.

Es struggle leicht, selbstgefällig zu predigen, dass die Leute einfach nur Code schreiben sollten. Einfach verwenden pydantisch statt YAML! Ich habe das sogar in einer früheren Rolle getan.

Wie alles beim Programmieren ist das leichter gesagt als getan. Obwohl alles typvalidiertes, auf Pydantic basierendes Python struggle, haben wir irgendwie immer noch viel zu viel Zeit damit verbracht, den Code in das von uns erstellte Konfigurationsframework einzupassen.

Warum kann ich nicht einfach Code schreiben?

Was ist das Besondere an ML?

Endlich wurde mir klar, warum es schwierig ist, einfach nur Code zu schreiben. Es gibt drei Hauptanforderungen für ein ML-Konfigurationssystem:

1. Die Möglichkeit, im gesamten DAG unterschiedlichen Code aufzurufen.

ML ist Forschung. Es ist Experimentieren. Es erfordert Iteration und Flexibilität.

Ich möchte verschiedene Klassifikatoren, verschiedene Verlustfunktionen, verschiedene Vorverarbeitungsmethoden usw. ausprobieren… Der einfachste Weg, dies zu unterstützen, besteht darin, das Schreiben und Aufrufen von Code zuzulassen.

Wir möchten Parameter nicht tief in einer verschachtelten DAG manuell ändern, um mit Dingen zu experimentieren. Wir definieren lieber alle unsere Parameter zu Beginn des DAG und überlassen den Relaxation dann dem DAG-Code.

2. Lazy-Instanziierung von Klassen in der DAG.

Wenn ich ein vorab trainiertes Modell verfeinere, möchte ich nicht das gesamte vorab trainierte Modell herunterladen müssen, wenn ich meine Konfiguration definiere.

# Some fast imports

import logging
import warnings

import transformers
from pydantic import BaseModel, ConfigDict
from transformers import AutoModelForSequenceClassification, PreTrainedModel

transformers.logging.set_verbosity(logging.ERROR)
warnings.filterwarnings("ignore", class=UserWarning, module="pydantic.*")
warnings.filterwarnings("ignore", class=UserWarning, module="tqdm.*")

Im folgenden Code wird das gesamte BERT heruntergeladen, wenn ich mein Konfigurationsobjekt definiere. Sie können sich schlimmere Szenarien vorstellen, bei denen die Instanziierung eines Modells die Zuweisung großer Mengen an GPU-Speicher erfordert. Wir sollten dies nicht tun, wenn unsere Konfiguration definiert ist. Dies ist besonders schlimm, wenn wir einen verteilten Trainingsjob ausführen und warten müssen, bis wir uns auf einem bestimmten Knoten befinden, bevor wir das Modell instanziieren.

# Dangerous
class TrainingConfig(BaseModel):
    model_config = ConfigDict(arbitrary_types_allowed=True)
    mannequin: PreTrainedModel
    

config = TrainingConfig(
    # The mannequin weights get downloaded when defining the config.
    mannequin=AutoModelForSequenceClassification.from_pretrained(
        "bert-base-uncased"
    )
)

Daher sollte die Modellinstanziierung so lange wie möglich verzögert werden.

# Higher
class TrainingConfig(BaseModel):
    model_id: str 

config = TrainingConfig(model_id="bert-base-uncased")

...

# Someday Later
mannequin = AutoModelForSequenceClassification.from_pretrained(
    config.model_id
)

3. Verfolgung aller Konfigurations(hyper)parameter

Wir führen beim Coaching von ML-Modellen so viele Experimente durch, dass wir für Experiment-Tracker wie diesen bezahlen müssen Gewichte und Voreingenommenheiten. Entscheidend für die Experimentverfolgung ist die Verfolgung der Änderungen zwischen verschiedenen Trainingsläufen. Der einfachste Weg, dies in einem Device wie W&B zu tun, besteht darin, die gesamte Konfiguration in ein Wörterbuch einzutragen und das Diktat für einen bestimmten Lauf zu protokollieren.

Es stellt sich heraus, dass diese Monitoring-Anforderung im direkten Widerspruch dazu steht, „nur Code zu schreiben“.

Es ist ganz einfach, einfach den Code zu schreiben, um ein Modell in PyTorch zu instanziieren:

import torch 

class MyModel(torch.nn.Module):
    def __init__(
        self, 
        num_features: int, 
        num_classes: int,
        hidden_size: int = 128
    ):
        tremendous().__init__()
        self.num_features = num_features
        self.num_classes = num_classes
        self.hidden_size = hidden_size
        self.layers = torch.nn.Sequential(
            torch.nn.Linear(num_features, self.hidden_size),
            torch.nn.ReLU(),
            torch.nn.Linear(self.hidden_size, num_classes)
        )
    
    def ahead(self, x):
        return self.layers(x)
    
mannequin = MyModel(1_000, 16)

Aber jetzt kann ich die Konstruktorargumente des Modells nicht verfolgen.

Ein Nebeneffekt der Sicherstellung der Nachverfolgbarkeit unserer Konfiguration besteht darin, dass wir einen Anschein von Reproduzierbarkeit erhalten, da unsere Konfiguration in etwas wie JSON oder YAML serialisierbar sein muss. Ein Grund, warum YAML so beliebt ist, ist, dass wir nichts serialisieren müssen!

Warum können wir YAML nicht von ML trennen?

YAML löst alle unsere Anforderungen.

Wir können benutzerdefinierte Konstruktoren schreiben, um beliebigen Code in unserer DAG aufzurufen.
Wenn wir unsere Konfiguration instanziieren, wird kein Python-Code instanziiert
YAML ist leicht nachverfolgbar und reproduzierbar.

Das Downside ist natürlich alles, was ich eingangs erwähnt habe.

Was sind die Lösungen?

Wenn Sie mit der Umgestaltung Ihrer gesamten Codebasis einverstanden sind, sollten Sie dafür sorgen, dass alle Ihre Klassen ein einziges Konfigurationsobjekt als Argumente verwenden. Dadurch werden alle drei Probleme gelöst und Sie erhalten schöne, strukturierte Nicht-YAML-Konfigurationen.

from typing import Kind

import torch

class MyModelConfig(BaseModel):
    num_features: int
    num_classes: int
    hidden_size: int = 128

class MyModel(torch.nn.Module):
    def __init__(self, config: MyModelConfig):
        tremendous().__init__()
        self.config = config
        self.layers = torch.nn.Sequential(
            torch.nn.Linear(config.num_features, config.hidden_size),
            torch.nn.ReLU(),
            torch.nn.Linear(config.hidden_size, config.num_classes)
        )
    
    def ahead(self, x):
        return self.layers(x)

class TrainingConfig(BaseModel):
    model_config = ConfigDict(arbitrary_types_allowed=True)
    model_cls: Kind(MyModel)
    model_cfg: MyModelConfig


# No fashions are instantiated within the config.
config = TrainingConfig(
    model_cls=MyModel,
    model_cfg=MyModelConfig(num_features=100, num_classes=10)
)
# Lazy-load the mannequin.
mannequin = config.model_cls(config.model_cfg)

Sie können sogar versuchen, etwas ausgefallener zu sein und die Klassenkonfigurationen innerhalb der Klasse zu definieren, sodass sie immer miteinander gekoppelt sind. Dies macht es einfach, die Klasse dynamisch zu instanziieren, allein basierend auf der Klassenkonfiguration.

import importlib

def load_config(config: BaseModel):
    module = config.__class__.__module__
    guardian = config.__class__.__qualname__.break up(".")(0)
    return getattr(importlib.import_module(module), guardian)(config)


class MyModel(torch.nn.Module):
    class Config(BaseModel):
        num_features: int
        num_classes: int
        hidden_size: int = 128
    def __init__(self, config: Config):
        tremendous().__init__()
        self.config = config
        self.layers = torch.nn.Sequential(
            torch.nn.Linear(config.num_features, config.hidden_size),
            torch.nn.ReLU(),
            torch.nn.Linear(config.hidden_size, config.num_classes)
        )
    
    def ahead(self, x):
        return self.layers(x)

class TrainingConfig(BaseModel):
    model_config = ConfigDict(arbitrary_types_allowed=True)
    model_cfg: BaseModel


config = TrainingConfig(
    model_cfg=MyModel.Config(num_features=100, num_classes=10)
)
mannequin = load_config(config.model_cfg)

Das Downside bei diesem Ansatz besteht natürlich darin, dass die gesamte Codebasis umgestaltet werden muss. Dies wird auch besonders unangenehm, da dafür eine Konfiguration erstellt werden muss alleseinschließlich Klassen, die Sie lieber nicht träge instanziieren möchten.

Was ich finde, ist, dass die Leute häufig eine Umgestaltung ihrer Codebasis vermeiden, indem sie separate Konfigurationen erstellen, die ihren Klassenkonstruktorargumenten entsprechen.

class MyModelConfig(BaseModel):
    num_features: int
    num_classes: int
    hidden_size: int = 128

class MyModel(torch.nn.Module):
    def __init__(
        self, 
        num_features: int, 
        num_classes: int,
        hidden_size: int = 128
    ):
        ...

Die Codeduplizierung hier ist schmerzhaft.

Eine bessere Lösung bewirkt drei Dinge:

Kein Refactoring des Klassenkonstruktors. Nennen Sie Klassen so, wie sie aufgerufen werden würden.
Verfolgen Sie alle Argumente des Klassenkonstruktors an einem serialisierbaren, zentralen Ort.
Irgendwie Auch Erlauben Sie Lazy-Instantion, auch wenn die Klassenkonstruktoren aufgerufen werden.

Schritt 3 kann übersprungen werden, wenn Sie eine Umgestaltung durchführen, um sicherzustellen, dass alle Konstruktoren des Modells „leichtgewichtig“ sind und nichts wie das Herunterladen riesiger Gewichte, die Zuweisung von viel GPU-Speicher usw. erfordert… aber das stellt große Einschränkungen für Ihre Codebasis dar.

Gibt es eine Lösung für alle 3 Schritte? Ich habe es noch nicht gesehen, aber ich habe einige Ideen. Ich brauche nur etwas mehr Zeit, um sie langsam zu laden.

[ad_2]