Predicting-LeagueOfLegends-Games-With-LSTM

Trabalho implementado na disciplina de Inteligência Computacional, que busca identificar qual o time vencedor em uma partida de League of Legends baseado em informações limitadas.

Sumário

Problema
Dataset
Técnica
Resultados obtidos
Instruções de uso
Vídeo

Problema

No jogo de League of Legends, você deve entrar em partidas separadas e desempenhar com seu time de maneira estratégica, visando eliminar a estrutura central do time inimigo (denominada Nexus). Dessa forma, decisões tomadas no início do jogo causam impactos no decorrer de toda a partida, sobre os objetivos adquiridos e a chance de vitória de cada time. Dito isto, este projeto busca avaliar determinadas situações ocorridas em início de jogo para identificar seus impactos no resultado final das partidas de League of Legends. O trabalho será aplicado sobre partidas de jogadores de alto nível, a fim de obter maior regularidade no nível dos jogadores e no desempenho ao longo do tempo.

Dataset

O dataset utilizado se encontra disponível em: (LoL) League of Legends Ranked Games

Técnica

Para implementação do modelo preditivo será utilizada um modelo LSTM com uma única saída, baseado em séries multivariadas. Dados de série temporal multivariada significam que o modelo deverá observar, para cada intervalo de tempo, mais de uma varíavel, o que se encaixa perfeitamente na proposta elaborada.

Um modelo LSTM precisa de contexto suficiente para aprender a mapear de uma sequência de entrada para um valor de saída. Os LSTMs podem suportar séries temporais de entrada paralela como variáveis ou recursos separados. Portanto, precisamos dividir os dados em amostras, mantendo a ordem das observações nas duas sequências de entrada. Sendo assim, o dataset foi tratado para mapear uma sequência selecionada pelo usuário através de uma interface. Entretanto, apesar do dataset fornecer 61 variáveis, escolhemos utilizar apenas 8 delas, sendo:

gameDuration	firstBlood	firstTower	firstInhibitor	firstBaron	firstDragon	firstRiftHerald		winner

Após escolher quais seriam os inputs com as características para o treinamento do modelo, obtivemos o seguinte output:

Com os dados organizados, podemos então definir uma função split_sequences() responsável por pegar o conjunto de dados como o definimos com linhas para intervalos de tempo e colunas para séries paralelas e amostras de retorno de entrada/saída. Ou seja, transformamos os dados em um array com o tamanho das features escolhidas (representando o x) e o vencedor da partida (y). O número de passos escolhido para cada intervalo de tempo foi de n_steps = 2, onde a cada dois inputs, o output é informado. O resultado obtido foi o seguinte:

[[1 2 1 2 2 0]
 [2 1 1 0 1 0]] 1

Os dados foram então tratados, utilizando do método train_test_split da biblioteca sklearn, permitindo obter uma amostra de mesmo tamanho para fornecer ao modelo. As varíaveis carregadas foram X_Train, X_test, y_train e y_test, o que posteriormente também nos permite obter a acurácia do modelo e visualizar os dados.

X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.5, random_state=5)

Optamos por utilizar um modelo Vanilla LSTM onde o número de passos de tempo e séries paralelas (recursos) são especificados para a camada de entrada por meio do argumento input_shape. Após alguns testes, a quantidade de neurônios escolhidos para a primeira camada LSTM foi de 50. A função de ativação adotada foi a ReLu, uma função de ativação não linear usada em redes neurais multicamadas ou redes neurais profundas, tendo como saída um valor máximo entre zero e o valor de entrada. Para o otimizador foi escolhido o Adam (utilizado para atualizar os pesos da rede iterativos com base nos dados de treinamento). Por fim, a função de perda aplicada foi a Mean Square Error (MSE), que é representada pela soma das distâncias quadradas entre nossa variável-alvo e os valores previstos.

# Modelo utilizado
model = Sequential()
model.add(LSTM(50, activation='relu', input_shape=(n_steps, n_features)))
model.add(Dense(1))
model.compile(optimizer='adam', loss='mse')

O modelo pode então ser treinado e testado. A quantidade de épocas utilizada para treinar o modelo foi de 50, uma vez que permitiram obter uma acurácia alta em um período de tempo para treinamento relativamente curto.

# Fit
model.fit(X_train, y_train, epochs=50, verbose=0)

# Exemplo de predição
x_input = array(X_test)
yhat = model.predict(x_input)

Resultados obtidos

Para a obtenção dos resultados, foram realizados os seguintes experimentos:

Alterações nas variáveis de entrada: foram utilizadas duas configurações de variáveis de entrada.
- FirstBaron e FirstInhibitor;
- FirstBlood, FirstTower e First Dragon
Alterações na quantidade de épocas do modelo: foram utilizadas diferentes quantidades de épocas para o treinamento (50, 100, 300, 500), observando qual resultaria na maior acurácia.
Alterações no nsteps do modelo (2, 3, 5), número que define a cada quantas entradas o modelo tenta predizer o resultado, observando qual resultaria na maior acurácia.

