From cadbbb635598638219f8d5e2ee0a00fa30e56d12 Mon Sep 17 00:00:00 2001
From: Xiang Cheng <chengx@suvrit-gpus.lids.mit.edu>
Date: Thu, 16 Nov 2023 16:57:24 -0500
Subject: [PATCH] updated to remove sparsity constriant

---
 linear_transformer_unconstrained.py | 241 ++++++++++++
 nonlinear_regression.ipynb          | 561 ----------------------------
 2 files changed, 241 insertions(+), 561 deletions(-)
 create mode 100644 linear_transformer_unconstrained.py
 delete mode 100644 nonlinear_regression.ipynb

diff --git a/linear_transformer_unconstrained.py b/linear_transformer_unconstrained.py
new file mode 100644
index 0000000..a0bc64a
--- /dev/null
+++ b/linear_transformer_unconstrained.py
@@ -0,0 +1,241 @@
+###########################################
+# This file contains the following:
+# 1. Linear Transformer Model
+# 2. Function for clipping gradient
+# 3. Function for generating random data
+#
+# The notation for linear attention follows
+# the paper at https://arxiv.org/pdf/2306.00297.pdf
+###########################################
+
+
+import torch
+from torch import nn
+import numpy as np
+
+device = torch.device("cuda" if torch.cuda.is_available() else "cpu")
+
+# Definition of a single linear attention unit for linear-regression data
+# P is the value matrix
+# Q is the product of key,query matrices
+# the dimensions of the input are
+# B: batch-size of prompts
+# N: context length (excluding query)
+# d: covariate dimension
+# P,Q are d x d matrices
+# Z is a B x (N+1) + (d+1) matrix
+# Output is also B x (N+1) + (d+1)
+
+# For linear attention, activation = None
+# For standard attention, activation(x) = torch.nn.functional.softmax(x, dim = 2)
+# For ReLU attention, activation(x) = torch.nn.relu(x)
+def attention(P,Q,Z, activation = None):
+    B= Z.shape[0]
+    N = Z.shape[1]-1
+    d = Z.shape[2]-1
+    P_full = P
+    Q_full = Q
+    A = torch.eye(N+1).to(device)
+    A[N,N] = 0
+    Attn = torch.einsum('BNi, ij, BMj -> BNM', (Z,Q_full,Z))
+    if activation is not None:
+        Attn = activation(Attn)
+    key = torch.einsum('ij, BNj -> BNi', (P_full,Z))
+    Output = torch.einsum('BNM,ML, BLi -> BNi', (Attn,A,key))
+    return Output /N
+
+
+# The Linear Transformer module
+# n_layer denotes the number of layers
+# n_head denotes the number of heads. In most of our experiments, n_head = 1
+# d denotes the dimension of covariates
+# var denotes the variance of initialization. It needs to be sufficiently small, but exact value is not important
+# allparam: contains all the parameters, has dimension n_layer x n_head x 2 x d x d
+# For example
+# - P matrix at layer i, head j is allparam[i,j,0,:,:]
+# - Q matrix at layer i, head j is allparam[i,j,1,:,:]
+class Transformer_F(nn.Module):
+    def __init__(self, n_layer, n_head, d, var):
+        super(Transformer_F, self).__init__()
+        self.register_parameter('allparam', torch.nn.Parameter(torch.zeros(n_layer, n_head, 2, d+1, d+1)))
+        with torch.no_grad():
+            self.allparam.normal_(0,var)
+        self.n_layer = n_layer
+        self.n_head = n_head
+
+    def forward(self, Z):
+        for i in range(self.n_layer):
+            Zi = Z
+            residues = 0
+            # the forwarad map of each layer is given by F(Z) = Z + attention(Z)
+            for j in range(self.n_head):
+                Pij = self.allparam[i,j,0,:,:]
+                Qij = self.allparam[i,j,1,:,:]
+                residues = residues + attention(Pij,Qij,Zi)
+            Z = Zi + residues
+        return Z
+    
+    #enforces top-left-dxd-block sparsity on p
+    def zero_p(self):
+        for i in range(self.n_layer):
+            for j in range(self.n_head):
+                with torch.no_grad():
+                    self.allparam[i,j,0,:,:].zero_()
+
+# evaluate the loss of model, given data (Z,y)
+def in_context_loss(model, Z, y):
+    N = Z.shape[1]-1
+    d = Z.shape[2]-1
+    output = model(Z)
+    diff = output[:,N,d]+y
+    loss = ((diff)**2).mean() 
+    return loss
+        
+# generate random data for linear regression
+# mode: distribution of samples to generate. Currently supports 'normal', 'gamma', 'sphere'
+# N: number of context examples
+# d: dimension of covariates
+# For gamma distribution:
+# - shape_k: shape parameter of gamma distribution (unused otherwise)
+# - scale parameter: hard coded so that when shape_k = 5/2 and d=5, the generated data is standard normal
+def generate_data(mode='normal',N=20,d=1,B=1000,shape_k=0.1, U=None, D=None):
+    W= torch.FloatTensor(B, d).normal_(0,1).cuda()
+    X = torch.FloatTensor(B, N, d).normal_(0, 1).cuda()
+    X_test = torch.FloatTensor(B,1,d).normal_(0, 1).cuda()
+    
+    if U is not None:
+        U = U.cuda()
+        D = D.cuda()
+        W= torch.FloatTensor(B, d).normal_(0,1).cuda()
+        W = torch.mm(W,torch.inverse(D))
+        W = torch.mm(W,U.t())
+    
+    if mode =='sphere':
+        X.div_(X.norm(p=2,dim=2)[:,:,None])
+        X_test.div_(X_test.norm(p=2,dim=2)[:,:,None])
+    elif mode == 'gamma':
+        # random gamma scaling for X
+        gamma_scales = np.random.gamma(shape=shape_k, scale=(10/shape_k)**(0.5), size=[B,N])
+        gamma_scales = torch.Tensor(gamma_scales).cuda()
+        gamma_scales = gamma_scales.sqrt()
+        # random gamma scaling for X_test
+        gamma_test_scales = np.random.gamma(shape=shape_k, scale=(10/shape_k)**(0.5), size=[B,1])
+        gamma_test_scales = torch.Tensor(gamma_test_scales).cuda()
+        gamma_test_scales = gamma_test_scales.sqrt()
+        # normalize to unit norm
+        X.div_(X.norm(p=2,dim=2)[:,:,None])
+        X_test.div_(X_test.norm(p=2,dim=2)[:,:,None])
+        # scale by gamma
+        X.mul_(gamma_scales[:,:,None])
+        X_test.mul_(gamma_test_scales[:,:,None])
+    elif mode =='normal':
+        assert True
+    elif mode == 'relu':
+        return generate_data_relu(N=N, d=d, B=B, hidden_dim=d)
+    elif mode == 'mlp':
+        generate_data_mlp(N=N, d=d, B=B, hidden_dim=d)
+    else:
+        assert False
+        
+    if U is not None:
+        X = torch.einsum('ij, jk, BNk -> BNi', (U,D,X))
+        X_test = torch.einsum('ij, jk, BNk -> BNi', (U,D,X_test))
+        
+    y = torch.einsum('bi,bni->bn', (W, X)).unsqueeze(2)
+    y_zero = torch.zeros(B,1,1).cuda()
+    y_test = torch.einsum('bi,bni->bn', (W, X_test)).squeeze(1)
+    X_comb= torch.cat([X,X_test],dim=1)
+    y_comb= torch.cat([y,y_zero],dim=1)
+    Z= torch.cat([X_comb,y_comb],dim=2)
+    return Z.to(device),y_test.to(device)
+
+def generate_data_inplace(Z, U=None, D=None):
+    
+    
+    B = Z.shape[0]
+    N = Z.shape[1]-1
+    d = Z.shape[2]-1
+    X = Z[:,:,0:-1]
+    X.normal_(0, 1).cuda()
+    W= torch.FloatTensor(B, d).normal_(0,1).cuda()
+    if U is not None:
+        U = U.cuda()
+        D = D.cuda()
+        W = torch.mm(W,torch.inverse(D))
+        W = torch.mm(W,U.t())
+        Z[:,:,0:-1] = torch.einsum('ij, jk, BNk -> BNi', (U,D,X))
+        
+    Z[:,:,-1] = torch.einsum('bi,bni->bn', (W, Z[:,:,0:-1])) #y update
+    y_test = Z[:,-1,-1].detach().clone()
+    Z[:,-1,-1].zero_()
+    return Z.to(device),y_test.to(device)
+
+def generate_data_sine(N=10, B=1000):
+    # Sample amplitude a and phase p for each task
+    a = torch.FloatTensor(B).uniform_(0.1, 5).cuda()
+    p = torch.FloatTensor(B).uniform_(0, math.pi).cuda()
+ 
+    X = torch.FloatTensor(B, N).uniform_(-5, 5).cuda()
+ 
+    Y = a.unsqueeze(1) * torch.sin(p.unsqueeze(1) + X)
+ 
+    X = X.unsqueeze(-1)
+    Y = Y.unsqueeze(-1)
+
+    return X, Y
+
+def generate_data_relu(mode='normal', N=20, d=1, B=1000, shape_k=0.1, U=None, D=None, hidden_dim=100):
+    # Generate random input data
+    X = torch.FloatTensor(B, N, d).normal_(0, 1).to(device)
+    X_test = torch.FloatTensor(B, 1, d).normal_(0, 1).to(device)
+
+    # Additional transformations if mode is 'sphere' or 'gamma' [Similar to the existing generate_data function]
+
+    # Define a 1-hidden layer ReLU network
+    model = nn.Sequential(
+        nn.Linear(d, hidden_dim),
+        nn.ReLU(),
+        nn.Linear(hidden_dim, 1)
+    ).to(device)
+    model[0].weight.data.normal_(0, 0.1)
+    model[2].weight.data.normal_(0, 0.1)
+
+    # Generate y values using the ReLU network
+    y = model(X.view(-1, d)).view(B, N, 1)
+    y_test = model(X_test.view(-1, d)).view(B, 1).squeeze(1)
+ 
+    y_zero = torch.zeros(B, 1, 1).to(device)
+    X_comb = torch.cat([X, X_test], dim=1)
+    y_comb = torch.cat([y, y_zero], dim=1)
+    Z = torch.cat([X_comb, y_comb], dim=2)
+
+    return Z, y_test
+
+def generate_data_mlp(N=20, d=1, B=1000, hidden_dim=100):
+    # Generate random input data
+    X = torch.FloatTensor(B, N, d).normal_(0, 1).to(device)
+    X_test = torch.FloatTensor(B, 1, d).normal_(0, 1).to(device)
+
+    # Additional transformations if mode is 'sphere' or 'gamma' [Similar to the existing generate_data function]
+
+    # Define a 1-hidden layer ReLU network
+    model = nn.Sequential(
+        nn.Linear(d, hidden_dim),
+        nn.ReLU(),
+        nn.Linear(hidden_dim, d)
+    ).to(device)
+    model[0].weight.data.normal_(0, 1)
+    model[2].weight.data.normal_(0, 1)
+
+    X_MLP = model(X.view(-1, d)).view(B, N, d)
+    X_test_MLP = model(X_test.view(-1, d)).view(B, 1, d)
+
+    W = torch.FloatTensor(B, d).normal_(0,1).cuda()
+    y = torch.einsum('bi,bni->bn', (W, X_MLP)).unsqueeze(2)
+    y_zero = torch.zeros(B,1,1).cuda()
+    y_test = torch.einsum('bi,bni->bn', (W, X_test_MLP)).squeeze(1)
+    X_comb= torch.cat([X_MLP,X_test_MLP],dim=1)
+    y_comb= torch.cat([y,y_zero],dim=1)
+    Z= torch.cat([X_comb,y_comb],dim=2)
+
+    return Z, y_test
\ No newline at end of file
diff --git a/nonlinear_regression.ipynb b/nonlinear_regression.ipynb
deleted file mode 100644
index c6f130a..0000000
--- a/nonlinear_regression.ipynb
+++ /dev/null
@@ -1,561 +0,0 @@
-{
-  "cells": [
-    {
-      "cell_type": "code",
-      "execution_count": 2,
-      "metadata": {
-        "colab": {
-          "base_uri": "https://localhost:8080/",
-          "height": 1000
-        },
-        "id": "7soBJnRez5fP",
-        "outputId": "05efbb5d-4d89-4d57-b1ab-2ee56192d1df"
-      },
-      "outputs": [
-        {
-          "output_type": "stream",
-          "name": "stdout",
-          "text": [
-            "Training with adam optimizer, Learning Rate: 0.001\n",
-            "Epoch 0, Loss: 0.4412432312965393\n",
-            "Epoch 100, Loss: 0.3081362843513489\n",
-            "Epoch 200, Loss: 0.19330720603466034\n",
-            "Epoch 300, Loss: 0.10414648801088333\n",
-            "Epoch 400, Loss: 0.07396550476551056\n",
-            "Training with adam optimizer, Learning Rate: 0.01\n",
-            "Epoch 0, Loss: 0.656155526638031\n",
-            "Epoch 100, Loss: 0.05443219840526581\n",
-            "Epoch 200, Loss: 0.008137507364153862\n",
-            "Epoch 300, Loss: 0.0019811345264315605\n",
-            "Epoch 400, Loss: 0.0017195559339597821\n",
-            "Training with adam optimizer, Learning Rate: 0.05\n",
-            "Epoch 0, Loss: 0.8398498892784119\n",
-            "Epoch 100, Loss: 0.01334674097597599\n",
-            "Epoch 200, Loss: 0.005106130614876747\n",
-            "Epoch 300, Loss: 0.005647515878081322\n",
-            "Epoch 400, Loss: 0.004366322886198759\n",
-            "Training with adam optimizer, Learning Rate: 0.1\n",
-            "Epoch 0, Loss: 0.47047388553619385\n",
-            "Epoch 100, Loss: 0.040700845420360565\n",
-            "Epoch 200, Loss: 0.013467609882354736\n",
-            "Epoch 300, Loss: 0.016668444499373436\n",
-            "Epoch 400, Loss: 0.024467971175909042\n",
-            "Optimal Learning Rate for adam: 0.01\n",
-            "Training with sgd optimizer, Learning Rate: 0.001\n",
-            "Epoch 0, Loss: 0.546783447265625\n",
-            "Epoch 100, Loss: 0.3665744662284851\n",
-            "Epoch 200, Loss: 0.24665801227092743\n",
-            "Epoch 300, Loss: 0.22600947320461273\n",
-            "Epoch 400, Loss: 0.22325775027275085\n",
-            "Training with sgd optimizer, Learning Rate: 0.01\n",
-            "Epoch 0, Loss: 0.2945556044578552\n",
-            "Epoch 100, Loss: 0.1943282186985016\n",
-            "Epoch 200, Loss: 0.16805551946163177\n",
-            "Epoch 300, Loss: 0.1443624645471573\n",
-            "Epoch 400, Loss: 0.14353042840957642\n",
-            "Training with sgd optimizer, Learning Rate: 0.05\n",
-            "Epoch 0, Loss: 0.8524317741394043\n",
-            "Epoch 100, Loss: 0.1048104465007782\n",
-            "Epoch 200, Loss: 0.09471305459737778\n",
-            "Epoch 300, Loss: 0.08268048614263535\n",
-            "Epoch 400, Loss: 0.04604833945631981\n",
-            "Training with sgd optimizer, Learning Rate: 0.1\n",
-            "Epoch 0, Loss: 0.41696229577064514\n",
-            "Epoch 100, Loss: 0.09462793916463852\n",
-            "Epoch 200, Loss: 0.04378156363964081\n",
-            "Epoch 300, Loss: 0.01161857508122921\n",
-            "Epoch 400, Loss: 0.010568294674158096\n",
-            "Optimal Learning Rate for sgd: 0.1\n",
-            "Extended Training with adam optimizer, Learning Rate: 0.01\n",
-            "Epoch 0, Loss: 0.5830532312393188\n",
-            "Epoch 100, Loss: 0.04069427773356438\n",
-            "Epoch 200, Loss: 0.014957701787352562\n",
-            "Epoch 300, Loss: 0.007756960112601519\n",
-            "Epoch 400, Loss: 0.0041653551161289215\n",
-            "Epoch 500, Loss: 0.0012850951170548797\n",
-            "Epoch 600, Loss: 0.0009612652356736362\n",
-            "Epoch 700, Loss: 0.0010141282109543681\n",
-            "Epoch 800, Loss: 0.0007847577799111605\n",
-            "Epoch 900, Loss: 0.0008019267697818577\n",
-            "Epoch 1000, Loss: 0.0008370596333406866\n",
-            "Epoch 1100, Loss: 0.0006477786810137331\n",
-            "Epoch 1200, Loss: 0.00045542255975306034\n",
-            "Epoch 1300, Loss: 0.0012033770326524973\n",
-            "Epoch 1400, Loss: 0.0003435359103605151\n",
-            "Epoch 1500, Loss: 0.0004934956086799502\n",
-            "Epoch 1600, Loss: 0.0006456899573095143\n",
-            "Epoch 1700, Loss: 0.0003973623679485172\n",
-            "Epoch 1800, Loss: 0.0007489100680686533\n",
-            "Epoch 1900, Loss: 0.0003518729645293206\n",
-            "Epoch 0, Loss: 0.5693204402923584\n",
-            "Epoch 100, Loss: 0.05138877406716347\n",
-            "Epoch 200, Loss: 0.013046055100858212\n",
-            "Epoch 300, Loss: 0.0010367457289248705\n",
-            "Epoch 400, Loss: 0.00109263660851866\n",
-            "Epoch 500, Loss: 0.0008252558181993663\n",
-            "Epoch 600, Loss: 0.0012738151708617806\n",
-            "Epoch 700, Loss: 0.000919490063097328\n",
-            "Epoch 800, Loss: 0.0008364793029613793\n",
-            "Epoch 900, Loss: 0.000980834593065083\n",
-            "Epoch 1000, Loss: 0.0009053452522493899\n",
-            "Epoch 1100, Loss: 0.0008737568277865648\n",
-            "Epoch 1200, Loss: 0.000731855456251651\n",
-            "Epoch 1300, Loss: 0.0008182672900147736\n",
-            "Epoch 1400, Loss: 0.001077506341971457\n",
-            "Epoch 1500, Loss: 0.0009018218843266368\n",
-            "Epoch 1600, Loss: 0.0008008335717022419\n",
-            "Epoch 1700, Loss: 0.0009431234211660922\n",
-            "Epoch 1800, Loss: 0.0008044749265536666\n",
-            "Epoch 1900, Loss: 0.0005106532480567694\n",
-            "Epoch 0, Loss: 0.42836982011795044\n",
-            "Epoch 100, Loss: 0.046658266335725784\n",
-            "Epoch 200, Loss: 0.008813182823359966\n",
-            "Epoch 300, Loss: 0.0020511108450591564\n",
-            "Epoch 400, Loss: 0.0011437180219218135\n",
-            "Epoch 500, Loss: 0.000253011763561517\n",
-            "Epoch 600, Loss: 0.0004903610097244382\n",
-            "Epoch 700, Loss: 0.0002295574377058074\n",
-            "Epoch 800, Loss: 0.0002057807141682133\n",
-            "Epoch 900, Loss: 0.00029910984449088573\n",
-            "Epoch 1000, Loss: 0.00014264315541367978\n",
-            "Epoch 1100, Loss: 0.0005909785977564752\n",
-            "Epoch 1200, Loss: 0.00026484622503630817\n",
-            "Epoch 1300, Loss: 0.0005396748892962933\n",
-            "Epoch 1400, Loss: 0.0001503111852798611\n",
-            "Epoch 1500, Loss: 0.00019361285376362503\n",
-            "Epoch 1600, Loss: 0.0009334768401458859\n",
-            "Epoch 1700, Loss: 0.00022425022325478494\n",
-            "Epoch 1800, Loss: 0.00018465385073795915\n",
-            "Epoch 1900, Loss: 0.0003867056511808187\n",
-            "Epoch 0, Loss: 0.424920916557312\n",
-            "Epoch 100, Loss: 0.0761205181479454\n",
-            "Epoch 200, Loss: 0.019174152985215187\n",
-            "Epoch 300, Loss: 0.010008974932134151\n",
-            "Epoch 400, Loss: 0.003048173151910305\n",
-            "Epoch 500, Loss: 0.0025286225136369467\n",
-            "Epoch 600, Loss: 0.0022129977587610483\n",
-            "Epoch 700, Loss: 0.0022107227705419064\n",
-            "Epoch 800, Loss: 0.0012501418823376298\n",
-            "Epoch 900, Loss: 0.0011722086928784847\n",
-            "Epoch 1000, Loss: 0.001014550682157278\n",
-            "Epoch 1100, Loss: 0.0015777176013216376\n",
-            "Epoch 1200, Loss: 0.0052093504928052425\n",
-            "Epoch 1300, Loss: 0.000918371370062232\n",
-            "Epoch 1400, Loss: 0.0008439962402917445\n",
-            "Epoch 1500, Loss: 0.0007502107182517648\n",
-            "Epoch 1600, Loss: 0.0006011141813360155\n",
-            "Epoch 1700, Loss: 0.0015145703218877316\n",
-            "Epoch 1800, Loss: 0.0016902879578992724\n",
-            "Epoch 1900, Loss: 0.000590030918829143\n",
-            "Epoch 0, Loss: 1.1833572387695312\n",
-            "Epoch 100, Loss: 0.08118738234043121\n",
-            "Epoch 200, Loss: 0.011251457035541534\n",
-            "Epoch 300, Loss: 0.006743659731000662\n",
-            "Epoch 400, Loss: 0.0040425886400043964\n",
-            "Epoch 500, Loss: 0.0026466394774615765\n",
-            "Epoch 600, Loss: 0.0019834197591990232\n",
-            "Epoch 700, Loss: 0.0009103421471081674\n",
-            "Epoch 800, Loss: 0.0008241773466579616\n",
-            "Epoch 900, Loss: 0.0013139243237674236\n",
-            "Epoch 1000, Loss: 0.0012432656949386\n",
-            "Epoch 1100, Loss: 0.0014463859843090177\n",
-            "Epoch 1200, Loss: 0.0008870864985510707\n",
-            "Epoch 1300, Loss: 0.0016969062853604555\n",
-            "Epoch 1400, Loss: 0.0013733449159190059\n",
-            "Epoch 1500, Loss: 0.0011933138594031334\n",
-            "Epoch 1600, Loss: 0.0016549158608540893\n",
-            "Epoch 1700, Loss: 0.0005628080107271671\n",
-            "Epoch 1800, Loss: 0.0010169916786253452\n",
-            "Epoch 1900, Loss: 0.0008006028365343809\n",
-            "Extended Training with sgd optimizer, Learning Rate: 0.1\n",
-            "Epoch 0, Loss: 0.5830532312393188\n",
-            "Epoch 100, Loss: 0.0930047407746315\n",
-            "Epoch 200, Loss: 0.03846289962530136\n",
-            "Epoch 300, Loss: 0.03576895222067833\n",
-            "Epoch 400, Loss: 0.03900745511054993\n",
-            "Epoch 500, Loss: 0.04208044707775116\n",
-            "Epoch 600, Loss: 0.026529449969530106\n",
-            "Epoch 700, Loss: 0.02303355187177658\n",
-            "Epoch 800, Loss: 0.0192039106041193\n",
-            "Epoch 900, Loss: 0.019693370908498764\n",
-            "Epoch 1000, Loss: 0.01920172944664955\n",
-            "Epoch 1100, Loss: 0.012625466100871563\n",
-            "Epoch 1200, Loss: 0.011659548617899418\n",
-            "Epoch 1300, Loss: 0.013284482061862946\n",
-            "Epoch 1400, Loss: 0.00943035539239645\n",
-            "Epoch 1500, Loss: 0.00858990103006363\n",
-            "Epoch 1600, Loss: 0.008162128739058971\n",
-            "Epoch 1700, Loss: 0.006184006575495005\n",
-            "Epoch 1800, Loss: 0.0066886404529213905\n",
-            "Epoch 1900, Loss: 0.004892262630164623\n",
-            "Epoch 0, Loss: 0.5693204402923584\n",
-            "Epoch 100, Loss: 0.05248872935771942\n",
-            "Epoch 200, Loss: 0.03954644873738289\n",
-            "Epoch 300, Loss: 0.01796639896929264\n",
-            "Epoch 400, Loss: 0.01394734624773264\n",
-            "Epoch 500, Loss: 0.012300420552492142\n",
-            "Epoch 600, Loss: 0.01125716045498848\n",
-            "Epoch 700, Loss: 0.012342509813606739\n",
-            "Epoch 800, Loss: 0.010939603671431541\n",
-            "Epoch 900, Loss: 0.011400185525417328\n",
-            "Epoch 1000, Loss: 0.011530214920639992\n",
-            "Epoch 1100, Loss: 0.012533148750662804\n",
-            "Epoch 1200, Loss: 0.01017774548381567\n",
-            "Epoch 1300, Loss: 0.009339832700788975\n",
-            "Epoch 1400, Loss: 0.010524758137762547\n",
-            "Epoch 1500, Loss: 0.011477043852210045\n",
-            "Epoch 1600, Loss: 0.007282334379851818\n",
-            "Epoch 1700, Loss: 0.0026162811554968357\n",
-            "Epoch 1800, Loss: 0.0028659002855420113\n",
-            "Epoch 1900, Loss: 0.0015429151244461536\n",
-            "Epoch 0, Loss: 0.42836982011795044\n",
-            "Epoch 100, Loss: 0.05211774632334709\n",
-            "Epoch 200, Loss: 0.054780058562755585\n",
-            "Epoch 300, Loss: 0.02610728330910206\n",
-            "Epoch 400, Loss: 0.011417727917432785\n",
-            "Epoch 500, Loss: 0.012193468399345875\n",
-            "Epoch 600, Loss: 0.010293148458003998\n",
-            "Epoch 700, Loss: 0.00896702241152525\n",
-            "Epoch 800, Loss: 0.005604006350040436\n",
-            "Epoch 900, Loss: 0.004703456070274115\n",
-            "Epoch 1000, Loss: 0.003618777496740222\n",
-            "Epoch 1100, Loss: 0.002921100240200758\n",
-            "Epoch 1200, Loss: 0.0037355180829763412\n",
-            "Epoch 1300, Loss: 0.003063815413042903\n",
-            "Epoch 1400, Loss: 0.002987377578392625\n",
-            "Epoch 1500, Loss: 0.003030637511983514\n",
-            "Epoch 1600, Loss: 0.0027869774494320154\n",
-            "Epoch 1700, Loss: 0.0029398156329989433\n",
-            "Epoch 1800, Loss: 0.0027278524357825518\n",
-            "Epoch 1900, Loss: 0.002908523427322507\n",
-            "Epoch 0, Loss: 0.424920916557312\n",
-            "Epoch 100, Loss: 0.09212422370910645\n",
-            "Epoch 200, Loss: 0.0675203949213028\n",
-            "Epoch 300, Loss: 0.04522519186139107\n",
-            "Epoch 400, Loss: 0.033005524426698685\n",
-            "Epoch 500, Loss: 0.018865013495087624\n",
-            "Epoch 600, Loss: 0.016999593004584312\n",
-            "Epoch 700, Loss: 0.012584787793457508\n",
-            "Epoch 800, Loss: 0.011952929198741913\n",
-            "Epoch 900, Loss: 0.008601702749729156\n",
-            "Epoch 1000, Loss: 0.006208001635968685\n",
-            "Epoch 1100, Loss: 0.006576959975063801\n",
-            "Epoch 1200, Loss: 0.005585736595094204\n",
-            "Epoch 1300, Loss: 0.004765945486724377\n",
-            "Epoch 1400, Loss: 0.0047289240173995495\n",
-            "Epoch 1500, Loss: 0.004848414566367865\n",
-            "Epoch 1600, Loss: 0.00441839499399066\n",
-            "Epoch 1700, Loss: 0.0049349404871463776\n",
-            "Epoch 1800, Loss: 0.00519229331985116\n",
-            "Epoch 1900, Loss: 0.003584818448871374\n",
-            "Epoch 0, Loss: 1.1833572387695312\n",
-            "Epoch 100, Loss: 0.08152821660041809\n",
-            "Epoch 200, Loss: 0.021270671859383583\n",
-            "Epoch 300, Loss: 0.010054366663098335\n",
-            "Epoch 400, Loss: 0.009115400724112988\n",
-            "Epoch 500, Loss: 0.007551252376288176\n",
-            "Epoch 600, Loss: 0.006697576958686113\n",
-            "Epoch 700, Loss: 0.005611020606011152\n",
-            "Epoch 800, Loss: 0.004934248514473438\n",
-            "Epoch 900, Loss: 0.005393086466938257\n",
-            "Epoch 1000, Loss: 0.005081726238131523\n",
-            "Epoch 1100, Loss: 0.004314498510211706\n",
-            "Epoch 1200, Loss: 0.004448655992746353\n",
-            "Epoch 1300, Loss: 0.004295793361961842\n",
-            "Epoch 1400, Loss: 0.0036569100338965654\n",
-            "Epoch 1500, Loss: 0.0036865808069705963\n",
-            "Epoch 1600, Loss: 0.004365374334156513\n",
-            "Epoch 1700, Loss: 0.0035841509234160185\n",
-            "Epoch 1800, Loss: 0.003948792349547148\n",
-            "Epoch 1900, Loss: 0.003741784719750285\n"
-          ]
-        },
-        {
-          "output_type": "display_data",
-          "data": {
-            "text/plain": [
-              "<Figure size 1000x600 with 1 Axes>"
-            ],
-            "image/png": "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\n"
-          },
-          "metadata": {}
-        }
-      ],
-      "source": [
-        "import torch\n",
-        "from torch import nn\n",
-        "import numpy as np\n",
-        "from matplotlib import pyplot as plt\n",
-        "\n",
-        "# Setup\n",
-        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-        "\n",
-        "\n",
-        "def set_random_seed(seed):\n",
-        "    torch.manual_seed(seed)  # PyTorch\n",
-        "\n",
-        "    # Ensures that PyTorch gets the same random numbers for CUDA as well, if using GPU.\n",
-        "    if torch.cuda.is_available():\n",
-        "        torch.cuda.manual_seed(seed)\n",
-        "        torch.cuda.manual_seed_all(seed)  # For multi-GPU setups\n",
-        "        torch.backends.cudnn.deterministic = True\n",
-        "        torch.backends.cudnn.benchmark = False\n",
-        "\n",
-        "\n",
-        "def attention(P,Q,Z, activation = None):\n",
-        "    B= Z.shape[0]\n",
-        "    N = Z.shape[1]-1\n",
-        "    d = Z.shape[2]-1\n",
-        "    P_full =  torch.cat([P,torch.zeros(1,d).to(device)],dim=0)\n",
-        "    P_full =  torch.cat([P_full,torch.zeros(d+1,1).to(device)],dim=1)\n",
-        "    P_full[d,d] = 1\n",
-        "    Q_full = torch.cat([Q, torch.zeros(1,d).to(device)],dim=0)\n",
-        "    Q_full = torch.cat([Q_full, torch.zeros(d+1,1).to(device)],dim=1)\n",
-        "    A = torch.eye(N+1).to(device)\n",
-        "    A[N,N] = 0\n",
-        "    Attn = torch.einsum('BNi, ij, BMj -> BNM', (Z,Q_full,Z))\n",
-        "    if activation is not None:\n",
-        "        Attn = activation(Attn)\n",
-        "    key = torch.einsum('ij, BNj -> BNi', (P_full,Z))\n",
-        "    Output = torch.einsum('BNM,ML, BLi -> BNi', (Attn,A,key))\n",
-        "    return Output /N\n",
-        "\n",
-        "\n",
-        "class Transformer_F(nn.Module):\n",
-        "    def __init__(self, n_layer, n_head, d, var):\n",
-        "        super(Transformer_F, self).__init__()\n",
-        "        self.register_parameter('allparam', torch.nn.Parameter(torch.zeros(n_layer, n_head, 2, d, d)))\n",
-        "        with torch.no_grad():\n",
-        "            self.allparam.normal_(0,var)\n",
-        "        self.n_layer = n_layer\n",
-        "        self.n_head = n_head\n",
-        "\n",
-        "    def forward(self, Z):\n",
-        "        for i in range(self.n_layer):\n",
-        "            Zi = Z\n",
-        "            residues = 0\n",
-        "            # the forwarad map of each layer is given by F(Z) = Z + attention(Z)\n",
-        "            for j in range(self.n_head):\n",
-        "                Pij = self.allparam[i,j,0,:,:]\n",
-        "                Qij = self.allparam[i,j,1,:,:]\n",
-        "                residues = residues + attention(Pij,Qij,Zi)\n",
-        "            Z = Zi + residues\n",
-        "        return Z\n",
-        "\n",
-        "    #enforces top-left-dxd-block sparsity on p\n",
-        "    def zero_p(self):\n",
-        "        for i in range(self.n_layer):\n",
-        "            for j in range(self.n_head):\n",
-        "                with torch.no_grad():\n",
-        "                    self.allparam[i,j,0,:,:].zero_()\n",
-        "\n",
-        "class Transformer_MLP_freeze(nn.Module):\n",
-        "    def __init__(self, n_layer, n_head, d, var, randomMLP):\n",
-        "        super(Transformer_MLP_freeze, self).__init__()\n",
-        "        self.register_parameter('allparam', torch.nn.Parameter(torch.zeros(n_layer, n_head, 2, d, d)))\n",
-        "        with torch.no_grad():\n",
-        "            self.allparam.normal_(0,var)\n",
-        "        self.n_layer = n_layer\n",
-        "        self.n_head = n_head\n",
-        "        self.randomMLP = randomMLP\n",
-        "\n",
-        "    def forward(self, Z):\n",
-        "        Z[:,:,:-1] = self.randomMLP(Z[:,:,:-1])\n",
-        "        for i in range(self.n_layer):\n",
-        "            Zi = Z\n",
-        "            residues = 0\n",
-        "            # the forwarad map of each layer is given by F(Z) = Z + attention(Z)\n",
-        "            for j in range(self.n_head):\n",
-        "                Pij = self.allparam[i,j,0,:,:]\n",
-        "                Qij = self.allparam[i,j,1,:,:]\n",
-        "                residues = residues + attention(Pij,Qij,Zi)\n",
-        "            Z = Zi + residues\n",
-        "        return Z\n",
-        "\n",
-        "class Transformer_MLP(nn.Module):\n",
-        "    def __init__(self, n_layer, n_head, d, var, hidden_dim):\n",
-        "        super(Transformer_MLP, self).__init__()\n",
-        "        self.register_parameter('allparam', torch.nn.Parameter(torch.zeros(n_layer, n_head, 2, d, d)))\n",
-        "        with torch.no_grad():\n",
-        "            self.allparam.normal_(0,var)\n",
-        "        self.n_layer = n_layer\n",
-        "        self.n_head = n_head\n",
-        "        self.mlp = nn.Sequential(nn.Linear(d, hidden_dim),nn.ReLU(),nn.Linear(hidden_dim, d))\n",
-        "\n",
-        "    def forward(self, Z):\n",
-        "        Z[:,:,:-1] = self.mlp(Z[:,:,:-1].clone())\n",
-        "        for i in range(self.n_layer):\n",
-        "            Zi = Z\n",
-        "            residues = 0\n",
-        "            # the forwarad map of each layer is given by F(Z) = Z + attention(Z)\n",
-        "            for j in range(self.n_head):\n",
-        "                Pij = self.allparam[i,j,0,:,:]\n",
-        "                Qij = self.allparam[i,j,1,:,:]\n",
-        "                residues = residues + attention(Pij,Qij,Zi)\n",
-        "            Z = Zi + residues\n",
-        "        return Z\n",
-        "\n",
-        "# evaluate the loss of model, given data (Z,y)\n",
-        "def in_context_loss(model, Z, y):\n",
-        "    N = Z.shape[1]-1\n",
-        "    d = Z.shape[2]-1\n",
-        "    output = model(Z)\n",
-        "    diff = output[:,N,d]+y\n",
-        "    loss = ((diff)**2).mean()\n",
-        "    return loss\n",
-        "\n",
-        "def generate_data_mlp(N, B, d, randomMLP):\n",
-        "    # Generate random input data\n",
-        "    X = torch.FloatTensor(B, N, d).normal_(0, 1).to(device)\n",
-        "    X_test = torch.FloatTensor(B, 1, d).normal_(0, 1).to(device)\n",
-        "\n",
-        "    # Additional transformations if mode is 'sphere' or 'gamma' [Similar to the existing generate_data function]\n",
-        "\n",
-        "    X_MLP = randomMLP(X.view(-1, d)).view(B, N, d)\n",
-        "    X_test_MLP = randomMLP(X_test.view(-1, d)).view(B, 1, d)\n",
-        "\n",
-        "    W = torch.FloatTensor(B, d).normal_(0,1).cuda()\n",
-        "    y = torch.einsum('bi,bni->bn', (W, X_MLP)).unsqueeze(2)\n",
-        "    y_zero = torch.zeros(B,1,1).cuda()\n",
-        "    y_test = torch.einsum('bi,bni->bn', (W, X_test_MLP)).squeeze(1)\n",
-        "    X_comb= torch.cat([X,X_test],dim=1)\n",
-        "    y_comb= torch.cat([y,y_zero],dim=1)\n",
-        "    Z= torch.cat([X_comb,y_comb],dim=2)\n",
-        "\n",
-        "    return Z, y_test\n",
-        "# Setup\n",
-        "N=20\n",
-        "device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n",
-        "n_layer = 3  # number of layers of transformer\n",
-        "d = 5        # dimension for the data\n",
-        "n_head = 1   # 1-headed attention\n",
-        "B = 1000     # minibatch size for sine data\n",
-        "var = 0.0001 # initializations scale of transformer parameter\n",
-        "clip_r =0.1\n",
-        "\n",
-        "\n",
-        "tuning_epochs = 500\n",
-        "max_iters = 2000  # Number of Iterations to run\n",
-        "hidden_dim = 5\n",
-        "learning_rates = [0.001, 0.01, 0.05, 0.1]\n",
-        "\n",
-        "# Function to run training\n",
-        "def train_transformer(optimizer_name, learning_rate, max_epochs):\n",
-        "    randomMLP = nn.Sequential(nn.Linear(d, hidden_dim),nn.ReLU(),nn.Linear(hidden_dim, d)).to(device)\n",
-        "    for para in randomMLP.parameters():\n",
-        "        para.requires_grad = False\n",
-        "    # Initialize model and optimizer\n",
-        "\n",
-        "    # Instantiate model\n",
-        "    model = Transformer_MLP(n_layer, n_head, d, var, 3* hidden_dim).to(device)\n",
-        "    #model = Transformer_MLP_freeze(n_layer, n_head, d, var, randomMLP).to(device)\n",
-        "\n",
-        "    # Wrap the model for DataParallel\n",
-        "    if torch.cuda.device_count() > 1:\n",
-        "        print(f\"Let's use {torch.cuda.device_count()} GPUs!\")\n",
-        "        model = nn.DataParallel(model)\n",
-        "\n",
-        "    if optimizer_name == 'sgd':\n",
-        "        optimizer = torch.optim.SGD(model.parameters(), lr=learning_rate, momentum=0.9)\n",
-        "    elif optimizer_name == 'adam':\n",
-        "        optimizer = torch.optim.Adam(model.parameters(), lr=learning_rate, betas=(0.9, 0.9))\n",
-        "\n",
-        "    losses = []\n",
-        "    for epoch in range(max_epochs):\n",
-        "        # Generate data\n",
-        "        Z, y = generate_data_mlp(N=N, B=B, d=d, randomMLP=randomMLP)\n",
-        "\n",
-        "        # Move data to the correct device\n",
-        "        Z, y = Z.to(device), y.to(device)\n",
-        "\n",
-        "        # Training step\n",
-        "        optimizer.zero_grad()\n",
-        "        loss = in_context_loss(model, Z, y)\n",
-        "        loss.backward()\n",
-        "\n",
-        "        torch.nn.utils.clip_grad_norm_(model.parameters(), max_norm=1)\n",
-        "\n",
-        "        optimizer.step()\n",
-        "\n",
-        "        optimizer.zero_grad()\n",
-        "\n",
-        "        # Record loss\n",
-        "        losses.append(loss.item())\n",
-        "\n",
-        "        # Optionally print progress\n",
-        "        if epoch % 100 == 0:\n",
-        "            print(f'Epoch {epoch}, Loss: {loss.item()}')\n",
-        "\n",
-        "    return losses\n",
-        "\n",
-        "# Tuning learning rate\n",
-        "\n",
-        "optimal_lr = {}\n",
-        "for optimizer_name in ['adam','sgd']:\n",
-        "    best_lr = None\n",
-        "    best_loss = float('inf')\n",
-        "    for lr in learning_rates:\n",
-        "        print(f\"Training with {optimizer_name} optimizer, Learning Rate: {lr}\")\n",
-        "        losses = train_transformer(optimizer_name, lr, tuning_epochs)\n",
-        "        avg_loss = np.mean(losses[-20:])  # Average loss over last epochs\n",
-        "        if avg_loss < best_loss:\n",
-        "            best_loss = avg_loss\n",
-        "            best_lr = lr\n",
-        "    optimal_lr[optimizer_name] = best_lr\n",
-        "    print(f\"Optimal Learning Rate for {optimizer_name}: {best_lr}\")\n",
-        "\n",
-        "num_runs = 5\n",
-        "final_losses = {}\n",
-        "for optimizer_name, lr in optimal_lr.items():\n",
-        "    print(f\"Extended Training with {optimizer_name} optimizer, Learning Rate: {lr}\")\n",
-        "    all_losses = []\n",
-        "    for seed in range(num_runs):\n",
-        "        set_random_seed(seed)  # Function to set the random seed, define it as needed\n",
-        "        losses = train_transformer(optimizer_name, lr, max_iters)\n",
-        "        all_losses.append(losses)\n",
-        "\n",
-        "    # Calculate the mean and standard deviation of the losses\n",
-        "    mean_losses = np.mean(all_losses, axis=0)\n",
-        "    std_losses = np.std(all_losses, axis=0)\n",
-        "    final_losses[optimizer_name] = (mean_losses, std_losses)\n",
-        "\n",
-        "# Plotting losses with shaded error bar\n",
-        "plt.figure(figsize=(10, 6))\n",
-        "epochs = range(len(mean_losses))  # Assuming all runs have the same number of epochs\n",
-        "for optimizer_name, (mean_losses, std_losses) in final_losses.items():\n",
-        "    plt.plot(epochs, mean_losses, label=f'{optimizer_name} LR={optimal_lr[optimizer_name]}')\n",
-        "    plt.fill_between(epochs, mean_losses - std_losses, mean_losses + std_losses, alpha=0.3)\n",
-        "plt.xlabel('Epochs')\n",
-        "plt.ylabel('Loss')\n",
-        "plt.yscale('log')\n",
-        "plt.legend()\n",
-        "plt.show()"
-      ]
-    }
-  ],
-  "metadata": {
-    "accelerator": "GPU",
-    "colab": {
-      "machine_shape": "hm",
-      "provenance": []
-    },
-    "kernelspec": {
-      "display_name": "Python 3",
-      "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.11.3"
-    }
-  },
-  "nbformat": 4,
-  "nbformat_minor": 0
-}