Antes de começar a mexer com Machine Learning pensei que fosse necessário MUITO conhecimento técnico e matemático então sempre adiei meus estudos! Até que resolvi encarar e descobri que eu estava errado! Vem comigo que, juntos, vamos ensinar o computador a aprender!

Primeiramente, o que é machine learning?

Machine learning é a ciência (e arte) de programar computadores para que estes aprendam com dados. Ou seja, é a ciência que dá aos computadores a habilidade de aprenderem sem serem explicitamente programados.

Se estivéssemos fazendo um programa de computador normal, criaríamos uma função que aceitaria um parâmetro de entrada e ele retornaria um valor de saída. Conceitualmente falando, programaríamos a regra, daríamos os valores de entrada e esperaríamos a resposta como saída:

Mas, com Machine Learning, o conceito é diferente (e isso que é SUPER legal)! Nós damos ao computador os valores de entrada e os valores de saída (respostas) e deixamos que ele se vire para descobrir quais são as regras! Ou seja, o computador aprende através dos vários dados informados a ele.

Diferenças entre um programa comum e machine learning: convertendo graus Celsius em graus Fahrenheit usando TensorFlow

TensorFlow é uma plataforma open-source de ferramentas e bibliotecas voltadas para Machine Learning.

Matematicamente falando, se obtém graus Fahrenheit através da fórmula Tf = Tc * 1.8 + 32

Se fossemos programar em Python um programa que converte graus Celsius em graus Fahrenheit, uma possível solução seria essa:

def convertCelsiusToFahrenheit(celsius):
   return celsius * 1.8 + 32

Para ensinar o computador a converter Celsius em Fahrenheit vamos dar dados a ele: valores correspondentes em Celsius e Fahrenheit.

O código abaixo faz toda a mágica (e em seguida analisaremos linha a linha):

import tensorflow as tf

celsius = [-10.0, -9.0, -8.0, -7.0, -6.0, -5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
fahrenheit = [14.0, 15.8, 17.6, 19.4, 21.2, 23.0, 24.8, 26.6, 28.4, 30.2, 32.0, 33.8, 35.6, 37.4, 39.2, 41.0, 42.8, 44.6, 46.4, 48.2, 50.0]

model = tf.keras.Sequential([tf.keras.layers.Dense(units=1, input_shape=[1])])
model.compile(loss='mean_squared_error', optimizer='sgd')
model.fit(celsius, fahrenheit, epochs=300)

print(model.predict([12.0]))

Vamos analisar linha a linha:

import tensorflow as tf

Começamos importando a biblioteca tensorflow

celsius = [-10.0, -9.0, -8.0, -7.0, -6.0, -5.0, -4.0, -3.0, -2.0, -1.0, 0.0, 1.0, 2.0, 3.0, 4.0, 5.0, 6.0, 7.0, 8.0, 9.0, 10.0]
fahrenheit = [14.0, 15.8, 17.6, 19.4, 21.2, 23.0, 24.8, 26.6, 28.4, 30.2, 32.0, 33.8, 35.6, 37.4, 39.2, 41.0, 42.8, 44.6, 46.4, 48.2, 50.0]

Declaramos celsius e fahrenheit com seus respectivos e correspondentes valores

model = tf.keras.Sequential([tf.keras.layers.Dense(units=1, input_shape=[1])])

Criamos uma rede neural com uma camada (units = 1) de um neurônio (tf.keras.layers.Dense) em que aceita 1 parâmetro de entrada (input_shape=[1]) Vamos destrinchar um pouco mais essa linha de código:

• Sequential: agrupa as camadas de neurônios de forma sequencial (porém no exemplo, só temos um). Isso é a rede neural.
• Dense: define uma camada de neurônios conectados. Com o units=1, foi especificado para que, nessa camada, fosse criado somente 1 neurônio

model.compile(loss='mean_squared_error', optimizer='sgd')

Compilamos o modelo e configuramos ele para utilizar como função loss sgd (stochastic gradient descent = gradiente descendente estocástico) e como otimizador mean_squared_error (erro médio quadrático).

A função loss calcula quão distante foi o chute do valor correto. O optimizer identifica quão bom/ruim foi o chute para que no próximo chute, esteja melhor.

A rede neural não faz ideia da relação entre Celsius e Fahrenheit. Então ela estima que Tf = Tc * 10 + 20. A função loss vai calcular quão distante do valor correto isso está e o optimizer vai identificar quão bom ou quão ruim foi o chute. A ideia é que, a cada tentativa, o chute seja cada vez melhor.

model.fit(celsius, fahrenheit, epochs=300)

Associamos os valores de Celsius e Fahrenheit e falamos para o modelo tentar por 300 vezes para aprender

print(model.predict([12.0]))

Quando usamos o model.predict, estamos pedindo para o nosso modelo nos dizer quanto é o valor que queremos.

Se você quiser ver esse código em ação, aqui está o link para o código usando o Google colab: https://colab.research.google.com/drive/1-nzyC-pK_5H_1qf44WSNVdM1oWsxM6DU?usp=sharing

Detalhe importante: 12 graus Celsius convertidos em Fahrenheit são 53.6. Nosso modelo retornou o valor de 53.5, que é uma aproximação muito boa. Isso pode acontecer por 2 principais motivos:

1. treinamos nossa rede neural com poucos dados: 20 valores somente. A rede neural entende que existe uma altíssima probabilidade de a relação entre os dados serem Tc * 1.8 + 32, mas não consegue ter certeza disso.
2. A rede neural vai tentar encontrar a resposta para tudo, então ela se manifesta através de probabilidades.

Esse foi só o primeiro post referente a Machine Learning! 2021 promete MUITO mais! Vem comigo!!