Mastering DeepChem

Olá, daqui é o Alex da DEV STORIES DOT EU. Dominar o DeepChem, episódio 1 de 15. Queres aplicar machine learning a um problema científico, então recorres a ferramentas standard, mas essas ferramentas tratam moléculas e proteínas como arrays de dados planos, ignorando completamente a física subjacente. A ferramenta que preenche esta lacuna é o projeto DeepChem. As pessoas costumam assumir que o DeepChem é um tensor engine standalone, algo que usas em vez do PyTorch, TensorFlow ou JAX. Isso está incorreto. O DeepChem é um toolset específico para o domínio, construído diretamente sobre essas frameworks genéricas. Atua como um tradutor. Trata da engenharia complexa necessária para transformar dados físicos desorganizados num formato que uma neural network standard consiga processar. O projeto existe para democratizar o deep learning para a ciência. Quando começou, o foco era estritamente na química. O objetivo inicial era tornar a descoberta de fármacos acessível, dando aos investigadores as ferramentas para prever propriedades químicas sem precisarem de um enorme laboratório proprietário. Mas, à medida que a área cresceu, a framework também. Hoje, o DeepChem evoluiu discretamente para um hub central para praticamente qualquer aplicação científica de deep learning. Para entenderes o seu alcance, considera a diferença nos domínios que abrange. Na segunda-feira, podes usar o DeepChem para prever a solubilidade aquosa de uma nova molécula semelhante a um fármaco. Isto requer um modelo que compreenda ligações moleculares e estados quânticos. Na quinta-feira, podes usar a mesma framework para analisar uma imagem de microscopia para contar células individuais. São problemas físicos muito diferentes. O DeepChem abstrai o boilerplate subjacente para ambos, fornecendo ferramentas especializadas para machine learning molecular, bioinformática e até ciência dos materiais. Aqui está o ponto chave. A parte mais difícil do machine learning científico é a representação de dados. Um modelo de deep learning standard não tem noção de estrutura atómica ou sequências biológicas. O DeepChem resolve isto fornecendo featurizers altamente otimizados. Um featurizer pega num objeto científico raw, como um composto químico escrito em notação de texto standard, e traduz isso matematicamente para um grafo ou um vetor. Após a featurization, a informação vai para objetos dataset especializados do DeepChem. Estes objetos são desenhados para gerir com eficiência grandes coleções de dados científicos no disco. Isto evita memory crashes quando processas milhões de compostos complexos. O DeepChem também aborda a forma como os modelos científicos são avaliados. No machine learning standard, normalmente divides os teus dados de training e testing de forma aleatória. Mas, em química, o random splitting faz com que os modelos memorizem os dados de training em vez de aprenderem a física real. Para corrigir isto, o DeepChem fornece splitters especializados. Por exemplo, um scaffold splitter separa moléculas com base na sua estrutura bidimensional central. Isto garante que os teus dados de testing representem famílias químicas inteiramente novas, forçando o modelo a provar que realmente generaliza para compostos nunca vistos. Assim que os teus dados estiverem preparados e com o split feito, o DeepChem fornece uma suite completa de modelos pre-built adaptados para estes datasets. Passas os teus objetos científicos para o featurizer, o DeepChem converte-os, lida com os splits, alimenta-os na layer subjacente de PyTorch ou TensorFlow, e gera uma previsão. O verdadeiro poder do DeepChem é que codifica o conhecimento de domínio diretamente na tua data pipeline, permitindo-te focar puramente na descoberta científica, em vez do plumbing estrutural do machine learning. Se quiseres ajudar a manter o podcast, podes procurar por DevStoriesEU no Patreon. É tudo por este episódio. Obrigado por ouvires, e continua a desenvolver!

Olá, daqui é o Alex da DEV STORIES DOT EU. Dominar o DeepChem, episódio 2 de 15. O maior bottleneck no machine learning científico quase nunca é a arquitetura do modelo. É tentar carregar ficheiros enormes sem fazer crash à tua RAM. Gerir Datasets científicos é como consegues ultrapassar essa barreira de memória. Ao passares para o DeepChem, um instinto comum é carregar tudo para um DataFrame de Pandas. Os DataFrames são excelentes para dados tabulares bidimensionais. Mas o machine learning científico requer frequentemente arrays de dimensões superiores, múltiplas tarefas de previsão simultâneas e importância da amostra por tarefa. O DeepChem usa a sua própria abstração de Dataset porque liga nativamente features, labels multi-task e weights de amostras num formato estrito que os modelos conseguem consumir de forma eficiente. Cada objeto Dataset no DeepChem garante a presença de quatro arrays paralelos. Primeiro, tens o X, que guarda as tuas features numéricas. Segundo, tens o y, que guarda as tuas labels ou os targets que estás a tentar prever. Terceiro, tens o w, o array de weights. É aqui que a coisa fica interessante. Os datasets científicos são muitas vezes esparsos. Podes ter dados experimentais a mostrar que uma molécula é eficaz contra um target, mas não ter dados sobre se é tóxica para o fígado. Em vez de descartares a molécula por completo ou inventares uma label falsa, defines o weight da tarefa em falta para zero. O modelo aprende com os dados que tens e ignora as lacunas. Finalmente, tens o array ids, que guarda um identificador único para cada amostra, como uma string SMILES química. Ter um formato standard é útil, mas o verdadeiro poder da abstração Dataset está na forma como gere a memória do sistema. O DeepChem oferece duas formas principais de guardar estes quatro arrays. Se o teu dataset for pequeno o suficiente para caber na memória do teu sistema, usas um NumpyDataset. Nos bastidores, isto simplesmente guarda arrays NumPy standard na RAM. Oferece um acesso extremamente rápido e é ideal para prototipagem ou para trabalhar com coleções mais pequenas de moléculas. A limitação do NumpyDataset torna-se óbvia quando lidas com dados científicos do mundo real. Imagina que estás a trabalhar com um dataset de 100 gigabytes de estruturas cristalinas tridimensionais densas. Tentar carregar isso para arrays in-memory standard vai fazer crash instantaneamente a uma máquina normal. Para resolver isto, o DeepChem oferece o DiskDataset. Um DiskDataset faz exatamente o que o nome indica. Guarda os arrays X, y, w e ids em vários ficheiros pequenos, ou shards, diretamente no teu disco rígido. Tu especificas um diretório de dados, e o DeepChem gere o armazenamento. Quando treinas um modelo, o DiskDataset puxa apenas o batch de dados atual para a RAM. Assim que o modelo processa esse batch, a memória é libertada para o próximo. A transição entre estes dois formatos é totalmente transparente para o resto do teu código. Podes escrever um training loop, testá-lo localmente usando um pequeno NumpyDataset, e depois fazer deploy exatamente do mesmo código num cluster a apontar para um DiskDataset massivo. O modelo simplesmente pede ao dataset o próximo batch, e o dataset gere se esse batch vem da RAM ou se é feito stream a partir do disco. Desenhar as tuas data pipelines à volta deste streaming out-of-core desde o primeiro dia garante que a tua infraestrutura vai sobreviver ao salto de alguns milhares de registos experimentais para milhões de estruturas geradas. Obrigado por ouvirem, happy coding a todos!

