Programa
Developing AI Applications
0 min
O que é o DeepSeek-Coder-V2?
O DeepSeek-Coder-V2 é um código aberto Mixture-of-Experts (MoE) de código aberto que rivaliza com o desempenho do GPT-4 em tarefas específicas de código. Projetado para ajudar os desenvolvedores, esse modelo traz vários recursos importantes para a tabela:
- Multilíngue: Treinado em código e linguagem natural em vários idiomas, inclusive inglês e chinês, o que o torna versátil para equipes de desenvolvimento globais.
- Versátil: Oferece suporte a uma ampla variedade de mais de 338 linguagens de programação, atendendo a diversos ambientes e necessidades de codificação.
- Em grande escala: Pré-treinado em trilhões de tokens de código e dados de texto, o que aprimora seus recursos de compreensão e geração em vários cenários de codificação.
- Vários tamanhos: Os modelos estão disponíveis em vários tamanhos, permitindo que os desenvolvedores escolham o tamanho do modelo que melhor se adapte aos seus recursos computacionais e requisitos de projeto.
Você pode acessar o modelo no site da DeepSeekvocê pode acessar o modelo no site da DeepSeek, que oferece acesso pago à API e um bate-papo. O código-fonte está disponível no GitHub e o artigo de pesquisa está hospedado no arXiv.
Os modelos estão hospedados em Huggingface-No entanto, você precisa de hardware de nível de pesquisa para executar os modelos localmente devido ao seu tamanho.
DeepSeek-Coder-V2 Benchmarks
Vamos ver o desempenho do DeepSeek-Coder-V2 nos benchmarks e como ele se compara a modelos como o GPT-4 Turbo, Gemini 1.5 Pro, Claude 3 Opus, LLaMA 3-70Be Codestral.
Fonte: Qihao Zhu et. al
HumanEval
O benchmark HumanEval mede a proficiência na geração de código, avaliando se o código gerado passa em testes de unidade específicos. O DeepSeek-Coder-V2 demonstra um desempenho excepcional nesse benchmark, alcançando uma precisão de 90,2%. Esse resultado ressalta a capacidade do modelo de gerar trechos de código funcionais e precisos, mesmo em cenários complexos.
MBPP+
O benchmark MBPP+ se concentra na compreensão do código, avaliando a capacidade de um modelo de entender e interpretar as estruturas e a semântica do código. O DeepSeek-Coder-V2 novamente se destaca nessa área, alcançando uma precisão de 76,2%, destacando sua forte compreensão do significado e da funcionalidade do código.
MATEMÁTICA
O benchmark MATH testa as habilidades de raciocínio matemático de um modelo dentro do código. O DeepSeek-Coder-V2 mantém sua liderança com uma precisão de 75,7%, indicando sua proficiência em lidar com operações matemáticas e lógica incorporada no código, um aspecto crucial de muitas tarefas de programação.
GSM8K
O benchmark GSM8K concentra-se na solução de problemas de matemática do ensino fundamental, avaliando as habilidades de solução de problemas mais amplas de um modelo, além da geração pura de código. O DeepSeek-Coder-V2 vem logo atrás do Claude 3 Opus com uma precisão de 94,9%, demonstrando sua capacidade de entender e resolver problemas matemáticos apresentados em linguagem natural.
Ajudante
O benchmark Aider avalia a capacidade de um modelo de fornecer assistência e sugestões de código. O DeepSeek-Coder-V2 lidera com uma precisão de 73,7%, sugerindo seu potencial como uma ferramenta valiosa para desenvolvedores que buscam orientação e suporte em tempo real durante tarefas de codificação.
LiveCodeBench
O benchmark LiveCodeBench mede o desempenho da geração de código em cenários do mundo real. O DeepSeek-Coder-V2 atinge uma precisão de 43,4% (segundo depois do GPT-4-Turbo-0409), demonstrando sua capacidade de gerar códigos funcionais e utilizáveis em contextos práticos.
SWE Bench Benchmark
O benchmark SWE-Bench avalia especificamente os modelos de IA em sua capacidade de executar tarefas de engenharia de software, como geração de código, depuração e compreensão de conceitos complexos de programação. Nesse contexto, o DeepSeek-Coder-V2 obteve uma pontuação de 12,7, o que indica um desempenho sólido, mas não a liderança do grupo. Ele fica atrás do GPT-4-Turbo-0409 (18,7) e do Gemini-1.5-Pro (18,3), que apresentam recursos superiores nessas tarefas. No entanto, o DeepSeek-Coder-V2 ainda superou modelos como Claude-3-Opus (11,7), Llama-3-70B (2,7) e Codestral, sugerindo que é uma opção confiável, mas não de primeira linha, para aplicativos de engenharia de software com base nesse benchmark.
Como o DeepSeek-Coder-V2 funciona
O DeepSeek-Coder-V2 baseia-se no modelo DeepSeek-V2, utilizando uma sofisticada arquitetura MoE (Mixture-of-Experts) para obter alto desempenho em tarefas específicas de código. Esse modelo utiliza vários modelos de especialistas, cada um especializado em diferentes tarefas de codificação, e seleciona dinamicamente o especialista mais relevante com base no código de entrada. Essa abordagem aumenta a eficiência e a precisão do modelo.
O processo de treinamento do DeepSeek-Coder-V2 envolve vários componentes críticos. Ele é pré-treinado em um conjunto de dados abrangente que inclui 60% de código-fonte, 10% de corpus matemático e 30% de corpus de linguagem natural, totalizando 10,2 trilhões de tokens. Esse conjunto de dados diversificado permite que o modelo compreenda e gere códigos de forma eficaz. O conjunto de dados de código-fonte inclui 1.170 bilhões de tokens provenientes do GitHub e do CommonCrawl, abrangendo 338 linguagens de programação, uma expansão significativa em relação aos modelos anteriores.
Após o pré-treinamento, o modelo passa por um ajuste fino com um conjunto de dados de instruções especializadas que inclui instruções de codificação, matemática e linguagem geral. Esse processo melhora a capacidade de resposta do modelo às solicitações de linguagem natural, o que transforma o modelo em um assistente útil.
Para os interessados na arquitetura subjacente, o modelo DeepSeek-V2, no qual o DeepSeek-Coder-V2 se baseia, apresenta inovações como a MLA (Multi-head Latent Attention) e a estrutura DeepSeekMoE. Essas inovações contribuem para a inferência eficiente e o treinamento econômico, conforme detalhado no artigo do DeepSeek-V2 disponível em arXiv.
Primeiros passos com o DeepSeek-Coder-V2
Há várias maneiras de você começar a usar o modelo DeepSeek-Coder-V2. Você pode executar o modelo localmente, acessando-o por meio da biblioteca biblioteca transformers da Hugging Face. No entanto, lembre-se de que os modelos são bastante grandes e exigem recursos computacionais significativos.
Como alternativa, o DeepSeek oferece uma API paga e uma interface de bate-papo on-line semelhante ao ChatGPT. O bate-papo on-line do DeepSeek também pode executar códigos HTML e JavaScript diretamente na janela de bate-papo! Esse recurso é bastante inovador - só vi algo semelhante no Artefatos do Claude 3.5 Sonnet modelo. Para este artigo, usaremos o recurso de bate-papo para nossos exemplos.
DeepSeek-Coder-V2: Exemplo de uso
No primeiro exemplo, pedirei ao modelo que programe o jogo da vida de Conway em HTML e JavaScript. Perguntei ao modelo a seguinte questão: "Você pode escrever o jogo da vida de Conway em HTML?" Aqui está a resposta:
Certainly! Below is a simple implementation of Conway's Game of Life using HTML, CSS, and JavaScript. This version will display the grid in an HTML table and update it every second.<!DOCTYPE html>
<html lang="en">
<head>
<meta charset="UTF-8">
<meta name="viewport" content="width=device-width, initial-scale=1.0">
<title>Conway's Game of Life</title>
<style>
table {
border-collapse: collapse;
}
td {
width: 10px;
height: 10px;
border: 1px solid #ccc;
}
.alive {
background-color: black;
}
.dead {
background-color: white;
}
</style>
</head>
<body>
<h1>Conway's Game of Life</h1>
<table id="grid"></table>
<script>
const N = 50; // Grid size
let grid = createGrid(N);
let intervalId;
function createGrid(N) {
let grid = new Array(N);
for (let i = 0; i < N; i++) {
grid[i] = new Array(N);
for (let j = 0; j < N; j++) {
grid[i][j] = Math.random() > 0.7 ? 1 : 0;
}
}
return grid;
}
function renderGrid(grid) {
const table = document.getElementById('grid');
table.innerHTML = '';
for (let i = 0; i < N; i++) {
const row = table.insertRow();
for (let j = 0; j < N; j++) {
const cell = row.insertCell();
cell.classList.add(grid[i][j] ? 'alive' : 'dead');
}
}
}
function updateGrid(grid) {
const newGrid = grid.map(row => row.slice());
for (let i = 0; i < N; i++) {
for (let j = 0; j < N; j++) {
const aliveNeighbors = countAliveNeighbors(grid, i, j);
if (grid[i][j] === 1) {
newGrid[i][j] = aliveNeighbors === 2 || aliveNeighbors === 3 ? 1 : 0;
} else {
newGrid[i][j] = aliveNeighbors === 3 ? 1 : 0;
}
}
}
return newGrid;
}
function countAliveNeighbors(grid, x, y) {
let count = 0;
for (let i = -1; i <= 1; i++) {
for (let j = -1; j <= 1; j++) {
if (i === 0 && j === 0) continue;
const newX = (x + i + N) % N;
const newY = (y + j + N) % N;
count += grid[newX][newY];
}
}
return count;
}
function startGame() {
intervalId = setInterval(() => {
grid = updateGrid(grid);
renderGrid(grid);
}, 1000);
}
renderGrid(grid);
startGame();
</script>
</body>
</html>Você também pode clicar no botão "Executar HTML" no final da resposta para obter o jogo da vida diretamente em nossa janela de bate-papo.
Captura de tela feita pelo autor.
Em seguida, pedi ao modelo que criasse um site dinâmico do jogo em que eu pudesse escolher a configuração inicial do tabuleiro. Este é o resultado, e ele funciona perfeitamente.
Captura de tela feita pelo autor.
Em nosso último exemplo, testei o modelo em um disco rígido Projeto Euler o problema "sapo saltador" o problema do "sapo saltador". Aqui está o código gerado pelo modelo:
import numpy as np
MOD = 10**9
def matrix_power(matrix, n):
result = np.identity(len(matrix), dtype=int)
while n > 0:
if n % 2 == 1:
result = np.dot(result, matrix) % MOD
matrix = np.dot(matrix, matrix) % MOD
n //= 2
return result
def fib_matrix(n):
if n == 0:
return 0
elif n == 1:
return 1
A = np.array([[1, 1, 1], [1, 0, 0], [0, 1, 0]], dtype=int)
A_power = matrix_power(A, n - 3)
initial_vector = np.array([2, 1, 1])
return np.dot(A_power, initial_vector)[0] % MOD
def S(L):
result = 0
for n in range(1, L + 1):
f_n = fib_matrix(n)
result = (result + f_n**3) % MOD
return result
# Compute S(10**14) % 10**9
print(S(10**14))Esse script demoraria muito para ser executado, então pedi ao modelo que o otimizasse e obtive o seguinte resultado:
import numpy as np
MOD = 10**9
def matrix_power(matrix, n):
result = np.identity(len(matrix), dtype=int)
while n > 0:
if n % 2 == 1:
result = np.dot(result, matrix) % MOD
matrix = np.dot(matrix, matrix) % MOD
n //= 2
return result
def fib_matrix(n):
if n == 0:
return 0
elif n == 1:
return 1
A = np.array([[1, 1, 1], [1, 0, 0], [0, 1, 0]], dtype=int)
A_power = matrix_power(A, n - 3)
initial_vector = np.array([2, 1, 1])
return np.dot(A_power, initial_vector)[0] % MOD
def find_pisano_period(m):
previous, current = 0, 1
for i in range(m * m):
previous, current = current, (previous + current) % m
if previous == 0 and current == 1:
return i + 1
def S(L):
pisano_period = find_pisano_period(MOD)
period_sum = 0
for n in range(1, pisano_period + 1):
f_n = fib_matrix(n)
period_sum = (period_sum + f_n**3) % MOD
full_periods, remainder = divmod(L, pisano_period)
result = (full_periods * period_sum) % MOD
for n in range(1, remainder + 1):
f_n = fib_matrix(n)
result = (result + f_n**3) % MOD
return result
# Compute S(10**14) % 10**9
print(S(10**14))Deixei o código otimizado ser executado por meia hora, mas ele ainda não produziu nenhum resultado. Embora eu ache que as soluções estão corretas, o desafio está em otimizar o código. Considerando que apenas 328 pessoas conseguiram resolver esse problema, não é de surpreender que o modelo não tenha conseguido resolvê-lo.
Conclusão
O DeepSeek-Coder-V2 é uma adição notável ao campo crescente de assistentes de codificação de código aberto, demonstrando desempenho competitivo com modelos proprietários estabelecidos.
Para aproveitar ao máximo o DeepSeek-Coder-V2, siga as práticas recomendadas, fornecendo prompts claros e específicos. Também incentivo você a fornecer feedback aos desenvolvedores se encontrar algum erro.
Se você quiser saber mais sobre assistentes de codificação de IA, recomendo que ouça este podcast do DataFrame: O futuro da programação com Kyle Daigle, COO do GitHub.
Tópicos
