test.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import networkx as nx\n",
    "import torch\n",
    "import matplotlib.pyplot as plt\n",
    "import numpy as np\n",
    "from sklearn import decomposition\n",
    "import pulp"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g =nx.erdos_renyi_graph(n=40,p=0.05)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Gcc = sorted(nx.connected_component_subgraphs(g), key=len, reverse=True)\n",
    "G0 = Gcc[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.min_edge_cover(G0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=nx.maximal_independent_set(G0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#nx.draw(G0,nodelist=a,node_color='b')\n",
    "color_map = []\n",
    "for node in G0:\n",
    "    if node in a:\n",
    "        color_map.append('blue')\n",
    "    else: color_map.append('green') \n",
    "nx.draw(G0,node_color=color_map)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.subgraph(G1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sys\n",
    "import graph\n",
    "import environment\n",
    "import runner\n",
    "import agent"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g=graph.Graph(\"erdos_renyi\",50,0.10)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from keras.models import Sequential, Model\n",
    "from keras.layers import Dense, Flatten, Input, Add, Dot, Concatenate, ReLU, Permute\n",
    "from keras.activations import relu\n",
    "from keras.optimizers import sgd\n",
    "import keras.backend as K\n",
    "import numpy as np"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodes=50\n",
    "p=32\n",
    "T=4\n",
    "xv = Input(shape=(nodes,))\n",
    "mu_init = Input(shape=(nodes,p))\n",
    "adj = Input(shape=(nodes, nodes))\n",
    "\n",
    "for t in range(T):\n",
    "    if t==0:\n",
    "        mu_1 = Dense(p, input_dim=nodes)(xv)\n",
    "        mu_2 = Dense(p, input_dim=p)(Dot(axes=1)([p, mu_init]))\n",
    "        mu = ReLU()(Add()([mu_1, mu_2]))\n",
    "    else:\n",
    "        mu_1 = Dense(p, input_dim=nodes)(xv)\n",
    "        mu_2 = Dense(p, input_dim=p)(Dot(axes=1)([adj, mu]))\n",
    "        mu = ReLU()(Add()([mu_1, mu_2]))\n",
    "\n",
    "q_1=Dense(p, input_dim=p)(Dot(axes=1)([adj,mu]))\n",
    "q_2=Dense(p,input_dim=p)(mu)\n",
    "q=ReLU()(Concatenate()([q_1,q_2]))\n",
    "\n",
    "model = Model(inputs=[xv, mu_init, adj], outputs=q)\n",
    "model.compile(optimizer='rmsprop',\n",
    "        loss='mse')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xv_=np.random.randn(1,nodes,1)\n",
    "mu_init_=np.zeros((1,nodes,p))\n",
    "adj_ = g.adj().todense() \n",
    "adj_ = np.expand_dims(adj_,axis=0)\n",
    "qp=np.random.randn(1,nodes,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "adj_.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(x=[xv_,mu_init,adj],y=qp,epochs=10,steps_per_epoch=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodes=50\n",
    "p=32\n",
    "T=3\n",
    "xv = Input(batch_shape=(1,nodes,1))\n",
    "mu_init = Input(batch_shape=(1,nodes,p))\n",
    "adj = Input(batch_shape=(1,nodes,nodes))\n",
    "\n",
    "for t in range(T):\n",
    "    if t==0:\n",
    "        mu_1 = Dense(p)(xv)\n",
    "        mu_2 = Dense(p)(Dot(axes=1)([adj,mu_init]))\n",
    "        mu = ReLU()(Add()([mu_1, mu_2]))\n",
    "    else:\n",
    "        mu_1 = Dense(p)(xv)\n",
    "        mu_2 = Dense(p)(Dot(axes=1)([adj,mu]))\n",
    "        mu = ReLU()(Add()([mu_1, mu_2]))\n",
    "\n",
    "q_1=Dense(p)(Dot(axes=1)([adj,mu]))\n",
    "q_2=Dense(p)(mu)\n",
    "q_=Concatenate(axis=2)([q_1,q_2])\n",
    "q=Dense(1,activation=\"relu\")(q_)\n",
    "\n",
    "model = Model(inputs=[xv, mu_init, adj], outputs=q)\n",
    "model.compile(optimizer='rmsprop',\n",
    "        loss='mse')\n",
    "model.fit(epochs=1,steps_per_epoch=2,validation_steps=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_2.name"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.fit(x=[xv_,mu_init,adj],y=qp)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "Concatenate(axis=2)([q_1,q_2]).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=Dot(axes=1)([adj,mu_init])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "############ torch"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nodes=50\n",
    "p=32\n",
    "T=3\n",
    "xv = Input(batch_shape=(1,nodes,1))\n",
    "mu_init = Input(batch_shape=(1,nodes,p))\n",
    "adj = Input(batch_shape=(1,nodes,nodes))\n",
    "\n",
    "for t in range(T):\n",
    "    if t==0:\n",
    "        mu_1 = Dense(p)(xv)\n",
    "        mu_2 = Dense(p)(Dot(axes=1)([adj,mu_init]))\n",
    "        mu = ReLU()(Add()([mu_1, mu_2]))\n",
    "    else:\n",
    "        mu_1 = Dense(p)(xv)\n",
    "        mu_2 = Dense(p)(Dot(axes=1)([adj,mu]))\n",
    "        mu = ReLU()(Add()([mu_1, mu_2]))\n",
    "\n",
    "q_1=Dense(p)(Dot(axes=1)([adj,mu]))\n",
    "q_2=Dense(p)(mu)\n",
    "q_=Concatenate(axis=2)([q_1,q_2])\n",
    "q=Dense(1,activation=\"relu\")(q_)\n",
    "\n",
    "model = Model(inputs=[xv, mu_init, adj], outputs=q)\n",
    "model.comp²ile(optimizer='rmsprop',\n",
    "        loss='mse')\n",
    "model.fit(epochs=1,steps_per_epoch=2,validation_steps=2)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "batch_size=8\n",
    "T=4\n",
    "xv=torch.randn(batch_size,nodes,1)\n",
    "mu_init=torch.randn(batch_size,nodes,p)\n",
    "adj=torch.randn(batch_size,nodes,nodes)\n",
    "y=torch.randn(batch_size,nodes,1)\n",
    "\n",
    "class S2V_QN(torch.nn.Module):\n",
    "    def __init__(self,p,nodes):\n",
    "        \n",
    "        super(S2V_QN,self).__init__()\n",
    "        self.mu_1=torch.nn.Linear(1,p)\n",
    "        self.mu_2=torch.nn.Linear(p,p)\n",
    "        self.q_1=torch.nn.Linear(p,p)\n",
    "        self.q_2=torch.nn.Linear(p,p)\n",
    "        self.q=torch.nn.Linear(2*p,1)\n",
    "    \n",
    "    def forward(self,xv,adj,mu_init,T):\n",
    "\n",
    "        for t in range(T):\n",
    "            if t==0:\n",
    "                mu_1=self.mu_1(xv)\n",
    "                mu_2=self.mu_2(torch.matmul(adj,mu_init))\n",
    "                mu=torch.add(mu_1,mu_2).clamp(0)\n",
    "            \n",
    "            else:\n",
    "                mu_1=self.mu_1(xv)\n",
    "                mu_2=self.mu_2(torch.matmul(adj,mu))\n",
    "                mu=torch.add(mu_1,mu_2).clamp(0)\n",
    "                \n",
    "\n",
    "        q_1=self.q_1(torch.matmul(adj,mu))\n",
    "        q_2=self.q_2(mu)\n",
    "        q_=torch.cat((q_1,q_2),dim=2)\n",
    "        q=self.q(q_)\n",
    "        return q\n",
    "model=S2V_QN(32,50)\n",
    "\n",
    "criterion=torch.nn.MSELoss(reduction='sum')\n",
    "optimizer=torch.optim.SGD(model.parameters(),lr=1e-10,momentum=0.9)\n",
    "for t in range(67):\n",
    "    y_pred = model(xv,adj,mu_init,T)\n",
    "    loss = criterion(y_pred, y)\n",
    "    print(t, loss.item())\n",
    "\n",
    "    # Zero gradients, perform a backward pass, and update the weights.\n",
    "    optimizer.zero_grad()\n",
    "    loss.backward()\n",
    "    optimizer.step()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.cat((q_1,q_2),dim=1).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_2.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xv=torch.randn(8,nodes,1)\n",
    "mu_init=torch.randn(1,nodes,p)\n",
    "#mu_init=np.random.randn(8,nodes,p)\n",
    "adj=torch.randn(1,nodes,nodes)\n",
    "mu1=torch.nn.Linear(1,p)(xv)\n",
    "mu2=torch.nn.Linear(p,p)(torch.matmul(adj,mu_init))\n",
    "mu_=torch.add(mu1,mu2).clamp(0)\n",
    "\n",
    "mu1=torch.nn.Linear(1,p)(xv)\n",
    "mu2=torch.nn.Linear(p,p)(torch.matmul(adj,mu_))\n",
    "mu_=torch.add(mu1,mu2).clamp(0)\n",
    "\n",
    "q_1=torch.nn.Linear(p,p)(torch.matmul(adj,mu_))\n",
    "q_2=torch.nn.Linear(p,p)(mu_)\n",
    "q_=torch.cat((q_1,q_2),dim=-1)\n",
    "q=torch.nn.Linear(2*p,1)(q_)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q[2,0]"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "##### q_1.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.matmul(adj,mu_).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.from_numpy(np.expand_dims(g.adj().todense().astype(int),axis=0))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=np.zeros(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=3\n",
    "c=4\n",
    "d=np.zeros(4)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=torch.zeros(8,1)\n",
    "a[1]=1\n",
    "np.sum(a.numpy())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "memory.append((a,b,c,d))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "memory"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import random\n",
    "minibatch = random.sample(memory, 8 - 1)\n",
    "minibatch.append(memory[-1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for a,b,c,d in minibatch:\n",
    "    print(a)\n",
    "    print(b)\n",
    "    print(c)\n",
    "    print(d)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation=torch.zeros(6,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation[1]=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation[observation==0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=observation.numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.random.choice(np.where(a==0)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=[1,2,3,4]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(1,4):\n",
    "    print(i)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "observation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#observation=observation.numpy()\n",
    "q=torch.randn(6,1).detach().numpy()\n",
    "np.where((q==np.max(q[observation==0])))[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "q[observation==0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "g=nx.gnp_random_graph(n=50,p=0.1)\n",
    "nx.draw(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=torch.zeros(1,16,1)\n",
    "b=torch.ones(1,1)\n",
    "list_=[]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list\n",
    "list_.append((a,b,b,a))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.array(list_[0][1])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list_"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=torch.empty(1,16,1)\n",
    "b=list_[0][1]\n",
    "for t,i in enumerate(list_):\n",
    "    \n",
    "    c=torch.cat((c,i[0]),dim=0)\n",
    "    b=torch.cat((b,i[1]),dim=0)\n",
    "c.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.empty(16,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.max(c,dim=1)[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d=torch.ones(6,3,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs=torch.ones(6,3,1)\n",
    "obs[1][2]=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "obs[0][1]=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "sel=obs*(-1e5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "d+sel"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "r=torch.cat((torch.tensor([[1.]]),torch.tensor([[3.]])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g=torch.ones(2,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g+r"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=torch.randn(3,5,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l[range(3),torch.tensor([0,1,2]),:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll=[38.0, 35.0, 37.0, 38.0, 37.0, 35.0, 38.0, 38.0, 38.0, 38.0, 38.0, 38.0, 37.0, 38.0, 38.0, 38.0, 38.0, 35.0, 38.0, 36.0, 34.0, 34.0, 37.0, 38.0, 35.0, 34.0, 38.0, 35.0, 38.0, 34.0, 38.0, 38.0, 35.0, 36.0, 38.0, 38.0, 38.0, 35.0, 38.0, 38.0, 38.0, 35.0, 38.0, 38.0, 33.0, 38.0, 38.0, 33.0, 32.0, 33.0, 28.0, 29.0, 32.0, 29.0, 29.0, 30.0, 29.0, 30.0, 31.0, 29.0, 29.0, 31.0, 30.0, 25.0, 30.0, 28.0, 30.0, 26.0, 27.0, 25.0, 26.0, 27.0, 26.0, 26.0, 26.0, 23.0, 23.0, 20.0, 20.0, 20.0, 21.0, 20.0, 20.0, 20.0, 20.0, 20.0, 21.0, 20.0, 20.0, 20.0, 20.0, 21.0, 21.0, 20.0, 20.0, 21.0, 20.0, 20.0, 20.0, 20.0, 20.0, 21.0, 21.0, 21.0, 20.0, 21.0, 20.0, 21.0, 21.0, 21.0, 20.0, 20.0, 20.0, 20.0, 20.0, 20.0, 20.0, 22.0, 20.0, 21.0, 21.0, 20.0, 20.0, 21.0, 21.0, 20.0, 21.0, 20.0, 21.0, 20.0, 20.0, 20.0, 20.0, 21.0, 20.0, 20.0, 21.0, 20.0, 20.0, 20.0, 20.0, 25.0, 27.0, 20.0, 25.0, 27.0, 25.0, 25.0, 25.0, 25.0]\n",
    "ll_w2V=[39.0, 38.0, 38.0, 34.0, 33.0, 34.0, 33.0, 31.0, 32.0, 35.0, 34.0, 34.0, 37.0, 38.0, 37.0, 38.0, 37.0, 36.0, 36.0, 35.0, 35.0, 33.0, 34.0, 34.0, 33.0, 34.0, 33.0, 33.0, 33.0, 32.0, 33.0, 34.0, 33.0, 33.0, 32.0, 32.0, 32.0, 32.0, 31.0, 31.0, 32.0, 31.0, 32.0, 31.0, 31.0, 30.0, 33.0, 31.0, 30.0, 31.0, 29.0, 27.0, 28.0, 28.0, 26.0, 30.0, 28.0, 30.0, 29.0, 26.0, 28.0, 26.0, 26.0, 26.0, 29.0, 26.0, 27.0, 26.0, 28.0, 28.0, 26.0, 27.0, 26.0, 26.0, 27.0, 26.0, 26.0, 26.0, 28.0, 27.0, 28.0, 26.0, 27.0, 26.0, 27.0, 27.0, 29.0, 24.0, 26.0, 26.0, 26.0, 27.0, 28.0, 26.0, 29.0, 28.0, 26.0, 27.0, 26.0, 27.0, 27.0, 26.0, 28.0, 27.0, 27.0, 27.0, 27.0, 26.0, 27.0, 26.0, 28.0, 26.0, 26.0, 26.0, 27.0, 27.0, 28.0, 27.0, 26.0, 28.0, 28.0, 26.0, 26.0, 27.0, 28.0, 26.0, 26.0, 27.0, 26.0, 26.0, 26.0, 26.0, 27.0, 26.0, 26.0, 26.0, 27.0, 27.0, 26.0, 26.0, 26.0, 26.0, 26.0, 26.0, 27.0, 26.0, 25.0, 23.0, 27.0, 23.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(ll)\n",
    "plt.plot(ll_w2V)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from gensim.models import Word2Vec\n",
    "import random\n",
    "from sklearn import decomposition"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "num_paths=400\n",
    "path_length=40\n",
    "seed=12\n",
    "embed_size=32\n",
    "window_size=5"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "G = nx.gnp_random_graph(n=60,p=0.1,seed=seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.neighbors(G,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "def random_walk(G,path_length, alpha=0, rand=random.Random(), start=None):    \n",
    "    \n",
    "    if start:\n",
    "        path = [start]\n",
    "    else:\n",
    "        # Sampling is uniform w.r.t V, and not w.r.t E\n",
    "        path = [rand.choice(list(G.nodes()))]\n",
    "\n",
    "    while len(path) < path_length:\n",
    "        cur = path[-1]\n",
    "        if len(G[cur]) > 0:\n",
    "            if rand.random() >= alpha:\n",
    "                path.append(rand.choice(list(nx.neighbors(G,cur))))\n",
    "            else:\n",
    "                path.append(path[0])\n",
    "        else:\n",
    "            break\n",
    "    return [str(node) for node in path]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "\n",
    "\n",
    "def build_deepwalk_corpus(G, num_paths, path_length, alpha=0,rand=random.Random(0)):\n",
    "    walks = []\n",
    "\n",
    "    nodes = list(G.nodes())\n",
    "\n",
    "    for cnt in range(num_paths):\n",
    "        rand.shuffle(nodes)\n",
    "        for node in nodes:\n",
    "            \n",
    "            walks.append(random_walk(G,path_length, rand=rand, alpha=alpha, start=node))\n",
    "\n",
    "    return walks"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Walking...\")\n",
    "walks = build_deepwalk_corpus(g, num_paths=num_paths,\n",
    "                                    path_length=path_length, alpha=0,\n",
    "                                    rand=random.Random(seed))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "vertex_counts=dict(G.degree())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"Training...\")\n",
    "model = Word2Vec(walks,size=embed_size, window=window_size\n",
    "                 , min_count=0, sg=1, hs=1,iter=1, negative=0,compute_loss=True)\n",
    "#model.build_vocab(walks)\n",
    "model.get_latest_training_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "  # prepare the model vocabulary\n",
    "for i in range(10):\n",
    "    print(model.train(walks,epochs=1,total_examples=model.corpus_count,compute_loss=True))\n",
    "    print(model.get_latest_training_loss())\n",
    "#model.get_latest_training_loss()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=model[list(model.wv.vocab)]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "words = map(int,list(model.wv.vocab))\n",
    "deg=list(words)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "s=[i[1] for i in list(g.degree(deg))]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "deg_n=list(nx.average_neighbor_degree(g,list(words)).values())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=[deg_n[i] for i in deg]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pca = decomposition.PCA(n_components=2)\n",
    "\n",
    "result = pca.fit_transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "u=torch.from_numpy(np.expand_dims(X,axis=0))\n",
    "u.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "plt.scatter(result[:, 0], result[:, 1],s=[i**3 for i in s],c=c)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=model_skip[model_skip.wv.vocab]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pca = decomposition.PCA(n_components=2)\n",
    "\n",
    "result = pca.fit_transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "plt.scatter(result[:, 0], result[:, 1])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g = nx.erdos_renyi_graph(n=50, p=0.07, seed=seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.draw(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g[9]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.adjacency_matrix(g).todense()[9].sum()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l=[29.0, 34.0, 36.0, 37.0, 36.0, 37.0, 37.0, 37.0, 37.0, 38.0, 38.0, 38.0, 36.0, 36.0, 36.0, 36.0, 36.0, 36.0, 34.0, 32.0, 32.0, 33.0, 34.0, 31.0, 33.0, 34.0, 35.0, 33.0, 34.0, 33.0, 32.0, 33.0, 32.0, 32.0, 34.0, 33.0, 34.0, 34.0, 33.0, 33.0, 34.0, 35.0, 32.0, 32.0, 32.0, 32.0, 32.0, 29.0, 26.0, 29.0, 26.0, 27.0, 27.0, 27.0, 28.0, 29.0, 26.0, 26.0, 26.0, 27.0, 26.0, 26.0, 26.0, 26.0, 27.0, 27.0, 27.0, 27.0, 26.0, 27.0, 26.0, 27.0, 28.0, 26.0, 27.0, 28.0, 26.0, 26.0, 28.0, 27.0, 26.0, 26.0, 26.0, 26.0, 26.0, 27.0, 29.0, 28.0, 26.0, 27.0, 28.0, 26.0, 26.0, 26.0, 28.0, 27.0, 27.0, 26.0, 26.0, 26.0, 27.0, 26.0, 26.0, 26.0, 27.0, 26.0, 27.0, 27.0, 26.0, 27.0, 27.0, 27.0, 26.0, 26.0, 28.0, 27.0, 26.0, 27.0, 29.0, 26.0, 25.0, 28.0, 26.0, 26.0, 26.0, 27.0, 26.0, 26.0, 26.0, 27.0, 26.0, 29.0, 26.0, 26.0, 26.0, 27.0, 26.0, 26.0, 26.0, 26.0, 26.0, 26.0, 26.0, 26.0, 28.0, 24.0, 27.0, 27.0, 27.0, 26.0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(l)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed=12\n",
    "g = nx.erdos_renyi_graph(n=20, p=0.12, seed=seed)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.draw(g)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "l_s2V_r2_5=np.array([352.7248308566741, 381.4600192460666, 359.16362679862493, 379.32293933471976, 382.0555117252666, 371.90396643360657, 372.2236827682573, 382.54333954643226, 382.8811235204283, 371.7552965261283, 382.5739060503756, 363.04020965227267, 334.49284137227954, 349.49612348996345, 349.3759900083172, 302.5438685951179, 299.10087579562725, 298.12188394805366, 298.8610531161149, 268.95167046977565, 248.7651847687759, 218.53560985224448, 254.12744710081546, 238.485269022608, 258.4538372912206, 228.25281361569608, 278.44659636803146, 238.37170459313967, 248.37180712218958, 238.4436019939844, 268.65285042378645, 228.28463179751427, 248.39736240883116, 238.407704558087, 238.3811019939844, 258.3424297013648, 265.8468524720644, 238.30930712218958, 258.49543313184495, 238.4221180585299, 238.34520455808703, 248.34060721889446, 228.3327049200439, 248.30930712218958, 238.30930712218955, 238.31525950314196, 228.28463179751427, 238.38399169687418, 238.42509586243483, 228.2702049200439, 238.41253547596142, 268.52843759027746, 238.35642666930914, 228.2702049200439, 258.4441881736324, 218.5004366920713, 218.2388623495709, 236.4864889208065, 258.27020492004397, 238.27020492004394, 228.27020492004394, 228.27020492004394, 228.27020492004394, 248.44323203912364, 248.34060721889452, 228.33040862730647, 228.31784824083303, 228.33040862730647, 228.27020492004394, 238.40477066877378, 238.33040862730647, 228.33040862730647, 228.31784824083303, 238.43068032757816, 246.62703839885597, 218.3193089718132, 248.4106091285596, 228.43068032757816, 238.27020492004394, 244.38545076621955, 218.40560382701034, 228.43068032757816, 238.4770981254665, 228.43068032757816, 248.43068032757816, 238.43068032757816, 238.4713207216668, 228.43068032757816, 228.43068032757816, 228.46407979847763, 248.61876479213313, 218.47727651891117, 238.48147397837178, 228.43068032757816, 238.66190700320135, 228.49318032757816, 228.43068032757816, 228.43068032757816, 228.43068032757816, 238.43068032757816, 228.2702049200439, 228.5072943878364, 228.43068032757816, 234.38393561470443, 244.45026558103436, 234.4027209566748, 254.49935560806557, 234.4145512953201, 228.4624985093963, 234.38467872465802, 228.6058805564111, 228.4624985093963, 234.44636947713826, 228.5249985093963, 228.4624985093963, 244.44636947713826, 228.3020231018621, 234.44636947713826, 244.36800900949925, 275.8696957278203, 234.44636947713826, 224.4929656684713, 244.4145512953201, 244.3576889413989, 226.58496179490308, 234.4145512953201, 244.4463694771383, 234.4463694771383, 244.2540758877859, 244.2540758877859, 244.2540758877859, 244.23668458343803, 234.23668458343803, 234.23668458343803, 243.61151915746612, 244.57125001800347, 234.23668458343803, 244.5123867931555, 234.35768894139892, 244.3460977768666, 244.4463694771383, 234.28589406960407, 234.28589406960404, 244.49499548880772, 254.25623085425866, 248.28026766042515, 244.26850276525622, 234.4463694771383, 229.72275480917918, 244.4463694771383])\n",
    "l_s2V_r2_3=np.array([352.2369222144628, 350.6401166585577, 346.2104014704054, 371.99494741859894, 413.61294275927287, 413.18138220518574, 390.1724826727588, 413.66523004636196, 382.59400031948627, 413.45441832223577, 413.8572899023649, 349.2909984038013, 349.34199780481174, 379.1065720245539, 379.40946001205947, 378.5823800530794, 370.40887151081586, 338.4484430395388, 299.83629928679875, 299.8685054059614, 330.06960885798014, 309.79989486995953, 299.87175215920814, 309.9541843469035, 299.8321009891222, 309.8321009891222, 309.66034649519275, 296.57809541294165, 309.71256425793683, 299.66034649519275, 309.88645804156107, 299.62503478596796, 299.5693380672278, 350.066807737532, 330.06960885798014, 350.026049103894, 356.7610484702926, 336.8138843579532, 386.80720041885684, 319.6868101482868, 299.6690045038507, 330.0439678323391, 299.6690045038507, 299.6690045038507, 330.2106344990058, 300.6225692318057, 340.2106344990058, 330.2106344990058, 340.0439678323391, 340.05587259424385, 330.06960885798014, 350.04396783233915, 352.4933227734436, 299.68823527308155, 359.93158125495887, 299.6690045038507, 309.9738832872545, 349.83573984147046, 350.2106344990058, 330.1080703964417, 299.6690045038507, 359.93158125495887, 309.7382476600504, 290.01091856138595, 340.0612770221547, 319.9495502152872, 349.93158125495887, 349.90755528093297, 299.64236160521295, 279.8622450356227, 339.8975241084018, 319.7060415408877, 300.0333294795013, 339.9396260956444, 289.8357892789038, 299.6826399827036, 339.9122299907547, 330.08151361988484, 309.3955206976995, 319.96663522722514, 299.87435120287597, 315.84754304371484, 290.0438189899908, 289.81014825326275, 289.9604856566575, 299.8487101772349, 299.9539957697328, 308.321133765757, 339.91577437665205, 299.8487101772349, 299.874351202876, 339.8231817840595, 299.93529026381503, 329.8625870411118, 299.9576845362093, 329.81127702215474, 329.8231817840595, 299.8487101772349, 299.75710964813436, 329.8231817840595, 320.0439678323391, 289.616042473459, 289.87435120287597, 309.9396260956444, 280.1271523233242, 299.95433197799736, 319.9304441839689, 289.93204351056823, 279.7986701486261, 279.67671094442164, 300.0477139855418, 270.0140987102706, 279.93204351056823, 289.893263661782, 299.89461035548806, 289.93204351056823, 319.8030098263875, 289.89461035548806, 270.11666281283465, 259.68734619267303, 279.9096055182773, 289.93204351056823, 299.84262775085193, 266.18376785295897, 280.1166628128347, 299.89461035548806, 256.5341256950589, 259.7051318928116, 270.0695202755386, 350.17871653419144, 299.7921677599946, 300.16248093806456, 300.058673714692, 303.126575645069, 242.27322070367444, 259.8384618471337, 249.6977094906524, 359.8088206017635, 280.058673714692, 282.3334976312655, 261.97995961781476, 292.34536030025413, 251.11876532455588, 259.8126999988654, 279.89461035548806, 269.8030098263875, 267.39252098808305, 278.8351058596758, 252.22585862542854, 369.6867967922397])\n",
    "l_w2v_r2_5=np.array([322.07988831830943, 369.023374822059, 355.51186206580945, 375.9079924072029, 380.67072398361876, 363.2350370487213, 368.9572476256686, 369.18933186696347, 379.15878240667706, 379.46243192480034, 359.2500409629357, 369.31481287718134, 299.311601059759, 287.57931832300255, 290.40524224313697, 270.27900125215916, 259.9675005306584, 259.7617570051781, 249.98594261489004, 249.88676182491974, 249.91451404346142, 239.86338812259868, 239.86338812259868, 239.86338812259868, 239.7085873677979, 249.86338812259868, 249.86338812259868, 249.80896330764753, 249.87193513114568, 249.75862621783676, 239.97291193212249, 250.18920582341636, 249.86338812259868, 239.86338812259868, 239.84910240831294, 239.86338812259868, 239.97291193212249, 259.94910240831297, 249.8750840290314, 249.8133492725598, 239.7776738368844, 239.86338812259868, 260.1832145924251, 239.86338812259868, 239.86338812259868, 239.9014833606939, 239.86338812259868, 240.15230106151162, 239.86338812259868, 239.86338812259868, 249.86338812259868, 229.8919595511701, 239.86338812259868, 239.9414833606939, 240.16452328373379, 250.1245232837338, 240.1245232837338, 240.1245232837338, 240.1245232837338, 258.39317407738463, 249.97688018609074, 239.86096832017887, 239.91100717021772, 249.91100717021774, 240.12452328373382, 270.1364280456386, 240.1245232837338, 237.55309471230524, 250.19717840638899, 260.33126931547986, 240.1523010615116, 250.13621919016654, 240.1523010615116, 270.2413494400336, 260.33682487103545, 240.1245232837338, 250.03440506861563, 240.1245232837338, 240.11261852182903, 240.1245232837338, 239.00150741071795, 250.19288547709604, 240.1245232837338, 250.15209220603953, 260.0192951785057, 250.24465315386368, 250.0864280456386, 240.11499947421, 250.0864280456386, 250.0864280456386, 250.11261852182903, 270.08642804563857, 250.1264280456386, 250.08245979167035, 240.11261852182903, 250.09833280754336, 250.0864280456386, 260.08642804563857, 250.0864280456386, 250.0864280456386, 240.1523010615116, 240.11261852182903, 240.11261852182906, 250.11261852182903, 250.12055502976554, 250.11261852182903, 250.16579312500363, 240.11261852182906, 240.11261852182906, 250.11261852182903, 240.04328230249283, 249.91100717021774, 239.91100717021774, 239.91100717021774, 239.91100717021774, 259.90205612126664, 249.91955417876474, 240.03351799272855, 239.91100717021774, 270.3987296329402, 260.09090135011195, 239.91100717021774, 239.91100717021774, 236.6564617156723, 239.896721455932, 239.91100717021774, 239.90096832017886, 249.86096832017887, 249.90096832017886, 249.91100717021774, 239.86096832017887, 229.88243574164625, 249.75620641541695, 239.86096832017887, 249.86096832017887, 249.86096832017887, 239.77525403446458, 239.86096832017887, 239.86096832017887, 249.946721455932, 259.9195541787647, 239.9538643130748, 239.9004808544282, 239.86096832017887, 239.84668260589314, 249.82071412992462, 239.98347914268965, 239.86338812259868, 239.8133492725598, 239.8133492725598])\n",
    "l_w2v_r2_3=np.array([312.85476197115764, 352.81521735413577, 390.8529351785793, 366.76223923623445, 382.79077250035954, 391.6975651464303, 382.88842447843336, 382.5607212704757, 382.976811463058, 382.50329963693156, 382.9860564152683, 345.7670221026357, 336.530647903299, 326.45720156709575, 296.22485890629014, 306.0257762578888, 285.96259372051276, 276.13911117847647, 268.6797174279243, 225.90648115633567, 225.91789256774706, 236.12777741005843, 235.8771017769563, 236.82141015641153, 235.88498653731713, 235.84932399917852, 235.80867261431206, 235.81027562065645, 235.75938740877683, 255.95982381788266, 235.80867261431206, 235.81306780163197, 235.82316881173298, 225.85668280989483, 245.82316881173298, 245.78678630854012, 245.91187848915234, 245.7724864805453, 235.82316881173298, 245.95740850679795, 235.82316881173298, 245.78983547839965, 235.87296301807612, 225.91789256774706, 255.84779228883255, 225.91789256774706, 248.6582436771336, 235.82316881173298, 249.1830488903704, 245.82316881173298, 236.03443218428671, 245.82316881173298, 245.8493239991785, 235.86981625867935, 235.78983547839965, 245.8493239991785, 235.82316881173298, 235.82316881173298, 245.74168733025152, 225.92589468751387, 235.8108881099786, 225.91789256774706, 225.88455923441373, 225.87314782300234, 245.9915238913784, 225.90648115633567, 225.9505988033945, 238.54853488971307, 235.90648115633567, 225.90648115633567, 245.86686642669073, 235.90840484726795, 245.81904533341597, 235.77842406698826, 246.08079843549166, 237.8735405943022, 235.8117574003216, 235.87314782300234, 225.90648115633567, 245.8117574003216, 225.95648115633566, 235.95871614994994, 235.8117574003216, 235.93088031830598, 245.88013346869766, 256.01355186340635, 225.92870337855788, 238.67047407027295, 225.92870337855786, 227.85112262434293, 245.5629495238424, 257.83306022697013, 237.8861653593857, 227.84537549790616, 227.85112262434293, 227.91133767810638, 227.85112262434293, 227.85112262434293, 227.85112262434293, 237.75639886832886, 247.91969748723832, 227.92301804917955, 237.88968471584622, 237.92301804917955, 237.88968471584622, 237.92301804917957, 237.9896847158462, 227.92301804917955, 227.85112262434293, 257.93022315087114, 247.88815966138, 257.92454869539836, 227.92301804917955, 227.8177892910096, 237.89143188286855, 238.05685643301794, 248.67260109288026, 227.90093105346173, 237.85112262434293, 227.69831497798694, 227.85112262434293, 227.85112262434293, 247.8482946279666, 237.8482946279666, 237.85112262434296, 227.85112262434293, 227.87890040212076, 227.7955670687874, 237.76122789089985, 227.87941331770594, 247.8020186816906, 227.8020186816906, 227.8020186816906, 227.8020186816906, 227.8230713132696, 227.8020186816906, 227.80201868169064, 227.80201868169064, 227.7686853483573, 237.80201868169064, 227.79052442881706, 237.90454393421587, 237.78350016317214, 237.82054688731563, 227.80201868169064, 247.92818266079584, 237.8309210658562, 227.64714538734364, 227.80201868169064, 237.8703947500667])\n",
    "\n",
    "plt.plot(l_s2V_r2_5*-1, label= \"S2V_5\")\n",
    "plt.plot(l_s2V_r2_3*-1, label=\"S2V_3\")\n",
    "plt.plot(l_w2v_r2_5*-1,label=\"W2V_5\")\n",
    "plt.plot(l_w2v_r2_3*-1,label=\"W2V_3\")\n",
    "plt.xlabel(\"epochs\")\n",
    "plt.ylabel(\"cumulative reward\")\n",
    "plt.legend(loc=4)\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll = np.loadtxt('test.out')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(ll)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll[-50000:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(ll)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc=[]\n",
    "for i in range(len(ll[-50000:])):\n",
    "    cc.append(np.mean(ll[-50000+i:-49900+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=[5,6,8,9,10,11]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[-5:]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[-5+1:-4+1]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a[-5+2:-4+2]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.remove(a[:-3])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll_e9= np.loadtxt('test_e9.out')\n",
    "opt_set = np.loadtxt('opt_set_e9.out')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "len(ll_e9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc=[]\n",
    "for i in range(len(ll_e9[-50000:])):\n",
    "    cc.append(np.mean(ll_e9[-50000+i:-49900+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(ll_e9)\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll_e6 = np.loadtxt('test_e6.out')\n",
    "opt_set = np.loadtxt('opt_set_e6.out')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc=[]\n",
    "for i in range(len(ll_e6[-50000:])):\n",
    "    cc.append(np.mean(ll_e6[-50000+i:-49900+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(opt_set)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_2 = torch.nn.Linear(1, 64)\n",
    "#torch.nn.init.normal_(mu_1.weight, mean=0, std=0.01)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_1.weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_2.weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=torch.ones(20,64,1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=torch.sum(a,dim=1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b.reshape(20,1,1).expand(20,64,1).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = torch.zeros(64,20,1)\n",
    "\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c = torch.zeros(64,3,1).type(torch.ByteTensor)\n",
    "c[0,1,0]=1\n",
    "c[0,2,0]=1\n",
    "c[1,1,0]=1\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b = torch.ones(64,3,32)\n",
    "mat = c.reshape(64,3)\n",
    "mat = torch.ones(64,3).type(torch.ByteTensor)-mat\n",
    "res=torch.zeros(64, 3,3)\n",
    "res.as_strided(mat.size(), [res.stride(0), res.size(2) + 1]).copy_(mat)\n",
    "res"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.matmul(torch.ones(64,64,3),res)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c[0,1,0]=1\n",
    "c[0,3,0]=1\n",
    "c[1,2,0]=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "b=torch.ones(20,64,1)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c=c.transpose_(1,2)\n",
    "c=c.transpose_(0,1)\n",
    "b = b.transpose_(0,1)\n",
    "b=b.transpose_(0,2)\n",
    "#print(c)\n",
    "print(c.shape)\n",
    "print(b.shape)\n",
    "torch.matmul(c,b).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.matmul(c,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "# w = torch.nn.Embedding(1,32)\n",
    "# w.weight.data = w.weight.data.normal_(0,\n",
    "#             0.01)\n",
    "w = torch.nn.Parameter(torch.Tensor(1,32))\n",
    "torch.nn.init.normal_(w,0,0.01)\n",
    "f = torch.zeros(64,20,1)\n",
    "f[0,1,0]=1\n",
    "f[0,2,0]=1\n",
    "f[1,2,0]=1\n",
    "mu = torch.nn.Linear(32,1,1)\n",
    "print(w)\n",
    "print(torch.matmul(f,w).shape)\n",
    "print(torch.matmul(f,w)[0,:,:])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu.weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "adj = torch.zeros(1,3,3)\n",
    "adj[0,1,0]=1\n",
    "adj[0,0,1]=1\n",
    "mu = torch.ones(64,3,32)\n",
    "print(torch.matmul(adj,mu).shape)\n",
    "print(torch.matmul(adj,mu))\n",
    "u = torch.matmul(adj,mu)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "mu_ =torch.nn.Linear(32,32)\n",
    "mu_.weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "par = torch.nn.Parameter(torch.Tensor(1,32,32))\n",
    "torch.nn.init.normal_(par,0,0.01)\n",
    "par"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(par[:,0])\n",
    "print(par[:,0].sum())\n",
    "u_ = u.transpose(1,2)\n",
    "print(torch.matmul(par,u_).shape)\n",
    "print(torch.matmul(par,u_))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "np.where(c[0,:,0]==np.max(c[0,:,0]))[0][0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll_e6 = np.loadtxt('test.out')\n",
    "opt_set = np.loadtxt('opt_set.out')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "cc=[]\n",
    "for i in range(len(ll_e6[-50000:])):\n",
    "    cc.append(np.mean(ll_e6[-50000+i:-49900+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)\n",
    "plt.show"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(ll_e6)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "c= torch.ones(64,20,20)\n",
    "b= torch.ones(64,20,20)\n",
    "torch.matmul(c,b).shape"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " ll=np.loadtxt('test_2.out')\n",
    "cc =[]\n",
    "for i in range(len(ll[-7000:])):\n",
    "    cc.append(np.mean(ll[-7000+i:-6900+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    " ll=np.loadtxt('test_8.out')\n",
    "cc =[]\n",
    "for i in range(len(ll[-7000:])):\n",
    "    cc.append(np.mean(ll[-7000+i:-6900+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll=np.loadtxt('test_0.out')\n",
    "cc =[]\n",
    "for i in range(len(ll[-2500:])):\n",
    "    cc.append(np.mean(ll[-2500+i:-2400+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "ll_1=np.loadtxt('test_1.out')\n",
    "ll_2= np.loadtxt('test_2.out')\n",
    "ll_3= np.loadtxt('test_3.out')\n",
    "ll_7=np.loadtxt('test_9.out')\n",
    "#ll_all = np.concatenate([ll,ll_5])\n",
    "print(len(ll_7))\n",
    "cc =[]\n",
    "for i in range(len(ll_7[-24000:])):\n",
    "    cc.append(np.mean(ll_7[-24000+i:-23900+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ll_7=np.loadtxt('test_6.out')\n",
    "#ll_all = np.concatenate([ll,ll_5])\n",
    "ll_7 =np.array(ll_7)/2\n",
    "print(len(ll_7))\n",
    "cc =[]\n",
    "for i in range(len(ll_7[-17000:])):\n",
    "    cc.append(np.mean(ll_7[-17000+i:-16000+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model = np.memmap('model.bin')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import os"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "os.getcwd()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ll_7=np.loadtxt('test_6.out')\n",
    "#ll_all = np.concatenate([ll,ll_5])\n",
    "ll_7 =np.array(ll_7)\n",
    "print(len(ll_7))\n",
    "cc =[]\n",
    "for i in range(len(ll_7[-17000:])):\n",
    "    cc.append(np.mean(ll_7[-17000+i:-16000+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "weight=torch.load('model.pt')\n",
    "weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "X=weight['mu_2.weight'].detach().numpy()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import sklearn.manifold as mnf\n",
    "#pca = decomposition..(n_components=3)\n",
    "tsne=mnf.TSNE(n_components=3)\n",
    "result = tsne.fit_transform(X)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "plt.scatter(result[:, 0], result[:, 1],s=0.5*result[:,2],c=result[:,2])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed=12\n",
    "g = nx.barabasi_albert_graph(n=20, m=4, seed=seed)\n",
    "nx.draw(g,with_labels=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "seed=12\n",
    "from collections import Counter\n",
    "#g = nx.erdos_renyi_graph(n=2000, p=0.14, seed=seed)\n",
    "G = nx.barabasi_albert_graph(n=1000,m=4,seed=seed)\n",
    "degree_sequence = sorted([d for n, d in G.degree()], reverse=True)  # degree sequence\n",
    "degreeCount = Counter(degree_sequence)\n",
    "deg, cnt = zip(*degreeCount.items())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "fig, ax = plt.subplots()\n",
    "plt.loglog(deg, [x/2000 for x in list(cnt)], 'b.')\n",
    "\n",
    "plt.title(\"Degree Distribution\")\n",
    "plt.ylabel(\"P(k)\")\n",
    "plt.xlabel(\"Degree\")\n",
    "#plt.xlim([-10,200])\n",
    "\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.matmul(torch.from_numpy(nx.adj_matrix(g).todense()).type(torch.FloatTensor),weight['mu_1.weight'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pca = decomposition.PCA(n_components=4)\n",
    "\n",
    "result = pca.fit_transform(X)\n",
    "\n",
    "plt.scatter(result[:, 0], result[:, 1],s=3000*result[:,2],c=result[:,3])\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "number_node = 20\n",
    "g = nx.erdos_renyi_graph(n=number_node, p=0.12, seed=121)\n",
    "xv=torch.ones(1,number_nodes,1,dtype=torch.float)\n",
    "xv[1,]\n",
    "minibatch_size = xv.shape[0]\n",
    "nbr_node = xv.shape[1]\n",
    "for t in range(self.T):\n",
    "    if t == 0:\n",
    "        #mu = self.mu_1(xv).clamp(0)\n",
    "        mu = torch.matmul(xv, self.mu_1).clamp(0)\n",
    "        #mu.transpose_(1,2)\n",
    "        #mu_2 = self.mu_2(torch.matmul(adj, mu_init))\n",
    "        #mu = torch.add(mu_1, mu_2).clamp(0)\n",
    "    else:\n",
    "        #mu_1 = self.mu_1(xv)\n",
    "        mu_1 = torch.matmul(xv, self.mu_1).clamp(0)\n",
    "        #mu_1.transpose_(1,2)\n",
    "        # before pooling:\n",
    "        for i in range(self.len_pre_pooling):\n",
    "            mu = self.list_pre_pooling[i](mu).clamp(0)\n",
    "        mu_pool = torch.matmul(adj, mu)\n",
    "        # after pooling\n",
    "        for i in range(self.len_post_pooling):\n",
    "            mu_pool = self.list_post_pooling[i](mu_pool).clamp(0)\n",
    "        mu_2 = self.mu_2(mu_pool)\n",
    "        mu = torch.add(mu_1, mu_2).clamp(0)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ll_7=np.loadtxt('test_6_10_12_2_layer_opt.out')\n",
    "#ll_all = np.concatenate([ll,ll_5])\n",
    "ll_7 =np.array(ll_7)\n",
    "print(len(ll_7))\n",
    "cc =[]\n",
    "for i in range(len(ll_7[-17500:])):\n",
    "    cc.append(np.mean(ll_7[-17500+i:-17100+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ll_7=np.loadtxt('test_1.out')\n",
    "#ll_all = np.concatenate([ll,ll_5])\n",
    "ll_7 =np.array(ll_7)\n",
    "print(len(ll_7))\n",
    "cc =[]\n",
    "for i in range(len(ll_7[-3400:])):a\n",
    "    cc.append(np.mean(ll_7[-3400+i:-3300+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ll_7=np.loadtxt('test_24_10_maxcut_10_5.out')\n",
    "ll_8 = np.loadtxt('test_24_10_mvc_2nd.out')\n",
    "#ll_all = np.concatenate([ll,ll_5])\n",
    "ll_7 =np.array(ll_7)\n",
    "ll_8 =np.array(ll_8)*-1\n",
    "print(len(ll_7))\n",
    "cc =[]\n",
    "cc_1=[]\n",
    "length=62500\n",
    "#ll_8=ll_8[:length]\n",
    "for i in range(len(ll_7[-length:])):\n",
    "    cc.append(np.mean(ll_7[-length+i:-length+300+i]))\n",
    "    cc_1.append(np.mean(ll_8[-length+i:-length+300+i]))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc_1,'r',label=\"new\")\n",
    "#plt.plot(cc,label=\"old\")\n",
    "plt.ylabel('Approximation ratio')\n",
    "plt.xlabel('epochs')\n",
    "plt.grid()\n",
    "#plt.legend()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "12/9"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "import pulp\n",
    "pulp.pulpTestAll()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ll_7=np.loadtxt('test_0.out')\n",
    "ll_8 = np.loadtxt('test_0_test_1_g_GCN_cp.out')\n",
    "ll_7 =np.array(ll_7)\n",
    "ll_8=np.array(ll_8)\n",
    "print(len(ll_7))\n",
    "print(len(ll_8))\n",
    "cc =[]\n",
    "cc_1=[]\n",
    "last =360\n",
    "for i in range(len(ll_7[-last:])):\n",
    "    cc.append(np.mean(ll_7[-last+i:-last+30+i]))\n",
    "    cc_1.append(np.mean(ll_8[-last+i:-last+30+i]))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)\n",
    "plt.plot(cc_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0.99997**(3000*30)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0.999985**(16000*15)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "0.999985**(700*5*8)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "700*5*8"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "a=torch.ones((3,3))\n",
    "a[1,2]=0\n",
    "b=torch.ones((3,3))*2\n",
    "b[0,1]=0"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.matmul(a,b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(a)\n",
    "print(b)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ll_7=np.loadtxt('test_6_10_12_1layer_ed_opti.out')\n",
    "ll_8 = np.loadtxt('test_6_10_12_2_layer_opt.out')\n",
    "ll_7 =np.array(ll_7)\n",
    "ll_8=np.array(ll_8)\n",
    "print(len(ll_7))\n",
    "print(len(ll_8))\n",
    "cc =[]\n",
    "cc_1=[]\n",
    "last =17500\n",
    "for i in range(len(ll_7[-last:])):\n",
    "    cc.append(np.mean(ll_7[-last+i:-last+200+i]))\n",
    "    cc_1.append(np.mean(ll_8[-last+i:-last+200+i]))\n",
    "    "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)#,label=\"2 layers\")\n",
    "#plt.plot(cc_1, label=\"1 layers\")\n",
    "plt.legend()\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('Approximation ratio')"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ll_7=np.loadtxt('test_6_10_10_corr.out')\n",
    "ll_8 = np.loadtxt('test_6_10_12_corr.out')\n",
    "ll_7 =np.array(ll_7)\n",
    "#ll_8=np.array(ll_8)*-1\n",
    "print(len(ll_7))\n",
    "#print(len(ll_8))\n",
    "cc =[]\n",
    "cc_1=[]\n",
    "last =17500\n",
    "for i in range(len(ll_7[-last:])):\n",
    "    cc.append(np.mean(ll_7[-last+i:-last+100+i]))\n",
    "    cc_1.append(np.mean(ll_8[-last+i:-last+200+i]))\n",
    "print(len(cc))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.plot(cc)\n",
    "#plt.plot(cc_1)\n",
    "plt.hlines(y=1,xmin=0,xmax=17500,linestyles='--',colors='r')\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('Approximation ratio')\n",
    "#plt.plot(cc_1)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "x = np.linspace(1,10000,10000)\n",
    "y = 0.02 +  (1- 0.02) * (8000 - x) / 8000\n",
    "            \n",
    "plt.plot(x,0.9997**x)\n",
    "plt.plot(x,y)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "ll_7=np.loadtxt('test_22.out')\n",
    "ll_8 = np.loadtxt('test_24_10_mvc_2nd.out')\n",
    "#ll_all = np.concatenate([ll,ll_5])\n",
    "ll_7 =np.array(ll_7)*-1\n",
    "ll_8=np.array(ll_8)*-1\n",
    "print(len(ll_7))\n",
    "print(len(ll_8))\n",
    "cc =[]\n",
    "cc_1=[]\n",
    "length=56600\n",
    "ll_7=ll_7[:length]\n",
    "ll_8=ll_8[:length]\n",
    "for i in range(len(ll_7[-length:])):\n",
    "    cc.append(np.mean(ll_7[-length+i:-length+200+i]))\n",
    "    cc_1.append(np.mean(ll_8[-length+i:-length+200+i]))"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": [
    "### plt.plot(cc,label=\"GCN\")\n",
    "plt.plot(cc_1,label=\"S2V\")\n",
    "plt.xlabel('epochs')\n",
    "plt.ylabel('Approximation ratio')\n",
    "plt.legend()\n",
    "plt.show()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g=nx.erdos_renyi_graph(n=20,p=0.15,seed=125)\n",
    "pos=nx.spring_layout(g,weight=0.9,iterations=18)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "edge_color=[]\n",
    "for u,v in g.edges():\n",
    "    if (u ==8) | (v==8):\n",
    "        edge_color.append('g')\n",
    "    else:\n",
    "        edge_color.append('powderblue')\n",
    "node_color=[]\n",
    "for u in g.nodes():\n",
    "    if (u ==8) | (u in list(g[8])):\n",
    "        node_color.append('g')\n",
    "    else:\n",
    "        node_color.append('powderblue')\n",
    "nx.draw(g,with_labels=True,seed=125,pos=pos,edge_color=edge_color,node_color=node_color,alpha=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "edge_color=[]\n",
    "selec=[8,11,13,1,7,14,9]\n",
    "for u,v in g.edges():\n",
    "    if (u in selec) | (v in selec):\n",
    "        edge_color.append('g')\n",
    "    else:\n",
    "        edge_color.append('powderblue')\n",
    "node_color=[]\n",
    "for u in g.nodes():\n",
    "    adj=[]\n",
    "    for x in selec:\n",
    "        adj+=list(g[x])\n",
    "    \n",
    "    if (u in selec) | (u in list(set(adj))):\n",
    "        node_color.append('g')\n",
    "        if (u == selec[-1]) :\n",
    "            node_color[-1]='tomato'\n",
    "    else:\n",
    "        node_color.append('powderblue')\n",
    "nx.draw(g,with_labels=True,seed=125,pos=pos,edge_color=edge_color,node_color=node_color,alpha=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "list(g.neighbors(8))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#weight=torch.load('model_mvc_10_14.pt')\n",
    "weight=torch.load('model_mvc_10_14.pt')\n",
    "weight"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "class S2V_QN_1(torch.nn.Module):\n",
    "    def __init__(self,reg_hidden, embed_dim, len_pre_pooling, len_post_pooling, T):\n",
    "\n",
    "        super(S2V_QN_1, self).__init__()\n",
    "        self.T = T\n",
    "        self.embed_dim=embed_dim\n",
    "        self.reg_hidden=reg_hidden\n",
    "        self.mu= torch.zeros(embed_dim,embed_dim)\n",
    "        #self.len_pre_pooling = len_pre_pooling\n",
    "        #self.len_post_pooling = len_post_pooling\n",
    "        #self.mu_1 = torch.nn.Linear(1, embed_dim)\n",
    "        #torch.nn.init.normal_(self.mu_1.weight,mean=0,std=0.01)\n",
    "        self.mu_1 = torch.nn.Parameter(torch.Tensor(1, embed_dim))\n",
    "        self.mu_1=torch.nn.Parameter(weight['mu_1'])\n",
    "        #torch.nn.init.normal_(self.mu_1, mean=0, std=0.01)\n",
    "        self.mu_2 = torch.nn.Linear(embed_dim, embed_dim,True)\n",
    "        self.mu_2.weight=torch.nn.Parameter(weight['mu_2.weight'])\n",
    "        self.mu_2.biais=torch.nn.Parameter(weight['mu_2.bias'])\n",
    "        #torch.nn.init.normal_(self.mu_2.weight, mean=0, std=0.01)\n",
    "        \n",
    "        self.q_1 = torch.nn.Linear(embed_dim, embed_dim,bias=True)\n",
    "        self.q_1.weight=torch.nn.Parameter(weight['q_1.weight'])\n",
    "        self.q_1.biais=torch.nn.Parameter(weight['q_1.bias'])\n",
    "        #torch.nn.init.normal_(self.q_1.weight, mean=0, std=0.01)\n",
    "        self.q_2 = torch.nn.Linear(embed_dim, embed_dim,bias=True)\n",
    "        self.q_2.weight=torch.nn.Parameter(weight['q_2.weight'])\n",
    "        self.q_2.biais=torch.nn.Parameter(weight['q_2.bias'])\n",
    "                        \n",
    "        #torch.nn.init.normal_(self.q_2.weight, mean=0, std=0.01)\n",
    "        if self.reg_hidden > 0:\n",
    "            self.q_reg = torch.nn.Linear(2 * embed_dim, self.reg_hidden)\n",
    "            self.q_reg.weight=torch.nn.Parameter(weight['q_reg.weight'])\n",
    "            self.q_reg.biais=torch.nn.Parameter(weight['q_reg.bias'])\n",
    "            #torch.nn.init.normal_(self.q_reg.weight, mean=0, std=0.01)\n",
    "            self.q = torch.nn.Linear(self.reg_hidden, 1)\n",
    "            self.q.weight=torch.nn.Parameter(weight['q.weight'])\n",
    "            self.q.biais=torch.nn.Parameter(weight['q.bias'])\n",
    "        else:\n",
    "            self.q = torch.nn.Linear(2 * embed_dim, 1)\n",
    "            self.q.weight=torch.nn.Parameter(weight['q.weight'])\n",
    "            self.q.biais=torch.nn.Parameter(weight['q.bias'])\n",
    "        #torch.nn.init.normal_(self.q.weight, mean=0, std=0.01)\n",
    "\n",
    "    def forward(self, xv, adj):\n",
    "\n",
    "        minibatch_size = xv.shape[0]\n",
    "        nbr_node = xv.shape[1]\n",
    "\n",
    "\n",
    "        for t in range(self.T):\n",
    "            if t == 0:\n",
    "                #mu = self.mu_1(xv).clamp(0)\n",
    "                self.mu = torch.matmul(xv, self.mu_1).clamp(0)\n",
    "                #mu.transpose_(1,2)\n",
    "                #mu_2 = self.mu_2(torch.matmul(adj, mu_init))\n",
    "                #mu = torch.add(mu_1, mu_2).clamp(0)\n",
    "\n",
    "            else:\n",
    "                #mu_1 = self.mu_1(xv).clamp(0)\n",
    "                mu_1 = torch.matmul(xv, self.mu_1).clamp(0)\n",
    "                #mu_1.transpose_(1,2)\n",
    "                # before pooling:\n",
    "                #for i in range(self.len_pre_pooling):\n",
    "                #    mu = self.list_pre_pooling[i](mu).clamp(0)\n",
    "\n",
    "                mu_pool = torch.matmul(adj, self.mu)\n",
    "\n",
    "                # after pooling\n",
    "                #for i in range(self.len_post_pooling):\n",
    "                #    mu_pool = self.list_post_pooling[i](mu_pool).clamp(0)\n",
    "\n",
    "                mu_2 = self.mu_2(mu_pool)\n",
    "                self.mu = torch.add(mu_1, mu_2).clamp(0)\n",
    "\n",
    "        q_1 = self.q_1(torch.matmul(xv.transpose(1,2),self.mu)).expand(minibatch_size,nbr_node,self.embed_dim)\n",
    "        q_2 = self.q_2(self.mu)\n",
    "        q_ = torch.cat((q_1, q_2), dim=-1)\n",
    "        if self.reg_hidden > 0:\n",
    "            q_reg = self.q_reg(q_).clamp(0)\n",
    "            q = self.q(q_reg)\n",
    "        else:\n",
    "            q_=q_.clamp(0)\n",
    "            q = self.q(q_)\n",
    "        return q\n",
    "    \n",
    "model = S2V_QN_1(reg_hidden=64,embed_dim=64,len_pre_pooling=0,len_post_pooling=0,T=5)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.mu"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "node=1000\n",
    "g=nx.erdos_renyi_graph(p=0.15,n=node,seed=125)\n",
    "xv=torch.zeros(1, node, 1, dtype=torch.float)\n",
    "xv[:,7,:]=1\n",
    "#xv[:,8,:]=1\n",
    "adj =nx.adj_matrix(g)\n",
    "adj = adj.todense()\n",
    "adj = torch.from_numpy(np.expand_dims(adj.astype(int), axis=0))\n",
    "adj = adj.type(torch.FloatTensor)\n",
    "\n",
    "q=model(xv,adj)\n",
    "q"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "\n",
    "\n",
    "torch.set_printoptions(precision=20)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "model.mu.detach().numpy()[0]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pca = decomposition.PCA(n_components=3)\n",
    "x=model.mu.detach().numpy()[0]\n",
    "#x=np.sqrt(10000*x)\n",
    "result = pca.fit_transform(x)\n",
    "\n",
    "plt.scatter(result[:, 0], result[:, 1],s=30,c=result[:,2])\n",
    "#for k,(i,j) in enumerate(zip(result[:,0],result[:,1])):\n",
    " #   plt.annotate('%s)' %k, xy=(i,j), xytext=((-1)**(k)*20,(-1)**(k)*10), textcoords='offset points')\n",
    "    #plt.annotate('(%s,' %i, xy=(i,j))\n",
    "plt.grid()\n",
    "plt.xlabel(\"1st component\")\n",
    "plt.ylabel(\"2nd component\")\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(20,20))\n",
    "nx.draw(g,with_labels=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "plt.figure(figsize=(25,25))\n",
    "kpca = decomposition.KernelPCA(kernel=\"rbf\", fit_inverse_transform=True, gamma=0.0000005,n_components=4)\n",
    "x=model.mu.detach().numpy()[0]\n",
    "result = kpca.fit_transform(x)\n",
    "#X_back = kpca.inverse_transform(X_kpca)\n",
    "#pca = PCA()\n",
    "#X_pca = pca.fit_transform(X)\n",
    "#pca = decomposition.PCA(n_components=3)\n",
    "\n",
    "#x=np.sqrt(10000*x)\n",
    "#result = pca.fit_transform(X)\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "fig = plt.figure(figsize=(20,20))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.scatter(xs=result[:, 0], ys=result[:, 1],zs=result[:,2],c=(result[:,3]-min(result[:,3]))/(max(result[:,3])-min(result[:,3])),s=30,zdir='z')\n",
    "#for k,(i,j,l) in enumerate(zip(result[:,0],result[:,1],result[:,2])):\n",
    " #   if k==7:\n",
    "  #      ax.annotate('%s 77777)' %k, xy=(i,j,l), xytext=((-1)**(k)*10,(-1)**(k)*10), textcoords='offset points')\n",
    "    #else:\n",
    "    #ax.annotate('%s)' %k, xy=(i,j,l), xytext=((-1)**(k)*10,(-1)**(k)*10), textcoords='offset points')\n",
    "    #plt.annotate('(%s,' %i, xy=(i,j))\n",
    "result"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xv=torch.zeros(32, node, 1, dtype=torch.float)\n",
    "done=False\n",
    "def get_reward(observation,last_observation,g):\n",
    "\n",
    "    new_nbr_nodes=np.sum(observation[0].numpy())\n",
    "    last_nbr_nodes=np.sum(last_observation[0].numpy())\n",
    "    \n",
    "    if new_nbr_nodes - last_nbr_nodes > 0:\n",
    "        reward = -1#np.round(-1.0/20.0,3)\n",
    "    else:\n",
    "        reward = 0\n",
    "\n",
    "    #Minimum vertex set:\n",
    "\n",
    "    done = True\n",
    "\n",
    "    edge_add = 0\n",
    "\n",
    "    for edge in g.edges():\n",
    "        if observation[:,edge[0],:]==0 and observation[:,edge[1],:]==0:\n",
    "            done=False\n",
    "            # break\n",
    "        else:\n",
    "            edge_add += 1\n",
    "\n",
    "    return (reward,done)\n",
    "def get_optimal(g):\n",
    "    x = list(range(g.number_of_nodes()))\n",
    "    xv = pulp.LpVariable.dicts('is_opti', x,\n",
    "                               lowBound=0,\n",
    "                               upBound=1,\n",
    "                               cat=pulp.LpInteger)\n",
    "\n",
    "    mdl = pulp.LpProblem(\"MVC\", pulp.LpMinimize)\n",
    "\n",
    "    mdl += sum(xv[k] for k in xv)\n",
    "\n",
    "    for edge in g.edges():\n",
    "        mdl += xv[edge[0]] + xv[edge[1]] >= 1, \"constraint :\" + str(edge)\n",
    "    mdl.solve()\n",
    "\n",
    "    #print(\"Status:\", pulp.LpStatus[mdl.status])\n",
    "    optimal=0\n",
    "    for x in xv:\n",
    "        optimal += xv[x].value()\n",
    "        #print(xv[x].value())\n",
    "    return (optimal,xv)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "xv[:,8,:]=1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "#model(xv,adj)"
   ]
  },
  {
   "cell_type": "markdown",
   "metadata": {},
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "node=20\n",
    "plot=True\n",
    "#cum_rew=[]\n",
    "g=nx.erdos_renyi_graph(p=0.15,n=node,seed=125)\n",
    "xv=torch.zeros(1, node, 1, dtype=torch.float)\n",
    "#xv[:,9,:]=1\n",
    "#xv[:,8,:]=1\n",
    "adj = nx.adj_matrix(g)\n",
    "adj = adj.todense()\n",
    "adj = torch.from_numpy(np.expand_dims(adj.astype(int), axis=0))\n",
    "adj = adj.type(torch.FloatTensor)\n",
    "done=False\n",
    "reward=0\n",
    "while done==False:\n",
    "    q_a = model(xv, adj)\n",
    "    \n",
    "    q_a=q_a.detach().numpy()\n",
    "    last_xv=xv.clone()\n",
    "    selec_=np.where((q_a[0, :, 0] == np.max(q_a[0, :, 0][xv.numpy()[0, :, 0] == 0])))[0][0]\n",
    "    print(selec_)\n",
    "    if plot:\n",
    "        pca = decomposition.PCA(n_components=3)\n",
    "        x=model.mu.detach().numpy()[0]\n",
    "        #x=np.sqrt(10000*x)\n",
    "        result = pca.fit_transform(x)\n",
    "\n",
    "        plt.scatter(result[:, 0], result[:, 1],s=30,c=result[:,2])\n",
    "        #for k,(i,j) in enumerate(zip(result[:,0],result[:,1])):\n",
    "            #plt.annotate('%s)' %k, xy=(i,j), xytext=((-1)**(k)*10,(-1)**(k)*15), textcoords='offset points')\n",
    "            #plt.annotate('(%s,' %i, xy=(i,j))\n",
    "        ax.grid()\n",
    "        #ax.xlabel(\"1st component\")\n",
    "        #ax.ylabel(\"2nd component\")\n",
    "        plt.show()\n",
    "    xv[:,selec_,:]=1\n",
    "    (rew,done)=get_reward(xv,last_xv,g)\n",
    "    reward+=rew\n",
    "if plot:\n",
    "    q_a = model(xv, adj)\n",
    "    pca = decomposition.PCA(n_components=3)\n",
    "    x=model.mu.detach().numpy()[0]\n",
    "    #x=np.sqrt(10000*x)\n",
    "    result = pca.fit_transform(x)\n",
    "\n",
    "    plt.scatter(result[:, 0], result[:, 1],s=30,c=result[:,2])\n",
    "    plt.grid()\n",
    "    plt.xlabel(\"1st component\")\n",
    "    plt.ylabel(\"2nd component\")\n",
    "\n",
    "    for k,(i,j) in enumerate(zip(result[:,0],result[:,1])):\n",
    "            plt.annotate('%s)' %k, xy=(i,j), xytext=((-1)**(k)*8,(-1)**(k)*10), textcoords='offset points')\n",
    "            #plt.annotate('(%s,' %i, xy=(i,j))\n",
    "    plt.show()\n",
    "#print(reward)\n",
    "print(np.sum(xv[0].numpy()))\n",
    "print(get_optimal(g)[0])\n",
    "cum_rew.append(np.sum(xv[0].numpy())/get_optimal(g)[0])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "from sklearn.metrics.pairwise import euclidean_distances\n",
    "from mpl_toolkits.mplot3d import Axes3D\n",
    "\n",
    "node=50\n",
    "plot=True\n",
    "#cum_rew=[]\n",
    "g=nx.erdos_renyi_graph(p=0.15,n=node,seed=np.random.seed(120))\n",
    "xv=torch.zeros(1, node, 1, dtype=torch.float)\n",
    "#xv[:,9,:]=1\n",
    "#xv[:,8,:]=1\n",
    "adj = nx.adj_matrix(g)\n",
    "adj = adj.todense()\n",
    "adj = torch.from_numpy(np.expand_dims(adj.astype(int), axis=0))\n",
    "adj = adj.type(torch.FloatTensor)\n",
    "done=False\n",
    "reward=0\n",
    "q_a = model(xv, adj)\n",
    "    \n",
    "q_a=q_a.detach().numpy()\n",
    "last_xv=xv.clone()\n",
    "selec_=np.where((q_a[0, :, 0] == np.max(q_a[0, :, 0][xv.numpy()[0, :, 0] == 0])))[0][0]\n",
    "kpca = decomposition.KernelPCA(kernel=\"rbf\", fit_inverse_transform=True, gamma=0.000005,n_components=4)\n",
    "x=model.mu.detach().numpy()[0]\n",
    "#x=np.sqrt(10000*x)\n",
    "xv[:,selec_,:]=1\n",
    "result = kpca.fit_transform(x)\n",
    "selec_list=[]\n",
    "selec_list.append(selec_)\n",
    "while done==False:\n",
    "    \n",
    "    print(selec_)\n",
    "    if plot:\n",
    "        #pca = decomposition.PCA(n_components=3)\n",
    "        \n",
    "        \n",
    "        fig = plt.figure(figsize=(20,20))\n",
    "        ax = fig.add_subplot(111, projection='3d')\n",
    "        ax.scatter(xs=result[:, 0], ys=result[:, 1],zs=result[:,2],c=xv.numpy()[0,:,0],s=30,zdir='z')\n",
    "        #(result[:,3]-min(result[:,3]))/(max(result[:,3])-min(result[:,3]))\n",
    "        #plt.scatter(result[:, 0], result[:, 1],s=30,c=result[:,2])\n",
    "        #for k,(i,j) in enumerate(zip(result[:,0],result[:,1])):\n",
    "            #plt.annotate('%s)' %k, xy=(i,j), xytext=((-1)**(k)*10,(-1)**(k)*15), textcoords='offset points')\n",
    "            #plt.annotate('(%s,' %i, xy=(i,j))\n",
    "        ax.grid()\n",
    "        #ax.xlabel(\"1st component\")\n",
    "        #ax.ylabel(\"2nd component\")\n",
    "        best_dist=1000\n",
    "        best_k=-1\n",
    "        for k in range(node):\n",
    "            dist= np.linalg.norm(result[selec_,:]-result[k,:],axis=0)#euclidean_distances(result[selec_,:].reshape(-1,1),result[k,:].reshape(-1,1),X_norm_squared=True,Y_norm_squared=True)\n",
    "            #print(dist)\n",
    "            if (k not in selec_list) and (dist<=best_dist):\n",
    "                best_k=k\n",
    "                best_dist=dist\n",
    "        selec_=best_k\n",
    "        print(selec_)\n",
    "        selec_list.append(selec_)\n",
    "        plt.show()\n",
    "    xv[:,selec_,:]=1\n",
    "    (rew,done)=get_reward(xv,last_xv,g)\n",
    "    reward+=rew\n",
    "#if plot:\n",
    "    #q_a = model(xv, adj)\n",
    "    #pca = decomposition.PCA(n_components=3)\n",
    "    #x=model.mu.detach().numpy()[0]\n",
    "    #x=np.sqrt(10000*x)\n",
    "    #result = pca.fit_transform(x)\n",
    "\n",
    "    #plt.scatter(result[:, 0], result[:, 1],s=30,c=result[:,2])\n",
    "    #plt.grid()\n",
    "    #plt.xlabel(\"1st component\")\n",
    "    #plt.ylabel(\"2nd component\")\n",
    "\n",
    "    #for k,(i,j) in enumerate(zip(result[:,0],result[:,1])):\n",
    "     #       plt.annotate('%s)' %k, xy=(i,j), xytext=((-1)**(k)*8,(-1)**(k)*10), textcoords='offset points')\n",
    "            #plt.annotate('(%s,' %i, xy=(i,j))\n",
    "    #plt.show()\n",
    "#print(reward)\n",
    "print(np.sum(xv[0].numpy()))\n",
    "print(get_optimal(g)[0])\n",
    "cum_rew.append(np.sum(xv[0].numpy())/get_optimal(g)[0])\n",
    "xv=torch.zeros(1, node, 1, dtype=torch.float)\n",
    "print(\"-------\")\n",
    "for i in get_optimal(g)[1]:\n",
    "    xv[:,i,:]=get_optimal(g)[1][i].value()\n",
    "print(xv)\n",
    "fig = plt.figure(figsize=(20,20))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.scatter(xs=result[:, 0], ys=result[:, 1],zs=result[:,2],c=xv.numpy()[0,:,0],s=30,zdir='z')\n",
    "plt.show()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "print(\"-------\")\n",
    "node=20\n",
    "plot=True\n",
    "#cum_rew=[]\n",
    "g=nx.erdos_renyi_graph(p=0.15,n=node,seed=126)\n",
    "xv=torch.zeros(1, node, 1, dtype=torch.float)\n",
    "#xv[:,9,:]=1\n",
    "#xv[:,8,:]=1\n",
    "adj = nx.adj_matrix(g)\n",
    "adj = adj.todense()\n",
    "adj = torch.from_numpy(np.expand_dims(adj.astype(int), axis=0))\n",
    "adj = adj.type(torch.FloatTensor)\n",
    "done=False\n",
    "reward=0\n",
    "q_a = model(xv, adj)\n",
    "    \n",
    "q_a=q_a.detach().numpy()\n",
    "last_xv=xv.clone()\n",
    "selec_=np.where((q_a[0, :, 0] == np.max(q_a[0, :, 0][xv.numpy()[0, :, 0] == 0])))[0][0]\n",
    "kpca = decomposition.KernelPCA(kernel=\"rbf\", fit_inverse_transform=True, gamma=0.005,n_components=4,alpha=0.9)\n",
    "x=model.mu.detach().numpy()[0]\n",
    "result = kpca.fit_transform(x)\n",
    "xv[:,selec_,:]=1\n",
    "#x=np.sqrt(10000*x)\n",
    "done=False\n",
    "while done==False:\n",
    "    last_xv=xv.clone()\n",
    "    q_a = model(xv, adj)\n",
    "    q_a=q_a.detach().numpy()\n",
    "    selec_=np.where((q_a[0, :, 0] == np.max(q_a[0, :, 0][xv.numpy()[0, :, 0] == 0])))[0][0]\n",
    "    xv[:,selec_,:]=1\n",
    "    (rew,done)=get_reward(xv,last_xv,g)\n",
    "x=model.mu.detach().numpy()[0]\n",
    "\n",
    "fig = plt.figure(figsize=(20,20))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "ax.scatter(xs=result[:, 0], ys=result[:, 1],zs=result[:,2],c=xv.numpy()[0,:,0]*50+20,s=30,zdir='z')\n",
    "plt.show()        \n",
    "xv=torch.zeros(1, node, 1, dtype=torch.float)\n",
    "q_a = model(xv, adj)\n",
    "for i in get_optimal(g)[1]:\n",
    "    xv[:,i,:]=get_optimal(g)[1][i].value()\n",
    "#print(xv)\n",
    "fig = plt.figure(figsize=(20,20))\n",
    "ax = fig.add_subplot(111, projection='3d')\n",
    "deg=[]\n",
    "for x in g.nodes():\n",
    "    deg.append(g.degree(x))\n",
    "deg=np.array(deg)\n",
    "ax.scatter(xs=result[:, 0], ys=result[:, 1],zs=result[:,2],c=xv.numpy()[0,:,0]*50+20,s=40,alpha=0.95,zdir='z')\n",
    "plt.show()        "
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for x in g.nodes():\n",
    "    print(g.degree(x))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "pos=nx.spring_layout(g,weight=0.9,iterations=18)\n"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "edge_color=[]\n",
    "selec=[0,5,7]\n",
    "for u,v in g.edges():\n",
    "    if (u in selec) | (v in selec):\n",
    "        edge_color.append('g')\n",
    "    else:\n",
    "        edge_color.append('powderblue')\n",
    "node_color=[]\n",
    "for u in g.nodes():\n",
    "    adj=[]\n",
    "    for x in selec:\n",
    "        adj+=list(g[x])\n",
    "    \n",
    "    if (u in selec) | (u in list(set(adj))):\n",
    "        node_color.append('g')\n",
    "        if (u == selec[-1]) :\n",
    "            node_color[-1]='tomato'\n",
    "    else:\n",
    "        node_color.append('powderblue')\n",
    "nx.draw(g,with_labels=True,seed=125,pos=pos,edge_color=edge_color,node_color=node_color,alpha=0.9)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i in range(0):\n",
    "    print(\"ee\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g=nx.erdos_renyi_graph(p=0.15,n=10,seed=368)\n",
    "x = list(range(g.number_of_nodes()))\n",
    "e = list(g.edges())\n",
    "xv = pulp.LpVariable.dicts('is_opti', x,\n",
    "                           lowBound=0,\n",
    "                           upBound=1,\n",
    "                           cat=pulp.LpBinary)\n",
    "ev = pulp.LpVariable.dicts('ev', e,\n",
    "                           lowBound=0,\n",
    "                           upBound=1,\n",
    "                           cat=pulp.LpInteger)\n",
    "\n",
    "mdl = pulp.LpProblem(\"MVC\", pulp.LpMaximize)\n",
    "\n",
    "mdl += sum(ev[k] for k in ev)\n",
    "\n",
    "for l in e:\n",
    "    mdl+= ev[l] <= xv[l[0]]+xv[l[1]]\n",
    "\n",
    "for l in e:\n",
    "    mdl+= ev[l]<= 2 -(xv[l[0]]+xv[l[1]])\n",
    "\n",
    "#pulp.LpSolverDefault.msg = 1\n",
    "mdl.solve()\n",
    "\n",
    "# print(\"Status:\", pulp.LpStatus[mdl.status])\n",
    "\n",
    "mdl.objective.value()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "g.number_of_nodes()"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i,l in enumerate(e):\n",
    "    print(ev[l].value())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "for i,l in enumerate(x):\n",
    "    print(xv[l].value())"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": [
    "nx.draw(g,with_labels=True)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3",
   "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.6.3"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 2
}