File size: 3,551 Bytes
672ecc3 | 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 | """Predict yields from reaction SMILES."""
from rdkit import Chem
import torch
from .reactiont5_jepa import load_model
def canonicalize(smiles):
# Same normalization and dot-component ordering as prepare_data.py.
cleaned = smiles.replace('. ', '').replace(' .', '').replace(' ', ' ').strip()
if not cleaned:
return ' '
molecule = Chem.MolFromSmiles(cleaned)
if molecule is None:
raise ValueError(f'Invalid SMILES: {smiles!r}')
return '.'.join(sorted(Chem.MolToSmiles(molecule, canonical=True).split('.')))
def reaction_text(row):
for key in ('REACTANT', 'REAGENT', 'PRODUCT'):
if key not in row or not isinstance(row[key], str):
raise ValueError(f'Missing or non-string field: {key}')
if not row['REACTANT'].strip() or not row['PRODUCT'].strip():
raise ValueError('REACTANT and PRODUCT must be nonempty SMILES')
catalyst = row.get('CATALYST') or ''
if not isinstance(catalyst, str):
raise ValueError('CATALYST must be a SMILES string')
reagent = '.'.join(part for part in (catalyst, row['REAGENT']) if part.strip())
fields = {
'REACTANT': canonicalize(row['REACTANT']),
'REAGENT': canonicalize(reagent),
'PRODUCT': canonicalize(row['PRODUCT']),
}
return ''.join(f'{key}:{fields[key]}' for key in ('REACTANT', 'REAGENT', 'PRODUCT'))
class YieldPredictor:
def __init__(self, model_dir, device='cpu', precision='fp32', verify_checksum=True):
if precision not in ('bf16', 'fp32'):
raise ValueError('precision must be bf16 or fp32')
self.model, self.tokenizer, self.info = load_model(model_dir, device, verify_checksum)
self.device = torch.device(device)
self.precision = precision
if self.device.type == 'cuda' and precision == 'bf16' and not torch.cuda.is_bf16_supported():
raise RuntimeError('This GPU does not support BF16; use precision="fp32"')
@torch.inference_mode()
def predict(self, reactions, batch_size=32):
if batch_size < 1:
raise ValueError('batch_size must be positive')
reactions = list(reactions)
texts = [reaction_text(row) for row in reactions]
results = []
for start in range(0, len(texts), batch_size):
batch = texts[start:start + batch_size]
full_ids = self.tokenizer(batch, add_special_tokens=True, truncation=False)['input_ids']
encoded = self.tokenizer(
batch, add_special_tokens=True, padding='max_length', truncation=True,
max_length=self.info['max_input_length'], return_tensors='pt',
)
inputs = {key: encoded[key].to(self.device) for key in ('input_ids', 'attention_mask')}
values = self.model(inputs, self.precision).float().cpu().tolist()
for offset, value in enumerate(values):
if not (-float('inf') < value < float('inf')):
raise RuntimeError('The model produced a non-finite prediction')
results.append({
'index': start + offset,
'reaction_input': batch[offset],
'yield_fraction_raw': value,
'yield_percent_raw': value * 100.0,
'yield_percent_clipped': min(100.0, max(0.0, value * 100.0)),
'input_tokens': len(full_ids[offset]),
'input_truncated': len(full_ids[offset]) > self.info['max_input_length'],
})
return results
|