No universo dos games, desvendar o comportamento dos jogadores é um superpoder para desenvolvedores e publicadores. Então, que tal conhecer o TensorFlow? Essa biblioteca de código aberto para computação numérica e aprendizado de máquina, criada pela equipe do Google Brain Team. Imagina só: com o TensorFlow, pesquisadores e desenvolvedores podem construir e treinar modelos de aprendizado de máquina, desde as simples regressões lineares até as redes neurais profundas mais complexas. Essa ferramenta é tão flexível e escalável que parece mágica! E sabe o que é mais legal? Ela pode ser usada em várias aventuras, incluindo visão computacional, processamento de linguagem natural, reconhecimento de fala, e muito mais!

Prepare-se para conhecer a arte de entender os jogadores com o poder do TensorFlow e leve seus jogos a um nível épico! 🎮🚀

A regressão linear é uma técnica de estatística usada para modelar a relação entre uma variável dependente e uma ou mais variáveis independentes. No caso de uma regressão linear simples, essa relação é representada por uma linha reta: y=b0+b1⋅x

Se você estiver interessado em entender mais detalhadamente como a regressão linear funciona, recomendo ler um artigo o artigo: PERSEGUIÇÃO INTELIGENTE: AJUSTANDO A VELOCIDADE DO NPC COM REGRESSÃO LINEAR. Para este artigo, focaremos em como implementar uma regressão linear simples utilizando TensorFlow. Nosso objetivo é aprender a prever o tempo médio que os jogadores gastam em um jogo com base no número de níveis. O modelo é treinado para encontrar os melhores valores para b0 e b1, minimizando o erro entre as previsões do modelo e os valores “reais”. Após o treinamento, o modelo pode fazer previsões precisas sobre quanto tempo os jogadores passam jogando, dado o número de níveis no jogo.

A utilização de TensorFlow neste contexto oferece uma maneira eficiente e escalável de implementar e treinar modelos de machine learning, aproveitando suas capacidades de otimização e suporte a diferentes hardwares, incluindo GPUs.

 

Desenvolvimento

1. Importações e Configuração Inicial

Para o nosso trabalho sera  importado as bibliotecas: numpy, pandas, tensorflow, matplotlib.pyplot e sklearn, as quais serao utilizadas para manipulação de dados, criação do modelo, visualização e avaliação do desempenho.


import numpy as np
import pandas as pd
import tensorflow as tf
import matplotlib.pyplot as plt
from sklearn.preprocessing import StandardScaler
from sklearn.metrics import mean_squared_error, r2_score, mean_absolute_error

 

2. Criação de um Dataset Fictício

Criearemos um dataset fictício com o número de níveis do jogo e o tempo médio de jogo correspondente em horas.



# Vamos criar um dataset fictício onde temos o número de níveis de um jogo e o tempo médio de jogo correspondente em horas:
data = {
'Number_of_Levels': [5, 10, 15, 20, 25, 30, 35, 40, 45, 50],
'Average_Play_Time': [2, 5, 7, 10, 12, 15, 14, 22, 30, 34] # tempo em horas
}
df = pd.DataFrame(data)

3. Divisão dos Dados

Os dados são divididos em variáveis independentes (X) e dependentes (y).


X = df[['Number_of_Levels']].values
y = df['Average_Play_Time'].values

4. Escalonamento dos Dados

Os dados são escalonados usando StandardScaler para normalização, o que facilita o treinamento do modelo


scaler_X = StandardScaler()
scaler_y = StandardScaler()

X = scaler_X.fit_transform(X)
y = scaler_y.fit_transform(y.reshape(-1, 1))

5. Inicialização dos Coeficientes e Variáveis do TensorFlow

Os coeficientes da regressão são inicializados aleatoriamente.


np.random.seed(0)
coef = np.random.rand(2)

b0 = tf.Variable(0.54)
b1 = tf.Variable(0.71)

6. Definição da Função de Perda

A função de perda é definida como o erro quadrático médio entre as previsões e os valores reais


def loss():
return tf.losses.mean_squared_error(y, (b0 + b1 * X))

7. Treinamento do Modelo

O modelo é treinado usando o otimizador SGD (Stochastic Gradient Descent) por 10.000 iterações para minimizar a função de perda e ajustar os coeficientes b0 e b1.


for _ in range(10000):
optimizer.minimize(loss, var_list=[b0, b1])

# Resultados do treinamento - achando os coeficientes
print(f"b0: {b0.numpy()}, b1: {b1.numpy()}")

8. Previsões e Desscalonamento

