ui: initial files

Dockerfile

@@ -0,0 +1,10 @@
+FROM python:3.10
+RUN useradd -m -u 1000 user
+USER user
+ENV HOME=/home/user \
+	PATH=/home/user/.local/bin:$PATH
+COPY --chown=user . $HOME/app
+WORKDIR $HOME/app
+RUN (cd agent & pip install -e .)
+
+CMD ["solara", "run", "agent.dashboard",  "--host", "0.0.0.0", "--port", "7860"]

agent/__init__.py

@@ -0,0 +1,3 @@
+"""APP2SCALE agent package"""
+__title__ = "Intelligent agent and its dashboard"
+__version__ = "0.0.1"

agent/backend/data.py

@@ -0,0 +1,101 @@
+import pandas as pd
+import torch
+from torch.utils.data import Dataset
+import numpy as np
+
+class ExplorationDataset(Dataset):
+    def __init__(self, df: pd.DataFrame, 
+                input_cols,
+                output_cols):
+        super().__init__()
+        self.df = df
+        self.input_cols = input_cols
+        self.output_cols = output_cols
+        self.transform_dict = self.transform_fit(df)
+        self.input_transformed = torch.tensor(self.input_transform(df[input_cols]).values).to(torch.float)
+        self.output_transformed = torch.tensor(self.output_transform(df[output_cols]).values).to(torch.float)
+                
+    def __getitem__(self, idx: int) -> tuple[torch.tensor, torch.tensor]:
+        inputs = self.input_transformed[idx]
+        outputs = self.output_transformed[idx]
+        return inputs, outputs
+    
+    def __len__(self) -> int:
+        return len(self.df)
+    
+    def transform_fit(self, df):
+        transform_dict = {}
+        for f in self.input_cols + self.output_cols:
+            if f in ['replica','cpu', 'heap']:
+                shift = df[f].median()
+                divide = 1
+                logtransform = False  
+            elif f in ['expected_tps']:
+                shift = df[f].mean()
+                divide = df[f].std()
+                logtransform = False
+            elif f in ['num_request']:
+                shift = 0
+                divide = df[f].max()
+                logtransform = False
+            elif f in ['response_time']:
+                # shift/divide is only after log
+                logtransform = True
+                shift = 0
+                divide = np.max(np.log10(df[f]))
+            else:
+                shift = 0
+                divide = 1
+                logtransform = False
+                
+            transform_dict[f] = {'shift': shift, 'divide': divide,'logtransform': logtransform}
+        return transform_dict
+        
+    def transform(self, df, cols):
+        df_transform = df.copy(deep=True)
+        for f in df.columns:
+            if f in cols:
+                shift = self.transform_dict[f]['shift']
+                divide = self.transform_dict[f]['divide']
+                logtransform = self.transform_dict[f]['logtransform']
+                if logtransform:
+                    df_transform[f] = np.log10(df_transform[f])
+                df_transform[f] =  (df_transform[f] - shift) / divide
+        return df_transform
+    
+    def inv_transform(self, df, cols):
+        df_transform = df.copy(deep=True)
+        for f in df.columns:
+            if f in cols:
+                shift = self.transform_dict[f]['shift']
+                divide = self.transform_dict[f]['divide']
+                logtransform = self.transform_dict[f]['logtransform']
+                df_transform[f] =  divide * df_transform[f] + shift
+                if logtransform:
+                    df_transform[f] = np.power(df_transform[f], 10)
+        return df_transform
+    
+    def input_transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        return self.transform(df, self.input_cols)
+    
+    def output_transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        return self.transform(df, self.output_cols)
+    
+    def input_inv_transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        return self.inv_transform(df, self.input_cols)
+
+    def output_inv_transform(self, df: pd.DataFrame) -> pd.DataFrame:
+        return self.inv_transform(df, self.output_cols)
+    
+
+def data_replica_vs_cpu_usage():
+    '''Replica versus cpu_usage'''
+    df = pd.read_csv('averaged_full_state_data.csv')
+    df.query('cpu == 5 and expected_tps == 88')
+    input_cols = ['replica']
+    output_cols = ['cpu_usage']
+    other_cols = []
+    
+    
+    df = df[input_cols + output_cols + other_cols]
+    return df, input_cols, output_cols, other_cols

agent/backend/loss.py

