Partager via

microsoftml.rx_oneclass_svm : Détection des anomalies

Usage

microsoftml.rx_oneclass_svm(formula: str,
    data: [revoscalepy.datasource.RxDataSource.RxDataSource,
    pandas.core.frame.DataFrame], cache_size: float = 100,
    kernel: [<function linear_kernel at 0x0000007156EAC8C8>,
    <function polynomial_kernel at 0x0000007156EAC950>,
    <function rbf_kernel at 0x0000007156EAC7B8>,
    <function sigmoid_kernel at 0x0000007156EACA60>] = {'Name': 'RbfKernel',
    'Settings': {}}, epsilon: float = 0.001, nu: float = 0.1,
    shrink: bool = True, normalize: ['No', 'Warn', 'Auto',
    'Yes'] = 'Auto', ml_transforms: list = None,
    ml_transform_vars: list = None, row_selection: str = None,
    transforms: dict = None, transform_objects: dict = None,
    transform_function: str = None,
    transform_variables: list = None,
    transform_packages: list = None,
    transform_environment: dict = None, blocks_per_read: int = None,
    report_progress: int = None, verbose: int = 1,
    ensemble: microsoftml.modules.ensemble.EnsembleControl = None,
    compute_context: revoscalepy.computecontext.RxComputeContext.RxComputeContext = None)

Descriptif

Machine Learning One Class Support Vector Machines

Détails

La machine virtuelle SVM d’une classe est un algorithme pour la détection d’anomalies. L’objectif de la détection d’anomalies est d’identifier les valeurs hors norme qui n’appartiennent pas à une classe cible. Ce type de machine virtuelle SVM est une classe, car le jeu d’entraînement contient uniquement des exemples de la classe cible. Il déduit quelles propriétés sont normales pour les objets de la classe cible et à partir de ces propriétés prédit quels exemples sont contrairement aux exemples normaux. Cela est utile pour la détection d’anomalies, car la rareté des exemples d’apprentissage est le caractère définissant des anomalies : en général, il existe très peu d’exemples d’intrusion, de fraude ou d’autres types de comportement anormal.

Arguments

formula

Formule décrite dans revoscalepy.rx_formula. Termes d’interaction et F() ne sont actuellement pas pris en charge dans microsoftml.

données

Objet source de données ou chaîne de caractères spécifiant un fichier .xdf ou un objet de trame de données.

cache_size

Taille maximale en Mo du cache qui stocke les données d’entraînement. Augmentez cette valeur pour les jeux d’entraînement volumineux. La valeur par défaut est de 100 Mo.

noyau

