app.py

import GPy
import GPyOpt
import pickle
import tensorflow as tf
import numpy as np
import pandas as pd
from preprocessing_utils import encode_categorical, scale_numerical, fill_nans
import os
import gradio as gr

# Load access tokens
WRITE_TOKEN = os.environ.get("WRITE_PER") # write

# Logs repo path
dataset_url = "https://huggingface.co/datasets/sandl/upload_alloy_hardness"
dataset_path = "logs_alloy_hardness.csv"


# Input parameters
model_path = "model_coatings.h5"
model = tf.keras.models.load_model(model_path)

df_columns = ['Binder', 'NMs_Type', 'Primary_Size (nm)', 'NM-Shape', 'Substrate',
              'Microorganism ', 'Duration (h)', 'Washing_cycles', 'Reduction_%',
              'Concetration (µg/mL)', 'NPs_Synthesis_method', 'Application method\n',
              'Evalutation_Standard', 'Evalutation_Method', 'Durability test',
              'Washing_Detergent', 'Washing_Temp']

targets = ["Reduction_%"]
numerical_columns = [#'Fabric diameter for antibacterial evaluation\n(cm)',
                     'Primary_Size (nm)', 'Duration (h)', 'Washing_cycles', 'Reduction_%',
                     'Concetration (µg/mL)']

categorical_columns = [column for column in df_columns if column not in numerical_columns]

numerical_columns.remove(targets[0])

# Unpickle files

with open("one_hot_scaler.pickle", "rb") as file:
    unpickler = pickle.Unpickler(file)
    one_hot_scaler = unpickler.load()

with open("minmax_scaler_targets.pickle", "rb") as file:
    unpickler = pickle.Unpickler(file)
    minmax_scaler_targets = unpickler.load()

with open("minmax_scaler_inputs.pickle", "rb") as file:
    unpickler = pickle.Unpickler(file)
    minmax_scaler_inputs = unpickler.load()

with open("one_hot_scaler.pickle", "rb") as file:
    unpickler = pickle.Unpickler(file)
    one_hot_scaler = unpickler.load()

