added timefit.py and energy_time_fit.py

analysis/Data Exploration Memcached.ipynb

@@ -826,7 +826,7 @@
    "name": "python",
    "nbconvert_exporter": "python",
    "pygments_lexer": "ipython3",
-   "version": "3.7.6"
+   "version": "3.8.3"
   },
   "toc": {
    "base_numbering": 1,

analysis/energy_time_fit.py

@@ -0,0 +1,138 @@
+import sys
+sys.path.append('../bayesopt')
+
+import read_agg_data
+import torch
+import torch.nn as nn
+import torch.autograd as auto
+import torch.optim as optim
+
+import numpy as np
+import matplotlib.pylab as plt
+
+import pdb
+
+plt.ion()
+
+def inference(d, n_iter, lr, workload, sys, print_freq=10):
+    # p_busy_min = 20
+    p_static = {
+        'c1':1.5, 
+        'c3':0.5,
+        'c4':0.25,
+        'c7':0,
+        'busy': 10
+    }
+    chosen_sleep = 'c7'
+
+    # p_q = p_static[chosen_sleep]
+    # p_detect = p_static[chosen_sleep]
+
+    #starts randomly
+    max_time = torch.tensor(torch.Tensor(1,1).uniform_(10, 500), requires_grad=True)
+    alpha = torch.tensor(torch.Tensor(1,1).uniform_(-2, 2), requires_grad=True)
+    beta = torch.tensor(torch.Tensor(1,1).uniform_(-2, 2), requires_grad=True)
+    p_static_busy = torch.tensor(torch.Tensor(1,1).uniform_(0, 35), requires_grad=True)
+    p_detect = torch.tensor(torch.Tensor(1,1).uniform_(0, 35), requires_grad=True)
+    p_q = torch.tensor(torch.Tensor(1,1).uniform_(0, 35), requires_grad=True)
+    p_busy_min = torch.tensor(torch.Tensor(1,1).uniform_(0, 35), requires_grad=True)
+    itr_suppress = torch.rand(1, requires_grad=True)
+
+    qps = d[:,3]
+    energy = d[:,0]/(qps*20)
+    itr = d[:,1]
+    dvfs = d[:,2]
+    time = d[:,4]
+    interarrival_time = 1/qps*10**6
+
+    current_loss_time = -100
+    fixed_max_time = -100
+    fixed_alpha = -100
+
+    criterion = nn.MSELoss()
+    optimizer_time = optim.Adam([max_time, alpha], lr=lr)
+    optimizer_energy = optim.Adam([max_time, alpha, beta, p_detect, p_q], lr=lr)
+    # optimizer = optim.Adam([max_time, alpha, beta, p_detect, p_q], lr=lr)
+
+    print(f'---------------FOR TIME LOSS {workload} {sys} lr = {lr}---------------')
+
+    for _ in range(n_iter):
+        p_busy = (p_static_busy + p_busy_min*dvfs**(2+beta))
+        t_busy = (max_time / dvfs**(1+alpha))
+        pred_time = itr_suppress*itr + t_busy
+        loss_time = criterion(pred_time/time, torch.ones((1,pred_time.shape[1])).double())
+        # loss = loss_energy + loss_time
+
+        optimizer_time.zero_grad()
+        loss_time.backward(retain_graph=True)
+        optimizer_time.step()
+
+        if(current_loss_time == -100):
+            current_loss_time = loss_time.item()
+        else:
+            if(current_loss_time >= loss_time.item()):
+                current_loss_time = loss_time.item()
+                fixed_max_time = max_time.item()
+                fixed_alpha = alpha.item()
+
+        if _ % print_freq == 0:
+            print(max_time.item(), alpha.item(), itr_suppress.item(), loss_time.item())
+
+    print(f'---------------FOR ENERGY LOSS {workload} {sys} lr = {lr} max_time = {fixed_max_time} alpha = {fixed_alpha}---------------')
+
+    for _ in range(n_iter):
+        t_busy_energy = (fixed_max_time / dvfs**(1+fixed_alpha))
+        t_q_energy = (interarrival_time - itr - t_busy_energy)
+        pred_energy = (p_detect * itr_suppress*itr) + (p_busy * t_busy_energy) + (p_q * t_q_energy)
+        loss_energy = criterion(pred_energy/energy, torch.ones((1,pred_energy.shape[1])).double())
+
+        optimizer_energy.zero_grad()
+        loss_energy.backward(retain_graph=True)
+        optimizer_energy.step()
+
+        if _ % print_freq == 0:
+            print(max_time.item(), alpha.item(), beta.item(), p_detect.item(), p_q.item(), itr_suppress.item(), loss_energy.item())
+
+    return pred_energy, pred_time
+
+def run(n_iter=2000, lr = 1e-2):
+    #read linux_mcd.csv
+    for workload in ['mcd']:
+        df_comb, _, _ = read_agg_data.start_analysis(workload) #DATA
+        df_comb['dvfs'] = df_comb['dvfs'].apply(lambda x: int(x, base=16))
+        df_comb = df_comb[(df_comb['itr']!=1) | (df_comb['dvfs']!=65535)] #filter out linux dynamic
+        df_comb['dvfs'] = df_comb['dvfs'].astype(float) / df_comb['dvfs'].min()
+        df_comb = df_comb[df_comb['QPS'] == 400000]
+
+        for sys in ['ebbrt_tuned']:
+            df = df_comb[(df_comb['sys']==sys)].copy()
+            df = df[['joules_mean','itr', 'dvfs', 'QPS', 'read_99th_mean']]
+            d = df.values
+            d = torch.tensor(d)
+            plt.plot(d[:,0], d[:,1], 'p')
+
+            for lr in [lr]:
+                pred_energy, pred_time = inference(d, n_iter, lr, workload, sys, print_freq=1000)
+                df[f'pre_energy lr={lr}'] = pred_energy.view(245, 1).detach().numpy()
+                df[f'pre_time lr={lr}'] = pred_time.view(245, 1).detach().numpy()
+
+                for pred_name in ['energy', 'time']:
+                    if pred_name == 'energy':
+                        pred = pred_energy
+                        qps = d[:,3]
+                        yvalue = d[:,0]/(qps*20)
+                    else:
+                        pred = pred_time
+                        yvalue = d[:,4]
+                    fig, ax = plt.subplots()
+                    plt.title(f'predict:{pred_name} workload={workload} system={sys} lr={lr} QPS=400000')
+                    plt.xlabel(u"predictions")
+                    plt.ylabel(pred_name)
+                    scatter = ax.scatter(pred.detach().numpy()[0], yvalue, marker = 'o', s = d[:,1], c = d[:,2], alpha=0.3)
+                    legend1 = ax.legend(*scatter.legend_elements(),loc="upper left", title="dvfs")
+                    ax.add_artist(legend1)
+                    handles, labels = scatter.legend_elements(prop="sizes", alpha=0.6)
+                    legend2 = plt.legend(handles, labels, loc="lower right", title="itr")
+                    ax.add_artist(legend2)
+                    plt.savefig(f'plots/energy_time_fit/randomp_{pred_name}_{workload}_{sys}_{lr}.png')
+                    plt.close()

analysis/experiment.py

@@ -0,0 +1,47 @@
+import sys
+sys.path.append('../bayesopt')
+
+import read_agg_data
+import torch
+import torch.nn as nn
+import torch.autograd as auto
+import torch.optim as optim
+import math
+
+import numpy as np
+import matplotlib.pylab as plt
+
+import pdb
+
+plt.ion()
+
+def inference(n_iter, lr, print_freq=10):
+    x = torch.rand(1, requires_grad=True)
+
+    func_tensor = torch.Tensor([1] * 10)
+    # min_tensor = torch.Tensor([-1] * 10)
+
+    # criterion = nn.MSELoss()
+    optimizer = optim.Adam([x], lr=lr)
+
+    for _ in range(n_iter):
+        # func = 5 * x
+        func = torch.Tensor(math.sin(x))
+        pdb.set_trace()
+        # loss = criterion(min_tensor, func)
+
+        optimizer.zero_grad()
+        func.backward()
+        optimizer.step()
+
+        if _ % print_freq == 0:
+            print(x.item())
+
+    return x
+
+def run(n_iter=2000, 
+        lr=1e-1):
+
+    pred = inference(n_iter, lr, print_freq=500)
+
+    return pred

analysis/nn_models.py

@@ -0,0 +1,164 @@
+import torch
+import torch.nn as nn
+import torch.optim as optim
+from torch.utils.data import Dataset, DataLoader
+
+import numpy as np
+import matplotlib.pylab as plt
+from sklearn.model_selection import train_test_split
+
+plt.ion()
+
+device = 'cuda' if torch.cuda.is_available() else 'cpu'
+
+#TODO: pass train_df and test_df to create Dataset objects
+class Dataset(Dataset):
+    def __init__(self, df, transform=None):
+        self.df = df
+        self.N_cols = df.shape[1]
+
+    def __len__(self):
+        return len(self.df)
+
+    def __getitem__(self, ix):
+        x = np.array(self.df.iloc[ix])
+
+        #TODO: map features and labels appropriately
+        features = x[:(self.N_cols-1)] 
+        label = x[[-1]]
+
+        return (torch.from_numpy(features).float(), torch.from_numpy(label))
+
+#TODO: create an instance of Net with N_inputs = number of features, N_outputs = 2(time, energy), N_hidden_layers=1 or 2, N_hidden_nodes=128
+#TODO: activation = nn.ReLU(), output_activation = None (TODO: maybe change output_activation to exp() to impose positivity)
+class Net(nn.Module):
+    def __init__(self, N_inputs, N_outputs, N_hidden_layers, N_hidden_nodes, activation, output_activation):
+        super(Net, self).__init__()
+
+        self.N_inputs = N_inputs
+        self.N_outputs = N_outputs
+
+        self.N_hidden_layers = N_hidden_layers
+        self.N_hidden_nodes = N_hidden_nodes
+
+        self.layer_list = nn.ModuleList([]) #use just as a python list
+        for n in range(N_hidden_layers):
+            if n==0:
+                self.layer_list.append(nn.Linear(N_inputs, N_hidden_nodes))
+            else:
+                self.layer_list.append(nn.Linear(N_hidden_nodes, N_hidden_nodes))
+
+        self.output_layer = nn.Linear(N_hidden_nodes, N_outputs)
+
+        self.activation = activation
+        self.output_activation = output_activation
+
+    def forward(self, inp):
+        out = inp
+        for layer in self.layer_list:
+            out = layer(out)
+            out = self.activation(out)
+
+        out = self.output_layer(out)
+        if self.output_activation is not None:
+            pred = self.output_activation(out)
+        else:
+            pred = out
+
+        return pred
+
+
+def train_model(train_dl, test_dl, model, criterion, N_epochs, print_freq, lr=1e-3, optimizer='adam'):
+    '''Loop over dataset in batches, compute loss, backprop and update weights
+    '''
+
+    model.train() #switch to train model (for dropout, batch normalization etc.)
+
+    model = model.to(device)
+    if optimizer=='adam':
+        optimizer = optim.Adam(model.parameters(), lr=lr)
+        print("Using adam")
+    elif optimizer=='sgd':
+        optimizer = optim.SGD(model.parameters(), lr=lr)
+        print("Using sgd")
+    else:
+        raise ValueError("Please use either adam or sgd")
+
+    loss_dict = {}
+    for epoch in range(N_epochs): #loop over epochs i.e. sweeps over full data
+        curr_loss = 0
+        N = 0
+
+        for idx, (features, labels) in enumerate(train_dl): #loop over batches = random samples from train dataset
+            #move features and labels to GPU if needed
+            features = features.to(device)
+            labels = labels.to(device)
+
+            preds = model(features) #make predictions
+            loss = criterion(preds.squeeze(), labels.squeeze().float()) #compute loss between predictions and labels
+
+            curr_loss += loss.item() #accumulate loss
+            N += len(labels) #accumulate number of data points seen in this epoch
+
+            #backprop and updates
+            optimizer.zero_grad()
+            loss.backward()
+            optimizer.step()
+
+        if epoch % print_freq == 0 or epoch==N_epochs-1:
+            val_loss = validate(test_dl, model, criterion) #get model perf metrics from test set
+
+            loss_dict[epoch] = val_loss
+
+            print(f'Iter = {epoch} Train Loss = {curr_loss / N} val_loss = {val_loss}')
+
+    return model, loss_dict
+
+def validate(test_dl, model, criterion):
+    '''Loop over test dataset and compute loss and accuracy
+    '''
+    model.eval() #switch to eval model
+
+    loss = 0
+    N = 0
+
+    preds_all, labels_all = torch.tensor([]), torch.tensor([])
+
+    with torch.no_grad(): #no need to keep variables for backprop computations
+        for idx, (features, labels) in enumerate(test_dl): #loop over batches from test set
+            features = features.to(device)
+            labels = labels.to(device).float()
+
+            preds = model(features)
+
+            preds_all = torch.cat((preds_all, preds.to('cpu')), 0)
+            labels_all = torch.cat((labels_all, labels.to('cpu')), 0)
+
+            loss += criterion(preds.squeeze(), labels.squeeze()) #cumulative loss
+            N += len(labels)
+
+    #avg_precision = average_precision_score(labels_all.squeeze().numpy(), preds_all.squeeze().numpy())
+
+    return loss / N
+
+def run():
+    df = ... #TODO: read csv file
+
+    #Split into train-test randomly
+    df_train, df_test = train_test_split(df, train_size=0.7)
+
+    #Create Dataset objects
+    ds_torch_train = Dataset(df_train)
+    ds_torch_test = Dataset(df_test)
+
+    #Create Dataloader objects (to sample batches of rows)
+    batch_size = 32
+    dl_torch_train = DataLoader(ds_torch_train, batch_size=batch_size, num_workers=0)
+    dl_torch_test = DataLoader(ds_torch_test, batch_size=batch_size, num_workers=0)
+
+    #criterion i.e. loss function
+    criterion = nn.MSELoss()
+
+    #init and train model
+    model = Net(...) #TODO: appropriate arguments
+    model, loss_dict = train_model(...) #TODO: arguments