Olá, daqui fala o Alex da DEV STORIES DOT EU. Dominar o DeepChem, episódio 3 de 15. Leste um paper a afirmar que uma nova graph neural network alcança resultados state-of-the-art em propriedades químicas. Mas, quando olhas com atenção, reparas que usaram um data split customizado, um dataset proprietário e uma métrica obscura, o que torna a sua afirmação matematicamente sem sentido. A comparação padronizada é a única forma de haver progresso científico, e em química computacional, esse standard é a benchmark suite MoleculeNet. Um erro comum é achares que o MoleculeNet é apenas um repositório estático. Não é uma pasta de ficheiros CSV para download num servidor, que tens de fazer o parse e limpar tu mesmo. É uma suite de datasets curada e profundamente integrada, embutida diretamente no DeepChem através do módulo dc dot molnet. Funciona como o ImageNet do machine learning molecular. Fornece um conjunto partilhado de tasks, splits padronizados e baselines avaliadas em diferentes domínios. A suite categoriza os seus dados em áreas científicas específicas para testar diferentes capacidades de modelação. Tens datasets de mecânica quântica, como o QM9, que contém propriedades geométricas e energéticas para moléculas pequenas. Tens datasets de físico-química para prever a solubilidade ou a energia livre de hidratação. E tens datasets de biofísica e fisiologia, incluindo benchmarks de toxicidade como o Tox21, que mede como milhares de químicos ambientais interagem com vias biológicas específicas. Vamos ver um cenário prático. Acabaste de desenhar um novo modelo de previsão de toxicidade e precisas de provar matematicamente que ele supera as baselines anteriores. Não precisas de ir à procura dos dados brutos do Tox21, lidar com os missing values, ou escrever um parser customizado. Em vez disso, chamas a função load tox 21 do módulo dc dot molnet. É aqui que a coisa fica interessante. Quando invocas uma função load no MoleculeNet, ela não devolve apenas texto bruto. Ela processa os dados dinamicamente usando um featurizer que especificas nos argumentos, como circular fingerprints ou estruturas de grafo. A função normalmente devolve um tuple com três elementos principais. Primeiro, dá-te uma lista com os nomes das tasks. Para o Tox21, estes são os doze alvos biológicos específicos que estás a tentar prever. Segundo, devolve o próprio dataset, que já está bem particionado em subconjuntos de treino, validação e teste. Terceiro, fornece os transformers usados para normalizar ou escalar os dados durante a fase de carregamento. Pegas nesse training set do Tox21 pre-split, alimentas o teu novo modelo e, em seguida, avalias as previsões em relação ao test set. Como todos os outros investigadores usam exatamente a mesma API e pipeline de featurization, o teu score ROC final pode ser comparado de forma direta e justa com as baselines publicadas. O MoleculeNet também padroniza a forma como avalias a generalização através de splitting strategies. A API suporta várias formas de dividir os teus dados. Embora possas usar um random split básico, a química muitas vezes exige um scaffold split. Um scaffold split separa as moléculas com base nas suas estruturas bidimensionais principais. Isto força o test set a conter frameworks moleculares que o modelo nunca viu durante o treino. Testa se o teu modelo realmente aprendeu as regras químicas subjacentes, em vez de apenas memorizar pequenas variações. Por default, as funções load aplicam o método de splitting que faz mais sentido científico para esse dataset específico. A parte mais difícil do machine learning aplicado não é escrever a arquitetura do modelo, é provar que o modelo realmente generaliza para dados não vistos sem data leakage. O MoleculeNet dá-te o playground rigoroso e padronizado necessário para que essas provas sejam válidas. É tudo por este episódio. Obrigado por ouvires, e continua a construir!

Olá, daqui é o Alex do DEV STORIES DOT EU. Dominar o DeepChem, episódio 4 de 15. Uma neural network não consegue digerir uma estrutura química desenhada num quadro branco. Mesmo que escrevas essa estrutura como uma text string, os algoritmos standard de machine learning continuam a não conseguir lê-la. Eles precisam que os dados sejam pré-mastigados em arrays numéricos. A ponte entre uma representação química e um modelo matemático é o Feature Engineering para Moléculas. Em quimioinformática, representamos frequentemente as moléculas como strings SMILES. Estas são sequências de caracteres que definem átomos e ligações. Um anel de carbono torna-se num padrão de texto específico. Mas se tentares passar uma raw string para um Random Forest ou para uma support vector machine, vai falhar. Um modelo matemático requer um vetor numérico de tamanho fixo como input. Transformar esse texto químico num array de números é o que chamamos de featurization. O DeepChem lida com este passo com um conjunto dedicado de classes chamadas featurizers. Antes de olharmos para como o DeepChem faz isto, há um ponto de confusão comum a esclarecer. Quando as pessoas ouvem falar em gerar uma representação vetorial de texto, pensam imediatamente em learned embeddings, como os usados nos language models modernos. Os chemical fingerprints não são learned embeddings. Não há weights a serem atualizados, e não há neural networks envolvidas na criação da feature em si. Um fingerprint é um algoritmo de hashing determinístico. Se processares exatamente a mesma molécula em duas máquinas diferentes, vais obter exatamente o mesmo array de uns e zeros. O featurizer mais comum que vais usar para baseline models no DeepChem é o Circular Fingerprint. Este implementa um método conhecido como Extended Connectivity Fingerprints. É assim que a lógica funciona. O algoritmo olha para cada átomo pesado na tua molécula. A partir de cada átomo, irradia para fora num círculo, olhando para os átomos e ligações vizinhas até um raio específico. Podes controlar este raio, mas olhar até duas ligações de distância é a prática standard. Ele captura estes fragmentos estruturais locais, passa-os por uma hash function, e mapeia-os para um index específico num array de tamanho fixo. O resultado é um bit vector. O valor um num index específico significa que uma determinada subestrutura química está presente. O valor zero significa que está ausente. Imagina que tens uma lista de strings SMILES a representar centenas de pequenas moléculas semelhantes a fármacos. Queres treinar um modelo de Random Forest para prever a sua toxicidade. Primeiro, inicializas a classe CircularFingerprint no DeepChem. Configuras a classe para fazer output de um tamanho de 1024. Esta é a parte que interessa. Cada molécula, independentemente de ter dez ou cinquenta átomos, será convertida num array de exatamente 1024 bits. A seguir, passas a tua lista de strings SMILES para o método featurize desta classe. O algoritmo processa cada string de forma independente e devolve uma matriz bidimensional. As linhas representam as tuas moléculas, e as 1024 colunas representam a presença ou ausência de subestruturas específicas. Como o output é apenas uma matriz numérica standard, já não estás limitado a ferramentas específicas de química. Podes passar essa matriz diretamente para libraries standard de machine learning. Como os fingerprints dependem de hashes determinísticos de tamanho fixo em vez de learned semantics, podem acontecer colisões, o que significa que dois fragmentos estruturais complexos diferentes podem ocasionalmente mapear para o mesmo bit. Apesar disto, continuam a ser a baseline mais rápida e fiável para transformar química abstrata em matemática concreta. É tudo por este episódio. Obrigado por ouvires, e continua a construir!

