Autoatenção multi-cabeça

A atenção multi-cabeça permite que um Transformer atenda a várias coisas ao mesmo tempo. Com a entrada X (n tokens × d colunas) e matrizes de pesos d × d:

Q = X × w_q, K = X × w_k, V = X × w_v
Divida as d colunas em num_heads cabeças de d_k = d / num_heads colunas consecutivas (a cabeça h usa as colunas h×d_k até (h+1)×d_k - 1).
Para cada cabeça, execute a atenção por produto escalar escalado nas suas colunas: para o token i, score_j = (Q_i · K_j) / √d_k nas colunas dessa cabeça, softmax sobre todos os n tokens j, e saída = Σ weight_j × V_j (colunas dessa cabeça).
Coloque as saídas das cabeças de volta em suas colunas (concatenação) e multiplique por w_o.

Implemente multi_head_attention(x, w_q, w_k, w_v, w_o, num_heads).

Entrada

x: Matriz de entrada n × d.

w_q, w_k, w_v, w_o: Matrizes de pesos d × d.

num_heads: O número de cabeças (d é divisível por ele).

Saída

Retorne a matriz de saída n × d.

Restrições

1 ≤ n ≤ 30, 1 ≤ d ≤ 32, 1 ≤ num_heads ≤ d e d é divisível por num_heads

-5 ≤ cada valor ≤ 5

Exemplos

Exemplo 1

Entrada:
x = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_k = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_o = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_q = [
    [0.0, 0.0],
    [0.0, 0.0]
]
w_v = [
    [1.0, 0.0],
    [0.0, 1.0]
]
num_heads = 1

Saída esperada:
[
    [0.5, 0.5],
    [0.5, 0.5]
]

Explicação

w_q é toda zero, então todas as pontuações são 0 e cada token faz a média das linhas de valores: V = X, então as duas linhas se tornam [0.5, 0.5].

Exemplo 2

Entrada:
x = [
    [2.0, 4.0]
]
w_k = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_o = [
    [0.0, 1.0],
    [1.0, 0.0]
]
w_q = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_v = [
    [1.0, 0.0],
    [0.0, 1.0]
]
num_heads = 2

Saída esperada:
[
    [4.0, 2.0]
]

Explicação

Com um único token, cada cabeça atende só a si mesma, então a saída concatenada é V = [2, 4]. w_o troca as duas colunas: [4, 2].

Referências

Execute os testes de exemplo para verificar seu código sem enviar.

Exemplo 1 Não executado

Entrada:

x = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_k = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_o = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_q = [
    [0.0, 0.0],
    [0.0, 0.0]
]
w_v = [
    [1.0, 0.0],
    [0.0, 1.0]
]
num_heads = 1

Saída esperada:

[
    [0.5, 0.5],
    [0.5, 0.5]
]

Sua saída

Exemplo 2 Não executado

Entrada:

x = [
    [2.0, 4.0]
]
w_k = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_o = [
    [0.0, 1.0],
    [1.0, 0.0]
]
w_q = [
    [1.0, 0.0],
    [0.0, 1.0]
]
w_v = [
    [1.0, 0.0],
    [0.0, 1.0]
]
num_heads = 2

Saída esperada:

[
    [4.0, 2.0]
]

Sua saída

4 testes ocultos também serão executados ao enviar.

Compilador e depurador C# online

Escreva, compile, execute e depure C# online. Use pontos de interrupção, execução passo a passo e inspeção de objetos em uma IDE com vários arquivos, sem Visual Studio.

Versão

Bibliotecas pré-instaladas

🚀 350,747 execuções totais (1 este mês)

Saída

Pratique C# com desafios de código

Resolva problemas práticos direto neste editor: rode os testes de exemplo, envie sua solução e receba uma revisão de código por IA.

Todos os desafios de C#

Fácil

Average of Three

Average three whole numbers.

Você vai aprender AritméticaDivisão

BeginnerLearning-pathVariables

