Compartilhar via

rxNeuralNet: rede neural

  • Artigo

Redes neurais para modelagem de regressão e classificação binária e multiclasse.

Uso

  rxNeuralNet(formula = NULL, data, type = c("binary", "multiClass",
    "regression"), numHiddenNodes = 100, numIterations = 100,
    optimizer = sgd(), netDefinition = NULL, initWtsDiameter = 0.1,
    maxNorm = 0, acceleration = c("sse", "gpu"), miniBatchSize = 1,
    normalize = "auto", mlTransforms = NULL, mlTransformVars = NULL,
    rowSelection = NULL, transforms = NULL, transformObjects = NULL,
    transformFunc = NULL, transformVars = NULL, transformPackages = NULL,
    transformEnvir = NULL, blocksPerRead = rxGetOption("blocksPerRead"),
    reportProgress = rxGetOption("reportProgress"), verbose = 1,
    computeContext = rxGetOption("computeContext"),
    ensemble = ensembleControl(), ...)

Argumentos

formula

A fórmula como descrita em rxFormula. 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 dataframe.

type

Uma cadeia de caracteres que denota o tipo de árvore rápida:

  • "binary" para a rede neural de classificação binária padrão.
  • "multiClass" para a rede neural de classificação multiclasse.
  • "regression" para uma rede neural de regressão.

numHiddenNodes

O número padrão de nós ocultos na rede neural. O valor padrão é 100.

numIterations

O número de iterações no conjunto de treinamento completo. O valor padrão é 100.

optimizer

Uma lista que especifica o algoritmo de otimização sgd ou adaptive. Essa lista pode ser criada usando sgd ou adaDeltaSgd. O valor padrão é sgd.

netDefinition

A definição de Net# da estrutura da rede neural. Para saber mais sobre a linguagem Net#, confira Reference Guide

initWtsDiameter

Define o diâmetro de pesos iniciais que especifica o intervalo do qual os valores dos pesos iniciais de aprendizado são extraídos. Os pesos são inicializados aleatoriamente de dentro desse intervalo. O valor padrão é 0,1.

maxNorm

Especifica um limite superior para restringir a norma do vetor de peso de entrada em cada unidade oculta. Esse argumento pode ser muito importante em redes neurais de nível máximo, bem como nos casos em que o treinamento gera pesos ilimitados.

acceleration

Especifica o tipo de aceleração de hardware a ser usado. Os valores possíveis são "sse" e "gpu". Para aceleração de GPU, é recomendado usar um miniBatchSize maior que um. Se você quer usar a aceleração de GPU, são necessárias mais algumas etapas de configuração manual:

  • Baixe e instale o NVidia CUDA Toolkit 6.5 (CUDA Toolkit).
  • Baixe e instale a biblioteca NVidia cuDNN v2 (cudnn Library).
  • Localize o diretório libs do pacote MicrosoftRML chamando system.file("mxLibs/x64", package = "MicrosoftML").
  • Copie cublas64_65.dll, cudart64_65.dll e cusparse64_65.dll do CUDA Toolkit 6.5 para o diretório libs do pacote MicrosoftML.
  • Copie cudnn64_65.dll da biblioteca cuDNN v2 para o diretório libs do pacote MicrosoftML.

miniBatchSize

Define o tamanho do minilote. Os valores recomendados estão entre 1 e 256. Esse parâmetro só é usado quando a aceleração é de GPU. A definição desse parâmetro como um valor mais alto aprimora a velocidade do treinamento, mas pode prejudicar a precisão. O valor padrão é 1.

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.

mlTransforms

Especifica uma lista de transformações do MicrosoftML a serem executadas nos dados antes do treinamento ou NULL para que nenhuma transformação seja executada. Confira featurizeText, categorical e categoricalHash, para ver as transformações com suporte. Essas transformações são executadas após as transformações R especificadas. O valor padrão é NULL.

mlTransformVars

Especifica um vetor de caracteres de nomes de variáveis a serem usados em mlTransforms ou NULL quando não é usado nenhum nome. O valor padrão é NULL.

rowSelection

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, rowSelection = "old" usará apenas observações nas quais o valor da variável old seja TRUE. rowSelection = (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 transformFunc). Assim como acontece com todas as expressões, é possível definir rowSelection fora da chamada de função usando a função de expressão.

transforms

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

transformObjects

Uma lista nomeada que contém objetos que podem ser referenciados por transforms, transformsFunc e rowSelection.

transformFunc

A função de transformação de variável. Confira rxTransform para obter detalhes.

transformVars

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

transformPackages

Um vetor de caracteres que especifica pacotes R adicionais (fora aqueles especificados em rxGetOption("transformPackages")) 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 RevoScaleR por meio dos respectivos argumentos transforms e transformFunc ou os definidos implicitamente por meio dos respectivos argumentos formula ou rowSelection. O argumento transformPackages também pode ser NULL, indicando que nenhum pacote fora de rxGetOption("transformPackages") é pré-carregado.