Olá, daqui fala o Alex da DEV STORIES DOT EU. Dominar o DeepChem, episódio 5 de 15. Se representares um composto químico como uma string plana de caracteres, eliminas completamente a topologia física que dita como ele interage com o mundo. As moléculas não são frases lineares, são estruturas interligadas. Para preservar essa realidade estrutural nos teus datasets, precisas de Graph Convolution Featurizers. Quando ouves a palavra convolução, podes imaginar um modelo de imagem a deslizar um filtro sobre uma grelha quadrada e fixa de píxeis. Precisas de abandonar esse modelo mental. Os átomos não se organizam em grelhas uniformes. Um átomo de carbono pode ligar-se a quatro vizinhos, enquanto um de oxigénio se liga a dois, e um de hidrogénio a apenas um. As operações de grafos lidam com esta conectividade arbitrária e irregular, e os graph featurizers atuam como a ponte para traduzir dados químicos brutos para um formato que estas operações possam consumir. O DeepChem fornece duas ferramentas principais para isso. A primeira é o ConvMolFeaturizer. Esta função analisa uma molécula e gera um feature vector inicial para cada átomo. Calcula propriedades como o tipo de elemento, o número total de átomos pesados ligados, valência, carga formal, carga parcial e hibridização orbital. Agrupa estas features ao nível do átomo num objeto específico chamado ConvMol. Este formato foi desenhado para alimentar diretamente as graph convolution networks nativas do DeepChem. A segunda ferramenta é o MolGraphConvFeaturizer. Esta é a abordagem mais moderna e é altamente versátil porque o seu output é um objeto GraphData standard. Isto torna-a a escolha ideal se estiveres a passar dados para frameworks genéricas como o PyTorch Geometric ou o DGL. Vamos ver como o MolGraphConvFeaturizer lida com um anel de benzeno simples. O benzeno consiste em seis átomos de carbono dispostos num hexágono contínuo. O featurizer processa esta estrutura dividindo-a em nodes e edges. Primeiro, cria os nodes. Para cada um dos seis átomos de carbono, calcula um array numérico de propriedades atómicas, registando o estado de hibridização e a carga parcial desse átomo específico. Estes seis arrays individuais são empilhados para formar a node feature matrix. A seguir, mapeia as edges, que correspondem às ligações químicas. Constrói um edge index, que é simplesmente uma lista de pares de coordenadas que identificam exatamente que átomo está ligado a qual. Também gera edge features. Para cada ligação nesse edge index, o featurizer regista dados estruturais. Verifica se a ligação é simples, dupla, tripla ou aromática. Como estamos a analisar o benzeno, o featurizer codifica explicitamente a natureza aromática destas ligações, juntamente com a indicação de se a ligação é conjugada ou faz parte de um sistema de anéis. Finalmente, empacota a node feature matrix, o edge index e as edge features num único objeto GraphData. Agora tens um grafo matemático que retém tanto as características atómicas como as ligações topológicas exatas da molécula original, contornando completamente as limitações das representações de flat vectors. Aqui está a ideia principal. A qualidade de uma graph neural network é totalmente limitada pela riqueza estrutural da estrutura de dados que lhe passas. Ao utilizares corretamente um graph featurizer, garantes que o teu modelo aprende realmente a química subjacente, em vez de tentar memorizar um resumo unidimensional. Obrigado por passares uns minutos comigo. Até à próxima, fica bem.

Olá, daqui é o Alex do DEV STORIES DOT EU. Dominar o DeepChem, episódio 6 de 15. Constróis um modelo num novo dataset químico, corres a tua validação e obténs noventa e nove por cento de precisão. Fazes o deploy, e ele falha imediatamente no mundo real. As tuas métricas de validação mentiram-te com toda a confiança por causa da forma como dividiste os teus dados. Hoje, vamos olhar para o Scientifically Aware Splitting, comparando especificamente o Random Splitter default com o Random Stratified Splitter. Podes assumir que fazer o split de dados no DeepChem é exatamente o mesmo que usar uma função básica de train-test split de uma library geral de machine learning como o Scikit-Learn. Isso é um erro comum. Splitters de propósito geral funcionam bem para arrays simples de single-label. Os splitters do DeepChem foram desenhados para lidar nativamente com ambientes complexos de multi-task, labels booleanas esparsas, e as estruturas de dados específicas que o DeepChem usa para guardar moléculas. Vamos começar com a abordagem default: o Random Splitter. Esta ferramenta comporta-se exatamente como o nome sugere. Pega no teu dataset carregado e atribui os compostos químicos aos sets de training, validation e testing de forma uniformemente aleatória. Se estiveres a trabalhar com um dataset perfeitamente balanceado, onde os teus compostos ativos e inativos ocorrem em igual medida, este random shuffling funciona bem. Mas os dados científicos praticamente nunca são balanceados. Considera um dataset de toxicidade como o Tox21. No mundo real, a grande maioria dos compostos químicos que testas são seguros, e os compostos tóxicos são relativamente raros. Supõe que apenas um por cento dos compostos no teu dataset são marcados como tóxicos. Isto é um class imbalance severo. Se passares este dataset por um Random Splitter standard, o puro acaso estatístico dita que o teu validation ou test set pode acabar com zero exemplos tóxicos. Se o teu test set consistir inteiramente em compostos seguros, um modelo que simplesmente adivinhe "seguro" para cada input vai obter um score de cem por cento. Acabas com um score matematicamente perfeito para um modelo completamente inútil. É aqui que o Random Stratified Splitter se torna obrigatório. Em vez de atirar compostos às cegas para buckets, a estratificação força o split a respeitar a distribuição real das tuas labels. O Random Stratified Splitter faz um scan às propriedades do teu dataset antes de dividir o que quer que seja. Se os teus dados globais contiverem exatamente um por cento de compostos tóxicos e noventa e nove por cento de compostos seguros, o splitter garante que o teu training set tem um rácio de um para noventa e nove, o teu validation set tem um rácio de um para noventa e nove, e o teu test set mantém exatamente essa mesma proporção. Aqui está o insight principal. Os datasets do DeepChem geralmente envolvem multi-task learning. Isto significa que um único composto químico não é avaliado apenas para uma propriedade, mas frequentemente para dezenas de ensaios biológicos diferentes em simultâneo. As labels ao longo destas tasks são altamente esparsas. Podes ter apenas uma mão cheia de hits positivos para um ensaio de toxicidade específico em dez mil linhas de dados. O Random Stratified Splitter navega por esta matriz multidimensional. Ele garante que esses hits positivos extremamente raros são distribuídos de forma justa pelos teus splits. Cada subset dos teus dados recebe uma fatia representativa dos compostos ativos, impedindo que qualquer task perca a sua minority class durante o split. Sem este mecanismo, a avaliação do teu modelo depende completamente da sorte. Para datasets científicos altamente desbalanceados e multi-task, a estratificação não é uma otimização opcional. É um requisito fundamental para provar que o teu modelo realmente aprendeu a química subjacente, em vez de apenas explorar um blind spot estatístico. Obrigado por passares uns minutos comigo. Até à próxima, fica bem.

