ExpressionEstimator Classe

Définition

Espace de noms:

Microsoft.ML.Transforms

Assembly:

Microsoft.ML.Transforms.dll

Paquet:

Microsoft.ML v3.0.1

Cet estimateur applique une expression fournie par l’utilisateur (spécifiée sous forme de chaîne) aux valeurs de colonne d’entrée pour produire de nouvelles valeurs de colonne de sortie.

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

Cet estimateur doit-il examiner les données pour effectuer l’apprentissage de ses paramètres ?	No
Type de données de colonne d’entrée	float, double, int, long, bool ou text.
Type de données de colonne de sortie	Il peut s’agir de float, double, int, long, bool ou text, selon l’expression.

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.

Opérateur	Signification	Arity	Commentaires
​? :	Conditionnelle	Ternaire	La condition d’expression ? value1 : value2 est résolu en valeur1 si la condition a la valeur true et en valeur2 si la condition a la valeur false. La condition doit être booléenne, tandis que value1 et value2 doivent être de type compatible.
​??	Coalesce	Binaire	L’expression x ?? y est résolu en x si x n’est pas NA, et en y dans le cas contraire. Les opérandes doivent être à la fois simples ou doubles. Cet opérateur est associatif à droite.
| | Ou	logique ou	Binaire	Les opérandes et le résultat sont booléens. Si un opérande a la valeur true, le résultat est true, sinon il est false.
&& et	logique et	Binaire	Les opérandes et le résultat sont booléens. Si un opérande a la valeur false, le résultat est false ; sinon, il est vrai.
​==, = !=, <> <, <= >, >=	est égal à n’est pas égal à inférieur ou égal à supérieur ou égal à	Plusieurs	- Les opérateurs de comparaison sont multi-arités, ce qui signifie qu’ils peuvent être appliqués à au moins deux opérandes. Par exemple, a == b == c donne la valeur true si a, b et c ont la même valeur. L’opérateur non égal exige que tous les opérandes soient distincts, de sorte que 1 != 2 != 1 a la valeur false. Pour tester si x est non négatif mais inférieur à 10, utilisez 0 <= x < 10. Il n’est pas nécessaire d’écrire 0 <= x && x < 10, et cela ne fonctionnera pas aussi bien. Les opérateurs répertoriés sur la même ligne peuvent être combinés dans une seule expression. Par conséquent, b >>= c est légal, mais b <>= c ne l’est pas. - Est égal à et non égal à n’importe quel type d’opérande, tandis que les opérateurs ordonnés nécessitent des opérandes numériques.
​+ -	addition et soustraction	Binaire	Addition et soustraction numériques avec propagation NA.
​* / %	multiplication, division et module	Binaire	Multiplication numérique, division et module avec propagation NA.
​- ! not	Négation numérique et non logique	Unaire	Il s’agit d’opérateurs de préfixe unaire, la négation (-) nécessitant un opérande numérique, et non ( !) nécessitant un opérande booléen.
​^	Pouvoir	Binaire	C’est une juste exponentiation associative. Il nécessite des opérandes numériques. Pour les opérandes entiers, 0^0 produit 1.
​( )	regroupement entre parenthèses	Unaire	Signification standard.

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.

Nom	Sens	Commentaires
Isna	test pour na	Retourne une valeur booléenne indiquant si l’opérande est une valeur NA.
Na	la valeur na	Retourne la valeur NA du même type que l’opérande (float ou double). Notez que cela n’évalue pas l’opérande, qu’il utilise uniquement l’opérande pour déterminer le type de NA à retourner, et que cette détermination se produit au moment de la compilation.
Par défaut	valeur par défaut	Retourne la valeur par défaut du même type que l’opérande. Par exemple, pour mapper des valeurs NA aux valeurs par défaut, utilisez x ?? default(x). Notez que cela n’évalue pas l’opérande, qu’il utilise uniquement l’opérande pour déterminer le type de valeur par défaut à retourner, et que cette détermination se produit au moment de la compilation. Pour les types numériques, la valeur par défaut est zéro. Pour booléen, la valeur par défaut est false. Pour le texte, la valeur par défaut est vide.

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

Nom	Sens	Commentaires
Bool	convertir en booléen	L’opérande doit être textuel ou booléen.
Int	convertir en Int32	L’entrée peut être de n’importe quel type.
Long	convertir en Int64	L’entrée peut être de n’importe quel type.
single, float	convertir en Single	L’entrée peut être de n’importe quel type.
Double	convertir en Double	L’entrée peut être de n’importe quel type.
Texte	convertir en texte	L’entrée peut être de n’importe quel type. Cela produit une représentation textuelle par défaut.

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.

Nom	Sens	Commentaires
Abs	valeur absolue	Produit la valeur absolue de l’opérande.
Signe	signe (-1, 0, 1)	Produit -1, 0 ou 1 selon que l’opérande est négatif, zéro ou positif.

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.

Nom	Sens	Commentaires
Min	Minimum	Produit le minimum des opérandes.
Max	maximum	Produit le maximum des opérandes.

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.

