bridgesign/bidder_sim.ipynb

## bidder_sim.ipynb
{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "name": "bidding_sim.ipynb",
      "provenance": [],
      "collapsed_sections": []
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "accelerator": "GPU"
  },
  "cells": [
    {
      "cell_type": "code",
      "metadata": {
        "id": "gZb04Kp5zqrK",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import numpy as np\n",
        "import pandas as pd\n",
        "import matplotlib.pyplot as plt"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "ocOMSj-rAS8V",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "import torch\n",
        "from torch import nn\n",
        "import torch.nn.functional as F\n",
        "import torch.optim as optim"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "uO-Hcpqqgizu",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "plt.rcParams[\"figure.figsize\"] = (20,8)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "OzJygrpazsbC",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "class user:\n",
        "  \"\"\"\n",
        "  The user class defines a user which are a part of the game\n",
        "  It keeps the views and clicks vector for all the ads and shares the\n",
        "  data to the bidder only about the ads the bidder owns\n",
        "\n",
        "  It also determines whether it will see the ad or not depending on\n",
        "  the overall clicks and views of all ads.\n",
        "\n",
        "  It also updates the vectors based on the view and click. The data about\n",
        "  other preferences of the user is not revealed and the bidder never stores the\n",
        "  user data, thus maintaing privacy\n",
        "  \"\"\"\n",
        "  def __init__(self, view_vec, click_vec):\n",
        "    self.view_vec = view_vec\n",
        "    self.click_vec = click_vec\n",
        "  \n",
        "  def toss(self):\n",
        "    clicks = np.zeros(self.view_vec.size)\n",
        "    views_n = self.view_vec+0.1\n",
        "    views_n = views_n/np.linalg.norm(views_n, 1)\n",
        "    clicks_n = self.click_vec+0.1\n",
        "    clicks_n = clicks_n/np.linalg.norm(clicks_n, 1)\n",
        "    r = views_n/clicks_n\n",
        "    prob = abs((1-r)/(1+r))\n",
        "    for j in range(clicks.size):\n",
        "      clicks[j] = np.random.binomial(1, prob[j])\n",
        "    \n",
        "    return clicks, views_n, clicks_n\n",
        "  \n",
        "  def update(self, view, click):\n",
        "    if view>-1:\n",
        "      self.view_vec[view]+=1\n",
        "    if click==1:\n",
        "      self.click_vec[view]+=1\n",
        "\n",
        "class bidmodel(nn.Module):\n",
        "  \"\"\"\n",
        "  This defines the neural model used by the bidder\n",
        "  It gives teo vectors as output. The first is the vectors\n",
        "  of bids and the second the probability of click vector over\n",
        "  all the ads the bidder owns.\n",
        "  \"\"\"\n",
        "  def __init__(self, size, cuda=True):\n",
        "    super(bidmodel, self).__init__()\n",
        "\n",
        "    self.fc1 = torch.nn.Linear(out_features=size//2, in_features=size)\n",
        "    self.fc2 = torch.nn.Linear(out_features=size//2, in_features=size)\n",
        "    self.fc11 = torch.nn.Linear(out_features=100, in_features=size//2)\n",
        "    self.fc21 = torch.nn.Linear(out_features=100, in_features=size//2)\n",
        "    self.fc3 = torch.nn.Linear(out_features=200, in_features=200)\n",
        "    self.fc3 = torch.nn.Linear(out_features=size//2, in_features=200)\n",
        "    self.fc4 = torch.nn.Linear(out_features=size, in_features=size//2)\n",
        "    self.fc5 = torch.nn.Linear(out_features=size, in_features=size//2)\n",
        "\n",
        "    if cuda:\n",
        "      self.cuda()\n",
        "  \n",
        "  def forward(self, vvec, cvec):\n",
        "    vvec = self.fc1(vvec)\n",
        "    vvec = F.relu(self.fc11(vvec))\n",
        "    cvec = self.fc2(cvec)\n",
        "    cvec = F.relu(self.fc21(cvec))\n",
        "\n",
        "    vec = torch.cat([vvec, cvec])\n",
        "    vec = self.fc3(vec)\n",
        "    vec = torch.tanh(vec)\n",
        "\n",
        "    bid = F.relu(torch.sigmoid(self.fc4(vec))*torch.tensor(2).float() - torch.tensor(1).float())+ torch.tensor(0.001).float()\n",
        "    click = torch.sigmoid(self.fc5(vec))\n",
        "\n",
        "    return bid, click\n",
        "\n",
        "class bidder:\n",
        "  \"\"\"\n",
        "  The bidder stores the ads that it owns and generates a bidmodel of\n",
        "  appropriate size. It has a reward which is it tries to maximize.\n",
        "\n",
        "  For maximization, it uses the predicted bid and the fact whether\n",
        "  it won, the ad clicked or not. The data is not shared between bidders.\n",
        "  So the bidders only know their own bids and whether they won the bid or not.\n",
        "  \"\"\"\n",
        "  def __init__(self, advec, cuda=True):\n",
        "    self.advec = advec\n",
        "    self.model = bidmodel(advec.size, cuda=cuda)\n",
        "    self.cuda = cuda\n",
        "\n",
        "    self.loss = nn.MSELoss()\n",
        "    self.optimizer = optim.Adam(self.model.parameters(), lr=0.003)\n",
        "\n",
        "    self.reward = 1\n",
        "  \n",
        "  def predict(self, vvec, cvec):\n",
        "    in_v = torch.from_numpy(vvec[self.advec]).float()\n",
        "    in_c = torch.from_numpy(cvec[self.advec]).float()\n",
        "\n",
        "    if self.cuda:\n",
        "      in_v = in_v.to('cuda')\n",
        "      in_c = in_c.to('cuda')\n",
        "    \n",
        "    self.bid, self.click = self.model(in_v, in_c)\n",
        "  \n",
        "  def backprop(self, view, click):\n",
        "    bidv = self.bid.clone().cpu().detach().numpy()\n",
        "    clickv = self.click.clone().cpu().detach().numpy()\n",
        "\n",
        "    ccl = np.where(clickv>0.5, clickv, (1-clickv))\n",
        "\n",
        "    bidv = ccl*bidv+0.01\n",
        "    if click==1:\n",
        "      self.reward+=1\n",
        "      bidv = ccl*bidv[view]\n",
        "    if view>-1:\n",
        "      self.reward-=bidv[view]\n",
        "      clickv[view]=click\n",
        "      if self.reward<0:\n",
        "        bidv = 0.5*bidv\n",
        "      bidv[view] = 0.89*(bidv[view]-0.01)*click\n",
        "    \n",
        "    bidv = (max(0, self.reward)+2.1)/(max(0, self.reward)+1)*bidv\n",
        "\n",
        "    if self.reward<-5 and view==-1:\n",
        "      bidv = bidv*0.1\n",
        "    if np.random.binomial(1, 0.01)==1 and self.reward>0:\n",
        "      bidv = np.ones(self.advec.size)*0.1\n",
        "    elif np.random.binomial(1, 0.01)==1:\n",
        "      bidv = np.ones(self.advec.size)*0.01\n",
        "    elif np.random.binomial(1, 0.01)==1:\n",
        "      bidv = np.ones(self.advec.size)\n",
        "\n",
        "    self.optimizer.zero_grad()\n",
        "    \n",
        "    bidv = torch.from_numpy(bidv)\n",
        "    clickv = torch.from_numpy(clickv)\n",
        "    if self.cuda:\n",
        "      bidv = bidv.to('cuda')\n",
        "      clickv = clickv.to('cuda')\n",
        "    loss = self.loss(bidv, self.bid)\n",
        "    loss+= self.loss(clickv, self.click)\n",
        "\n",
        "    loss.backward()\n",
        "    self.optimizer.step()\n",
        "\n",
        "class generator:\n",
        "  \"\"\"\n",
        "  The generator creates a single ad slot with a random user and\n",
        "  makes the bidders to bid for the slot. Depending on the result,\n",
        "  it sends back the result to the individual bidders.\n",
        "  \"\"\"\n",
        "  def __init__(self, users, bidders):\n",
        "    self.users = users\n",
        "    self.bidders = bidders\n",
        "    self.bidders_num = len(bidders)\n",
        "    self.users_num = len(users)\n",
        "  \n",
        "  def generate(self):\n",
        "    ruser = np.random.choice(self.users)\n",
        "    clicks, views_n, clicks_n = ruser.toss()\n",
        "\n",
        "    bidi = 0\n",
        "    bidder_index = -1\n",
        "    advec_index = -1\n",
        "    index = -1\n",
        "    for i in range(self.bidders_num):\n",
        "      b = self.bidders[i]\n",
        "      b.predict(views_n, clicks_n)\n",
        "      maxi = torch.max(b.bid)\n",
        "      if maxi>bidi:\n",
        "        bidi = float(maxi)\n",
        "        advec_index = torch.argmax(b.bid)\n",
        "        index = b.advec[advec_index]\n",
        "        bidder_index = i\n",
        "\n",
        "    ruser.update(index, clicks[index])\n",
        "    for i in range(self.bidders_num):\n",
        "      if i==bidder_index:\n",
        "        self.bidders[i].backprop(advec_index, clicks[index])\n",
        "      else:\n",
        "        self.bidders[i].backprop(-1, 0)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "iD97Vj34--t8",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 54
        },
        "outputId": "d6e75753-7c41-4b49-a041-f95f653f7557"
      },
      "source": [
        "# Loading and curating the dataset\n",
        "df = pd.read_csv('datasets/train_trim.csv')\n",
        "df.device_id = pd.Categorical(df.device_id)\n",
        "df['device_id'] = df.device_id.cat.codes\n",
        "df.device_model = pd.Categorical(df.device_model)\n",
        "df['device_model'] = df.device_model.cat.codes\n",
        "\n",
        "num_id = len(df['device_id'].drop_duplicates().index)\n",
        "num_model = len(df['device_model'].drop_duplicates().index)\n",
        "\n",
        "df['uid'] = df['device_id']*num_model + df['device_model']\n",
        "\n",
        "df.uid = pd.Categorical(df.uid)\n",
        "df['uid'] = df.uid.cat.codes\n",
        "\n",
        "# Removing users with less than 4 datapoints\n",
        "df = df[df.groupby('uid')['uid'].transform('count').ge(3)]\n",
        "\n",
        "df.uid = pd.Categorical(df.uid)\n",
        "df['uid'] = df.uid.cat.codes\n",
        "\n",
        "num_users = len(df.uid.drop_duplicates().index)\n",
        "print(\"Number of users:\",num_users)\n",
        "\n",
        "df.site_id = pd.Categorical(df.site_id)\n",
        "df['site_id'] = df.site_id.cat.codes\n",
        "num_ads = len(df['site_id'].drop_duplicates().index)\n",
        "print(\"Number of Ads:\",num_ads)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "stream",
          "text": [
            "Number of users: 124687\n",
            "Number of Ads: 3127\n"
          ],
          "name": "stdout"
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "gamjm2aH_XFH",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Generating users\n",
        "users = [user(np.zeros(num_ads), np.zeros(num_ads)) for j in range(num_users)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "zjq_tsUUAN_r",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Creating user click-view vectors\n",
        "rows = df[['uid','site_id', 'click']].values\n",
        "for row in rows:\n",
        "  users[row[0]].view_vec[row[1]]+=1\n",
        "  users[row[0]].click_vec[row[1]]+=row[2]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "z333kIegAsex",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Splitting Ads\n",
        "x = np.arange(num_ads)\n",
        "np.random.shuffle(x)\n",
        "parts = np.array_split(x, 5)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VJMltmFCEBWV",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Creating bidders\n",
        "bidders = [bidder(parts[j], False) for j in range(5)]"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "JCoq5fGW4Gns",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Rerun point"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "-CaGrOrJGAAG",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# Creating Generator\n",
        "Gen = generator(users, bidders)"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "K1eqtSQsb0r9",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "rewards = []"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "UnGLpiQoqmiB",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for b in Gen.bidders:\n",
        "  b.reward = 1"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "VzpQV2GDBHeo",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "# For more training directly run from here"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "hRxl2J4oLH2E",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        "for i in range(20):\n",
        "  for j in range(100):\n",
        "    Gen.generate()\n",
        "  rewards.append([b.reward for b in Gen.bidders])"
      ],
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "KB_j0qQiMi6T",
        "colab_type": "code",
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 575
        },
        "outputId": "970829f5-1a14-4feb-ef01-d86461b357f4"
      },
      "source": [
        "plt.plot(rewards)"
      ],
      "execution_count": null,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "[<matplotlib.lines.Line2D at 0x7ff9268e8550>,\n",
              " <matplotlib.lines.Line2D at 0x7ff9268e8668>,\n",
              " <matplotlib.lines.Line2D at 0x7ff9268e87b8>,\n",
              " <matplotlib.lines.Line2D at 0x7ff9268e8908>,\n",
              " <matplotlib.lines.Line2D at 0x7ff9268e8a58>]"
            ]
          },
          "metadata": {
            "tags": []
          },
          "execution_count": 17
        },
        {
          "output_type": "display_data",
          "data": {
            "image/png": "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\n",
            "text/plain": [
              "<Figure size 1440x576 with 1 Axes>"
            ]
          },
          "metadata": {
            "tags": [],
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "code",
      "metadata": {
        "id": "rIS_yUGZUnP7",
        "colab_type": "code",
        "colab": {}
      },
      "source": [
        ""
      ],
      "execution_count": null,
      "outputs": []
    }
  ]
}