Code/data.py

import os
import random
from concurrent.futures import ProcessPoolExecutor
from functools import partial
from pathlib import Path
from typing import Optional
import torch.nn.functional as F
import lmdb
import gzip
import pickle
import json

from itertools import product

import numpy as np
from tqdm import tqdm
import torch

from torch_geometric.data import Data, Dataset
from torch_geometric.loader import DataLoader
import periodictable
from torch.utils.data.distributed import DistributedSampler
from torch.utils.data import SubsetRandomSampler, random_split, Subset
import bisect

HARTREE_2_EV = 27.2114
BOHR_2_ANGSTROM = 1.8897
_MEAN_ENERGY = -4.269320623583757
_STD_ENERGY = 1.0
_STD_FORCE_SCALE = 1.0

atomic_number_mapping = {}
for element in periodictable.elements:
    atomic_number_mapping[element.symbol] = element.number
    atomic_number_mapping[element.symbol.upper()] = element.number
    atomic_number_mapping[element.symbol.lower()] = element.number


atom_energy = {
    1: -0.5002727762,
    4: -14.6684425428,
    5: -24.6543539532,
    6: -37.8462799513,
    7: -54.5844893657,
    8: -75.0606214015,
    9: -99.7155354215,
    14: -289.3723539998,
    15: -341.2580898032,
    16: -398.1049925382,
    17: -460.1362417086,
    21: -760.5813501324,
    22: -849.3013849537,
    23: -943.8255794204,
    24: -1044.2810289455,
    25: -1150.8680174849,
    26: -1263.5207828239406,
    27: -1382.5485719267936,
    28: -1508.0542451335,
    29: -1640.1731641564784,
    31: -1924.5926070018,
    32: -2076.6914561594,
    33: -2235.5683127287,
    34: -2401.2347730327,
    35: -2573.8397377628
}

def find_last_index_with_key(objects, key):
    last_index = -1
    for i in range(len(objects) - 1, -1, -1):
        if key in objects[i] and objects[i][key] is not None:
            last_index = i
            break
    return last_index