@@ -0,0 +1,4 @@
+import torch
+
+def loss_mape(output, target):
+    return torch.mean(torch.abs((target - output) / target))

agent/backend/models.py

@@ -0,0 +1,35 @@
+import torch.nn as nn
+import torch
+
+class Perceptron(nn.Module):
+    def __init__(self, in_features: int, out_features: int):
+        super().__init__()
+        self.in_features = in_features
+        self.out_features = out_features
+        self.layer = nn.Sequential(nn.Linear(in_features=self.in_features,out_features=self.out_features))
+        
+    def forward(self, x: torch.Tensor) -> torch.Tensor:
+        out = self.layer(x)
+        return out
+    
+
+class PolicyGradientNetwork(nn.Module):
+    def __init__(self, num_inputs, num_actions, hidden_size):
+        super(PolicyGradientNetwork, self).__init__()
+
+        self.num_actions = num_actions
+        self.norm0 = nn.BatchNorm1d(num_features=num_inputs)
+        self.linear1 = nn.Linear(num_inputs, hidden_size)
+        self.linear2 = nn.Linear(hidden_size, hidden_size)
+        self.linear_act = nn.Linear(hidden_size, int(num_actions))
+
+    # a neural network two hidden layers with the same size
+    def forward(self, state):
+        x = self.norm0(state)
+        x = torch.nn.functional.gelu(self.linear1(x))
+        x = torch.nn.functional.relu(self.linear2(x))
+        x_act = self.linear_act(x)
+        x_act = torch.nn.functional.softmax(x_act, dim=1)
+
+        # return the probability list of the actions
+        return x_act

agent/backend/utils.py

@@ -0,0 +1,113 @@
+import torch
+from tqdm import tqdm
+from torch.utils.data import Dataset, DataLoader
+from functools import partial
+
+from .data import ExplorationDataset
+from .models import Perceptron
+from .loss import loss_mape
+
+
+
+def train(df, model_name, input_cols, output_cols, trn_ratio, 
+          batch_size_trn, batch_size_val, optimizer_name, learning_rate,
+          max_epoch, loss_name):
+    if model_name == "Perceptron":
+        model = Perceptron(in_features=len(input_cols), out_features=len(output_cols))
+    if loss_name == "mape":
+        loss_fn = loss_mape
+    ds = ExplorationDataset(df, input_cols=input_cols, output_cols=output_cols)
+
+    trn_size = int(len(ds)*trn_ratio)
+    val_size = len(ds) - trn_size
+    ds_trn, ds_val = torch.utils.data.random_split(ds, [trn_size, val_size])
+    dl_trn = DataLoader(ds_trn, batch_size=batch_size_trn, shuffle=True)
+    dl_val = DataLoader(ds_val, batch_size=batch_size_val, shuffle=True)
+
+    if optimizer_name == "Adam":
+        optimizer_fn = partial(torch.optim.Adam,lr=learning_rate)
+    print('backend training ...')
+    print('training in progress...', len(df))
+    print('data columns', list(df.columns))
+    print('input columns', input_cols)
+    print('output columns', output_cols)
+    print('training ratio', trn_ratio)
+    print('batch size trainig', batch_size_trn)
+    print('batch size validation', batch_size_val)
+    print(f'Number of samples {len(ds)}')
+    print(f'Number of samples in training {len(ds_trn)}')
+    print(f'Number of samples in validation {len(ds_val)}')
+    print(f'Learning rate: {learning_rate}')
+    print(f'Optimizer {optimizer_name}')
+    print(f'Max epoch: {max_epoch}')
+
+    x, y = ds[0]
+    in_features = x.shape[0]
+    out_features = y.shape[0]
+
+
+    optimizer = optimizer_fn(model.parameters())
+
+    #epochbar = tqdm(range(max_epoch))
+    for ep in range(max_epoch):
+        model.train()
+        for x, y in dl_trn:
+            optimizer.zero_grad()
+            y_pred = model(x)
+            loss = loss_fn(y_pred, y)
+            loss.backward()
+            optimizer.step()
+
+        trn_loss = evaluate(model, dl_trn, loss_fn)
+        val_loss = evaluate(model, dl_val, loss_fn)
+        #epochbar.set_postfix(epoch=ep+1,loss=loss.item(),val_loss=val_loss)
+        yield ep, trn_loss, val_loss, None
+        
+    return ep, trn_loss, val_loss, model
+
+def predict(model, dataloader):
+    with torch.no_grad():
+        predictions = torch.empty(0, model.out_features)
+        targets = torch.empty(predictions.shape)
+        for x, y in dataloader:
+            y_pred = model.forward(x)
+            predictions = torch.cat([predictions, y_pred], dim=0)
+            targets = torch.cat([targets, y], dim=0)
+        return predictions, targets
+
+def evaluate(model, dataloader, loss_fn):
+    with torch.no_grad():
+        avg_loss = 0
+        for x, y in dataloader:
+            y_pred = model.forward(x)
+            loss = loss_fn(y_pred, y)
+            avg_loss += loss.item()
+        avg_loss = avg_loss / len(dataloader) 
+        return avg_loss
+    
+
+def update_policy(model, rewards, log_probabilities, gamma, learning_rate, optimizer):
+    discounted_rewards = []
+
+    for t in range(len(rewards)):
+        gt = 0
+        pw = 0
+        for r in rewards[t:]:
+            gt = gt + gamma ** pw * r
+            pw = pw + 1
+        discounted_rewards.append(gt)
+
+    discounted_rewards = torch.tensor(discounted_rewards)
+    # normalize discounted rewards
+    discounted_rewards = (discounted_rewards - discounted_rewards.mean()) / (discounted_rewards.std(0) + 1e-9)
+
+    policy_gradient = []
+    for log_probability, gt in zip(log_probabilities, discounted_rewards):
+        policy_gradient.append(-log_probability * gt)
+        # policy_gradient.append(1.0 / log_probability * gt)
+
+    model.optimizer.zero_grad()
+    policy_gradient = torch.stack(policy_gradient).sum()
+    # policy_gradient.backward()
+    policy_gradient.backward(retain_graph=True)
+    optimizer.step()

