demo.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "be9442a6",
   "metadata": {},
   "outputs": [],
   "source": [
    "from saibot import *"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "3309843d",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "s error 0.3901811715524032\n",
      "beta error 0.11898090084670562\n"
     ]
    }
   ],
   "source": [
    "# Use Saibot to privatize union\n",
    "# DP constants\n",
    "B = 5\n",
    "eps = 1\n",
    "delta = 1e-6\n",
    "\n",
    "# data parameters\n",
    "num_att = 3\n",
    "num_rows = 1000\n",
    "\n",
    "# data search parameters\n",
    "num_users = 2\n",
    "requests = 1\n",
    "ridge = 0\n",
    "\n",
    "result = []\n",
    "result.append(int(num_rows/2))\n",
    "num_rows *= 2\n",
    "\n",
    "columns = [f\"f{i}\" for i in range(num_att)]\n",
    "X = columns[1:]\n",
    "y = columns[0]\n",
    "\n",
    "# create datasets\n",
    "mean, cov = get_pos_def_mean_cov(num_att)\n",
    "\n",
    "df = generate_dataframe(mean, cov, num_rows, columns, B)\n",
    "sensitivity = union_sensitivity(B)\n",
    "\n",
    "# compute the non privatized estimator\n",
    "non_privatized_data = agg_dataset()\n",
    "non_privatized_data.load(df.copy(deep=True), columns,[])\n",
    "non_privatized_data.compute_agg()\n",
    "\n",
    "non_privatized_cov = non_privatized_data.agg/num_rows\n",
    "non_privatized_parameter = ridge_linear_regression(non_privatized_data.agg, X, y, ridge)\n",
    "\n",
    "noise = compute_std(eps, delta, sensitivity)\n",
    "\n",
    "# compute the fdp estimator\n",
    "buyeragg = agg_dataset()\n",
    "buyeragg.load(df[:int(num_rows/2)].copy(deep=True), columns, [])\n",
    "buyeragg.compute_agg()\n",
    "\n",
    "selleragg = agg_dataset()\n",
    "selleragg.load(df[int(num_rows/2):].copy(deep=True), columns, [])\n",
    "selleragg.compute_agg()\n",
    "\n",
    "# impute noise\n",
    "for col in selleragg.semi_ring_columns():\n",
    "    if col != \"cov:c\":\n",
    "        selleragg.agg[col] += np.random.normal(0, noise, 1)\n",
    "\n",
    "for col in buyeragg.semi_ring_columns():\n",
    "    if col != \"cov:c\":\n",
    "        buyeragg.agg[col] += np.random.normal(0, noise, 1)\n",
    "\n",
    "\n",
    "fdp_cov = selleragg.agg/num_rows + buyeragg.agg/num_rows\n",
    "print(\"s error\", get_l2_distance(fdp_cov, non_privatized_cov))\n",
    "\n",
    "if not sanity_check(fdp_cov, X, ridge):\n",
    "    print(\"fail\")\n",
    "else:\n",
    "    fdp_parameter = ridge_linear_regression(fdp_cov, X, y, ridge)\n",
    "    print(\"beta error\", get_l2_distance(fdp_parameter, non_privatized_parameter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "608b3200",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "beta error 0.8114082938434813\n"
     ]
    }
   ],
   "source": [
    "# Use Saibot to privatize join\n",
    "# DP constants\n",
    "B = 5\n",
    "eps = 1\n",
    "delta = 1e-6\n",
    "\n",
    "# data parameters\n",
    "buyer_att = 2\n",
    "seller_att = 1\n",
    "num_group = 100\n",
    "num_rows_per_group = 100\n",
    "\n",
    "# data search parameters\n",
    "num_users = 2\n",
    "requests=1\n",
    "ridge = 10\n",
    "\n",
    "num_att = buyer_att + seller_att\n",
    "num_rows = num_group * num_rows_per_group\n",
    "\n",
    "columns = [f\"f{i}\" for i in range(num_att)]\n",
    "X = columns[1:]\n",
    "y = columns[0]\n",
    "buyer_columns = columns[:buyer_att]\n",
    "seller_columns = columns[buyer_att:]\n",
    "\n",
    "# create data\n",
    "mean, cov = get_pos_def_mean_cov(num_att)\n",
    "df = generate_dataframe(mean, cov, num_rows, columns, B)\n",
    "joinkey = []\n",
    "for i in range(num_group):\n",
    "    joinkey += [i] * num_rows_per_group \n",
    "df[\"join_key\"] = joinkey\n",
    "\n",
    "# compute the non-private estimator\n",
    "buyeragg = agg_dataset()\n",
    "buyeragg.load(df[buyer_columns + [\"join_key\"]].copy(deep=True), buyer_columns, [\"join_key\"])\n",
    "buyeragg.compute_agg()\n",
    "\n",
    "selleragg = agg_dataset()\n",
    "selleragg.load(df[seller_columns + [\"join_key\"]].copy(deep=True), seller_columns, [\"join_key\"])\n",
    "selleragg.compute_agg()\n",
    "\n",
    "join_train = join_agg(selleragg, buyeragg, \"join_key\")\n",
    "non_privatized_cov = join_train.sum()\n",
    "non_privatized_cov = unbiased_est(non_privatized_cov.copy(deep=True), buyer_columns, seller_columns, num_group, num_rows)\n",
    "non_privatized_parameter = ridge_linear_regression(non_privatized_cov, X, y, ridge)\n",
    "    \n",
    "# FDP-OPT \n",
    "buyeragg = agg_dataset()\n",
    "buyeragg.load(df[buyer_columns + [\"join_key\"]].copy(deep=True), buyer_columns, [\"join_key\"])\n",
    "buyeragg.compute_agg()\n",
    "\n",
    "selleragg = agg_dataset()\n",
    "selleragg.load(df[seller_columns + [\"join_key\"]].copy(deep=True), seller_columns, [\"join_key\"])\n",
    "selleragg.compute_agg()\n",
    "\n",
    "sen1, sen2, sen3 = join_sensitivity_opt(B)\n",
    "r1, r2, r3 = 1/3,1/3,1/3\n",
    "noise1, noise2, noise3 = compute_std(eps*r1, delta*r1, sen1), compute_std(eps*r2, delta*r2, sen2), compute_std(eps*r3, delta*r3, sen3)\n",
    "\n",
    "# impute noise\n",
    "selleragg.agg_dimensions[\"join_key\"]['cov:c'] += np.random.normal(0, noise1, len(selleragg.agg_dimensions[\"join_key\"]))\n",
    "buyeragg.agg_dimensions[\"join_key\"]['cov:c'] += np.random.normal(0, noise1, len(selleragg.agg_dimensions[\"join_key\"]))\n",
    "\n",
    "for col in [string for string in selleragg.semi_ring_columns() if string.startswith('cov:s:')]:\n",
    "    selleragg.agg_dimensions[\"join_key\"][col] += np.random.normal(0, noise2, len(selleragg.agg_dimensions[\"join_key\"]))\n",
    "    \n",
    "for col in [string for string in selleragg.semi_ring_columns() if string.startswith('cov:Q:')]:\n",
    "    selleragg.agg_dimensions[\"join_key\"][col] += np.random.normal(0, noise3, len(selleragg.agg_dimensions[\"join_key\"]))\n",
    "\n",
    "for col in [string for string in buyeragg.semi_ring_columns() if string.startswith('cov:s:')]:\n",
    "    buyeragg.agg_dimensions[\"join_key\"][col] += np.random.normal(0, noise2, len(buyeragg.agg_dimensions[\"join_key\"]))\n",
    "\n",
    "for col in [string for string in buyeragg.semi_ring_columns() if string.startswith('cov:Q:')]:\n",
    "    buyeragg.agg_dimensions[\"join_key\"][col] += np.random.normal(0, noise3, len(buyeragg.agg_dimensions[\"join_key\"]))\n",
    "\n",
    "fdp_opt_train = join_agg(selleragg, buyeragg, \"join_key\")\n",
    "fdp_opt_train_cov = fdp_opt_train.sum()\n",
    "\n",
    "est_num_rows = int((fdp_opt_train_cov[\"cov:c\"]/num_group)**0.5*num_group)\n",
    "\n",
    "if not sanity_check(fdp_opt_train_cov, X, ridge):\n",
    "    print(\"fail\")\n",
    "else:\n",
    "    fdp_opt_cov = unbiased_est(fdp_opt_train_cov.copy(deep=True), buyer_columns, seller_columns, num_group, est_num_rows)\n",
    "    fdp_opt_parameter = ridge_linear_regression(fdp_opt_cov, X, y, ridge)\n",
    "    print(\"beta error\", get_l2_distance(fdp_opt_parameter, non_privatized_parameter))"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": null,
   "id": "52aa7941",
   "metadata": {},
   "outputs": [],
   "source": []
  }
 ],
 "metadata": {
  "kernelspec": {
   "display_name": "Python 3 (ipykernel)",
   "language": "python",
   "name": "python3"
  },
  "language_info": {
   "codemirror_mode": {
    "name": "ipython",
    "version": 3
   },
   "file_extension": ".py",
   "mimetype": "text/x-python",
   "name": "python",
   "nbconvert_exporter": "python",
   "pygments_lexer": "ipython3",
   "version": "3.8.10"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}