def data_to_pyg(data, key, stage='1st', filter=False):
    def process_data(phase):
        nonlocal data
        nonlocal key
        nonlocal stage
        datas = []
        if phase is None or len(phase) == 0:
            return datas

        if stage == 'mixing':
            if len(data['DFT_2nd']) != 0:
                last_index = find_last_index_with_key(data['DFT_2nd'], 'energy')
                if last_index == -1:
                    if data['DFT_1st'] is None or len(data['DFT_1st']) == 0:
                        return datas
                    last_index = find_last_index_with_key(data['DFT_1st'], 'energy')
                    last_data = data['DFT_1st'][last_index]
                else:
                    last_data = data['DFT_2nd'][last_index]
            else:
                if data['DFT_1st'] is None or len(data['DFT_1st']) == 0:
                    return datas
                last_index = find_last_index_with_key(data['DFT_1st'], 'energy')
                last_data = data['DFT_1st'][last_index]

        elif stage == '1st':
            last_index = find_last_index_with_key(data['DFT_1st'], 'energy')
            if last_index == -1:
                return datas
            last_data = phase[last_index]

        elif stage == '1st_smash':
            last_index = find_last_index_with_key(data['DFT_1st'], 'energy')
            if last_index == -1:
                return datas
            last_data = phase[last_index]

        elif stage == '2nd':
            last_index = find_last_index_with_key(data['DFT_2nd'], 'energy')
            if last_index == -1:
                return datas
            last_data = phase[last_index]

        elif stage == 'hf':
            last_index = find_last_index_with_key(data['hf'], 'energy')
            if last_index == -1:
                return datas
            last_data = phase[last_index]

        elif stage == 'pm3':
            last_index = find_last_index_with_key(data['pm3'], 'energy')
            if last_index == -1:
                return datas
            last_data = phase[last_index]
        else:
            raise Exception('Unknown stage')

    
        last_coordinates = last_data['coordinates']  
        last_energy = last_data['energy'] 

        if stage == '1st_smash':  
            if 'charge' in last_coordinates[0]:
                return datas

        for d in phase: 
            coords = d['coordinates']  
            energy = d['energy']  
            gradient = d['gradient']  
            formation_energies = []  
            atomic_numbers = [] 
            positions = []  
            last_positions = []  
            forces = []  

            if coords is None or len(
                    coords) == 0:  
                continue

            if stage == '1st_smash': 
                if 'charge' in coords[0]:
                    continue

            if energy is None: 
                continue
            if len(coords) != len(last_coordinates): 
                continue
            if len(gradient) != len(coords): 
                continue
            for i, atom_info in enumerate(coords):  
                atom = atom_info['atom']  
                atomic_number = atomic_number_mapping[atom]  
                x = atom_info['x'] 
                y = atom_info['y'] 
                z = atom_info['z']  

                atomic_numbers.append(atomic_number)  
                formation_energies.append(atom_energy[atomic_number])
                positions.append([x, y, z]) 
                last_positions.append([last_coordinates[i]['x'], last_coordinates[i]['y'],
                                       last_coordinates[i]['z']]) 
                forces.append([-gradient[i]['dx'] * HARTREE_2_EV * BOHR_2_ANGSTROM, -gradient[i]['dy'] * HARTREE_2_EV * BOHR_2_ANGSTROM,
                               -gradient[i]['dz'] * HARTREE_2_EV * BOHR_2_ANGSTROM])  

            x = torch.tensor(atomic_numbers, dtype=torch.long).view(-1,
                                                                    1)  
            pos = torch.tensor(positions, dtype=torch.float) 
            last_pos = torch.tensor(last_positions,
                                    dtype=torch.float)  
            y = torch.tensor([(energy - sum(formation_energies)) * HARTREE_2_EV / x.size(0)],
                             dtype=torch.float)  
            last_y = torch.tensor([(last_energy - sum(formation_energies)) * HARTREE_2_EV / x.size(0)],
                                  dtype=torch.float) 
            y_force = torch.tensor(forces,
                                   dtype=torch.float)  

            if (torch.isnan(x).any() or torch.isnan(pos).any() or torch.isnan(last_pos).any() or torch.isnan(
                    y).any() or torch.isnan(last_y).any() or torch.isnan(y_force).any()):
                continue

            ds = Data(x=x, natoms=x.size(0), pos=pos, last_pos=last_pos, y=y, last_y=last_y, y_force=y_force, cid=str(key))
            datas.append(ds)

        return datas 

    if stage == '1st':
        return process_data(data['DFT_1st'])
    elif stage == '1st_smash':
        return process_data(data['DFT_1st'])
    elif stage == '2nd':
        return process_data(data['DFT_2nd'])
    elif stage == 'mixing':
        return process_data(data['DFT_1st']) + process_data(data['DFT_2nd'])
    elif stage == 'pm3':
        return process_data(data['pm3'])
    elif stage == 'hf':
        return process_data(data['hf'])
    else:
        raise Exception('Unknown stage')


def process_key(key, db_path, stage, filtering):
    env = lmdb.open(str(db_path), subdir=False, readonly=True, lock=False)
    with env.begin(write=False) as txn:
        datapoint_pickled = txn.get(key)
        data_objects = data_to_pyg(pickle.loads(gzip.decompress(datapoint_pickled)), stage, filter=filtering) 

    if len(data_objects) > 0:
        return key
    else:
        return None

def process_num(key, db_path, stage, filtering):
    env = lmdb.open(str(db_path), subdir=False, readonly=True, lock=False)
    with env.begin(write=False) as txn:
        datapoint_pickled = txn.get(key)
        data_objects = data_to_pyg(pickle.loads(gzip.decompress(datapoint_pickled)), stage, filter=filtering)  

    if len(data_objects) > 0:
        return len(data_objects)
    else:
        return None


def get_valid_nums(db_path, keys, stage, filtering):

    valid_nums = []

    worker_func = partial(process_num, db_path=db_path, stage=stage, filtering=filtering)

    with ProcessPoolExecutor(max_workers=32) as executor:
        results = executor.map(worker_func, keys)
        for maybe_len in tqdm(results, total=len(keys), desc="Get valid numbers"):
            if maybe_len is not None:
                valid_nums.append(maybe_len)

    return valid_nums 

def filter_valid_keys(db_path, keys, stage, filtering):
    
    valid_keys = []
    
    worker_func = partial(process_key, db_path=db_path, stage=stage, filtering=filtering)

    with ProcessPoolExecutor(max_workers=32) as executor:
        results = executor.map(worker_func, keys)
        for maybe_key in tqdm(results, total=len(keys), desc="Filtering valid keys"):
            if maybe_key is not None:
                valid_keys.append(maybe_key)

    return valid_keys 

