Página Inicial>Relacionado com a programação>Pitão
Baixar

Notícias: lançamento do novo curso, "Modelo de massa feito à mão Framework", operador de CUDA manuscrito completo, Modelos LLAMA2 e 3.x e Qwen2.5

Oi, olá, amigos! Eu sou o autor de Kuiperinfer. Como um curso de código aberto, Kuiperinfer ganhou 2,5 mil estrelas no Github até agora. Agora, com base no curso original, lançamos a "estrutura de inferência de modelos". O novo curso suporta a série de modelos LLAMA (incluindo a mais recente série LLAMA3.2) e QWEN2.5 de modelos, e suporta a aceleração do CUDA e a quantização INT8 , que tem sido amplamente elogiada desde o seu lançamento.

Catálogo de cursos de "estrutura de inferência de maquete feita à mão":

https://l0kzvikuq0w.feishu.cn/docx/zf2hd0xfaoaxqaxcpn2c5ohanbc

Vantagens do curso de "estrutura de inferência de máscara feita à mão"

  1. Use os mais recentes padrões C ++ 20 para escrever código, com um estilo de código unificado e bonito e bom manuseio de erros;
  2. Para um excelente gerenciamento de projetos, usamos o CMake+Git para gerenciar projetos e conectar -se com grandes empresas;
  3. Ensine as pessoas a projetar um projeto moderno de C ++ e ensine como usar testes de unidade e referência para testar e verificar seus projetos;
  4. O operador da CPU e a implementação de back -end de CUDA têm um suporte muito bom para novos modelos grandes (LLAMA3 e QWEN SERIES).

Se você estiver interessado no raciocínio de grandes modelos, deseja ter um entendimento aprofundado e dominar as tecnologias relevantes e deseja se destacar nas entrevistas de recrutamento escolar e recrutamento de outono, este curso "Big Model Inference Framework" não deve ser perdido. Venha e junte -se a nós e comece sua jornada de aprendizado juntos! Os alunos interessados são bem -vindos para digitalizar o código QR abaixo do curso ou adicionar WeChat Lyrry1997 para participar do curso

Leve você a criar uma estrutura de raciocínio de aprendizado profundo com suas próprias mãos. Siga o espaço da minha estação B para obter as últimas atualizações de vídeo.

Siga este projeto e comece com sua própria estrutura de raciocínio de aprendizado profundo do zero, você ganhará o seguinte:

  1. Aprenda o conhecimento por trás de uma estrutura de aprendizado profundo, domine os métodos de escrita, habilidades de depuração e experiência de engenharia de projetos modernos de C ++;
  2. Como projetar e escrever um diagrama de cálculo;
  3. Implementar operadores comuns, operadores de convolução, operadores de pool, operadores totalmente conectados, etc.;
  4. Com base em 3, aprenda métodos de otimização comum para acelerar a execução dos operadores;
  5. Por fim, você obterá sua própria estrutura de raciocínio, que pode raciocinar resnet, unet, yolov5, mobilenet e outros modelos, que serão de grande benefício para entrevistas e avanço do conhecimento.

Link do curso de vídeo: https://space.bilibili.com/1822828582

Contorno do curso

O segundo curso é uma versão de redefinição do primeiro curso, e o conteúdo é mais gratificante e perfeito. Veja o capítulo abaixo para o primeiro curso do curso.