Ver soluções (1)

Fácil

Rectangle Perimeter

Compute the perimeter of a rectangle from its sides.

Você vai aprender AritméticaValores de retorno

BeginnerLearning-pathVariables

Ver soluções (1)

Médio

Uma geração de um algoritmo genético

Gere a próxima geração de strings de bits com seleção por torneio, cruzamento de um ponto e mutação.

Você vai aprender Algoritmos genéticosBusca evolutiva

OptimizationSimulationai

Ainda sem soluções

Fácil

Bandido multibraço epsilon-greedy

Equilibre exploração e aproveitamento em um bandido multibraço com seleção de ações epsilon-greedy.

Você vai aprender Explorar ou aproveitarBandidos

Aprendizado por reforçoaiaprendizado de máquina

Ainda sem soluções

Fácil

Distribuição de estados de uma cadeia de Markov

Propague uma distribuição de probabilidade pela matriz de transição de uma cadeia de Markov por um número de passos.

Você vai aprender Cadeias de MarkovProbabilidade

Simulationaimath

Ainda sem soluções

Médio

Iteração de valor

Calcule quanto vale cada estado de um processo de decisão de Markov aplicando repetidamente a atualização de otimalidade de Bellman.

Você vai aprender Equação de BellmanMDPs

Aprendizado por reforçoaiaprendizado de máquina

Ainda sem soluções

Médio

Atualizações de Q-learning

Aplique a atualização do Q-learning a um fluxo de experiências e veja as recompensas voltarem para estados anteriores.

Você vai aprender Q-learningRecompensas descontadas

Aprendizado por reforçoaiaprendizado de máquina

Ainda sem soluções

Médio

Poda alfa-beta

Avalie uma árvore de jogo com minimax e poda alfa-beta, e conte quantas folhas a busca realmente examina.

Você vai aprender Poda alfa-betaBusca em jogos

RecursionTreesai

Ainda sem soluções

Médio

Jogo da velha com minimax

Escolha a jogada perfeita no jogo da velha explorando toda a árvore de jogo com minimax.

Você vai aprender MinimaxÁrvores de jogo

Recursionai

Ainda sem soluções

Médio

Busca A* em uma grade ponderada

Encontre o caminho mais barato por uma grade de custos de terreno com A*, o algoritmo de busca por trás da navegação em jogos e robôs.

Você vai aprender Busca A*Heurísticas

GraphsGridsShortest-pathai

Ainda sem soluções

Médio

Amostragem com temperatura e top-k

Escolha o próximo token como um modelo de linguagem: mantenha os k maiores logits, aplique a temperatura e amostre.

Você vai aprender Geração de textoAmostragem

aiaprendizado de máquina

Ainda sem soluções

Médio

Normalização de camada

Normalize cada linha para média 0 e variância 1 e depois escale e desloque, como todo bloco Transformer faz.

Você vai aprender Normalização de camadaTransformers

Redes neuraisaiaprendizado de máquina

Ainda sem soluções

🔷 Sobre este Executor Online de C# / .NET

O CodeUtility C# Executor permite escrever e executar código C# real diretamente no navegador - sem necessidade de instalar, configurar o Visual Studio ou o .NET SDK. Ele é alimentado por um sandbox seguro que oferece suporte ao runtime do .NET e a versões modernas da linguagem C#, incluindo C# 9 e posteriores.

Esta ferramenta usa dotnet-script nos bastidores para compilar e executar seu código com comportamento real do .NET, permitindo experimentar recursos básicos e avançados de C#, como LINQ, async/await, pattern matching e generics.

Você pode testar scripts simples, funções e fluxos de lógica, ou explorar conceitos como classes, structs, herança e interfaces - tudo em um ambiente de codificação limpo e sem distrações.

Seja para aprender C#, testar algoritmos ou experimentar recursos do .NET, o CodeUtility C# Executor oferece uma forma rápida, segura e confiável de executar código C# instantaneamente a partir de qualquer navegador.

