Todos os cursos Grátis · Sem conta · No seu navegador

Redes Neurais: De Neurônio a Transformer

Construa redes neurais por conta própria, de um neurônio a um transformer, depois modelos generativos, difusão, leis de escala e olhando dentro de um modelo, em Python puro e NumPy, treinados no seu navegador. Escreva seu próprio autograd, diagnostique execuções quebradas, julgue afirmações por evidências e termine com um projeto final que você pode repetir. Grátis, sem conta.

25 módulos 246 lições 246 exercícios corrigidos automaticamente No seu próprio ritmo · ~143 de material Treinado no seu navegador, sem precisar de GPUPreveja a curva, depois execute-a
Seu progresso 0 / 246 exercícios concluídos
Meta diária
Módulo 1 · 60 min

Módulo 0: Linha de início

Você vai ser capaz de: dizer como o curso funciona e o que ele mede; fazer uma previsão e conferir com uma execução; registrar sua pontuação inicial nos quatro seletores; medir a velocidade do seu dispositivo em FLOPs.

Módulo 2 · sobre 8 h

Módulo 1: Python para este curso

Você vai ser capaz de: escrever e testar functions sobre listas e dicionários; usar NumPy arrays, shapes, slicing e broadcasting em vez de laços; definir a semente da aleatoriedade de forma reproduzível; escrever pequenas classes e closures. Verificado pelo Python gate (já fluente? faça primeiro: passar pula o módulo).

Etapa 1 de 7 · camada de rede Linha de início Passe todos os exercícios 5 desta etapa para ganhar sua camada.
Módulo 3 · sobre 7 h

Módulo 2: Matemática e probabilidade, apenas conforme necessário

Você vai ser capaz de: calcular produtos escalares, multiplicações de matrizes e broadcasts; encontrar inclinações por ajuste e pela regra da cadeia, para números e para matrizes inteiras; explicar como a dispersão se soma e o que um eigenvalue faz; derivar o gradiente softmax; escrever log-sum-exp, softmax e cross-entropy que nunca transbordam (o portão).

Etapa 2 de 7 · camada de rede Fundamentos Passe todos os exercícios 3 desta etapa para ganhar sua camada.
Etapa 3 de 7 · camada de rede Fazendo o treinamento funcionar Passe todos os exercícios 40 desta etapa para ganhar sua camada.
Módulo 14 · sobre 10 h

Módulo 13: Atenção e transformers

Você vai ser capaz de: construir atenção, a causal mask, heads, positions, layer norm e um bloco inteiro que corresponde a um modelo real; derivar o backward pass da atenção; treinar um GPT pequeno; ler execuções gravadas; gerar com um cache; mapear seu engine no PyTorch; consertar um transformer quebrado (o gate).

Etapa 4 de 7 · camada de rede Arquiteturas para estrutura Passe todos os exercícios 56 desta etapa para ganhar sua camada.
Módulo 17 · sobre 4 h

Módulo 16: Duas redes em um jogo (GANs, opcional)

Módulo opcional, não necessário para o certificado. Você será capaz de: escrever as GAN losses e dizer pelos seus declives quando a saturante trava; treinar uma GAN em oito blobs e julgar sua cobertura; fazer o mode collapse acontecer; testar truques de estabilização sobre seeds gravadas e relatar o que ajudou; rodar um convolutional generator; resgatar uma GAN quebrada sozinho (the gate).

Módulo 19 · sobre 6 h

Módulo 18: Aprendizado sem rótulos

Você vai ser capaz de: julgar features por acordo de vizinho mais próximo e por uma linear probe que você escrever; pré-treinar com masked prediction; escrever InfoNCE e dizer por que é cross-entropy; pré-treinar com SimCLR e ler o que as augmentations decidem; combinar captions com pictures (opcional); testar features em objetos que o modelo nunca viu, sozinho (o gate).

Etapa 5 de 7 · camada de rede Redes que fazem coisas Passe todos os exercícios 26 desta etapa para ganhar sua camada.
Módulo 20 · sobre 5 h

Módulo 19: Maior, e o quanto melhor (leis de escala)

Você vai ser capaz de: calcular o custo de uma execução de treinamento em FLOPs; ajustar uma lei de potência com um piso e barras de erro; ler se pesos ou dados limitam uma execução; planejar o melhor tamanho de modelo para um orçamento fixo; prever uma execução maior e verificá-la; distinguir um salto real de uma métrica que o cria; planejar uma execução sozinho (o portão).

Módulo 21 · sobre 5 h

Módulo 20: Adaptando um modelo treinado de forma barata

Você vai ser capaz de: mostrar o esquecimento catastrófico; contar, construir e fazer o gradient-check do LoRA; escolher o rank dele a partir de medições; fazer o fine-tune de um modelo no seu próprio texto sem estragá-lo; dizer quando a destilação ajuda; quantizar pesos e prever o custo; ajustar preferências com DPO e parar a tempo; escolher um método para uma situação; atingir uma meta de adaptação com um Orçamento sozinho (o gate).

Módulo 22 · sobre 8 h

Módulo 21: Olhando dentro de um modelo

Você vai ser capaz de: dizer se evidências sobre o interior de um modelo são um padrão, um efeito ou um mecanismo; rodar uma probe com um controle; fazer patch em ativações para encontrar onde a informação está; remover partes e verificar o backup; testar um mecanismo de livro no modelo à sua frente; mostrar superposição em um brinquedo; treinar um sparse autoencoder e testar um feature label em texto não visto; ler grokking de execuções gravadas e verificar suas ondas removendo-as; encontrar onde a informação está apenas em novas entradas (o gate).

Módulo 23 · sobre 5 h

Módulo 22: Julgando afirmações

Você será capaz de: encontrar um conjunto de teste vazado por sobreposição e relatar a pontuação limpa; dividir uma perda média ao longo da parte que importa; dizer como a ablação de zero e média diferem e relatar o método; distinguir uma diferença de uma semente de uma medida com erros padrão; replicar um resultado em novas sementes e encontrar a configuração onde ele para de valer; revisar uma afirmação sozinho (o portão).

Etapa 6 de 7 · camada de rede Escalar e entender Passe todos os exercícios 36 desta etapa para ganhar sua camada.
Módulo 24 · sobre 7 h

Módulo 23: Estúdio de conclusão: um card de modelo que você pode rodar

Você vai ser capaz de: planejar um projeto com um orçamento de FLOP; chamar e rodar uma referência sobre seeds; julgar mudanças com barras de erro; encontrar um bug que ainda treina por gradient checking; fazer uma descoberta dentro do seu modelo contra um controle não treinado; avaliar uma vez em um conjunto oculto com barras de erro; escrever um model card onde cada número corresponde ao seu run log; exportar um arquivo offline cujas execuções sejam reproduzíveis.

Módulo 25 · 50 min

Módulo 24: Exame final e reteste

Você vai ser capaz de: mostrar, com a IA desligada, o que a Parte 2 ensinou em todos os quatro seletores (formulário C); comparar seus seletores da linha de partida até o fim da Parte 2; verificar um mês depois o que permaneceu (formulário D, opcional).

Etapa 7 de 7 · camada de rede Projeto final e prova Passe todos os exercícios 10 desta etapa para ganhar sua camada.