Olá pessoal!

Já fizemos classificadores de sentimentos em Python e no Azure, agora chegou a hora do ML.NET.

Este post foi feito em parceria com Microsoft MVP Juliano Custódio, onde no post Utilizando ML.NET em aplicações Xamarin.Forms ele utiliza o modelo que criaremos aqui para rodar em aplicações móveis! Depois de entender as bases para criar o modelo, corre lá no blog dele para ver ele executando na prática!

Vamos começar então! Aqui iremos implementar um modelo para classificação de comentários, usando o ML.NET. Assim como implementamos anteriormente outros modelos de classificação. Você pode também pode conferir o modelo feito em Python ou feito com o Azure Machine Learning Studio.

Os três modelos de classificação utilizam o mesmo dataset e resolvem o mesmo problema. O modelo deve indicar se um dado comentário é positivo ou negativo. Os dados para treinamento utilizam dados referentes à filmes, lugares e produtos, vamos manter a implementação, mas mudaremos o framework.

Então vamos lá, o que é o ML.NET?

ML.NET

O ML.NET é um framework para Machine Learning open source e cross-platform (Windows, Linux & macOS) focado em .NET, ou seja. podemos utilizar C# e F# para criação de modelos de machine learning!

O mais legal disso, é que o resultado é totalmente exportável, ou seja, o ambiente de criação não precisa ser necessariamente o mesmo ambiente de desenvolvimento.

Como já citado, podemos usar C# ou F#, mas qual devemos escolher?

Depende.

Na minha opinião pessoal, eu prefiro utilizar o F# para a criação de modelos, meus principais argumentos sobre isso são:

1. Você pode extrair dados para montar seus datasets utilizando Type Providers;
2. Eu gosto bastante da facilidade de gerar gráficos com o F#, por ser uma pessoa bastante visual, gosto de comparar as métricas através de gráficos;
3. Como o ambiente de criação do modelo é descolado do ambiente de utilização do modelo, você não precisará de desenvolvedores com aptidão em F#, desenvolvedores C# (mais comuns no mercado) poderão utilizar seu modelo sem nenhum tipo de problema;

Isso significa que é melhor criar o modelo em F# do que C#? Não.

Apenas significa que no meu cenário, F# acaba sendo melhor. Mas avalie caso a caso, se você estiver confortável com C# e não com F#, vai de C# que o framework é literalmente o mesmo (o que muda são as coisas periféricas da linguagem).

Criando o projeto

Podemos começar criando um projeto Console em F# comum. Antes de qualquer código vamos instalar os pacotes:

PM> Install-Package Microsoft.ML
PM> Install-Package FSharp.Data

Isso vai nos dar as ferramentas necessárias para gerar o modelo com o ML.NET.

Agora que já instalamos o pacote precisamos dos dados que serão utilizados para treinamento e avaliação. Para isso vamos usar o mesmo conjunto de dados dos exemplos anteriores. Ele é composto por três fontes públicas que contém comentários dos sites: IMDb, Amazon e Yelp. Ao todo teremos exatos três mil registros.

Pré-processamento

Vamos importar os arquivos .csv para nosso projeto:

Outra coisa que precisamos fazer para garantir que a importação vai funcionar em tempo de execução é marcarmos os arquivos para serem copiados para a pasta destino da publicação.

Para fazer isso, basta alterarmos o valor da propriedade Copy to Output Directory para Copy if newer:

Com isso já podemos começar a implementação!

A primeira coisa que precisamos fazer é criar um objeto do tipo MLContext, esse é o objeto mais importante do ML.NET, praticamente tudo está ligado à ele.

Agora vamos importar os dados dos arquivos CSV, para fazer isso, precisamos de um tipo que reflita os dados presentes no arquivo. Os arquivos possuem duas colunas: Text e Value, vamos criar um tipo para carregar isso.

Vamos deixar os tipos da implementação em um arquivo separado, vamos chamá-lo de Types:

module Types

open Microsoft.ML.Data

