def generate_composite_front(*fronts):
_fronts = np.vstack(fronts)
cf = _fronts[nds(_fronts)[0][0]]
return cf
def non_dominated(self):
"""Fix this. check if nd2 and nds mean the same thing"""
obj = self.objectives
num_obj = obj.shape[1]
if num_obj == 2:
non_dom_front = nd2(obj)
else:
non_dom_front = nds(obj)
if isinstance(non_dom_front, tuple):
self.non_dom = self.objectives[non_dom_front[0][0]]
elif isinstance(non_dom_front, np.ndarray):
self.non_dom = self.objectives[non_dom_front]
else:
print("Non Dom error Line 285 in population.py")
return non_dom_front
def select(self, population, max_rank=20) -> list:
"""Of the population, individuals lower than max_rank are selected.
Return indices of selected individuals.
Parameters
----------
population : Population
Contains the current population and problem
information.
max_rank : int
Select only individuals lower than max_rank
Returns
-------
list
List of indices of individuals to be selected.
"""
# Calculating fronts and ranks
_, _, _, rank = nds(population.fitness)
selection = np.nonzero(rank > max_rank)
return selection[0]
def do(self, pop: Population, vectors: ReferenceVectors,
reference_point: np.ndarray) -> List[int]:
"""Select individuals for mating for NSGA-III.
Parameters
----------
pop : Population
The current population.
vectors : ReferenceVectors
Class instance containing reference vectors.
Returns
-------
List[int]
List of indices of the selected individuals
"""
ref_dirs = vectors.values_planar
fitness = np.asarray([
scalar(pop.fitness, reference_point)
for scalar in self.scalarization_methods
]).T
# Calculating fronts and ranks
fronts, dl, dc, rank = nds(fitness)
non_dominated = fronts[0]
fmin = np.amin(fitness, axis=0)
self.ideal = np.amin(np.vstack((self.ideal, fmin)), axis=0)
# Calculating worst points
self.worst_fitness = np.amax(np.vstack((self.worst_fitness, fitness)),
axis=0)
worst_of_population = np.amax(fitness, axis=0)
worst_of_front = np.max(fitness[non_dominated, :], axis=0)
self.extreme_points = self.get_extreme_points_c(
fitness[non_dominated, :],
self.ideal,
extreme_points=self.extreme_points)
nadir_point = self.get_nadir_point(
self.extreme_points,
self.ideal,
self.worst_fitness,
worst_of_population,
worst_of_front,
)
# Finding individuals in first 'n' fronts
selection = np.asarray([], dtype=int)
for front_id in range(len(fronts)):
if len(np.concatenate(fronts[:front_id + 1])) < self.n_survive:
continue
else:
fronts = fronts[:front_id + 1]
selection = np.concatenate(fronts)
break
F = fitness[selection]
last_front = fronts[-1]
# Selecting individuals from the last acceptable front.
if len(selection) > self.n_survive:
niche_of_individuals, dist_to_niche = self.associate_to_niches(
F, ref_dirs, self.ideal, nadir_point)
# if there is only one front
if len(fronts) == 1:
n_remaining = self.n_survive
until_last_front = np.array([], dtype=np.int)
niche_count = np.zeros(len(ref_dirs), dtype=np.int)
# if some individuals already survived
else:
until_last_front = np.concatenate(fronts[:-1])
id_until_last_front = list(range(len(until_last_front)))
niche_count = self.calc_niche_count(
len(ref_dirs), niche_of_individuals[id_until_last_front])
n_remaining = self.n_survive - len(until_last_front)
last_front_selection_id = list(
range(len(until_last_front), len(selection)))
if np.any(selection[last_front_selection_id] != last_front):
print("error!!!")
selected_from_last_front = self.niching(
fitness[last_front, :],
n_remaining,
niche_count,
niche_of_individuals[last_front_selection_id],
dist_to_niche[last_front_selection_id],
)
final_selection = np.concatenate(
(until_last_front, last_front[selected_from_last_front]))
if self.extreme_points is None:
print("Error")
if final_selection is None:
print("Error")
else:
final_selection = selection
return final_selection.astype(int)
def NSGAIII_select(
fitness: list,
ref_dirs: "ReferenceVectors",
ideal_point: list = None,
worst_point: list = None,
extreme_points: list = None,
n_survive: int = None,
):
# Calculating fronts and ranks
fronts, dl, dc, rank = nds(fitness)
non_dominated = fronts[0]
# Calculating worst points
worst_of_population = np.amax(fitness, axis=0)
worst_of_front = np.max(fitness[non_dominated, :], axis=0)
extreme_points = get_extreme_points_c(
fitness[non_dominated, :], ideal_point, extreme_points=extreme_points
)
nadir_point = get_nadir_point(
extreme_points, ideal_point, worst_point, worst_of_population, worst_of_front
)
# Finding individuals in first 'n' fronts
selection = np.asarray([], dtype=int)
for front_id in range(len(fronts)):
if len(np.concatenate(fronts[: front_id + 1])) < n_survive:
continue
else:
fronts = fronts[: front_id + 1]
selection = np.concatenate(fronts)
break
F = fitness[selection]
last_front = fronts[-1]
# Selecting individuals from the last acceptable front.
if len(selection) > n_survive:
niche_of_individuals, dist_to_niche = associate_to_niches(
F, ref_dirs, ideal_point, nadir_point
)
# if there is only one front
if len(fronts) == 1:
n_remaining = n_survive
until_last_front = np.array([], dtype=np.int)
niche_count = np.zeros(len(ref_dirs), dtype=np.int)
# if some individuals already survived
else:
until_last_front = np.concatenate(fronts[:-1])
id_until_last_front = list(range(len(until_last_front)))
niche_count = calc_niche_count(
len(ref_dirs), niche_of_individuals[id_until_last_front]
)
n_remaining = n_survive - len(until_last_front)
last_front_selection_id = list(range(len(until_last_front), len(selection)))
if np.any(selection[last_front_selection_id] != last_front):
print("error!!!")
selected_from_last_front = niching(
fitness[last_front, :],
n_remaining,
niche_count,
niche_of_individuals[last_front_selection_id],
dist_to_niche[last_front_selection_id],
)
final_selection = np.concatenate(
(until_last_front, last_front[selected_from_last_front])
)
if extreme_points is None:
print('Error')
if final_selection is None:
print('Error')
else:
final_selection = selection
return(final_selection.astype(int), extreme_points)
import dash_bootstrap_components as dbc
import utils.dash_reusable_components as drc
import dash_table
import plotly.express as ex
import plotly.graph_objects as go
import pandas as pd
import numpy as np
from pygmo import fast_non_dominated_sorting as nds
data = pd.read_csv("./data/car_data_processed.csv", header=0)
maxi = data.loc[0]
data = data.loc[1:]
front = data.loc[nds(data.values * maxi.values)[0][2]].reset_index(drop=True)
print(len(front))
app = dash.Dash(__name__, external_stylesheets=[dbc.themes.FLATLY])
app.layout = html.Div(
children=[
# .container class is fixed, .container.scalable is scalable
dbc.Row([dbc.Col(html.H1(children="Optimization Group"))]),
dbc.Row([
dbc.Col(
children=html.Div([
dbc.Card([
html.H4(
"Researcher's Night Event",
className="card-title",
data = pd.read_csv("./data/Phone_dataset.csv", header=0)
details = pd.read_csv("./data/Phone_details.csv", header=0)
names = details.loc[0]
data = data.rename(columns=names)
details = details.rename(columns=names)
maxi = details.loc[1].astype(int)
details_on_card = details.loc[2].astype(int)
details_on_card = details.columns[details_on_card == 1]
sort_columns = details.columns[maxi != 0]
sort_data = data[sort_columns].values * maxi[sort_columns].values
front = data.loc[nds(sort_data)[0][0]].reset_index(drop=True)
numeric_cols = [
attr for attr in data
if data.dtypes[attr] == "int64" or data.dtypes[attr] == "float64"
]
other_cols = [attr for attr in data if data.dtypes[attr] == "object"]
app = dash.Dash(__name__, external_stylesheets=[dbc.themes.LITERA])
app.layout = html.Div(
children=[
# .container class is fixed, .container.scalable is scalable
dbc.Row([
dbc.Col(
def ndx(data):
return nds(data)