Olá, daqui fala o Alex da DEV STORIES DOT EU. Dominar o DeepChem, episódio 7 de 15. Os dados científicos reais são caóticos, desequilibrados e espalham-se por enormes gamas numéricas. Se alimentares esses valores experimentais brutos diretamente numa neural network, estás praticamente a implorar por gradientes não convergentes durante a backpropagation. Para corrigir isto, precisas de domar as tuas distribuições antes que elas toquem no teu model, e é aí que entram os Transformers do DeepChem. Quando ouves a palavra transformer no machine learning moderno, a tua mente provavelmente salta para attention mechanisms, large language models ou BERT. Esquece tudo isso para este episódio. No ecossistema DeepChem, um Transformer é simplesmente um utilitário de data preprocessing. Não é uma layer de uma neural network. É um objecto que recebe um dataset e modifica as suas features, labels ou weights para se encaixar nas restrições matemáticas estritas dos algoritmos de machine learning. Imagina um cenário onde estás a prever a solubilidade molecular experimental. A tua training data bruta pode conter target values que vão desde números negativos minúsculos até dezenas de milhares. Os weights da neural network geralmente inicializam-se como números muito pequenos. Se as tuas input features ou target labels contiverem um valor de quarenta mil, o cálculo de loss resultante gera um gradiente enorme. Os weights da rede vão oscilar drasticamente durante o update step, falhando em convergir para uma solução. Tens de fazer scale down aos dados. Uma maneira de lidar com isto é o MinMax Transformer. Este utilitário examina todo o teu dataset, localiza os valores mínimo e máximo absolutos para as tuas features ou labels especificadas, e comprime toda a distribuição num intervalo estrito de zero a um. O valor mais baixo passa a zero, o mais alto passa a um, e tudo o resto cai proporcionalmente no meio. Tu inicializas o transformer passando-lhe o teu target dataset para que ele possa computar esses limites. A seguir, chamas o seu método transform, que faz output de um novo dataset com os números recém-escalados. Agora os gradientes permanecem estáveis. Comprimir dados entre zero e um nem sempre é ideal, particularmente se o teu dataset contiver outliers massivos. Um outlier extremo vai forçar o resto dos teus data points normais a comprimirem-se numa fatia minúscula e indistinguível desse intervalo de zero a um. Para isto, usas o Normalization Transformer. Em vez de impor limites rígidos, ele desloca toda a tua distribuição para que a média fique exatamente em zero, e faz scale da dispersão para que o desvio padrão seja um. Isto centra os teus dados perfeitamente, alinhando-os com o sweet spot operacional da maioria das activation functions de neural networks. Aqui está o insight principal. Fazer scale às input features é uma rua de sentido único, mas transformar as tuas labels cria um problema secundário. Se o teu model treinar em targets de solubilidade normalizados, as suas predictions finais também serão normalizadas. Um valor previsto de zero vírgula quatro é matematicamente correto, mas praticamente inútil para um químico que espera uma medição do mundo real. O DeepChem resolve isto mantendo o state das métricas de scaling dentro do objecto transformer. Assim que o teu model gerar uma prediction normalizada, passas esse output para o método untransform do exato mesmo transformer. Ele inverte a aritmética, mapeando a prediction escalada diretamente de volta para a sua unidade científica original. Normalizar os teus dados não é um passo de otimização opcional em deep learning, é um requisito estrutural para a estabilidade do training. Obrigado por ouvirem, happy coding a todos!

Olá, daqui fala o Alex da DEV STORIES DOT EU. Dominar o DeepChem, episódio 8 de 15. Às vezes, a melhor solução para um problema científico não é uma neural network massiva que demora uma semana a treinar. Muitas vezes, um random forest robusto é tudo o que precisas. Mas alternar entre um algoritmo tradicional e um pipeline complexo de deep learning geralmente significa reescrever todo o teu código de data handling. Este episódio aborda a Model API e os Scikit-Learn Wrappers, que resolvem exatamente esse problema. O DeepChem usa uma base class unificada chamada simplesmente Model. Esta classe padroniza a forma como treinas e avalias algoritmos em toda a library. A lógica central baseia-se em dois métodos principais. Usas o fit para treinar o algoritmo, e usas o predict para gerar outputs em novos dados. A característica principal desta interface é que estes métodos esperam objetos Dataset do DeepChem como input. Não passas arrays ou dataframes raw diretamente para o model. O Dataset atua como um container standard para as tuas features, labels e weights, e a Model API sabe exatamente como o ler. Podes assumir que uma library especializada como o DeepChem escreveria as suas próprias implementações custom para algoritmos básicos de machine learning. Não o faz. O DeepChem não reinventa o Scikit-Learn. Em vez disso, fornece um adapter chamado SklearnModel. Este wrapper pega em qualquer estimator standard do Scikit-Learn e dá-lhe a interface Model do DeepChem. Imagina um cenário em que queres prever as propriedades físicas de um novo material. Primeiro, importas um random forest regressor standard diretamente do Scikit-Learn e inicializas o regressor. A seguir, passas esse regressor standard para o wrapper SklearnModel do DeepChem. Agora tens um objeto compatível com o DeepChem. Para o treinar, chamas o fit no wrapped model, passando o teu Dataset do DeepChem. Nos bastidores, o wrapper extrai automaticamente as feature matrices, targets e sample weights do Dataset, e passa-os para o algoritmo subjacente do Scikit-Learn. Quando chega a hora de testar, chamas o predict num novo Dataset, e o wrapper formata o output de volta para um array standard. Aqui está o ponto chave. Como o wrapper SklearnModel expõe exatamente os mesmos métodos fit e predict que uma deep neural network construída nativamente no DeepChem, podes trocar o algoritmo subjacente sem mexer no teu data pipeline. Podes estabelecer uma baseline rápida com um model tradicional de machine learning, e mais tarde trocar facilmente para uma neural network complexa, apenas alterando a única linha de código que inicializa o model. O data loading, o training loop e os passos de evaluation permanecem idênticos. A principal conclusão é que a Model API desacopla a tua data ingestion da escolha do algoritmo, libertando-te para testar diferentes abordagens matemáticas sem estares constantemente a reescrever glue code. Se achas estes episódios úteis e queres apoiar o programa, podes procurar por DevStoriesEU no Patreon. Por este episódio é tudo. Até à próxima!