class LMDBDataset(Dataset):

    def __init__(self, path, transform=None, keys_file='valid_keys', stage='1st', total_traj=True,
                 SubsetOnly=False, getTest = False, stochastic_frame = False) -> None:

        super(LMDBDataset, self).__init__()

        self.path = Path(path)

        self.keys_file = keys_file

        self.stage = stage

        self.total_traj = total_traj
        self.stochastic_frame = stochastic_frame

        assert self.path.is_dir(), "Path is not a directory"

        db_paths = sorted(self.path.glob("*.lmdb"))

        assert len(db_paths) > 0, f"No LMDBs found in '{self.path}'"

        self._keys = []

        if total_traj:
            self._nums = []

        self.envs = []

        self.SubsetOnly = SubsetOnly

        self.postfix = ""
        if SubsetOnly:
            self.postfix = "_Subset"

        for i, db_path in enumerate(db_paths): 

            if SubsetOnly:
                if 'Data06.lmdb' not in str(db_path):
                    continue
                
            # If we're generating the test set, skip all lmdbs that aren't the test otherwise skip only the test lmdb
            if getTest:
                if 'test.lmdb' not in str(db_path):
                    continue
            else:
                if 'test.lmdb' in str(db_path):
                    continue

            cur_env = self.connect_db(db_path) 
            self.envs.append(cur_env)  
            
            lmdb_name = Path(str(db_path)).stem

            if os.path.exists(self.path / Path(self.keys_file + f'_{lmdb_name}_{self.stage}{self.postfix}.txt')):  
                self._keys.append(self.load_keys(lmdb_name))  
            else:  
                with cur_env.begin() as txn:  
                    all_keys = [key for key in tqdm(txn.cursor().iternext(values=False))] 
                filter_keys = filter_valid_keys(db_path, all_keys, self.stage, not self.SubsetOnly)  
                self._keys.append(filter_keys) 
                self.save_keys(filter_keys, lmdb_name) 

            if total_traj:
                if os.path.exists(
                        self.path / Path(self.keys_file + f'_{lmdb_name}_{self.stage}{self.postfix}_number.txt')):
                    self._nums.append(self.load_nums(lmdb_name)) 
                else:
                    numbers = get_valid_nums(db_path, self._keys[-1], self.stage, not self.SubsetOnly)
                    self._nums.append(numbers)
                    self.save_numbers(numbers, lmdb_name)

        if not total_traj: 
            keylens = [len(k) for k in self._keys]  
            self._keylen_cumulative = np.cumsum(keylens).tolist()  
            self.num_samples = sum(keylens)  
            
        else: 
            keylens = [sum(k) for k in self._nums]  
            self._keylen_cumulative = np.cumsum(keylens).tolist()  
            self._num_cumulative = [np.cumsum(k).tolist() for k in
                                    self._nums] 
            self.num_samples = sum(
                keylens) 
            nums_flat = np.concatenate([np.array(nums) for nums in self._nums])
            cumulative_nums = np.cumsum(nums_flat)
            start_indices = np.concatenate(([0], cumulative_nums[:-1]))
            self.trajectory_indices = list(zip(start_indices.tolist(), cumulative_nums.tolist()))
            
        self.transform = transform 
        
        self.maximum_dist = 0

    def save_keys(self, keys, lmdb_name):
        with open(self.path / Path(self.keys_file + f'_{lmdb_name}_{self.stage}{self.postfix}.txt'), 'w') as f:
            for key in keys:
                f.write(key.hex() + '\n')

    def save_numbers(self, numbers, lmdb_name):
        with open(self.path / Path(self.keys_file + f'_{lmdb_name}_{self.stage}{self.postfix}_number.txt'), 'w') as f:
            for num in numbers:
                f.write(str(num) + '\n')

    def load_keys(self, lmdb_name):

        with open(self.path / Path(self.keys_file + f'_{lmdb_name}_{self.stage}{self.postfix}.txt'), 'r') as f:  
            keys = [bytes.fromhex(line.strip()) for line in f] 

        return keys  

    def load_nums(self, lmdb_name):

        with open(self.path / Path(self.keys_file + f'_{lmdb_name}_{self.stage}{self.postfix}_number.txt'), 'r') as f:
            nums = [int(line.strip()) for line in f]
        return nums

    def __len__(self) -> int:
        return self.num_samples

    def __getitem__(self, idx: int): 

        db_idx = bisect.bisect(self._keylen_cumulative, idx)
        el_idx = idx

        if db_idx != 0:
            el_idx = idx - self._keylen_cumulative[db_idx - 1]
        assert el_idx >= 0

        if not self.total_traj:
            datapoint_pickled = (
                self.envs[db_idx]
                .begin()
                .get(self._keys[db_idx][el_idx])
            )
            data_objects = data_to_pyg(pickle.loads(gzip.decompress(datapoint_pickled)), self._keys[db_idx][el_idx], filter=not self.SubsetOnly)
            if len(data_objects) == 0:
                return None

            if self.transform is not None:
                data_objects = [self.transform(data_object, self.stochastic_frame) for data_object in data_objects]

            return random.choice(data_objects)

        else:
            num_idx = bisect.bisect(self._num_cumulative[db_idx], el_idx)
            data_idx = el_idx
            if num_idx != 0:
                data_idx = el_idx - self._num_cumulative[db_idx][num_idx - 1]
            assert data_idx >= 0
            datapoint_pickled = (
                self.envs[db_idx]
                .begin()
                .get(self._keys[db_idx][num_idx])
            )
            data_objects = data_to_pyg(pickle.loads(gzip.decompress(datapoint_pickled)), self._keys[db_idx][num_idx], filter=not self.SubsetOnly)

            data_object = data_objects[data_idx]
            if self.transform is not None:
                data_object = self.transform(data_object, self.stochastic_frame)
            return data_object

    def connect_db(self, lmdb_path: Optional[Path] = None) -> lmdb.Environment:
        env = lmdb.open(
            str(lmdb_path),
            subdir=False,
            readonly=True,
            lock=False,
            readahead=False,
            meminit=False,
            max_readers=128,
        )
        return env

    def close_db(self) -> None:
        self.env.close()


