Freigeben über

Laden von Daten aus Dateien und anderen Quellen

  • Artikel

Diese Anleitung zeigt Ihnen, wie Sie Daten mithilfe der API für die Verarbeitung und das Training in ML.NET laden. Die Daten werden ursprünglich in Dateien oder anderen Datenquellen wie Datenbanken, JSON, XML oder In-Memory-Sammlungen gespeichert.

Wenn Sie den Modell-Generator verwenden, finden Sie weitere Informationen unter Laden von Trainingsdaten in den Modell-Generator.

Erstellen des Datenmodells

Mit ML.NET können Sie Datenmodelle über Klassen definieren. Nehmen wir zum Beispiel die folgenden Eingabedaten:

Size (Sq. ft.), HistoricalPrice1 ($), HistoricalPrice2 ($), HistoricalPrice3 ($), Current Price ($)
700, 100000, 3000000, 250000, 500000
1000, 600000, 400000, 650000, 700000

Erstellen Sie ein Datenmodell, das den folgenden Codeschnipsel darstellt:

public class HousingData
{
    [LoadColumn(0)]
    public float Size { get; set; }

    [LoadColumn(1, 3)]
    [VectorType(3)]
    public float[] HistoricalPrices { get; set; }

    [LoadColumn(4)]
    [ColumnName("Label")]
    public float CurrentPrice { get; set; }
}

Kommentieren des Datenmodells mit Spaltenattributen

Attribute geben ML.NET mehr Informationen über das Datenmodell und die Datenquelle.

Das LoadColumn-Attribut gibt die Spaltenindizes Ihrer Eigenschaften an.

Wichtig

LoadColumn ist nur erforderlich, wenn Daten aus einer Datei geladen werden.

Spalten werden folgendermaßen geladen:

  • Als Einzelspalten, wie Size und CurrentPrices in der HousingData-Klasse
  • In mehreren Spalten gleichzeitig in Form eines Vektors wie HistoricalPrices in der HousingData-Klasse

Wenn Sie eine Vektoreigenschaft haben, wenden Sie das VectorType-Attribut auf die Eigenschaft in Ihrem Datenmodell an. Alle Elemente im Vektor müssen denselben Typ aufweisen. Die Trennung der Spalten ermöglicht einfaches und flexibles Feature Engineering, aber bei einer großen Anzahl von Spalten führt die Bearbeitung der einzelnen Spalten zu einem negativen Einfluss auf die Trainingsgeschwindigkeit.

ML.NET arbeitet mit Spaltennamen. Wenn die Spalte einen anderen Namen als den Eigenschaftsnamen haben soll, verwenden Sie das ColumnName-Attribut. Beim Erstellen von In-Memory-Objekten erstellen Sie Objekte weiterhin unter Verwendung des Eigenschaftsnamens. Für die Datenverarbeitung und die Erstellung von Machine Learning-Modellen überschreibt und referenziert ML.NET jedoch die Eigenschaft mit dem im ColumnName-Attribut angegebenen Wert.

Laden von Daten aus einer Einzeldatei

Um Daten aus einer Datei zu laden, verwenden Sie die LoadFromTextFile-Methode mit dem Datenmodell für die zu ladenden Daten. Da der separatorChar-Parameter standardmäßig mit Tabstopptrennzeichen getrennt ist, ändern Sie ihn bei Bedarf für Ihre Datendatei. Wenn Ihre Datei einen Header hat, setzen Sie den hasHeader-Parameter auf true, um die erste Zeile in der Datei zu ignorieren und mit dem Laden von Daten aus der zweiten Zeile zu beginnen.

//Create MLContext
MLContext mlContext = new MLContext();

//Load Data
IDataView data = mlContext.Data.LoadFromTextFile<HousingData>("my-data-file.csv", separatorChar: ',', hasHeader: true);

Laden von Daten aus mehreren Dateien

Wenn Ihre Daten in mehreren Dateien gespeichert sind, können Sie mit ML.NET Daten aus mehreren Dateien laden, die sich entweder im gleichen Verzeichnis oder in mehreren Verzeichnissen befinden, solange das Datenschema gleich ist.

Laden von Dateien in einem einzigen Verzeichnis