test_data_columns = ['Binder_ADA',
 'Binder_Alginates',
 'Binder_Anatase',
 'Binder_Butane tetracarboxylic',
 'Binder_CDA',
 'Binder_CF4 plasma',
 'Binder_CTAB',
 'Binder_Carboxylic acid ',
 'Binder_Carboxymethyl chitosan (CMCTS)',
 'Binder_Cellulase',
 'Binder_Chitosan',
 'Binder_Citric acid ',
 'Binder_Copper phosphide',
 'Binder_Date seed extract',
 'Binder_Dendrimer',
 'Binder_HSDA',
 'Binder_HY',
 'Binder_Mesosilver',
 'Binder_Multi-amino compound (RSD-NH2)',
 'Binder_NIDA',
 'Binder_Nano-clay',
 'Binder_Organosilicon',
 'Binder_PEG',
 'Binder_PS-b-PAA',
 'Binder_PUBK (hydrophilic aliphatic polyester-urethanes)',
 'Binder_Poly(quaternary ammonium salt-epoxy)',
 'Binder_Printofix® Binder MTB EG liquid',
 'Binder_Rutile',
 'Binder_SDS',
 'Binder_Seaweed',
 'Binder_Silane ',
 'Binder_Silica',
 'Binder_Silpure',
 'Binder_Sodium citrate',
 'Binder_Starch',
 'Binder_TX-100',
 'Binder_Thioglycolic acid (TGA)',
 'Binder_hexadecyltrimethoxysilane(HDTMS)',
 'Binder_hexamethyltriethylenetetramine',
 'Binder_poly-hydroxy-amino methyl silicone',
 'Binder_polyamide network polymer (PNP)',
 'NMs_Type_Ag',
 'NMs_Type_Au',
 'NMs_Type_CS',
 'NMs_Type_Ce',
 'NMs_Type_Ce_ZnO',
 'NMs_Type_Co',
 'NMs_Type_CuO',
 'NMs_Type_CuO_TiO2',
 'NMs_Type_Fe3O4',
 'NMs_Type_Fe3O4_ZnO',
 'NMs_Type_Mn',
 'NMs_Type_SA_TSA',
 'NMs_Type_SiO2_Ag_Cu',
 'NMs_Type_TiO2',
 'NMs_Type_ZnO',
 'NMs_Type_ZnO_Cs',
 'NMs_Type_ZrO2',
 'NM-Shape_Crystalline',
 'NM-Shape_Disc',
 'NM-Shape_Ellipsoidal',
 'NM-Shape_Hexagonal',
 'NM-Shape_Hierarchical',
 'NM-Shape_Irregular',
 'NM-Shape_Nanotube',
 'NM-Shape_Nanowire',
 'NM-Shape_Polygonal',
 'NM-Shape_Prism',
 'NM-Shape_Rod ',
 'NM-Shape_Spherical',
 'NM-Shape_rectangle',
 'Substrate_Bamboo',
 'Substrate_Cotton',
 'Substrate_Cotton_Polyester',
 'Substrate_Denim',
 'Substrate_PET',
 'Substrate_Polyamide',
 'Substrate_Polyester',
 'Substrate_Silk',
 'Substrate_Viscose',
 'Substrate_Wool',
 'Substrate_Wool_Polyester',
 'Substrate_cotton',
 'Microorganism _Aci_baumannii',
 'Microorganism _Alt_brassicicola',
 'Microorganism _Asp_niger',
 'Microorganism _Bac_subtilis',
 'Microorganism _C_albicans',
 'Microorganism _E_coli',
 'Microorganism _Enter_faecalis',
 'Microorganism _Fus_oxysporum',
 'Microorganism _K_aerogens',
 'Microorganism _Kle_pneumoniae',
 'Microorganism _MRSA',
 'Microorganism _Mi_canis',
 'Microorganism _Pse_aeruginosa',
 'Microorganism _S_aureus',
 'Microorganism _S_epidermis',
 'Microorganism _S_pyogenes',
 'Microorganism _Sal_typhimurium',
 'Microorganism _Tric_mentagraphytes',
 'NPs_Synthesis_method_Bio synthesis',
 'NPs_Synthesis_method_Biosythesis ',
 'NPs_Synthesis_method_Degradation',
 'NPs_Synthesis_method_Dip_coated_Temp curated_Ultrasound',
 'NPs_Synthesis_method_Not_applicable',
 'NPs_Synthesis_method_Photochemical Reduction',
 'NPs_Synthesis_method_Supplied',
 'NPs_Synthesis_method_Wet chemical reduced',
 'NPs_Synthesis_method_Wet chemistry',
 'NPs_Synthesis_method_biosynthesis-green',
 'NPs_Synthesis_method_ex situ synthesis',
 'NPs_Synthesis_method_fungal process (biosynthesis)_green synthesis',
 'NPs_Synthesis_method_green synthesis',
 'NPs_Synthesis_method_in situ',
 'NPs_Synthesis_method_in situ  synthesis',
 'NPs_Synthesis_method_in situ biosythesis',
 'NPs_Synthesis_method_in situ desposition (alkalization and deposition)',
 'NPs_Synthesis_method_in situ microwave irradiation',
 'NPs_Synthesis_method_in situ reduction',
 'NPs_Synthesis_method_in situ sol gel immersion',
 'NPs_Synthesis_method_in situ sol–gel method',
 'NPs_Synthesis_method_in situ synthesis',
 'NPs_Synthesis_method_in situ synthesized',
 'NPs_Synthesis_method_in situ ultrasound irradiation',
 'NPs_Synthesis_method_ionic gelation',
 'NPs_Synthesis_method_nebulize',
 'NPs_Synthesis_method_reducing',
 'NPs_Synthesis_method_reduction in situ',
 'NPs_Synthesis_method_reduction of celluloce in viscose',
 'NPs_Synthesis_method_reverse micellar cores',
 'NPs_Synthesis_method_sol gel',
 'NPs_Synthesis_method_sol-gel',
 'NPs_Synthesis_method_sonication',
 'NPs_Synthesis_method_sonochemical',
 'NPs_Synthesis_method_ultrasound irradiation',
 'NPs_Synthesis_method_wet chemical method',
 'NPs_Synthesis_method_wet chemistry',
 'Application method\n_ exhaustion and Pad_squeeze_dry',
 'Application method\n_Dip coating',
 'Application method\n_Dip coating and shaking',
 'Application method\n_Dip padding and microwave irradiation',
 'Application method\n_Dip-coating and Ultrasound irradiation',
 'Application method\n_Dip_coating',
 'Application method\n_Exhaust dyeing',
 'Application method\n_Grafting Wet chemical ',
 'Application method\n_Immersion',
 'Application method\n_In situ Immersion',
 'Application method\n_In situ dip-coating',
 'Application method\n_Mist',
 'Application method\n_Pad-Dry-Cure ',
 'Application method\n_Pad-Dry-Cure and Dip coating',
 'Application method\n_Pad-dry-cure',
 'Application method\n_Padding',
 'Application method\n_Pre-alkalization/sorption',
 'Application method\n_Sonochemical',
 'Application method\n_Sonochemical throwingstones',
 'Application method\n_Sonochemical/Roll to roll ',
 'Application method\n_Sonochemical/Ultrasonic irradiation',
 'Application method\n_Sonochemical/ultrasonic transducer',
 'Application method\n_Sorption',
 'Application method\n_Top-coating with Pericoat',
 'Application method\n_Ultrasonic irradiation',
 'Application method\n_Ultrasonic-mediated dip coating',
 'Application method\n_Ultrasound irradiation',
 'Application method\n_Wet-on-wet padding',
 'Application method\n_Wetting-Immersion',
 'Application method\n_Wetting-Immersion or spraying',
 'Application method\n_Wetting-Spraying',
 'Application method\n_direct multi-layer coating with a socalled\nair blade',
 'Application method\n_pad-dry-cure',
 'Application method\n_plasma jet',
 'Application method\n_ultrasonic ',
 'Evalutation_Standard_AATCC_100',
 'Evalutation_Standard_AATCC_147',
 'Evalutation_Standard_AATCC_147_ISO_20645',
 'Evalutation_Standard_AATCC_30',
 'Evalutation_Standard_ASTME_2149',
 'Evalutation_Standard_ASTM_2180',
 'Evalutation_Standard_GB_T_20944_AATCC_61',
 'Evalutation_Standard_ISO_20645',
 'Evalutation_Standard_ISO_20743',
 'Evalutation_Method_Agar_diffusion',
 'Evalutation_Method_Dyn_shake',
 'Durability test_ Memeret shaker',
 'Durability test_AATCC 124',
 'Durability test_AATCC 61',
 'Durability test_AATCC standard wash machine',
 'Durability test_Boiled',
 'Durability test_GB/T 20944.3-2008(China)',
 'Durability test_Hand washes',
 'Durability test_Home laundering machine',
 'Durability test_Home laundry washing',
 'Durability test_Home/commercial laundering',
 'Durability test_IS 687:1979',
 'Durability test_ISO 105 CO3-1982',
 'Durability test_ISO 105-C014:1989',
 'Durability test_ISO 105-C06: 2010',
 'Durability test_ISO 105-C06:1994',
 'Durability test_ISO 105-C10:2006',
 'Durability test_ISO 105-CO6-1M',
 'Durability test_ISO 105-CO6-1M ',
 'Durability test_ISO 6330 : 2000',
 'Durability test_Industrial washing machine ISO standards',
 'Durability test_Not_applicable',
 'Durability test_Ordinary washing machine',
 'Durability test_PNEN ISO 6330:2002/A1:2011',
 'Durability test_Repeated washing',
 'Durability test_UV transmission',
 'Durability test_Ultrasonic cleaner',
 'Durability test_Ultrasound bath',
 'Durability test_Washed in a bath',
 'Durability test_Washed in bath',
 'Durability test_laundering cycles',
 'Durability test_laundry cycle',
 'Durability test_laundry regimes used in hospitals',
 'Durability test_vigorous magnetic stirring',
 'Washing_Detergent_AATCC Standard Detergent WOB',
 'Washing_Detergent_AATCC WOB standard detergent',
 'Washing_Detergent_AATCC standard detergent WOB',
 'Washing_Detergent_AATCC standards specified detergent WOB',
 'Washing_Detergent_Anionic detergent',
 'Washing_Detergent_Commercial detergent',
 'Washing_Detergent_Deionized water',
 'Washing_Detergent_Distilled water',
 'Washing_Detergent_IS-I neutral soap',
 'Washing_Detergent_Na2CO3/commercial detergent',
 'Washing_Detergent_Neutral soap solution',
 'Washing_Detergent_Non-ionic detergent, Triton X-100',
 'Washing_Detergent_Nonionic detergent',
 'Washing_Detergent_Nonionic washing agent Felosan RG-N',
 'Washing_Detergent_Not_applicable',
 'Washing_Detergent_Ordinary detergent',
 'Washing_Detergent_SDC standard detergent-Sodium carbonate',
 'Washing_Detergent_Soap',
 'Washing_Detergent_Soap detergent',
 'Washing_Detergent_Sodium carbonate',
 'Washing_Detergent_Sodium carbonate and soap',
 'Washing_Detergent_Standard detergent',
 'Washing_Detergent_Tap and deionized water',
 'Washing_Detergent_Tap water',
 'Washing_Detergent_Triton-X, non-ionic detergent',
 'Washing_Detergent_nonionic detergent',
 'Washing_Detergent_sodium dodecanesulphonate',
 'Washing_Detergent_“Li Bai” washing powder',
 'Washing_Temp_25',
 'Washing_Temp_40',
 'Washing_Temp_49',
 'Washing_Temp_50',
 'Washing_Temp_60',
 'Washing_Temp_75',
 'Washing_Temp_83',
 'Washing_Temp_92',
 'Washing_Temp_95',
 'Washing_Temp_Not_applicable',
 'Washing_Temp_Room_Temp',
 'Washing_Temp_Warm water',
 'Washing_Temp_machine set with warm\nwater',
 'Washing_Temp_warm water',
 'Primary_Size (nm)',
 'Duration (h)',
 'Washing_cycles',
 'Concetration (µg/mL)']

    