class CommonLMDBDataset(Dataset):

    def __init__(self, path, transform=None) -> None:
        
        super(CommonLMDBDataset, self).__init__()
        self.path = Path(path)
       
        assert self.path.is_file(), "Path is not a file"
        self.env = self.connect_db(self.path)

        self.transform = transform  

    def __len__(self) -> int:
        with self.env.begin() as txn: 
            self.all_keys = [key for key in tqdm(txn.cursor().iternext(values=False))]
        return len(self.all_keys)

    def __getitem__(self, idx: int): 
        datapoint_pickled = self.env.begin().get(self.all_keys[idx])
        data_object = pickle.loads(gzip.decompress(datapoint_pickled))
        pos = random.choice([pos for pos in data_object.pos])
        data_object.pos = pos
        if self.transform is not None:
            data_object = self.transform(data_object, self.stochastic_frame)

        return data_object

    def connect_db(self, lmdb_path: Optional[Path] = None) -> lmdb.Environment:
        env = lmdb.open(
            str(lmdb_path),
            subdir=False,
            readonly=True,
            lock=False,
            readahead=False,
            meminit=False,
            max_readers=128,
        )
        return env

    def close_db(self) -> None:
        self.env.close()


def initialize_datasets(root, transform, stage, total_traj, SubsetOnly, stochastic_frame):
    lmdb_dataset = LMDBDataset(
        root,
        transform=transform,
        stage=stage,
        total_traj=total_traj,
        SubsetOnly=SubsetOnly,
        stochastic_frame=stochastic_frame
    )
    
    if not total_traj:
    
        train_size = int(0.8 * len(lmdb_dataset))
        val_size = len(lmdb_dataset) - train_size
        
        with open('splits/new_split.json' if SubsetOnly else 'splits/new_split_full.json', 'r') as f:
            split = json.load(f)
            
        mol_indices = list(range(len(lmdb_dataset)))
        mol_indices_np = np.array(mol_indices)
       
        train_trajectory_indices = (mol_indices_np[split['train']]).tolist()
        val_trajectory_indices = (mol_indices_np[split['val']]).tolist()
        
        train_dataset = Subset(lmdb_dataset, train_trajectory_indices)
        val_dataset = Subset(lmdb_dataset, val_trajectory_indices)
        
    else:
        num_trajectories = len(lmdb_dataset.trajectory_indices)
        trajectory_indices = list(range(num_trajectories))
        
        with open('splits/new_split.json' if SubsetOnly else 'splits/new_split_full.json', 'r') as f:
            split = json.load(f)
            
        trajectory_indices_np = np.array(trajectory_indices)
        
        train_trajectory_indices = (trajectory_indices_np[split['train']]).tolist()
        val_trajectory_indices = (trajectory_indices_np[split['val']]).tolist()

        train_snapshot_indices = []
        val_snapshot_indices = []

        for idx_set, snapshot_indices_set in zip(
            [train_trajectory_indices, val_trajectory_indices],
            [train_snapshot_indices, val_snapshot_indices],
        ):
            for traj_idx in idx_set:
                start_idx, end_idx = lmdb_dataset.trajectory_indices[traj_idx]
                snapshot_indices_set.extend(range(start_idx, end_idx))

        train_dataset = Subset(lmdb_dataset, train_snapshot_indices)
        val_dataset = Subset(lmdb_dataset, val_snapshot_indices)

    lmdb_test_dataset = LMDBDataset(
        root,
        transform=transform,
        stage=stage,
        total_traj=True,
        SubsetOnly=False,
        getTest=True,
        stochastic_frame=stochastic_frame
    )

    test_snapshot_indices = []
    for start_idx, end_idx in lmdb_test_dataset.trajectory_indices:
        test_snapshot_indices.extend(range(start_idx, end_idx))
    test_dataset = Subset(lmdb_test_dataset, test_snapshot_indices)

    return {"train": train_dataset, "val": val_dataset, "test": test_dataset}

