| """Predict yields from reaction SMILES.""" |
| from rdkit import Chem |
| import torch |
| from .reactiont5_jepa import load_model |
|
|
| def canonicalize(smiles): |
| |
| 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 |
|
|
|
|