### Define space and constraints

constraints = []
dimensionality_dict = {}
one_hot_mapping = {}
for c in categorical_columns:
    dimensionality_dict[c] = 0
    one_hot_mapping[c] = []
for c in categorical_columns:
    for t in test_data_columns:
        if c in t:
            dimensionality_dict[c]+=1 
            one_hot_mapping[c].append(t)

domain = []
for column in targets:
    df_columns.remove(column)
for c in df_columns:
    if c in numerical_columns:
        domain.append({'name': str(c), 'type': 'continuous', 'domain': (0.,1.)})
    else:
        domain.append({'name': str(c), 'type': 'categorical', 'domain': (0,1),
                       'dimensionality': dimensionality_dict[c]})



def write_logs(message, message_type="Prediction"):
    """
    Write logs
    """
    #with Repository(local_dir="data", clone_from=dataset_url, use_auth_token=WRITE_TOKEN).commit(commit_message="from private", blocking=False):
     #   with open(dataset_path, "a") as csvfile:
      #          writer = csv.DictWriter(csvfile, fieldnames=["name", "message", "time"])
       #         writer.writerow(
        #            {"name": message_type, "message": message, "time": str(datetime.now())}
         #       )
    return 
    
def predict(x, request: gr.Request):
    """
    Predict the hardness and yield strength using the ML model. Input data is a dataframe
    """
    loaded_model = tf.keras.models.load_model("hardness_nn_graph_separate_elements.h5")
    print("summary is", loaded_model.summary())
    #x = x.replace("", 0)
    x = np.asarray(x).astype("float32")
    y = loaded_model.predict(x)
    y_hardness = y[0][0]
    y_ys = y[0][1]
    minimum_hardness, maximum_hardness = scaling_factors['PROPERTY: HV']
    minimum_ys, maximum_ys = scaling_factors['PROPERTY: YS (MPa)']
    print("Prediction is ", y)
    if request is not None:   # Verify if request is not None (when building the app the first request is None)
        message = f"{request.username}_{request.client.host}"
        print("MESSAGE")
        print(message)
        res = write_logs(message)
    #interpret_fig = utils.interpret(x)
    return (round(y_hardness*(maximum_hardness-minimum_hardness)+minimum_hardness, 2), 12,
            round(y_ys*(maximum_ys-minimum_ys)+minimum_ys, 2), 12)

