ExpressionEstimator Classe

Définition

public sealed class ExpressionEstimator : Microsoft.ML.IEstimator<Microsoft.ML.Transforms.ExpressionTransformer>

type ExpressionEstimator = class
    interface IEstimator<ExpressionTransformer>

Public NotInheritable Class ExpressionEstimator
Implements IEstimator(Of ExpressionTransformer)

Héritage

Object

ExpressionEstimator

Implémente

IEstimator<ExpressionTransformer>

Remarques

Caractéristiques de l’estimateur

ExpressionTransformer résultant crée une colonne, nommée comme spécifié dans les paramètres de nom de colonne de sortie, où l’expression est appliquée aux valeurs d’entrée. Au plus une des colonnes d’entrée peut être de type VectorDataViewType, et lorsque l’entrée contient une colonne vectorielle, l’expression est calculée indépendamment sur chaque élément du vecteur, pour créer une sortie vectorielle de la même longueur que cette entrée.

Langage d’expression

La langue de l’estimateur d’expression doit être confortable pour un large éventail d’utilisateurs. Il partage de nombreuses similitudes avec certaines langues populaires. Il respecte la casse, prend en charge plusieurs types et dispose d’un ensemble complet d’opérateurs et de fonctions. Il est purement fonctionnel, dans le sens où il n’y a pas de valeurs mutables ou d’opérations de mutation dans le langage. Il n’a pas, ni besoin, de mécanisme d’exception, au lieu de produire des valeurs NA lorsqu’une valeur normale n’est pas appropriée. Il est typé de manière statique, mais tous les types sont déduits par le compilateur.

Syntax

La syntaxe de l’lambda se compose d’une liste de paramètres suivie des deux-points (:) ou flèche (=>) suivies d’une expression. La liste de paramètres peut être un identificateur unique ou une liste séparée par des virgules d’un ou plusieurs identificateurs entourés de parenthèses.

Lambda:

• parameter-list : expression
• parameter-list => expression

parameter-list :

• identifier
• (parameter-names)

parameter-names :

• identifier
• identifier , parameter-names

L’expression peut utiliser des paramètres, des littéraux, des opérateurs, des with-expressions et des fonctions.

Littéraux

• Les littéraux booléens sont true et false.
• Les littéraux entiers peuvent être décimaux ou hexadécimaux (par exemple, 0x1234ABCD). Ils peuvent être suffixes avec you ou U, indiquant unsigned, ainsi que l ou L, indiquant long (Int64). L’utilisation de vous ou de U est rare et affecte uniquement la promotion de certaines valeurs hexadécimales 32 bits, en déterminant si la constante est considérée comme une valeur Int32 négative ou une valeur Int64 positive.
• Les littéraux à virgule flottante utilisent la syntaxe standard, y compris la notation exponentielle (123,45e-37). Ils peuvent être suffixes de f ou F, indiquant une précision unique, ou d ou D, indiquant une double précision. Contrairement à C#, la précision par défaut d’un littéral à virgule flottante est une précision unique. Pour spécifier une double précision, ajoutez d ou D.
• Les littéraux de texte sont placés entre guillemets doubles et prennent en charge les mécanismes d’échappement standard.

Opérateurs

Les opérateurs de la langue d’expression sont répertoriés dans le tableau suivant, dans l’ordre de précédence. Sauf indication contraire, les opérateurs binaires restent associatifs et propagent les valeurs NA (si l’une des valeurs de l’opérande est NA, le résultat est NA). En règle générale, le dépassement des valeurs entières produit NA, tandis que le dépassement de valeurs à virgule flottante produit l’infini.

L’expression With

La syntaxe de with-expression est la suivante :

with-expression :

• with( assignment-list ; expression )

assignment-list :

• affectation
• assignment , assignment-list

Affectation:

• expression d’identificateur =

L’expression with introduit une ou plusieurs valeurs nommées. Par exemple, l’expression suivante convertit une température celcius en fahrenheit, puis génère un message selon que le fahrenheit est trop faible ou élevé.