Número de cursos agendar Link do curso
Palestra 1 Visualização do projeto e configuração do ambiente Terminar https://www.bilibili.com/video/bv118411f7ym
Palestra 2 Design e implementação de tensores Terminar https://www.bilibili.com/video/bv1hn411k7q7
Palestra 3 Definição de gráfico computacional Terminar https://www.bilibili.com/video/bv1vc411m7yp
Palestra 4: Construindo relacionamentos com gráficos computacionais e ordem de execução Terminar https://www.bilibili.com/video/bv19s4y1r7az
Palestra 5: Operadores e trabalhadores registrados em Kuiperinfer Terminar https://www.bilibili.com/video/bv1gx4y1o7pj
Palestra 6: Implementação de operadores de convolução e pool Terminar https://www.bilibili.com/video/bv1hx4y197ds
Palestra 7: Análise lexical e análise gramatical e implementação do operador na camada de expressão Terminar https://www.bilibili.com/video/bv1j8411o7ao
Palestra 8: A estrutura de raciocínio caseiro suporta o raciocínio das redes Resnet Terminar https://www.bilibili.com/video/bv1o84y1o7ni
Palestra 9: A estrutura de raciocínio caseiro suporta o raciocínio da rede YOLOV5 Terminar https://www.bilibili.com/video/bv1qk4y1a7xl

Efeito de demonstração

Segmentação semântica não atrevida

? Atualmente

Reproduzir o raciocínio pode se referir à demonstração em execução Kuiper no final do artigo

Detecção de alvo Yolov5

A demonstração usa diretamente os pesos pré-treinados (conjunto de dados Coco) do Yolov5-S e usa Kuiperinfer para raciocinar

Esboço do primeiro curso

Eu tenho um curso de ensino sobre Bilibili e atualmente são os 13 primeiros cursos do curso. O esboço do curso é o seguinte, a página inicial é: https://space.bilibili.com/1822828582. Todos são convidados a seguir e apoiar. A maneira de entrar no grupo de aprendizagem é mostrada no código QR na figura acima.

Número de cursos Conteúdo principal agendar Link do curso
Primeira classe Configuração geral do ambiente de interpretação e desenvolvimento da estrutura Terminar https://www.bilibili.com/video/bv1hv4y1a7h8/
Segunda lição A análise da classe Tensor Tensor e o arranjo de memória dos dados de entrada Terminar https://www.bilibili.com/video/bv1ed4y1v7gb/
A terceira lição Inicialize uma instância do tensor tensor Terminar https://www.bilibili.com/video/bv1pg411j7v5/
Lição 4 Manuscrito o primeiro operador relu e complete a aula de fábrica de registro do operador Terminar https://www.bilibili.com/video/bv1bg4y1j7sq/
Lição 5 O princípio do IM2COL e a implementação do operador de convolução Terminar https://www.bilibili.com/video/bv1f841137ct
Lição 6 Complete o operador Maxpooling desenhando um gato e desenhando um tigre Terminar https://www.bilibili.com/video/bv1m3411s7yy
Lição 7 Explicação da estrutura do gráfico (PNNX) e gráfico de cálculo preliminar Terminar https://www.bilibili.com/video/bv1vw4y1v7vp
Lição 8 Leia PNNX e construa seu próprio diagrama de cálculo Terminar https://www.bilibili.com/video/bv1hy4y1z7s3
Lição 9 A implementação do operador de convolução e o princípio do cálculo acelerado do IM2COL Terminar https://www.bilibili.com/video/bv1f841137ct
Lição 10 Explore a classe Tensor novamente, construa o relacionamento gráfico do gráfico de cálculo e pré-aloce a entrada e a saída do operador Terminar https://www.bilibili.com/video/bv1m54y1k7ag
Lição 11 Processo de execução do operador Terminar https://www.bilibili.com/video/bv1wy411c7kv
Lição 12 Use nossa estrutura de raciocínio caseiro para concluir a inferência e classificação de imagens de redes Resnet Terminar https://www.bilibili.com/video/bv1jd4y1m772
Lição 13 Apoie o raciocínio do modelo Yolov5 com uma estrutura de raciocínio caseiro Terminar https://www.bilibili.com/video/bv1xs4y1j7t2

Contribuição do projeto

Lista de colaboradores

Obrigado aos seguintes alunos por seus esforços para Kuiperinfer

  • ZJHELOFSS
  • Liuxubit
  • Azusachan
  • WFS2010
  • mlmz
  • Tigerrr07
  • ZYT1024
  • zpye
  • cmcamdy
  • Supercb
  • Sanbuphy
  • Typefloat
  • Jasmim-up
  • Perryskywalker
  • Delve-Wang
  • Z-Learner
  • Meihongtao