Mais do que um executor de código

Use no mesmo executor um editor de vários arquivos, um terminal de execução isolado, bibliotecas específicas do ambiente, espaços de trabalho persistentes, compartilhamento e colaboração em tempo real.

Como usar este executor?

Escolha um ambiente de execução, abra ou crie um arquivo, escreva o código e selecione Executar. A saída aparece no terminal; usuários conectados podem manter arquivos em um espaço de trabalho, instalar bibliotecas e colaborar por meio de compartilhamentos.

Selecione uma versão e edite o arquivo atual ou abra outro arquivo do espaço de trabalho.
Execute o código, forneça dados no terminal quando solicitado e consulte o histórico de execuções salvo.
Use bibliotecas, ferramentas do espaço de trabalho, compartilhamento e chat quando a tarefa exigir mais de um trecho de código.

Comece a codificar

VersãoSelecione um tempo de execução antes de executar.As bibliotecas instaladas pertencem à versão do idioma selecionado.
Arquivos abertos lista arquivos de texto não abertos.Selecione um para abri-lo em uma guia do editor disponível.
Executar executa o arquivo ativo com seu espaço de trabalho disponível para o programa.
Stop encerra a execução atual antes do limite de tempo.
O Modo Avançado abre o layout IDE com um explorador de arquivos e um terminal móvel e redimensionável.

Espaço de trabalho e bibliotecas

Novo arquivo cria um arquivo no diretório pai selecionado e o abre no editor.
A nova pasta cria um diretório, até a profundidade de aninhamento suportada.
Carregar arquivos adiciona um ou mais arquivos seguros a um diretório.
Baixar salva um arquivo ou diretório compactado em seu dispositivo.
Copiar duplica um arquivo ou diretório de espaço de trabalho.
Renomear altera o nome de um arquivo e atualiza sua guia aberta e histórico.
Move realoca um item;arquivos e diretórios também podem ser arrastados.
Excluir remove um item após a confirmação e fecha a guia aberta do editor.
Libs pré-instaladas mostram pacotes já incluídos neste tempo de execução.
Adicionar Lib instala um pacote privado para sua conta e tempo de execução selecionado.

Terminal e assistência

O histórico de execução abre as saídas salvas anteriores e seguintes.
A saída de cópia copia o texto do terminal atual.
Limpar saída remove todas as saídas de execução salvas após a confirmação.
Explicar resume o código ativo.
Recentes abre explicações e resultados recentes.
As configurações alteram fontes, temas e botões visíveis da barra de ferramentas.

Compartilhamento e colaboração

Compartilhar publica o arquivo atual, um diretório ou todo o espaço de trabalho como um instantâneo ou espaço de trabalho ativo.Você controla o acesso ao link e quem pode salvar as alterações.
Registra as ações salvas do colaborador em um espaço de trabalho compartilhado.
Compartilhar bate-papo permite que participantes conectados enviem mensagens, mencionem pessoas, compartilhem blocos de código e vejam membros on-line ou digitando.
A colaboração ao vivo mostra cursores de colaboradores e atualizações de arquivos salvos.Os usuários somente visualização podem carregar a versão mais recente ou manter edições temporárias.

Cotas e limites

O tempo de execução é limitado a 20 segundos por execução do servidor.Use Parar quando quiser terminar mais cedo.
O armazenamento do espaço de trabalho permite 100 arquivos, 100 diretórios e 10 MiB no total para cada espaço de trabalho e idioma do usuário conectado.
Arquivos e pastas são limitados a 1 MiB por arquivo e 5 níveis de diretório aninhados.Os arquivos gerados pelo seu código seguem a mesma cota.
As bibliotecas privadas estão limitadas a 10 pacotes instalados para cada conta e tempo de execução.
Os instantâneos de compartilhamento podem conter até 100 arquivos, 1 MiB por arquivo e 2 MiB no total.
Os convites de compartilhamento suportam até 25 pessoas por compartilhamento, com permissões de acesso e salvamento gerenciadas separadamente.
O chat de compartilhamento permite 2.000 caracteres por mensagem e 10.000 mensagens por compartilhamento.
A imposição de cota também se aplica enquanto o código está em execução.Uma gravação que excede os limites de contagem, tamanho, armazenamento ou aninhamento de arquivos é rejeitada com segurança.