Chaîne de caractères représentant le noyau utilisé pour l’informatique des produits internes. Pour plus d’informations, consultez ma_kernel(). Les choix suivants sont disponibles :

  • rbf_kernel: noyau de fonction de base radiale. Son paramètre représentegamma dans le terme exp(-gamma|x-y|^2. S’il n’est pas spécifié, il est 1 divisé par défaut par le nombre de fonctionnalités utilisées. Par exemple : rbf_kernel(gamma = .1). Il s’agit de la valeur par défaut.

  • linear_kernel: noyau linéaire.

  • polynomial_kernel: noyau polynomial avec des noms ade paramètres , biaset deg dans le terme (a*<x,y> + bias)^deg. La biasvaleur par défaut 0est . Degré, degvaleur par défaut 3. S’il a n’est pas spécifié, il est défini sur 1 divisé par le nombre de fonctionnalités.

  • sigmoid_kernel: noyau sigmoid avec des noms gamma de paramètres et coef0 dans le terme tanh(gamma*<x,y> + coef0). gamma, la valeur par défaut est 1 divisée par le nombre de fonctionnalités. Le paramètre coef0 est défini par défaut sur 0. Par exemple : sigmoid_kernel(gamma = .1, coef0 = 0).

Epsilon

Seuil de convergence de l’optimiseur. Si l’amélioration entre les itérations est inférieure au seuil, l’algorithme s’arrête et retourne le modèle actuel. La valeur doit être supérieure ou égale à numpy.finfo(double).eps. La valeur par défaut est 0.001.

nu

Compromis entre la fraction de valeurs hors norme et le nombre de vecteurs de support (représentés par la lettre grecque nu). Doit être compris entre 0 et 1, généralement entre 0,1 et 0,5. La valeur par défaut est 0.1.

shrink

Utilise l’heuristique de réduction si True. Dans ce cas, certains exemples seront « réduits » pendant la procédure d’entraînement, ce qui peut accélérer l’entraînement. La valeur par défaut est True.

Normaliser

Spécifie le type de normalisation automatique utilisé :

  • "Auto": si la normalisation est nécessaire, elle est effectuée automatiquement. Il s’agit du choix par défaut.

  • "No": aucune normalisation n’est effectuée.

  • "Yes": la normalisation est effectuée.

  • "Warn": si la normalisation est nécessaire, un message d’avertissement s’affiche, mais la normalisation n’est pas effectuée.

La normalisation met à l’échelle des plages de données disparates à une échelle standard. La mise à l’échelle des caractéristiques garantit que les distances entre les points de données sont proportionnelles et permet à diverses méthodes d’optimisation telles que la descente de dégradé de converger beaucoup plus rapidement. Si la normalisation est effectuée, un MaxMin normaliseur est utilisé. Il normalise les valeurs dans un intervalle [a, b] où -1 <= a <= 0 et 0 <= b <= 1b - a = 1. Ce normaliseur conserve l’éparse en mappant zéro à zéro.

ml_transforms

Spécifie une liste des transformations MicrosoftML à effectuer sur les données avant l’entraînement ou None si aucune transformation n’est à effectuer. Consultez featurize_text, categoricalet , pour categorical_hashconnaître les transformations prises en charge. Ces transformations sont effectuées après les transformations Python spécifiées. La valeur par défaut est None.

ml_transform_vars

Spécifie un vecteur de caractères de noms de variables à utiliser dans ml_transforms ou Aucun si aucun doit être utilisé. La valeur par défaut est None.

row_selection

NON PRIS EN CHARGE. Spécifie les lignes (observations) du jeu de données à utiliser par le modèle avec le nom d’une variable logique à partir du jeu de données (entre guillemets) ou avec une expression logique à l’aide de variables dans le jeu de données. Par exemple:

  • row_selection = "old" utilise uniquement les observations dans lesquelles la valeur de la variable old est True.

  • row_selection = (age > 20) & (age < 65) & (log(income) > 10) utilise uniquement les observations dans lesquelles la valeur de la age variable est comprise entre 20 et 65 et la valeur de la logincome variable est supérieure à 10.

La sélection de lignes est effectuée après le traitement des transformations de données (voir les arguments transforms ou transform_function). Comme pour toutes les expressions, row_selection vous pouvez définir en dehors de l’appel de fonction à l’aide de la expression fonction.

Transforme

NON PRIS EN CHARGE. Expression du formulaire qui représente la première série de transformations de variables. Comme avec toutes les expressions, transforms (ou row_selection) peut être défini en dehors de l’appel de fonction à l’aide de la expression fonction.

transform_objects

NON PRIS EN CHARGE. Liste nommée qui contient des objets qui peuvent être référencés par transforms, transform_functionet row_selection.

transform_function

Fonction de transformation de variable.

transform_variables

Vecteur de caractères des variables de jeu de données d’entrée nécessaires pour la fonction de transformation.

transform_packages

NON PRIS EN CHARGE. Vecteur de caractères spécifiant des packages Python supplémentaires (en dehors de ceux spécifiés dans RxOptions.get_option("transform_packages")) à rendre disponibles et préchargés pour une utilisation dans les fonctions de transformation de variable. Par exemple, ceux définis explicitement dans les fonctions revoscalepy via leurs arguments et transform_function leurs transforms arguments ou ceux définis implicitement par leur ou row_selection leurs formula arguments. L’argument transform_packages peut également être None, ce qui indique qu’aucun package en dehors RxOptions.get_option("transform_packages") n’est préchargé.

transform_environment

NON PRIS EN CHARGE. Environnement défini par l’utilisateur pour servir de parent à tous les environnements développés en interne et utilisés pour la transformation des données variables. Si transform_environment = None, un nouvel environnement de « hachage » avec revoscalepy.baseenv parent est utilisé à la place.

blocks_per_read

Spécifie le nombre de blocs à lire pour chaque bloc de données lu à partir de la source de données.

report_progress

Valeur entière qui spécifie le niveau de création de rapports sur la progression du traitement des lignes :

  • 0: aucune progression n’est signalée.

  • 1: le nombre de lignes traitées est imprimé et mis à jour.

  • 2: les lignes traitées et le minutage sont signalés.

  • 3: lignes traitées et toutes les minutages sont signalées.

verbose

Valeur entière qui spécifie la quantité de sortie souhaitée. Si 0, aucune sortie détaillée n’est imprimée pendant les calculs. Valeurs entières allant de 1 à 4 fournir des quantités croissantes d’informations.

compute_context

Définit le contexte dans lequel les calculs sont exécutés, spécifiés avec une révoscalepy valide. RxComputeContext. Actuellement local et revoscalepy. Les contextes de calcul RxInSqlServer sont pris en charge.

ensemble

Paramètres de contrôle pour l’ensembling.

Retours

Objet OneClassSvm avec le modèle entraîné.

Note

Cet algorithme est monothread et tente toujours de charger l’ensemble du jeu de données en mémoire.

Voir aussi

linear_kernel, , polynomial_kernel, rbf_kernelsigmoid_kernel, , rx_predict.

References

Wikipédia : Détection d’anomalies

Microsoft Azure Machine Learning Studio (classique) : One-Class Support Vector Machine

Estimation de la prise en charge d’une distribution de High-Dimensional

Nouveaux algorithmes de vecteur de prise en charge

LIBSVM : bibliothèque pour les machines vectorielles de prise en charge

Example

'''
Anomaly Detection.
'''
import numpy
import pandas
from microsoftml import rx_oneclass_svm, rx_predict
from revoscalepy.etl.RxDataStep import rx_data_step
from microsoftml.datasets.datasets import get_dataset

iris = get_dataset("iris")

import sklearn
if sklearn.__version__ < "0.18":
    from sklearn.cross_validation import train_test_split
else:
    from sklearn.model_selection import train_test_split

irisdf = iris.as_df()
data_train, data_test = train_test_split(irisdf)

# Estimate a One-Class SVM model
model = rx_oneclass_svm(
            formula= "~ Sepal_Length + Sepal_Width + Petal_Length + Petal_Width",
            data=data_train)

# Add additional non-iris data to the test data set
data_test["isIris"] = 1.0
not_iris = pandas.DataFrame(data=dict(Sepal_Length=[2.5, 2.6], 
        Sepal_Width=[.75, .9], Petal_Length=[2.5, 2.5], 
        Petal_Width=[.8, .7], Species=["not iris", "not iris"], 
        isIris=[0., 0.]))

merged_test = pandas.concat([data_test, not_iris])

scoresdf = rx_predict(model, data=merged_test, extra_vars_to_write=["isIris"])

# Look at the last few observations
print(scoresdf.tail())

Sortie:

Automatically adding a MinMax normalization transform, use 'norm=Warn' or 'norm=No' to turn this behavior off.
Beginning processing data.
Rows Read: 112, Read Time: 0, Transform Time: 0
Beginning processing data.
Beginning processing data.
Rows Read: 112, Read Time: 0, Transform Time: 0
Beginning processing data.
Using these libsvm parameters: svm_type=2, nu=0.1, cache_size=100, eps=0.001, shrinking=1, kernel_type=2, gamma=0.25, degree=0, coef0=0
Reconstructed gradient.
optimization finished, #iter = 15
obj = 52.905421, rho = 9.506052
nSV = 12, nBSV = 9
Not training a calibrator because it is not needed.
Elapsed time: 00:00:00.0555122
Elapsed time: 00:00:00.0212389
Beginning processing data.
Rows Read: 40, Read Time: 0, Transform Time: 0
Beginning processing data.
Elapsed time: 00:00:00.0349974
Finished writing 40 rows.
Writing completed.
    isIris     Score
35     1.0 -0.142141
36     1.0 -0.531449
37     1.0 -0.189874
38     0.0  0.635845
39     0.0  0.555602
  • Last updated on