Upload code.

.idea/.gitignore

@@ -0,0 +1,3 @@
+# Default ignored files
+/shelf/
+/workspace.xml

.idea/COMP8604.iml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<module type="PYTHON_MODULE" version="4">
+  <component name="NewModuleRootManager">
+    <content url="file://$MODULE_DIR$" />
+    <orderEntry type="inheritedJdk" />
+    <orderEntry type="sourceFolder" forTests="false" />
+  </component>
+</module>

.idea/inspectionProfiles/Project_Default.xml

@@ -0,0 +1,57 @@
+<component name="InspectionProjectProfileManager">
+  <profile version="1.0">
+    <option name="myName" value="Project Default" />
+    <inspection_tool class="PyPackageRequirementsInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredPackages">
+        <value>
+          <list size="26">
+            <item index="0" class="java.lang.String" itemvalue="yacs" />
+            <item index="1" class="java.lang.String" itemvalue="scikit-image" />
+            <item index="2" class="java.lang.String" itemvalue="numba" />
+            <item index="3" class="java.lang.String" itemvalue="filterpy" />
+            <item index="4" class="java.lang.String" itemvalue="joblib" />
+            <item index="5" class="java.lang.String" itemvalue="PyYAML" />
+            <item index="6" class="java.lang.String" itemvalue="yolov3-pytorch" />
+            <item index="7" class="java.lang.String" itemvalue="numpy" />
+            <item index="8" class="java.lang.String" itemvalue="llvmlite" />
+            <item index="9" class="java.lang.String" itemvalue="torchvision" />
+            <item index="10" class="java.lang.String" itemvalue="trimesh" />
+            <item index="11" class="java.lang.String" itemvalue="tensorflow" />
+            <item index="12" class="java.lang.String" itemvalue="gdown" />
+            <item index="13" class="java.lang.String" itemvalue="scipy" />
+            <item index="14" class="java.lang.String" itemvalue="multi-person-tracker" />
+            <item index="15" class="java.lang.String" itemvalue="smplx" />
+            <item index="16" class="java.lang.String" itemvalue="opencv-python" />
+            <item index="17" class="java.lang.String" itemvalue="h5py" />
+            <item index="18" class="java.lang.String" itemvalue="chumpy" />
+            <item index="19" class="java.lang.String" itemvalue="scikit-video" />
+            <item index="20" class="java.lang.String" itemvalue="tqdm" />
+            <item index="21" class="java.lang.String" itemvalue="tensorboard" />
+            <item index="22" class="java.lang.String" itemvalue="matplotlib" />
+            <item index="23" class="java.lang.String" itemvalue="pillow" />
+            <item index="24" class="java.lang.String" itemvalue="progress" />
+            <item index="25" class="java.lang.String" itemvalue="pyrender" />
+          </list>
+        </value>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyPep8Inspection" enabled="true" level="WEAK WARNING" enabled_by_default="true">
+      <option name="ignoredErrors">
+        <list>
+          <option value="E265" />
+          <option value="E251" />
+          <option value="E231" />
+          <option value="E225" />
+          <option value="E501" />
+        </list>
+      </option>
+    </inspection_tool>
+    <inspection_tool class="PyUnresolvedReferencesInspection" enabled="true" level="WARNING" enabled_by_default="true">
+      <option name="ignoredIdentifiers">
+        <list>
+          <option value="services.csv_service" />
+        </list>
+      </option>
+    </inspection_tool>
+  </profile>
+</component>

.idea/inspectionProfiles/profiles_settings.xml

@@ -0,0 +1,6 @@
+<component name="InspectionProjectProfileManager">
+  <settings>
+    <option name="USE_PROJECT_PROFILE" value="false" />
+    <version value="1.0" />
+  </settings>
+</component>

.idea/misc.xml

@@ -0,0 +1,4 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectRootManager" version="2" project-jdk-name="Python 3.9" project-jdk-type="Python SDK" />
+</project>

.idea/modules.xml

@@ -0,0 +1,8 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="ProjectModuleManager">
+    <modules>
+      <module fileurl="file://$PROJECT_DIR$/.idea/COMP8604.iml" filepath="$PROJECT_DIR$/.idea/COMP8604.iml" />
+    </modules>
+  </component>
+</project>

.idea/vcs.xml

@@ -0,0 +1,6 @@
+<?xml version="1.0" encoding="UTF-8"?>
+<project version="4">
+  <component name="VcsDirectoryMappings">
+    <mapping directory="$PROJECT_DIR$" vcs="Git" />
+  </component>
+</project>

Interface/empirical_parameter_calculator.py

