Partilhar via

microsoftml.rx_oneclass_svm: detecção de anomalias

  • Artigo

Uso

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)

Descrição

Máquinas de Vetor de Suporte One Class do Machine Learning

Detalhes

A SVM One-class é um algoritmo para detecção de anomalias. O objetivo da detecção de anomalias é identificar exceções que não pertençam a alguma classe de destino. Esse tipo de SVM é one-class porque o conjunto de treinamento contém apenas exemplos da classe de destino. Ele infere quais propriedades são normais para os objetos na classe de destino, e essas propriedades preveem quais exemplos são diferentes dos exemplos normais. Isso é útil para a detecção de anomalias porque a escassez de exemplos de treinamento é o caractere determinante das anomalias: normalmente há poucos exemplos de invasão de rede, fraude ou outros tipos de comportamento anormais.

Argumentos

formula

A fórmula, conforme a descrição em revoscalepy.rx_formula. No momento, não há suporte para termos de interação nem para F() no microsoftml.

data

Um objeto de fonte de dados ou uma cadeia de caracteres que especifica um arquivo .xdf ou um objeto de quadro de dados.

cache_size

O tamanho máximo em MB do cache que armazena os dados de treinamento. Aumente para grandes conjuntos de treinamento. O valor padrão é 100 MB.

kernel