Wenn sich alle Ihre Datendateien im gleichen Verzeichnis befinden, verwenden Sie in der LoadFromTextFile-Methode Platzhalter.

//Create MLContext
MLContext mlContext = new MLContext();

//Load Data File
IDataView data = mlContext.Data.LoadFromTextFile<HousingData>("Data/*", separatorChar: ',', hasHeader: true);

Laden von Dateien in mehreren Verzeichnissen

Um Daten aus mehreren Verzeichnissen zu laden, verwenden Sie die CreateTextLoader-Methode, um einen TextLoader zu erstellen. Verwenden Sie dann die TextLoader.Load-Methode, und geben Sie die einzelnen Dateipfade an (Platzhalter können nicht verwendet werden).

//Create MLContext
MLContext mlContext = new MLContext();

// Create TextLoader
TextLoader textLoader = mlContext.Data.CreateTextLoader<HousingData>(separatorChar: ',', hasHeader: true);

// Load Data
IDataView data = textLoader.Load("DataFolder/SubFolder1/1.txt", "DataFolder/SubFolder2/1.txt");

Laden von Daten aus einer relationalen Datenbank

ML.NET unterstützt das Laden von Daten aus einer Vielzahl von relationalen Datenbanken, die von System.Data unterstützt werden, darunter SQL Server, Azure SQL-Datenbank, Oracle, SQLite, PostgreSQL, Progress, IBM DB2 und viele mehr.

Hinweis

Um DatabaseLoaderzu verwenden, verweisen Sie auf das NuGet-Paket System. Data. SqlClient.

Bei einer Datenbank mit einer Tabelle mit dem Namen House und dem folgenden Schema:

CREATE TABLE [House] (
    [HouseId] INT NOT NULL IDENTITY,
    [Size] INT NOT NULL,
    [NumBed] INT NOT NULL,
    [Price] REAL NOT NULL
    CONSTRAINT [PK_House] PRIMARY KEY ([HouseId])
);

Die Daten können durch eine Klasse wie HouseData modelliert werden:

public class HouseData
{
    public float Size { get; set; }
    public float NumBed { get; set; }
    public float Price { get; set; }
}

Erstellen Sie dann in der Anwendung eine DatabaseLoader-Klasse.

MLContext mlContext = new MLContext();

DatabaseLoader loader = mlContext.Data.CreateDatabaseLoader<HouseData>();

Definieren Sie die Verbindungszeichenfolge sowie den SQL-Befehl, der für die Datenbank ausgeführt werden soll, und erstellen Sie eine DatabaseSource-Instanz. Dieses Beispiel verwendet eine LocalDB-SQL Server-Datenbank mit einem Dateipfad. DatabaseLoader unterstützt jedoch jede andere gültige Verbindungszeichenfolge für lokale Datenbanken und Clouddatenbanken.

Wichtig

Microsoft empfiehlt, immer den sichersten Authentifizierungsflow zu verwenden. Wenn Sie eine Verbindung mit Azure SQL herstellen, ist Managed Identities for Azure Resources die empfohlene Authentifizierungsmethode.

string connectionString = @"Data Source=(LocalDB)\MSSQLLocalDB;AttachDbFilename=<YOUR-DB-FILEPATH>;Database=<YOUR-DB-NAME>;Integrated Security=True;Connect Timeout=30";

string sqlCommand = "SELECT CAST(Size as REAL) as Size, CAST(NumBed as REAL) as NumBed, Price FROM House";

DatabaseSource dbSource = new DatabaseSource(SqlClientFactory.Instance, connectionString, sqlCommand);

Numerische Daten, die nicht vom Typ Real sind, müssen in Real konvertiert werden. Der Real-Typ wird als Gleitkommawert mit einfacher Genauigkeit oder Single dargestellt (der von ML.NET-Algorithmen erwartete Eingabetyp). In diesem Beispiel sind die Spalten Size und NumBed ganze Zahlen in der Datenbank. Mithilfe der integrierten Funktion CAST wird sie in Real konvertiert. Da die Price-Eigenschaft bereits vom Typ Real ist, wird sie unverändert geladen.

Verwenden Sie die Load-Methode, um die Daten in ein IDataView-Element zu laden.

