Latent_simultion_.ipynb

{
  "nbformat": 4,
  "nbformat_minor": 0,
  "metadata": {
    "colab": {
      "provenance": [],
      "collapsed_sections": [],
      "machine_shape": "hm",
      "authorship_tag": "ABX9TyNDPQ6pTQiKGzgjm81fvbmm",
      "include_colab_link": true
    },
    "kernelspec": {
      "name": "python3",
      "display_name": "Python 3"
    },
    "language_info": {
      "name": "python"
    },
    "gpuClass": "standard"
  },
  "cells": [
    {
      "cell_type": "markdown",
      "metadata": {
        "id": "view-in-github",
        "colab_type": "text"
      },
      "source": [
        "<a href=\"https://colab.research.google.com/github/hereagain-Y/TCR_VAE/blob/main/Latent_simultion_.ipynb\" target=\"_parent\"><img src=\"https://colab.research.google.com/assets/colab-badge.svg\" alt=\"Open In Colab\"/></a>"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "! pip install Biopython"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "ngVcYZoZiEpy",
        "outputId": "907e6156-19e6-4af0-d18a-f6e64f7190f7"
      },
      "execution_count": 1,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Looking in indexes: https://pypi.org/simple, https://us-python.pkg.dev/colab-wheels/public/simple/\n",
            "Collecting Biopython\n",
            "  Downloading biopython-1.79-cp37-cp37m-manylinux_2_5_x86_64.manylinux1_x86_64.whl (2.3 MB)\n",
            "\u001b[K     |████████████████████████████████| 2.3 MB 5.2 MB/s \n",
            "\u001b[?25hRequirement already satisfied: numpy in /usr/local/lib/python3.7/dist-packages (from Biopython) (1.21.6)\n",
            "Installing collected packages: Biopython\n",
            "Successfully installed Biopython-1.79\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "execution_count": 2,
      "metadata": {
        "id": "5wAVMDnIh1Gs"
      },
      "outputs": [],
      "source": [
        "from pkgutil import extend_path\n",
        "import pandas as pd\n",
        "import numpy as np\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "from six.moves import xrange\n",
        "import torch\n",
        "import torch.nn as nn\n",
        "import torchvision.transforms as transforms\n",
        "import numpy as np\n",
        "\n",
        "from tqdm import tqdm\n",
        "from torchvision.utils import save_image, make_grid\n",
        "from torch.utils.data import DataLoader, Subset\n",
        "from sklearn.model_selection import train_test_split\n",
        "#\n",
        "from scipy.spatial import distance\n",
        "import random \n",
        "\n",
        "import random\n",
        "from Bio import pairwise2\n",
        "from Bio.Align import substitution_matrices\n",
        "from scipy import spatial\n",
        "from scipy import stats\n",
        "\n",
        "from google.colab import drive"
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "drive.mount('/content/drive')"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "b0yiOau-iIh_",
        "outputId": "08abfd46-4091-4488-893d-5d940ff81baf"
      },
      "execution_count": 3,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Mounted at /content/drive\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "AAs= ['A', 'R', 'N', 'D', 'C', 'E', 'Q', 'G', 'H', 'I', 'L', 'K', 'M', 'F', 'P', 'S', 'T', 'W', 'Y', 'V']\n",
        "index_code = {}\n",
        "code_index = {}\n",
        "l_max = 20\n",
        "for i in range(len(AAs)):\n",
        "    index_code[i] = AAs[i]\n",
        "    code_index[ AAs[i] ] = i\n",
        "\n",
        "def oneHotEncode(seq, l_max=l_max, index_code=index_code, code_index=code_index):\n",
        "    n_amino = 20\n",
        "    matrix = np.zeros((l_max,n_amino)).astype(int)\n",
        "    for i in range(len(seq)):\n",
        "        matrix[ i , code_index[seq[i]] ] = 1\n",
        "    return matrix\n",
        "\n",
        "# pca encoded \n",
        "pca_index = pd.read_csv(\"/content/drive/My Drive/DL/VAE/AA_indexPCA.csv\")\n",
        "d=pca_index.set_index('Unnamed: 0').T.to_dict('list')\n",
        "\n",
        "\n",
        "# pca normalization\n",
        "data = d.items()\n",
        "list_dat = list(d.values())\n",
        "arr = np.array(list_dat)\n",
        "ex = np.array(arr)\n",
        "ex_norm = (ex-ex.min(axis=0))/(ex.max(axis=0)-ex.min(axis=0))\n",
        "\n",
        "AAs=np.array(list(d.keys()))\n",
        "new_pca = {}\n",
        "\n",
        "for i in np.arange(20):\n",
        "    new_pca[AAs[i]]=ex_norm[i]\n",
        "\n",
        "new_pca\n",
        "d= new_pca\n",
        "\n",
        "def AAindexEncoding(Seq):\n",
        "    length_seq=len(Seq)\n",
        "    global l_max\n",
        "    AAE=np.zeros([l_max,20])\n",
        "    if length_seq<l_max:\n",
        "        for amino in range(length_seq):\n",
        "            AA=Seq[amino]# \n",
        "            AAE[amino,]=d[AA] # add PC value \n",
        "            \n",
        "        for amino in range(length_seq,l_max):\n",
        "            AAE[amino,]=np.zeros(20)\n",
        "    else: \n",
        "        for amino in range(length_seq): # zero padding\n",
        "            AA=Seq[amino]# \n",
        "            AAE[amino,]=d[AA]\n",
        "        \n",
        "    #AAE=np.transpose(AAE.astype(np.float32)) # row as PC. and column as AA sequence \n",
        "    return AAE \n",
        "\n",
        "  \n",
        "def GetFeatures(file):\n",
        "    hot_encode=[]\n",
        "    for seq in file:\n",
        "        hot_encode.append(AAindexEncoding(seq))\n",
        "    hot_encode=np.array(hot_encode)\n",
        "    result=np.array(hot_encode)\n",
        "    return(result)"
      ],
      "metadata": {
        "id": "97qD-AIWiKSp"
      },
      "execution_count": 4,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "matrix = substitution_matrices.load('BLOSUM62')\n",
        "#from Bio.SubsMat import MatrixInfo as matlist\n",
        "#matrix = matlist.blosum62\n",
        "#in 80 max penalty for substitution is -6,\n",
        "open_penalty = -4\n",
        "gap_penalty = -4\n",
        "#\n",
        "def parseMatrix(m):\n",
        "    re = {}\n",
        "    alpha = m.alphabet\n",
        "    for i in range(len(alpha)):\n",
        "        for j in range(i,len(alpha)):\n",
        "            re[(alpha[i],alpha[j])] = m[i,j]\n",
        "    return re\n",
        "align_matrix =  parseMatrix(substitution_matrices.load('BLOSUM62'))"
      ],
      "metadata": {
        "id": "LrTTEgTmiWht"
      },
      "execution_count": 5,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "seq_test = pd.read_csv('/content/drive/My Drive/DL/VAE/NormalCDR3_test.txt',delimiter='\\t',header=None,names=['seq'])\n",
        "seq_test['length'] = [len(seq) for seq in seq_test['seq']]\n",
        "\n",
        "seq_test = seq_test[ seq_test['length']<=20 ]\n",
        "seq = list( seq_test['seq'] )\n",
        "# random select 10000 sequences \n",
        "seq_x = random.sample(seq,5000)\n",
        "seq_y = random.sample(seq,5000)"
      ],
      "metadata": {
        "id": "TOqtI6GAjCCV"
      },
      "execution_count": 6,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "class VAE(nn.Module):\n",
        "    def __init__(self,h_dim=64*10*10, z_dim=32):\n",
        "        super(VAE, self).__init__()\n",
        "        self.encoder = nn.Sequential(\n",
        "            \n",
        "            nn.Conv2d(1, 16, kernel_size=5, stride=1), #16\n",
        "            nn.ReLU(),\n",
        "            nn.Conv2d(16, 32, kernel_size=5, stride=1), # 12\n",
        "            nn.ReLU(),\n",
        "            nn.Conv2d(32, 64, kernel_size=3, stride=1), #10\n",
        "            nn.ReLU()\n",
        "        \n",
        "        )\n",
        "\n",
        "        \n",
        "        \n",
        "        # mean 64*5*5 =\n",
        "        self.fc1 = nn.Linear(h_dim, z_dim)\n",
        "        # var \n",
        "        self.fc2 = nn.Linear(h_dim, z_dim)\n",
        "        # for decoder layer \n",
        "        self.fc3 = nn.Linear(z_dim, h_dim)\n",
        "        \n",
        "        self.decoder = nn.Sequential(\n",
        "            \n",
        "   \n",
        "            nn.ConvTranspose2d(64, 32, kernel_size=3, stride=1),\n",
        "            nn.ReLU(),\n",
        "            nn.ConvTranspose2d(32, 16, kernel_size=5, stride=1),\n",
        "            nn.ReLU(),\n",
        "            nn.ConvTranspose2d(16, 1, kernel_size=5, stride=1),\n",
        "            nn.Sigmoid()\n",
        "        )\n",
        "        \n",
        "    def reparameterize(self, mu):\n",
        "        #std = logvar.mul(0.5).exp_()\n",
        "        # return torch.normal(mu, std)\n",
        "        #esp = torch.randn(*mu.size())\n",
        "        z = mu\n",
        "        return z\n",
        "    \n",
        "    def bottleneck(self, h):\n",
        "        mu= self.fc1(h)\n",
        "        z = self.reparameterize(mu)\n",
        "        return mu, z\n",
        "        \n",
        "    def representation(self, x):\n",
        "        return self.bottleneck(self.encoder(x))[0] # latent layer \n",
        "\n",
        "        \n",
        "    \n",
        "    #def alignmentscore(self,x,y):\n",
        "    #    scores = pairwise2.align.localds(x,y,align_matrix,open=open_penalty,extend=gap_penalty)\n",
        "    #    score_align = scores[0].score\n",
        "    #    return score_align\n",
        "        \n",
        "    def latent(self,x,y):\n",
        "        l1 = self.encoder(x)# 32\n",
        "        l1 = l1.view(-1,64*10*10) # 32\n",
        "        l1, mu1 = self.bottleneck(l1)\n",
        "\n",
        "        l2 = self.encoder(y)# 32\n",
        "        l2 = l2.view(-1,64*10*10) # 32\n",
        "        l2, mu2 = self.bottleneck(l2)\n",
        "        # use cos-simialrity\n",
        "        #latent_dist =np.sqrt( np.sum(np.square(l1 - l2)) )\n",
        "        \n",
        "        \n",
        "        return l1,l2\n",
        "\n",
        "    def forward(self, x,y):\n",
        "      # for dataset 1\n",
        "        h1= self.encoder(x)\n",
        "        h1 = h1.view(-1,64*10*10)\n",
        "        z1, mu1 = self.bottleneck(h1) #\n",
        "        z1 = self.fc3(z1) # 64*10*10\n",
        "        z1 = z1.view(-1,64,10,10)\n",
        "        z1 = self.decoder(z1)\n",
        "      # for dat2   \n",
        "        h2= self.encoder(y)\n",
        "        h2 = h2.view(-1,64*10*10)\n",
        "        z2, mu2 = self.bottleneck(h2)\n",
        "        z2 = self.fc3(z2)\n",
        "        z2 = z2.view(-1,64,10,10)\n",
        "        z2 = self.decoder(z2)\n",
        "        \n",
        "        # aligment \n",
        "        #s = self.alignmentscore(x,y)\n",
        "        # latent distance\n",
        "        l1,l2 = self.latent(x,y)\n",
        "        \n",
        "        \n",
        "        \n",
        "        return z1, mu1,z2,mu2,l1,l2"
      ],
      "metadata": {
        "id": "SyecqKZuiZFq"
      },
      "execution_count": 7,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "device = \"cpu\""
      ],
      "metadata": {
        "id": "hoLDW5RVjU8G"
      },
      "execution_count": 10,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = VAE(h_dim=64*10*10, z_dim=32).to(device)"
      ],
      "metadata": {
        "id": "JmD4txMTihyF"
      },
      "execution_count": 11,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "model = torch.load('/content/drive/MyDrive/DL/CNNVAE/Paired_sigmoid_modified_1000_echo_cat_train.apx')"
      ],
      "metadata": {
        "id": "-0WwxmVOiiwA"
      },
      "execution_count": 12,
      "outputs": []
    },
    {
      "cell_type": "markdown",
      "source": [
        "Start simulation "
      ],
      "metadata": {
        "id": "mEJPBn2XioQk"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "\n",
        "n = 10000\n",
        "df_out = pd.DataFrame(columns=['seq1','seq2','alignment_score','latent_dist'])\n",
        "\n",
        "for i in range(n):\n",
        "    if i % 1000 == 0:\n",
        "        print(i)\n",
        "    seq1 = random.sample(seq_x, 1)[0]\n",
        "    seq2 = random.sample(seq_y, 1)[0]\n",
        "    #seq1\n",
        "    mat2 = AAindexEncoding(seq1) # 20*20\n",
        "    #matrix =mat2.reshape((800,))\n",
        "    matrix3 = torch.from_numpy(mat2).float()\n",
        "    # reshape the size \n",
        "    matrix3 = matrix3.view(1,1,20,20)\n",
        "   \n",
        "    #seq2\n",
        "    mat4 = AAindexEncoding(seq2)\n",
        "    #matrix = np.concatenate((mat3,mat4),axis=1).reshape((800,))\n",
        "    matrix4 = torch.from_numpy(mat4).float()\n",
        "    matrix4 = matrix4.view(1,1,20,20)\n",
        "    \n",
        "    latent1  =  model(matrix3,matrix4)[4].cpu().detach().numpy()\n",
        "    latent2  =  model(matrix3,matrix4)[5].cpu().detach().numpy()\n",
        "   \n",
        "    \n",
        "    #alignments\n",
        "    alignments = pairwise2.align.localds(seq1, seq2, align_matrix, open=open_penalty, extend=gap_penalty)\n",
        "    score_align = alignments[0].score\n",
        "    #\n",
        "    latent_dist = np.sqrt( np.sum(np.square(latent1 - latent2)) )\n",
        "    df_out.loc[len(df_out)] = [seq1, seq2, score_align, latent_dist]\n",
        "\n",
        "df_out.to_csv('/content/drive/MyDrive/DL/CNNVAE/Deepcat_data_latent_score1.csv',index=False)\n",
        "\n",
        "import seaborn as sns\n",
        "from scipy import stats\n",
        "import matplotlib.pyplot as plt\n",
        "\n",
        "print(\"start plotting\")\n",
        "sns.scatterplot(x='alignment_score',y='latent_dist',data=df_out,s=4)\n",
        "#sns.lmplot(x='alignment_score',y='latent_dist',data=distance)\n",
        "r,p =stats.pearsonr(df_out['alignment_score'], df_out['latent_dist'])\n",
        "print(r)\n",
        "plt.text(10, 200, 'r={:.2f}'.format(r))\n",
        "plt.savefig('/content/drive/MyDrive/DL/CNNVAE/aligment_score.png')\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/",
          "height": 494
        },
        "id": "uqR-lc50in_E",
        "outputId": "9c4d3c33-bbde-4c78-8970-ba74752626a4"
      },
      "execution_count": 23,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "0\n",
            "1000\n",
            "2000\n",
            "3000\n",
            "4000\n",
            "5000\n",
            "6000\n",
            "7000\n",
            "8000\n",
            "9000\n",
            "start plotting\n",
            "-0.313735742191133\n"
          ]
        },
        {
          "output_type": "display_data",
          "data": {
            "text/plain": [
              "<Figure size 432x288 with 1 Axes>"
            ],
            "image/png": "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\n"
          },
          "metadata": {
            "needs_background": "light"
          }
        }
      ]
    },
    {
      "cell_type": "markdown",
      "source": [
        "Sequence reconstruction "
      ],
      "metadata": {
        "id": "am09ne9omatG"
      }
    },
    {
      "cell_type": "code",
      "source": [
        "print('Read Seq')\n",
        "seq_test = pd.read_csv('/content/drive/My Drive/DL/VAE/NormalCDR3_test.txt',delimiter='\\t',header=None,names=['seq'])\n",
        "seq_test['length'] = [len(seq) for seq in seq_test['seq']]\n",
        "#select seqs <=20 length\n",
        "seq_test = seq_test[ seq_test['length']<=20 ]\n",
        "seq = list( seq_test['seq'] )\n",
        "\n",
        "\n",
        "seq_x = random.sample(seq,5000)\n",
        "seq_y = random.sample(seq,5000)\n",
        "\n",
        "\n",
        "\n",
        "AA_matx= GetFeatures(seq_x)\n",
        "AA_maty= GetFeatures(seq_y)\n",
        "\n",
        "\n",
        "r1_transform_x=torch.from_numpy(AA_matx).float()\n",
        "r1_transform_y=torch.from_numpy(AA_maty).float()\n",
        "\n",
        "\n",
        "\n",
        "m1 =r1_transform_x.view(len(r1_transform_x),1,20,20)\n",
        "m2 =r1_transform_y.view(len(r1_transform_y),1,20,20)\n",
        "x_hat = model(m1,m2)[0]\n",
        "y_hat = model(m1,m2)[2]\n",
        "# get encoding layer? #1000, 20,20\n",
        "#mat2 = model(m2)[2] \n",
        "result1= x_hat.view( 5000,20,20).cpu().detach().numpy()\n",
        "\n",
        "result2= y_hat.view( len(y_hat),20,20 ).cpu().detach().numpy()\n",
        "\n",
        "\n",
        "\n",
        "def Reverse(dict, data):\n",
        "    re=np.zeros(20)\n",
        "        \n",
        "    for i in range(len(data)):\n",
        "        if np.sum(data)==0:\n",
        "            re[i]=0\n",
        "        else: \n",
        "            a_min = dict.min(axis=0)[i]\n",
        "            b_max = dict.max(axis=0)[i]\n",
        "            re[i]= data[i]*(b_max-a_min)+(a_min)\n",
        "    return re\n",
        "\n",
        "\n",
        "\n",
        "def Reversematrix (dict,matrix):\n",
        "\n",
        "    result = []\n",
        "    for i in range(len(matrix)):\n",
        "        result.append(Reverse(dict,matrix[i]))\n",
        "    return np.array(result)\n",
        "## d to array \n",
        "\n",
        "list_dat = list(d.values())\n",
        "arr = np.array(list_dat)\n",
        "ex = np.array(arr)\n",
        "# reverse to original array \n",
        "\n",
        "seq_decode1 = []\n",
        "for i in range(len(result1)):\n",
        "\n",
        "    seq_decode1.append(Reversematrix(ex, result1[i]))\n",
        "    \n",
        "seq_decode2 = []\n",
        "for i in range(len(result2)):\n",
        "\n",
        "    seq_decode2.append(Reversematrix(ex, result2[i]))\n",
        "    \n",
        "print(\"reverted to original scale!\")\n",
        "    \n",
        "print(\"==start reconstuction!--\")\n",
        "# \n",
        "\n",
        "   \n",
        "def reconstructSequence(dict,data):\n",
        "  result = []\n",
        "  for i in range(len(data)):\n",
        "    currentSeq= ''\n",
        "    dict_index=list(dict.keys())\n",
        "    if(i%1000==0):\n",
        "      print(str(i/len(data)*100)+'%')\n",
        "    for j in range(len(data[i])):\n",
        "      row = data[i][j]\n",
        "      max_value= np.max(row)\n",
        "      if max_value <= 0.1:\n",
        "        continue\n",
        "      #calculate distance\n",
        "      dist = []\n",
        "      for key, value in dict.items():\n",
        "        dist.append(distance.euclidean(dict[key], row))\n",
        "      currentSeq += dict_index[np.argmin(dist)]\n",
        "    result.append(currentSeq)\n",
        "  return result  \n",
        "\n",
        "\n",
        "\n",
        "seq_decode1= reconstructSequence(d,seq_decode1)\n",
        "\n",
        "seq_decode2= reconstructSequence(d,seq_decode2)\n",
        "print(\"Sequence reconstructed!\")\n",
        "\n",
        "#seq_decode2= ReconstructSeq(result2)\n",
        "df = pd.DataFrame(columns=['seq_original_x','seq_original_y','seq_model_x','seq_model_y'])\n",
        "df['seq_original'] = seq_x\n",
        "df['seq_original_y']=seq_y\n",
        "\n",
        "df['seq_model_x'] = seq_decode1\n",
        "df['seq_model_y'] = seq_decode2\n",
        "\n",
        "print(\"calculate accuracy\")\n",
        "print( len(df[df['seq_original_x']==df['seq_model_x']])/len(df) )\n",
        "print( len(df[df['seq_original_y']==df['seq_model_y']])/len(df) )\n",
        "\n",
        "df.to_csv('/content/drive/MyDrive/DL/CNNVAE/pairedAE_test_AA_seq1.csv',index=False)\n",
        "\n",
        "        "
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "AbAGTCgymaRS",
        "outputId": "2c5d2b2c-71cc-4370-e665-fc0fd1cfd808"
      },
      "execution_count": 32,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "Read Seq\n",
            "reverted to original scale!\n",
            "==start reconstuction!--\n",
            "0.0%\n",
            "20.0%\n",
            "40.0%\n",
            "60.0%\n",
            "80.0%\n",
            "0.0%\n",
            "20.0%\n",
            "40.0%\n",
            "60.0%\n",
            "80.0%\n",
            "Sequence reconstructed!\n",
            "calculate accuracy\n",
            "0.0\n",
            "0.3868\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "r1_transform_x=torch.from_numpy(AA_matx).float()\n",
        "r1_transform_y=torch.from_numpy(AA_maty).float()\n",
        "\n",
        "\n",
        "\n",
        "m1 =r1_transform_x.view(len(r1_transform_x),1,20,20)\n",
        "m2 =r1_transform_y.view(len(r1_transform_y),1,20,20)"
      ],
      "metadata": {
        "id": "gZq0VeHhppkm"
      },
      "execution_count": null,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "print(m1.shape)\n",
        "x_hat = model(m1,m2)[0]\n"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "IlLd1BdhpuD4",
        "outputId": "20be9e7f-f900-4cc2-b65f-64c70838ae03"
      },
      "execution_count": 27,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([5000, 1, 20, 20])\n",
            "5000\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "print(x_hat.shape)"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "WI9vCjOPsDJN",
        "outputId": "27f0105b-1866-415a-8c8f-4f01322d0f96"
      },
      "execution_count": 28,
      "outputs": [
        {
          "output_type": "stream",
          "name": "stdout",
          "text": [
            "torch.Size([5000, 1, 20, 20])\n"
          ]
        }
      ]
    },
    {
      "cell_type": "code",
      "source": [
        "result1= x_hat.view( 5000,20,20 ).cpu().detach().numpy()"
      ],
      "metadata": {
        "id": "wVo64YfSsN9N"
      },
      "execution_count": 31,
      "outputs": []
    },
    {
      "cell_type": "code",
      "source": [
        "result1.shape"
      ],
      "metadata": {
        "colab": {
          "base_uri": "https://localhost:8080/"
        },
        "id": "awwqFWazsO0R",
        "outputId": "0e520845-b67c-48a8-ccbb-0967fe0ab620"
      },
      "execution_count": 30,
      "outputs": [
        {
          "output_type": "execute_result",
          "data": {
            "text/plain": [
              "(5000, 1, 20, 20)"
            ]
          },
          "metadata": {},
          "execution_count": 30
        }
      ]
    }
  ]
}