Dando vida ao aprendizado de máquina com o TensorFlow

Como desenvolvedor JavaScript, mergulhar no aprendizado de máquina não é tão assustador quanto pode parecer. Embora seja tecnicamente possível lidar com tudo com pacotes Node.js, o ecossistema Python ML é muito rico e bem estabelecido para ser ignorado. Além disso, é incrível trabalhar com Python. Portanto, faz sentido usar Python para o trabalho pesado no back-end. Depois de preparar seu modelo, você pode exportá-lo para um formato amigável de front-end e carregá-lo no cliente para executar previsões.

Gerando um modelo

Nesta postagem, vamos construir um modelo para prever a popularidade de um artista com base no número de seguidores no Twitter.

O primeiro passo é colocar as mãos em um conjunto de dados. Para este projeto, usaremos um arquivo artist.csv parecido com este:

twitter_followers,popularity,handle
111024636,94,justinbieber
107920365,91,rihanna
106599902,89,katyperry
95307659,97,taylorswift13
66325495,87,selenagomez
66325135,71,selenagomez
60943147,83,jtimberlake
54815915,82,britneyspears
53569307,85,shakira

Como você pode ver, existem dois valores principais aqui: twitter_followers e popularidade. Isso nos prepara perfeitamente para um modelo de sequência, onde x será twitter_followers ey será popularidade.

Modelo de sequência é uma das opções mais fáceis para construir um modelo. Embora a escolha dependa, em última análise, do caso de uso específico, estou mantendo a simplicidade e mantendo essa abordagem por enquanto.

Construindo o back-end

Quando você está construindo um modelo, há algumas tarefas básicas que você precisa realizar:

• Limpe ou normalize os dados
• Divida os dados em Treinamento (80%) e Teste (20%)
• Escolha um modelo junto com configurações como otimizador e função de perda
• Treine o modelo (ajuste)
• Avalie o modelo
• Salve o modelo

O código a seguir oferece uma boa visão geral dessas tarefas, embora não seja o quadro completo. Você pode conferir o código completo no Github.

Python: primeiros passos com o TensorFlow

def get_model(x, y):
    x_normalized = layers.Normalization(
        axis=None,
    )
    x_normalized.adapt(np.array(x))

    model = tensorflow.keras.Sequential([x_normalized, layers.Dense(units=1)])

    model.compile(
        optimizer=tensorflow.keras.optimizers.Adam(learning_rate=0.1),
        loss="mean_squared_error",
    )

    model.fit(
        x,
        y,
        epochs=2,
        verbose=0,
        validation_split=0.2,
    )

    return model

def main:
  train_features, test_features, train_labels, test_labels = split_data(dataset)

  model = get_model(
      train_features["twitter_followers"],
      train_labels,
  )

  test_loss = model.evaluate(
      test_features["twitter_followers"], test_labels, verbose=2
  )

  model.export("./saved_model")

Como você pode ver, o código Python é bastante simples. Existe uma função principal que trata da divisão dos dados, obtendo o modelo, avaliando-o e, finalmente, salvando-o.

Em poucas palavras, estas são as etapas essenciais para criar um modelo. Mas sejamos realistas: construir um modelo que realmente funcione é uma arte e uma ciência. Meu objetivo aqui é apenas mostrar como pode ser fácil começar a usar Python. No entanto, é preciso muita coisa para criar um modelo com bom desempenho, como ter um conjunto de dados sólido, limpar e normalizar seus dados, escolher o modelo e as configurações corretos e ter o poder computacional para treiná-los. Todas essas tarefas exigem um grande investimento de tempo e esforço!

Consumindo o modelo no frontend

Agora que treinamos e salvamos nosso modelo, é hora de trazê-lo para o frontend. Esta etapa é onde carregaremos o modelo em um formato amigável para a web, para que possamos executar previsões diretamente no navegador. Esteja você usando o TensorFlow.js ou outra biblioteca, a integração do aprendizado de máquina ao seu aplicativo Web abre um mundo de possibilidades. Vamos ver como fazer isso!

O TensorFlow oferece um pacote npm chamado tensorflowjs_converter que ajuda a converter modelos salvos em JSON e binário.

tensorflowjs_converter --input_format=tf_saved_model model/saved_model out/public

• tf_saved_model: Este é o formato usado para salvar o modelo.
• model/saved_model: Este é o diretório onde o modelo foi salvo quando o código Python foi executado.
• out/public: Este é o diretório de saída onde os arquivos amigáveis ​​ao frontend são salvos. A estrutura de pastas ficará assim:

ls -la out/public

group1-shard1of1.bin
model.json

Essa configuração facilita o acesso aos arquivos necessários para seu aplicativo da web.

Javascript: usando TensorFlowJS

Você pode conferir o código completo no Github.

const model = await tensorflow.loadGraphModel("model.json");

const getPopularity = (followers) => {
  const followers = 1_000;
  const normalized = followers;
  const x = tensorflow.tensor(normalized).reshape([-1, 1]);

  const result = model.predict(x);
  const values = result.arraySync();

  const y = values[0][0].toFixed(2) * 100;
  const popularity = y;

  return popularity;
};

Como mencionado anteriormente, este modelo visa “prever popularidade” com base no número de seguidores no Twitter. Embora possa parecer um exemplo simples, ele demonstra efetivamente como gerar um modelo no backend e consumi-lo no frontend.

Dê uma olhada em como getPopularity processa um pouco a entrada, mas a linha principal é model.predict(x), que usa o modelo para prever um valor (y) com base na entrada x.

Vá para a página de demonstração e experimente alguns identificadores do Twitter. É uma maneira divertida de ver como o modelo prevê a popularidade com base na contagem de seguidores.

Conclusão

TensorFlow é uma biblioteca incrível que fornece ferramentas para desenvolvimento de back-end e front-end. Qualquer desenvolvedor JavaScript pode mergulhar na criação de um modelo usando Python ou uma linguagem semelhante e, em seguida, importar facilmente esse modelo para o frontend para executar previsões.

Embora o aprendizado de máquina seja um campo vasto que requer muito conhecimento, ferramentas como o TensorFlow ajudam a preencher a lacuna entre os desenvolvedores de software e de aprendizado de máquina. Isso torna a jornada muito mais tranquila para quem deseja incorporar ML em seus projetos!