DataOperationsCatalog.ShuffleRows Metodo

Definizione

Spazio dei nomi:

Microsoft.ML

Assembly:

Microsoft.ML.Data.dll

Pacchetto:

Microsoft.ML v3.0.1

Eseguire lo shuffle delle righe di input.

public Microsoft.ML.IDataView ShuffleRows (Microsoft.ML.IDataView input, int? seed = default, int shufflePoolSize = 1000, bool shuffleSource = true);

member this.ShuffleRows : Microsoft.ML.IDataView * Nullable<int> * int * bool -> Microsoft.ML.IDataView

Public Function ShuffleRows (input As IDataView, Optional seed As Nullable(Of Integer) = Nothing, Optional shufflePoolSize As Integer = 1000, Optional shuffleSource As Boolean = true) As IDataView

Parametri

input

IDataView

Dati di input.

seed

Nullable<Int32>

Valore di inizializzazione casuale. Se non specificato, lo stato casuale verrà invece derivato da MLContext.

shufflePoolSize

Int32

Numero di righe da contenere nel pool. Se si imposta su 1, la sequenza casuale del pool verrà disattivata e ShuffleRows(IDataView, Nullable<Int32>, Int32, Boolean) verrà eseguita solo una sequenza input casuale leggendo in un ordine casuale.

shuffleSource

Boolean

Se false, la trasformazione non tenterà di leggere input in un ordine casuale e userà solo il pooling per eseguire la sequenza casuale. Questo parametro non ha alcun effetto se la CanShuffle proprietà di input è false.

Restituisce

IDataView

Esempio

using System;
using System.Collections.Generic;
using Microsoft.ML;

namespace Samples.Dynamic
{
    public static class ShuffleRows
    {
        // Sample class showing how to shuffle rows in 
        // IDataView.
        public static void Example()
        {
            // Create a new context for ML.NET operations. It can be used for
            // exception tracking and logging, as a catalog of available operations
            // and as the source of randomness.
            var mlContext = new MLContext();

            // Get a small dataset as an IEnumerable.
            var enumerableOfData = GetSampleTemperatureData(5);
            var data = mlContext.Data.LoadFromEnumerable(enumerableOfData);

            // Before we apply a filter, examine all the records in the dataset.
            Console.WriteLine($"Date\tTemperature");
            foreach (var row in enumerableOfData)
            {
                Console.WriteLine($"{row.Date.ToString("d")}" +
                    $"\t{row.Temperature}");
            }
            Console.WriteLine();
            // Expected output:
            //  Date    Temperature
            //  1/2/2012        36
            //  1/3/2012        36
            //  1/4/2012        34
            //  1/5/2012        35
            //  1/6/2012        35

            // Shuffle the dataset.
            var shuffledData = mlContext.Data.ShuffleRows(data, seed: 123);

            // Look at the shuffled data and observe that the rows are in a
            // randomized order.
            var enumerable = mlContext.Data
                .CreateEnumerable<SampleTemperatureData>(shuffledData,
                reuseRowObject: true);

            Console.WriteLine($"Date\tTemperature");
            foreach (var row in enumerable)
            {
                Console.WriteLine($"{row.Date.ToString("d")}" +
                $"\t{row.Temperature}");
            }
            // Expected output:
            //  Date    Temperature
            //  1/4/2012        34
            //  1/2/2012        36
            //  1/5/2012        35
            //  1/3/2012        36
            //  1/6/2012        35
        }

        private class SampleTemperatureData
        {
            public DateTime Date { get; set; }
            public float Temperature { get; set; }
        }

        /// <summary>
        /// Get a fake temperature dataset.
        /// </summary>
        /// <param name="exampleCount">The number of examples to return.</param>
        /// <returns>An enumerable of <see cref="SampleTemperatureData"/>.</returns>
        private static IEnumerable<SampleTemperatureData> GetSampleTemperatureData(
            int exampleCount)

        {
            var rng = new Random(1234321);
            var date = new DateTime(2012, 1, 1);
            float temperature = 39.0f;

            for (int i = 0; i < exampleCount; i++)
            {
                date = date.AddDays(1);
                temperature += rng.Next(-5, 5);
                yield return new SampleTemperatureData
                {
                    Date = date,
                    Temperature =
                    temperature
                };

            }
        }
    }
}

Commenti

ShuffleRows(IDataView, Nullable<Int32>, Int32, Boolean) riformerà in modo casuale le righe di qualsiasi input IDataView usando un approccio di streaming. Per non caricare l'intero set di dati in memoria, verrà usato un pool di shufflePoolSize righe per selezionare in modo casuale le righe da restituire. Il pool viene costruito dalle prime shufflePoolSize righe in input. Le righe verranno quindi restituite in modo casuale dal pool e sostituite con la riga successiva da input finché non vengono restituite tutte le righe, con conseguente nuova IDataView dimensione della stessa dimensione input , ma con le righe in un ordine casuale. Se la CanShuffle proprietà di input è true, verrà letta anche nel pool in un ordine casuale, offrendo due origini di casualità.