[<CLIMutable>]
type DataCommentary = {
    [<LoadColumn(0)>]
    Text : string

    [<LoadColumn(1)>]
    Label : bool
}   

Note algumas coisas nesse tipo: estamos utilizando a anotação [<CLIMutable>] por conta de compatibilidade; alteramos o nome de Value para Label que é um nome mais correto para esse tipo de modelagem; estamos utilizando a notação [<LoadColumn>] presente no namespace Microsoft.ML.Data para mapear os dados do arquivo para o objeto de dados.

Agora já podemos carregar o arquivo na função main! Usamos a função Load de um TextLoader, com ela podemos carregar os três arquivos.

Além disso, no momento de criar o loader precisamos configurar qual o separador do arquivo CSV e se o arquivo possui um cabeçalho ou não.

[<EntryPoint>]
let main argv =
    let mlContext = new MLContext();
    let textLoader = mlContext.Data.CreateTextLoader<DataCommentary>(',', true)
    let rawData = textLoader.Load 
                    [|
                      "Datasets/amazon_cells_labelled.csv"
                      "Datasets/imdb_labelled.csv"
                      "Datasets/yelp_labelled.csv"
                    |]

Agora podemos fazer a divisão dos dados: 80% para treinamento e 20% para avaliação. Faremos isso através da função: TrainTestSplit:

...
    let data = mlContext.Data.TrainTestSplit(rawData, 0.2)

Por fim, vamos encapsular tudo isso em uma função para não poluir a função main:

let preprocessing (mlContext:MLContext) = 
    let textLoader = mlContext.Data.CreateTextLoader<DataCommentary>(',', true)
    let rawData = textLoader.Load 
                    [|
                      "Datasets/amazon_cells_labelled.csv"
                      "Datasets/imdb_labelled.csv"
                      "Datasets/yelp_labelled.csv"
                    |]
    let data = mlContext.Data.TrainTestSplit(rawData, 0.2)

    rawData, data

Estamos retornando uma tupla com os dados crus importados do arquivo e com os dados já divididos entre treino e avaliação.

Treinamento

Na etapa de treinamento precisamos fazer a “featurização” do texto, que expliquei no primeiro post sobre essa implementação. A explicação mostra a forma mais simples de featurizar um texto, mas lembre-se que existem várias outras formas.

Fazer esse processo com ML.NET é bastante simples, basta usar a função FeaturizeTextindicando qual coluna deve ser featurizada e qual o nome da coluna que receberá o resultado do processo:

let mlFeaturedText = 
    mlContext.Transforms.Text.FeaturizeText("Features", "Text")

Agora chega o momento de escolher o algoritmo de treinamento e fazê-lo de fato. Por enquanto vamos escolher o algoritmo LinearSvm, conforme código:

let mlFeaturedText = 
    mlContext.Transforms.Text.FeaturizeText("Features", "Text")

let trainer = 
    mlContext.BinaryClassification.Trainers.LinearSvm(
        "Label", 
        "Features")
 
let pipeline = mlFeaturedText.Append trainer
let model = pipeline.Fit data.TrainSet

Neste ponto já temos um modelo gerado!

Para poder testarmos precisamos descrever o tipo referênte ao parâmetro de entrada e o tipo do valor de saída. Então vamos voltar rapidinho lá para o arquivo Types.fs e adicionar esses caras:

[<CLIMutable>]
type InputCommentary = {
    Text:string
}

[<CLIMutable>]
type Prediction = {
    [<ColumnName("PredictedLabel")>]
    Prediction : bool

    Score : float32
}

A explicação desses tipos é bastante simples. Para entrada só precisamos de um texto, afinal o label é o valor que estamos tentando descobrir.

Para o retorno temos alguns indicadores (Score e Probability) e o resultado propriamente dito: Prediction.

Vamos testar:

let predictiveModel = 
    mlContext.Model.CreatePredictionEngine<InputCommentary, Prediction>(model)

predictiveModel.Predict { Text = "awesome" }
|> Console.WriteLine

Já podemos ver o resultado no console!