Como participar das contribuições do projeto?

  1. Enviar código para adicionar novos recursos ou modificar erros;
  2. Fazer sugestões particularmente úteis;
  3. Melhore a documentação ou adicione testes de unidade.

A relação entre este projeto e curso de vídeo

  • Este projeto é equivalente ao projeto a montante ou pré-pesquisa do curso

  • Cada recurso aqui pode se tornar um ponto de conhecimento no curso de vídeo, seja desenvolvido por mim ou melhorado por outros alunos.

Ambiente de tecnologia e desenvolvimento usado

  • Linguagem de desenvolvimento: C ++ 17
  • Biblioteca de Matemática: Armadillo + OpenBlas (ou Intel MKL mais rápido)
  • Biblioteca de Aceleração: OpenMP
  • Teste de unidade: teste do Google
  • Teste de desempenho: benchmark do Google

Processo de instalação (usando o Docker)

  1. Docker Pull Registry.cn-hangzhou.aliyuncs.com/hellofss/kuiperinfer:latest
  2. Sudo Docker Run -t -i Registry.cn-hangzhou.aliyuncs.com/hellofss/kuiperinfer:latest/bin/Bash
  3. Código do CD
  4. Clone Git -Recursivo https://github.com/zjhellofss/kuiperinfer.git
  5. CD Kuiperinfer
  6. Git Checkout -B Seu novo Branch estude_version_0.02 (se você deseja copiar o código do projeto, use esta etapa para alternar para estudar a tag)
  7. mkdir Build
  8. CD Build
  9. cmake -dcmake_build_type = release -ddevelopment = off ..
  10. make -j $ (nproc)

Pontas:

  1. Se você precisar desenvolver o Kuiperinfer , use o Git Clone -Recursive https://github.com/zjhellofss/kuiperinfer.git para baixar o TMP da subpasta ao mesmo tempo e definir $DEVELOPMENT ou especificar -DDEVELOPMENT=ON no arquivo cmake.
  2. Se a velocidade doméstica da Internet estiver gaguejando , use o git clone https://gitee.com/fssssss/kuiperinfergitee.git
  3. Se você deseja uma experiência de corrida mais rápida , recompile o OpenBlas ou Apt Install Intel-Mkl nativamente

Processo de instalação (Imagem do Docker de construção)

  1. Docker Build -t Kuiperinfer: mais recente.
  2. Docker Run -Nome Kuiperinfer -it Kuiperinfer: mais recente /bin /Bash
  3. CD /APP
  4. Consulte as etapas 4-10 do processo de instalação acima para o restante das etapas

Processo de instalação (o docker não é usado)

  1. Clone Git -Recursivo https://github.com/zjhellofss/kuiperinfer.git
  2. Git Checkout -B Seu novo Branch estude_version_0.01 (se você deseja copiar o código do projeto, use esta etapa para alternar para estudar a tag)
  3. Instale o ambiente necessário (recomenda-se o OpenBlas para compilar e instalar, que pode alcançar uma velocidade de execução mais rápida ou usar o APT Install Intel-Mkl em vez de OpenBlas) 
 apt install cmake, libopenblas-dev, liblapack-dev, libarpack-dev, libsuperlu-dev
  1. Baixe e compilar Armadillo https://arma.sourceforge.net/download.html
  2. Compilar e instalar o Glog Google Test Google Benchmark
  3. As etapas restantes são consistentes com o acima

Pontas:

  1. Durante o processo de compilação do Google Benchmark, se você encontrar um erro sobre o GTEST ausente, poderá desativar a opção GTEST no cmake do Google Benchmark

Execute a demonstração de Kuiper

Execute o raciocínio da UNET

Copie o endereço absoluto ou relativo da imagem Test.png na pasta tmp/unet/demo após a compilação e, em seguida, execute o programa de inferência no seguinte formato em build/demos 