@@ -0,0 +1,280 @@
+"""empirical parameter calculator, includes calculation functions for 14 values:
+'Enthalpy(kJ/mol)', 'std_enthalpy(kJ/mol)', 'average_atomic_radius', 'Delta(%)', 'Omega', 'Entropy(J/K*mol)', 'Tm(K)',
+'std_Tm (%)', 'X', 'std_X(%)', 'VEC', 'std_VEC', 'Density(g/com^3)', 'Price(USD/kg)'
+written by Will Nash and Zhipeng Li
+version 2.1.1"""
+
+import itertools
+import numpy as np
+import matminer.utils.data as mm_data
+
+
+# the market price for most chemical elements, these data are retrieved from
+# http://www.leonland.de/elements_by_price/en/list
+price_dic = {
+    "Ag": 462, "Al": 1.91, "Au": 38189, "B": 2386, "Be": 831.6, "Bi": 10.34, "C": 24, "Ca": 5.93, "Cd": 1.98, "Ce": 7,
+    "Co": 59.5, "Cr": 7.64, "Cu": 5.9, "Dy": 350, "Er": 95, "Fe": 0.08, "Gd": 55, "Ge": 1833, "Hf": 1414, "Ho": 1400,
+    "In": 341.6, "Ir": 31186, "La": 7, "Li": 115.7, "Lu": 6269, "Mg": 2.26, "Mn": 2.06, "Mo": 16, "Nb": 42, "Nd": 60,
+    "Ni": 9.19, "Os": 12860, "P": 300, "Pb": 2.29, "Pd": 34401, "Pr": 85, "Pt": 26492, "Re": 1635, "Rh": 76840,
+    "Ru": 14720, "Sb": 7.05, "Sc": 15000, "Si": 1.91, "Sm": 14.35, "Sn": 20, "Sr": 5.4, "Ta": 238, "Tb": 550,
+    "Ti": 3.77, "Tm": 6200, "V": 22.6, "W": 25.52, "Y": 35, "Yb": 1600, "Zn": 2.83, "Zr": 23.14, "H": 23.64,
+    "He": 40.39, "N": 2.77, "O": 0.64, "F": 1900, "Ne": 629.9, "Na": 3.04, "S": 0.1, "Cl": 1.5, "Ar": 2.56, "K": 13.02,
+    "Ga": 278.2, "As": 1.74, "Se": 30.37, "Br": 4.4, "Kr": 1.4, "Rb": 14720, "Te": 55.68, "I": 28.00,
+    "Xe": 9.2, "Cs": 73400, "Ba": 550, "Eu": 258, "Hg": 38.44, "Tl": 7400, "Th": 176, "U": 57.76,
+}
+
+
+class EmpiricalParams(object):
+    """functions for returning the empirical parameters of alloy compositions where element list is a list of pymatgen
+    Elements that are in the alloy, and mol_ratio is their respective mole ratios """
+
+    def __init__(self, element_list, mol_ratio=None):
+        self.element_list = element_list
+        if mol_ratio is None:  # assume that mol_ratio is evenly distributed amongst elements
+            mol_ratio = [1 / len(element_list)] * len(element_list)
+        self.mol_ratio = np.divide(mol_ratio, np.sum(mol_ratio))
+        self.a = self.mean_atomic_radius()
+        self.delta = self.atomic_size_difference()
+        self.Tm = self.average_melting_point()
+        self.mix_entropy = self.entropy_mixing()
+        self.mix_enthalpy = self.enthalpy_mixing()
+        self.omega = self.calc_omega()
+        self.x = self.mean_electronegativity()
+        self.std_x = self.std_electronegativity()
+        self.vec = self.average_vec()
+        self.density = self.calc_density()
+        self.price = self.calc_price()
+
+        # self.k = self.mean_bulk_modulus()
+        # self.std_k = self.std_bulk_modulus()
+        self.std_enthalpy = self.std_enthalpy_mixing()
+        self.std_Tm = self.std_melting_point()
+        self.vec_std = self.std_vec()
+
+    '''
+    2. average atomic radius
+    '''
+    def mean_atomic_radius(self):
+        """function to return the mean atomic size radius 平均原子尺寸半径 (a) of the alloy"""
+        radii = []
+        for i in range(len(self.element_list)):
+            radii.append(self.element_list[i].atomic_radius)
+        avg_radii = np.dot(radii, self.mol_ratio)
+        return avg_radii
+
+    '''
+    3. atomic size difference
+    '''
+    def atomic_size_difference(self):
+        """function to return the atomic size difference  原子半径差比率 (delta) of the alloy"""
+        delta = 0
+        radii = []
+        for i in range(len(self.element_list)):
+            radii.append(self.element_list[i].atomic_radius)
+
+        for j in range(len(self.element_list)):
+            delta += self.mol_ratio[j] * np.square((1 - np.divide(radii[j], self.a)))
+
+        return np.sqrt(delta)
+
+    '''
+    6. average melting point
+    '''
+    def average_melting_point(self):
+        """function to return the average melting point 熔点的均值 (Tm) of the alloy"""
+        Tm = 0
+        for i in range(len(self.element_list)):
+            Tm += self.mol_ratio[i] * self.element_list[i].melting_point
+        return Tm
+
+    '''
+    7. standard melting point
+    '''
+    def std_melting_point(self):
+        """function to return the standard deviation (in percentage) of melting points 熔点的标准偏差 (sigma_t) of the alloy"""
+        sigma_t = 0
+        T = []
+        for i in range(len(self.element_list)):
+            T.append(self.element_list[i].melting_point)
+
+        for j in range(len(self.element_list)):
+            sigma_t += self.mol_ratio[j] * np.square((1 - np.divide(T[j], self.Tm)))
+        return np.sqrt(sigma_t)
+
+    '''
+    1. entropy of mixing
+    '''
+    def entropy_mixing(self):
+        """function to return entropy of mixing 混合熵 for alloy elements based on Boltzmann's hypothesis"""
+        entropy = 0
+        for i in range(len(self.mol_ratio)):
+            if self.mol_ratio[i] > 0:
+                entropy += self.mol_ratio[i] * np.log(self.mol_ratio[i])
+        return -8.31446261815324 * entropy
+
+    '''
+    4. enthalpy of mixing
+    '''
+    def enthalpy_mixing(self):
+        """function to return the sum enthalpy of mixing 混合焓和 of an alloy system based on binary mixtures and the molar
+        ratio """
+        enthalpies = []
+        mol_coefficients = []
+
+        for pair in itertools.combinations(self.element_list, 2):
+            enthalpies.append(mm_data.MixingEnthalpy().get_mixing_enthalpy(*pair))
+
+        for molies in itertools.combinations(self.mol_ratio, 2):
+            mol_coefficients.append(4 * np.product(molies))
+
+        enthalpy = np.dot(enthalpies, mol_coefficients)
+        return enthalpy
+
+    '''
+    5. standard deviation of enthalpy
+    '''
+    def std_enthalpy_mixing(self):
+        """function to return the standard deviation of enthalpy of mixing 混合焓的标准偏差 (sigma_h) of the alloy"""
+        sigma_h = 0
+        H = np.zeros((len(self.element_list), len(self.element_list)))
+        for i in range(len(self.element_list)):
+            for j in range(len(self.element_list)):
+                if i != j:
+                    H[i][j] = mm_data.MixingEnthalpy().get_mixing_enthalpy(self.element_list[i], self.element_list[j])
+
+        for i in range(len(self.element_list)):
+            for j in range(len(self.element_list)):
+                if i != j:
+                    sigma_h += self.mol_ratio[i] * self.mol_ratio[j] * np.square(H[i][j] - self.enthalpy_mixing())
+        sigma_h = sigma_h / 2
+        return np.sqrt(sigma_h)
+
+    '''
+    12. Omega omega
+    '''
+    def calc_omega(self):
+        """function to return the omega value of the alloy"""
+        if np.abs(self.mix_enthalpy) < 1e-6:
+            self.mix_enthalpy = 1e-6
+        return self.Tm * self.mix_entropy / (np.abs(self.mix_enthalpy) * 1000)
+
+    '''
+    8. average electronegativity
+    '''
+    def mean_electronegativity(self):
+        """function to return the mean electronegativity 电负性的均值 (x) of the alloy"""
+        x_list = []
+        for i in range(len(self.element_list)):
+            x_list.append(self.element_list[i].X)
+        x_avg = np.dot(x_list, self.mol_ratio)
+        return x_avg
+
+    '''
+    9. standard deviation of electronegativity
+    '''
+    def std_electronegativity(self):
+        """function to return the standard deviation (in percentage) of electronegativity 电负性的标准偏差 (sigma_x) of the alloy"""
+        sigma_x = 0
+        x_list = []
+        for i in range(len(self.element_list)):
+            x_list.append(self.element_list[i].X)
+
+        for j in range(len(self.element_list)):
+            sigma_x += self.mol_ratio[j] * np.square(x_list[j] - self.x)
+        return np.sqrt(sigma_x) / self.x
+
+    '''
+    10. valence electron concentration
+    '''
+    def num_ve(self, element):
+        """function to return the number of valence electron of the element元素的价电子"""
+        e_structure = element.full_electronic_structure
+        outer = element.full_electronic_structure[-1][0]
+        num_e = 0
+        for t in e_structure:
+            if t[0] == outer - 1 and t[1] == 'd':
+                num_e += t[2]
+            if t[0] == outer:
+                num_e += t[2]
+        return num_e
+
+    '''
+     average of valence electron concentration
+    '''
+    def average_vec(self):
+        """function to return the average of valence electron concentration 价电子浓度的均值 (vec) of the alloy"""
+        vec = 0
+        for i in range(len(self.element_list)):
+            vec += self.mol_ratio[i] * self.num_ve(self.element_list[i])
+        return vec
+
+    '''
+    11. standard deviation of valence electron concentration
+    '''
+    def std_vec(self):
+        """function to return the standard deviation of valence electron concentration 价电子浓度的标准偏差 (sigma_vec) of the alloy"""
+        sigma_vec = 0
+        vec_list = []
+        for i in range(len(self.element_list)):
+            vec_list.append(self.num_ve(self.element_list[i]))
+
+        for j in range(len(self.element_list)):
+            sigma_vec += self.mol_ratio[j] * np.square(vec_list[j] - self.vec)
+        return np.sqrt(sigma_vec)
+
+    '''
+     average of bulk modulus
+    '''
+    def mean_bulk_modulus(self):
+        """function to return the average of bulk modulus (k)体积弹性模量 of the alloy"""
+        k = 0
+        for i in range(len(self.element_list)):
+            if self.element_list[i].bulk_modulus is None:
+                print(self.element_list[i])
+            else:
+                k += self.mol_ratio[i] * self.element_list[i].bulk_modulus
+        return k
+
+    '''
+     standard deviation of bulk modulus
+    '''
+    def std_bulk_modulus(self):
+        """function to return the standard deviation of bulk modulus (k)体积弹性模量 of the alloy"""
+        sigma_k = 0
+        k_list = []
+        for i in range(len(self.element_list)):
+            k_list.append(self.element_list[i].bulk_modulus)
+
+        for j in range(len(self.element_list)):
+            if self.element_list[i].bulk_modulus is None:
+                print(self.element_list[i])
+            else:
+                sigma_k += self.mol_ratio[j] * np.square(k_list[j] - self.k)
+        return np.sqrt(sigma_k)
+
+    '''
+    13. density
+    '''
+    def calc_density(self):
+        """function to return the density (g/cm^3) of the alloy"""
+        mass = 0
+        volume = 0
+        for i in range(len(self.element_list)):
+            mass += float(self.element_list[i].atomic_mass) * self.mol_ratio[i]
+            volume += self.mol_ratio[i] * self.element_list[i].molar_volume
+        return mass / volume
+
+    '''
+    14. price/element cost 
+    '''
+    def calc_price(self):
+        """function to return the price (USD/kg) of the alloy"""
+        total_mass = 0
+        total_price = 0
+        for i in range(len(self.element_list)):
+            if not str(self.element_list[i]) in price_dic:
+                return 'unknown'
+            mass = float(self.element_list[i].atomic_mass) * self.mol_ratio[i]
+            total_mass += mass
+            total_price += mass * price_dic[str(self.element_list[i])]
+        return format(total_price / total_mass, '.2f')