agent/dashboard/__init__.py

@@ -0,0 +1,8 @@
+import solara
+
+@solara.component
+def Page():
+    with solara.VBox() as main:
+        solara.Text("Home")
+
+    return main

agent/dashboard/data.py

@@ -0,0 +1,93 @@
+import solara
+import pandas as pd
+from typing import Optional, cast
+import solara.express as solara_px
+
+df = pd.read_csv('agent/data/averaged_full_state_data.csv')
+
+state = solara.reactive(
+    {
+        'data': df ,
+        'x':  solara.reactive('expected_tps'),
+        'y':  solara.reactive('avg_num_request'),
+        'logx': solara.reactive(False),
+        'logy': solara.reactive(False),
+        'size_max': solara.reactive(10.0),
+        'size': solara.reactive('replica'),
+        'color': solara.reactive('cpu_usage'),
+        'filter': solara.reactive(None),
+    }
+    )
+
+@solara.component
+def FilteredDataFrame(df):
+    filter = state.value['filter'].value
+ 
+    dff = df
+    if filter is not None:
+        dff = df[filter]
+    solara.DataFrame(dff, items_per_page=10)
+
+@solara.component
+def FilterPanel(df):
+    solara.CrossFilterReport(df, classes=["py-2"])
+    solara.CrossFilterSelect(df, configurable=False, column='replica')
+    solara.CrossFilterSelect(df, configurable=False, column='cpu')
+    solara.CrossFilterSelect(df, configurable=False, column='expected_tps')
+    solara.CrossFilterSelect(df, configurable=False, column='previous_tps')
+
+
+
+@solara.component
+def ExecutionPanel():
+    solara.Text("Execution Panel")
+
+@solara.component
+def DataViewer(df):
+    input_cols, set_input_cols = solara.use_state(['replica'])
+
+    filter = state.value['filter'].value
+
+    dff = df
+    if filter is not None:
+        dff = df[filter]
+
+    with solara.Sidebar():
+        FilterPanel(df)
+        with solara.Card("Controls", margin=0, elevation=0):
+                with solara.Column():
+                    columns = list(df.columns)
+                    solara.SliderFloat(label="Size Max", value=state.value['size_max'], min=1, max=100, on_value=state.value['size_max'].set)
+                    solara.Checkbox(label="Log x", value=state.value['logx'], on_value=state.value['logx'].set)
+                    solara.Checkbox(label="Log y", value=state.value['logy'], on_value=state.value['logy'].set)
+                    solara.Select("Size", values=columns, value=state.value['size'].value, on_value=state.value['size'].set)
+                    solara.Select("Color", values=columns, value=state.value['color'].value, on_value=state.value['color'].set)
+                    solara.Select("Column x", values=columns, value=state.value['x'].value, on_value=state.value['x'].set)
+                    solara.Select("Column y", values=columns, value=state.value['y'].value, on_value=state.value['y'].set)
+
+       
+    solara.CrossFilterDataFrame(df, items_per_page=10)
+
+
+    if state.value['x'].value and state.value['y'].value:
+        solara_px.scatter(
+            dff,
+            state.value['x'].value,
+            state.value['y'].value,
+            size=state.value['size'].value,
+            color=state.value['color'].value,
+            size_max=state.value['size_max'].value,
+            log_x=state.value['logx'].value,
+            log_y=state.value['logy'].value,
+        )
+    else:
+        solara.Warning("Select x and y columns")
+            
+@solara.component 
+def Page():
+    #if state.value['filter'].value is None:
+    #    print('setting....')
+    #    filter, set_filter = solara.use_cross_filter(id(state.value['data']))
+    #    state.value['filter'].set(filter)
+
+    DataViewer(state.value['data'])