def scale_transform(data, stochastic_frame=False):  
    y_scale = (data.y - _MEAN_ENERGY) / _STD_ENERGY
    data.y = y_scale
    data.y_force = data.y_force / _STD_FORCE_SCALE
    data.pos = data.pos - data.pos.mean(0, keepdim=True)
    data.num_atoms = data.pos.size(0)
    if stochastic_frame:
        plus_minus_list = list(product([1, -1], repeat=3))
        index = random.randint(0, len(plus_minus_list) - 1)
        signs = plus_minus_list[index]
        Q = torch.linalg.eig(data.pos.T @ data.pos)[1] * torch.tensor(signs).unsqueeze(0)
        data.Q = Q.to(torch.float32).unsqueeze(0).expand(data.pos.size(0), 3, 3)
    
    return data

class LMDBDataLoader:
    def __init__(
            self,
            root,
            batch_size=32,
            num_workers=4,
            stage='1st',
            total_traj=False,
            SubsetOnly=False,
            stochastic_frame=False
    ) -> None:
        self.batch_size = batch_size  
        self.num_workers = num_workers  
        self.datasets = initialize_datasets(root, scale_transform, stage, total_traj,
                                            SubsetOnly=SubsetOnly, stochastic_frame=stochastic_frame)  
       

    def train_loader(self, distributed=False):
        if distributed:
            sampler = DistributedSampler(self.datasets["train"])
        else:
            subset_indices = torch.randperm(len(self.datasets["train"]))
            sampler = SubsetRandomSampler(subset_indices)
        return DataLoader(
            self.datasets["train"],
            batch_size=self.batch_size,
            drop_last=False,
            num_workers=self.num_workers,
            sampler=sampler, 
            pin_memory=True,
        )

    def val_loader(self, distributed=False):
        if distributed:
            sampler = DistributedSampler(self.datasets["val"])
            return DataLoader(
                self.datasets["val"],
                batch_size=self.batch_size,
                drop_last=False,
                num_workers=self.num_workers,
                sampler=sampler,  
                pin_memory=True,
            )
        return DataLoader(
            self.datasets["val"],
            batch_size=self.batch_size,
            drop_last=False,
            num_workers=self.num_workers,
            pin_memory=True,
            
        )

    def test_loader(self, distributed=False):
        if distributed:
            sampler = DistributedSampler(self.datasets["test"])
            return DataLoader(
                self.datasets["test"],
                batch_size=self.batch_size,
                drop_last=False,
                num_workers=self.num_workers,
                sampler=sampler, 
                pin_memory=True,
            )

        return DataLoader(
            self.datasets["test"],
            batch_size=self.batch_size,
            drop_last=False,
            num_workers=self.num_workers,
            pin_memory=True,
        )

def serialize_and_compress(data: Data):
    """
    Serializes the Data object using msgpack and compresses it using lz4.
    """
    return gzip.compress(pickle.dumps(data))