Olá, daqui é o Alex da DEV STORIES DOT EU. Dominar o DeepChem, episódio 9 de 15. Não podes simplesmente dar uma molécula como input a uma neural network standard desenhada para imagens. As moléculas não são grids rígidas de píxeis; são teias complexas de átomos de tamanhos e conexões variáveis. Se as forçares a encaixar numa grid standard, destróis a química estrutural que as torna únicas. Para resolver isto, usamos Specialized Molecular Graph Models. Estes modelos foram desenhados especificamente para ingerir de forma nativa os featurized graphs gerados nos teus steps de preprocessing anteriores. Os ouvintes às vezes confundem-nos com as tradicionais Convolutional Neural Networks. Uma CNN standard desliza um filter de tamanho fixo sobre uma grid bidimensional. Mas uma molécula não tem um canto superior esquerdo nem uma resolução fixa. Em vez disso, os graph models especializados operam dinamicamente nas ligações químicas como edges e nos átomos como nodes. Eles não querem saber das coordenadas da grid. Preocupam-se inteiramente com a conectividade. O DeepChem fornece algumas architectures específicas para isto. A primeira é o GCNModel, que significa Graph Convolutional Network. Pensa numa GCN como uma forma de reunir vizinhanças atómicas locais. Para cada átomo na tua featurized molecule, a GCN olha para os seus vizinhos imediatos. Ela pega nas features desses átomos vizinhos, como o seu tipo de elemento ou estado de hibridização, e faz um pooling delas para fazer o update das features do átomo original. Ela repete este processo ao longo de algumas layers. No final, cada átomo tem uma representação matemática que inclui o contexto do seu ambiente químico circundante. O modelo depois agrega todas estas representações atómicas num único vetor matemático para prever uma propriedade química geral, como a toxicidade ou a solubilidade. Isto cobre as GCNs, que se focam principalmente em agregar dados dos nodes. Mas e as próprias ligações? Uma ligação dupla comporta-se de maneira muito diferente de uma ligação simples e, às vezes, precisas que a network pondere bastante essa diferença. É aqui que entra o MPNNModel, ou Message Passing Neural Network. As Message Passing Neural Networks não se limitam a olhar para uma molécula. Elas simulam matematicamente como a informação flui entre vizinhos atómicos. Digamos que estás a treinar um MPNNModel para prever as propriedades mecânicas quânticas de uma molécula. Para fazer isto com precisão, a natureza exata das ligações importa imenso. Numa MPNN, tanto os átomos como as ligações contêm dados de features explícitos. Durante o step de training, o modelo realiza uma fase de message passing. Cada átomo gera uma message com base no seu state atual e envia-a para os seus vizinhos ao longo das ligações que os unem. Crucialmente, a própria ligação modifica essa message. Uma message que viaje por uma ligação aromática rígida será calculada de forma diferente de uma que viaje por uma ligação simples flexível. Quando um átomo recebe messages de todos os seus vizinhos, usa uma pequena neural network interna para fazer o update do seu próprio state. Essencialmente, calcula que é um átomo de carbono a ser influenciado por um átomo de oxigénio numa ligação dupla e por um átomo de hidrogénio numa ligação simples. Este processo itera várias vezes. A informação propaga-se para fora, passo a passo, por toda a network de ligações. Após um número determinado de steps, o modelo reúne os states finais de todos os átomos para fazer a sua prediction. Como a MPNN respeita nativamente a verdadeira estrutura química, destaca-se a prever comportamentos quânticos complexos que modelos mais simples não conseguem prever. Aqui está o insight principal. Não precisas de inventar maneiras de mapear moléculas para arrays planos. Ao usar os modelos GCN e MPNN, preservas a topologia atómica exata dos teus dados, permitindo que a network aprenda diretamente com a própria química. É tudo por este episódio. Obrigado por ouvires, e continua a desenvolver!

Olá, daqui fala o Alex da DEV STORIES DOT EU. Mastering DeepChem, episódio 10 de 15. Se estiveres a fazer o screening de moléculas para um novo medicamento, talvez uma em dez mil realmente funcione. Um modelo que simplesmente prevê que todas as moléculas são inúteis vai atingir uma accuracy de 99,99%, sem descobrir absolutamente nada. É por isso que a accuracy básica é muitas vezes uma péssima métrica para a descoberta científica, e é exatamente por isso que precisamos de falar sobre a Avaliação de Modelos Científicos. Nas ciências, os datasets são quase sempre altamente desequilibrados. Considera criar um classifier para prever a inibição do HIV. A grande maioria dos compostos químicos testados não vai inibir o vírus. Os candidatos a medicamentos ativos são extremamente raros. Se usares a accuracy standard para avaliar o teu modelo, os resultados vão mentir-te. O modelo simplesmente aprende a adivinhar a majority class, e atinge scores muito altos, mas falha completamente na descoberta de um único medicamento eficaz. Para corrigir isto, precisas de métricas que exponham este comportamento. A primeira é o recall score. O recall mede quantos dos compostos ativos reais o teu modelo identificou com sucesso. Ele penaliza severamente os modelos que falham verdadeiras descobertas. No entanto, o recall por si só não oferece uma visão completa. Um modelo naive poderia simplesmente adivinhar que todos os compostos são ativos, alcançando um recall score perfeito, mas a gerar milhares de false positives. É aqui que o Matthews correlation coefficient, ou MCC, se torna essencial. O MCC é uma medida equilibrada que avalia todas as quatro categorias dos teus resultados. Ele analisa simultaneamente os true positives, true negatives, false positives e false negatives. Produz um score entre menos um e mais um. Um score de mais um significa uma prediction perfeita, zero significa que o modelo não é melhor do que random guessing, e menos um significa discordância total. O MCC só gera um score alto se o modelo prever com accuracy tanto os compostos ativos raros como os inativos comuns. Ele penaliza brutalmente um modelo que opta pelo caminho mais fácil de adivinhar a majority class. Podes estar a perguntar-te por que não podes simplesmente importar estas funções de métricas diretamente do scikit-learn. O scikit-learn tem implementações perfeitamente boas tanto de recall como de MCC. O problema resume-se ao data shape. Os modelos do DeepChem fazem frequentemente multi-task learning, a prever dezenas de propriedades químicas diferentes em simultâneo. As funções standard do scikit-learn esperam flat arrays simples. Se lhes passares os outputs complexos e multidimensionais do DeepChem, elas vão fazer crash ou calcular o score incorretamente. O DeepChem resolve esta incompatibilidade com a sua própria classe Metric. Esta classe funciona como um wrapper à volta de funções matemáticas de scoring standard. Quando instancias uma Metric do DeepChem, passas-lhe a função de scoring raw que queres usar, como a função MCC do scikit-learn. O wrapper Metric do DeepChem assume o controlo a partir daí. Ele gere o batching dos teus dados e alinha as true labels com as predictions do teu modelo em todo o dataset. Aqui está o insight principal. A classe Metric depende fortemente de um mecanismo interno chamado normalize prediction shape. Ele inspeciona os teus dados para determinar se o teu modelo está a fazer output de uma single task, multiple tasks, ou vetores de probabilidade com one-hot encoding. A seguir, faz o reshape desses outputs multidimensionais raw nos flat arrays exatos que as funções matemáticas subjacentes exigem. Não tens de escrever loops manuais para fazer slice e unpack dos teus arrays multi-task antes de lhes fazeres o scoring. O wrapper lida com a complexidade estrutural automaticamente, para que a matemática funcione exatamente como pretendido. Quando avalias um modelo científico num dataset desequilibrado, o teu trabalho principal é provar que o modelo não está a fazer cheat à baseline, por isso escolhe uma métrica que force o modelo a aprender realmente a química rara. Obrigado por passares uns minutos comigo. Até à próxima, fica bem.

