|
import time |
|
import math |
|
from contextlib import nullcontext |
|
import numpy as np |
|
import torch |
|
import torch.nn as nn |
|
from torch.nn import functional as F |
|
import inspect |
|
from dataclasses import dataclass |
|
import streamlit as st |
|
import pandas as pd |
|
from rdkit import Chem |
|
from rdkit.Chem import Draw |
|
|
|
|
|
eval_interval = 250 |
|
eval_iters = 200 |
|
log_interval = 10 |
|
always_save_checkpoint = False |
|
dataset = 'lipid_char' |
|
gradient_accumulation_steps = 1 |
|
beta2 = 0.99 |
|
eval_only = False |
|
init_from = 'scratch' |
|
bias = False |
|
weight_decay = 1e-1 |
|
beta1 = 0.9 |
|
grad_clip = 1.0 |
|
min_lr = 6e-5 |
|
backend = 'nccl' |
|
device = 'cuda' |
|
dtype = 'bfloat16' if torch.cuda.is_available() and torch.cuda.is_bf16_supported() else 'float16' |
|
config_keys = [k for k,v in globals().items() if not k.startswith('_') and isinstance(v, (int, float, bool, str))] |
|
config = {k: globals()[k] for k in config_keys} |
|
master_process = True |
|
torch.backends.cuda.matmul.allow_tf32 = True |
|
torch.backends.cudnn.allow_tf32 = True |
|
device_type = 'cuda' if 'cuda' in device else 'cpu' |
|
ptdtype = {'float32': torch.float32, 'bfloat16': torch.bfloat16, 'float16': torch.float16}[dtype] |
|
ctx = nullcontext() if device_type == 'cpu' else torch.amp.autocast(device_type=device_type, dtype=ptdtype) |
|
|
|
|
|
@st.cache_resource |
|
class LayerNorm(nn.Module): |
|
""" LayerNorm but with an optional bias. PyTorch doesn't support simply bias=False """ |
|
|
|
def __init__(self, ndim, bias): |
|
super().__init__() |
|
self.weight = nn.Parameter(torch.ones(ndim)) |
|
self.bias = nn.Parameter(torch.zeros(ndim)) if bias else None |
|
|
|
def forward(self, input): |
|
return F.layer_norm(input, self.weight.shape, self.weight, self.bias, 1e-5) |
|
|
|
@st.cache_resource |
|
class CausalSelfAttention(nn.Module): |
|
|
|
def __init__(self, config): |
|
super().__init__() |
|
assert config.n_embd % config.n_head == 0 |
|
|
|
self.c_attn = nn.Linear(config.n_embd, 3 * config.n_embd, bias=config.bias) |
|
|
|
self.c_proj = nn.Linear(config.n_embd, config.n_embd, bias=config.bias) |
|
|
|
self.attn_dropout = nn.Dropout(config.dropout) |
|
self.resid_dropout = nn.Dropout(config.dropout) |
|
self.n_head = config.n_head |
|
self.n_embd = config.n_embd |
|
self.dropout = config.dropout |
|
|
|
self.flash = hasattr(torch.nn.functional, 'scaled_dot_product_attention') |
|
if not self.flash: |
|
print("WARNING: using slow attention. Flash Attention requires PyTorch >= 2.0") |
|
|
|
self.register_buffer("bias", torch.tril(torch.ones(config.block_size, config.block_size)) |
|
.view(1, 1, config.block_size, config.block_size)) |
|
|
|
def forward(self, x): |
|
B, T, C = x.size() |
|
|
|
|
|
q, k, v = self.c_attn(x).split(self.n_embd, dim=2) |
|
k = k.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) |
|
q = q.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) |
|
v = v.view(B, T, self.n_head, C // self.n_head).transpose(1, 2) |
|
|
|
|
|
if self.flash: |
|
|
|
y = torch.nn.functional.scaled_dot_product_attention(q, k, v, attn_mask=None, dropout_p=self.dropout if self.training else 0, is_causal=True) |
|
else: |
|
|
|
att = (q @ k.transpose(-2, -1)) * (1.0 / math.sqrt(k.size(-1))) |
|
att = att.masked_fill(self.bias[:,:,:T,:T] == 0, float('-inf')) |
|
att = F.softmax(att, dim=-1) |
|
att = self.attn_dropout(att) |
|
y = att @ v |
|
y = y.transpose(1, 2).contiguous().view(B, T, C) |
|
|
|
|
|
y = self.resid_dropout(self.c_proj(y)) |
|
return y |
|
|
|
@st.cache_resource |
|
class MLP(nn.Module): |
|
|
|
def __init__(self, config): |
|
super().__init__() |
|
self.c_fc = nn.Linear(config.n_embd, 4 * config.n_embd, bias=config.bias) |
|
self.gelu = nn.GELU() |
|
self.c_proj = nn.Linear(4 * config.n_embd, config.n_embd, bias=config.bias) |
|
self.dropout = nn.Dropout(config.dropout) |
|
|
|
def forward(self, x): |
|
x = self.c_fc(x) |
|
x = self.gelu(x) |
|
x = self.c_proj(x) |
|
x = self.dropout(x) |
|
return x |
|
|
|
@st.cache_resource |
|
class Block(nn.Module): |
|
|
|
def __init__(self, config): |
|
super().__init__() |
|
self.ln_1 = LayerNorm(config.n_embd, bias=config.bias) |
|
self.attn = CausalSelfAttention(config) |
|
self.ln_2 = LayerNorm(config.n_embd, bias=config.bias) |
|
self.mlp = MLP(config) |
|
|
|
def forward(self, x): |
|
x = x + self.attn(self.ln_1(x)) |
|
x = x + self.mlp(self.ln_2(x)) |
|
return x |
|
|
|
@dataclass |
|
class GPTConfig: |
|
block_size: int = 1024 |
|
vocab_size: int = 50304 |
|
n_layer: int = 12 |
|
n_head: int = 12 |
|
n_embd: int = 768 |
|
dropout: float = 0.0 |
|
bias: bool = True |
|
|
|
@st.cache_resource |
|
class GPT(nn.Module): |
|
|
|
def __init__(self, config): |
|
super().__init__() |
|
assert config.vocab_size is not None |
|
assert config.block_size is not None |
|
self.config = config |
|
|
|
self.transformer = nn.ModuleDict(dict( |
|
wte = nn.Embedding(config.vocab_size, config.n_embd), |
|
wpe = nn.Embedding(config.block_size, config.n_embd), |
|
drop = nn.Dropout(config.dropout), |
|
h = nn.ModuleList([Block(config) for _ in range(config.n_layer)]), |
|
ln_f = LayerNorm(config.n_embd, bias=config.bias), |
|
)) |
|
self.lm_head = nn.Linear(config.n_embd, config.vocab_size, bias=False) |
|
self.transformer.wte.weight = self.lm_head.weight |
|
|
|
|
|
self.apply(self._init_weights) |
|
|
|
for pn, p in self.named_parameters(): |
|
if pn.endswith('c_proj.weight'): |
|
torch.nn.init.normal_(p, mean=0.0, std=0.02/math.sqrt(2 * config.n_layer)) |
|
|
|
print("number of parameters: %.2fM" % (self.get_num_params()/1e6,)) |
|
|
|
def get_num_params(self, non_embedding=True): |
|
""" |
|
Return the number of parameters in the model. |
|
For non-embedding count (default), the position embeddings get subtracted. |
|
The token embeddings would too, except due to the parameter sharing these |
|
params are actually used as weights in the final layer, so we include them. |
|
""" |
|
n_params = sum(p.numel() for p in self.parameters()) |
|
if non_embedding: |
|
n_params -= self.transformer.wpe.weight.numel() |
|
return n_params |
|
|
|
def _init_weights(self, module): |
|
if isinstance(module, nn.Linear): |
|
torch.nn.init.normal_(module.weight, mean=0.0, std=0.02) |
|
if module.bias is not None: |
|
torch.nn.init.zeros_(module.bias) |
|
elif isinstance(module, nn.Embedding): |
|
torch.nn.init.normal_(module.weight, mean=0.0, std=0.02) |
|
|
|
def forward(self, idx, targets=None): |
|
device = idx.device |
|
b, t = idx.size() |
|
assert t <= self.config.block_size, f"Cannot forward sequence of length {t}, block size is only {self.config.block_size}" |
|
pos = torch.arange(0, t, dtype=torch.long, device=device) |
|
|
|
|
|
tok_emb = self.transformer.wte(idx) |
|
pos_emb = self.transformer.wpe(pos) |
|
x = self.transformer.drop(tok_emb + pos_emb) |
|
for block in self.transformer.h: |
|
x = block(x) |
|
x = self.transformer.ln_f(x) |
|
|
|
if targets is not None: |
|
|
|
logits = self.lm_head(x) |
|
loss = F.cross_entropy(logits.view(-1, logits.size(-1)), targets.view(-1), ignore_index=-1) |
|
else: |
|
|
|
logits = self.lm_head(x[:, [-1], :]) |
|
loss = None |
|
return logits, loss |
|
|
|
def crop_block_size(self, block_size): |
|
|
|
|
|
|
|
assert block_size <= self.config.block_size |
|
self.config.block_size = block_size |
|
self.transformer.wpe.weight = nn.Parameter(self.transformer.wpe.weight[:block_size]) |
|
for block in self.transformer.h: |
|
if hasattr(block.attn, 'bias'): |
|
block.attn.bias = block.attn.bias[:,:,:block_size,:block_size] |
|
|
|
@classmethod |
|
def from_pretrained(cls, model_type, override_args=None): |
|
assert model_type in {'gpt2', 'gpt2-medium', 'gpt2-large', 'gpt2-xl'} |
|
override_args = override_args or {} |
|
|
|
assert all(k == 'dropout' for k in override_args) |
|
from transformers import GPT2LMHeadModel |
|
print("loading weights from pretrained gpt: %s" % model_type) |
|
|
|
|
|
config_args = { |
|
'gpt2': dict(n_layer=12, n_head=12, n_embd=768), |
|
'gpt2-medium': dict(n_layer=24, n_head=16, n_embd=1024), |
|
'gpt2-large': dict(n_layer=36, n_head=20, n_embd=1280), |
|
'gpt2-xl': dict(n_layer=48, n_head=25, n_embd=1600), |
|
}[model_type] |
|
print("forcing vocab_size=50257, block_size=1024, bias=True") |
|
config_args['vocab_size'] = 50257 |
|
config_args['block_size'] = 1024 |
|
config_args['bias'] = True |
|
|
|
if 'dropout' in override_args: |
|
print(f"overriding dropout rate to {override_args['dropout']}") |
|
config_args['dropout'] = override_args['dropout'] |
|
|
|
config = GPTConfig(**config_args) |
|
model = GPT(config) |
|
sd = model.state_dict() |
|
sd_keys = sd.keys() |
|
sd_keys = [k for k in sd_keys if not k.endswith('.attn.bias')] |
|
|
|
|
|
model_hf = GPT2LMHeadModel.from_pretrained(model_type) |
|
sd_hf = model_hf.state_dict() |
|
|
|
|
|
sd_keys_hf = sd_hf.keys() |
|
sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.masked_bias')] |
|
sd_keys_hf = [k for k in sd_keys_hf if not k.endswith('.attn.bias')] |
|
transposed = ['attn.c_attn.weight', 'attn.c_proj.weight', 'mlp.c_fc.weight', 'mlp.c_proj.weight'] |
|
|
|
|
|
assert len(sd_keys_hf) == len(sd_keys), f"mismatched keys: {len(sd_keys_hf)} != {len(sd_keys)}" |
|
for k in sd_keys_hf: |
|
if any(k.endswith(w) for w in transposed): |
|
|
|
assert sd_hf[k].shape[::-1] == sd[k].shape |
|
with torch.no_grad(): |
|
sd[k].copy_(sd_hf[k].t()) |
|
else: |
|
|
|
assert sd_hf[k].shape == sd[k].shape |
|
with torch.no_grad(): |
|
sd[k].copy_(sd_hf[k]) |
|
return model |
|
|
|
def configure_optimizers(self, weight_decay, learning_rate, betas, device_type): |
|
|
|
param_dict = {pn: p for pn, p in self.named_parameters()} |
|
|
|
param_dict = {pn: p for pn, p in param_dict.items() if p.requires_grad} |
|
|
|
|
|
decay_params = [p for n, p in param_dict.items() if p.dim() >= 2] |
|
nodecay_params = [p for n, p in param_dict.items() if p.dim() < 2] |
|
optim_groups = [ |
|
{'params': decay_params, 'weight_decay': weight_decay}, |
|
{'params': nodecay_params, 'weight_decay': 0.0} |
|
] |
|
num_decay_params = sum(p.numel() for p in decay_params) |
|
num_nodecay_params = sum(p.numel() for p in nodecay_params) |
|
print(f"num decayed parameter tensors: {len(decay_params)}, with {num_decay_params:,} parameters") |
|
print(f"num non-decayed parameter tensors: {len(nodecay_params)}, with {num_nodecay_params:,} parameters") |
|
|
|
fused_available = 'fused' in inspect.signature(torch.optim.AdamW).parameters |
|
use_fused = fused_available and device_type == 'cuda' |
|
extra_args = dict(fused=True) if use_fused else dict() |
|
optimizer = torch.optim.AdamW(optim_groups, lr=learning_rate, betas=betas, **extra_args) |
|
print(f"using fused AdamW: {use_fused}") |
|
return optimizer |
|
|
|
def estimate_mfu(self, fwdbwd_per_iter, dt): |
|
""" estimate model flops utilization (MFU) in units of A100 bfloat16 peak FLOPS """ |
|
|
|
|
|
N = self.get_num_params() |
|
cfg = self.config |
|
L, H, Q, T = cfg.n_layer, cfg.n_head, cfg.n_embd//cfg.n_head, cfg.block_size |
|
flops_per_token = 6*N + 12*L*H*Q*T |
|
flops_per_fwdbwd = flops_per_token * T |
|
flops_per_iter = flops_per_fwdbwd * fwdbwd_per_iter |
|
|
|
flops_achieved = flops_per_iter * (1.0/dt) |
|
flops_promised = 312e12 |
|
mfu = flops_achieved / flops_promised |
|
return mfu |
|
|
|
@torch.no_grad() |
|
def generate(self, idx, max_new_tokens, temperature=1.0, top_k=None): |
|
while True: |
|
|
|
idx_cond = idx if idx.size(1) <= self.config.block_size else idx[:, -self.config.block_size:] |
|
|
|
logits, _ = self(idx_cond) |
|
|
|
logits = logits[:, -1, :] / temperature |
|
|
|
if top_k is not None: |
|
v, _ = torch.topk(logits, min(top_k, logits.size(-1))) |
|
logits[logits < v[:, [-1]]] = -float('Inf') |
|
|
|
probs = F.softmax(logits, dim=-1) |
|
|
|
idx_next = torch.multinomial(probs, num_samples=1) |
|
if idx_next.item() == 0: |
|
break |
|
else: |
|
idx = torch.cat((idx, idx_next), dim=1) |
|
return idx |
|
|
|
@st.cache_data |
|
def canonicalize(smiles): |
|
mol = Chem.MolFromSmiles(smiles) |
|
if mol is not None: |
|
return Chem.MolToSmiles(mol) |
|
else: |
|
return None |
|
|
|
@st.cache_data |
|
def get_batch(split): |
|
data = train_data if split == 'train' else val_data |
|
ix = torch.randint(len(data) - block_size, (batch_size,)) |
|
x = torch.stack([torch.from_numpy((data[i:i+block_size]).astype(np.int64)) for i in ix]) |
|
y = torch.stack([torch.from_numpy((data[i+1:i+1+block_size]).astype(np.int64)) for i in ix]) |
|
if device_type == 'cuda': |
|
x, y = x.pin_memory().to(device, non_blocking=True), y.pin_memory().to(device, non_blocking=True) |
|
else: |
|
x, y = x.to(device), y.to(device) |
|
return x, y |
|
|
|
|
|
st.subheader(":rainbow[LiPT: Generate New Molecules With Your Training Data]") |
|
col1, col2, col3 = st.columns(3) |
|
uploaded_file = st.file_uploader("Upload SMILES Data (SMILES should be in a column named smiles)", type="csv") |
|
split_ratio = st.slider("Train-Test Split Ratio", min_value=0.01, max_value=0.99, value=0.9) |
|
st.write("Train on {:.1f}% of data. Test on {:.1f}% of data.".format(split_ratio*100, 100-split_ratio*100)) |
|
|
|
with col1: |
|
max_iters = st.number_input("Training Iterations", min_value=1000, value=4500, step=1) |
|
dropout = st.number_input("Dropout", min_value=0.0, max_value=0.9, value=0.05) |
|
learning_rate = st.number_input("Learning Rate", min_value=6e-5, max_value=1.0, value=1e-3, format="%.5f") |
|
|
|
with col2: |
|
model_complexity = st.number_input("Model Complexity", min_value=1, value=3, step=1) |
|
grad_clip = st.number_input("Gradient Clipping", min_value=0.01, max_value=100.0, value=1.0) |
|
temperature = st.number_input("Randomness of Generation", min_value=0.01, max_value=100.0, value=1.0) |
|
|
|
with col3: |
|
batch_size = st.number_input("Batch Size", min_value=2, value=64, step=1) |
|
block_size = st.number_input("Context Window", min_value=2, value=256, step=1) |
|
num_samples = st.number_input(":violet[**Number of Molecules to Generate**]", min_value=1, value=20, step=1) |
|
|
|
tokens_per_iter = gradient_accumulation_steps * batch_size * block_size |
|
decay_lr = st.checkbox("Learning Rate Decay", value=True) |
|
n_layer = model_complexity |
|
n_head = model_complexity |
|
n_embd = 64 * model_complexity |
|
|
|
if uploaded_file and st.button(":orange[**Train Model and Generate Molecules**]"): |
|
lipid_data = pd.read_csv(uploaded_file).drop_duplicates(subset=['smiles']) |
|
lipid_data['smiles'] = lipid_data['smiles'].apply(canonicalize) |
|
lipid_data = lipid_data.dropna().sample(frac=1).reset_index(drop=True) |
|
data = '\n'.join(lipid_data['smiles']) |
|
chars = sorted(list(set(data))) |
|
vocab_size = len(chars) |
|
st.write("Number of Valid Lipids: {:d}".format(len(lipid_data))) |
|
st.write("All unique characters:", ''.join(chars)) |
|
st.write(f"Vocabulary size: {vocab_size:,}") |
|
stoi = {ch:i for i,ch in enumerate(chars)} |
|
itos = {i:ch for i,ch in enumerate(chars)} |
|
def encode(s): |
|
return [stoi[c] for c in s] |
|
def decode(l): |
|
return ''.join([itos[i] for i in l]) |
|
lr_decay_iters = max_iters |
|
warmup_iters = max_iters // 50 |
|
n = len(data) |
|
train_data = data[:int(n * split_ratio)] |
|
val_data = data[int(n * split_ratio):] |
|
train_ids = encode(train_data) |
|
val_ids = encode(val_data) |
|
st.write(f"{len(train_ids):,} tokens for training") |
|
st.write(f"{len(val_ids):,} tokens for testing") |
|
st.write(":orange[Patience is key π]") |
|
train_data = np.array(train_ids, dtype=np.uint16) |
|
val_data = np.array(val_ids, dtype=np.uint16) |
|
meta = {'vocab_size': vocab_size, 'itos': itos, 'stoi': stoi} |
|
|
|
iter_num = 0 |
|
best_val_loss = 1e9 |
|
meta_vocab_size = meta['vocab_size'] |
|
model_args = dict(n_layer=n_layer, n_head=n_head, n_embd=n_embd, block_size=block_size, bias=bias, vocab_size=None, dropout=dropout) |
|
model_args['vocab_size'] = meta_vocab_size |
|
gptconf = GPTConfig(**model_args) |
|
model = GPT(gptconf) |
|
if block_size < model.config.block_size: |
|
model.crop_block_size(block_size) |
|
model_args['block_size'] = block_size |
|
model.to(device) |
|
scaler = torch.cuda.amp.GradScaler(enabled=(dtype == 'float16')) |
|
optimizer = model.configure_optimizers(weight_decay, learning_rate, (beta1, beta2), device_type) |
|
checkpoint = None |
|
|
|
@torch.no_grad() |
|
def estimate_loss(): |
|
out = {} |
|
model.eval() |
|
for split in ['train', 'val']: |
|
losses = torch.zeros(eval_iters) |
|
for k in range(eval_iters): |
|
X, Y = get_batch(split) |
|
with ctx: |
|
logits, loss = model(X, Y) |
|
losses[k] = loss.item() |
|
out[split] = losses.mean() |
|
model.train() |
|
return out |
|
|
|
def get_lr(it): |
|
if it < warmup_iters: |
|
return learning_rate * it / warmup_iters |
|
if it > lr_decay_iters: |
|
return min_lr |
|
decay_ratio = (it - warmup_iters) / (lr_decay_iters - warmup_iters) |
|
assert 0 <= decay_ratio <= 1 |
|
coeff = 0.5 * (1.0 + math.cos(math.pi * decay_ratio)) |
|
return min_lr + coeff * (learning_rate - min_lr) |
|
|
|
X, Y = get_batch('train') |
|
t0 = time.time() |
|
local_iter_num = 0 |
|
raw_model = model |
|
running_mfu = -1.0 |
|
|
|
while True: |
|
lr = get_lr(iter_num) if decay_lr else learning_rate |
|
for param_group in optimizer.param_groups: |
|
param_group['lr'] = lr |
|
|
|
if iter_num % eval_interval == 0 and master_process: |
|
losses = estimate_loss() |
|
print(f"step {iter_num}: train loss {losses['train']:.4f}, val loss {losses['val']:.4f}") |
|
|
|
if losses['val'] < best_val_loss or always_save_checkpoint: |
|
best_val_loss = losses['val'] |
|
if iter_num > 0: |
|
checkpoint = { |
|
'model': raw_model.state_dict(), |
|
'optimizer': optimizer.state_dict(), |
|
'model_args': model_args, |
|
'iter_num': iter_num, |
|
'best_val_loss': best_val_loss, |
|
'config': config, |
|
} |
|
print("saving checkpoint") |
|
torch.save(checkpoint, 'ckpt.pt') |
|
if iter_num == 0 and eval_only: |
|
break |
|
for micro_step in range(gradient_accumulation_steps): |
|
with ctx: |
|
logits, loss = model(X, Y) |
|
loss = loss / gradient_accumulation_steps |
|
X, Y = get_batch('train') |
|
scaler.scale(loss).backward() |
|
if grad_clip != 0.0: |
|
scaler.unscale_(optimizer) |
|
torch.nn.utils.clip_grad_norm_(model.parameters(), grad_clip) |
|
scaler.step(optimizer) |
|
scaler.update() |
|
optimizer.zero_grad(set_to_none=True) |
|
t1 = time.time() |
|
dt = t1 - t0 |
|
t0 = t1 |
|
if iter_num % log_interval == 0 and master_process: |
|
lossf = loss.item() * gradient_accumulation_steps |
|
if local_iter_num >= 5: |
|
mfu = raw_model.estimate_mfu(batch_size * gradient_accumulation_steps, dt) |
|
running_mfu = mfu if running_mfu == -1.0 else 0.9*running_mfu + 0.1*mfu |
|
print(f"iter {iter_num}: loss {lossf:.4f}, time {dt*1000:.2f}ms, mfu {running_mfu*100:.2f}%") |
|
iter_num += 1 |
|
local_iter_num += 1 |
|
if iter_num > max_iters: |
|
break |
|
|
|
start = "\n" |
|
max_new_tokens = 512 |
|
top_k = 100 |
|
start_ids = encode(start) |
|
x = (torch.tensor(start_ids, dtype=torch.long, device=device)[None, ...]) |
|
gen_smiles = [] |
|
with torch.no_grad(): |
|
with ctx: |
|
while len(gen_smiles) < num_samples: |
|
y = model.generate(x, max_new_tokens, temperature=temperature, top_k=top_k) |
|
smiles = decode(y[0].tolist()).replace('\n', '') |
|
mol = Chem.MolFromSmiles(smiles) |
|
if mol: |
|
smiles = Chem.MolToSmiles(mol) |
|
if (smiles not in gen_smiles) and (smiles not in data): |
|
gen_smiles.append(smiles) |
|
|
|
print(gen_smiles) |
|
smiles_df = pd.DataFrame(gen_smiles, columns=['smiles']) |
|
st.table(smiles_df) |
|
csv_data = smiles_df.to_csv(index=False) |
|
st.download_button(label="Download CSV", data=csv_data, file_name="generated_smiles.csv", mime="text/csv") |
|
st.image(Draw.MolToImage(Chem.MolFromSmiles(gen_smiles[0]), size=(600, 600)), caption='First Generated Molecule', use_column_width=True) |
|
|
|
|