./unet_test test.png unet_demo.pnnx.param unet_demo.pnnx.bin

O endereço de download do modelo PNNX: https://cowtransfer.com/s/09c7f337bab443

Se o raciocínio for bem -sucedido, você verá o resultado da divisão da imagem original na pasta unet_output.jpg.

Raciocínio para a corrida Yolov5

Modifique o seguinte código na pasta yolo_test.cpp sob a pasta demos 

 const std::string& image_path = " imgs/car.jpg " ;
const std::string& param_path = " tmp/yolo/demo/yolov5s_batch8.pnnx.param " ;
const std::string& bin_path = " tmp/yolo/demo/yolov5s_batch8.pnnx.bin " ;

  • image_path especifica o diretório de imagem, param_path é o arquivo de parâmetro do modelo, e bin_path é o arquivo de peso do modelo. Substitua -o pelo seu caminho local.

  • A definição do modelo e o endereço de download de peso são os seguintes: https://cowtransfer.com/s/9bc43e0905cb40

  • Depois que a compilação é concluída, ligue para ./build/demos/yolo_test no diretório do projeto

Operadores que foram suportados

Conceito geral: otimize gradualmente os operadores existentes; Desenvolva operadores não implementados quando necessário

  • Convolução
  • AdaptivePooling
  • Maxpooling
  • Expressão (árvore de sintaxe abstrata)
  • Achatado, vista (achatamento e deformação dimensional)
  • Sigmóide
  • HardSigmóide
  • Hardswish
  • Relu
  • Linear (multiplicação da matriz)
  • Softmax
  • BatchNorm
  • Up -upsample
  • Silu
  • Concat
  • ConvanPese

Índice

Fonte é o diretório de origem

  1. Dados/ é a implementação do tensor da classe Tensor e do método de inicialização do tensor
  2. camada/ é a implementação do operador
  3. Analisador/ é uma classe de analisador para expressões de PNNX
  4. Tempo de execução/ é a estrutura do gráfico de cálculo, análise e tempo de execução relacionados

O teste é um diretório de teste de unidade, implementando basicamente os direitos de teste de unidade do método público

O Benchmark é um benchmark do Google, que contém testes de desempenho para MobileNetv3, Resnet18 e Yolov5s.

Teste de desempenho

Equipamento de teste

15 CORE AMD EPYC 7543 (Xiaolong) Processador de 32 núcleos (Docker Container, o host tem um total de 32 núcleos)

Ambiente de compilação

GCC (Ubuntu 9.4.0-1Buntu1 ~ 20.04.1) 9.4.0

Resultados de desempenho

Demorado e executando cinco vezes consecutivo e calculado de maneira média

tamanho de entrada Nome do modelo Equipamento de computação demorado
224 × 224 lote = 8 MobileNetv3Small CPU (Armadillo + OpenBlas) 6.76ms/imagem
224 × 224 lote = 8 Resnet18 CPU (Armadillo + OpenBlas) 23.53ms/imagem
224 × 224 lote = 16 Resnet18 CPU (Armadillo + OpenBlas) 13.52ms/imagem
640 × 640 lote = 8 Yolov5nano CPU (Armadillo + OpenBlas) 78.37ms/imagem
640 × 640 lote = 8 Yolov5s CPU (Armadillo + OpenBlas) 177.54ms/imagem
640 × 640 lote = 16 Yolov5s CPU (Armadillo + OpenBlas) 134.57ms/imagem

Agradecimentos

A estrutura de raciocínio NCNN manteve o protocolo BSD da NCNN no código referenciado https://github.com/tencent/ncnn

Excelente biblioteca de matemática OpenBlas: https://github.com/xianyi/openblas

Excelente Biblioteca de Matemática Armadillo: https://arma.sourceforge.net/docs.html

CAFFE Framework que me inspira: https://github.com/bvlc/caffe

FMATH Framework: https://github.com/herumi/fmath/

Expandir
Informações adicionais
Aplicativos Relacionados
Recomendado para você
Informações Relacionadas Todos