moospread 0.1.0__py3-none-any.whl

moospread/utils/mobo_utils/evolution/norm.py

@@ -0,0 +1,40 @@
+import numpy as np
+
+# This file implements normalization procedure
+
+
+# normalize the variables, for training neural nets
+def var_normalization(individuals, low, up, lv=-1, uv=1):
+    if len(np.shape(individuals)) == 1:
+        individuals = [individuals]
+
+    variables = np.array(individuals)
+
+    low = np.array(low)
+    up = np.array(up)
+
+    normalized_vars = ((variables - low) / (up - low)) * (uv - lv) + lv
+    normalized_vars = normalized_vars.tolist()
+
+    for ind, normalized_var in zip(individuals, normalized_vars):
+        ind.normalized_var = normalized_var
+
+
+# use estimated objective limits to normalize objectives
+def obj_normalization(individuals, f_min, f_max):
+    if len(np.shape(individuals)) == 1:
+        individuals = [individuals]
+
+    fvs = np.array([ind.fitness.values for ind in individuals])
+    normalized_fvs = (fvs - f_min) / (f_max - f_min)
+    normalized_fvs = normalized_fvs.tolist()
+
+    for ind, normalized_obj_values in zip(individuals, normalized_fvs):
+        ind.normalized_obj_values = normalized_obj_values
+
+
+
+
+
+
+

moospread/utils/mobo_utils/evolution/utils.py

@@ -0,0 +1,97 @@
+import numpy as np
+from moospread.utils.mobo_utils.evolution.norm import obj_normalization
+from moospread.utils.mobo_utils.evolution.dom import pareto_dominance
+
+# several Utility Functions
+
+
+# read estimated objective limits
+def init_obj_limits(f_min, f_max):
+    if f_min is None:
+        f_min = 0
+    else:
+        print('#######')
+        print(f_min)
+        f_min = np.array(f_min)
+
+    if f_max is None:
+        f_max = f_min + 1
+    else:
+        f_max = np.array(f_max)
+
+    return f_min, f_max
+
+
+def init_scalar_rep(pop):
+    rep_individuals = {}
+
+    for ind in pop:
+        update_scalar_rep(rep_individuals, ind)
+
+    return rep_individuals
+
+
+def update_scalar_rep(rep_individuals, ind):
+    cid = ind.cluster_id
+    rep_ind = rep_individuals.get(cid)
+
+    if rep_ind is None or ind.scalar_dist < rep_ind.scalar_dist:
+        rep_individuals[cid] = ind
+        print(f"Scalar rep in cluster {cid} is updated")
+        return True
+    return False
+
+
+def get_non_dominated_scalar_rep(rep_individuals):
+    keys = set()
+    for i in rep_individuals:
+        for j in rep_individuals:
+            if j <= i:
+                continue;
+
+            ind1 = rep_individuals[i]
+            ind2 = rep_individuals[j]
+
+            r = pareto_dominance(ind1, ind2)
+            if r == 1:
+                keys.add(j)
+            elif r == 2:
+                keys.add(i)
+
+    nd_rep_individuals = {}
+
+    for i in rep_individuals:
+        if i not in keys:
+            nd_rep_individuals[i] = rep_individuals[i]
+
+    return nd_rep_individuals
+
+
+def get_pareto_rep_ind(s_rep_ind, nd_rep_individuals, ref_points):
+    cid = s_rep_ind.cluster_id
+    rp = ref_points[cid]
+
+    p_rep_ind = None
+    min_dist = float('inf')
+
+    if cid in nd_rep_individuals:
+        return s_rep_ind
+    else:
+        for i in nd_rep_individuals:
+            ind = nd_rep_individuals.get(i)
+            r = pareto_dominance(ind, s_rep_ind)
+            if r == 1:
+                dist = np.sum((ref_points[i] - rp)**2)
+                if dist < min_dist:
+                    min_dist = dist
+                    p_rep_ind = ind
+
+    return p_rep_ind
+
+
+def init_dom_rel_map(size):
+    pareto_rel = np.ones([size, size], dtype=np.int8) * (-1)
+    scalar_rel = np.ones([size, size], dtype=np.int8) * (-1)
+    return pareto_rel, scalar_rel
+
+

moospread/utils/mobo_utils/learning/model.py

