synthetic_data_s2.ipynb

{
 "cells": [
  {
   "cell_type": "code",
   "execution_count": 1,
   "id": "3405bd25",
   "metadata": {
    "id": "3405bd25"
   },
   "outputs": [],
   "source": [
    "import torch\n",
    "import math\n",
    "import numpy as np\n",
    "import pickle\n",
    "import random\n",
    "\n",
    "torch.manual_seed(11)\n",
    "np.random.seed(11)\n",
    "random.seed(11)"
   ]
  },
  {
   "cell_type": "markdown",
   "id": "61aaef9c",
   "metadata": {
    "id": "61aaef9c"
   },
   "source": [
    "### Data Generation"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 2,
   "id": "6cfa9699",
   "metadata": {},
   "outputs": [],
   "source": [
    "DATA_NUM = 16000\n",
    "CLUSTER_NUM = 4\n",
    "EXPERT_NUM = 8\n",
    "PATCH_NUM = 4\n",
    "PATCH_LEN = 50"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 3,
   "id": "49b853f1",
   "metadata": {},
   "outputs": [
    {
     "name": "stdout",
     "output_type": "stream",
     "text": [
      "torch.Size([32000, 200])\n",
      "torch.Size([32000])\n",
      "torch.Size([16000, 1, 200]) torch.Size([16000, 1, 200])\n",
      "torch.Size([16000]) torch.Size([16000])\n"
     ]
    }
   ],
   "source": [
    "features = torch.zeros(CLUSTER_NUM, PATCH_LEN)\n",
    "x = np.random.randn(PATCH_LEN) \n",
    "x /= np.linalg.norm(x)\n",
    "current_x = []\n",
    "for i in range(CLUSTER_NUM):\n",
    "    features[i] = torch.tensor(x)\n",
    "    current_x.append(x)\n",
    "    x = np.random.randn(PATCH_LEN) \n",
    "    x /= np.linalg.norm(x)\n",
    "    for x_prev in current_x:\n",
    "        x -= x.dot(x_prev) * x_prev\n",
    "    x /= np.linalg.norm(x)\n",
    "\n",
    "centers = torch.zeros(CLUSTER_NUM, PATCH_LEN)\n",
    "for i in range(CLUSTER_NUM):\n",
    "    centers[i] = torch.tensor(x)\n",
    "    if i!=3:\n",
    "        current_x.append(x)\n",
    "        x = np.random.randn(PATCH_LEN) \n",
    "        x /= np.linalg.norm(x)\n",
    "        for x_prev in current_x:\n",
    "            x -= x.dot(x_prev) * x_prev\n",
    "        x /= np.linalg.norm(x)\n",
    "\n",
    "\n",
    "data = []\n",
    "labels = []\n",
    "train_cluster_idx = [[] for x in range(CLUSTER_NUM)]\n",
    "test_cluster_idx = [[] for x in range(CLUSTER_NUM)]\n",
    "\n",
    "for i in range(DATA_NUM*2):\n",
    "    y = np.random.choice([-1,1], 1)[0] \n",
    "    k = np.random.choice(list(range(0,CLUSTER_NUM)))\n",
    "    \n",
    "    if i < DATA_NUM:\n",
    "        train_cluster_idx[k].append(i)\n",
    "    else:\n",
    "        test_cluster_idx[k].append(i-DATA_NUM)\n",
    "\n",
    "    # Noise patch\n",
    "    xi = torch.tensor(np.random.normal(0, 2/math.sqrt(PATCH_LEN), size=(PATCH_LEN)))\n",
    "    \n",
    "    # Feature noise patch\n",
    "    pos_or_neg = np.random.choice([-1,1], 1)[0]\n",
    "    k_noise = np.random.choice(list(set(range(0,CLUSTER_NUM))-set([int(k)])))\n",
    "    alpha, beta, gamma = np.random.uniform(0.5,2), np.random.uniform(1,2), np.random.uniform(0.5,3)\n",
    "\n",
    "    x = torch.stack([features[k]*y*alpha, centers[k]*beta, xi, \n",
    "                     pos_or_neg*features[k_noise]*gamma])\n",
    "    \n",
    "    # random permutation\n",
    "    idx = torch.randperm(len(x))\n",
    "    x = x[idx].flatten()\n",
    "\n",
    "    data.append(x)\n",
    "    labels.append(y)\n",
    "\n",
    "data = torch.stack(data)\n",
    "print(data.shape)\n",
    "\n",
    "labels = torch.tensor(labels)\n",
    "labels[labels==-1] = 0\n",
    "print(labels.shape)\n",
    "\n",
    "training_data = data[:DATA_NUM,:].unsqueeze(1).float()\n",
    "test_data = data[DATA_NUM::].unsqueeze(1).float()\n",
    "print(training_data.shape, test_data.shape)\n",
    "\n",
    "training_labels = labels[:DATA_NUM]\n",
    "test_labels = labels[DATA_NUM:]\n",
    "print(training_labels.shape, test_labels.shape)\n",
    "\n",
    "training_data, test_data = training_data.cuda(), test_data.cuda()\n",
    "training_labels, test_labels = training_labels.cuda(), test_labels.cuda()\n",
    "training_labels = training_labels.long()\n",
    "test_labels = test_labels.long()\n",
    "centers, features = centers.cuda(), features.cuda()\n",
    "training_data *= 10\n",
    "test_data *= 10\n",
    "# Below does not affect training, just for plotting\n",
    "centers *= 10\n",
    "features *= 10"
   ]
  },
  {
   "cell_type": "code",
   "execution_count": 4,
   "id": "476f9e92",
   "metadata": {},
   "outputs": [],
   "source": [
    "torch.save(training_data, 'synthetic_data_s2/train_data.pt')\n",
    "torch.save(training_labels, 'synthetic_data_s2/train_labels.pt')\n",
    "\n",
    "torch.save(test_data, 'synthetic_data_s2/test_data.pt')\n",
    "torch.save(test_labels, 'synthetic_data_s2/test_labels.pt')\n",
    "\n",
    "torch.save(centers, 'synthetic_data_s2/centers.pt')\n",
    "torch.save(features, 'synthetic_data_s2/features.pt')\n",
    "\n",
    "with open(\"synthetic_data_s2/train_cluster\", \"wb\") as fp:  \n",
    "    pickle.dump(train_cluster_idx,fp)\n",
    "    \n",
    "with open(\"synthetic_data_s2/test_cluster\", \"wb\") as fp:  \n",
    "    pickle.dump(test_cluster_idx,fp)"
   ]
  }
 ],
 "metadata": {
  "accelerator": "GPU",
  "colab": {
   "collapsed_sections": [],
   "name": "Copy of tensorpowernew.ipynb",
   "provenance": []
  },
  "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.7.9"
  }
 },
 "nbformat": 4,
 "nbformat_minor": 5
}