def fit_outputs_constraints(X, antimicrobial_activity_target, request: gr.Request):
    reduction_target = 100 - int(antimicrobial_activity_target)
    reduction_target_df = pd.DataFrame({'Reduction_%':[reduction_target]})
    reduction_target_df = scale_numerical(reduction_target_df, ['Reduction_%'], scaler=minmax_scaler_targets, fit=False)
    predictions = model.predict(X)[0]   
    error = np.sqrt(np.square(predictions[0]-reduction_target_df))
    return error

def predict_inverse(antimicrobial_activity_target, request: gr.Request):

    def fit_outputs(x):
        return fit_outputs_constraints(x, antimicrobial_activity_target, request)
    opt = GPyOpt.methods.BayesianOptimization(f = fit_outputs,            # function to optimize       
                                              domain = domain,        # box-constraints of the problem
                                              constraints = constraints,
                                              acquisition_type ='LCB',       # LCB acquisition
                                              acquisition_weight = 0.1)   # Exploration exploitation
    # it may take a few seconds
    opt.run_optimization(max_iter=10)
    opt.plot_convergence()

    opt = GPyOpt.methods.BayesianOptimization(f = fit_outputs,            # function to optimize       
                                              domain = domain,        # box-constraints of the problem
                                              constraints = constraints,
                                              acquisition_type ='LCB',       # LCB acquisition
                                              acquisition_weight = 0.1)   # Exploration exploitation

    x_best = opt.X[np.argmin(opt.Y)]
    best_params = dict(zip(
        [el['name'] for el in domain],
        [[x] for x in x_best]))
    optimized_x = pd.DataFrame.from_dict(best_params)
    optimized_x[numerical_columns] = minmax_scaler_inputs.inverse_transform(optimized_x[numerical_columns])

    return optimized_x