Model/saved_model/gmm_ssl/compressive_strength.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:0e02174ea35006e99f8b43e3a78d13e3d2f7673e9e439491ebfc4aad075f357b
+size 2565375

Model/saved_model/gmm_ssl/elongation.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:57ae33c95007da01c562c761d11b6bcb000048f30a8b83335deeae2e2c202d36
+size 726983

Model/saved_model/gmm_ssl/hardness.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:b496e73fba46999e20f9ffd2403331798a3b34fa5f65a332e7501549bd7d2373
+size 2349713

Model/saved_model/gmm_ssl/plasticity.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:a53ad7ef355647acd95f17953ca1449aa8e226c6d8a251eb40c480ca2535a203
+size 1110343

Model/saved_model/gmm_ssl/tensile_strength.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:68f28229724735e324cdd8c469179abb04196f5e88a757a4f5b65a314a613250
+size 26876

Model/saved_model/gmm_ssl/yield_strength.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:6260faf8a063c032a626dca7e95bf3147185882cf3fa8ee1e89d1fbf49a94657
+size 540505

Model/saved_model/kmeans_ssl/compressive_strength.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:c302a942c75e9f780382b9b07d80acf00960cff017a0a3f39f3a0ece3f33d1ae
+size 1455669

Model/saved_model/kmeans_ssl/elongation.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:767918e24001e2d111526e1a86088b28ba28a768f6770b73e0bead8ab1dcacba
+size 1600365