Bom saber Execute apenas o código e instale pacotes em que você confia.A execução é isolada e limitada, mas seu programa ainda pode modificar arquivos dentro de um espaço de trabalho gravável até sua cota imposta.

💡 Fundamentos de C# e Exemplos que Você Pode Testar Acima

1. Declarando Variáveis e Constantes

C# usa declarações de variáveis com tipagem forte. Use const para constantes de compilação e readonly para constantes de tempo de execução.

int age = 30;
double pi = 3.14159;
char grade = 'A';
string name = "Alice";
bool isActive = true;

// Constantes
const int MaxUsers = 100;
const string Company = "CodeUtility";

2. Condicionais (if / switch)

Use if, else if e switch para controle de fluxo.

int x = 2;
if (x == 1)
{
    Console.WriteLine("Um");
}
else if (x == 2)
{
    Console.WriteLine("Dois");
}
else
{
    Console.WriteLine("Outro");
}

switch (x)
{
    case 1:
        Console.WriteLine("Um");
        break;
    case 2:
        Console.WriteLine("Dois");
        break;
    default:
        Console.WriteLine("Outro");
        break;
}

3. Laços

C# oferece os laços for, while e foreach.

for (int i = 0; i < 3; i++)
{
    Console.WriteLine(i);
}

int n = 3;
while (n > 0)
{
    Console.WriteLine(n);
    n--;
}

4. Arrays

Arrays armazenam coleções de tamanho fixo de elementos do mesmo tipo.

int[] numbers = { 10, 20, 30 };
Console.WriteLine(numbers[1]);

5. Manipulação de Listas

Use List<T> para coleções dinâmicas.

List<int> nums = new List<int> { 1, 2, 3 };
nums.Add(4);
nums.Remove(2);

foreach (int n in nums)
{
    Console.Write(n + " ");
}

6. Entrada/Saída no Console

Use Console.WriteLine e Console.ReadLine para I/O básico.

Console.Write("Digite seu nome: ");
string name = Console.ReadLine();
Console.WriteLine($"Olá, {name}!");

7. Funções

Defina métodos usando um tipo de retorno, nome e parâmetros.

int Add(int a, int b)
{
    return a + b;
}

Console.WriteLine(Add(3, 4));

8. Dicionários

Dictionary<TKey, TValue> armazena pares chave-valor.

Dictionary<string, int> ages = new Dictionary<string, int>();
ages["Alice"] = 30;
Console.WriteLine(ages["Alice"]);

9. Tratamento de Exceções

Trate erros em tempo de execução usando try, catch e finally.

try
{
    throw new Exception("Algo deu errado");
}
catch (Exception ex)
{
    Console.WriteLine(ex.Message);
}

10. Entrada/Saída de Arquivos

Use File e StreamReader/StreamWriter para operações com arquivos.

File.WriteAllText("file.txt", "Olá, arquivo");
string text = File.ReadAllText("file.txt");
Console.WriteLine(text);

11. Manipulação de Strings

Strings em C# oferecem métodos como Length, Substring, Contains.

string message = "Olá Mundo";
Console.WriteLine(message.Length);
Console.WriteLine(message.Substring(0, 5));
Console.WriteLine(message.Contains("Mundo"));

12. Classes e Objetos

C# suporta programação orientada a objetos por meio de classes e objetos.

class Person
{
    public string Name;
    public Person(string name) => Name = name;
    public void Greet() => Console.WriteLine($"Olá, eu sou {Name}");
}

Person p = new Person("Alice");
p.Greet();