Nom	Sens	Commentaires
Sqrt	racine carrée	Les opérandes négatifs produisent NA.
trunc, tronquer	Tronquer en entier	Arrondit vers zéro à la valeur entière la plus proche.
Étage	Étage	Arrondit vers l’infini négatif à la valeur entière la plus proche.
ceil, plafond	Plafond	Arrondit vers l’infini positif à la valeur entière la plus proche.
Rond	arrondi non biaisé	Arrondit à la valeur entière la plus proche. Lorsque l’opérande se trouve à mi-chemin entre deux valeurs entières, cela produit l’entier pair.
Exp	Exponentielle	Élève e à l’opérande.
ln, log	Logarithme	Produit le logarithme naturel (base e). Il existe également une version de journal à deux opérandes pour l’utilisation d’une base différente.
deg, degrees	radians aux degrés	Mappe des radians aux degrés.
rad, radians	degrés en radians	Mappe des degrés aux radians.
sin, sind	Sinus	Prend le sinus d’un angle. La fonction sin suppose que l’opérande est en radians, tandis que la fonction sind suppose que l’opérande est en degrés.
cos, cosd	Cosinus	Prend le cosinus d’un angle. La fonction cos suppose que l’opérande est en radians, tandis que la fonction cosd suppose que l’opérande est en degrés.
tan, tand	Tangente	Prend la tangente d’un angle. La fonction tan suppose que l’opérande est en radians, tandis que la fonction tand suppose que l’opérande est en degrés.
Sinh	sinus hyperbolique	Prend le sinus hyperbolique de son opérande.
Cosh	cosinus hyperbolique	Prend le cosinus hyperbolique de son opérande.
tanh	tangente hyperbolique	Prend la tangente hyperbolique de son opérande.
Asin	sinus inverse	Prend le sinus inverse de son opérande.
Acos	cosinus inverse	Prend le cosinus inverse de son opérande.
Atan	tangente inverse	Prend la tangente inverse de son opérande.

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.

Nom	Sens	Commentaires
rapport	logarithme avec base donnée	Le deuxième opérande est la base. La première est la valeur à prendre le logarithme de.
atan2, atanyx	déterminer l’angle	Détermine l’angle entre -pi et pi à partir des valeurs y et x données. Notez que y est le premier opérande.

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

Nom	Sens	Commentaires
len(x)	longueur du texte	L’opérande doit être du texte. Le résultat est un I4 indiquant la longueur de l’opérande. Si l’opérande est NA, le résultat est NA.
lower(x), upper(x)	minuscules ou majuscules	Mappe le texte en minuscules ou majuscules.
left(x, k), right(x, k)	Sous-chaîne	Le premier opérande doit être du texte et le deuxième opérande doit être Int32. Si le deuxième opérande est négatif, il est traité comme un décalage par rapport à la fin du texte. Cet index ajusté est ensuite limité à 0 à len(x). Le résultat est les caractères situés à gauche ou à droite de la position résultante.
mid(x, a, b)	Sous-chaîne	Le premier opérande doit être du texte et les deux autres opérandes doivent être Int32. Les index sont transformés de la même façon que pour les fonctions de gauche et de droite : les valeurs négatives sont traitées comme des décalages par rapport à la fin du texte ; ces indices ajustés sont limités à 0 à len(x). Le deuxième index serré est également serré en dessous du premier index serré. Le résultat est les caractères entre ces deux index serrés.
concat(x1, x2, ..., xn)	Concaténation	Cela accepte un nombre arbitraire d’opérandes (y compris zéro). Tous les opérandes doivent être du texte. Le résultat est la concaténation de tous les opérandes, dans l’ordre.

Méthodes

Fit(IDataView)	Cet estimateur applique une expression fournie par l’utilisateur (spécifiée sous forme de chaîne) aux valeurs de colonne d’entrée pour produire de nouvelles valeurs de colonne de sortie.
GetOutputSchema(SchemaShape)	Cet estimateur applique une expression fournie par l’utilisateur (spécifiée sous forme de chaîne) aux valeurs de colonne d’entrée pour produire de nouvelles valeurs de colonne de sortie.

Méthodes d’extension

AppendCacheCheckpoint<TTrans>(IEstimator<TTrans>, IHostEnvironment)

Ajoutez un « point de contrôle de mise en cache » à la chaîne de l’estimateur. Cela garantit que les estimateurs en aval seront entraînés sur les données mises en cache. Il est utile d’avoir un point de contrôle de mise en cache avant les formateurs qui effectuent plusieurs passes de données.

WithOnFitDelegate<TTransformer>(IEstimator<TTransformer>, Action<TTransformer>)

Avec un estimateur, retournez un objet d’habillage qui appellera un délégué une fois Fit(IDataView) appelé. Il est souvent important pour un estimateur de retourner des informations sur ce qui était adapté, c’est pourquoi la Fit(IDataView) méthode retourne un objet spécifiquement typé, plutôt qu’un simple général ITransformer. Toutefois, dans le même temps, IEstimator<TTransformer> sont souvent formés dans des pipelines avec de nombreux objets, nous devrons donc créer une chaîne d’estimateurs par le biais EstimatorChain<TLastTransformer> de l’emplacement où l’estimateur pour lequel nous voulons obtenir le transformateur est enterré quelque part dans cette chaîne. Pour ce scénario, nous pouvons, par le biais de cette méthode, attacher un délégué qui sera appelé une fois que fit est appelé.

Voir aussi

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