Upload New File

fb164c12 · bailey.barber-scar · 55788c78 · fb164c12
Commit fb164c12 authored May 18, 2023 by bailey.barber-scar
Show whitespace changes
Inline Side-by-side

Showing with 569 additions and 0 deletions

CSGO_Predict_Player_Death_DATA.ipynb CSGO_Predict_Player_Death_DATA.ipynb +569 -0

No files found.
--- a/CSGO_Predict_Player_Death_DATA.ipynb
+++ b/CSGO_Predict_Player_Death_DATA.ipynb
+{
+  "cells": [
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 53
+        },
+        "id": "5bVFEFI8Nd7S",
+        "outputId": "0952cf9d-d2dd-422a-8d6e-661c1bddc9d3"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "'\\n%%shell\\nadd-apt-repository -y ppa:longsleep/golang-backports\\napt -y update\\napt -y install golang-go\\n\\npip install awpy\\n'"
+            ],
+            "application/vnd.google.colaboratory.intrinsic+json": {
+              "type": "string"
+            }
+          },
+          "metadata": {},
+          "execution_count": 2
+        }
+      ],
+      "source": [
+        "\"\"\"\n",
+        "%%shell\n",
+        "add-apt-repository -y ppa:longsleep/golang-backports\n",
+        "apt -y update\n",
+        "apt -y install golang-go\n",
+        "\n",
+        "pip install awpy\n",
+        "\n",
+        "from awpy import DemoParser\n",
+        "demo_parser = DemoParser(demofile = \"demo.dem\")\n",
+        "df = demo_parser.parse(return_type=\"df\")\n",
+        "\"\"\""
+      ],
+      "id": "5bVFEFI8Nd7S"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "52e96819"
+      },
+      "outputs": [],
+      "source": [
+        "import pandas as pd\n",
+        "import os"
+      ],
+      "id": "52e96819"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "Cy9VuFhbJ5uc",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "4d9c909d-a4a4-4ab4-9eda-b0c78ecdf9da"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Mounted at /content/drive\n"
+          ]
+        }
+      ],
+      "source": [
+        "from google.colab import drive\n",
+        "drive.mount('/content/drive')"
+      ],
+      "id": "Cy9VuFhbJ5uc"
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def processInput(dataframe):\n",
+        "    # Outline the features we want from our data\n",
+        "    #features = ['tick', 'eyeX', 'eyeY', 'eyeZ', 'viewX', 'viewY', 'isPlanting', 'isDefusing', 'x', 'y', 'z', 'seconds', 'hp', 'hasBomb',\n",
+        "     #           'isScoped', 'roundNum', 'isBlinded', 'isDucking', 'armor', 'equipmentValue', 'flashGrenades', 'smokeGrenades',\n",
+        "      #          'heGrenades', 'isWalking', 'side']\n",
+        "    features = ['tick', 'eyeX', 'eyeY', 'eyeZ', 'viewX', 'viewY', 'isPlanting', 'isDefusing', 'x', 'y', 'z', 'seconds', 'hp', 'hasBomb',\n",
+        "                'isScoped', 'roundNum', 'isBlinded', 'isDucking', 'armor', 'equipmentValue', 'flashGrenades', 'smokeGrenades',\n",
+        "                'heGrenades', 'isWalking', 'side']\n",
+        "\n",
+        "\n",
+        "    # Set our input and output\n",
+        "    X = dataframe[features]\n",
+        "\n",
+        "    # Encode our categorical features\n",
+        "    # Select the categorical columns to be one-hot encoded\n",
+        "    categorical_cols = ['side', 'isPlanting', 'isDefusing', 'hasBomb', 'isScoped', 'isBlinded', 'isDucking', 'isWalking']\n",
+        "\n",
+        "    # Perform one-hot encoding using pandas get_dummies function\n",
+        "    X = pd.get_dummies(X, columns=categorical_cols)\n",
+        "\n",
+        "    return X"
+      ],
+      "metadata": {
+        "id": "5N-wRSrSahOm"
+      },
+      "id": "5N-wRSrSahOm",
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "def processOutput(dataframe):\n",
+        "    Y = dataframe['isAlive'].values  # Extract the target column as a NumPy array\n",
+        "    return Y"
+      ],
+      "metadata": {
+        "id": "3LfPUb4nfEHJ"
+      },
+      "id": "3LfPUb4nfEHJ",
+      "execution_count": null,
+      "outputs": []
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "8022d35e"
+      },
+      "outputs": [],
+      "source": [
+        "#Read our CSV into a dataframe\n",
+        "allData = allData = pd.read_csv('/content/drive/MyDrive/CSGO DEMOS/allDemos25.csv')\n",
+        "\n",
+        "# Split up our data into the percentage we want - 5 games (0.2), 10 games (0.4), 25 games\n",
+        "#dataSample = allData.sample(frac=0.2)\n",
+        "dataSample = allData"
+      ],
+      "id": "8022d35e"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "42b4652a"
+      },
+      "outputs": [],
+      "source": [
+        "import tensorflow as tf\n",
+        "import numpy as np\n",
+        "from sklearn.model_selection import train_test_split\n",
+        "from sklearn.preprocessing import LabelEncoder, OneHotEncoder\n",
+        "from sklearn.metrics import accuracy_score, precision_score, recall_score, f1_score"
+      ],
+      "id": "42b4652a"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "8e6021e1"
+      },
+      "outputs": [],
+      "source": [
+        "# Set our input and output\n",
+        "X = processInput(dataSample)\n",
+        "Y = processOutput(dataSample)"
+      ],
+      "id": "8e6021e1"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "ab7cee95",
+        "outputId": "abd1b444-ff91-4f67-88df-924a364df850"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "Index(['tick', 'eyeX', 'eyeY', 'eyeZ', 'viewX', 'viewY', 'x', 'y', 'z',\n",
+              "       'seconds', 'hp', 'roundNum', 'armor', 'equipmentValue', 'flashGrenades',\n",
+              "       'smokeGrenades', 'heGrenades', 'side_CT', 'side_T', 'isPlanting_False',\n",
+              "       'isPlanting_True', 'isDefusing_False', 'isDefusing_True',\n",
+              "       'hasBomb_False', 'hasBomb_True', 'isScoped_False', 'isScoped_True',\n",
+              "       'isBlinded_False', 'isBlinded_True', 'isDucking_False',\n",
+              "       'isDucking_True', 'isWalking_False', 'isWalking_True'],\n",
+              "      dtype='object')"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 8
+        }
+      ],
+      "source": [
+        "# List the types so we know what needs to be one hot encoded\n",
+        "X.dtypes"
+      ],
+      "id": "ab7cee95"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "b2df8ac1",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "91f307eb-67ea-411b-97fa-9c8a966ae976"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(621973, 33)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 9
+        }
+      ],
+      "source": [
+        "X.shape"
+      ],
+      "id": "b2df8ac1"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "718e19a3",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "988ced78-8790-4f2e-91fd-f929e2f7756a"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(621973,)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 10
+        }
+      ],
+      "source": [
+        "Y.shape"
+      ],
+      "id": "718e19a3"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "6d17d909"
+      },
+      "outputs": [],
+      "source": [
+        "X_train, X_test, Y_train, Y_test = train_test_split(X, Y, test_size=0.2, random_state=42)"
+      ],
+      "id": "6d17d909"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "9mHdWykRJM8M",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "ddefadad-b8d2-4381-b1eb-74b124f61c9a"
+      },
+      "outputs": [
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "(497578, 33)"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 12
+        }
+      ],
+      "source": [
+        "X_train.shape"
+      ],
+      "id": "9mHdWykRJM8M"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "fafaccc9",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "d62d8631-2ed1-4e8c-cb1f-6259bcd8b3c6"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "WARNING:tensorflow:Layer lstm will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Build the model - RNN\n",
+        "model = tf.keras.Sequential([\n",
+        "    tf.keras.layers.LSTM(128, activation='relu', input_shape=(X_train.shape[1], 1)),\n",
+        "    tf.keras.layers.Dense(64, activation='relu'),\n",
+        "    tf.keras.layers.Dense(32, activation='relu'),\n",
+        "    tf.keras.layers.Dense(16, activation='relu'),\n",
+        "    tf.keras.layers.Dense(1, activation='sigmoid')\n",
+        "])"
+      ],
+      "id": "fafaccc9"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "009e6972"
+      },
+      "outputs": [],
+      "source": [
+        "from sklearn.metrics import precision_score, recall_score, f1_score, roc_auc_score\n",
+        "# Compile the model\n",
+        "model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])"
+      ],
+      "id": "009e6972"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "2a0b42f4",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "71d6618d-9e30-44f2-8e76-0b5f608a6eba"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "Epoch 1/8\n",
+            "15550/15550 [==============================] - 579s 37ms/step - loss: 16.9916 - accuracy: 0.6889 - val_loss: 0.5770 - val_accuracy: 0.7387\n",
+            "Epoch 2/8\n",
+            "15550/15550 [==============================] - 571s 37ms/step - loss: 0.5739 - accuracy: 0.7400 - val_loss: 0.5742 - val_accuracy: 0.7389\n",
+            "Epoch 3/8\n",
+            "15550/15550 [==============================] - 569s 37ms/step - loss: 0.5732 - accuracy: 0.7399 - val_loss: 0.5743 - val_accuracy: 0.7389\n",
+            "Epoch 4/8\n",
+            "15550/15550 [==============================] - 570s 37ms/step - loss: 0.5732 - accuracy: 0.7399 - val_loss: 0.5742 - val_accuracy: 0.7389\n",
+            "Epoch 5/8\n",
+            "15550/15550 [==============================] - 571s 37ms/step - loss: 0.5732 - accuracy: 0.7399 - val_loss: 0.5742 - val_accuracy: 0.7389\n",
+            "Epoch 6/8\n",
+            "15550/15550 [==============================] - 571s 37ms/step - loss: 0.5732 - accuracy: 0.7399 - val_loss: 0.5742 - val_accuracy: 0.7389\n",
+            "Epoch 7/8\n",
+            "15550/15550 [==============================] - 568s 37ms/step - loss: 0.5732 - accuracy: 0.7399 - val_loss: 0.5742 - val_accuracy: 0.7389\n",
+            "Epoch 8/8\n",
+            "15550/15550 [==============================] - 569s 37ms/step - loss: 0.5732 - accuracy: 0.7399 - val_loss: 0.5744 - val_accuracy: 0.7389\n"
+          ]
+        },
+        {
+          "output_type": "execute_result",
+          "data": {
+            "text/plain": [
+              "<keras.callbacks.History at 0x7feb70527e80>"
+            ]
+          },
+          "metadata": {},
+          "execution_count": 15
+        }
+      ],
+      "source": [
+        "# Train the model\n",
+        "model.fit(X_train, Y_train, epochs=8, batch_size=32, validation_data=(X_test, Y_test))"
+      ],
+      "id": "2a0b42f4"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "DQGX_izLccHn"
+      },
+      "outputs": [],
+      "source": [
+        "# Save the model :)\n",
+        "model.save(\"/content/drive/MyDrive/CSGO MODELS/MODEL25\")"
+      ],
+      "id": "DQGX_izLccHn"
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "W8mSc63RqMO5",
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "outputId": "845005f2-0f26-4ab8-ab8e-21be5f008782"
+      },
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stderr",
+          "text": [
+            "WARNING:tensorflow:Layer lstm will not use cuDNN kernels since it doesn't meet the criteria. It will use a generic GPU kernel as fallback when running on GPU.\n"
+          ]
+        }
+      ],
+      "source": [
+        "# Load the model :)\n",
+        "#model = tf.keras.models.load_model(\"/content/drive/MyDrive/CSGO MODELS/LSTM\")"
+      ],
+      "id": "W8mSc63RqMO5"
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "import matplotlib.pyplot as plt\n",
+        "import numpy as np\n",
+        "\n",
+        "# Retrieve the weights from the SimpleRNN layer\n",
+        "rnn_layer = model.layers[0]\n",
+        "weights = rnn_layer.get_weights()[0]  # Weights matrix of shape (input_dim, units)\n",
+        "\n",
+        "# Retrieve the feature names from X.columns\n",
+        "feature_names = X.columns\n",
+        "\n",
+        "# Sort the weights and feature names in descending order based on the weights\n",
+        "sorted_weights = sorted(zip(weights.flatten(), feature_names), reverse=False)\n",
+        "\n",
+        "# Separate the weights and feature names\n",
+        "sorted_weights, sorted_features = zip(*sorted_weights)\n",
+        "\n",
+        "# Create a diverging color map\n",
+        "cmap = plt.get_cmap('coolwarm')\n",
+        "\n",
+        "# Calculate the maximum absolute weight\n",
+        "max_weight = max(np.abs(sorted_weights))\n",
+        "\n",
+        "# Set the size of the graph\n",
+        "fig, ax = plt.subplots(figsize=(4, 6))\n",
+        "\n",
+        "# Create a horizontal bar chart\n",
+        "ax.barh(sorted_features, sorted_weights, color=cmap(sorted_weights / max_weight))\n",
+        "ax.set_xlabel('Weight')\n",
+        "ax.set_ylabel('Feature')\n",
+        "ax.set_title('Weights of Features')\n",
+        "\n",
+        "# Adjust the x-axis limits\n",
+        "ax.set_xlim(-max_weight, max_weight)\n",
+        "\n",
+        "# Show the plot\n",
+        "plt.show()\n"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/",
+          "height": 564
+        },
+        "id": "sfv8Yb05BqKN",
+        "outputId": "6194b616-6283-477c-a2b8-653690ce62ae"
+      },
+      "id": "sfv8Yb05BqKN",
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "display_data",
+          "data": {
+            "text/plain": [
+              "<Figure size 400x600 with 1 Axes>"
+            ],
+            "image/png": "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\n"
+          },
+          "metadata": {}
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "source": [
+        "# Evaluate the model on X_test and Y_test\n",
+        "loss, accuracy = model.evaluate(X_test, Y_test)\n",
+        "\n",
+        "print(\"Accuracy:\" + str(accuracy))"
+      ],
+      "metadata": {
+        "colab": {
+          "base_uri": "https://localhost:8080/"
+        },
+        "id": "yVmtP5drI0Jf",
+        "outputId": "cca0b0c8-6354-4ec3-d5aa-df05b558ef81"
+      },
+      "id": "yVmtP5drI0Jf",
+      "execution_count": null,
+      "outputs": [
+        {
+          "output_type": "stream",
+          "name": "stdout",
+          "text": [
+            "778/778 [==============================] - 4s 5ms/step - loss: 0.0971 - accuracy: 0.9550\n",
+            "Accuracy:0.9550223350524902\n"
+          ]
+        }
+      ]
+    },
+    {
+      "cell_type": "code",
+      "execution_count": null,
+      "metadata": {
+        "id": "1HGB9NchVRvb"
+      },
+      "outputs": [],
+      "source": [
+        "model.summary()"
+      ],
+      "id": "1HGB9NchVRvb"
+    }
+  ],
+  "metadata": {
+    "colab": {
+      "provenance": [],
+      "gpuType": "A100",
+      "machine_shape": "hm"
+    },
+    "gpuClass": "standard",
+    "kernelspec": {
+      "display_name": "Python 3 (ipykernel)",
+      "language": "python",
+      "name": "python3"
+    },
+    "language_info": {
+      "codemirror_mode": {
+        "name": "ipython",
+        "version": 3
+      },
+      "file_extension": ".py",
+      "mimetype": "text/x-python",
+      "name": "python",
+      "nbconvert_exporter": "python",
+      "pygments_lexer": "ipython3",
+      "version": "3.9.13"
+    },
+    "accelerator": "GPU"
+  },
+  "nbformat": 4,
+  "nbformat_minor": 5
+}
\ No newline at end of file