As previsões são feitas usando os coeficientes treinados, e os valores são “desscalonados” para obter os valores reais.


previsoes = b0 + b1* X

y1 = scaler_y.inverse_transform(y)
print(y1)

previsoes3 = scaler_y.inverse_transform(previsoes)
print(previsoes3)

9. Avaliação do Modelo

O modelo é avaliado usando métricas como MAE, MSE e R².

  • O Mean Absolute Error – (MAE)  é a média dos erros absolutos entre as previsões e os valores reais. Ele fornece uma medida da magnitude média dos erros de previsão em uma escala compreensível.
  • O Mean Squared Error – (MSE) é a média dos quadrados dos erros entre as previsões e os valores reais. Ele penaliza erros grandes mais severamente do que o MAE, pois os erros são elevados ao quadrado.
  • O R² (Coeficiente de Determinação) mede a proporção da variabilidade total dos dados que é explicada pelo modelo. Ele varia entre 0 e 1, onde 1 indica que o modelo explica toda a variabilidade dos dados e 0 indica que o modelo não explica nada.

mae =mean_absolute_error(y1,previsoes3)

mse = mean_squared_error(y1, previsoes3)

r2 = r2_score(y1, previsoes3)

10. Visualizar os dados

Os dados e a linha de regressão são plotados para visualização.


# Plotar os dados e a linha de regressão
plt.scatter(X, y, label='Dados')
plt.plot(X,previsoes, color='red', label='Linha de Regressão')
plt.xlabel('Number of Levels')
plt.ylabel('Average Play Time (hours)')
plt.legend()
plt.show()

 

TensorFlow

Figura 1.0 – Regressão Linear com TensorFlow

 

11. Interpretação dos Resultados

Vamos analisar os resultados das métricas R² e MAE que o algoritmo obteve:

R² (Coeficiente de Determinação): 0.9240142998938108
MAE (Mean Absolute Error): 2.17

MSE (Mean Squared Error) : 7.62

  • MAE = 2.17: Isso significa que, em média, as previsões do modelo estão errando por cerca de 2.17 horas. Dependendo do contexto, esse erro pode ser considerado pequeno ou grande. No entanto, dado o intervalo dos valores reais de tempo de jogo (de 2 a 34 horas), um erro médio de 2.17 horas é relativamente aceitável.
  • R² = 0.92: Isso significa que 92.4% da variação no tempo médio de jogo pode ser explicada pelo número de níveis. Isso é um excelente resultado, indicando que o modelo está capturando bem a relação entre o número de níveis e o tempo de jogo.
  • O MSE de 7.62, sendo a média dos erros elevados ao quadrado, mostra que o modelo tem uma boa precisão geral, mas penaliza mais os erros maiores, revelando a presença de alguns desvios significativos.

Conclusão Geral

Com um R² alto (0.92), um MAE razoavelmente baixo (2.17) e um MSE aceitável (7.62), o modelo de regressão linear simples é bastante eficaz para prever o tempo médio que os jogadores gastam em um jogo com base no número de níveis. Os valores indicam que o modelo está capturando bem a relação e que a maioria das previsões está próxima dos valores reais, apesar de alguns desvios maiores. Mas lembre-se, estamos usando dados fictícios.

12. Por que usar TensorFlow?

  • Flexibilidade: Permite definir e treinar modelos complexos de machine learning, desde regressões simples até redes neurais profundas;
  • Desempenho: Otimizado para executar em diferentes hardwares, incluindo GPUs, o que pode acelerar significativamente o treinamento;
  • Suporte e Comunidade: Uma vasta comunidade e suporte robusto, com muitos recursos e documentação disponível;
  • Produção: Facilita a transição do desenvolvimento para a produção com ferramentas como TensorFlow Serving e TensorFlow Lite.

Conclusão 
E aí está! Com um pouco de mágica matemática e a ajuda poderosa do TensorFlow, conseguimos treinar um modelo de regressão linear simples que pode prever quanto tempo os jogadores passam se divertindo em um jogo, baseado no número de níveis. É como ter um oráculo gamer que, em vez de uma bola de cristal, usa linhas de código para fazer suas previsões.

Imagine só: você cria um jogo e, com algumas linhas de código, pode antecipar o quanto os jogadores vão se viciar nele! Não é incrível? Então, prepare seu controle, aumente o volume, e vamos codar rumo ao futuro das previsões no mundo dos jogos. Quem sabe, um dia, seu jogo não seja o próximo sucesso previsto por seu próprio modelo de regressão linear? Vamos jogar e codar! 🎮🚀