example_inputs = [80]

css_styling = """#submit {background: #1eccd8} 
#submit:hover {background: #a2f1f6} 
.output-image, .input-image, .image-preview {height: 250px !important}
.output-plot {height: 250px !important}"""

light_theme_colors = gr.themes.Color(c50="#e4f3fa", # Dataframe background cell content - light mode only
                                c100="#e4f3fa", # Top corner of clear button in light mode + markdown text in dark mode
                                c200="#a1c6db", # Component borders
                                c300="#FFFFFF", # 
                                c400="#e4f3fa", # Footer text
                                c500="#0c1538", # Text of component headers in light mode only
                                c600="#a1c6db", # Top corner of button in dark mode
                                c700="#475383", # Button text in light mode + component borders in dark mode
                                c800="#0c1538", # Markdown text in light mode
                                c900="#a1c6db", # Background of dataframe - dark mode
                                c950="#0c1538") # Background in dark mode only
# secondary color used for highlight box content when typing in light mode, and download option in dark mode
# primary color used for login button in dark mode
osium_theme = gr.themes.Default(primary_hue="cyan", secondary_hue="cyan", neutral_hue=light_theme_colors)
page_title = "Recommendation of optimal parameters to fulfill coating antimicrobial activity requirement"
favicon_path = "osiumai_favicon.ico"
logo_path  = "osiumai_logo.jpg"
html = f"""<html> <link rel="icon" type="image/x-icon" href="file={favicon_path}">
<img src='file={logo_path}' alt='Osium AI logo' width='200' height='100'> </html>"""


with gr.Blocks(css=css_styling, title=page_title, theme=osium_theme) as demo:
    #gr.HTML(html)
    gr.Markdown("# <p style='text-align: center;'>Get optimal textile coating recommendation to fufill your target antimicrobial activity requirement</p>")
    gr.Markdown("Recommendation of optimal parameters to fulfill textile coating antimicrobial activity requirement")
    with gr.Row():
        clear_button = gr.Button("Clear")
        prediction_button = gr.Button("Predict", elem_id="submit")
    with gr.Row():
        with gr.Column():
            gr.Markdown("### The target antimicrobial activity of your textile coating")
            antimicrobial_activity_target = gr.Text(label="Enter the minimum acceptable antimicrobial activity for your textile coating")

        with gr.Column():
            with gr.Row():
                with gr.Column():
                    gr.Markdown("### Optimal conditions")
                    optimal_conditions = gr.DataFrame(label="Optimal conditions")

    with gr.Row():
        gr.Examples([example_inputs], [antimicrobial_activity_target])
            
            

    prediction_button.click(
        fn=predict_inverse,
        inputs=[antimicrobial_activity_target],
        outputs=[optimal_conditions],
        show_progress=True,
    )
    clear_button.click(
        lambda x: [gr.update(value=None)] * 2,
        [],
        [
            antimicrobial_activity_target,
            optimal_conditions,
        ],
    )


if __name__ == "__main__":
    demo.queue(concurrency_count=2)
    demo.launch()