Olá, daqui é o Alex da DEV STORIES DOT EU. A dominar o DeepChem, episódio 11 de 15. Testar exaustivamente todas as combinações possíveis de learning rate, layer size e penalty para um modelo pesado pode demorar semanas ou até meses. Mas e se o teu código conseguisse adivinhar de forma inteligente onde está a melhor configuração do modelo após apenas algumas tentativas? Hoje, vamos olhar para o hyperparameter tuning inteligente no DeepChem. Antes de olharmos para os métodos de search, vamos esclarecer uma confusão comum. O DeepChem fornece uma base class chamada HyperparamOpt. Este não é o teu training loop do modelo em si. É um loop de otimização exterior. Tu forneces uma função chamada model builder. Esta função sabe como construir o teu modelo específico dado um conjunto de parâmetros. A classe HyperparamOpt faz o wrap deste builder, passando-lhe diferentes conjuntos de parâmetros, para treinar o modelo resultante num dataset, avaliá-lo com uma métrica específica e devolver a melhor configuração. A maneira mais simples de pesquisar este espaço de parâmetros é usar o GridHyperparamOpt. Tu dás-lhe listas discretas de valores. Por exemplo, três learning rates, quatro números diferentes de estimators e dois tipos de penalty. O grid search adota uma abordagem de força bruta. Avalia cada uma das combinações, uma a uma. Se tiveres um modelo pequeno e um espaço de parâmetros pequeno, o grid search serve perfeitamente. Mas assim que adicionas mais parâmetros, atinges uma explosão combinatória. Se a tua grid de parâmetros criar mil combinações e cada uma demorar uma hora a treinar, o grid search deixa de ser viável. É aqui que entra o GaussianProcessHyperparamOpt. Em vez de uma grid de força bruta, faz uma pesquisa probabilística recorrendo a uma library de backend chamada pyGPGO. Tu defines intervalos contínuos ou escolhas categóricas para os teus parâmetros, em vez de listas fixas. O Processo Gaussiano trata a avaliação do teu modelo como uma função de caixa preta. Ele quer encontrar a métrica de performance máxima com o menor número possível de avaliações. Aqui está a ideia principal. O Processo Gaussiano aprende à medida que avança. Quando testa uma combinação específica de learning rate e penalty, olha para o score de avaliação resultante. Depois, constrói um mapa matemático do espaço de parâmetros, para prever onde os scores poderão ser mais altos e onde as suas previsões são mais incertas. Para a sua próxima tentativa, não escolhe simplesmente o próximo item de uma lista. Calcula uma função de aquisição para decidir qual é a próxima estimativa mais inteligente. Equilibra a exploração de zonas desconhecidas do teu espaço de parâmetros com o aproveitamento de áreas que já produziram bons scores. Portanto, num cenário de tuning de um modelo pesado, tu passas o teu model builder para o GaussianProcessHyperparamOpt. Defines um espaço de search que dita os limites superior e inferior para o learning rate e para o número de estimators. Dizes ao optimizer para correr durante vinte tentativas. Em vez de percorrer cegamente mil combinações, o algoritmo sonda o espaço, percebe que certos learning rates têm uma má performance, evita completamente esse território e concentra-se na zona ideal. Poupas uma enorme quantidade de tempo computacional. A principal conclusão aqui é adequares a tua estratégia de search ao teu orçamento computacional. Usa o grid search quando tiveres uma mão cheia de valores discretos e tempos de treino rápidos, mas quando o treino for dispendioso e o espaço de parâmetros for vasto, confia num Processo Gaussiano para caçar ativamente o melhor modelo. Gostaria de tirar um momento para te agradecer por ouvires — ajuda-nos imenso. Tem um ótimo dia!

