rec_attack_fedr_fb15k_TransE.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "13f28aa4",
   "metadata": {},
   "outputs": [],
   "source": [
    "import torch\n",
    "import pickle\n",
    "import numpy as np\n",
    "import random\n",
    "from scipy import spatial"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "62431191",
   "metadata": {},
   "outputs": [],
   "source": [
    "emb = torch.load('./state/fb15k237_fed3_fed_TransE.best', map_location=torch.device('cpu'))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "405c7f20",
   "metadata": {},
   "outputs": [],
   "source": [
    "ent_embed = emb['ent_embed']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "e9de591b",
   "metadata": {},
   "outputs": [],
   "source": [
    "rel_embed = emb['rel_embed']"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 5,
   "id": "80bcf3f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "data = pickle.load(open(\"Fed_data/FB15K237-Fed3.pkl\", \"rb\" ))"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "70a98ee0",
   "metadata": {},
   "source": [
    "#### ERR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 6,
   "id": "8a83d890",
   "metadata": {},
   "outputs": [],
   "source": [
    "# assume the adversary knows all information of the client 0\n",
    "c0_ent = np.unique(data[0]['train']['edge_index'])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 7,
   "id": "c2b80aa9",
   "metadata": {},
   "outputs": [],
   "source": [
    "# creat entity pool of selected entities (adversary knowledge) in a global view\n",
    "c0_ent_embed_dict = {}\n",
    "value = ent_embed[0]\n",
    "for idx,ent in enumerate(c0_ent):\n",
    "    c0_ent_embed_dict[ent] = value[idx]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 8,
   "id": "455855ae",
   "metadata": {},
   "outputs": [],
   "source": [
    "# map local to global\n",
    "c0_mapping = dict(zip(data[0]['train']['edge_index'][0], data[0]['train']['edge_index_ori'][0]))\n",
    "c0_mapping.update(dict(zip(data[0]['train']['edge_index'][1], data[0]['train']['edge_index_ori'][1])))\n",
    "\n",
    "c0_ent_embed_dict_mapped = dict((c0_mapping[key], value) for (key, value) in c0_ent_embed_dict.items())\n",
    "c0_ent_pool_mapped = [c0_mapping[i] for i in c0_ent]"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "5c8ebc92",
   "metadata": {},
   "source": [
    "##### Client 1"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 27,
   "id": "00a24226",
   "metadata": {},
   "outputs": [],
   "source": [
    "# map local to global\n",
    "c1_mapping = dict(zip(data[1]['train']['edge_index'][0], data[1]['train']['edge_index_ori'][0]))\n",
    "c1_mapping.update(dict(zip(data[1]['train']['edge_index'][1], data[1]['train']['edge_index_ori'][1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 28,
   "id": "551206a0",
   "metadata": {},
   "outputs": [],
   "source": [
    "c1_ent = np.unique(data[1]['train']['edge_index'])\n",
    "\n",
    "random.seed(10)\n",
    "np.random.seed(10)\n",
    "p = 1\n",
    "\n",
    "c1_ent_pool = np.random.choice(c1_ent, int(p * len(c1_ent)), replace = False)\n",
    "c1_ent_embed = ent_embed[1][[c1_ent_pool]]\n",
    "\n",
    "c1_ent_pool_mapped = [c1_mapping[i] for i in c1_ent_pool]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "c03a8e30",
   "metadata": {},
   "outputs": [],
   "source": [
    "syn_ent_list = [] # synthetic entity label\n",
    "\n",
    "for i in c1_ent_pool:\n",
    "    c1_ent_embed = ent_embed[1][i]\n",
    "    count = 0\n",
    "    loss_bound = 0\n",
    "    ent_idx = []\n",
    "    for j in c0_ent_embed_dict_mapped:\n",
    "        loss = spatial.distance.cosine(c1_ent_embed.detach().numpy(), c0_ent_embed_dict_mapped[j].detach().numpy())\n",
    "        if count == 0: # first round\n",
    "            loss_bound = loss\n",
    "            ent_idx.append(j)\n",
    "            count += 1\n",
    "        else:\n",
    "            if loss < loss_bound:\n",
    "                loss_bound = loss\n",
    "                ent_idx.append(j)\n",
    "    syn_ent_list.append(ent_idx[-1]) # global index of the entity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 30,
   "id": "74345f58",
   "metadata": {},
   "outputs": [],
   "source": [
    "tru_ent_list = [c1_mapping[i] for i in c1_ent_pool]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "0145b127",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.014542589010674118"
      ]
     },
     "execution_count": 31,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "# calculate the number of correct reconstruction\n",
    "sum(first == second for (first, second) in zip(syn_ent_list, tru_ent_list)) / len(c1_ent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cb49a946",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "c7450910",
   "metadata": {},
   "source": [
    "#### TRR"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 32,
   "id": "c63e9472",
   "metadata": {},
   "outputs": [],
   "source": [
    "c0_rel = np.unique(data[0]['train']['edge_type_ori'])\n",
    "# creat relation pool based on selected entities (global relation index)\n",
    "c1_triple_all = np.array([data[1]['train']['edge_index_ori'][0], \n",
    "                          data[1]['train']['edge_type_ori'], \n",
    "                          data[1]['train']['edge_index_ori'][1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 33,
   "id": "f0342d3b",
   "metadata": {},
   "outputs": [],
   "source": [
    "tru_trr_list = []\n",
    "# the adversary knows all relation embeddings and their corresponding index, so here we use ori directly\n",
    "len_c1_triple = c1_triple_all[0].shape[0]\n",
    "for i in range(len_c1_triple):\n",
    "    triple = c1_triple_all[:,i]\n",
    "    h, r, t= triple[0], triple[1], triple[2]\n",
    "    if (h in c1_ent_pool_mapped) and (t in c1_ent_pool_mapped):\n",
    "        if h not in tru_trr_list:\n",
    "            tru_trr_list.append(h)\n",
    "        if t not in tru_trr_list:\n",
    "            tru_trr_list.append(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 34,
   "id": "bf5dd926",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0024547444284556876"
      ]
     },
     "execution_count": 34,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "syn_trr_list = []\n",
    "for (first, second) in zip(syn_ent_list, tru_ent_list):\n",
    "    if first == second:\n",
    "        syn_trr_list.append(first)\n",
    "\n",
    "# calculate the number of correct reconstruction\n",
    "len(list(set(syn_trr_list).intersection(tru_trr_list))) / len_c1_triple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "663e8026",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "markdown",
   "id": "58e6c324",
   "metadata": {},
   "source": [
    "##### Client 2"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 48,
   "id": "513471b0",
   "metadata": {},
   "outputs": [],
   "source": [
    "# ERR\n",
    "# map local to global\n",
    "c2_mapping = dict(zip(data[2]['train']['edge_index'][0], data[2]['train']['edge_index_ori'][0]))\n",
    "c2_mapping.update(dict(zip(data[2]['train']['edge_index'][1], data[2]['train']['edge_index_ori'][1])))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 49,
   "id": "5f923c49",
   "metadata": {},
   "outputs": [],
   "source": [
    "c2_ent = np.unique(data[2]['train']['edge_index'])\n",
    "\n",
    "random.seed(10)\n",
    "np.random.seed(10)\n",
    "p = 1\n",
    "\n",
    "c2_ent_pool = np.random.choice(c2_ent, int(p * len(c2_ent)), replace = False)\n",
    "c2_ent_embed = ent_embed[2][[c2_ent_pool]]\n",
    "\n",
    "c2_ent_pool_mapped = [c2_mapping[i] for i in c2_ent_pool]"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 50,
   "id": "1e0b3647",
   "metadata": {},
   "outputs": [],
   "source": [
    "syn_ent_list = [] # synthetic entity label\n",
    "\n",
    "for i in c2_ent_pool:\n",
    "    c2_ent_embed = ent_embed[2][i]\n",
    "    count = 0\n",
    "    loss_bound = 0\n",
    "    ent_idx = []\n",
    "    for j in c0_ent_embed_dict_mapped:\n",
    "        loss = spatial.distance.cosine(c2_ent_embed.detach().numpy(), c0_ent_embed_dict_mapped[j].detach().numpy())\n",
    "        if count == 0: # first round\n",
    "            loss_bound = loss\n",
    "            ent_idx.append(j)\n",
    "            count += 1\n",
    "        else:\n",
    "            if loss < loss_bound:\n",
    "                loss_bound = loss\n",
    "                ent_idx.append(j)\n",
    "    syn_ent_list.append(ent_idx[-1]) # global index of the entity"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 51,
   "id": "58149825",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.012976827094474154"
      ]
     },
     "execution_count": 51,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "tru_ent_list = [c2_mapping[i] for i in c2_ent_pool]\n",
    "# calculate the number of correct reconstruction\n",
    "sum(first == second for (first, second) in zip(syn_ent_list, tru_ent_list)) / len(c2_ent)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "34d26413",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 52,
   "id": "7dd45465",
   "metadata": {},
   "outputs": [],
   "source": [
    "# TRR\n",
    "c0_rel = np.unique(data[0]['train']['edge_type_ori'])\n",
    "# creat relation pool based on selected entities (global relation index)\n",
    "c2_triple_all = np.array([data[2]['train']['edge_index_ori'][0], \n",
    "                          data[2]['train']['edge_type_ori'], \n",
    "                          data[2]['train']['edge_index_ori'][1]])"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 53,
   "id": "cbbb24f3",
   "metadata": {},
   "outputs": [],
   "source": [
    "tru_trr_list = []\n",
    "# the adversary knows all relation embeddings and their corresponding index, so here we use ori directly\n",
    "len_c2_triple = c2_triple_all[0].shape[0]\n",
    "for i in range(len_c2_triple):\n",
    "    triple = c2_triple_all[:,i]\n",
    "    h, r, t= triple[0], triple[1], triple[2]\n",
    "    if (h in c2_ent_pool_mapped) and (t in c2_ent_pool_mapped):\n",
    "        if h not in tru_trr_list:\n",
    "            tru_trr_list.append(h)\n",
    "        if t not in tru_trr_list:\n",
    "            tru_trr_list.append(t)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 54,
   "id": "2a58b74e",
   "metadata": {},
   "outputs": [
    {
     "data": {
      "text/plain": [
       "0.0022008053496499268"
      ]
     },
     "execution_count": 54,
     "metadata": {},
     "output_type": "execute_result"
    }
   ],
   "source": [
    "syn_trr_list = []\n",
    "for (first, second) in zip(syn_ent_list, tru_ent_list):\n",
    "    if first == second:\n",
    "        syn_trr_list.append(first)\n",
    "\n",
    "# calculate the number of correct reconstruction\n",
    "len(list(set(syn_trr_list).intersection(tru_trr_list))) / len_c2_triple"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "dca02295",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "cf41ce4a",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "78531830",
   "metadata": {},
   "outputs": [],
   "source": []
  },
  {
   "cell_type": "code",
   "execution_count": 29,
   "id": "51c00026",
   "metadata": {},
   "outputs": [],
   "source": [
    "# !usr/bin env python\n",
    "# -*- coding: utf-8 -*-\n",
    " \n",
    " \n",
    "import re\n",
    "import math\n",
    " \n",
    " \n",
    "def ConvertELogStrToValue(eLogStr):\n",
    "    \"\"\"\n",
    "    convert string of natural logarithm base of E to value\n",
    "    return (convertOK, convertedValue)\n",
    "    eg:\n",
    "    input:  -1.1694737e-03\n",
    "    output: -0.001169\n",
    "    input:  8.9455025e-04\n",
    "    output: 0.000895\n",
    "    \"\"\"\n",
    " \n",
    "    (convertOK, convertedValue) = (False, 0.0)\n",
    "    foundEPower = re.search(\"(?P<coefficientPart>-?\\d+\\.\\d+)e(?P<ePowerPart>-\\d+)\", eLogStr, re.I)\n",
    "    #print \"foundEPower=\",foundEPower\n",
    "    if(foundEPower):\n",
    "        coefficientPart = foundEPower.group(\"coefficientPart\")\n",
    "        ePowerPart = foundEPower.group(\"ePowerPart\")\n",
    "        #print \"coefficientPart=%s,ePower=%s\"%(coefficientPart, ePower)\n",
    "        coefficientValue = float(coefficientPart)\n",
    "        ePowerValue = float(ePowerPart)\n",
    "        #print \"coefficientValue=%f,ePowerValue=%f\"%(coefficientValue, ePowerValue)\n",
    "        #math.e= 2.71828182846\n",
    "        # wholeOrigValue = coefficientValue * math.pow(math.e, ePowerValue)\n",
    "        wholeOrigValue = coefficientValue * math.pow(10, ePowerValue)\n",
    " \n",
    "        #print \"wholeOrigValue=\",wholeOrigValue;\n",
    " \n",
    "        (convertOK, convertedValue) = (True, wholeOrigValue)\n",
    "    else:\n",
    "        (convertOK, convertedValue) = (False, 0.0)\n",
    " \n",
    "    return (convertOK, convertedValue)\n",
    " \n",
    "def parseIntEValue(intEValuesStr):\n",
    "    # print \"intEValuesStr=\", intEValuesStr\n",
    "    intEStrList = re.findall(\"-?\\d+\\.\\d+e-\\d+\", intEValuesStr)\n",
    "    # intEStrList = intEValuesStr.split(' ')\n",
    "    # print \"intEStrList=\", intEStrList\n",
    "    for eachIntEStr in intEStrList:\n",
    "        # intValue = int(eachIntEStr)\n",
    "        # print \"intValue=\",intValue\n",
    "        (convertOK, convertedValue) = ConvertELogStrToValue(eachIntEStr)\n",
    "        #print \"convertOK=%s,convertedValue=%f\"%(convertOK, convertedValue)\n",
    "        print(\"eachIntEStr=%s,\\tconvertedValue=%f\" % (eachIntEStr, convertedValue)"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 31,
   "id": "753de860",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "eachIntEStr=7.036802476954472e-05,\tconvertedValue=0.000070\n"
     ]
    }
   ],
   "source": [
    "parseIntEValue(\"7.036802476954472e-05\")"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "8451bc67",
   "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.8.8"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}