Partager via

Charger des données depuis des fichiers et d’autres sources

  • Article

Découvrez comment charger des données dans ML.NET en utilisant l’API pour le traitement et l’apprentissage. Les données sont stockées à l’origine dans des fichiers ou d’autres sources de données, comme des bases de données, du JSON, du XML ou des collections en mémoire.

Si vous utilisez Model Builder, consultez Charger des données d’entraînement dans Model Builder.

Créer le modèle de données

ML.NET permet de définir des modèles de données par le biais de classes. Soit les données d’entrée suivantes :

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

Créez un modèle de données qui représente l’extrait de code ci-dessous :

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; }
}

Annoter le modèle de données avec des attributs de colonne

Les attributs donnent à ML.NET plus d’informations sur le modèle de données et la source de données.

L’attribut LoadColumn spécifie les index de colonne de vos propriétés.

Important

LoadColumn est nécessaire uniquement lors du chargement de données à partir d’un fichier.

Chargez les colonnes en tant que :

  • Des colonnes individuelles, comme Size et CurrentPrices dans la classe HousingData.
  • Plusieurs colonnes à la fois sous la forme d’un vecteur, comme HistoricalPrices dans la classe HousingData.

Si vous avez une propriété de vecteur, appliquez-lui l’attribut VectorType dans votre modèle de données. Tous les éléments du vecteur doivent être du même type. Le fait de conserver les colonnes séparées permet de faciliter et d’assouplir l’ingénierie de caractéristiques, mais pour un très grand nombre de colonnes, travailler sur les colonnes individuelles a un impact sur la vitesse d’apprentissage.

ML.NET fonctionne en utilisant les noms de colonne. Si vous souhaitez nommer une colonne en autre chose que le nom de propriété, utilisez l’attribut ColumnName. Quand vous créez des objets en mémoire, vous le faites toujours en utilisant le nom de propriété. Toutefois, pour le traitement des données et la génération des modèles Machine Learning, ML.NET remplace la propriété et la référence avec la valeur fournie dans l’attribut ColumnName.

Charger des données à partir d’un fichier spécifique

Pour charger des données depuis un fichier, utilisez la méthode LoadFromTextFile avec le modèle de données pour les données à charger. Le paramètre separatorChar étant par défaut défini sur le caractère de tabulation, changez-le pour votre fichier de données si cela est nécessaire. Si votre fichier a un en-tête, définissez le paramètre hasHeader sur true pour ignorer la première ligne du fichier et commencer à charger les données à partir de la deuxième ligne.

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

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

Charger des données à partir de plusieurs fichiers

Si vos données sont stockées dans plusieurs fichiers, tant que le schéma de données est le même, ML.NET vous permet de charger les données, que les différents fichiers se trouvent dans le même répertoire ou dans plusieurs répertoires.

Effectuer le chargement à partir de fichiers situés dans le même répertoire

Si tous vos fichiers de données se trouvent dans le même répertoire, utilisez des caractères génériques dans la méthode LoadFromTextFile.

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

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

Effectuer le chargement à partir de fichiers situés dans plusieurs répertoires

Pour charger des données à partir de plusieurs répertoires, utilisez la méthode CreateTextLoader pour créer un TextLoader. Ensuite, utilisez la méthode TextLoader.Load et spécifiez les différents chemins de fichiers (vous ne pouvez pas utiliser de caractères génériques).

//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");

Charger des données depuis une base de données relationnelle

ML.NET prend en charge le chargement de données à partir d’une variété de bases de données relationnelles prises en charge par System.Data, qui incluent SQL Server, Azure SQL Database, Oracle, SQLite, PostgreSQL, Progress, IBM DB2 et beaucoup d’autres.

Notes

Pour utiliser DatabaseLoader, référencez le package NuGet System.Data.SqlClient.

Étant donné une base de données avec une table nommée House et le schéma suivant :

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])
);

Les données peuvent être modélisées par une classe telle que HouseData :

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

Ensuite, dans votre application, créez un DatabaseLoader.

MLContext mlContext = new MLContext();

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

Définissez votre chaîne de connexion ainsi que la commande SQL à exécuter sur la base de données, et créez une instance DatabaseSource. Cet exemple utilise une base de données SQL Server LocalDB avec un chemin de fichier. Cependant, DatabaseLoader prend en charge n’importe quelle autre chaîne de connexion valide pour les bases de données locales et dans le cloud.

Important

Microsoft vous recommande d’utiliser le flux d’authentification le plus sécurisé disponible. Si vous vous connectez à Azure SQL, les identités managées pour les ressources Azure sont la méthode d'authentification recommandée.

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);

Les données numériques qui ne sont pas de type Real doivent être converties en Real. Le type Real est représenté sous la forme d’une valeur à virgule flottante simple précision ou Single, le type d’entrée attendu par les algorithmes ML.NET. Dans cet exemple, les colonnes Size et NumBed sont des entiers dans la base de données. En utilisant la fonction intégrée CAST, elle est convertie en Real. Comme la propriété Price est déjà de type Real, elle est chargée telle quelle.

Utilisez la méthode Load pour charger les données dans une IDataView.

IDataView data = loader.Load(dbSource);

Charger des images

Pour charger des données d’image depuis un répertoire, commencez par créer un modèle qui inclut le chemin d’accès des images et une étiquette. ImagePath est le chemin absolu de l’image dans le répertoire qui est la source de données. Label est la classe ou la catégorie du fichier image réel.

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
        };
    }
}

Chargez ensuite l’image :

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

Pour charger des images brutes en mémoire depuis le répertoire, créez un modèle destiné à contenir le tableau d’octets et l’étiquette des images brutes :

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
        };

    }
}

Charger des données depuis d’autres sources

En plus du chargement de données stockées dans des fichiers, ML.NET prend en charge le chargement de données depuis des sources qui incluent :

  • Collections en mémoire
  • JSON/XML

Quand vous utilisez des sources de streaming, ML.NET s’attend à ce que l’entrée soit sous la forme d’une collection en mémoire. Ainsi, quand vous utilisez des sources telles que JSON/XML, veillez à convertir les données en une collection en mémoire.

Soit la collection en mémoire suivante :

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
    }
};

Chargez la collection en mémoire dans un IDataView avec la méthode LoadFromEnumerable :

Important

La méthode LoadFromEnumerable suppose que l’IEnumerable à partir duquel elle est chargée est thread-safe.

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

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

Étapes suivantes