“`html
Ajuste Fino do Unimol: Guia Prático para Melhor Compreensão Molecular
Como engenheiro de ML, eu vi em primeira mão o poder dos modelos pré-treinados. Na descoberta de medicamentos e ciência dos materiais, a modelagem molecular é crítica. Unimol, um poderoso modelo de representação molecular pré-treinado, oferece um avanço significativo. No entanto, seu verdadeiro potencial é liberado através do ajuste fino. Este artigo fornece um guia prático e acionável para o ajuste fino do unimol, ajudando você a usar essa tecnologia para suas tarefas moleculares específicas.
O que é Unimol e Por que Ajustá-lo?
Unimol significa representação MOLecular UNIversal. É um modelo de aprendizado profundo treinado em um grande conjunto de dados de estruturas e propriedades moleculares. Esse pré-treinamento permite que o Unimol aprenda características e relações generalizáveis dentro das moléculas, tornando-o excelente em capturar a intuição química.
Embora os pesos pré-treinados do Unimol sejam bons, eles são genéricos. Sua tarefa específica – prever afinidade de ligação, solubilidade ou resultados de reações – tem nuances únicas. O ajuste fino adapta essas representações gerais do Unimol ao seu domínio e conjunto de dados específicos. Esse processo refina a compreensão do modelo, levando a um desempenho preditivo significativamente melhor em comparação ao uso do Unimol como um extrator de características fixo ou ao treinamento de um modelo do zero. O ajuste fino do unimol é sobre especialização.
Pré-requisitos para o Ajuste Fino do Unimol
Antes de explorar o código, certifique-se de que você tem o seguinte:
* **Uma tarefa bem definida:** O que exatamente você está tentando 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 strings SMILES, gráficos moleculares ou coordenadas 3D, junto com os valores-alvo correspondentes (por exemplo, medições experimentais, rótulos).
* **Recursos computacionais:** O ajuste fino de grandes modelos como o 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 o Unimol. Uma compreensão básica de carregamento de dados, definição de modelos e loops de treinamento é útil.
* **Biblioteca Unimol:** Você precisará instalar a biblioteca Unimol e suas dependências. Isso geralmente envolve `pip install unimol`.
Preparando Seus Dados Moleculares para o Ajuste Fino
A preparação de dados é frequentemente a parte mais demorada de qualquer projeto de aprendizado de máquina. Para o ajuste fino do unimol, envolve várias etapas:
1. Coleta e Limpeza de Dados
Reúna seus dados experimentais ou simulados. Garanta consistência nas unidades, remova outliers e trate valores ausentes de maneira apropriada. Para estruturas moleculares, valide strings SMILES ou assegure que as coordenadas 3D sejam quimicamente sensatas.
2. Representação Molecular
O Unimol usa principalmente representações gráficas moleculares 3D. Embora você possa frequentemente gerar coordenadas 3D a partir de SMILES, usar estruturas 3D experimentais ou otimizadas de alta qualidade (por exemplo, do PDB, PubChem 3D) é geralmente melhor. A biblioteca Unimol fornece utilitários para converter diversos formatos moleculares em sua representação interna.
* **SMILES para 3D:** Use RDKit ou bibliotecas semelhantes para gerar conformers. Em seguida, otimize esses conformers usando um campo de força (por exemplo, MMFF94, UFF) para estruturas mais estáveis.
* **Manipulando múltiplos conformers:** Para moléculas flexíveis, você pode ter múltiplos conformers de baixa energia. Decida se deve usar um único conformer representativo (por exemplo, o de menor energia) ou incorporar informações de múltiplos conformers (por exemplo, fazendo uma média das previsões ou usando um conjunto de conformers).
3. Divisão do Conjunto de Dados
Divida seus dados em conjuntos de treinamento, validação e teste. Uma divisão comum é 80/10/10 ou 70/15/15. Certifique-se de que suas divisões sejam representativas da distribuição geral dos dados. Para dados moleculares, considere a divisão estratificada se você tiver classes ou propriedades desequilibradas. A divisão por scaffold 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. Criando um Conjunto de Dados PyTorch e DataLoader
A biblioteca Unimol espera dados em um formato específico. Você normalmente criará um `Dataset` personalizado do PyTorch que carrega suas estruturas moleculares e valores-alvo. O método `__getitem__` do seu conjunto de dados deve retornar os dados do gráfico molecular (geralmente como um dicionário contendo recursos de nó, recursos de aresta e informações de adjacência) e 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 mol do RDKit para o formato de gráfico esperado da Unimol
# Esta parte depende fortemente das utilidades específicas da biblioteca Unimol.
# Geralmente envolve a extração de características de átomos, características de ligações e coordenadas 3D.
unimol_graph_data = self._mol_to_unimol_format(mol) # Função de espaço reservado
return unimol_graph_data, torch.tensor(target, dtype=torch.float)
def _mol_to_unimol_format(self, mol):
# Espaço reservado: Implementar a conversão real usando as utilidades unimol.data
# Isso envolverá a extração de características de nós (tipos de átomos, cargas),
# características de arestas (tipos de ligações) 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 agrupar tamanhos de gráficos variados.
# A biblioteca Unimol geralmente fornece um collate_fn padrão ou espera um formato de entrada específico.
“`
Configurando o Modelo Unimol para Fine-Tuning
O núcleo do fine-tuning do unimol envolve o carregamento do modelo Unimol pré-treinado e a anexação de uma nova “cabeça” apropriada para a sua tarefa.
1. Carregando o 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 objeto de configuração similar
# Carregar configuração pré-treinada (ajuste o caminho se necessário)
config = UnimolConfig.from_pretrained(“path/to/unimol_base_config.json”)
# Carregar 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 de exemplo
config=config
)
unimol_encoder.eval() # Defina para o modo de avaliação se não estiver treinando as camadas do codificador inicialmente
“`
2. Anexando uma Cabeça Específica para a Tarefa
A saída do codificador Unimol é uma representação molecular (por exemplo, um vetor de tamanho fixo ou incorporações em nível de nó). Você precisa adicionar uma pequena rede neural em cima dessa representação para realizar sua previsão específica.
* **Regressão:** Para prever valores contínuos (por exemplo, afinidade de ligação), uma camada linear simples ou um pequeno MLP (Perceptron Multicamadas) é comum.
* **Classificação:** Para prever classes discretas (por exemplo, ativo/inativo), use uma camada linear seguida por uma ativação sigmoidal (para binário) ou softmax (para múltiplas classes).
“`python
import torch.nn as nn
class UnimolFineTuneModel(nn.Module):
def __init__(self, unimol_encoder, num_output_features, task_type=”regression”):
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 # Acesso exemplo
se 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 regressão de valor único
)
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 agrupada.
# A chave exata para a representação agrupada 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”]
# Adicione outras entradas necessárias de acordo com o método forward do UnimolModel
)
# Assumindo que ‘mol_embedding’ é a representação agrupada para toda a 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 Ajuste Fino do Unimol
Agora, combine seus dados e modelo para treinamento.
1. Defina a Função de Perda e o Otimizador
* **Regressão:** Erro Médio Quadrático (MSE) ou Erro Absoluto Médio (MAE) são comuns.
* **Classificação:** Entropia Cruzada Binária (BCE) para classificação binária, Entropia Cruzada para múltiplas classes.
* **Otimizador:** AdamW é um bom padrão, geralmente com um agendador de taxa de aprendizado.
“`python
optimizer = torch.optim.AdamW(fine_tuned_model.parameters(), lr=1e-5) # Começar com uma taxa de aprendizado pequena
criterion = nn.MSELoss() # Para regressão
“`
2. Congelando Camadas (Opcional, mas Recomendado)
Inicialmente, muitas vezes é benéfico congelar as camadas do codificador Unimol pré-treinado e treinar apenas a nova cabeça de previsão adicionada. Isso evita que grandes atualizações de gradiente corrompam os pesos valiosos pré-treinados. Após algumas épocas, você pode descongelar 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
# Somente os parâmetros em prediction_head serão atualizados
# Você descongelaria mais tarde:
# for param in fine_tuned_model.unimol_encoder.parameters():
# param.requires_grad = True
“`
3. Loop de Treinamento
O loop de treinamento segue práticas padrão do PyTorch. Itere através das épocas, processe lotes, calcule a perda, retropropague 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):
# Mova os dados para o dispositivo
# unimol_graph_data_batch precisa ser processado para mover seus tensores para o dispositivo
# Exemplo: batch_coords = unimol_graph_data_batch[“coords”].to(device)
# batch_atom_features = unimol_graph_data_batch[“atom_features”].to(device)
# …
# Isso requer uma função collate_fn adequada em seu DataLoader.
# Simplificado para ilustração, assumindo que unimol_graph_data_batch já foi movido
# ou lidar com a mudança dentro do loop para cada tensor no dicionário.
# Mova tensores individuais dentro do dicionário para o dispositivo
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 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 (implementar de forma semelhante)
fine_tuned_model.eval()
val_loss = 0
com torch.no_grad():
for batch_idx, (unimol_graph_data_batch, targets_batch) in enumerate(val_loader):
# Mover dados para o dispositivo
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 com base 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 agendador de taxa de aprendizado (por exemplo, resfriamento cosseno, ReduceLROnPlateau) costuma ser útil.
* **Tamanho do Lote:** Limitado pela memória da GPU. Tamanhos de lote maiores podem oferecer gradientes mais estáveis, mas exigem mais memória.
* **Número de Épocas:** Monitore a perda de validação para evitar overfitting. O interrompimento antecipado é importante.
* **Dropout:** Aplique dropout na cabeça de previsão para regularização.
* **Decaimento de Peso:** Adicione regularização L2 ao otimizador.
Avaliação e Implantação
Após o ajuste fino do unimol, avalie seu modelo no conjunto de teste não visto usando métricas apropriadas:
* **Regressão:** R-quadrado, MAE, RMSE.
* **Classificação:** Acurácia, Precisão, Recall, F1-score, ROC-AUC.
Uma vez satisfeito com o desempenho, salve seu modelo ajustado. 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=”regressão”)
loaded_model.load_state_dict(torch.load(“fine_tuned_unimol_model.pt”))
loaded_model.to(device)
loaded_model.eval()
# Inferência de exemplo
com 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 Ajuste Fino bem-sucedido do Unimol
* **Comece Simples:** Comece com uma taxa de aprendizado baixa e um codificador congelado. Gradualmente descongele camadas e aumente a taxa de aprendizado à medida que o modelo se estabiliza.
* **Monitore as Métricas:** Fique de olho próximo tanto na perda/métricas de treinamento quanto de validação. Procure sinais de overfitting (perda de treinamento diminuindo, perda de validação aumentando).
* **Aumento de Dados:** Para dados moleculares, isso pode envolver a geração de diferentes conformadores, rotacionar moléculas ou aplicar pequenas perturbações. Isso ajuda o modelo a aprender representações mais sólidas.
* **Estratégias de Transferência de Aprendizado:**
* **Extração de Características:** Use Unimol para gerar embeddings, em seguida, treine um modelo separado mais simples (por exemplo, SVM, XGBoost) nesses embeddings. Isso costuma ser uma boa referência.
* **Ajuste Fino 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 computacionais e ajuste cuidadoso.
* **Ajuste Fino por Camadas:** Descongele e treine primeiro as camadas externas, depois descongele gradualmente as camadas internas.
* **Experimente com Arquiteturas:** Enquanto uma cabeça linear simples é um bom ponto de partida, experimente MLPs um pouco mais complexos para a cabeça de previsão.
* **Use as Utilidades do Unimol:** A biblioteca Unimol oferece várias ferramentas para processamento de dados, construção de gráficos e carregamento de modelos. Familiarize-se com sua API para agilizar seu fluxo de trabalho.
* **Pré-computação:** Se a geração de conformadores 3D for lenta, considere pré-gerá-los e salvá-los em disco antes do treinamento.
O ajuste fino do Unimol é uma abordagem poderosa para adaptar representações moleculares de última geração às suas tarefas específicas. Ao seguir estas etapas práticas, você pode alcançar melhores modelos preditivos em descobertas de medicamentos, ciência de materiais e outros domínios moleculares.
Perguntas Frequentes sobre Ajuste Fino do Unimol
**Q1: Quanta informação eu preciso para o ajuste fino do unimol?**
A1: Quanto mais, melhor. Embora o pré-treinamento do Unimol ajude com a escassez de dados, o ajuste fino ainda se beneficia significativamente de conjuntos de dados maiores e diversos. 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 o seu conjunto de dados for muito pequeno (dezenas de amostras), considere usar o Unimol como um extrator de características fixo em vez de ajustar todo o modelo.
**Q2: Qual é a diferença entre usar o Unimol como um extrator de características e o ajuste fino completo?**
A2: Como extrator de características, você usa o modelo pré-treinado do Unimol para gerar embeddings moleculares (vetores de tamanho fixo) para suas moléculas. Você então treina um modelo separado e mais simples (como uma regressão linear, SVM ou um pequeno MLP) com esses embeddings. Os pesos do Unimol permanecem fixos. No ajuste fino completo, você carrega o modelo pré-treinado do Unimol e, em seguida, continua a treinar suas camadas (junto com uma nova cabeça específica da tarefa) no seu conjunto de dados. O ajuste fino completo geralmente proporciona melhor desempenho se você tiver dados e recursos computacionais suficientes, pois adapta as representações internas do Unimol à sua tarefa específica.
**Q3: Como lido com estruturas moleculares 3D para o Unimol?**
A3: O Unimol é projetado para usar informações de grafos moleculares 3D. Se você tiver apenas strings SMILES, precisará gerar conformadores 3D. Ferramentas como o RDKit podem fazer isso (por exemplo, `Chem.AllChem.EmbedMolecule`). É recomendado, então, otimizar esses conformadores usando um campo de força (por exemplo, `AllChem.MMFFOptimizeMolecule`) para obter estruturas quimicamente mais plausíveis. Para tarefas críticas, usar estruturas 3D determinadas experimentalmente (de bancos de dados como o PDB) ou estruturas otimizadas por química quântica de alto nível é preferível. A biblioteca Unimol, então, utilizará essas coordenadas 3D, junto com características de átomos e ligações, para construir sua representação gráfica interna.
🕒 Published: