Delete docs

docs/cluster.md

@@ -1,140 +0,0 @@
-# Installation
-
-### First time connecting to a cluster
-
-```bash
-ssh -Y aburger@killarney.alliancecan.ca
-```
-
-Add ssh key to github
-```bash
-ssh-keygen -t ed25519
-eval "$(ssh-agent -s)"
-ssh-add ~/.ssh/id_ed25519
-cat ~/.ssh/id_ed25519.pub
-```
-
-### Python env
-
-```bash
-python3.11 -m venv gadenv
-source gadenv/bin/activate
-```
-
-```bash
-# module spider cuda
-module load cuda/12.6
-module load gcc/12.3
-```
-
-```bash
-pip3 uninstall torch torchvision torchaudio torch-scatter torch-sparse torch-cluster torch-spline-conv -y
-pip3 install --no-cache-dir torch==2.4.1 --index-url https://download.pytorch.org/whl/cu126
-
-# install the rest
-pip3 uninstall torch-cluster pyg-lib torch-scatter torch-sparse torch-geometric -y
-pip3 install --no-cache-dir --no-index torch-scatter -f https://data.pyg.org/whl/torch-2.4.1+cu128.html
-pip3 install --no-cache-dir torch-geometric==2.6.1
-
-pip3 install --no-cache-dir numpy>=1.26.0 scipy scikit-learn pandas ase==3.25.0 plotly imageio seaborn black tqdm joblib einops ipykernel toml omegaconf nbformat nglview py3Dmol==2.5.0 hydra-submitit-launcher hydra-core==1.* wandb==0.19.11w pyyaml dxtb[libcint] torchmetrics joblib submitit rmsd pytorch_warmup e3nn==0.5.1 huggingface_hub>=0.27.1 kagglehub>=0.3.12 networkx==3.4.2 pydantic==2.11.4 opt-einsum-fx==0.1.4 lmdb==1.5.1 h5py>=3.10.0 progressbar==2.5
-# fairchem-core==1.10.0
-pip3 install --no-cache-dir triton==2.2.0 pytorch-lightning==2.5.1.post0
-# pip3 install les@git+https://github.com/ChengUCB/les
-
-# compute canada
-# pip3 install --no-cache-dir rdkit==2024.9.6
-module load rdkit/2023.09.5 openmm/8.2.0 openbabel/3.1.1 mctc-lib/0.3.1
-
-pip install -e .
-
-pip install -U "jax[cuda12]"==0.6.2
-pip install -e sella
-```
-
-I had problems with the compute canada version of wandb, so I installed it manually
-```bash
-pip uninstall wandb -y
-
-wget https://files.pythonhosted.org/packages/88/c9/41b8bdb493e5eda32b502bc1cc49d539335a92cacaf0ef304d7dae0240aa/wandb-0.20.1-py3-none-manylinux_2_17_x86_64.manylinux2014_x86_64.whl -O wandb-0.20.1-py3-none-any.whl
-
-PIP_CONFIG_FILE=/dev/null pip3 install wandb-0.20.1-py3-none-any.whl --force-reinstall --no-deps --no-build-isolation --no-cache-dir --no-index
-```
-
-If you want to use MACE
-```bash
-pip install cuequivariance cuequivariance-torch cuequivariance-ops-torch-cu12
-git clone https://github.com/ACEsuit/mace.git
-pip install -e ./mace
-```
-
-
-### Setup
-Create a .env file in the root directory and set these variables (adjust as needed):
-```bash
-touch .env
-nano .env
-```
-```bash
-# .env
-HOMEROOT=${HOME}/gad-ff
-# some scratch space where we can write files during training. can be the same as HOMEROOT
-PROJECTROOT=${PROJECT}/gad-ff
-# the python environment to use (run `which python` to find it)
-PYTHONBIN=${HOME}/gad-ff/gadenv/bin/python
-WANDB_ENTITY=...
-MPLCONFIGDIR=${PROJECTROOT}/.matplotlib
-```
-
-
-Simlink
-```bash
-rm -rf ${PROJECT}/.cache
-rm -rf ${HOME}/.cache
-mkdir -p ${PROJECT}/.cache
-# the fake folder we will use
-ln -s ${PROJECT}/.cache ${HOME}/.cache
-# Check the simlink
-ls -la ${PROJECT}/.cache
-
-rm -rf ${PROJECT}/.conda
-rm -rf ${HOME}/.conda
-mkdir -p ${PROJECT}/.conda
-# the fake folder we will use
-ln -s ${PROJECT}/.conda ${HOME}/.conda
-# Check the simlink
-ls -la ${PROJECT}/.conda
-
-rm -rf ${PROJECT}/.mamba
-rm -rf ${HOME}/.mamba
-mkdir -p ${PROJECT}/.mamba
-# the fake folder we will use
-ln -s ${PROJECT}/.mamba ${HOME}/.mamba
-# Check the simlink
-ls -la ${PROJECT}/.mamba
-```
-
-
-### Setup
-
-```bash
-# download HORM dataset (11GB)
-python scripts_horm/download_horm_data_kaggle.py
-```
-
-```bash
-# Download HORM EquiformerV2 with Energy-Force-Hessian Training
-mkdir -p ckpt
-wget https://huggingface.co/yhong55/HORM/resolve/main/eqv2.ckpt -O ckpt/eqv2.ckpt
-```
-
-
-### Start an interactive session
-
-Killarney
-```bash
-salloc -A aip-aspuru -t 60:00:00 -D /project/aip-aspuru/aburger/gad-ff --gres=gpu:l40s:1 --mem=128GB
-```
-Balam
-```bash
-debugjob --clean -g 1
-```