Model/saved_model/kmeans_ssl/hardness.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:42bba0a5173fb494cfba42290969b41dbca355c47d1e8e238748bdf479cbe4e0
+size 425195

Model/saved_model/kmeans_ssl/plasticity.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2253eaabc6a8ac03413e5f2c0aaee3338726c50399d667b7e04f011088da6a7b
+size 377195

Model/saved_model/kmeans_ssl/tensile_strength.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:75401382feb034ca78043de863b3cab03f3047470f514c5cdb0144b224110d25
+size 627655

Model/saved_model/kmeans_ssl/yield_strength.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:cb532096c4caad2df0fbef8de0653d34b732924e3a5195ae83e273c2934a554b
+size 23804

Model/saved_model/lr/compressive_strength.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:550f45334ed9f0e7a21bc7f480f195f18435e9272d3852bf0bfa2df9a9a344ce
+size 937

Model/saved_model/lr/elongation.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:e9fe4f2045e678c286b66e7271a927f6532ab35774f71dab2f3a823d8fc846bf
+size 42049

Model/saved_model/lr/hardness.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:7fb61f94fc1e0becb7fc1125c54e21bb47e63658c49a2f4d685d5c759c962816
+size 124771

Model/saved_model/lr/plasticity.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:2523c8f36729ef800a9a9caea6b02c0a049ac012e4ce690115831891247eb065
+size 101525

