test_pipeline5.ipynb

{
 "cells": [
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# testing pipeline 5\n",
    "11/15\n",
    "\n",
    "The purpose of this file is to work on adapting a tokenizer training method like in scgpt. Idea feiyang proposed that makes more sense than what I would have done otherwise\n",
    "\n",
    "Basically embed protein names via some token, then do some linear network for the other one"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Seed set to 42\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import os\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import pytorch_lightning as pl\n",
    "from pytorch_lightning import seed_everything\n",
    "from torch import Tensor\n",
    "\n",
    "seed_everything(42)\n",
    "\n",
    "\n",
    "from utils import *\n",
    "from sklearn.metrics import mean_squared_error\n",
    "# from transformers import GPT2Model, GPT2Tokenizer\n",
    "\n",
    "dataloader = LoadData(impute='KNN',load = True)\n",
    "cv = CV(dataloader)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [],
   "source": [
    "# here's the stolen class\n",
    "\n",
    "class ContinuousValueEncoder(nn.Module):\n",
    "    \"\"\"\n",
    "    Encode real number values to a vector using neural nets projection.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, d_model: int = 1024, dropout: float = 0.1, max_value: int = 512):\n",
    "        super().__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "        self.linear1 = nn.Linear(1, d_model)\n",
    "        self.activation = nn.ReLU()\n",
    "        self.linear2 = nn.Linear(d_model, d_model)\n",
    "        self.norm = nn.LayerNorm(d_model)\n",
    "        self.max_value = max_value\n",
    "\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            x: Tensor, shape [batch_size, seq_len]\n",
    "        \"\"\"\n",
    "        # TODO: test using actual embedding layer if input is categorical\n",
    "        # expand last dimension\n",
    "        x = x.unsqueeze(-1)\n",
    "        # clip x to [-inf, max_value]\n",
    "        #x = torch.clamp(x, max=self.max_value) # Ignored for now, doesn't really make sense\n",
    "        x = self.activation(self.linear1(x))\n",
    "        x = self.linear2(x)\n",
    "        x = self.norm(x)\n",
    "        return self.dropout(x)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 10,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2, 251, 1])\n"
     ]
    }
   ],
   "source": [
    "x = torch.tensor(cv.met[:2,:]).float()\n",
    "print(x.unsqueeze(-1).shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 12,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2, 251, 1024])\n"
     ]
    }
   ],
   "source": [
    "#run it through the model\n",
    "encoder = ContinuousValueEncoder()\n",
    "y = encoder(x)\n",
    "print(y.shape)\n",
    "#it's perfect, gives it 251x1024"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(251,)\n",
      "X20280.0.0\n"
     ]
    }
   ],
   "source": [
    "#now that we have this network,  this give sus each of our values as a 1024 vector, let's just go ahead and ignore that\n",
    "#now find some way to embed my categorical variables and then just add it to each of the elements of the vector\n",
    "#so the output should be batch size x 1024 because that will be broadcasted to each of the samples of the vector\n",
    "#each sample has its own value using that embedding\n",
    "print(cv.m_cols.shape)\n",
    "print(cv.m_cols[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 15,
   "metadata": {},
   "outputs": [],
   "source": [
    "class CategoryValueEncoder(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        num_embeddings: int,\n",
    "        embedding_dim: int,\n",
    "        padding_idx: int = None,\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.embedding = nn.Embedding(\n",
    "            num_embeddings, embedding_dim, padding_idx=padding_idx\n",
    "        )\n",
    "        self.enc_norm = nn.LayerNorm(embedding_dim)\n",
    "\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        x = x.long()\n",
    "        x = self.embedding(x)  # (batch, seq_len, embsize)\n",
    "        x = self.enc_norm(x)\n",
    "        return x\n",
    "    \n",
    "#num embeddings means input the metabolite index which is 0 to 251"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 21,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([1024])\n",
      "tensor([-0.5191, -0.4254, -0.6439,  0.4114, -0.3544,  2.0380,  0.1668,  0.2545,\n",
      "        -0.1622, -1.6150], grad_fn=<SliceBackward0>)\n",
      "torch.Size([1024])\n",
      "tensor([ 0.4662, -0.4237, -0.5169, -0.3998, -1.0081, -0.3986, -0.4728,  0.2921,\n",
      "        -0.9745, -0.9531], grad_fn=<SliceBackward0>)\n",
      "error: index out of range in self\n"
     ]
    }
   ],
   "source": [
    "#initialize\n",
    "cat_encoder = CategoryValueEncoder(num_embeddings = 251, embedding_dim = 1024)\n",
    "#run it through\n",
    "y = cat_encoder(torch.tensor(0))\n",
    "print(y.shape)\n",
    "print(y[0:10])\n",
    "z = cat_encoder(torch.tensor(250))\n",
    "print(z.shape)\n",
    "print(z[0:10])\n",
    "try:\n",
    "    print(cat_encoder(torch.tensor(251)))\n",
    "except Exception as e:\n",
    "    print('error:', e)\n",
    "    \n",
    "#see, it does work as intended\n",
    "#very different indeed"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 1024])\n"
     ]
    }
   ],
   "source": [
    "#let's try a longer tensor of multiple values\n",
    "y = cat_encoder(torch.tensor([0,1,2,3,4,5,6,7,8,9]))\n",
    "print(y.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "tensor([  0,   1,   2,   3,   4,   5,   6,   7,   8,   9,  10,  11,  12,  13,\n",
       "         14,  15,  16,  17,  18,  19,  20,  21,  22,  23,  24,  25,  26,  27,\n",
       "         28,  29,  30,  31,  32,  33,  34,  35,  36,  37,  38,  39,  40,  41,\n",
       "         42,  43,  44,  45,  46,  47,  48,  49,  50,  51,  52,  53,  54,  55,\n",
       "         56,  57,  58,  59,  60,  61,  62,  63,  64,  65,  66,  67,  68,  69,\n",
       "         70,  71,  72,  73,  74,  75,  76,  77,  78,  79,  80,  81,  82,  83,\n",
       "         84,  85,  86,  87,  88,  89,  90,  91,  92,  93,  94,  95,  96,  97,\n",
       "         98,  99, 100, 101, 102, 103, 104, 105, 106, 107, 108, 109, 110, 111,\n",
       "        112, 113, 114, 115, 116, 117, 118, 119, 120, 121, 122, 123, 124, 125,\n",
       "        126, 127, 128, 129, 130, 131, 132, 133, 134, 135, 136, 137, 138, 139,\n",
       "        140, 141, 142, 143, 144, 145, 146, 147, 148, 149, 150, 151, 152, 153,\n",
       "        154, 155, 156, 157, 158, 159, 160, 161, 162, 163, 164, 165, 166, 167,\n",
       "        168, 169, 170, 171, 172, 173, 174, 175, 176, 177, 178, 179, 180, 181,\n",
       "        182, 183, 184, 185, 186, 187, 188, 189, 190, 191, 192, 193, 194, 195,\n",
       "        196, 197, 198, 199, 200, 201, 202, 203, 204, 205, 206, 207, 208, 209,\n",
       "        210, 211, 212, 213, 214, 215, 216, 217, 218, 219, 220, 221, 222, 223,\n",
       "        224, 225, 226, 227, 228, 229, 230, 231, 232, 233, 234, 235, 236, 237,\n",
       "        238, 239, 240, 241, 242, 243, 244, 245, 246, 247, 248, 249, 250])"
      ]
     },
     "execution_count": 24,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "torch.arange(251)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#so we have our two encoders, now we need to combine them in the transformer module\n",
    "\n",
    "class TransformerEncoderLayer(nn.Module):\n",
    "    \"\"\"\n",
    "    Transformer encoder layer module.\n",
    "\n",
    "    :param int d_model: the number of expected features in the input (required).\n",
    "    :param int nhead: the number of heads in the multiheadattention models (required).\n",
    "    :param int dim_feedforward: the dimension of the feedforward network model (default=2048).\n",
    "    :param float dropout: the dropout value (default=0.1).\n",
    "    :param activation: the activation function of intermediate layer, relu or gelu (default=relu).\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(\n",
    "        self,\n",
    "        d_model: int = 1024,\n",
    "        nhead: int = 8,\n",
    "        dim_feedforward: int = 2048,\n",
    "        dropout: float = 0.1,\n",
    "        activation: str = \"relu\",\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.self_attn = nn.MultiheadAttention(d_model, nhead, dropout=dropout)\n",
    "        # Implementation of Feedforward model\n",
    "        self.linear1 = nn.Linear(d_model, dim_feedforward)\n",
    "        self.dropout = nn.Dropout(dropout)\n",
    "        self.linear2 = nn.Linear(dim_feedforward, d_model)\n",
    "        self.norm1 = nn.LayerNorm(d_model)\n",
    "        \n",
    "#recommended output lol, idk how correct it is tho, let's do it manually, their scGPT class is massive for the transformer model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformerBasic(nn.Module):\n",
    "    def __init__(self, d_model = 1024, dpout = .1, num_embeddings = 251, device = 'cpu'):\n",
    "        super().__init__()\n",
    "        self.d_model = d_model\n",
    "        self.dpout = dpout\n",
    "        self.num_embeddings = num_embeddings\n",
    "        self.cont_encoder = ContinuousValueEncoder(d_model = d_model, dropout = dpout)\n",
    "        self.cat_encoder = CategoryValueEncoder(num_embeddings = num_embeddings, embedding_dim = d_model)\n",
    "        self.cat_labels = torch.arange(num_embeddings)\n",
    "    \n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        encoded_cont = self.cont_encoder(x)\n",
    "        encoded_cat = self.cat_encoder(self.cat_labels).unsqueeze(0) #the unsqueeze is to add a batch dimension\n",
    "        final_embedding = encoded_cont[:] + encoded_cat\n",
    "        return final_embedding"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 1024])\n",
      "torch.Size([10, 251, 1024])\n"
     ]
    },
    {
     "ename": "RuntimeError",
     "evalue": "The size of tensor a (10) must match the size of tensor b (251) at non-singleton dimension 1",
     "output_type": "error",
     "traceback": [
      "\u001b[0;31m---------------------------------------------------------------------------\u001b[0m",
      "\u001b[0;31mRuntimeError\u001b[0m                              Traceback (most recent call last)",
      "\u001b[1;32m/home/sat4017/PRIME/test_pipeline5.ipynb Cell 13\u001b[0m line \u001b[0;36m8\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2B7b22686f73744e616d65223a224b72756d7369656b2e6c6162227d/home/sat4017/PRIME/test_pipeline5.ipynb#X16sdnNjb2RlLXJlbW90ZQ%3D%3D?line=4'>5</a>\u001b[0m \u001b[39mprint\u001b[39m(b\u001b[39m.\u001b[39mshape)\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2B7b22686f73744e616d65223a224b72756d7369656b2e6c6162227d/home/sat4017/PRIME/test_pipeline5.ipynb#X16sdnNjb2RlLXJlbW90ZQ%3D%3D?line=6'>7</a>\u001b[0m \u001b[39m#now how do we add them together?\u001b[39;00m\n\u001b[0;32m----> <a href='vscode-notebook-cell://ssh-remote%2B7b22686f73744e616d65223a224b72756d7369656b2e6c6162227d/home/sat4017/PRIME/test_pipeline5.ipynb#X16sdnNjb2RlLXJlbW90ZQ%3D%3D?line=7'>8</a>\u001b[0m c \u001b[39m=\u001b[39m a \u001b[39m+\u001b[39;49m b\n\u001b[1;32m      <a href='vscode-notebook-cell://ssh-remote%2B7b22686f73744e616d65223a224b72756d7369656b2e6c6162227d/home/sat4017/PRIME/test_pipeline5.ipynb#X16sdnNjb2RlLXJlbW90ZQ%3D%3D?line=8'>9</a>\u001b[0m \u001b[39mprint\u001b[39m(c\u001b[39m.\u001b[39mshape)\n",
      "\u001b[0;31mRuntimeError\u001b[0m: The size of tensor a (10) must match the size of tensor b (251) at non-singleton dimension 1"
     ]
    }
   ],
   "source": [
    "#test tensor addition\n",
    "a = torch.zeros((10,1024))\n",
    "b = torch.zeros((10,251,1024))\n",
    "print(a.shape)\n",
    "print(b.shape)\n",
    "\n",
    "#now how do we add them together?\n",
    "c = a + b\n",
    "print(c.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([10, 1, 1024])\n",
      "torch.Size([10, 251, 1024])\n"
     ]
    }
   ],
   "source": [
    "a2 = a.unsqueeze(1)\n",
    "print(a2.shape)\n",
    "\n",
    "c = a2 + b\n",
    "print(c.shape)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "torch.Size([1, 10, 1024])"
      ]
     },
     "execution_count": 28,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "a.unsqueeze(0).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "metadata": {},
   "outputs": [],
   "source": [
    "class TransformerBasic(nn.Module):\n",
    "    def __init__(self, d_model = 1024, dpout = .1, num_embeddings = 251, device = 'cpu'):\n",
    "        super().__init__()\n",
    "        self.d_model = d_model\n",
    "        self.dpout = dpout\n",
    "        self.num_embeddings = num_embeddings\n",
    "        self.cont_encoder = ContinuousValueEncoder(d_model = d_model, dropout = dpout)\n",
    "        self.cat_encoder = CategoryValueEncoder(num_embeddings = num_embeddings, embedding_dim = d_model)\n",
    "        self.cat_labels = torch.arange(num_embeddings)\n",
    "    \n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        encoded_cont = self.cont_encoder(x)\n",
    "        encoded_cat = self.cat_encoder(self.cat_labels).unsqueeze(0) #the unsqueeze is to add a batch dimension\n",
    "        final_embedding = encoded_cont + encoded_cat\n",
    "        return final_embedding\n",
    "    \n",
    "transformer = TransformerBasic()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([2, 251])\n",
      "torch.Size([2, 251, 1024])\n"
     ]
    }
   ],
   "source": [
    "print(x.shape)\n",
    "y = transformer(x)\n",
    "print(y.shape)\n",
    "#this part itself seems to work, but now we'd need to pretrain our model which is definitely a lot\n",
    "#this will train it via backprop"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "# encoding scheme is done, but now wtf do I do?\n",
    "# PL and figuring out the distribution of age/BMI/sex"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 1,
   "metadata": {},
   "outputs": [
    {
     "name": "stderr",
     "output_type": "stream",
     "text": [
      "Seed set to 42\n"
     ]
    }
   ],
   "source": [
    "import numpy as np\n",
    "import matplotlib.pyplot as plt\n",
    "import pandas as pd\n",
    "import seaborn as sns\n",
    "import os\n",
    "import torch\n",
    "import torch.nn as nn\n",
    "import pytorch_lightning as pl\n",
    "from pytorch_lightning import seed_everything\n",
    "from torch import Tensor\n",
    "\n",
    "seed_everything(42)\n",
    "\n",
    "\n",
    "from utils import *\n",
    "from sklearn.metrics import mean_squared_error\n",
    "# from transformers import GPT2Model, GPT2Tokenizer\n",
    "\n",
    "dataloader = LoadData(impute='KNN',load = True)\n",
    "cv = CV(dataloader)\n",
    "# here's the stolen class\n",
    "\n",
    "class ContinuousValueEncoder(nn.Module):\n",
    "    \"\"\"\n",
    "    Encode real number values to a vector using neural nets projection.\n",
    "    \"\"\"\n",
    "\n",
    "    def __init__(self, d_model: int = 1024, dropout: float = 0.1, max_value: int = 512):\n",
    "        super().__init__()\n",
    "        self.dropout = nn.Dropout(p=dropout)\n",
    "        self.linear1 = nn.Linear(1, d_model)\n",
    "        self.activation = nn.ReLU()\n",
    "        self.linear2 = nn.Linear(d_model, d_model)\n",
    "        self.norm = nn.LayerNorm(d_model)\n",
    "        self.max_value = max_value\n",
    "\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        \"\"\"\n",
    "        Args:\n",
    "            x: Tensor, shape [batch_size, seq_len]\n",
    "        \"\"\"\n",
    "        # TODO: test using actual embedding layer if input is categorical\n",
    "        # expand last dimension\n",
    "        x = x.unsqueeze(-1)\n",
    "        # clip x to [-inf, max_value]\n",
    "        #x = torch.clamp(x, max=self.max_value) # Ignored for now, doesn't really make sense\n",
    "        x = self.activation(self.linear1(x))\n",
    "        x = self.linear2(x)\n",
    "        x = self.norm(x)\n",
    "        return self.dropout(x)\n",
    "    \n",
    "class CategoryValueEncoder(nn.Module):\n",
    "    def __init__(\n",
    "        self,\n",
    "        num_embeddings: int,\n",
    "        embedding_dim: int,\n",
    "        padding_idx: int = None,\n",
    "    ):\n",
    "        super().__init__()\n",
    "        self.embedding = nn.Embedding(\n",
    "            num_embeddings, embedding_dim, padding_idx=padding_idx\n",
    "        )\n",
    "        self.enc_norm = nn.LayerNorm(embedding_dim)\n",
    "\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        x = x.long()\n",
    "        x = self.embedding(x)  # (batch, seq_len, embsize)\n",
    "        x = self.enc_norm(x)\n",
    "        return x\n",
    "    \n",
    "#num embeddings means input the metabolite index which is 0 to 251\n",
    "\n",
    "class TransformerBasic(nn.Module):\n",
    "    def __init__(self, d_model = 1024, dpout = .1, num_embeddings = 251, device = 'cpu'):\n",
    "        super().__init__()\n",
    "        self.d_model = d_model\n",
    "        self.dpout = dpout\n",
    "        self.num_embeddings = num_embeddings\n",
    "        self.cont_encoder = ContinuousValueEncoder(d_model = d_model, dropout = dpout)\n",
    "        self.cat_encoder = CategoryValueEncoder(num_embeddings = num_embeddings, embedding_dim = d_model)\n",
    "        self.cat_labels = torch.arange(num_embeddings)\n",
    "    \n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        encoded_cont = self.cont_encoder(x)\n",
    "        encoded_cat = self.cat_encoder(self.cat_labels).unsqueeze(0) #the unsqueeze is to add a batch dimension\n",
    "        final_embedding = encoded_cont + encoded_cat\n",
    "        return final_embedding\n",
    "    \n",
    "transformer = TransformerBasic()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "class TransformerBasicLightning(pl.LightningModule):\n",
    "    def __init__(self, d_model=1024, dpout=0.1, num_embeddings=251, device='cpu'):\n",
    "        super().__init__()\n",
    "        self.d_model = d_model\n",
    "        self.dpout = dpout\n",
    "        self.num_embeddings = num_embeddings\n",
    "        self.cont_encoder = ContinuousValueEncoder(d_model=d_model, dropout=dpout)\n",
    "        self.cat_encoder = CategoryValueEncoder(num_embeddings=num_embeddings, embedding_dim=d_model)\n",
    "        self.cat_labels = torch.arange(num_embeddings)\n",
    "\n",
    "    def forward(self, x: Tensor) -> Tensor:\n",
    "        encoded_cont = self.cont_encoder(x)\n",
    "        encoded_cat = self.cat_encoder(self.cat_labels).unsqueeze(0)  # the unsqueeze is to add a batch dimension\n",
    "        final_embedding = encoded_cont + encoded_cat\n",
    "        return final_embedding\n",
    "\n",
    "    def training_step(self, batch, batch_idx):\n",
    "        # Extract data from batch and perform a forward pass\n",
    "        # Then calculate the loss and return it\n",
    "        x, y = batch\n",
    "        y_hat = self(x)\n",
    "        loss = some_loss_function(y_hat, y)  # replace with your actual loss function\n",
    "        return loss\n",
    "\n",
    "    def configure_optimizers(self):\n",
    "        optimizer = torch.optim.Adam(self.parameters(), lr=1e-3)\n",
    "        return optimizer\n",
    "\n",
    "    # Define validation_step and test_step if needed\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "(25818,) (25818,) (25818,)\n",
      "[1. 0. 1.]\n"
     ]
    }
   ],
   "source": [
    "#very quickly bmi/sex/age plots\n",
    "\n",
    "bmi = cv.demographic_vec('bmi')\n",
    "age = cv.demographic_vec('age')\n",
    "sex = cv.demographic_vec('sex')\n",
    "print(bmi.shape,age.shape,sex.shape)\n",
    "print(sex[0:3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([13708.,     0.,     0.,     0.,     0.,     0.,     0.,     0.,\n",
       "            0., 12110.]),\n",
       " array([0. , 0.1, 0.2, 0.3, 0.4, 0.5, 0.6, 0.7, 0.8, 0.9, 1. ]),\n",
       " <BarContainer object of 10 artists>)"
      ]
     },
     "execution_count": 6,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#now let's do a violin plot for sex using seaborn\n",
    "\n",
    "plt.hist(sex)\n",
    "#see it's quite similar"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#now do a violin plot of bmi based on sex\n",
    "data = pd.DataFrame({'Sex': sex, 'BMI': bmi})\n",
    "\n",
    "# Create a violin plot\n",
    "sns.violinplot(x='Sex', y='BMI', data=data)\n",
    "\n",
    "# Display the plot\n",
    "plt.title(\"Violin Plot of BMI Stratified by Sex\")\n",
    "plt.xlabel(\"Sex\")\n",
    "plt.ylabel(\"BMI\")\n",
    "plt.show()\n",
    "#you can see they're quite similar, and are pretty good, now let's do a histogram stratified by sex as well\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 14,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    },
    {
     "data": {
      "image/png": "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",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#now the histogram\n",
    "male_bmi = bmi[sex==0]\n",
    "female_bmi = bmi[sex==1]\n",
    "\n",
    "plt.hist(male_bmi, color='blue', alpha=0.7, label='Male', bins=100)\n",
    "plt.hist(female_bmi, color='red', alpha=0.7, label='Female', bins=100)\n",
    "plt.show()\n",
    "\n",
    "plt.hist(bmi, bins = 100)\n",
    "plt.show()\n",
    "\n",
    "#bmi whether by sex or not is veyr lognormal!"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 17,
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "(array([ 290.,  555.,  524.,  588.,  636.,  635.,  607.,  645.,  613.,\n",
       "         647.,  686.,  761.,  754.,  756.,  772.,  797.,  892.,  856.,\n",
       "         934.,  981., 1224., 1390., 1349., 1193., 1154., 1211., 1136.,\n",
       "        1048., 1000., 1184.]),\n",
       " array([39.        , 40.03333333, 41.06666667, 42.1       , 43.13333333,\n",
       "        44.16666667, 45.2       , 46.23333333, 47.26666667, 48.3       ,\n",
       "        49.33333333, 50.36666667, 51.4       , 52.43333333, 53.46666667,\n",
       "        54.5       , 55.53333333, 56.56666667, 57.6       , 58.63333333,\n",
       "        59.66666667, 60.7       , 61.73333333, 62.76666667, 63.8       ,\n",
       "        64.83333333, 65.86666667, 66.9       , 67.93333333, 68.96666667,\n",
       "        70.        ]),\n",
       " <BarContainer object of 30 artists>)"
      ]
     },
     "execution_count": 17,
     "metadata": {},
     "output_type": "execute_result"
    },
    {
     "data": {
      "image/png": "iVBORw0KGgoAAAANSUhEUgAAAjEAAAGdCAYAAADjWSL8AAAAOXRFWHRTb2Z0d2FyZQBNYXRwbG90bGliIHZlcnNpb24zLjguMCwgaHR0cHM6Ly9tYXRwbG90bGliLm9yZy81sbWrAAAACXBIWXMAAA9hAAAPYQGoP6dpAAAnS0lEQVR4nO3df1BV953/8dctP26UgRvBcK+3xUg6NDWBJi52iSRbyYIYV0I7zgZTU2qm1pjRaFgxKuN2YzIbUHejbsPURscJRrT0n+imm1TFTUrqECPBslXXNWaDipEbsllygYReKJzvH1nPNxcURC+5fOD5mDkzuZ/zPsfP+cyn5TWfe+45DsuyLAEAABjma+HuAAAAwPUgxAAAACMRYgAAgJEIMQAAwEiEGAAAYCRCDAAAMBIhBgAAGIkQAwAAjBQZ7g4Ml97eXl26dEmxsbFyOBzh7g4AALgGlmWpvb1dXq9XX/vawGstozbEXLp0SUlJSeHuBgAAuA5NTU36xje+MWDNqA0xsbGxkr4YhLi4uDD3BgAAXIu2tjYlJSXZf8cHMmpDzOWvkOLi4ggxAAAY5lpuBeHGXgAAYCRCDAAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkQgxAADASEMOMW+99ZYefPBBeb1eORwO7d+//6q1S5YskcPh0NatW4PaA4GAli9frokTJyomJkb5+fm6ePFiUE1ra6sKCwvlcrnkcrlUWFioTz/9dKjdBQAAo9SQQ8xnn32mu+66S+Xl5QPW7d+/X++88468Xm+/fUVFRdq3b5+qqqp05MgRdXR0KC8vTz09PXbNggUL1NDQoAMHDujAgQNqaGhQYWHhULsLAABGqSG/dmDOnDmaM2fOgDUffvihnnjiCR08eFBz584N2uf3+7Vz507t3r1bOTk5kqTKykolJSXp8OHDmj17tk6fPq0DBw7o6NGjysjIkCTt2LFDM2bM0JkzZ3T77bcPtdsAAGCUCfk9Mb29vSosLNRTTz2lO++8s9/++vp6dXd3Kzc3127zer1KTU1VbW2tJOntt9+Wy+WyA4wk3XPPPXK5XHZNX4FAQG1tbUEbAAAYvUIeYjZu3KjIyEitWLHiivt9Pp+io6M1YcKEoHa32y2fz2fXJCYm9js2MTHRrumrrKzMvn/G5XIpKSnpBq8EAACMZCENMfX19fqXf/kXVVRUXNPbJ7/MsqygY650fN+aLyspKZHf77e3pqamoXUeAAAYZcj3xAzk97//vVpaWjR58mS7raenR8XFxdq6davOnTsnj8ejrq4utba2Bq3GtLS0KDMzU5Lk8Xj00Ucf9Tv/xx9/LLfbfcV/2+l0yul0hvJyAGDMm7L2tes+9tyGuYMXATcgpCsxhYWF+uMf/6iGhgZ783q9euqpp3Tw4EFJUnp6uqKiolRdXW0f19zcrJMnT9ohZsaMGfL7/Tp27Jhd884778jv99s1AABgbBvySkxHR4fef/99+3NjY6MaGhoUHx+vyZMnKyEhIag+KipKHo/H/kWRy+XSokWLVFxcrISEBMXHx2vVqlVKS0uzf600depUPfDAA1q8eLFefPFFSdJjjz2mvLw8fpkEAAAkXUeIeffdd3X//ffbn1euXClJWrhwoSoqKq7pHFu2bFFkZKQKCgrU2dmp7OxsVVRUKCIiwq7Zs2ePVqxYYf+KKT8/f9Bn0wAAgLHDYVmWFe5ODIe2tja5XC75/X7FxcWFuzsAYCTuicFXbSh/v3l3EgAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkUL62gEAAC7j59kYbqzEAAAAIxFiAACAkQgxAADASIQYAABgJEIMAAAwEiEGAAAYiRADAACMRIgBAABGIsQAAAAjEWIAAICRCDEAAMBIhBgAAGAkQgwAADASIQYAABiJEAMAAIxEiAEAAEYixAAAACMRYgAAgJEIMQAAwEiEGAAAYCRCDAAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkQgxAADASIQYAABgJEIMAAAwEiEGAAAYKTLcHQAADK8pa18LdxeAYcFKDAAAMNKQQ8xbb72lBx98UF6vVw6HQ/v377f3dXd3a82aNUpLS1NMTIy8Xq9+/OMf69KlS0HnCAQCWr58uSZOnKiYmBjl5+fr4sWLQTWtra0qLCyUy+WSy+VSYWGhPv300+u6SAAAMPoMOcR89tlnuuuuu1ReXt5v3+eff67jx4/rZz/7mY4fP65XXnlF7733nvLz84PqioqKtG/fPlVVVenIkSPq6OhQXl6eenp67JoFCxaooaFBBw4c0IEDB9TQ0KDCwsLruEQAADAaOSzLsq77YIdD+/bt0w9+8IOr1tTV1ekv//Ivdf78eU2ePFl+v1+33HKLdu/erfnz50uSLl26pKSkJL3++uuaPXu2Tp8+rTvuuENHjx5VRkaGJOno0aOaMWOG/uu//ku33377oH1ra2uTy+WS3+9XXFzc9V4iABjPxHtizm2YG7Z/+0bGK5z9Hi2G8vd72O+J8fv9cjgcuvnmmyVJ9fX16u7uVm5url3j9XqVmpqq2tpaSdLbb78tl8tlBxhJuueee+RyueyavgKBgNra2oI2AAAweg1riPnTn/6ktWvXasGCBXaa8vl8io6O1oQJE4Jq3W63fD6fXZOYmNjvfImJiXZNX2VlZfb9My6XS0lJSSG+GgAAMJIMW4jp7u7Www8/rN7eXv3iF78YtN6yLDkcDvvzl//7ajVfVlJSIr/fb29NTU3X33kAADDiDctzYrq7u1VQUKDGxka98cYbQd9peTwedXV1qbW1NWg1pqWlRZmZmXbNRx991O+8H3/8sdxu9xX/TafTKafTGeIrAQCEA/el4FqEfCXmcoA5e/asDh8+rISEhKD96enpioqKUnV1td3W3NyskydP2iFmxowZ8vv9OnbsmF3zzjvvyO/32zUAAGBsG/JKTEdHh95//337c2NjoxoaGhQfHy+v16u//du/1fHjx/Vv//Zv6unpse9hiY+PV3R0tFwulxYtWqTi4mIlJCQoPj5eq1atUlpamnJyciRJU6dO1QMPPKDFixfrxRdflCQ99thjysvLu6ZfJgEAgGtj8qrXkEPMu+++q/vvv9/+vHLlSknSwoULtX79er366quSpLvvvjvouDfffFNZWVmSpC1btigyMlIFBQXq7OxUdna2KioqFBERYdfv2bNHK1assH/FlJ+ff8Vn0wAAgLFpyCEmKytLAz1a5loeO3PTTTfphRde0AsvvHDVmvj4eFVWVg61ewAAYIzg3UkAAMBIhBgAAGAkQgwAADASIQYAABiJEAMAAIw0LE/sBQAgXEx8azeuDysxAADASIQYAABgJEIMAAAwEiEGAAAYiRt7AQAIEZNfpmgiVmIAAICRCDEAAMBIhBgAAGAkQgwAADASIQYAABiJEAMAAIxEiAEAAEYixAAAACMRYgAAgJEIMQAAwEiEGAAAYCRCDAAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkQgxAADASIQYAABgJEIMAAAwEiEGAAAYKTLcHQAAANKUta9d97HnNswNYU/MwUoMAAAwEiEGAAAYiRADAACMRIgBAABGIsQAAAAjEWIAAICRCDEAAMBIQw4xb731lh588EF5vV45HA7t378/aL9lWVq/fr28Xq/GjRunrKwsnTp1KqgmEAho+fLlmjhxomJiYpSfn6+LFy8G1bS2tqqwsFAul0sul0uFhYX69NNPh3yBAABgdBpyiPnss8901113qby8/Ir7N23apM2bN6u8vFx1dXXyeDyaNWuW2tvb7ZqioiLt27dPVVVVOnLkiDo6OpSXl6eenh67ZsGCBWpoaNCBAwd04MABNTQ0qLCw8DouEQAAjEZDfmLvnDlzNGfOnCvusyxLW7du1bp16zRv3jxJ0q5du+R2u7V3714tWbJEfr9fO3fu1O7du5WTkyNJqqysVFJSkg4fPqzZs2fr9OnTOnDggI4ePaqMjAxJ0o4dOzRjxgydOXNGt99++/VeLwAAGCVCek9MY2OjfD6fcnNz7Tan06mZM2eqtrZWklRfX6/u7u6gGq/Xq9TUVLvm7bfflsvlsgOMJN1zzz1yuVx2TV+BQEBtbW1BGwAAGL1C+u4kn88nSXK73UHtbrdb58+ft2uio6M1YcKEfjWXj/f5fEpMTOx3/sTERLumr7KyMj3zzDM3fA0AAJjmRt67ZLJh+XWSw+EI+mxZVr+2vvrWXKl+oPOUlJTI7/fbW1NT03X0HAAAmCKkIcbj8UhSv9WSlpYWe3XG4/Goq6tLra2tA9Z89NFH/c7/8ccf91vluczpdCouLi5oAwAAo1dIQ0xycrI8Ho+qq6vttq6uLtXU1CgzM1OSlJ6erqioqKCa5uZmnTx50q6ZMWOG/H6/jh07Zte888478vv9dg0AABjbhnxPTEdHh95//337c2NjoxoaGhQfH6/JkyerqKhIpaWlSklJUUpKikpLSzV+/HgtWLBAkuRyubRo0SIVFxcrISFB8fHxWrVqldLS0uxfK02dOlUPPPCAFi9erBdffFGS9NhjjykvL49fJgEAAEnXEWLeffdd3X///fbnlStXSpIWLlyoiooKrV69Wp2dnVq6dKlaW1uVkZGhQ4cOKTY21j5my5YtioyMVEFBgTo7O5Wdna2KigpFRETYNXv27NGKFSvsXzHl5+df9dk0ADDajdUbN4GBOCzLssLdieHQ1tYml8slv9/P/TEAjEeIwUh0bsPckJ9zKH+/eXcSAAAwEiEGAAAYiRADAACMRIgBAABGIsQAAAAjEWIAAICRCDEAAMBIhBgAAGAkQgwAADASIQYAABhpyO9OAgBcH14dAIQWKzEAAMBIhBgAAGAkQgwAADASIQYAABiJEAMAAIxEiAEAAEYixAAAACMRYgAAgJEIMQAAwEg8sRfAmHMjT849t2FuCHsC4EawEgMAAIxEiAEAAEYixAAAACMRYgAAgJEIMQAAwEiEGAAAYCRCDAAAMBIhBgAAGIkQAwAAjMQTewFgCG7kab8AQouVGAAAYCRCDAAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkQgxAADASIQYAABgpJCHmD//+c/6+7//eyUnJ2vcuHG67bbb9Oyzz6q3t9eusSxL69evl9fr1bhx45SVlaVTp04FnScQCGj58uWaOHGiYmJilJ+fr4sXL4a6uwAAwFAhDzEbN27UL3/5S5WXl+v06dPatGmT/umf/kkvvPCCXbNp0yZt3rxZ5eXlqqurk8fj0axZs9Te3m7XFBUVad++faqqqtKRI0fU0dGhvLw89fT0hLrLAADAQCF/d9Lbb7+t73//+5o7d64kacqUKfrVr36ld999V9IXqzBbt27VunXrNG/ePEnSrl275Ha7tXfvXi1ZskR+v187d+7U7t27lZOTI0mqrKxUUlKSDh8+rNmzZ4e62wAAwDAhX4m577779O///u967733JEn/8R//oSNHjuhv/uZvJEmNjY3y+XzKzc21j3E6nZo5c6Zqa2slSfX19eru7g6q8Xq9Sk1NtWv6CgQCamtrC9oAAMDoFfKVmDVr1sjv9+vb3/62IiIi1NPTo+eee04//OEPJUk+n0+S5Ha7g45zu906f/68XRMdHa0JEyb0q7l8fF9lZWV65plnQn05AEYo3iYNIOQrMb/+9a9VWVmpvXv36vjx49q1a5f++Z//Wbt27QqqczgcQZ8ty+rX1tdANSUlJfL7/fbW1NR0YxcCAABGtJCvxDz11FNau3atHn74YUlSWlqazp8/r7KyMi1cuFAej0fSF6stkyZNso9raWmxV2c8Ho+6urrU2toatBrT0tKizMzMK/67TqdTTqcz1JcDAABGqJCvxHz++ef62teCTxsREWH/xDo5OVkej0fV1dX2/q6uLtXU1NgBJT09XVFRUUE1zc3NOnny5FVDDAAAGFtCvhLz4IMP6rnnntPkyZN155136g9/+IM2b96sn/zkJ5K++BqpqKhIpaWlSklJUUpKikpLSzV+/HgtWLBAkuRyubRo0SIVFxcrISFB8fHxWrVqldLS0uxfKwEAgLEt5CHmhRde0M9+9jMtXbpULS0t8nq9WrJkif7hH/7Brlm9erU6Ozu1dOlStba2KiMjQ4cOHVJsbKxds2XLFkVGRqqgoECdnZ3Kzs5WRUWFIiIiQt1lAABgIIdlWVa4OzEc2tra5HK55Pf7FRcXF+7uAAgxfp0EhN+5DXNDfs6h/P0O+UoMAFwrggiAG8ELIAEAgJEIMQAAwEh8nQSMEjfy1cxwfK8NAMONEAOAe1MAGImvkwAAgJEIMQAAwEiEGAAAYCRCDAAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkQgxAADASIQYAABgJEIMAAAwEiEGAAAYiRADAACMRIgBAABGIsQAAAAjEWIAAICRIsPdAQD/35S1r4W7CwBgDFZiAACAkQgxAADASIQYAABgJEIMAAAwEiEGAAAYiRADAACMRIgBAABGIsQAAAAj8bA7IMR4YB0AfDUIMRi1biRMnNswN4Q9AQAMB75OAgAARmIlBtckXF+RsCICALgaVmIAAICRCDEAAMBIhBgAAGAkQgwAADDSsISYDz/8UD/60Y+UkJCg8ePH6+6771Z9fb2937IsrV+/Xl6vV+PGjVNWVpZOnToVdI5AIKDly5dr4sSJiomJUX5+vi5evDgc3QUAAAYK+a+TWltbde+99+r+++/Xb3/7WyUmJuq///u/dfPNN9s1mzZt0ubNm1VRUaFvfetb+sd//EfNmjVLZ86cUWxsrCSpqKhIv/nNb1RVVaWEhAQVFxcrLy9P9fX1ioiICHW3gSA8sA4ARr6Qh5iNGzcqKSlJL730kt02ZcoU+78ty9LWrVu1bt06zZs3T5K0a9cuud1u7d27V0uWLJHf79fOnTu1e/du5eTkSJIqKyuVlJSkw4cPa/bs2aHuNgAAMEzIQ8yrr76q2bNn66GHHlJNTY2+/vWva+nSpVq8eLEkqbGxUT6fT7m5ufYxTqdTM2fOVG1trZYsWaL6+np1d3cH1Xi9XqWmpqq2tvaKISYQCCgQCNif29raQn1pCANWRAAAVxPye2I++OADbdu2TSkpKTp48KAef/xxrVixQi+//LIkyefzSZLcbnfQcW63297n8/kUHR2tCRMmXLWmr7KyMrlcLntLSkoK9aUBAIARJOQhpre3V3/xF3+h0tJSTZs2TUuWLNHixYu1bdu2oDqHwxH02bKsfm19DVRTUlIiv99vb01NTTd2IQAAYEQLeYiZNGmS7rjjjqC2qVOn6sKFC5Ikj8cjSf1WVFpaWuzVGY/Ho66uLrW2tl61pi+n06m4uLigDQAAjF4hvyfm3nvv1ZkzZ4La3nvvPd16662SpOTkZHk8HlVXV2vatGmSpK6uLtXU1Gjjxo2SpPT0dEVFRam6uloFBQWSpObmZp08eVKbNm0KdZfHDO4vAQCMJiEPMX/3d3+nzMxMlZaWqqCgQMeOHdP27du1fft2SV98jVRUVKTS0lKlpKQoJSVFpaWlGj9+vBYsWCBJcrlcWrRokYqLi5WQkKD4+HitWrVKaWlp9q+VAADA2BbyEPPd735X+/btU0lJiZ599lklJydr69ateuSRR+ya1atXq7OzU0uXLlVra6syMjJ06NAh+xkxkrRlyxZFRkaqoKBAnZ2dys7OVkVFBc+IAQAAkiSHZVlWuDsxHNra2uRyueT3+7k/5v/wdRIAIJTObZgb8nMO5e83704CAABGIsQAAAAjEWIAAICRCDEAAMBIhBgAAGCkkP/EGoO7kV8JDced4AAAmIiVGAAAYCRCDAAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkXhOjGF4EzUAAF9gJQYAABiJEAMAAIxEiAEAAEYixAAAACMRYgAAgJEIMQAAwEiEGAAAYCRCDAAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkQgxAADASIQYAABgJEIMAAAwEiEGAAAYiRADAACMRIgBAABGIsQAAAAjEWIAAICRCDEAAMBIhBgAAGAkQgwAADASIQYAABiJEAMAAIw07CGmrKxMDodDRUVFdptlWVq/fr28Xq/GjRunrKwsnTp1Kui4QCCg5cuXa+LEiYqJiVF+fr4uXrw43N0FAACGGNYQU1dXp+3bt+s73/lOUPumTZu0efNmlZeXq66uTh6PR7NmzVJ7e7tdU1RUpH379qmqqkpHjhxRR0eH8vLy1NPTM5xdBgAAhhi2ENPR0aFHHnlEO3bs0IQJE+x2y7K0detWrVu3TvPmzVNqaqp27dqlzz//XHv37pUk+f1+7dy5U88//7xycnI0bdo0VVZW6sSJEzp8+PBwdRkAABhk2ELMsmXLNHfuXOXk5AS1NzY2yufzKTc3125zOp2aOXOmamtrJUn19fXq7u4OqvF6vUpNTbVr+goEAmprawvaAADA6BU5HCetqqrS8ePHVVdX12+fz+eTJLnd7qB2t9ut8+fP2zXR0dFBKziXay4f31dZWZmeeeaZUHQfAAAYIOQrMU1NTXryySdVWVmpm2666ap1Docj6LNlWf3a+hqopqSkRH6/396ampqG3nkAAGCMkIeY+vp6tbS0KD09XZGRkYqMjFRNTY1+/vOfKzIy0l6B6bui0tLSYu/zeDzq6upSa2vrVWv6cjqdiouLC9oAAMDoFfIQk52drRMnTqihocHepk+frkceeUQNDQ267bbb5PF4VF1dbR/T1dWlmpoaZWZmSpLS09MVFRUVVNPc3KyTJ0/aNQAAYGwL+T0xsbGxSk1NDWqLiYlRQkKC3V5UVKTS0lKlpKQoJSVFpaWlGj9+vBYsWCBJcrlcWrRokYqLi5WQkKD4+HitWrVKaWlp/W4UBgAAY9Ow3Ng7mNWrV6uzs1NLly5Va2urMjIydOjQIcXGxto1W7ZsUWRkpAoKCtTZ2ans7GxVVFQoIiIiHF0GAAAjjMOyLCvcnRgObW1tcrlc8vv9I+7+mClrXwt3FwAAuGHnNswN+TmH8vebdycBAAAjEWIAAICRCDEAAMBIhBgAAGAkQgwAADASIQYAABiJEAMAAIxEiAEAAEYixAAAACMRYgAAgJEIMQAAwEiEGAAAYCRCDAAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkQgxAADASIQYAABgJEIMAAAwUmS4O2CqKWtfC3cXAAAY01iJAQAARiLEAAAAIxFiAACAkQgxAADASIQYAABgJEIMAAAwEiEGAAAYiRADAACMRIgBAABGIsQAAAAjEWIAAICRCDEAAMBIhBgAAGAkQgwAADASIQYAABiJEAMAAIxEiAEAAEYKeYgpKyvTd7/7XcXGxioxMVE/+MEPdObMmaAay7K0fv16eb1ejRs3TllZWTp16lRQTSAQ0PLlyzVx4kTFxMQoPz9fFy9eDHV3AQCAoUIeYmpqarRs2TIdPXpU1dXV+vOf/6zc3Fx99tlnds2mTZu0efNmlZeXq66uTh6PR7NmzVJ7e7tdU1RUpH379qmqqkpHjhxRR0eH8vLy1NPTE+ouAwAAAzksy7KG8x/4+OOPlZiYqJqaGn3ve9+TZVnyer0qKirSmjVrJH2x6uJ2u7Vx40YtWbJEfr9ft9xyi3bv3q358+dLki5duqSkpCS9/vrrmj179qD/bltbm1wul/x+v+Li4kJ+XVPWvhbycwIAYJJzG+aG/JxD+fs97PfE+P1+SVJ8fLwkqbGxUT6fT7m5uXaN0+nUzJkzVVtbK0mqr69Xd3d3UI3X61VqaqpdAwAAxrbI4Ty5ZVlauXKl7rvvPqWmpkqSfD6fJMntdgfVut1unT9/3q6Jjo7WhAkT+tVcPr6vQCCgQCBgf25rawvZdQAAgJFnWFdinnjiCf3xj3/Ur371q377HA5H0GfLsvq19TVQTVlZmVwul70lJSVdf8cBAMCIN2whZvny5Xr11Vf15ptv6hvf+Ibd7vF4JKnfikpLS4u9OuPxeNTV1aXW1tar1vRVUlIiv99vb01NTaG8HAAAMMKEPMRYlqUnnnhCr7zyit544w0lJycH7U9OTpbH41F1dbXd1tXVpZqaGmVmZkqS0tPTFRUVFVTT3NyskydP2jV9OZ1OxcXFBW0AAGD0Cvk9McuWLdPevXv1r//6r4qNjbVXXFwul8aNGyeHw6GioiKVlpYqJSVFKSkpKi0t1fjx47VgwQK7dtGiRSouLlZCQoLi4+O1atUqpaWlKScnJ9RdBgAABgp5iNm2bZskKSsrK6j9pZde0qOPPipJWr16tTo7O7V06VK1trYqIyNDhw4dUmxsrF2/ZcsWRUZGqqCgQJ2dncrOzlZFRYUiIiJC3WUAAGCgYX9OTLjwnBgAAIbXqH9ODAAAwHAgxAAAACMRYgAAgJEIMQAAwEiEGAAAYCRCDAAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkQgxAADASIQYAABgJEIMAAAwEiEGAAAYiRADAACMRIgBAABGIsQAAAAjEWIAAICRCDEAAMBIhBgAAGAkQgwAADASIQYAABiJEAMAAIxEiAEAAEYixAAAACMRYgAAgJEIMQAAwEiEGAAAYCRCDAAAMBIhBgAAGIkQAwAAjESIAQAARiLEAAAAIxFiAACAkQgxAADASIQYAABgJEIMAAAwEiEGAAAYiRADAACMNOJDzC9+8QslJyfrpptuUnp6un7/+9+Hu0sAAGAEGNEh5te//rWKioq0bt06/eEPf9Bf/dVfac6cObpw4UK4uwYAAMJsRIeYzZs3a9GiRfrpT3+qqVOnauvWrUpKStK2bdvC3TUAABBmkeHuwNV0dXWpvr5ea9euDWrPzc1VbW1tv/pAIKBAIGB/9vv9kqS2trZh6V9v4PNhOS8AAKYYjr+xl89pWdagtSM2xPzP//yPenp65Ha7g9rdbrd8Pl+/+rKyMj3zzDP92pOSkoatjwAAjGWurcN37vb2drlcrgFrRmyIuczhcAR9tiyrX5sklZSUaOXKlfbn3t5e/e///q8SEhKuWB8ObW1tSkpKUlNTk+Li4sLdnRGJMRocYzQwxmdwjNHgGKPBDdcYWZal9vZ2eb3eQWtHbIiZOHGiIiIi+q26tLS09FudkSSn0ymn0xnUdvPNNw9nF69bXFwc/6MYBGM0OMZoYIzP4BijwTFGgxuOMRpsBeayEXtjb3R0tNLT01VdXR3UXl1drczMzDD1CgAAjBQjdiVGklauXKnCwkJNnz5dM2bM0Pbt23XhwgU9/vjj4e4aAAAIsxEdYubPn69PPvlEzz77rJqbm5WamqrXX39dt956a7i7dl2cTqeefvrpfl974f9jjAbHGA2M8RkcYzQ4xmhwI2GMHNa1/IYJAABghBmx98QAAAAMhBADAACMRIgBAABGIsQAAAAjEWKGWVlZmRwOh4qKiuw2y7K0fv16eb1ejRs3TllZWTp16lT4OhlmVxqjRx99VA6HI2i75557wtfJr9j69ev7Xb/H47H3M4cGH6OxPock6cMPP9SPfvQjJSQkaPz48br77rtVX19v72ceDT5GY30eTZkypd/1OxwOLVu2TFL45xAhZhjV1dVp+/bt+s53vhPUvmnTJm3evFnl5eWqq6uTx+PRrFmz1N7eHqaehs/VxkiSHnjgATU3N9vb66+/HoYehs+dd94ZdP0nTpyw9zGHvjDQGEljew61trbq3nvvVVRUlH7729/qP//zP/X8888HPcl8rM+jaxkjaWzPo7q6uqBrv/wA2oceekjSCJhDFoZFe3u7lZKSYlVXV1szZ860nnzyScuyLKu3t9fyeDzWhg0b7No//elPlsvlsn75y1+GqbfhcbUxsizLWrhwofX9738/bH0Lt6efftq66667rriPOfSFgcbIsphDa9asse67776r7mceDT5GlsU86uvJJ5+0vvnNb1q9vb0jYg6xEjNMli1bprlz5yonJyeovbGxUT6fT7m5uXab0+nUzJkzVVtb+1V3M6yuNkaX/e53v1NiYqK+9a1vafHixWppafmKexheZ8+eldfrVXJysh5++GF98MEHkphDX3a1MbpsLM+hV199VdOnT9dDDz2kxMRETZs2TTt27LD3M48GH6PLxvI8+rKuri5VVlbqJz/5iRwOx4iYQ4SYYVBVVaXjx4+rrKys377LL7Ts+xJLt9vd72WXo9lAYyRJc+bM0Z49e/TGG2/o+eefV11dnf76r/9agUDgK+5peGRkZOjll1/WwYMHtWPHDvl8PmVmZuqTTz5hDv2fgcZIYg598MEH2rZtm1JSUnTw4EE9/vjjWrFihV5++WVJ/H+RNPgYScyjL9u/f78+/fRTPfroo5JGxhwa0a8dMFFTU5OefPJJHTp0SDfddNNV6xwOR9Bny7L6tY1W1zJG8+fPt/87NTVV06dP16233qrXXntN8+bN+6q6GjZz5syx/zstLU0zZszQN7/5Te3atcu+qXAszyFp4DFauXLlmJ9Dvb29mj59ukpLSyVJ06ZN06lTp7Rt2zb9+Mc/tuvG8jy6ljEa6/Poy3bu3Kk5c+bI6/UGtYdzDrESE2L19fVqaWlRenq6IiMjFRkZqZqaGv385z9XZGSknVj7ptSWlpZ+aXa0GmyMenp6+h0zadIk3XrrrTp79mwYehx+MTExSktL09mzZ+1f4IzlOXQlXx6jKxlrc2jSpEm64447gtqmTp2qCxcuSBLzSIOP0dWOGUvz6LLz58/r8OHD+ulPf2q3jYQ5RIgJsezsbJ04cUINDQ32Nn36dD3yyCNqaGjQbbfdJo/HY9/hLX3xPWNNTY0yMzPD2POvzmBjFBER0e+YTz75RE1NTZo0aVIYehx+gUBAp0+f1qRJk5ScnDzm59CVfHmMrmSszaF7771XZ86cCWp777337BfoMo8GH6MrGWvz6LKXXnpJiYmJmjt3rt02IubQV3L78BjX95c3GzZssFwul/XKK69YJ06csH74wx9akyZNstra2sLXyTD78hi1t7dbxcXFVm1trdXY2Gi9+eab1owZM6yvf/3rY2aMiouLrd/97nfWBx98YB09etTKy8uzYmNjrXPnzlmWxRyyrIHHiDlkWceOHbMiIyOt5557zjp79qy1Z88ea/z48VZlZaVdM9bn0WBjxDz6Qk9PjzV58mRrzZo1/faFew4RYr4CfUNMb2+v9fTTT1sej8dyOp3W9773PevEiRPh6+AI8OUx+vzzz63c3FzrlltusaKioqzJkydbCxcutC5cuBDeTn6F5s+fb02aNMmKioqyvF6vNW/ePOvUqVP2fubQwGPEHPrCb37zGys1NdVyOp3Wt7/9bWv79u1B+5lHA48R8+gLBw8etCRZZ86c6bcv3HPIYVmW9dWs+QAAAIQO98QAAAAjEWIAAICRCDEAAMBIhBgAAGAkQgwAADASIQYAABiJEAMAAIxEiAEAAEYixAAAACMRYgAAgJEIMQAAwEiEGAAAYKT/B8dzHRnSGMcLAAAAAElFTkSuQmCC",
      "text/plain": [
       "<Figure size 640x480 with 1 Axes>"
      ]
     },
     "metadata": {},
     "output_type": "display_data"
    }
   ],
   "source": [
    "#now do for age\n",
    "plt.hist(age, bins = 30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 24,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "3.302698849019496 0.16570285818267133\n"
     ]
    }
   ],
   "source": [
    "#now let's find the parameters of the lognormal distribution BMI vector\n",
    "from scipy.stats import norm\n",
    "log_bmi = np.log(bmi[np.isnan(bmi)==False])\n",
    "\n",
    "mu, sigma = norm.fit(log_bmi)\n",
    "print(mu,sigma)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 23,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "134\n",
      "0\n",
      "0\n"
     ]
    }
   ],
   "source": [
    "#find how many nan in BMI\n",
    "print(np.sum(np.isnan(bmi))) #just some nans for BMI...?\n",
    "#now for age and sex\n",
    "print(np.sum(np.isnan(age)))\n",
    "print(np.sum(np.isnan(sex)))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 26,
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "0.5309474010380355\n"
     ]
    }
   ],
   "source": [
    "num0 = np.sum(sex ==0)\n",
    "num1 = np.sum(sex==1)\n",
    "print(num0/(num1+num0))"
   ]
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "prot_torch",
   "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.11.6"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}