@@ -0,0 +1,40 @@
+import torch.nn as nn
+
+
+class NeuralNet(nn.Module):  # defines deep feedforward neural nets
+    def __init__(self, input_size, hidden_size=200, num_hidden_layers=2, output_size=3, activation='relu'):
+        super(NeuralNet, self).__init__()
+        act_fun = get_activation(activation)
+        self.input_size = input_size
+        self.first_hidden_layer = nn.Sequential(nn.Linear(input_size, hidden_size), act_fun)
+        self.out_layer = nn.Linear(hidden_size, output_size)
+
+        self.hidden_layers = [self.first_hidden_layer]
+        for _ in range(num_hidden_layers - 1):
+            layer = nn.Sequential(nn.Linear(hidden_size, hidden_size), act_fun)
+            self.hidden_layers.append(layer)
+
+        if num_hidden_layers != 0:
+            self.hidden_layers = nn.ModuleList(self.hidden_layers)
+        else:
+            self.out_layer = nn.Linear(input_size, output_size)
+            self.hidden_layers = []
+
+    def forward(self, x):
+        for layer in self.hidden_layers:
+            x = layer(x)
+
+        x = self.out_layer(x)
+        return x
+
+
+def get_activation(activation):
+    if activation == "relu":
+        return nn.ReLU()
+    elif activation == "tanh":
+        return nn.Tanh()
+    elif activation == "sigmoid":
+        return nn.Sigmoid()
+    else:
+        raise RuntimeError("activation should be relu/tanh/sigmoid, not %s." % activation)
+

moospread/utils/mobo_utils/learning/model_init.py

@@ -0,0 +1,33 @@
+import torch
+from moospread.utils.mobo_utils.learning.utils import prepare_dom_data, compute_class_weight, load_batched_dom_data, train_nn
+from moospread.utils.mobo_utils.learning.model import NeuralNet
+import torch.nn as nn
+
+
+
+def init_dom_nn_classifier(x, y, rel_map, dom, n_var, batch_size=32,
+                           activation='relu', lr=0.001, weight_decay=0.00001):
+    device = torch.device('cuda' if torch.cuda.is_available() else 'cpu')
+    input_size = 2 * n_var
+    hidden_size = 200
+    num_hidden_layers = 3
+    epochs = 20
+    data = prepare_dom_data(x, y, rel_map, dom, data_kind='tensor', device=device)
+    # print(f"Data shape: {data.shape}")
+    # print("data[:, -1]", data[:, -1])
+    weight = compute_class_weight(data[:, -1])
+    # print(f"Class weights: {weight}")
+    if weight is None:
+        return None
+
+    net = NeuralNet(input_size, hidden_size, num_hidden_layers,
+                    activation=activation).to(device)
+
+    weight = torch.tensor(weight, device=device).float()
+    criterion = nn.CrossEntropyLoss(weight=weight)
+
+    optimizer = torch.optim.Adam(net.parameters(), lr=lr, weight_decay=weight_decay)
+    train_nn(data, load_batched_dom_data, net, criterion, optimizer, batch_size, epochs)
+    # print("Net", net)
+    return net
+

moospread/utils/mobo_utils/learning/model_update.py

@@ -0,0 +1,51 @@
+from moospread.utils.mobo_utils.learning.utils import *
+from moospread.utils.mobo_utils.learning.prediction import nn_predict_dom
+import math
+
+
+
+
+def update_dom_nn_classifier(net, x, y, rel_map, dom, problem,
+                             max_adjust_epochs=50, batch_size=32, lr=0.001,
+                             acc_thr=0.9, weight_decay=0.00001):
+    device = 'cuda'
+    max_window_size = 11 * problem.n_var + 24
+    n = len(x)
+  #  start = get_start_pos(n, max_window_size)
+
+    new_data = prepare_new_dom_data(x,y, rel_map, dom, n - 5, start=0, data_kind='tensor', device=device)
+    labels, _ = nn_predict_dom(new_data[:, :-1], net)
+
+    acc0, acc1, acc2 = get_accuracy(new_data[:, -1], labels)
+    min_acc = min(acc0, acc1, acc2)
+
+ #   print("Estimated accuracy for each class: ", acc0, acc1, acc2)
+
+    if min_acc >= acc_thr:
+        return
+
+    data = prepare_dom_data(x,y, rel_map, dom, start=0, data_kind='tensor', device=device)
+
+    weight = compute_class_weight(data[:, -1])
+    if weight is None:
+        return
+
+    weight = torch.tensor(weight, device=device).float()
+    criterion = nn.CrossEntropyLoss(weight=weight)
+
+    optimizer = torch.optim.Adam(net.parameters(), lr=lr, weight_decay=weight_decay)
+
+    adjust_epochs = max_adjust_epochs * ((acc_thr - min_acc) / acc_thr)
+
+    adjust_epochs = math.ceil(adjust_epochs)
+    train_nn(data, load_batched_dom_data, net, criterion, optimizer, batch_size, adjust_epochs)
+
+
+
+
+
+
+
+
+
+