Uma cadeia de caracteres que representa o kernel usado para computação de produtos internos. Para obter mais informações, consulte ma_kernel(). As seguintes opções estão disponíveis:

  • rbf_kernel: kernel de função de base radial. Seu parâmetro representa gamma no termo exp(-gamma|x-y|^2. Se não for especificado, o padrão será 1 dividido pelo número de recursos usados. Por exemplo, rbf_kernel(gamma = .1). Esse é o valor padrão.

  • linear_kernel: kernel linear.

  • polynomial_kernel: kernel polinomial com nomes de parâmetros a, bias e deg no termo (a*<x,y> + bias)^deg. O bias, assume 0 como padrão. O grau, deg, assume 3 como padrão. Se a não for especificado, será definido para 1 dividido pelo número de recursos.

  • sigmoid_kernel: kernel sigmoide com nomes de parâmetros gamma e coef0 no termo tanh(gamma*<x,y> + coef0). gamma, assume 1 como padrão dividido pelo número de recursos. O parâmetro coef0 assume 0 como padrão. Por exemplo, sigmoid_kernel(gamma = .1, coef0 = 0).

épsilon

O limite de convergência do otimizador. Se a melhoria entre as iterações for menor que o limite, o algoritmo para e retorna o modelo atual. O valor precisa ser maior ou igual a numpy.finfo(double).eps. O valor padrão é 0,001.

nu

A troca entre a fração de exceções e o número de vetores de suporte (representado pela letra grega nu). Deve estar entre 0 e 1, normalmente entre 0,1 e 0,5. O valor padrão é 0,1.

shrink

Usa a heurística de redução se True. Nesse caso, algumas amostras serão “reduzidas” durante o procedimento de treinamento, o que pode acelerar o treinamento. O valor padrão é True.

normalize

Especifica o tipo de normalização automática usado:

  • "Auto": se a normalização for necessária, ela será executada automaticamente. Essa é a opção padrão.

  • "No": não é executada nenhuma normalização.

  • "Yes": a normalização é executada.

  • "Warn": se a normalização for necessária, uma mensagem de aviso será exibida, mas a normalização não será executada.

A normalização redimensiona intervalos de dados diferentes para uma escala padrão. O dimensionamento de recursos garante que as distâncias entre os pontos de dados sejam proporcionais e permite que vários métodos de otimização, como o descendente de gradiente, sejam convergidos com uma rapidez muito maior. Quando a normalização é executada, um normalizador MaxMin é usado. Ele normaliza os valores em um intervalo [a, b] em que -1 <= a <= 0 e 0 <= b <= 1 e b - a = 1. Esse normalizador preserva a dispersão mapeando zero para zero.

ml_transforms

Especifica uma lista de transformações do MicrosoftML a serem executadas nos dados antes do treinamento ou None para que nenhuma transformação seja executada. Confira featurize_text, categorical e categorical_hash, para saber quais são as transformações com suporte. Essas transformações são executadas após qualquer transformação do Python especificada. O valor padrão é None.

ml_transform_vars

Especifica um vetor de caracteres de nomes de variáveis a ser usado em ml_transforms ou None para que nenhum vetor seja usado. O valor padrão é None.

row_selection

SEM SUPORTE. Especifica as linhas (observações) do conjunto de dados que devem ser usadas pelo modelo com o nome de uma variável lógica do conjunto de dados (entre aspas) ou com uma expressão lógica usando variáveis no conjunto de dados. Por exemplo:

  • row_selection = "old" usará apenas observações nas quais o valor da variável old seja True.

  • row_selection = (age > 20) & (age < 65) & (log(income) > 10) apenas usa observações nas quais o valor da variável age está entre 20 e 65 e o valor de log da variável income é maior que 10.

A seleção de linha é executada após o processamento de todas as transformações de dados (confira os argumentos transforms ou transform_function). Assim como acontece com todas as expressões, é possível definir row_selection fora da chamada de função usando a função expression.

transformações

SEM SUPORTE. Uma expressão do formato que representa a primeira rodada de transformações de variável. Assim como acontece com todas as expressões, é possível definir transforms (ou row_selection) fora da chamada de função usando a função expression.

transform_objects

SEM SUPORTE. Uma lista nomeada que contém objetos que podem ser referenciados por transforms, transform_function e row_selection.

transform_function

A função de transformação de variável.

transform_variables

Um vetor de caracteres de variáveis do conjunto de dados de entrada necessário para a função de transformação.

transform_packages

SEM SUPORTE. Um vetor de caracteres que especifica pacotes Python adicionais (fora aqueles especificados em RxOptions.get_option("transform_packages")) a serem disponibilizados e pré-carregados para uso em funções de transformação de variável. Por exemplo, os definidos explicitamente nas funções revoscalepy por meio dos respectivos argumentos transforms e transform_function ou os definidos implicitamente por meio dos respectivos argumentos formula ou row_selection. O argumento transform_packages também pode ser None, indicando que nenhum pacote fora de RxOptions.get_option("transform_packages") é pré-carregado.

transform_environment

SEM SUPORTE. Um ambiente definido pelo usuário para funcionar como um pai de todos os ambientes desenvolvidos internamente e usados para transformação de dados de variável. Se transform_environment = None, um novo ambiente de "hash" com revoscalepy.baseenv pai é usado.

blocks_per_read

Especifica o número de blocos a serem lidos em cada parte dos dados lidos da fonte de dados.

report_progress

Um valor inteiro que especifica o nível de relatório sobre o progresso do processamento de linha:

  • 0: não é relatado nenhum progresso.

  • 1: o número de linhas processadas é impresso e atualizado.

  • 2: as linhas processadas e os tempos são relatados.

  • 3: as linhas processadas e todos os tempos são relatados.

verbose

Um valor inteiro que especifica a quantidade de saída desejada. Se definido como 0, não será impressa nenhuma saída detalhada durante os cálculos. Valores inteiros de 1 a 4 fornecem quantidades crescentes de informações.

compute_context

Define o contexto no qual as computações são executadas, especificado com um revoscalepy.RxComputeContext válido. No momento, há suporte para os contextos de computação local e revoscalepy.RxInSqlServer.

ensemble

Parâmetros de controle para conjuntos.

Retornos

Um objeto OneClassSvm com o modelo treinado.

Observação

Este algoritmo é de thread única e sempre tentará carregar todo o conjuntos de dados na memória.

Confira também

linear_kernel, polynomial_kernel, rbf_kernel, sigmoid_kernel, rx_predict.

Referências

Wikipedia: detecção de anomalias

Microsoft Azure Machine Learning Studio (clássico): Máquina de Vetor de Suporte One-Class

Estimando o suporte de uma distribuição altamente dimensional

Novos algoritmos de vetor de suporte

LIBSVM: uma biblioteca para Máquinas de Vetor de Suporte

Exemplo

'''
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())

Saída:

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