Model/saved_model/lr/tensile_strength.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:caad1f7df03626cf820eb00ad032cefd90375544356488de3fb7f58071c880f6
+size 44408

Model/saved_model/lr/yield_strength.pkl

@@ -0,0 +1,3 @@
+version https://git-lfs.github.com/spec/v1
+oid sha256:05516385450822deb25cf0d963021b3eb41503970e07a38f651b57eb77a26780
+size 54432

app.py

@@ -0,0 +1,329 @@
+import os
+import gradio as gr
+from pandas import Series, DataFrame
+import pandas as pd
+import sys
+import numpy as np
+from Interface.empirical_parameter_calculator import EmpiricalParams
+from pymatgen.core.periodic_table import Element
+from pip._internal import main
+
+main(['install', 'joblib'])
+main(['install', 'matminer'])
+
+import joblib
+
+'''
+Get the path of all of the saved models.
+'''
+
+lr_compressive_strength = "./Model/saved_model/lr/compressive_strength.pkl"
+lr_elongation = "./Model/saved_model/lr/elongation.pkl"
+lr_hardness = "./Model/saved_model/lr/hardness.pkl"
+lr_plasticity ="./Model/saved_model/lr/plasticity.pkl"
+lr_tensile_strength ="./Model/saved_model/lr/tensile_strength.pkl"
+lr_yield_strength ="./Model/saved_model/lr/yield_strength.pkl"
+
+kmeans_ssl_compressive_strength = "./Model/saved_model/kmeans_ssl/compressive_strength.pkl"
+kmeans_ssl_elongation = "./Model/saved_model/kmeans_ssl/elongation.pkl"
+kmeans_ssl_hardness = "./Model/saved_model/kmeans_ssl/hardness.pkl"
+kmeans_ssl_plasticity = "./Model/saved_model/kmeans_ssl/plasticity.pkl"
+kmeans_ssl_tensile_strength = "./Model/saved_model/kmeans_ssl/tensile_strength.pkl"
+kmeans_ssl_yield_strength = "./Model/saved_model/kmeans_ssl/yield_strength.pkl"
+
+gmm_ssl_compressive_strength = "./Model/saved_model/gmm_ssl/compressive_strength.pkl"
+gmm_ssl_elongation = "./Model/saved_model/gmm_ssl/elongation.pkl"
+gmm_ssl_hardness ="./Model/saved_model/gmm_ssl/hardness.pkl"
+gmm_ssl_plasticity = "./Model/saved_model/gmm_ssl/plasticity.pkl"
+gmm_ssl_tensile_strength = "./Model/saved_model/gmm_ssl/tensile_strength.pkl"
+gmm_ssl_yield_strength = "./Model/saved_model/gmm_ssl/yield_strength.pkl"
+
+
+'''
+Get the composition of input alloy.
+'''
+
+def normalize_molar_ratios(ratios):
+    normalized_ratios = list()
+    ele_sum = sum(ratios)
+    for ele in ratios:
+        ele = float(ele / ele_sum)
+        normalized_ratios.append(ele)
+    return normalized_ratios
+
+
+'''
+Load the saved ML models.
+'''
+
+def predict_input(path):
+    with open(path, 'rb') as p:
+        loaded_model = joblib.load(p)
+    return loaded_model
+
+
+'''
+Predict the six properties of the input alloy, 
+with Linear Regression Models, K-Means Semi-supervised Model and GMM Semi-supervised Model.
+'''
+
+def pred(Al, B, C, Co, Cr, Cu, Fe, Ga, Ge, Hf, Li, Mg, Mn, Mo, N, Nb, Ni, Sc, Si, Sn, Ta, Ti, V, W, Y, Zn, Zr, operation):
+    # Get the model acceptable composition format.
+    # print(B)
+    comp = {"Al": Al, "B": B, "C": C, "Co": Co, "Cr": Cr, "Cu": Cu, "Fe": Fe, "Ga": Ga, "Ge": Ge, "Hf": Hf, "Li": Li,
+            "Mg": Mg, "Mn": Mn,
+            "Mo": Mo, "N": N, "Nb": Nb, "Ni": Ni, "Sc": Sc, "Si": Si, "Sn": Sn, "Ta": Ta, "Ti": Ti, "V": V, "W": W,
+            "Y": Y, "Zn": Zn, "Zr": Zr}
+
+    df_values = normalize_molar_ratios(comp.values())
+    df = pd.DataFrame(data=[df_values],
+                      columns=["Al", "B", "C", "Co", "Cr", "Cu", "Fe", "Ga", "Ge", "Hf", "Li", "Mg", "Mn", "Mo", "N",
+                               "Nb", "Ni",
+                               "Sc", "Si", "Sn", "Ta", "Ti", "V", "W", "Y", "Zn", "Zr"])
+    # print(df)
+
+    Composition = ""
+    index = 0
+    for k, v in comp.items():
+        if v != 0:
+            Composition = Composition + k + str(round(df_values[index], 2))
+        index += 1
+    # print(Composition)
+    # print(comp.values())
+
+    if operation=="Linear Regression":
+        #Using RandomForest to predict properties.
+        Hardness = predict_input(lr_hardness).predict(df)
+        YieldStrength=predict_input(lr_yield_strength).predict(df)
+        TensileStrength=predict_input(lr_tensile_strength).predict(df)
+        Elongation=predict_input(lr_elongation).predict(df)
+        CompressiveStrength=predict_input(lr_compressive_strength).predict(df)
+        Plasticity=predict_input(lr_plasticity).predict(df)
+        # print("1")
+
+    elif operation=="K-Means Semi-supervisor Model":
+        #Using KNN & RandomForest to predict properties.
+        Hardness = predict_input(kmeans_ssl_hardness).predict(df)
+        YieldStrength = predict_input(kmeans_ssl_yield_strength).predict(df)
+        TensileStrength = predict_input(kmeans_ssl_tensile_strength).predict(df)
+        Elongation = predict_input(kmeans_ssl_elongation).predict(df)
+        CompressiveStrength = predict_input(kmeans_ssl_compressive_strength).predict(df)
+        Plasticity = predict_input(kmeans_ssl_plasticity).predict(df)
+        # print("2")
+
+    elif operation == "GMM Semi-supervisor Model":
+        # Using semi_supervisor Label Propagation to predict properties.
+        Hardness = predict_input(gmm_ssl_hardness).predict(df)
+        YieldStrength = predict_input(gmm_ssl_yield_strength).predict(df)
+        TensileStrength = predict_input(gmm_ssl_tensile_strength).predict(df)
+        Elongation = predict_input(gmm_ssl_elongation).predict(df)
+        CompressiveStrength = predict_input(gmm_ssl_compressive_strength).predict(df)
+        Plasticity = predict_input(gmm_ssl_plasticity).predict(df)
+
+    Hardness = round(float(Hardness),2)
+    YieldStrength = round(float(YieldStrength),2)
+    TensileStrength = round(float(TensileStrength),2)
+    Elongation = round(float(Elongation),2)
+    CompressiveStrength = round(float(CompressiveStrength),2)
+    Plasticity = round(float(Plasticity),2)
+
+    return Composition, Hardness, YieldStrength, TensileStrength, Elongation, CompressiveStrength, Plasticity
+
+
+'''
+Import the function to Calculate the empirical parameters.
+'''
+
+def empirical_parameter(Al, B, C, Co, Cr, Cu, Fe, Ga, Ge, Hf, Li, Mg, Mn, Mo, N, Nb, Ni, Sc, Si, Sn, Ta, Ti, V, W, Y, Zn, Zr):
+    # Get the model acceptable composition format.
+    # print(B)
+    comp = {"Al": Al, "B": B, "C": C, "Co": Co, "Cr": Cr, "Cu": Cu, "Fe": Fe, "Ga": Ga, "Ge": Ge, "Hf": Hf, "Li": Li,
+            "Mg": Mg, "Mn": Mn,
+            "Mo": Mo, "N": N, "Nb": Nb, "Ni": Ni, "Sc": Sc, "Si": Si, "Sn": Sn, "Ta": Ta, "Ti": Ti, "V": V, "W": W,
+            "Y": Y, "Zn": Zn, "Zr": Zr}
+
+    df_values = normalize_molar_ratios(comp.values())
+    print(df_values)
+
+    df_element=[]
+    df_ratio=[]
+    index = 0
+    for key, value in comp.items():
+        if int(value) != 0:
+            df_element.append(key)
+            df_ratio.append(df_values[index])
+        index += 1
+    print(df_element)
+    print(df_ratio)
+
+    df_elements = []
+    for i in df_element:
+        df_elements.append(Element[i])
+    print(df_elements)
+
+    input_ele = EmpiricalParams(element_list=df_elements,mol_ratio=df_ratio)
+
+    # 1. Calculate the entropy mixing.
+    para1 = round(float(input_ele.entropy_mixing()),2)
+
+    #2. Calculate the average atomic radius.
+    para2 = round(float(input_ele.mean_atomic_radius()),2)
+
+    #3. Calculate the atomic size difference.
+    para3 = round(float(input_ele.atomic_size_difference()),2)
+
+    #4. Calculate the enthalpy of mixing.
+    para4= round(float(input_ele.enthalpy_mixing()),2)
+
+    #5. Calculate the standard deviation of enthalpy.
+    para5= round(float(input_ele.std_enthalpy_mixing()),2)
+
+    #6. Calculate the average melting point.
+    para6= round(float(input_ele.average_melting_point()),2)
+
+    #7. Calculate the standard melting point.
+    para7= round(float(input_ele.std_melting_point()),2)
+
+    #8. Calculate the average electronegativity.
+    para8= round(float(input_ele.mean_electronegativity()),2)
+
+    #9. Calculate the standard deviation of electronegativity.
+    para9= round(float(input_ele.std_electronegativity()),2)
+
+    #10. Calculate the valence electron concentration.
+    para10= round(float(input_ele.average_vec()),2)
+
+    #11. Calculate the standard deviation of valence electron concentration.
+    para11= round(float(input_ele.std_vec()),2)
+
+    #12. Calculate the omega.
+    para12= round(float(input_ele.calc_omega()),2)
+
+    #13. Calculate the density.
+    para13= round(float(input_ele.calc_density()),2)
+
+    #14. Calculate the price.
+    para14= round(float(input_ele.calc_price()),2)
+
+    return para1, para2, para3, para4,para5, para6, para7, para8, para9, para10, para11, para12, para13, para14
+
+
+'''
+The function of Clear button.
+'''
+
+def clear_input():
+    return 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, "", 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0
+
+
+'''
+Interface Details
+'''
+
+with gr.Blocks() as demo:
+    # The title and description of interface.
+    gr.Markdown("# Multi Principal Element Alloy Property Predictor")
+    gr.Markdown("Input alloy composition to obtain output of alloy properties (sum of composition should be equal to 100)")
+
+    # The section to select the Machine Learning Model.
+    with gr.Row():
+        operation = gr.inputs.Radio(["Linear Regression","K-Means Semi-supervisor Model", "GMM Semi-supervisor Model"])
+
+    # The section to input the element ratio.
+    with gr.Row():
+        Al = gr.Number(label="Al")
+        B = gr.Number(label="B")
+        C = gr.Number(label="C")
+        Co = gr.Number(label="Co")
+        Cr = gr.Number(label="Cr")
+        Cu = gr.Number(label="Cu")
+        Fe = gr.Number(label="Fe")
+        Ga = gr.Number(label="Ga")
+        Ge = gr.Number(label="Ge")
+        Hf = gr.Number(label="Hf")
+        Li = gr.Number(label="Li")
+        Mg = gr.Number(label="Mg")
+        Mn = gr.Number(label="Mn")
+        Mo = gr.Number(label="Mo")
+        N = gr.Number(label="N")
+        Nb = gr.Number(label="Nb")
+        Ni = gr.Number(label="Ni")
+        Sc = gr.Number(label="Sc")
+        Si = gr.Number(label="Si")
+        Sn = gr.Number(label="Sn")
+        Ta = gr.Number(label="Ta")
+        Ti = gr.Number(label="Ti")
+        V = gr.Number(label="V")
+        W = gr.Number(label="W")
+        Y = gr.Number(label="Y")
+        Zn = gr.Number(label="Zn")
+        Zr = gr.Number(label="Zr")
+        Composition = gr.Text(label="Alloy Composition")
+
+    #Action buttons.("Clear" and "Prediction")
+    with gr.Row():
+        clear = gr.Button("Clear")
+        submit = gr.Button("Predict")
+
+    #The prediction result(Six mechanical properties) of ML models.
+    with gr.Row():
+        Hardness = gr.Number(label="Hardness (VHN)")
+        YieldStrength = gr.Number(label="Yield Strength (MPa)")
+        TensileStrength = gr.Number(label="Tensile Strength (MPa)")
+        Elongation = gr.Number(label="Elongation (%)")
+        CompressiveStrength = gr.Number(label="Compressive Strength (MPa)")
+        Plasticity = gr.Number(label="Plasticity (from compression)")
+
+    #Calculer resutl of empirical parameters.
+    with gr.Row():
+        entropy_mixing = gr.Number(label="Entropy of Mixing (J/K*mol)")
+        average_atomic_radius = gr.Number(label="Average Atomic Radius (Angstroms)")
+        atomic_size_dif = gr.Number(label="Atomic Size Difference")
+        enthalpy_mixing = gr.Number(label="Enthalpy of Mixing (kJ/mol)")
+        std_deviation_enthalpy = gr.Number(label="Standard Deviation of Enthalpy")
+        average_melting_point = gr.Number(label="Average Melting Point (Tm, in Celcius)")
+        std_deviation_melting_point = gr.Number(label="Standard Deviation of Melting Point")
+        average_electronegativity = gr.Number(label="Average Electronegativity (X)")
+        std_deviation_electronegativity= gr.Number(label="Standard Deviation of Electronegativity")
+        valence_electron_concentration = gr.Number(label="Valence Electron Concentration (VEC)")
+        std_deviation_valence_electron_concentration = gr.Number(label="Standard Deviation of Valence Electron Concentration (VEC)")
+        omega = gr.Number(label="The Unitless Parameter Omega")
+        density = gr.Number(label="Density (g/cm^3)")
+        price = gr.Number(label="Price (USD/kg)")
+
+    # Define the action of "Clear" button.
+    clear.click(fn=clear_input, inputs=[],
+                outputs=[Al, B, C, Co, Cr, Cu, Fe, Ga, Ge, Hf, Li, Mg, Mn, Mo, N, Nb, Ni, Sc, Si, Sn, Ta, Ti, V, W, Y,
+                         Zn, Zr, Composition,
+                         Hardness, YieldStrength, TensileStrength, Elongation, CompressiveStrength, Plasticity, entropy_mixing, average_atomic_radius, atomic_size_dif, enthalpy_mixing,
+                          std_deviation_enthalpy, average_melting_point, std_deviation_melting_point,
+                          average_electronegativity, std_deviation_electronegativity, valence_electron_concentration,
+                          std_deviation_valence_electron_concentration, omega, density, price])
+
+    # Define the action of "Predict" button.
+    # 1.Predict the result of "Composition", "Hardness", "YieldStrength", "TensileStrength", "Elongation", "CompressiveStrength", "Plasticity".
+    submit.click(fn=pred,
+                 inputs=[Al, B, C, Co, Cr, Cu, Fe, Ga, Ge, Hf, Li, Mg, Mn, Mo, N, Nb, Ni, Sc, Si, Sn, Ta, Ti, V, W, Y,
+                         Zn, Zr,operation],
+                 outputs=[Composition, Hardness, YieldStrength, TensileStrength, Elongation, CompressiveStrength,
+                          Plasticity])
+
+    # 2.Activate the empirical parameter calculator.
+    submit.click(fn=empirical_parameter,
+                 inputs=[Al, B, C, Co, Cr, Cu, Fe, Ga, Ge, Hf, Li, Mg, Mn, Mo, N, Nb, Ni, Sc, Si, Sn, Ta, Ti, V, W, Y,
+                         Zn, Zr],
+                 outputs=[entropy_mixing, average_atomic_radius, atomic_size_dif, enthalpy_mixing,
+                          std_deviation_enthalpy, average_melting_point, std_deviation_melting_point,
+                          average_electronegativity, std_deviation_electronegativity, valence_electron_concentration,
+                          std_deviation_valence_electron_concentration, omega, density, price])
+
+
+'''
+Launch the interface.
+'''
+if __name__ == "__main__":
+    # Run the Alloy Property Predictor Interface, without public URL.
+    # demo.launch()
+
+    # Run the Alloy Property Predictor Interface, with a public URL.
+    demo.launch(share="True")