moospread/utils/mobo_utils/learning/prediction.py

@@ -0,0 +1,116 @@
+import torch
+import torch.nn.functional as F
+import numpy as np
+from moospread.utils.mobo_utils.evolution.dom import get_inverted_dom_rel
+
+# This file implements dominance prediction in two different scenarios
+
+
+def nn_predict_dom_intra(pop, net, device): # predict the dominance relation between any two solutions in pop
+    size = len(pop)
+
+    label_matrix = np.zeros([size, size], dtype=np.int8)
+    conf_matrix = np.ones([size, size])
+
+    data = []
+    indexes = []
+    for i in range(size):
+        for j in range(i + 1, size):
+            ind1 = pop[i]
+            ind2 = pop[j]
+            # data.append(ind1.normalized_var + ind2.normalized_var)
+            a = ind1.tolist() + ind2.tolist()
+            data.append(a)
+            indexes.append((i, j))
+
+    data = torch.tensor(data, device=device).float()
+
+    labels, confidences = nn_predict_dom(data, net)
+
+    for k in range(len(indexes)):
+        i = indexes[k][0]
+        j = indexes[k][1]
+
+        label_matrix[i, j] = labels[k].item()
+        conf_matrix[i, j] = confidences[k].item()
+
+        label_matrix[j, i] = get_inverted_dom_rel(label_matrix[i, j])
+        conf_matrix[j, i] = conf_matrix[i, j]
+
+    return label_matrix, conf_matrix
+
+
+def nn_predict_dom_inter(pop1, pop2, net, device):
+    # predict the dominance relation between any two solutions from pop1 and po2 respectively
+
+    size1 = len(pop1)
+    size2 = len(pop2)
+
+    label_matrix = np.zeros([size1, size2], dtype=np.int8)
+    conf_matrix = np.ones([size1, size2])
+    data = []
+    indexes = []
+    for i in range(size1):
+        for j in range(size2):
+            ind1 = pop1[i]
+            ind2 = pop2[j]
+            a = ind1.tolist() + ind2.tolist()
+            data.append(a)
+            indexes.append((i, j))
+
+    data = torch.tensor(data, device=device).float()
+    labels, confidences = nn_predict_dom(data, net)
+    for k in range(len(indexes)):
+        i = indexes[k][0]
+        j = indexes[k][1]
+
+        label_matrix[i, j] = labels[k].item()
+
+        conf_matrix[i, j] = confidences[k].item()
+
+    return label_matrix, conf_matrix
+
+
+def nn_predict_dom(data, net):
+    # print("data shape:", data.shape)
+    n = data.shape[1] // 2
+
+    s_data = torch.cat((data[:, n:], data[:, 0:n]), dim=1)
+
+
+    net.eval()
+    with torch.no_grad():
+        y = nn_predict(data, net)
+        sy = nn_predict(s_data, net)
+    max_y, max_y_ids = y.max(dim=1)
+    max_sy, max_sy_ids = sy.max(dim=1)
+    max_sy_ids = torch.where(max_sy_ids == 1, max_sy_ids, 2 - max_sy_ids)
+
+    labels = torch.where(max_y > max_sy, max_y_ids, max_sy_ids)
+    confidences = torch.where(max_y > max_sy, max_y, max_sy)
+
+    return labels, confidences
+
+
+def nn_predict(data, net, batch_size=1000, max_size=100000):
+    if data.shape[0] < max_size:
+        y = net(data)
+        return F.softmax(y, dim=1)
+    else:
+        n = data.shape[0]
+        y_list = []
+        i = 0
+        while i < n:
+            j = i + batch_size
+            if j > n:
+                j = n
+
+            bl_data = data[i:j, :]
+
+            y = net(bl_data)
+            y = F.softmax(y, dim=1)
+            y_list.append(y)
+
+            i = j
+
+        return torch.cat(y_list, dim=0)

moospread/utils/mobo_utils/learning/utils.py