transformEnvir

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 transformEnvir = NULL, um novo ambiente de “hash” com baseenv() pai é usado.

blocksPerRead

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

reportProgress

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.

computeContext

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

ensemble

Parâmetros de controle para conjuntos.

...

Argumentos adicionais a serem passados diretamente para o Microsoft Compute Engine.

Detalhes

Uma rede neural é uma classe de modelos de previsão inspirada pelo cérebro humano. Uma rede neural pode ser representada como um grafo direcionado ponderado. Cada nó no grafo é chamado de neurônio. Os neurônios no grafo são organizados em camadas. Os neurônios em uma camada são conectados por uma borda ponderada (os pesos podem ser 0 ou números positivos) aos neurônios na próxima camada. A primeira camada é chamada de camada de entrada. Cada neurônio na camada de entrada corresponde a um dos recursos. A última camada da função é chamada de camada de saída. Portanto, no caso de redes neurais binárias, ela contém dois neurônios de saída, um para cada classe, cujos valores são as probabilidades de pertencer a cada classe. As camadas restantes são chamadas de camadas ocultas. Os valores dos neurônios nas camadas ocultas e na camada de saída são definidos calculando a soma ponderada dos valores dos neurônios na camada anterior e aplicando uma função de ativação a essa soma ponderada. Um modelo de rede neural é definido pela estrutura do respectivo grafo (ou seja, o número de camadas ocultas e o número de neurônios em cada camada oculta), pela escolha da função de ativação e pelos pesos nas bordas do grafo. O algoritmo rede neural tenta aprender os pesos ideais nas bordas com base nos dados de treinamento.

Embora as redes neurais sejam muito conhecidas pelo uso em problemas complexos de aprendizado profundo e de modelagem, como reconhecimento de imagem, elas também podem ser adaptadas facilmente para problemas de regressão. Qualquer classe de modelos estatísticos pode ser considerada uma rede neural quando usa pesos adaptáveis e consegue aproximar funções não lineares das respectivas entradas. A regressão de rede neural é adequada principalmente para problemas em que um modelo de regressão mais tradicional não chega a uma solução.

Valor

rxNeuralNet: um objeto rxNeuralNet com o modelo treinado.
NeuralNet: um objeto de especificação de aluno da classe maml para o treinador da Rede Neural.

Observações

Este algoritmo é single-threaded e não tentará carregar o conjunto de dados inteiro na memória.

Autor(es)

Microsoft Corporation Microsoft Technical Support

Referências

Wikipedia: Artificial neural network

Confira também

rxFastTrees, rxFastForest, rxFastLinear, rxLogisticRegression, rxOneClassSvm, featurizeText, categorical, categoricalHash, rxPredict.mlModel.

Exemplos


 # Estimate a binary neural net
 rxNeuralNet1 <- rxNeuralNet(isCase ~ age + parity + education + spontaneous + induced,
                   transforms = list(isCase = case == 1),
                   data = infert)

 # Score to a data frame
 scoreDF <- rxPredict(rxNeuralNet1, data = infert, 
     extraVarsToWrite = "isCase",
     outData = NULL) # return a data frame

 # Compute and plot the Radio Operator Curve and AUC
 roc1 <- rxRoc(actualVarName = "isCase", predVarNames = "Probability", data = scoreDF) 
 plot(roc1)
 rxAuc(roc1)

 #########################################################################
 # Regression neural net

 # Create an xdf file with the attitude data
 myXdf <- tempfile(pattern = "tempAttitude", fileext = ".xdf")
 rxDataStep(attitude, myXdf, rowsPerRead = 50, overwrite = TRUE)
 myXdfDS <- RxXdfData(file = myXdf)

 attitudeForm <- rating ~ complaints + privileges + learning + 
     raises + critical + advance

 # Estimate a regression neural net 
 res2 <- rxNeuralNet(formula = attitudeForm,  data = myXdfDS, 
     type = "regression")

 # Score to data frame
 scoreOut2 <- rxPredict(res2, data = myXdfDS, 
     extraVarsToWrite = "rating")

 # Plot the rating versus the score with a regression line
 rxLinePlot(rating~Score, type = c("p","r"), data = scoreOut2)

 # Clean up   
 file.remove(myXdf)    

 #############################################################################
 # Multi-class neural net
 multiNN <- rxNeuralNet(
     formula = Species~Sepal.Length + Sepal.Width + Petal.Length + Petal.Width,
     type = "multiClass", data = iris)
 scoreMultiDF <- rxPredict(multiNN, data = iris, 
     extraVarsToWrite = "Species", outData = NULL)    
 # Print the first rows of the data frame with scores
 head(scoreMultiDF)
 # Compute % of incorrect predictions
 badPrediction = scoreMultiDF$Species != scoreMultiDF$PredictedLabel
 sum(badPrediction)*100/nrow(scoreMultiDF)
 # Look at the observations with incorrect predictions
 scoreMultiDF[badPrediction,]