Olá, daqui é o Alex da DEV STORIES DOT EU. Dominar o DeepChem, episódio 12 de 15. Quando uma única experiência biológica custa dez mil dólares, não podes recolher big data. Podes conseguir apenas cinco data points para um ensaio completamente novo. O deep learning standard vai fazer overfit instantaneamente e falhar completamente aqui. O que precisas é de um algoritmo desenhado especificamente para extrair sinal de quase nada. Isto leva-nos ao metalearning para low-data regimes. O DeepChem lida com isto através de uma classe chamada MAML, que significa Model-Agnostic Meta-Learning. Em muitos domínios científicos, especialmente na descoberta de fármacos ou na ciência dos materiais, simplesmente não tens o volume de dados necessário para neural networks tradicionais. És forçado a operar num low-data regime, onde o few-shot learning é a única abordagem viável. Muitos engenheiros vão assumir que o transfer learning standard é a resposta aqui. Não é. O transfer learning treina um modelo num dataset massivo, na esperança de que as features estáticas aprendidas forneçam um bom warm-start para um dataset mais pequeno. O MAML não faz apenas um warm-start aos weights. Ele otimiza matematicamente a trajetória do gradient do modelo. Não aprende apenas os dados; aprende a adaptar-se a novos dados de forma eficiente. Como é que ele consegue isto? O MAML usa um nested loop de otimização através de uma distribuição de tasks. Durante o training, não alimentas o algoritmo com uma única stream contínua de dados. Alimentas-o com batches de tasks distintas. Para cada task no batch, o algoritmo pega numa quantidade minúscula de dados. Calcula os gradients e computa quais seriam os novos weights do modelo após um ou dois training steps standard. Aqui está o insight principal. O algoritmo ainda não aplica esses weights atualizados permanentemente. Em vez disso, pega nesses weights hipotéticos e testa-os contra um segundo set de dados separado, dessa exata mesma task. Calcula a loss neste validation set. Depois, computa o gradient dessa validation loss em relação aos starting weights originais, e atualiza esses weights originais. A matemática força o modelo a encontrar um ponto de inicialização onde dar apenas alguns gradient steps produz uma queda massiva no erro para qualquer nova task extraída desse domínio. Vamos aplicar isto a um cenário concreto. Supõe que tens dados históricos de dezenas de ensaios biológicos mais antigos. Queres prever os resultados de um ensaio completamente novo e altamente dispendioso, onde só tens orçamento para recolher cinco data points reais. No DeepChem, instancias o objeto MAML e passas-lhe um modelo base. Este modelo base é chamado de learner. Depois, treinas o algoritmo MAML fazendo sampling de pequenas tasks dos teus ensaios históricos. O algoritmo pratica constantemente a adaptação. Pega em cinco data points do ensaio A, atualiza-se, verifica o seu erro de previsão em mais dados do ensaio A, e faz backpropagation do resultado para os starting weights globais. Depois repete esta simulação exata para o ensaio B, ensaio C, e por aí fora. Com o tempo, o modelo converge para um set ideal de starting parameters para toda a família de ensaios. Quando o teu novo e caro ensaio finalmente chega, pegas nesses starting parameters e corres uma pass de fine-tuning standard usando os teus cinco pequenos data points. Como a otimização MAML alinhou a trajetória do gradient especificamente para uma adaptação rápida, o modelo configura-se quase instantaneamente. Obténs previsões altamente precisas para um problema novo usando um dataset microscópico. O MAML muda o objetivo fundamental do pre-training, passando de minimizar o erro de previsão em dados antigos para maximizar a adaptabilidade em novos dados. É tudo por este episódio. Obrigado por ouvires, e continua a desenvolver!

Olá, daqui fala o Alex da DEV STORIES DOT EU. Dominar o DeepChem, episódio 13 de 15. Tens uma estrutura 3D recentemente mapeada de uma proteína viral, mas encontrar onde um medicamento terapêutico se pode realmente ligar a ela é como tentar encaixar uma única peça de um puzzle de dez mil peças a flutuar em três dimensões. Não podes simplesmente atirar uma pequena molécula a uma proteína enorme e esperar que ela cole. Precisas de mapear os sulcos estruturais primeiro, e é exatamente para isso que serve o Binding Pocket Discovery. Antes de avançarmos, vamos esclarecer um mal-entendido comum. O pocket discovery não coloca um medicamento dentro de uma proteína. Apenas examina o espaço disponível para encontrar potenciais binding sites. Gerar a posição real da molécula dentro desse binding site chama-se pose generation. Esse é um passo completamente separado. Hoje, só nos interessa encontrar os lugares de estacionamento vazios. No DeepChem, este workflow começa com a base class Binding Pocket Finder. Este é um template abstrato. A sua função é fornecer uma interface standard, que recebe uma macromolécula 3D como input e devolve uma lista de potenciais pockets como output. Ao usar uma base class, o DeepChem garante que, quer uses um algoritmo built-in ou escrevas o teu próprio, a pipeline se mantém consistente. Mas o trabalho pesado a sério é feito por implementações específicas, sendo a mais comum o Convex Hull Pocket Finder. O Convex Hull Pocket Finder analisa algoritmicamente a geometria tridimensional da tua proteína viral. Imagina envolver toda a macromolécula bem apertada em película aderente. A película estica-se a direito sobre as lacunas, fendas e reentrâncias da superfície. Esse limite exterior é o convex hull matemático. Os espaços vazios presos entre esse limite exterior plano e a verdadeira superfície atómica irregular da proteína são os teus potenciais binding pockets. Estes são os sulcos vulneráveis onde um novo medicamento se pode ancorar com sucesso. Para identificar estes espaços sistematicamente, o algoritmo divide o volume à volta da proteína numa grid tridimensional fina. Ele percorre esta grid e identifica voxels, que são minúsculas caixas 3D. Procura voxels que estejam dentro do convex hull, mas que não contenham quaisquer átomos de proteína. Também mede a distância destas caixas vazias até ao átomo de proteína mais próximo. Se uma caixa estiver demasiado exposta à superfície, é ignorada. Se estiver demasiado enterrada no núcleo da proteína, também é ignorada. O algoritmo agrupa as caixas válidas restantes para criar as formas contínuas das cavidades da superfície. Assim que mapeia uma cavidade, o finder gera uma bounding box à sua volta. Aqui está o ponto-chave. O algoritmo não corta esta bounding box perfeitamente com as dimensões exatas do buraco. Ele adiciona uma camada calculada de padding à volta das margens. Esta margem extra é crucial porque as moléculas em biologia são dinâmicas. Quando finalmente passares estas coordenadas do pocket a um algoritmo de docking mais à frente na tua pipeline, esse padding fornece a margem de manobra necessária. Isto dá ao próximo passo espaço circundante suficiente para calcular como o medicamento se pode torcer, rodar ou deslocar ao acomodar-se no sulco. Passas a tua proteína viral para o Convex Hull Pocket Finder, e ele devolve-te um array limpo de bounding boxes com padding. Agora sabes exatamente onde estão as vulnerabilidades estruturais, e podes concentrar os teus recursos computacionais puramente nestas coordenadas específicas. Se quiseres ajudar a que estes episódios continuem a sair, podes apoiar o programa pesquisando por DevStoriesEU no Patreon. O padding garante que as tuas simulações de docking downstream não vão falhar simplesmente porque bateram numa parede matemática artificial. É tudo por este episódio. Obrigado por ouvires, e continua a desenvolver!

