List of Objective functions in HAS (WIP)

Existing Optimization Models

Minimize an unweighted value

{  
         "minimize":{  
            "attribute":  
               {  
                  "distance_between":[  
                     "customer_loc",
                     "vG"
                  ]
               }
         }
 }

Minimize a weighted value

{
    "minimize": {
        "attribute": {
            "product": [
                200,
                {
                    "distance_between": [
                        "customer_loc",
                        "vG"
                    ]
                }
            ]
        }
    }
}

Maximize an unweighted value

{
    "maximize": {
        "attribute": {
            "reliability": [
                "URLLC"
            ]
        }
    }
}

Maximize a weighted value

{
    "maximize": {
        "attribute": {
            "product": [
                200,
                {
                    "reliability": [
                        "URLLC"
                    ]
                }
            ]
        }
    }
}

Minimize the sum of unweighted values

{
    "minimize": {
        "sum": [
            {
                "distance_between": [
                    "customer_loc",
                    "vG"
                ]
            },
            {
                "distance_between": [
                    "customer_loc",
                    "vG"
                ]
            }
        ]
    }
}

Minimize the sum of weighted values

{
    "minimize": {
        "sum": [
            {
                "product": [
                    100,
                    {
                        "distance_between": [
                            "customer_loc",
                            "vG"
                        ]
                    }
                ]
            },
            {
                "product": [
                    200,
                    {
                        "hpa_score": [
                            "vG"
                        ]
                    }
                ]
            }
        ]
    }
}

New Optimization Model

Attribute	Required	Content	Values	Description
goal	Y	String	minimize, maximize	The goal of the optimization
objective_function	Y	Objective function Object		The objective function that has to be optimized

Objective function object

Attribute

Required

Content

Values

Description

operation

Y

String

sum, min, max

The operation which will be a part of the objective function

operands

Y

List of operand object

The operand on which the operation is to be performed.

The operand can be an attribute or result of a function

inverse

N

Boolean

default : False

Flag to specify whether the objective function has to be inverted.

operand object

Attribute	Required	Content	Values	Description
weight	N	decimal	default: 1.0	Weight of the operand
objective_function	N	Objective function object
function	N	String	distance_between, latency_between, attribute	Function to be performed on the parameters
fucntion_params	N	dict		parameters on which the function will be applied. The parameters will change for each function.

Examples

1. Minimize an attribute of the demand

{
    "goal": "minimize",
    "objective_function": {
        "operand": [
            {
                "function": "attribute",
                "params": {
                    "attribute": "latency",
                    "demand": "urllc_core"
                }
            }
        ],
        "operation": "sum"
    }
}

2. Minimize the sum of the distance between the demand and the customer location.

objective function - distance_between(demand, location) + distance_between(demand, location)

{
   "goal": "minimize",
   "objective_function": {
      "operation": "sum",
      "operands": [
         {
            "function": "distance_between",
            "weight": 1.0,
            "params": {
               "demand": "vG",
               "location": "customer_loc"      
            } 
         },
         {
 	        "function": "distance_between",
            "weight": 1.0,
            "params": {
               "demand": "vFW",
               "location": "customer_loc"      
            } 
         }
      ]
   }
}

Scenario:

Minimize the sum of latencies of slice subnets

objective function - latency(demand) + latency(demand)

{
   "goal": "minimize",
   "objective_function": {
   "operation": "sum",
   "operands": [
      {
         "function": "attribute",
         "weight": 1.0,
         "params": {
            "demand": "urllc_core",
            "attribute": "latency"      
         } 
      },
      {
         "function": "attribute",
         "weight": 1.0,
         "params": {
            "demand": "urllc_ran",
            "attribute": "latency"      
         } 
      }
   ]
 }
}

Scenario:

Max [ sum ( W_bw * min (ran_nssi_bw, core_nssi_bw, tr_nssi_bw), 1/(W_lat * ( sum (w1 * ran_nssi_lat, w2 core_lat, W3* tn_lat)) ) ]

{
   "goal": "maximize",
   "objective_function": {
   "operation": "sum",
   "operands": [
      {
         "objective_function": {
             "operation": "min",
             "operand": [
                 {
                      "weight": 1.0,
                      "function": "attribute",
                      "params": {
                         "demand": "urllc_core",
                         "attribute": "throughput"
                      }
                 },
                 {
                      "weight": 1.0,
                      "function": "attribute",
                      "params": {
                         "demand": "urllc_ran",
                         "attribute": "throughput"
                      }
                 },
                 {
                      "weight": 1.0,
                      "function": "attribute",
                      "params": {
                         "demand": "urllc_transport",
                         "attribute": "throughput"
                      }
                 }
             ]
         },
         "weight": 2.0 
      },
      {
         "objective_function": {
             "inverse": true,
             "operation": "sum",
             "operand": [
                 {
                     "weight": 1.0,
                     "function": "attribute",
                     "params": {
                         "demand": "urllc_core",
                         "attribute": "latency"
                      }
                 },
                 {
                     "weight": 1.0,
                     "function": "attribute",
                     "params": {
                         "demand": "urllc_ran",
                         "attribute": "latency"
                      }
                 },
                 {
                     "weight": 1.0,
                     "function": "attribute",
                     "params": {
                         "demand": "urllc_transport",
                         "attribute": "latency"
                      }
                 }
             ]
         },
         "weight": 1.0
      }
   ]
 }
}

_bw = [100, 200, 300]

ran_nssi → property bw → func(slice_profile[])

core_nssi → property bw → func(slice_profile[])

tn_nssi → property bw→ func(slice_profile[])

Maximize (min (ran_nssi_bw, core_nssi_bw, tr_nssi_bw))

Max [ sum ( W_bw * min (ran_nssi_bw, core_nssi_bw, tr_nssi_bw), 1/(W_lat * ( sum (w1 * ran_nssi_lat, w2 core_lat, W3* tn_lat)) ) ]

Min/max operator: list of operands

Sum operator : list of operands

prod operator: weight, operand

normalized_unit = func(bw, weight, unit)

normalized_unit = func(lat, weight, unit)

Impact Analysis

API

Controller

Data

Solver

Reservation