IDataView data = loader.Load(dbSource);

Laden von Bildern

Um Bilddaten aus einem Verzeichnis zu laden, erstellen Sie zuerst ein Modell, das den Bildpfad und eine Bezeichnung enthält. ImagePath ist der absolute Pfad des Bilds im Datenquellenverzeichnis. Label ist die Klasse oder Kategorie der tatsächlichen Bilddatei.

public class ImageData
{
    [LoadColumn(0)]
    public string ImagePath;

    [LoadColumn(1)]
    public string Label;
}

public static IEnumerable<ImageData> LoadImagesFromDirectory(string folder,
            bool useFolderNameAsLabel = true)
{
    string[] files = Directory.GetFiles(folder, "*", searchOption: SearchOption.AllDirectories);

    foreach (string file in files)
    {
        if (Path.GetExtension(file) != ".jpg")
            continue;

        string label = Path.GetFileName(file);

        if (useFolderNameAsLabel)
            label = Directory.GetParent(file).Name;
        else
        {
            for (int index = 0; index < label.Length; index++)
            {
                if (!char.IsLetter(label[index]))
                {
                    label = label.Substring(0, index);
                    break;
                }
            }
        }

        yield return new ImageData()
        {
            ImagePath = file,
            Label = label
        };
    }
}

Laden Sie dann das Bild:

IEnumerable<ImageData> images = LoadImagesFromDirectory(
                folder: "your-image-directory-path",
                useFolderNameAsLabel: true
                );

Erstellen Sie zum Laden von In-Memory-Rohbildern aus einem Verzeichnis ein Modell, um das Bytearray und die Beschriftung des Rohbilds zu speichern:

public class InMemoryImageData
{
    [LoadColumn(0)]
    public byte[] Image;

    [LoadColumn(1)]
    public string Label;
}

static IEnumerable<InMemoryImageData> LoadInMemoryImagesFromDirectory(
    string folder,
    bool useFolderNameAsLabel = true
    )
{
    string[] files = Directory.GetFiles(folder, "*",
        searchOption: SearchOption.AllDirectories);
    foreach (string file in files)
    {
        if (Path.GetExtension(file) != ".jpg")
            continue;

        string label = Path.GetFileName(file);
        if (useFolderNameAsLabel)
            label = Directory.GetParent(file).Name;
        else
        {
            for (int index = 0; index < label.Length; index++)
            {
                if (!char.IsLetter(label[index]))
                {
                    label = label.Substring(0, index);
                    break;
                }
            }
        }

        yield return new InMemoryImageData()
        {
            Image = File.ReadAllBytes(file),
            Label = label
        };

    }
}

Laden von Daten aus anderen Quellen

Zusätzlich zum Laden von Daten, die in Dateien gespeichert sind, unterstützt ML.NET das Laden von Daten aus verschiedenen Quellen:

  • In-Memory-Sammlungen
  • JSON/XML

ML.NET erwartet bei der Arbeit mit Streamingquellen, dass die Eingabe in Form einer In-Memory-Sammlung erfolgt. Achten Sie daher bei der Arbeit mit Quellen wie JSON/XML darauf, die Daten in eine In-Memory-Sammlung zu formatieren.

Schauen Sie sich die folgende in-Memory-Sammlung an:

HousingData[] inMemoryCollection = new HousingData[]
{
    new HousingData
    {
        Size =700f,
        HistoricalPrices = new float[]
        {
            100000f, 3000000f, 250000f
        },
        CurrentPrice = 500000f
    },
    new HousingData
    {
        Size =1000f,
        HistoricalPrices = new float[]
        {
            600000f, 400000f, 650000f
        },
        CurrentPrice=700000f
    }
};

Laden Sie die in-Memory-Sammlung mit der LoadFromEnumerable-Methode in eine IDataView:

Wichtig

LoadFromEnumerable geht davon aus, dass das IEnumerable-Element, aus dem es geladen wird, threadsicher ist.

// Create MLContext
MLContext mlContext = new MLContext();

//Load Data
IDataView data = mlContext.Data.LoadFromEnumerable<HousingData>(inMemoryCollection);

Nächste Schritte