Olá, daqui é o Alex do DEV STORIES DOT EU. Dominar o DeepChem, episódio 14 de 15. Tens uma proteína alvo e uma potencial molécula de um fármaco, mas saber que podem interagir é inútil a não ser que saibas exatamente como se encaixam fisicamente. Já não precisamos de adivinhar formas às cegas. Podemos usar Convolutional Neural Networks pré-treinadas para prever a física real das binding poses. Isto é Pose Generation com Vina e Gnina. Primeiro, vamos esclarecer uma confusão comum. Os ouvintes confundem frequentemente docking com Molecular Dynamics. A Molecular Dynamics é uma simulação baseada no tempo que mostra como as moléculas se torcem, dobram e vibram ao longo de microssegundos. A pose generation, ou docking, não faz isto. Calcula um snapshot estático. Calcula a geometria de repouso ideal de um ligando dentro de um pocket da proteína e atribui-lhe um score energético estacionário com base nessa única posição. No DeepChem, o trabalho computacional pesado para isto acontece dentro da classe PoseGenerator. O seu trabalho específico é calcular múltiplos arranjos tridimensionais do teu ligando, chamados poses, dentro de uma bounding box restrita na proteína. Depois, faz o rank destas poses. A implementação standard para isto é o VinaPoseGenerator. Este faz o wrap do engine AutoDock Vina, que se baseia numa scoring function empírica. Calcula um score de binding energy clássico avaliando interações físicas como ligações de hidrogénio, contactos hidrofóbicos e repulsão estérica. O Vina testa uma configuração geométrica, calcula a penalidade ou recompensa de energia, ajusta ligeiramente os átomos e tenta de novo. Pesquisa este vasto espaço geométrico e devolve uma lista de poses ordenadas pela sua binding energy mais baixa. As fórmulas da física clássica são incrivelmente rápidas, mas às vezes avaliam mal interações moleculares complexas. É aqui que entra o GninaPoseGenerator. O GNINA é um upgrade de deep learning. Pega na framework subjacente do Vina e avalia as configurações usando uma Convolutional Neural Network pré-treinada. Imagina um cenário em que estás a avaliar um novo candidato a fármaco contra o cancro. O pose generator calcula 10 configurações geométricas diferentes deste fármaco a repousar dentro de um binding pocket alvo. Em vez de simplesmente somar os termos da física clássica, o GNINA passa as estruturas atómicas tridimensionais destas 10 poses pela sua neural network. O GNINA classifica essas 10 poses usando três métricas distintas. Primeiro, continua a calcular o score empírico tradicional do Vina como baseline. Segundo, faz o output de um CNN pose score. Esta é uma probabilidade entre zero e um que indica o quão bem a pose gerada corresponde a uma estrutura de alta qualidade, comprovada experimentalmente. Terceiro, calcula um CNN affinity score, que prevê a força de binding real. O CNN pose score é a adição crucial aqui. Atua como um filtro avançado, impedindo que o sistema dê um rank elevado a uma pose que pareça matematicamente estável para as equações clássicas, mas que seja fisicamente irrealista na natureza. Implementar isto requer apenas alguns passos. Inicializas o GninaPoseGenerator. Chamas o seu método generate, passando o ficheiro da estrutura da proteína, o ficheiro da estrutura do ligando e as dimensões das coordenadas que definem a bounding box do pocket. Restringir a pesquisa a uma box específica impede que o sistema desperdice compute cycles em espaço vazio. O método depois devolve as tuas poses ordenadas, juntamente com os CNN scores, permitindo-te extrair o melhor candidato físico. Aqui está o insight principal. O GNINA atinge esta alta precisão ao tratar o espaço físico 3D do pocket da proteína como uma imagem estruturada. Divide as coordenadas atómicas numa grid tridimensional. A Convolutional Neural Network depois procura padrões espaciais e químicos nessa grid volumétrica, exatamente da mesma forma que uma rede de reconhecimento de imagem standard procura contornos e texturas numa fotografia. É tudo por este episódio. Obrigado por ouvires, e continua a desenvolver!

Olá, daqui é o Alex da DEV STORIES DOT EU. Dominar o DeepChem, episódio 15 de 15. Queres desenhar uma molécula altamente estável, mas não tens um dataset enorme de exemplos perfeitos para treinar um modelo. Só tens um conjunto de regras físicas. Quando não tens dados estáticos, não podes usar supervised learning standard. Em vez disso, precisas de uma IA que aprenda por tentativa, erro e feedback. Isso leva-nos ao Reinforcement Learning na Ciência. Se estás habituado ao machine learning tradicional, podes confundir isto com supervised training. São fundamentalmente diferentes. O supervised learning requer um dataset estático, explícito e labeled. O reinforcement learning baseia-se em rewards interativas contínuas geradas por um environment. O modelo tenta uma jogada, o environment responde com um score, e o modelo ajusta a sua estratégia. No DeepChem, a base para esta interação é a classe Environment. Pensa no Environment como o teu simulador científico de alta fidelidade. Ele define as regras físicas do universo em que a tua IA opera. Ele monitoriza o state atual do teu sistema, define as ações matemáticas que o teu modelo pode tomar, e expõe uma step function. Quando o teu modelo toma uma ação, passa-a a essa step function. O Environment calcula a física, e depois devolve três coisas: o novo state, uma reward numérica baseada na qualidade do state resultante, e uma boolean flag a indicar se a tarefa está concluída. Se já trabalhas com ferramentas standard de fora da química, o DeepChem fornece a classe GymEnvironment. Esta simplesmente faz o wrap de environments de simulação standard do OpenAI Gym para que se integrem diretamente nos teus workflows do DeepChem. O componente que interage de facto com este Environment chama-se Policy. A Policy é a abstração que representa o cérebro do teu agent. Ela recebe o state atual do Environment e mapeia-o para uma ação específica, ou faz o output de um conjunto de probabilidades para diferentes ações possíveis. Para treinar uma Policy de forma eficiente, o DeepChem implementa algoritmos como o Advantage Actor-Critic, geralmente referido como A2C. Aqui está a ideia principal. O A2C divide o processo de aprendizagem em duas redes neuronais separadas a correr em paralelo: o Actor e o Critic. O Actor olha para o state e decide que ação tomar para progredir na tarefa. O Critic observa o resultado e estima o valor geral de estar nesse novo state. A palavra advantage refere-se à diferença entre a reward real recebida do Environment e a reward que o Critic previu. Se a ação resultou numa reward maior do que o Critic esperava, a advantage é positiva, e a rede do Actor é atualizada para tomar essa ação com mais frequência no futuro. Considera um cenário concreto em que queres construir novas moléculas de forma autónoma. O teu Environment é um engine de química programado para calcular a estabilidade molecular. Começas com um anel químico básico. O Actor avalia este state inicial e decide adicionar um átomo de carbono. O Environment processa este step, simula a nova estrutura química, descobre uma quebra na estabilidade, e devolve uma reward negativa. O Critic observa este resultado, atualiza a sua expectativa de baseline, e sinaliza ao Actor que esta foi uma má jogada. Na iteração seguinte, o Actor tenta antes adicionar um átomo de oxigénio. O Environment simula a mudança, calcula uma maior estabilidade, devolve uma reward positiva, e o Critic reforça essa escolha. Passo a passo, o algoritmo A2C navega pelo simulador químico, a construir uma molécula complexa e altamente estável de forma totalmente autónoma, sem nunca consultar um dataset estático de boas moléculas. Agents de reinforcement learning podem consultar simuladores milhões de vezes, a descobrir soluções que a intuição humana poderia ignorar completamente. Este episódio leva-nos ao fim do nosso deep dive no DeepChem. Se quiseres levar estas ferramentas mais longe, explora a documentação oficial e tenta construir os teus próprios environments hands-on. Também podes visitar devstories dot eu para sugerir tópicos para futuras séries. É tudo por este episódio. Obrigado por ouvires, e continua a construir!