“`html
Unimol Fine-Tuning : Guia Prático para uma Melhor Compreensão Molecular
Como engenheiro em ML, eu vi com meus próprios olhos o poder dos modelos pré-treinados. Na descoberta de medicamentos e na ciência dos materiais, a modelagem molecular é essencial. Unimol, um poderoso modelo de representação molecular pré-treinado, oferece um avanço significativo. No entanto, seu verdadeiro potencial se revela através do fine-tuning. Este artigo propõe um guia prático e concreto sobre o fine-tuning de unimol, ajudando você a usar essa tecnologia para suas tarefas moleculares específicas.
O que é Unimol e por que o Fine-Tuner?
Unimol significa UNIversal MOLecular representation. É um modelo de aprendizado profundo treinado em um vasto conjunto de dados de estruturas e propriedades moleculares. Esse pré-treinamento permite que Unimol aprenda características e relações generalizáveis dentro das moléculas, tornando-o excelente para capturar a intuição química.
Embora os pesos pré-treinados de Unimol sejam de boa qualidade, eles são genéricos. Sua tarefa específica – prever a afinidade de ligação, a solubilidade ou os resultados de reações – apresenta nuances únicas. O fine-tuning adapta essas representações gerais de Unimol ao seu domínio e conjunto de dados específicos. Este processo aprimora a compreensão do modelo, levando a um desempenho preditivo significativamente melhor em comparação ao uso de Unimol como um extrator de características fixo ou ao treinamento de um modelo do zero. O fine-tuning de unimol diz respeito à especialização.
Pré-requisitos para o Fine-Tuning de Unimol
Antes de explorar o código, certifique-se de ter o seguinte:
* **Uma tarefa bem definida:** O que você exatamente está buscando prever ou classificar? Objetivos claros são cruciais.
* **Um conjunto de dados de alta qualidade:** Isso é primordial. Seu conjunto de dados deve ser relevante para sua tarefa, limpo e suficientemente grande. Para tarefas moleculares, isso significa cadeias SMILES, grafos moleculares ou coordenadas 3D, acompanhados dos valores-alvo correspondentes (por exemplo, medidas experimentais, rótulos).
* **Recursos computacionais:** O fine-tuning de modelos volumosos como Unimol requer GPUs. Os requisitos específicos dependem do tamanho do seu conjunto de dados e da arquitetura do modelo, mas espere precisar de pelo menos uma GPU moderna (por exemplo, NVIDIA V100, A100).
* **Familiaridade com frameworks de aprendizado profundo:** PyTorch é comumente usado para Unimol. Uma compreensão básica do carregamento de dados, definição do modelo e loops de treinamento é útil.
* **Biblioteca Unimol:** Você precisará instalar a biblioteca Unimol e suas dependências. Isso geralmente envolve `pip install unimol`.
Preparação dos Seus Dados Moleculares para o Fine-Tuning
A preparação dos dados é muitas vezes a parte mais demorada de qualquer projeto de aprendizado de máquina. Para o fine-tuning de unimol, isso envolve várias etapas:
1. Coleta e Limpeza de Dados
Reúna seus dados experimentais ou simulados. Assegure a consistência das unidades, remova valores aberrantes e trate os valores ausentes de forma apropriada. Para as estruturas moleculares, valide as cadeias SMILES ou assegure-se de que as coordenadas 3D sejam quimicamente sensatas.
2. Representação Molecular
Unimol utiliza principalmente representações de grafos moleculares em 3D. Embora você possa frequentemente gerar coordenadas 3D a partir de SMILES, geralmente é melhor usar estruturas experimentais ou otimizadas de alta qualidade (por exemplo, provenientes do PDB, PubChem 3D). A biblioteca Unimol fornece utilitários para converter diversos formatos moleculares em sua representação interna.
* **SMILES para 3D:** Utilize RDKit ou bibliotecas semelhantes para gerar conformeres. Em seguida, otimize esses conformeres com o auxílio de um campo de força (por exemplo, MMFF94, UFF) para obter estruturas mais estáveis.
* **Gerenciamento de múltiplos conformeres:** Para moléculas flexíveis, você pode ter múltiplos conformeres de baixa energia. Decida usar um conformere representativo único (por exemplo, o de menor energia) ou incorporar informações de vários conformeres (por exemplo, fazendo a média das previsões ou usando um conjunto de conformeres).
3. Divisão do Conjunto de Dados
“““html
Divida seus dados em conjuntos de treinamento, validação e teste. Uma divisão comum é de 80/10/10 ou 70/15/15. Certifique-se de que suas divisões representem bem a distribuição geral dos dados. Para dados moleculares, considere uma divisão estratificada se você tiver classes ou propriedades desequilibradas. A divisão por scaffolding também pode ser importante para garantir que o modelo generalize para um novo espaço químico, não apenas para novos exemplos de scaffolds existentes.
4. Criação de um Dataset PyTorch e DataLoader
A biblioteca Unimol espera dados em um formato específico. Você normalmente criará um `Dataset` PyTorch personalizado que carrega suas estruturas moleculares e valores alvo. O método `__getitem__` do seu dataset deve retornar os dados de grafos moleculares (geralmente na forma de um dicionário contendo características de nós, características de ligações e informações de adjacência) juntamente com o rótulo/valor correspondente.
“`python
import torch
from torch.utils.data import Dataset, DataLoader
from unimol.data import MoleculeDataset # Exemplo, a classe real pode variar
from rdkit import Chem
from rdkit.Chem import AllChem
class CustomMolDataset(Dataset):
def __init__(self, smiles_list, targets_list):
self.smiles_list = smiles_list
self.targets_list = targets_list
def __len__(self):
return len(self.smiles_list)
def __getitem__(self, idx):
smiles = self.smiles_list[idx]
target = self.targets_list[idx]
# Gerar coordenadas 3D (simplificado para ilustração)
mol = Chem.MolFromSmiles(smiles)
if mol:
mol = Chem.AddHs(mol)
AllChem.EmbedMolecule(mol, AllChem.ETKDG())
AllChem.MMFFOptimizeMolecule(mol)
# Converter o mol RDKit para o formato de grafo esperado pela Unimol
# Esta parte depende fortemente das utilidades específicas da biblioteca Unimol.
# Geralmente envolve a extração de características atômicas, características de ligação e coordenadas 3D.
unimol_graph_data = self._mol_to_unimol_format(mol) # Função de substituição
return unimol_graph_data, torch.tensor(target, dtype=torch.float)
def _mol_to_unimol_format(self, mol):
# Substituição: Implemente a conversão real usando as utilidades de unimol.data
# Isso envolverá extrair características de nós (tipos de átomos, cargas),
# características de ligação (tipos de ligação) e coordenadas 3D.
# unimol.data.data_utils.get_graph_from_mol é um candidato provável.
return {“coords”: torch.rand(mol.GetNumAtoms(), 3), # Exemplo
“atom_features”: torch.rand(mol.GetNumAtoms(), 10), # Exemplo
“bond_features”: torch.rand(mol.GetNumBonds(), 5), # Exemplo
“edges”: torch.randint(0, mol.GetNumAtoms(), (mol.GetNumBonds(), 2))} # Exemplo
# Exemplo de uso (substitua pelos seus dados reais)
smiles_data = [“CCO”, “CC(=O)O”, “c1ccccc1”]
target_data = [1.2, 3.4, 5.6]
train_dataset = CustomMolDataset(smiles_data, target_data)
train_loader = DataLoader(train_dataset, batch_size=4, shuffle=True)
# Você também precisará de um collate_fn para o processamento de tamanhos de grafos variados.
# A biblioteca Unimol geralmente fornece um collate_fn padrão ou espera um formato de entrada específico.
“`
Configurar o Modelo Unimol para Fine-Tuning
O cerne do fine-tuning do unimol envolve o carregamento do modelo Unimol pré-treinado e a anexação de uma nova “cabeça” apropriada para sua tarefa.
1. Carregamento do Codificador Unimol Pré-treinado
A biblioteca Unimol fornece funções para carregar os pesos pré-treinados. Esses pesos representam o codificador molecular.
“`python
from unimol.models import UnimolModel
from unimol.config import UnimolConfig # Ou um objeto de configuração similar
# Carregar a configuração pré-treinada (ajuste o caminho se necessário)
config = UnimolConfig.from_pretrained(“path/to/unimol_base_config.json”)
# Carregar o modelo Unimol pré-treinado
# Você pode precisar especificar o caminho para os pesos pré-treinados reais (.pt ou .bin)
unimol_encoder = UnimolModel.from_pretrained(
“path/to/unimol_base_weights.pt”, # Caminho exemplo
config=config
)
unimol_encoder.eval() # Colocar em modo avaliação se você não estiver inicialmente treinando as camadas do codificador
“`
“““html
2. Anexar uma Cabeça Específica à Tarefa
A saída do codificador Unimol é uma representação molecular (por exemplo, um vetor de tamanho fixo ou embeddings em nível de nó). Você deve adicionar uma pequena rede de neurônios acima dessa representação para realizar sua previsão específica.
* **Regressão:** Para prever valores contínuos (por exemplo, a afinidade de ligação), uma simples camada linear ou um pequeno MLP (Perceptron Multi-Camadas) é comum.
* **Classificação:** Para prever classes discretas (por exemplo, ativo/inativo), utilize uma camada linear seguida de uma ativação sigmoide (para binário) ou softmax (para multi-classe).
“`python
import torch.nn as nn
class UnimolFineTuneModel(nn.Module):
def __init__(self, unimol_encoder, num_output_features, task_type=”regressão”):
super().__init__()
self.unimol_encoder = unimol_encoder
self.task_type = task_type
# A dimensão de saída do codificador Unimol depende de sua configuração.
# Geralmente é referida como `hidden_size` ou `embedding_dim`.
encoder_output_dim = self.unimol_encoder.args.encoder_embed_dim # Exemplo de acesso
if task_type == “regressão”:
self.prediction_head = nn.Sequential(
nn.Linear(encoder_output_dim, 256),
nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(256, num_output_features) # num_output_features é 1 para a regressão de um único valor
)
elif task_type == “classificação”:
self.prediction_head = nn.Sequential(
nn.Linear(encoder_output_dim, 256),
nn.ReLU(),
nn.Dropout(0.3),
nn.Linear(256, num_output_features) # num_output_features é o número de classes
)
else:
raise ValueError(“Tipo de tarefa não suportado”)
def forward(self, unimol_graph_data):
# O codificador Unimol geralmente retorna um dicionário. Precisamos da representação agregada.
# A chave exata para a representação agregada pode variar (por exemplo, ‘mol_embedding’, ‘graph_embedding’).
encoder_output = self.unimol_encoder(
coords=unimol_graph_data[“coords”],
atom_features=unimol_graph_data[“atom_features”],
bond_features=unimol_graph_data[“bond_features”],
edges=unimol_graph_data[“edges”]
# Adicionar outras entradas necessárias conforme o método forward de UnimolModel
)
# Presumindo que ‘mol_embedding’ é a representação agregada para o conjunto da molécula
pooled_representation = encoder_output[‘mol_embedding’]
prediction = self.prediction_head(pooled_representation)
return prediction
# Instanciar o modelo ajustado
fine_tuned_model = UnimolFineTuneModel(unimol_encoder, num_output_features=1, task_type=”regressão”)
“`
O processo de fine-tuning do Unimol
Agora, combine seus dados e seu modelo para o treinamento.
1. Definir a função de perda e o otimizador
* **Regressão:** O erro quadrático médio (MSE) ou o erro absoluto médio (MAE) são comuns.
* **Classificação:** A perda de entropia cruzada binária (BCE) para classificação binária, a entropia cruzada para classificação multi-classe.
* **Otimizador:** AdamW é uma boa escolha padrão, frequentemente com um planejador de taxa de aprendizado.
“`python
optimizer = torch.optim.AdamW(fine_tuned_model.parameters(), lr=1e-5) # Começar com uma baixa taxa de aprendizado
criterion = nn.MSELoss() # Para a regressão
“`
2. Congelamento das camadas (opcional, mas recomendado)
No início, muitas vezes é benéfico congelar as camadas do codificador Unimol pré-treinado e treinar apenas a cabeça de previsão recém-adicionada. Isso impede que grandes atualizações de gradiente corrompam os pesos pré-treinados valiosos. Após algumas épocas, você pode desbloquear algumas ou todas as camadas do codificador e treinar com uma taxa de aprendizado muito baixa.
“`python
# Para congelar os parâmetros do unimol_encoder
for param in fine_tuned_model.unimol_encoder.parameters():
param.requires_grad = False
# Apenas os parâmetros na prediction_head serão atualizados
# Você desbloqueará mais tarde :
# for param in fine_tuned_model.unimol_encoder.parameters():
# param.requires_grad = True
“`
3. Loop de treinamento
“`
O loop de treinamento segue as práticas padrão do PyTorch. Itere sobre as épocas, processe os lotes, calcule a perda, faça a retropropagação e atualize os pesos.
“`python
device = torch.device(“cuda” if torch.cuda.is_available() else “cpu”)
fine_tuned_model.to(device)
num_epochs = 10
for epoch in range(num_epochs):
fine_tuned_model.train()
total_loss = 0
for batch_idx, (unimol_graph_data_batch, targets_batch) in enumerate(train_loader):
# Mover os dados para o device
# unimol_graph_data_batch deve ser processado para mover seus tensores para o device
# Exemplo : batch_coords = unimol_graph_data_batch[“coords”].to(device)
# batch_atom_features = unimol_graph_data_batch[“atom_features”].to(device)
# …
# Isso requer um collate_fn apropriado no seu DataLoader.
# Simplificado para ilustração, assumindo que unimol_graph_data_batch já foi movido
# ou gerenciar o movimento no loop para cada tensor no dicionário.
# Mover os tensores individuais no dicionário para o device
processed_graph_data = {k: v.to(device) for k, v in unimol_graph_data_batch.items()}
targets_batch = targets_batch.to(device)
optimizer.zero_grad()
predictions = fine_tuned_model(processed_graph_data)
loss = criterion(predictions.squeeze(), targets_batch) # .squeeze() para a regressão de valor único
loss.backward()
optimizer.step()
total_loss += loss.item()
avg_train_loss = total_loss / len(train_loader)
print(f”Época {epoch+1}, Perda de treinamento : {avg_train_loss:.4f}”)
# Etapa de validação (implemente de maneira semelhante)
fine_tuned_model.eval()
val_loss = 0
with torch.no_grad():
for batch_idx, (unimol_graph_data_batch, targets_batch) in enumerate(val_loader):
# Mover os dados para o device
processed_graph_data = {k: v.to(device) for k, v in unimol_graph_data_batch.items()}
targets_batch = targets_batch.to(device)
predictions = fine_tuned_model(processed_graph_data)
loss = criterion(predictions.squeeze(), targets_batch)
val_loss += loss.item()
avg_val_loss = val_loss / len(val_loader)
print(f”Época {epoch+1}, Perda de validação : {avg_val_loss:.4f}”)
# Salvar o melhor modelo baseado na perda de validação
# …
“`
4. Ajuste de hiperparâmetros
* **Taxa de aprendizado :** Crucial. Experimente valores como 1e-4, 5e-5, 1e-5, 5e-6. Um planejador de taxa de aprendizado (por exemplo, resfriamento cosseno, ReduceLROnPlateau) é frequentemente útil.
* **Tamanho do lote :** Limitado pela memória GPU. Tamanhos de lote maiores podem fornecer gradientes mais estáveis, mas requerem mais memória.
* **Número de épocas :** Monitore a perda de validação para evitar overfitting. O early stopping é importante.
* **Dropout :** Aplique o dropout na cabeça de predição para regularizar.
* **Regularização de pesos :** Adicione regularização L2 ao otimizador.
Avaliação e Implantação
Após o fine-tuning do unimol, avalie seu modelo no conjunto de teste não visto usando métricas apropriadas :
* **Regressão :** R-quadrado, MAE, RMSE.
* **Classificação :** Precisão, Precisão, Recall, F1-score, ROC-AUC.
Uma vez satisfeito com o desempenho, salve seu modelo afinado. Para implantação, você pode carregar o modelo salvo e usá-lo para inferência em novos dados moleculares.
“`python
# Salvar o modelo
torch.save(fine_tuned_model.state_dict(), “fine_tuned_unimol_model.pt”)
# Carregar para inferência
loaded_model = UnimolFineTuneModel(unimol_encoder, num_output_features=1, task_type=”regression”)
loaded_model.load_state_dict(torch.load(“fine_tuned_unimol_model.pt”))
loaded_model.to(device)
loaded_model.eval()
# Exemplo de inferência
with torch.no_grad():
sample_mol_data = … # Preparar novos dados moleculares
processed_sample_mol_data = {k: v.to(device) for k, v in sample_mol_data.items()}
prediction = loaded_model(processed_sample_mol_data)
print(“Predição :”, prediction.item())
“`
Dicas para um fine-tuning bem-sucedido de Unimol
* **Comece simplesmente:** Comece com uma baixa taxa de aprendizado e um codificador congelado. Desbloqueie progressivamente as camadas e aumente a taxa de aprendizado à medida que o modelo se estabiliza.
* **Monitore as métricas:** Fique de olho nas perdas/métricas de treinamento e validação. Procure sinais de sobreajuste (a perda de treinamento diminui, a perda de validação aumenta).
* **Aumento de dados:** Para dados moleculares, isso pode envolver gerar diferentes conformeres, girar moléculas ou aplicar pequenas perturbações. Isso ajuda o modelo a aprender representações mais robustas.
* **Estratégias de aprendizado de transferência:**
* **Extração de características:** Use Unimol para gerar embeddings e, em seguida, treine um modelo separado mais simples (por exemplo, SVM, XGBoost) nessas embeddings. Isso geralmente serve como uma boa referência.
* **Fine-tuning completo:** Treine todo o modelo Unimol (codificador + cabeça) com uma taxa de aprendizado muito baixa. Isso oferece o maior potencial de desempenho, mas requer mais recursos de computação e um ajuste cuidadoso.
* **Fine-tuning camada por camada:** Desbloqueie e treine primeiro as camadas externas, em seguida, desbloqueie progressivamente as camadas internas.
* **Experimente com as arquiteturas:** Embora uma cabeça linear simples seja um bom ponto de partida, experimente MLPs ligeiramente mais complexos para a cabeça de predição.
* **Use as utilidades do Unimol:** A biblioteca Unimol fornece várias ferramentas para processamento de dados, construção de grafos e carregamento de modelos. Familiarize-se com sua API para otimizar seu fluxo de trabalho.
* **Pré-cálculo:** Se a geração de conformeres 3D for lenta, considere gerá-los e salvá-los em disco antes do treinamento.
O fine-tuning do Unimol é uma abordagem poderosa para adaptar representações moleculares de ponta às suas tarefas específicas. Seguindo estas etapas práticas, você pode obter melhores modelos preditivos na descoberta de medicamentos, ciência dos materiais e outros campos moleculares.
FAQ sobre o fine-tuning do Unimol
**Q1: Quantos dados eu preciso para o fine-tuning do Unimol?**
A1: Quanto mais, melhor. Embora o pré-treinamento do Unimol ajude em casos de escassez de dados, o fine-tuning ainda se beneficia bastante de conjuntos de dados maiores e diversificados. Para tarefas de regressão, centenas a milhares de pontos de dados são frequentemente um bom ponto de partida. Para classificação, especialmente com várias classes, mais dados geralmente são necessários para aprender fronteiras de decisão distintas. Se seu conjunto de dados for muito pequeno (diz dezenas de amostras), considere usar o Unimol como um extrator de características fixo em vez de fazer um fine-tuning de todo o modelo.
**Q2: Qual é a diferença entre usar o Unimol como extrator de características e o fine-tuning completo?**
A2: Como extrator de características, você usa o modelo Unimol pré-treinado para gerar embeddings moleculares (vetores de tamanho fixo) para suas moléculas. Em seguida, você treina um modelo separado, mais simples (como uma regressão linear, um SVM ou um pequeno MLP) nessas embeddings. Os pesos do Unimol permanecem fixos. Durante o fine-tuning completo, você carrega o modelo Unimol pré-treinado e continua a treinar suas camadas (com uma nova cabeça específica para a tarefa) em seu conjunto de dados. O fine-tuning completo geralmente fornece um desempenho melhor se você tiver dados e recursos de computação suficientes, pois adapta as representações internas do Unimol à sua tarefa específica.
**Q3 : Como gerenciar estruturas moleculares 3D para Unimol?**
A3 : Unimol é projetado para utilizar informações de grafos moleculares 3D. Se você tiver apenas cadeias SMILES, precisará gerar conformeres 3D. Ferramentas como RDKit podem fazer isso (por exemplo, `Chem.AllChem.EmbedMolecule`). Recomenda-se, em seguida, otimizar esses conformeres usando um campo de força (por exemplo, `AllChem.MMFFOptimizeMolecule`) para obter estruturas mais quimicamente plausíveis. Para tarefas críticas, é preferível usar estruturas 3D determinadas experimentalmente (provenientes de bancos de dados como PDB) ou estruturas otimizadas por química quântica de alto nível. A biblioteca Unimol usará então essas coordenadas 3D, assim como as características dos átomos e das ligações, para construir sua representação gráfica interna.
🕒 Published: