ACSF descriptors for ML

[WSukmas]

Hello everyone. I'm new here, and I'd like to understand more about ACSF workflows. Let's start with a toy example as follows:
Using pymatgen, I queried "Ti-O" systems and their corresponding formation energy per atom which (will be the target property) where "A" can be any elements. There are 116 samples in the dataset. And I want to build an ML to predict the formation energy per atom using ACSF features as descriptors.

Then I tried to generate the descriptors as a csv file for each sample.

def process_csv(input_filename, output_filename):
    # Get data
    structures = read(input_filename)
    species=["Ti", "O"]
    
    # Setting up ACSF 
    acsf = ACSF(
        species = species,
        periodic=True,
        rcut=6,
        g2_params=[[1, 1], [1, 2], [1, 3]],
        g4_params=[[1, 1, 1], [1, 2, 1], [1, 2, -1]],
        sparse=False
    )
    acsf_pos = acsf.create(structures, verbose=False)
    mat = np.matrix(np.array(acsf_pos))
    df = pd.DataFrame(data=mat.astype(float))
    df.to_csv(output_filename, header=True, float_format='%.2f', index=False)

INPUT_PATH = os.getcwd()
OUTPUT_PATH = os.getcwd()

for csv_filename in glob.glob(os.path.join(INPUT_PATH, "*.cif")):
    name, ext = os.path.splitext(os.path.basename(csv_filename))
    
    output_filename = os.path.join(OUTPUT_PATH, f"{name}_OUTPUT.csv")
    process_csv(csv_filename, output_filename)

Basically, this generates a csv file for each sample in the dataset. And in these files the number of rows are different due to the difference in crystal structures. For example: that of TiO,

and that of TiO2

So, my question is how do I exploit these lines of data as descriptors for ML? Can I just average all the rows of each sample and use it to train the model to predict the formation energy?

Another question: if I'm working on multi-element systems, let's say, "A-O" systems where A can be any elements. Now that species = ["Ac, Al, Ag, ....] becomes a huge list, which consequently leads to a ridiculously large set of descriptors. So, is there an alternative method to work around this problem, or I've missed something?

Any suggestions would be greatly appreciated.

[lauri-codes]

Hi @WSukmas,

Q1: So, my question is how do I exploit these lines of data as descriptors for ML? Can I just average all the rows of each sample and use it to train the model to predict the formation energy?
A1: ACSF is a local descriptor, so it only describes a localized region in your structure. In order to use such a localized feature to predict a global property (formation energy per atom = formation energy / number of atoms), you need to jump through some additional hoops. Either you somehow squeeze out a single vector from the ACSF of all atoms (average, REMatch, etc.) or then you essentially train a more complex model that can e.g. predict the formation energy by looking at each ACSF all at once, typically using some form of a neural network. I'm not too familiar with this approach but there are several examples available, e.g. Megnet. There are also global descriptors that from the get-go attempt to capture the full structure into a single vector (e.g. MBTR), but how successfull this is depends a lot on the property and amount of training data.

Q2: if I'm working on multi-element systems, let's say, "A-O" systems where A can be any elements. Now that species = ["Ac, Al, Ag, ....] becomes a huge list, which consequently leads to a ridiculously large set of descriptors. So, is there an alternative method to work around this problem, or I've missed something?
A2: This is a typical problem when you increase the number of elements, and your descriptor size has a nonlinear dependency on the amount of elements. Once again there are several alternatives: if the rest of your pipeline allows it, start using sparse arrays. Creating them with dscribe is as easy as setting sparse=true in the constructor, more information here. Another approach is to do a feature selection or feature projection that are fairly standard in the ML world: tjhese methods will reduce the dimensionality of your data while trying to retain the information as best as they can.