Spaces:

---

wayne-chi

/

Eagle

Like 0

Paused

import streamlit as st

import pandas as pd

import matplotlib

import matplotlib.pyplot as plt

import plotly.express as px

import numpy as np

import plotly.graph_objects as go

import sqlite3

from typing import Optional, Dict, Any

from datetime import datetime, timedelta

import re

from pathlib import Path

import time # Add this import to the top of your script

import math

import plotly.graph_objects as go

from pymoo.core.problem import Problem

from pymoo.core.repair import Repair

from pymoo.algorithms.moo.nsga2 import NSGA2

from pymoo.optimize import minimize

from pymoo.core.callback import Callback

class OptimizationProgressCallback(Callback):

def __init__(self, progress_bar, total_generations):

super().__init__()

self.progress_bar = progress_bar

self.total_generations = total_generations

def notify(self, algorithm):

# Calculate progress percentage

progress_percent = algorithm.n_gen / self.total_generations

# --- FIX: Changed the text to show percentage ---

progress_text = f"Optimizing... {progress_percent:.0%}"

# Update the Streamlit progress bar

self.progress_bar.progress(progress_percent, text=progress_text)

class NormalizationRepair(Repair):

"""Ensures the first 5 variables (fractions) sum to 1."""

def _do(self, problem, X, **kwargs):

fractions = X[:, :5]

row_sums = np.sum(fractions, axis=1, keepdims=True)

row_sums[row_sums == 0] = 1

normalized_fractions = fractions / row_sums

X[:, :5] = normalized_fractions

return X

class BlendOptimizationProblem(Problem):

def __init__(self, blend_model, target_properties, fixed_inputs,

frozen_targets, input_columns, output_columns, optimize_cost=False):

self.blend_model = blend_model

self.target_properties = target_properties

self.fixed_inputs = fixed_inputs

self.frozen_targets = frozen_targets

self.input_columns = input_columns

self.output_columns = output_columns # Columns from predict_fast

self.optimize_cost = optimize_cost

n_constraints = len(self.frozen_targets)

n_obj = 2 if self.optimize_cost else 1

super().__init__(n_var=5, n_obj=n_obj, n_constr=n_constraints if n_constraints > 0 else 1, xl=0.0, xu=1.0)

self.epsilon = 1e-3

self.frozen_indices_predicted = [self.output_columns.index(f'BlendProperty{k}') for k in self.frozen_targets.keys() if f'BlendProperty{k}' in self.output_columns]

self.frozen_values = np.array([v for k, v in self.frozen_targets.items() if f'BlendProperty{k}' in self.output_columns])

self.objective_mask_predicted = np.ones(len(self.output_columns), dtype=bool)

if self.frozen_indices_predicted:

self.objective_mask_predicted[self.frozen_indices_predicted] = False

all_output_prop_indices = [int(col.replace('BlendProperty', '')) for col in self.output_columns]

self.objective_targets = np.array([

self.target_properties[prop_idx - 1]

for i, prop_idx in enumerate(all_output_prop_indices)

if self.objective_mask_predicted[i]

])

def _evaluate(self, x, out, *args, **kwargs):

fixed_data = np.tile(self.fixed_inputs, (len(x), 1))

full_input_data = np.hstack([x, fixed_data])

input_df = pd.DataFrame(full_input_data, columns=self.input_columns)

# STEP 1: Use predict_fast for optimization loop

predicted_properties = self.blend_model.predict_fast(input_df)[self.output_columns].values

error = np.sum((predicted_properties[:, self.objective_mask_predicted] - self.objective_targets)**2, axis=1)

if self.optimize_cost:

component_costs = np.array([st.session_state.get(f"opt_c{i}_cost", 0.0) for i in range(5)])

cost = input_df.iloc[:, :5].values @ component_costs

out["F"] = np.column_stack([error, cost])