Analisando o gráfico, podemos observar que a melhor acurácia obtida pelo modelo foi de 0,88 (88%) em 50 épocas, com a configuração de entradas de FirstBaron e FirstInhibitor. Podemos notar também que, para ambas as configurações de entradas, quanto maior o número de épocas pior a acurácia do modelo. O caso mais extremo alcançou 0,69 (69%) com 500 épocas na segunda configurações de entradas.

Na busca dos melhores resultados para o modelo, a análise da acurácia com diferentes nsteps foi também realizada, onde o cenário com a menor quantidade de steps (2) alcançou o melhor resultado (87%). Ao utilizar 3 steps a acurácia obtida foi de aproximadamente 85%, enquanto o invervalo de 5 steps resultou em uma acurácia de 83%.

Em um aspecto geral os resultados foram satisfatórios. A acurácia do modelo ficou acima de 80% em alguns dos cenários testados, enquanto seu menor valor foi de 69%. Cabe ressaltar que o modelo terá acurácias diferentes destas dependendo das entradas que forem selecionadas. Alguns ajustes poderiam ser feitos para maximizar o poder de previsão do modelo, como por exemplo testar outras funções de ativação como tanh ou até mesmo a softmax.

Os dados de acurácias exibidos foram obtidos ao fazer o experimento 5 vezes em cada configuração, e depois calculando a média das 5 acurácias obtidas em cada configuração.

Instruções de uso

O software é acessado com a execução do arquivo view.py, utilizando da sua IDE de preferência. A execução do software elaborado foi testada tanto no pyCharm quanto no Visual Studio Code. Um arquivo requirements.txt foi gerado informando todas as dependências necessárias para a execução do projeto e treinamento do mesmo.

Para instalar as dependências necessárias, basta executar o seguinte comando no console:

pip3 install -r requirements.txt

Após isso, é necessário verificar se o caminhho do arquivo está correto. Durante os testes encontramos dois possíveis cenários:

# Possíveis caminhos para acesso ao dataset
pd.read_csv('../datasets/games.csv'

pd.read_csv('datasets\games.csv'

Por fim, após a configuração do projeto, é possível então executar o arquivo view.py para acessar à interface contendo os fatores de influência durante uma partida. Ao selecionar quais características você deseja analisar, basta clicar no botão de executar para que o modelo seja treinado e a interface apresente um gráfico contendo os resultados obtidos e a acurácia alcançada.

Vídeo

O vídeo com a demonstração da aplicação realizada encontra-se disponível para acesso em Lolstm

Avaliação da Entrega Final

PROBLEMA
Ok. Identificar os impactos que situações ocorridas no início do jogo causam no final do jogo League of Legends.
DATASET
Ok. (LoL) League of Legends Ranked Games
TÉCNICA
LSTM. Problemas no relatório:

Faltou explicar qual é a variável de saída do modelo e seus possíveis valores.
Justificativa de terem utilizado apenas 8 variáveis do dataset. Faltou explicar também o que significa cada variável e seus valores.
É mostrada uma tabela de output, mas ela não é explicada. Por exemplo ela mostra 5 exemplos, são apenas estes exemplos considerados no trabalho? Esta tabela mostra um recorte do dataset, ou já são saídas previstas pelo LSTM adotado no trabalho?
“a cada dois inputs, o output é informado” se o dataset já possui quem é o “winner” (output) para cada input, então qual é a necessidade de calcular um outro output a cada dois?
Não foi explicada a estratégia de validação cruzada utilizada.
Foram utilizados parâmetros que não ficaram totalmente claros para a equipe (“random_state”)
RESULTADOS OBTIDOS
Problemas no relatório:
a) Não fica claro se todas as partidas do datset foram usadas no treinamento e resultados.
b) Não são mostrados resultados de outras arquiteturas testadas, para justificar a escolha do LSTM com 50 neurônios.
c) Não foi explicado o motivo de se alterar as variáveis de entrada (ex: só firstbaron e firstinhibitor) e como isso afeta as 8 variáveis do dataset.
d) Nos gráficos de resultados não fica claro se os resultados obtidos são para o conjunto de treinamento ou teste.
Ponto positivo: os resultados são média de 5 execuções.
INSTRUÇÕES DE USO DO SOFTWARE
Ok
VÍDEO
O vídeo esclarece sobre as variáveis do modelo, itens (1) e (2) acima. Os demais itens não foram esclarecidos no vídeo.
OBSERVAÇÕES
A cada execução o sistema está treinando novamente o modelo. Na implementação funcional do software, o correto seria utilizar apenas aquele modelo que produziu o melhor resultado
NOTA FINAL
7.5

guilherme-deschamps / predicting-leagueoflegends-games-with-lstm Goto Github PK