c => with(f = c * 9 / 5 + 32 ; f < 60 ? "Too Cold!" : f > 90 ? "Too Hot!" : "Just Right!")

L’expression d’une affectation peut référencer les identificateurs introduits par les affectations précédentes, comme dans cet exemple qui retourne -1, 0 ou 1 au lieu des messages :

c : with(f = c * 9 / 5 + 32, cold = f < 60, hot = f > 90 ; -float(cold) + float(hot))

Comme illustré ci-dessus, with-expression est utile lorsqu’une valeur d’expression est nécessaire plusieurs fois dans une expression plus grande. Il est également utile quand vous traitez des constantes complexes ou significatives :

    ticks => with(
        ticksPerSecond = 10000000L,
        ticksPerHour = ticksPerSecond \* 3600,
        ticksPerDay = ticksPerHour \* 24,
        day = ticks / ticksPerDay,
        dayEpoch = 1 ;
        (day + dayEpoch) % 7)

Cela calcule le jour de la semaine à partir du nombre de cycles (sous la forme d’un Int64) depuis l’époque .Net DateTime standard (01/01/0001 dans le calendrier grégorien idéalisé). Les affectations sont utilisées pour le nombre de cycles en une seconde, le nombre de cycles en une heure, le nombre de cycles dans une année et le jour de la semaine pour l’époque. Pour cet exemple, nous voulons mapper le dimanche à zéro. Par conséquent, puisque l’époque est un lundi, nous définissons dayEpoch sur 1. Si l’époque était modifiée ou si nous voulions mapper un autre jour de la semaine à zéro, nous changerions simplement dayEpoch. Notez que ticksPerSecond est défini comme 10000000L pour en faire une valeur Int64 (entier de 8 octets). Sans le suffixe L, ticksPerDay dépassera la plage d’Int32.

Fonctions

La transformation d’expression prend en charge de nombreuses fonctions utiles.

Les fonctions unaires générales qui peuvent accepter un opérande de n’importe quel type sont répertoriées dans le tableau suivant.

Les fonctions de conversion unaires sont répertoriées dans le tableau suivant. Un opérande NA produit un NA ou lève si le type ne le prend pas en charge. Une conversion qui ne réussit pas ou un dépassement de capacité entraîne également un NA ou une exception. Le cas le plus courant est lors de la conversion à partir de texte, qui utilise l’analyse de conversion standard. Lors de la conversion d’une valeur à virgule flottante (float ou double) en valeur entière (Int32 ou Int64), la conversion effectue une opération de tronquer (arrondir vers zéro).

Les fonctions unaires qui nécessitent un opérande numérique sont répertoriées dans le tableau suivant. Le type de résultat est le même que le type d’opérande. Une valeur d’opérande NA produit NA.

Les fonctions binaires qui nécessitent des opérandes numériques sont répertoriées dans le tableau suivant. Lorsque les types d’opérandes ne sont pas les mêmes, les opérandes sont promus vers un type approprié. Le type de résultat est le même que le type d’opérande promu. Une valeur d’opérande NA produit NA.

Les fonctions unaires qui nécessitent un opérande à virgule flottante sont répertoriées dans le tableau suivant. Le type de résultat est le même que le type d’opérande. Le dépassement de capacité produit l’infini. Les valeurs d’entrée non valides produisent NA.

Les fonctions binaires qui nécessitent des opérandes à virgule flottante sont répertoriées dans le tableau suivant. Lorsque les types d’opérandes ne sont pas les mêmes, les opérandes sont promus vers un type approprié. Le type de résultat est le même que le type d’opérande promu. Une valeur d’opérande NA produit NA.

Les fonctions de texte sont répertoriées dans le tableau suivant.

Méthodes

Méthodes d’extension

S’applique à

Voir aussi

• Expression(TransformsCatalog, String, String, String[])