Update app.py

app.py

@@ -96,47 +96,7 @@ def predict(x, request: gr.Request):
     return (round(y_hardness*(maximum_hardness-minimum_hardness)+minimum_hardness, 2), 12,
             round(y_ys*(maximum_ys-minimum_ys)+minimum_ys, 2), 12)
 
-
-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(one_hot, request)
-
-def fit_outputs_constraints(x, hardness_target, ys_target, request: gr.Request):
+def fit_outputs_constraints(x, hardness_target, ys_target, metals_to_use, request: gr.Request):
     predictions = predict(x, request)
     error_hardness = np.sqrt(np.square(predictions[0]-float(hardness_target)))
     error_ys = np.sqrt(np.square(predictions[2]-float(ys_target)))
@@ -144,47 +104,56 @@ def fit_outputs_constraints(x, hardness_target, ys_target, request: gr.Request):
           error_hardness, error_ys)
     return error_hardness + error_ys
 
-def predict_inverse(hardness_target, ys_target, formula, request: gr.Request):
+def predict_inverse(hardness_original_target, ys_original_target, request: gr.Request):
+
+    #one_hot_columns = utils.return_feature_names()
 
-    one_hot_columns = utils.return_feature_names()
+    hardness_target = (hardness_original_target-min_df_hardness)/(max_df_hardness-min_df_hardness)
+    ys_target = (ys_original_target-min_df_ys)/(max_df_ys-min_df_ys)
 
     continuous_variables = ['PROPERTY: Calculated Density (g/cm$^3$)',
-                         'PROPERTY: Calculated Young modulus (GPa)']
-    categorical_variables = list(one_hot_columns)
+                        'PROPERTY: Calculated Young modulus (GPa)',
+                        'PROPERTY: Metal Al', 'PROPERTY: Metal Co',
+                        'PROPERTY: Metal Fe', 'PROPERTY: Metal Ni', 'PROPERTY: Metal Si',
+                        'PROPERTY: Metal Cr', 'PROPERTY: Metal Nb', 'PROPERTY: Metal Ti',
+                        'PROPERTY: Metal Mn', 'PROPERTY: Metal V', 'PROPERTY: Metal Mo',
+                        'PROPERTY: Metal Cu', 'PROPERTY: Metal Ta', 'PROPERTY: Metal Zr',
+                        'PROPERTY: Metal Hf', 'PROPERTY: Metal W', 'PROPERTY: Metal Zn',
+                        'PROPERTY: Metal Sn', 'PROPERTY: Metal Re', 'PROPERTY: Metal C',
+                        'PROPERTY: Metal Pd', 'PROPERTY: Metal Sc', 'PROPERTY: Metal Y']
+    categorical_variables = list(one_hot.columns)
     for c in continuous_variables:
         categorical_variables.remove(c)
 
+    # Metals constraints 
+    metals_elements = [c for c in continuous_variables if c.startswith("PROPERTY: Metal")]
+    metals_to_use = ['Al', 'Co', 'Fe', 'Cr']
+    metals_to_use = ["PROPERTY: Metal " + metals_to_use[i] for i in range(len(metals_to_use))]
 
-    fixed_density = utils.calculate_density(str(formula))
-    fixed_ym = utils.calculate_youngs_modulus(str(formula))
-    
+    # Domain 
     domain = []
-    for c in one_hot_columns:
+    for c in one_hot.columns:
         if c in continuous_variables:
-            if c == continuous_variables[0]:
-                domain_density = (fixed_density-scaling_factors[c][0])/(
-                    scaling_factors[c][1]-scaling_factors[c][0])
-                domain.append({'name': str(c), 'type': 'continuous', 'domain': (domain_density, domain_density)})#(0.,1.)})
+            if c.startswith("PROPERTY: Metal") and c not in metals_to_use:
+                domain.append({'name': str(c), 'type': 'continuous', 'domain': (0., 0.)})
             else:
-                domain_ym = (fixed_ym-scaling_factors[c][0])/(
-                    scaling_factors[c][1]-scaling_factors[c][0])
-                domain.append({'name': str(c), 'type': 'continuous', 'domain': (domain_ym, domain_ym)})#(0.,1.)})
+                domain.append({'name': str(c), 'type': 'continuous', 'domain': (0., 1.)})#(0.,1.)})
         else:
             domain.append({'name': str(c), 'type': 'discrete', 'domain': (0,1)})
 
-    print("Domain is ", domain)
+    # Constraints 
     constraints = []
-    constrained_columns = ['Single/Multiphase', 'Preprocessing method', 'BCC/FCC/other']#, 'Microstructure']
-
+    constrained_columns = ['Single/Multiphase', 'Preprocessing method', 'BCC/FCC/other'] #'PROPERTY: Metal']#, 'Microstructure']
     for constraint in constrained_columns:
         sum_string = ''