@@ -0,0 +1,143 @@
+from moospread.utils.mobo_utils.evolution.dom import access_dom_rel
+import torch
+import numpy as np
+import torch.nn as nn
+
+
+# This file implements some Utility Functions about training
+
+def prepare_dom_data(x, y, rel_map, dom, start=0, data_kind='tensor', device='cpu'):
+    n = len(x)
+    data = []
+    for i in range(start, n):
+        for j in range(start, n):
+            if i == j:
+                continue
+
+            r = access_dom_rel(i, j, x, y, rel_map, dom) 
+            d = x[i,:].tolist() + x[j,:].tolist() + [r]
+            data.append(d)
+    return get_packed_data(data, data_kind, device)
+
+
+def prepare_new_dom_data(x , y , rel_map, dom, spilt_loc, start=0, data_kind='tensor', device='cpu'):
+    n = len(x)
+
+    data = []
+
+    for i in range(start, spilt_loc):
+        for j in range(spilt_loc, n):
+            r1 = access_dom_rel(i, j, x,y, rel_map, dom)
+            d1 = x[i,:].tolist() + x[j,:].tolist() + [r1]
+
+            r2 = access_dom_rel(j, i, x,y, rel_map, dom)
+            d2 = x[j,:].tolist() + x[i,:].tolist() + [r2]
+
+            data.append(d1)
+            data.append(d2)
+
+    for i in range(spilt_loc, n):
+        for j in range(spilt_loc, n):
+            if i == j:
+                continue;
+
+            r = access_dom_rel(i, j, x,y, rel_map, dom)
+            d = x[i,:].tolist() + x[j,:].tolist() + [r]
+            data.append(d)
+    return get_packed_data(data, data_kind, device)
+
+
+def load_batched_dom_data(data, batch_size):
+    batched_data = []
+    n = data.shape[0]
+    r = torch.randperm(n)
+    data = data[r, :]
+
+    j = 0
+    while j < n:
+        k = min(j + batch_size, n)
+        x = data[j:k, :-1]
+        y = data[j:k:, -1].long()
+        batched_data.append((x, y))
+        j = k
+
+    return batched_data
+
+
+def compute_class_weight(class_labels):
+    n_examples = len(class_labels)
+
+    class_labels = class_labels.cpu().numpy()
+    n_zero = np.sum(class_labels == 0)
+    n_one = np.sum(class_labels == 1)
+    n_two = n_examples - n_zero - n_one
+
+    if n_zero == 0 or n_one == 0 or n_two == 0:
+        return None
+
+    w_zero = n_examples / (3. * n_zero)
+    w_one = n_examples / (3. * n_one)
+    w_two = n_examples / (3. * n_two)
+
+    return w_zero, w_one, w_two
+
+
+def train_nn(data, data_loader, net, criterion, optimizer, batch_size, epochs):
+    #10000 12
+    net.train()
+
+    for epoch in range(epochs):  # loop over the dataset multiple times
+        running_loss = 0.0
+        batched_data = data_loader(data, batch_size)
+        for i, d in enumerate(batched_data): #1000
+            # get the inputs; data is a list of [inputs, labels]
+            inputs, labels = d #10 *12,10*1
+            # zero the parameter gradients
+            optimizer.zero_grad()
+
+            # forward + backward + optimize
+            outputs = net(inputs)
+
+            loss = criterion(outputs, labels)
+            loss.backward() 
+            optimizer.step()
+
+            running_loss += loss.item()
+       # print(f"Epoch {epoch + 1}: {running_loss / len(batched_data)}")
+
+
+def get_packed_data(data, data_kind, device):
+    if data_kind == 'tensor':
+        return torch.tensor(data, device=device).float()
+    elif data_kind == 'ndarray':
+        return np.array(data)
+    else:
+        raise ValueError(f"{data_kind} is not a supported kind of data")
+
+
+def get_start_pos(total_size, max_window_size):
+    if max_window_size is not None and total_size > max_window_size:
+        return total_size - max_window_size
+    else:
+        return 0
+
+
+def reset_parameters(m):
+    if type(m) == nn.Linear:
+        m.reset_parameters()
+
+
+def get_accuracy(true_labels, pred_labels):
+    acc0 = acc_for_class(true_labels, pred_labels, 0)
+    acc1 = acc_for_class(true_labels, pred_labels, 1)
+    acc2 = acc_for_class(true_labels, pred_labels, 2)
+    return acc0, acc1, acc2
+
+
+def acc_for_class(true_labels, pred_labels, cls):
+    pls = pred_labels[true_labels == cls]
+
+    if len(pls) == 0:
+        return 1
+
+    return (pls == cls).sum().item() / len(pls)