Create app.py

app.py

@@ -0,0 +1,246 @@
+import os
+import csv
+import gradio as gr
+import tensorflow as tf
+import numpy as np
+import pandas as pd
+from datetime import datetime
+import utils
+from huggingface_hub import Repository
+import itertools
+
+# Unique phase elements
+
+# 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"
+
+scaling_factors = {'PROPERTY: Calculated Density (g/cm$^3$)': (5.5, 13.7),
+                   'PROPERTY: Calculated Young modulus (GPa)': (77.0, 336.0),
+                   'PROPERTY: HV': (107.0, 1183.0),
+                   'PROPERTY: YS (MPa)': (62.0, 3416.0)}
+
+input_mapping = {'PROPERTY: BCC/FCC/other': {'BCC': 0, 'FCC': 1, 'OTHER': 2, 'nan': 2},
+                 'PROPERTY: Processing method': {'ANNEAL': 0, 'CAST': 1, 'OTHER': 2, 'POWDER': 3, 'WROUGHT': 4, 'nan': 2},
+                 'PROPERTY: Microstructure': {'B2': 0, 'B2+BCC': 1, 'B2+L12': 2, 'B2+Laves+Sec.': 3, 'B2+Sec.': 4, 'BCC': 5,
+                                              'BCC+B2': 6, 'BCC+B2+FCC': 7, 'BCC+B2+FCC+Sec.': 8, 'BCC+B2+L12': 9, 'BCC+B2+Laves': 10,
+                                              'BCC+B2+Sec.': 11, 'BCC+BCC': 12, 'BCC+BCC+HCP': 13, 'BCC+BCC+Laves': 14,
+                                              'BCC+BCC+Laves(C14)': 15, 'BCC+BCC+Laves(C15)': 16, 'BCC+FCC': 17, 'BCC+HCP': 18,
+                                              'BCC+Laves': 19, 'BCC+Laves(C14)': 20, 'BCC+Laves(C15)': 21, 'BCC+Laves+Sec.': 22,
+                                              'BCC+Sec.': 23, 'FCC': 24, 'FCC+B2': 25, 'FCC+B2+Sec.': 26, 'FCC+BCC': 27,
+                                              'FCC+BCC+B2': 28, 'FCC+BCC+B2+Sec.': 29, 'FCC+BCC+BCC': 30, 'FCC+BCC+Sec.': 31,
+                                              'FCC+FCC': 32, 'FCC+HCP': 33, 'FCC+HCP+Sec.': 34, 'FCC+L12': 35, 'FCC+L12+B2': 36,
+                                              'FCC+L12+Sec.': 37, 'FCC+Laves': 38, 'FCC+Laves(C14)': 39, 'FCC+Laves+Sec.': 40,
+                                              'FCC+Sec.': 41, 'L12+B2': 42, 'Laves(C14)+Sec.': 43, 'OTHER': 44, 'nan': 44},
+                 'PROPERTY: Single/Multiphase': {'': 0, 'M': 1, 'S': 2, 'OTHER': 3, 'nan': 3}}
+
+unique_phase_elements = ['B2', 'BCC', 'FCC', 'HCP', 'L12', 'Laves', 'Laves(C14)', 'Laves(C15)', 'Sec.', 'OTHER']
+
+input_cols = {
+    "PROPERTY: Alloy formula": "(PROPERTY: Alloy formula) "
+                               "Recommended alloy formula using proportions representation (i.e. Al0.25 Co1 Fe1 Ni1)",
+    "PROPERTY: Single/Multiphase": "(PROPERTY: Single/Multiphase) "
+                                   "Recommended between Single (S), Multiphase (M) and other (OTHER)",
+    "PROPERTY: BCC/FCC/other": "(PROPERTY: BCC/FCC/other) "
+                               "Recommended microstructure between BCC, FCC and other ",
+    "PROPERTY: Processing method": "(PROPERTY: Processing method) "
+                                   "Recommended processing method (ANNEAL, CAST, POWDER, WROUGHT or OTHER)",
+    "PROPERTY: Microstructure": "(PROPERTY: Microstructure) "
+                                "Recommended microstructure (SEC means the secondary/tertiary microstructure is not one of FCC, BCC, HCP, L12, B2, Laves, Laves (C14), Laves (C15))",
+}
+
+def process_microstructure(list_phases):
+    permutations = list(itertools.permutations(list_phases))
+    permutations_strings = [str('+'.join(list(e))) for e in permutations]
+    for e in permutations_strings:
+        if e in list(input_mapping['PROPERTY: Microstructure'].keys()):
+            return e
+    return 'OTHER'
+    
+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())}
+    #             )
+    print(message)
+    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("models/hardness_old.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_hardness, fig2 = utils.interpret(x)
+    #interpret_fig_ys = utils.interpret(x, 1)
+    return (np.round(y_hardness*(maximum_hardness-minimum_hardness)+minimum_hardness, 2), 12, interpret_fig_hardness)
+
+
+def predict_from_tuple(in1, in2, in3, in4, in5, request: gr.Request):
+    """
+    Predict the hardness using the ML model. Input data is a tuple. Input order should be the same as the cols list
+    """
+    input_tuple = (in1, in2, in3, in4, in5)
+    formula = utils.normalize_and_alphabetize_formula(in1)
+    density = utils.calculate_density(formula)
+    young_modulus = utils.calculate_youngs_modulus(formula)
+    input_dict = {}
+
+    in2 = input_mapping['PROPERTY: Single/Multiphase'][str(in2)]
+    input_dict['PROPERTY: Single/Multiphase'] = [int(in2)]
+    
+    in3 = input_mapping['PROPERTY: BCC/FCC/other'][str(in3)]
+    input_dict['PROPERTY: BCC/FCC/other'] = [int(in3)]
+    
+    in4 = input_mapping['PROPERTY: Processing method'][str(in4)]
+    input_dict['PROPERTY: Processing method'] = [int(in4)]
+
+    in5 = process_microstructure(in5)
+    in5 = input_mapping['PROPERTY: Microstructure'][in5]
+    input_dict['PROPERTY: Microstructure'] = [int(in5)]
+    
+    density_scaling_factors = scaling_factors['PROPERTY: Calculated Density (g/cm$^3$)']
+    density = (density-density_scaling_factors[0])/(
+        density_scaling_factors[1]-density_scaling_factors[0])
+    input_dict['PROPERTY: Calculated Density (g/cm$^3$)'] = [float(density)]
+
+    
+    ym_scaling_factors = scaling_factors['PROPERTY: Calculated Young modulus (GPa)']
+    young_modulus = (young_modulus-ym_scaling_factors[0])/(
+        ym_scaling_factors[1]-ym_scaling_factors[0])
+    input_dict['PROPERTY: Calculated Young modulus (GPa)'] = [float(young_modulus)]
+
+    input_df = pd.DataFrame.from_dict(input_dict)
+    one_hot = utils.turn_into_one_hot(input_df, input_mapping)
+    print("One hot columns are ", one_hot.columns)
+    # return predict(input_df, request)
+    return predict(one_hot, request)
+
+
+def predict_inverse(target_hardness, target_yield_strength, request: gr.Request):
+    return "Al1", "S", "BCC", "CAST", "HCP"
+
+
+example_inputs = [420, 10]
+
+css_styling = """#submit {background: #1eccd8} 
+submit {color: white} 
+.output-image, .input-image, .image-preview {height: 250px !important}
+.output-plot {height: 250px !important}"""
+
+new_blue_color = gr.themes.Color(c50="#FFFFFF", # Dataframe background cell content - light mode only
+                                c100="#0c1538", # Text of markdown (headers) and componnet contencts
+                                c200="#000000", # Text of component headers
+                                c300="#a1c6db", # Login button when used in primary color
+                                c400="#000000", # Text of "or" objects and footer
+                                c500="#000000", # Text of component headers in light mode only
+                                c600="#e4f3fa", # Clear button (gradient between c600 and c700 + mouse over)
+                                c700="#a1c6db", # Componennt borders
+                                c800="#e4f3fa", # Background of components
+                                c900="#a1c6db", # Etiquette of components
+                                c950="#FFFFFF") # Background
+# 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=new_blue_color)
+page_title = "Alloys' hardness and yield strength prediction"
+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 alloy recommendations based on your target performance</p>")
+    gr.Markdown("This AI model provides a recommended alloy formula, microstructure and processing conditions based on your target hardness and yield strength")
+    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 performance of your alloy")
+            input_hardness = gr.Text(label="Enter your target hardness (in HV)")
+            input_yield_strength = gr.Text(label="Enter your target yield strength (MPa)")
+        with gr.Column():
+            gr.Markdown("### Your optimal formulation and processing conditions")
+            output_formula = gr.Textbox(
+                lines=1, label=input_cols["PROPERTY: Alloy formula"]
+            )
+            output_phase = gr.Dropdown(
+                choices=list(input_mapping["PROPERTY: Single/Multiphase"].keys()),
+                label=input_cols["PROPERTY: Single/Multiphase"],
+            )
+            output_bccfcc = gr.Dropdown(
+                choices=list(input_mapping["PROPERTY: BCC/FCC/other"].keys()),
+                label=input_cols["PROPERTY: BCC/FCC/other"],
+            )
+            output_processing = gr.Dropdown(
+                choices=list(input_mapping["PROPERTY: Processing method"].keys()),
+                label=input_cols["PROPERTY: Processing method"],
+            )
+            output_microstructure = gr.CheckboxGroup(
+                choices=unique_phase_elements, #list(input_mapping["PROPERTY: Microstructure"].keys()),
+                label=input_cols["PROPERTY: Microstructure"],
+            )
+        
+        # with gr.Column():
+        #     gr.Markdown("### Your alloy's yield strength (MPa)")
+        #     output_ys = gr.Text(label="Yield Strength (MPa)")
+        #     output_ys_uncertainty = gr.Text(label="Yield strength uncertainty (%)")
+        #     output_ys_interpretation = gr.Plot(label="Yield strength interpretation")
+    with gr.Row():
+        gr.Examples([example_inputs], [input_hardness, input_yield_strength])
+            
+            
+
+    prediction_button.click(
+        fn=predict_inverse,
+        inputs=[input_hardness, input_yield_strength],
+        outputs=[
+            output_formula,
+            output_phase,
+            output_bccfcc,
+            output_processing, 
+            output_microstructure 
+        ],
+        show_progress=True,
+    )
+    clear_button.click(
+        lambda x: [gr.update(value=None)] * 8,
+        [],
+        [
+            output_formula,
+            output_phase,
+            output_bccfcc,
+            output_processing,
+            output_microstructure,
+            input_hardness,
+            input_yield_strength,
+        ],
+    )
+
+
+if __name__ == "__main__":
+    demo.queue(concurrency_count=2)
+    demo.launch()