agent/dashboard/training.py

@@ -0,0 +1,172 @@
+import solara
+import pandas as pd
+from typing import Optional, cast
+import solara.express as solara_px
+from .data import state
+from ..backend.utils import train
+from ..backend.loss import loss_mape
+
+local_state = solara.reactive(
+    {
+        'input_cols': solara.reactive(['replica']),
+        'output_cols': solara.reactive(['cpu_usage']),
+        'trn_ratio' : solara.reactive(0.8),
+        'learning_rate_log10': solara.reactive(-3),
+        'batch_size_trn': solara.reactive(32),
+        'batch_size_val': solara.reactive(16),
+        'model_name': solara.reactive("Perceptron"),
+        'optimizer_name': solara.reactive("Adam"),
+        'max_epoch': solara.reactive(100),
+        'loss_name': solara.reactive('mape'),
+        'loss_plot_data': solara.reactive({'epoch': [], 'trn_loss': [], 'val_loss': []}),
+        'render_count': solara.reactive(0),
+        'model': solara.reactive(None),
+    }
+    )
+
+@solara.component
+def LossPlot(data, render_count):
+    options = {
+        "xAxis": {
+            "type": "category",
+            "data": data['epoch'],
+        },
+        "yAxis": {
+            "type": "value",
+        },
+        "series": [ 
+            {
+                "data": data['trn_loss'],
+                "type": 'line'
+            },
+            {
+                "data": data['val_loss'],
+                "type": 'line'
+            },            
+        ]
+    }
+
+    with solara.Column():
+        solara.FigureEcharts(option=options)
+
+def force_render():
+    local_state.value['render_count'].set(1 + local_state.value['render_count'].value)
+
+@solara.component
+def FilterPanel(df):
+    solara.CrossFilterReport(df, classes=["py-2"])
+    for col in ['replica','cpu','expected_tps','previous_tps']:
+        if col in df.columns:
+            solara.CrossFilterSelect(df, configurable=False, column=col)
+
+@solara.component
+def ExecutePanel(df):
+    filter, set_filter = solara.use_cross_filter(id(df))
+
+    dff = df
+    if filter is not None:
+        dff = df[filter]
+
+    def trigger_training():
+
+        input_cols = local_state.value['input_cols'].value
+        output_cols = local_state.value['output_cols'].value
+        trn_ratio = local_state.value['trn_ratio'].value
+        batch_size_trn = local_state.value['batch_size_trn'].value
+        batch_size_val = local_state.value['batch_size_val'].value
+        learning_rate_log10 = local_state.value['learning_rate_log10'].value
+        learning_rate = 10**learning_rate_log10
+        optimizer_name = local_state.value['optimizer_name'].value
+        max_epoch = local_state.value['max_epoch'].value
+        loss_name = local_state.value['loss_name'].value
+
+        epoch_list = []
+        trn_loss_list = []
+        val_loss_list = []
+        for epoch, trn_loss, val_loss, model in train(dff, "Perceptron", input_cols, output_cols, trn_ratio,
+              batch_size_trn, batch_size_val, optimizer_name, learning_rate,
+              max_epoch, loss_name):
+            epoch_list.append(epoch)
+            trn_loss_list.append(trn_loss)
+            val_loss_list.append(val_loss)
+            local_state.value['loss_plot_data'].set(
+                {'epoch':epoch_list,
+                 'trn_loss': trn_loss_list,
+                 'val_loss': val_loss_list})
+            force_render()
+        local_state.value['model'].set(model)
+    solara.Button(label='Train', on_click=trigger_training)
+    LossPlot(local_state.value['loss_plot_data'].value, local_state.value['render_count'].value)
+
+
+@solara.component
+def ParameterSelection(df):
+    def select_input_cols(selected_cols):
+        local_state.value['input_cols'].set(selected_cols)
+    def select_output_cols(selected_cols):
+        local_state.value['output_cols'].set(selected_cols)
+
+    with solara.Row():
+        with solara.Columns([50,50]):
+            with solara.Column():
+                solara.SelectMultiple(label='Input cols', all_values=list(df.columns), 
+                            values=local_state.value['input_cols'].value,
+                            on_value=select_input_cols)
+                solara.SelectMultiple(label='Output cols', all_values=list(df.columns), 
+                            values=local_state.value['output_cols'].value,
+                            on_value=select_output_cols)
+                solara.Select(label="Optimizer", values=["Adam"], 
+                            value=local_state.value['optimizer_name'].value,
+                            on_value=local_state.value['optimizer_name'].set)
+                
+                solara.Select(label="Model", values=["Perceptron"], 
+                            value=local_state.value['model_name'].value,
+                            on_value=local_state.value['model_name'].set)
+                
+                solara.Select(label="Loss", values=['mape'], 
+                            value=local_state.value['loss_name'].value,
+                            on_value=local_state.value['loss_name'].set)
+                
+            with solara.Column():
+                solara.SliderFloat(label='Training ratio', 
+                                value=local_state.value['trn_ratio'].value, min=0, max=1,
+                                on_value=local_state.value['trn_ratio'].set,
+                                thumb_label=True)
+                solara.SliderInt(label='Batch size training', 
+                                value=local_state.value['batch_size_trn'].value, min=1, max=256,
+                                on_value=local_state.value['batch_size_trn'].set,
+                                thumb_label=True)   
+                solara.SliderInt(label='Batch size validation', 
+                                value=local_state.value['batch_size_val'].value, min=1, max=256,
+                                on_value=local_state.value['batch_size_val'].set,
+                                thumb_label=True)  
+                solara.SliderInt(label='Max epoch', 
+                                value=local_state.value['max_epoch'].value, min=1, max=1000,
+                                on_value=local_state.value['max_epoch'].set,
+                                thumb_label=True)    
+                solara.SliderFloat(label="Learning rate log10",
+                                value=local_state.value['learning_rate_log10'].value, 
+                                min=-4, max=1, step=0.01,
+                                on_value=local_state.value['learning_rate_log10'].set)
+    
+
+        
+
+@solara.component
+def Page():
+    df = state.value['data']
+    dff = df
+    filtered_cols = []
+    if len(local_state.value['input_cols'].value) > 0:
+        filtered_cols += local_state.value['input_cols'].value
+    if len(local_state.value['output_cols'].value) > 0:
+        filtered_cols += local_state.value['output_cols'].value
+    if len(filtered_cols) > 0:
+        dff = df[filtered_cols]
+    with solara.Columns([40,30,30]):
+        ParameterSelection(df)
+        FilterPanel(dff)
+        solara.CrossFilterDataFrame(dff, items_per_page=10)
+    ExecutePanel(dff)
+
+    

mypy.ini

@@ -0,0 +1,3 @@
+[mypy]
+check_untyped_defs = True
+ignore_missing_imports = True

pyproject.toml

@@ -0,0 +1,30 @@
+[build-system]
+requires = ["hatchling >=0.25"]
+build-backend = "hatchling.build"
+
+[project]
+name = "agent"
+license = {file = "LICENSE"}
+classifiers = ["License :: OSI Approved :: MIT License"]
+dynamic = ["version", "description"]
+dependencies = [
+    "solara",
+    "pandas",
+    "torch",
+    "plotly",
+    "tqdm",
+]
+
+[tool.hatch.version]
+path = "agent/__init__.py"
+
+
+
+[project.urls]
+Home = "https://www.github.com/app2scale/dashboard"
+
+[tool.black]
+line-length = 160
+
+[tool.isort]
+profile = "black"