Spaces:
Sleeping
Sleeping
File size: 7,684 Bytes
82aacbc |
1 2 3 4 5 6 7 8 9 10 11 12 13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33 34 35 36 37 38 39 40 41 42 43 44 45 46 47 48 49 50 51 52 53 54 55 56 57 58 59 60 61 62 63 64 65 66 67 68 69 70 71 72 73 74 75 76 77 78 79 80 81 82 83 84 85 86 87 88 89 90 91 92 93 94 95 96 97 98 99 100 101 102 103 104 105 106 107 108 109 110 111 112 113 114 115 116 117 118 119 120 121 122 123 124 125 126 127 128 129 130 131 132 133 134 135 136 137 138 139 140 141 142 143 144 145 146 147 148 149 150 151 152 153 154 155 156 157 158 159 160 161 162 163 164 165 166 167 168 169 170 171 172 |
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$)': (2.7, 13.7),
'PROPERTY: Calculated Young modulus (GPa)': (66, 336),
'PROPERTY: HV': (94.7, 1183.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+Sec.': 2, 'BCC': 3, 'BCC+B2': 4, 'BCC+B2+Laves': 5,
'BCC+B2+Sec.': 6, 'BCC+BCC': 7, 'BCC+BCC+HCP': 8, 'BCC+BCC+Laves(C15)': 9,
'BCC+FCC': 10, 'BCC+HCP': 11, 'BCC+Laves': 12, 'BCC+Laves(C14)': 13,
'BCC+Laves(C15)': 14, 'BCC+Laves+Sec.': 15, 'BCC+Sec.': 16, 'FCC': 17,
'FCC+B2': 18, 'FCC+B2+Sec.': 19, 'FCC+BCC': 20, 'FCC+BCC+B2': 21, 'FCC+BCC+B2+Sec.': 22,
'FCC+BCC+Sec.': 23, 'FCC+FCC': 24, 'FCC+HCP': 25, 'FCC+L12': 26, 'FCC+L12+Sec.': 27,
'FCC+Sec.': 28, 'OTHER': 29}, #'nan': 29},
'PROPERTY: Single/Multiphase': {'M': 0, 'S': 1, '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) "
"Enter alloy formula using proportions representation (i.e. Al0.25 Co1 Fe1 Ni1)",
"PROPERTY: Single/Multiphase": "(PROPERTY: Single/Multiphase) "
"Choose between Single (S), Multiphase (M) and other (OTHER)",
"PROPERTY: BCC/FCC/other": "(PROPERTY: BCC/FCC/other) "
"Choose between BCC, FCC and other ",
"PROPERTY: Processing method": "(PROPERTY: Processing method) "
"Choose your processing method (ANNEAL, CAST, POWDER, WROUGHT or OTHER)",
"PROPERTY: Microstructure": "(PROPERTY: Microstructure) "
"Choose the 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())}
)
return
def predict(x, request: gr.Request):
"""
Predict the hardness using the ML model. Input data is a dataframe
"""
loaded_model = tf.keras.models.load_model("hardness.h5")
x = x.replace("", 0)
x = np.asarray(x).astype("float32")
y = loaded_model.predict(x)[0][0]
minimum, maximum = scaling_factors['PROPERTY: HV']
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*(maximum-minimum)+minimum, 2), 12, interpret_fig
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)
return predict(one_hot, request)
input_formula = gr.Textbox(
lines=1, placeholder=input_cols["PROPERTY: Alloy formula"], label=input_cols["PROPERTY: Alloy formula"]
)
input_phase = gr.Dropdown(
choices=list(input_mapping["PROPERTY: Single/Multiphase"].keys()),
label=input_cols["PROPERTY: Single/Multiphase"],
)
input_bccfcc = gr.Dropdown(
choices=list(input_mapping["PROPERTY: BCC/FCC/other"].keys()),
label=input_cols["PROPERTY: BCC/FCC/other"],
)
input_processing = gr.Dropdown(
choices=list(input_mapping["PROPERTY: Processing method"].keys()),
label=input_cols["PROPERTY: Processing method"],
)
input_microstructure = gr.CheckboxGroup(
choices=unique_phase_elements, #list(input_mapping["PROPERTY: Microstructure"].keys()),
label=input_cols["PROPERTY: Microstructure"],
)
input_list = [input_formula, input_phase, input_bccfcc, input_processing, input_microstructure]
examples_inputs = ['Al0.25 Co1 Fe1 Ni1', 'S', 'BCC', 'CAST', ['B2', 'BCC']]
# Version where input is a DataFrame
# demo = gr.Interface(fn=predict,
# inputs=gr.DataFrame(headers=cols),
# outputs=gr.Text(label="Hardness (in HV)"))
demo = gr.Interface(
fn=predict_from_tuple,
inputs=input_list,
outputs=[gr.Text(label="Hardness (in HV)"), gr.Text(label="Uncertainty (%)"), gr.Plot(label="Interpretation")],
title="Predict your alloy's hardness",
description="This AI model provides the estimation of hardness based on the input alloy description",
examples=[examples_inputs],
)
if __name__ == "__main__":
demo.launch(show_error=True) |