docs/eigen_dataset.md

@@ -1,81 +0,0 @@
-# Creating the Eigen dataset 
-Smallest Hessian eigenvalues and their eigenvectors
-
-For more information about the HORM dataset, see [docs/horm.md](docs/horm.md)
-
-### Prerequisites
-
-Start an interactive job
-```bash
-salloc -A aip-aspuru -t 60:00:00 -D /project/aip-aspuru/aburger/gad-ff --gres=gpu:l40s:1 --mem=128GB
-source gadenv/bin/activate
-source .env
-```
-
-Download the HORM dataset (11GB)
-```bash
-python scripts_horm/download_horm_data_kaggle.py
-```
-
-## DFT Hessian-eigen dataset
-
-```bash
-python scripts/create_dft_hess_eigen_dataset.py --dataset-file data/sample_100.lmdb
-    
-python scripts/create_dft_hess_eigen_dataset.py --dataset-file ts1x-val.lmdb
-python scripts/create_dft_hess_eigen_dataset.py --dataset-file RGD1.lmdb
-python scripts/create_dft_hess_eigen_dataset.py --dataset-file ts1x_hess_train_big.lmdb
-"""
-
-## EquiformerV2 Hessian-eigen dataset
-
-### Test
-Test if the dataset creation is working
-```bash
-python scripts/create_equ_hess_eigen_dataset.py --dataset-file data/sample_100.lmdb
-python scripts/test_eigen_dataset.py --original-dataset data/sample_100.lmdb
-```
-
-### Smaller datasets
-Create the smaller datasets (~10-20h each)
-```bash
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset.py --dataset-file ts1x-val.lmdb
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset.py --dataset-file RGD1.lmdb
-
-# test
-python scripts/test_eigen_dataset.py --original-dataset ts1x-val.lmdb
-python scripts/test_eigen_dataset.py --original-dataset RGD1.lmdb
-```
-
-### Large datasets
-
-We split the datasets into 10 parts that can run in parallel (~3 days each)
-```bash
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset_split.py --process --dataset ts1x_hess_train_big.lmdb --start-idx 0 --end-idx 172536 --job-id 0
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset_split.py --process --dataset ts1x_hess_train_big.lmdb --start-idx 172536 --end-idx 345072 --job-id 1
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset_split.py --process --dataset ts1x_hess_train_big.lmdb --start-idx 345072 --end-idx 517608 --job-id 2
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset_split.py --process --dataset ts1x_hess_train_big.lmdb --start-idx 517608 --end-idx 690144 --job-id 3
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset_split.py --process --dataset ts1x_hess_train_big.lmdb --start-idx 690144 --end-idx 862680 --job-id 4
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset_split.py --process --dataset ts1x_hess_train_big.lmdb --start-idx 862680 --end-idx 1035216 --job-id 5
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset_split.py --process --dataset ts1x_hess_train_big.lmdb --start-idx 1035216 --end-idx 1207752 --job-id 6
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset_split.py --process --dataset ts1x_hess_train_big.lmdb --start-idx 1207752 --end-idx 1380288 --job-id 7
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset_split.py --process --dataset ts1x_hess_train_big.lmdb --start-idx 1380288 --end-idx 1552824 --job-id 8
-sbatch scripts/killarney.sh scripts/create_equ_hess_eigen_dataset_split.py --process --dataset ts1x_hess_train_big.lmdb --start-idx 1552824 --end-idx 1725362 --job-id 9
-```
-
-After the job is done, we can merge the datasets
-```bash
-python scripts/create_equ_hess_eigen_dataset_split.py --combine --dataset ts1x_hess_train_big.lmdb
-```
-
-Check the files (default location)
-```bash
-ls -lh ~/.cache/kagglehub/datasets/yunhonghan/hessian-dataset-for-optimizing-reactive-mliphorm/versions/5/
-```
-
-### Next steps
-
-Get training
-```bash
-python scripts/train_eigen.py experiment=debug
-```

docs/horm.md

@@ -1,157 +0,0 @@
-# HORM：A Molecular Hessian Database for Optimizing Reactive Machine Learning Interatomic Potentials
-
-This is the official implementation for the paper: "A Molecular Hessian Database for Optimizing Reactive Machine Learning Interatomic Potentials". 
-
-Paper: https://arxiv.org/abs/2505.12447
-Code: https://github.com/deepprinciple/HORM
-Data: https://www.kaggle.com/datasets/yunhonghan/hessian-dataset-for-optimizing-reactive-mliphorm/data
-
-
-- [Overview](#overview)
-- [Installation Guide](#installation-guide)
-- [How to run this code](#how-to-run-this-code)
-
-# Overview
-Transition state (TS) characterization is central to computational reaction modeling, yet conventional approaches depend on expensive density functional theory (DFT) calculations, limiting their scalability. Machine learning interatomic potentials (MLIPs) have emerged as a promising approach to accelerate TS searches by approximating quantum-level accuracy at a fraction of the cost. However, most MLIPs are primarily designed for energy and force prediction, thus their capacity to accurately estimate Hessians, which are crucial for TS optimization, remains constrained by limited training data and inadequate learning strategies. This work introduces the Hessian dataset for Optimizing Reactive MLIP (HORM), the largest quantum chemistry Hessian database dedicated to reactive systems, comprising 1.84 million Hessian matrices computed at the $\omega$B97X/6-31G(d) level of theory. To effectively leverage this dataset, we adopt a Hessian-informed training strategy that incorporates stochastic row sampling, which addresses the dramatically increased cost and complexity of incorporating second-order information into MLIPs. Various MLIP architectures and force prediction schemes trained on HORM demonstrate up to a 63\% reduction in Hessian mean absolute error and up to a 200× increase in TS search success rates compared to models trained without Hessian information. These results highlight how HORM addresses critical data and methodological gaps, enabling the development of more accurate and robust reactive MLIPs for large-scale reaction network exploration.
-
-
-# Installation Guide:
-
-
-```bash
-pip install torch==2.2.1
-pip install . # building wheel might take a while
-```
-
-For torch-cluster installation, you need to install the version that matches your CUDA version. 
-For example, if you encounter CUDA-related errors, you can uninstall torch-cluster and install the version matching your CUDA version. For CUDA 12.1:
-
-```bash
-pip install torch-cluster -f https://data.pyg.org/whl/torch-2.2.1+cu121.html
-```
-
-
-
-# How to run this code:
-
-### Train models
-
-To train a model, please select the desired architecture from the available options: 'LeftNet', 'EquiformerV2', and 'AlphaNet'.  
-Specify your choice in the `model_type` field within the `train.py` file.
-```bash
-python train.py
-```
-
-### Evaluate models
-
-To evaluate a model, please specify the lmdb dataset and checkpoint, and run the following command:
-```bash
-python eval.py
-```
-
-EquiformerV2 MAE should be:
-Transition1x:
-Energy: 0.02 eV
-Force: 0.02 eV/A
-Hessian: 0.08 eV/A^2
-Hessian eigenvalues: 0.003 eV/A^2
-RGD1:
-Energy: 0.13 eV
-Force: 0.05 eV/A
-Hessian: 0.09 eV/A^2
-Hessian eigenvalues: 0.003 eV/A^2
-
-## Dataset
-
-The HORM dataset is available at: https://www.kaggle.com/datasets/yunhonghan/hessian-dataset-for-optimizing-reactive-mliphorm/data
-
-Run the following command to download the dataset:
-```bash
-# default is ~/.cache
-# export KAGGLEHUB_CACHE=/path/to/your/preferred/directory
-python download_horm_data_kaggle.py
-```
-
-```bash
-ls ~/.cache/kagglehub/datasets/yunhonghan/hessian-dataset-for-optimizing-reactive-mliphorm/versions/5
-
-total 23G
-1.1G RGD1.lmdb (60000 samples)
-21G ts1x_hess_train_big.lmdb (1725362 samples)
-620M ts1x-val.lmdb (50844 samples)
-```
-
-Keys in the dataset:
-```python
-['force_constant', 'charges', 'energy', 'freq', 'forces', 'one_hot', 'pos', 'natoms', 'eig_values', 'hessian']
-```
-```python
-Shapes per key:
-forces: torch.Size([22, 3])
-freq: torch.Size([66])
-force_constant: torch.Size([66])
-charges: torch.Size([22])
-one_hot: torch.Size([22, 5])
-energy: torch.Size([])
-pos: torch.Size([22, 3])
-hessian: torch.Size([4356])
-eig_values: torch.Size([66])
-natoms: torch.Size([])
-```
-
-Note on the elements / atomic numbers:
-the HORM dataset uses a weird convention:
-atom types are encoded as one-hot vectors of shape (N, 5)
-where the fifth is unused, likely a padding or None class.
-corresponds to H, C, N, O, None
-
-All models are trained on the HORM-Transition1x training set
-and evaluated on both the in-distribution (ID) Transition1x validation set and the out-of-distribution
-(OOD) HORM-RGD1 subset
-
-## Model checkpoints
-Pre-trained model checkpoints can be downloaded from: https://huggingface.co/yhong55/HORM
-
-Checkpoints available:
-
-Filename | Model | Training Method \
-alpha_orig.ckpt | AlphaNet | Energy-Force Training \
-alpha.ckpt | AlphaNet | Energy-Force-Hessian Training \
-left_orig.ckpt | LEFTNet | Energy-Force Training \
-left.ckpt | LEFTNet | Energy-Force-Hessian Training \
-left-df_orig.ckpt | LEFTNet-df | Energy-Force Training \
-left-df.ckpt | LEFTNet-df | Energy-Force-Hessian Training \
-eqv2_orig.ckpt | EquiformerV2 | Energy-Force Training \
-eqv2.ckpt | EquiformerV2 | Energy-Force-Hessian Training \
-
-
-To download specific model checkpoints, use the following command:
-```bash
-# Download EquiformerV2 with Energy-Force-Hessian Training
-mkdir -p ckpt
-wget https://huggingface.co/yhong55/HORM/resolve/main/eqv2.ckpt -O ckpt/eqv2.ckpt
-```
-
-
-# Notes
-
-### Dataset
-- The models were trained on the HORM dataset.
-- The geometries in the HORM dataset are sampled from Transition1x and RGD1. 
-- All sampled geometries were recomputed by GPU4PYSCF at the $\omega$B97X/6-31G* level of theory to obtain energies, forces, and Hessian
-- T1x: 9,000 reactions to the training set and the remaining 1,073 reactions to the validation set. From these, 1,725,362 geometries corresponding to the training reactions and 50,844 geometries from the validation reactions were used to train the models.
-- RGD1: From approximately 950,000 available reactions, we randomly selected 80,000 and sampled up to 15 geometries per reaction along their IRC trajectories. From this pool, 60,000 geometries were randomly chosen.
-
-### Training
-- The Hessian was computed from the forces via autograd.
-- Randomly sample a subset of two columns from each Hessian matrix during training.
-- Training was done on an unknown number of A30 (24 GB) and H20 (96 GB) GPUs
-
-For EquiformerV2:
-
-Layers HiddenDim Heads NHR LearningRate BatchSize \
-4 128 4 2 3e-4 128
-
-
-# License
-This project is licensed under the Creative Commons Attribution-NonCommercial-ShareAlike 4.0 International License (CC BY-NC-SA 4.0). For more details, please refer to the [CC BY-NC-SA 4.0 License](https://creativecommons.org/licenses/by-nc-sa/4.0/).

docs/rgd1.md

@@ -1,79 +0,0 @@
-# RGD1
-https://www.nature.com/articles/s41597-023-02043-z
-
-## TL;DR
-
-After filtering we get 140_673 triplets of (transition state, reactant, product), where each reactant-product pair appears only once.
-
-- train split: 112538 reactions, 8249716 total atoms
-- val split: 14067 reactions, 1031949 total atoms
-- test split: 14068 reactions, 1031144 total atoms
-
-## Train/val/test split
-
-Use the same validation strategy as OA-ReactDiff and React-OT:
-Train on all of RGD1, validate on part of Transition1x:
-partitioned Transition1x randomly, with 9,000 reactions used in training and validation, 
-and the remaining 1,073 reactions as set-aside test set
-
-It is not guaranteed that all molecules in test reactions are unseen by a trained model 
-due to the overlapping structures in different reactions. 
-However, each elementary reaction is unique, so atmost either the reactant or product, 
-but not both, is seen in the training set.
-
-## RGD1 dataset info
-We attempted ~760k reactions at the xtb level, 
-but after filtering unintended transition states 
-(i.e., those classified to not correspond to the reactant and product that were used in the double-ended search) 
-we were left with ~176k transition states. 
-Most of the RGD-1 data at the DFT level is on the filtered ~176k intended TSs.
-React-OT pretrained on the full set of intended and unintended at the xtb level (~760k).
-
-The dataset is composed of 176,992 organic reactions possessing: 
-at least one validated TS, activation energy, heat of reaction, reactant and product geometries, frequencies, and atom-mapping. 
-For 33,032 reactions, more than one TS was discovered by conformational sampling.
-Note: here 'reaction' refers to a reaction-product pair, not a transition state.
-I.e. the number of reactions is smaller than the number of transition states.
-
-## RGD1 file structure
-- RGD1_CHNO.h5 contains the geometry information of the transition states. 176_992 entries.
-- RGD1CHNO_AMsmiles.csv contains atom-mapped SMILES, activation energies, and enthalpies of formation for each reaction. Only 176_898 entries?
-- RandP_smiles.txt is a dictionary to map the reactant and product smiles appear in RGD1_CHNO.h5 to a molecule index (molX).
-- RGD1_RPs.h5 provides xtb and DFT optimized geometries of each individual reactant/product molecules. 123_088 entries, because some reactants and products are identical. But 836 are missing?
-- 3D ML models can be trained by combining RGD1_RPs.h5, RGD1_CHNO.h5, and RandP_smiles.txt
-- DFT_reaction_info.csv is supplied to reproduce figures in the article. Ignore.
-
-In the RGD1_CHNO.h5 file: 
-Property                             | Key     | Units
--------------------------------------|---------|--------
-Reactant smiles                      | Rsmiles | -
-Product smiles                       | Psmiles | -
-Reactant single point energy         | R_E     | Hartree
-Reactant enthalpy                    | R_H     | Hartree
-Reactant Gibbs free energy           | R_F     | Hartree
-Product single point energy          | P_E     | Hartree
-Product enthalpy                     | P_H     | Hartree
-Product Gibbs free energy            | P_F     | Hartree
-Transition state single point energy | TS_E    | Hartree
-Transition state enthalpy            | TS_H    | Hartree
-Transition state Gibbs free energy   | TS_F    | Hartree
-Reactant geometry                    | RG      | Å
-Product geometry                     | PG      | Å
-Transition state geometry            | TSG     | Å
-
-In the .csv file:
-Column   | Description
----------|--------------------------------------------------
-Rind     | Reaction index
-Rsmiles  | Atom-mapped smiles of reactant(s)
-Psmiles  | Atom-mapped smiles of product(s)
-DE_F     | Activation energy of the forward reaction
-DE_B     | Activation energy of the backward reaction
-DG_F     | Free energy of activation of the forward reaction
-DG_B     | Free energy of activation of the backward reaction
-DH       | Enthalpy of reaction (forward reaction)
-
-The Rind refers to the reaction index with a format of MR_XXX_X
-
-The RGD1-xTB-760k dataset that React-OT used is here: 
-https://transfer.rcac.purdue.edu/file-manager?origin_id=1cc8429c-f64c-11ed-9bb7-c9bb788c490e&path=%2F

docs/training.md

@@ -1,77 +0,0 @@
-# Training HORM EquiformerV2 on Eigen dataset
-
-Extra prediction heads for the Hessian eigenvalues and eigenvectors.
-
-## Start job
-
-Killarney
-```bash
-salloc -A aip-aspuru -t 60:00:00 -D /project/aip-aspuru/aburger/gad-ff --gres=gpu:l40s:1 --mem=128GB
-source gadenv/bin/activate
-source .env
-```
-
-## Training
-
-Verify the training script and environment are working
-```bash
-python scripts/train_eigen.py experiment=debug
-sbatch scripts/killarney.sh scripts/train_eigen.py experiment=debug
-```
-
-Verify that we can overfit to the tiny dataset (using one L40s)
-```bash
-sbatch scripts/killarney.sh scripts/train_eigen.py experiment=overfit100
-sbatch scripts/killarney.sh scripts/train_eigen.py experiment=overfit100 training.loss_type_vec=cosine
-```
-
-Fit on the smaller training dataset (RGD1), test on TS1x
-```bash
-sbatch scripts/killarney_2xl40s.sh scripts/train_eigen.py experiment=rgd1 gpu=two
-sbatch scripts/killarney_2xl40s.sh scripts/train_eigen.py experiment=rgd1 gpu=two training.lr_schedule_type=null
-
-# smaller batch size instead
-sbatch scripts/killarney.sh scripts/train_eigen.py experiment=rgd1 training.bz=64
-sbatch scripts/killarney.sh scripts/train_eigen.py experiment=rgd1 training.bz=64 training.lr_schedule_type=null
-
-# H100 instead
-sbatch scripts/killarney_h100.sh scripts/train_eigen.py experiment=rgd1 
-```
-
-Fit on the larger training dataset (TS1x), test on TS1x
-```bash
-sbatch scripts/killarney.sh scripts/train_eigen.py experiment=ts1x
-sbatch scripts/killarney.sh scripts/train_eigen.py experiment=ts1x training.loss_type_vec=cosine
-sbatch scripts/killarney.sh scripts/train_eigen.py experiment=ts1x training.loss_type_vec=cosine training.lr_schedule_type=null
-```
-
-Fit on both datasets (RGD1 and TS1x), test on TS1x
-```bash
-sbatch scripts/killarney_h100.sh scripts/train_eigen.py experiment=alldata
-```
-
-## Background
-
-We have two training datasets and one validation dataset:
-```bash
-ls ~/.cache/kagglehub/datasets/yunhonghan/hessian-dataset-for-optimizing-reactive-mliphorm/versions/5
-
-total 23G
-1.1G RGD1.lmdb (60000 samples)
-21G ts1x_hess_train_big.lmdb (1725362 samples)
-620M ts1x-val.lmdb (50844 samples)
-```
-Plus a tiny subset for debugging
-```bash
-ls data
-
-sample_100.lmdb
-```
-
-There are two kinds of nodes on our Killarney cluster:
-
-Performance Tier | Nodes | Model | CPU | Cores | System Memory | GPUs per node | Total GPUs \
-Standard Compute | 168 | Dell 750xa | 2 x Intel Xeon Gold 6338 | 64 | 512 GB | 4 x NVIDIA L40S 48GB | 672 \
-Performance Compute | 10 | Dell XE9680 | 2 x Intel Xeon Gold 6442Y | 48 | 2048 GB | 8 x NVIDIA H100 SXM 80GB | 80
-
-