-        for i in range (len(one_hot_columns)):
-            column_one_hot = one_hot_columns[i]
+            for i in range (len(one_hot.columns)):
+        column_one_hot = one_hot.columns[i]
             if column_one_hot.startswith(constraint):
                 sum_string = sum_string+"+x[:," + str(i) + "]"
         constraints.append({'name': constraint + "+1", 'constraint': sum_string + '-1'})
         constraints.append({'name': constraint + "-1", 'constraint': '-1*(' + sum_string + ')+1'})
 
+
     def fit_outputs(x):
         return fit_outputs_constraints(x, hardness_target, ys_target, request)
 
@@ -194,29 +163,30 @@ def predict_inverse(hardness_target, ys_target, formula, request: gr.Request):
                                               acquisition_type ='LCB',       # LCB acquisition
                                               acquisition_weight = 0.1)   # Exploration exploitation
     # it may take a few seconds
-    opt.run_optimization(max_iter=20)
-    opt.plot_convergence()
+    opt.run_optimization(max_iter=50)
+    # opt.plot_convergence()
     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)
-    #for c in optimized_x.columns:
-     #   if c in continuous_variables:
-      #      optimized_x[c]=optimized_x[c]*(scaling_factors[c][1]-scaling_factors[c][0])+scaling_factors[c][0]
-    optimized_x = optimized_x[['PROPERTY: Calculated Density (g/cm$^3$)',
-                               'PROPERTY: Calculated Young modulus (GPa)',
-                               'Preprocessing method ANNEAL',
-                               'Preprocessing method CAST', 'Preprocessing method OTHER',
-                               'Preprocessing method POWDER', 'Preprocessing method WROUGHT',
-                               'BCC/FCC/other BCC', 'BCC/FCC/other FCC', 'BCC/FCC/other OTHER',
-                               'Single/Multiphase ', 'Single/Multiphase M', 'Single/Multiphase S']]
+    for c in optimized_x.columns:
+        if c in continuous_variables:
+            if c in ['PROPERTY: Calculated Density (g/cm$^3$)', 'PROPERTY: Calculated Young modulus (GPa)']:
+                optimized_x[c]=optimized_x[c]*(scales_dictionary[c][1]-scales_dictionary[c][0])+scales_dictionary[c][0]
     result = optimized_x
-    result = result[result>0.0].dropna(axis=1)
-    return list(result.keys())[2:]
 
+    # Normalize metals outputs
+    sum_metals = np.sum(result[c] for c in list(result. columns) if c.startswith("PROPERTY: Metal"))
+    for column in result.columns:
+        if column.startswith("PROPERTY: Metal"):
+            result[column]/= sum_metals
+    result = result.transpose()
 
-example_inputs = ["Al0.25 Co1 Fe1 Ni1", 820, 1800]
+    return result
+
+
+example_inputs = [820, 1800]
 
 css_styling = """#submit {background: #1eccd8} 
 #submit:hover {background: #a2f1f6} 
@@ -253,22 +223,20 @@ with gr.Blocks(css=css_styling, title=page_title, theme=osium_theme) as demo:
         prediction_button = gr.Button("Predict", elem_id="submit")
     with gr.Row():
         with gr.Column():
-            gr.Markdown("### Your alloy formula")
-            formula = gr.Text(label = "Alloy formula")
             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():
             with gr.Row():
-                with gr.Column():
-                    gr.Markdown("### Your optimal microstructure and processing conditions")
-                #optimal_parameters = gr.DataFrame(label="Optimal parameters", wrap=True)
-                with gr.Column():
-                    param1 = gr.Text(label="Processing method")
-                with gr.Column():
-                    param2 = gr.Text(label="Microstructure")
-                with gr.Column():
-                    param3 = gr.Text(label="Phase")
+                #with gr.Column():
+                 #   gr.Markdown("### Your optimal microstructure and processing conditions")
+                optimal_parameters = gr.DataFrame(label="Optimal parameters", wrap=True)
+                #with gr.Column():
+                 #   param1 = gr.Text(label="Processing method")
+                #with gr.Column():
+                 #   param2 = gr.Text(label="Microstructure")
+                #with gr.Column():
+                 #   param3 = gr.Text(label="Phase")
             #with gr.Row():
                 #with gr.Column():
                     #with gr.Row():
@@ -284,11 +252,8 @@ with gr.Blocks(css=css_styling, title=page_title, theme=osium_theme) as demo:
 
     prediction_button.click(
         fn=predict_inverse,
-        inputs=[input_hardness, input_yield_strength, formula],
-        outputs=[
-            param1,
-            param2,
-            param3,
+        inputs=[input_hardness, input_yield_strength],
+        outputs=[optimal_parameters
         ],
         show_progress=True,
     )