Forum Replies Created
- Posts
Olá Anderson!
Você tentou usar o comando pip install -U bitsandbytes e mesmo após reiniciar a execução não funcionou, correto?
Recomendo desinstalar e instalar a biblioteca, mas agora de outro modo usando esse comando:
python -m pip install bitsandbytes --prefer-binary --extra-index-url=https://jllllll.github.io/bitsandbytes-windows-webuiQual versão do pytorch você está usando aliás? Instalou pelo mesmo comando recomendado em aula?
Olá Rodrigo!
A escolha de hardware e software dependerá das configurações específicas e das técnicas que serão utilizadas. Se você estiver utilizando apenas o YOLO, basta seguir as configurações recomendadas pelo repositório oficial, o que geralmente é suficiente para a maioria das aplicações.
As recomendações:
Python 3.8+; PyTorch 1.10+; GPU da NVIDIA com CUDA 11.2+; 8GB+ RAM; 50GB de espaço em disco (para armazenamento do dataset e treinamento).Ter GPU é extremamente importante para rodar em tempo real. Uma RTX 3060 com 12GB tende a ser uma boa de início, se possível uma superior (16GB ou 24GB, mas depende realmente da escala e complexidade dos seus conjuntos de dados e modelos); porém, no geral, essa é recomendada pela comunidade e considerada uma ótima placa de início.
Para as câmeras, a escolha dependerá do ambiente e do tipo de aplicação. Câmeras industriais com resolução mínima de 1080p e taxas de quadros de 30 fps são ideais para detecção em tempo real. Modelos com suporte a GigE Vision ou USB 3.0 facilitam a integração em redes industriais. Se o ambiente for externo ou exigir maior durabilidade, opte por modelos com proteção IP65 ou IP67.
A infraestrutura de rede também deve ser dimensionada para garantir desempenho contínuo. Switches gerenciáveis com portas Gigabit Ethernet são recomendados para lidar com o fluxo de dados das câmeras. Caso as câmeras sejam alimentadas via PoE (Power over Ethernet), utilize switches compatíveis para simplificar a instalação.
Quanto ao software, YOLO pode ser executado pela própria biblioteca de Ultralytics, que é mostrada na última seção do curso de Detecção com YOLO. Você também consegue otimizar bastante salvando em formatos eficientes (veja aqui). Uma dica bônus seria você procurar por frameworks como DeepStream da NVIDIA, que é otimizado para aplicações industriais. Em caso de aplicações mais complexas, o uso de TensorRT pode otimizar ainda mais a inferência.
Ah sim entendi, se não funcionasse eu iria nesse caso recomendar criar um ambiente separado e fazer a instalação das bibliotecas lá
Mas que ótimo saber que já deu certo! =)
Olá Raquel!
Esse erro ocorre apenas ao executar o comando pip pro dotenv? Para todas as outras bibliotecas foi instalado com sucesso e sem erros?
A propósito, qual a versão do Python que você está usando?
Experimente rodar esse comando abaixo e me diga se funciona pra você, ou qual mensagem que ocorre
pip install -U python-dotenv
Ah sim entendo, mas sem problemas! São linguagens bem diferentes mesmo então o melhor é ir calma e no seu ritmo
Abraços
Olá, verifiquei aqui o seu código e descobri o problema, estava faltando fazer uma conversão para int nessa linha:
id = os.path.split(path)[1].split(‘.’)[0].replace(‘subject’,”)
ou seja, tem que ficar assim
id = int(os.path.split(path)[1].split(‘.’)[0].replace(‘subject’,”))
(na dúvida, pode verificar no colab da aula, nesse trecho aqui)
Após fazer esse ajuste eu rodei esse mesmo Colab que você compartilhou e funcionou aqui
Olá Elaine!
Esse erro passou a ocorrer bem recentemente devido a um bug na biblioteca pytube, que ainda não foi resolvido pelos desenvolvedores. Ele ocorre somente ao usar o parâmetro “add_video_info = True”, então caso não seja essencial obter essas informações agora pode deixar “= False” (ou não passar o parâmetro, já que esse é o valor padrão).
Um modo de tentar resolver é executar novamente a célula de código (primeiramente a anterior a essa e depois a seguinte, que é a que gerou o erro). Isso funcionou para nós algumas vezes mas parece que nem sempre está funcionando, portanto não é certeza.
Se mesmo assim o erro continuar, sugiro usar esse outro método para obter informações do vídeo de modo automático:
import requests from bs4 import BeautifulSoup def get_video_title(url): r = requests.get(url) soup = BeautifulSoup(r.text) link = soup.find_all(name="title")[0] title = str(link) title = title.replace("<title>","") title = title.replace("</title>","") return title video_url = "https://www.youtube.com/watch?v=########" video_title = get_video_title(video_url) print(video_title)Este código busca o conteúdo HTML de uma página de vídeo do YouTube usando a função requests.get() e em seguida analisa-o com a biblioteca BeautifulSoup, usado para carregar dados de páginas na internet. Ele procura a tag usando soup.find_all(), que retorna uma lista de tags correspondentes. O título do vídeo é extraído pegando o primeiro elemento, convertendo-o em uma string e, em seguida, removendo o <title> e as tags com replace(). Por fim, ele imprime o título “limpo” (se quiser também pode usar a função de replace para remover o “- YouTube” ao final do título).
Opa aqui o Colab está com acesso restrito, se puder mudar o compartilhamento para ser acessível pelo link, ou aprovar a solicitação que mandei.
Outra coisa (se quiser testar antes) é voltar uma versão do OpenCV, para mim está funcionando aqui corretamente com a versão que atribuiu automaticamente ao meu Colab, mas talvez pra você foi associado uma versão diferente e que está com algum bug ao rodar esse método. Por isso, pode tentar executar o seguinte comando no início do seu Colab (antes de todo o resto)
!pip install opencv-contrib-python==4.8.0.76
E em seguida continuar a execução do restante do código, na ordem
Olá José,
Esse erro ocorre quando é passado um parâmetro incorreto, geralmente a imagem em um formato que a função não estava esperando. Verifique se você carregou corretamente as fotos e carregou corretamente as variáveis. Cheque se todas os blocos de códigos anteriores a esse foram executados na ordem correta, e se nenhum deles gerou alguma mensagem de erro.
Eu rodei aqui o código do Colab oficial dessa seção do curso (link aqui) e para mim rodou tudo conforme o esperado. Portanto, teste novamente e verifique se foi carregado corretamente as imagens usadas para treinamento. Se o erro persistir, peço que compartilhe seu Colab aqui, já que deve ter outra coisa em seu código interferindo.
Ah sim ele consegue detectar faces com esse limiar, porém o que eu me referi na resposta anterior na verdade era quanto ao momento da gravação da aula, pois no vídeo (minuto 3:02) perceba que após mudar para essa nível de confiança nenhuma das faces exibidas na célula de saída foram detectadas, então por isso quis dizer que passou despercebido.
Olá Murilo,
Para rodar projetos com LLMs, a escolha entre essas placas depende de como você pretende usar a GPU. Na minha opinião, a RTX 3050 com mais VRAM (12GB) pode ser uma opção interessante, já que LLMs (especialmente os maiores) tendem a exigir bastante memória de vídeo para rodar de forma eficiente. No entanto, a RTX 4060 oferece uma arquitetura mais moderna, com melhor desempenho geral, apesar de ter menos VRAM.
Se seus projetos forem rodar modelos menores ou otimizados, a 4060 pode ser uma escolha mais eficiente em termos de performance. No entanto, se você planeja trabalhar com modelos maiores e precisa de mais memória para carregar os dados e o modelo, a 3050 com mais VRAM pode ser a opção mais estável. Para o uso pessoal e IA, ambos os modelos são boas opções, mas se a VRAM for uma prioridade para você, a 3050 seria mais indicada.
Além disso, eu realmente recomendo que você busque comparativos específicos entre as duas GPUs, especialmente em cenários que envolvam as tarefas que você pretende realizar, como o uso de LLMs ou outros projetos de IA. Isso vai te ajudar a visualizar o desempenho prático de cada uma em situações reais, não apenas agora, mas também em futuros projetos que possam exigir mais poder de processamento. Dessa forma, você pode evitar possíveis limitações ou decepções e escolher a placa que melhor atende às suas necessidades a longo prazo, pois podem haver vários pontos que não cogitamos aqui agora e apenas são levantados nesses comparativos.
Mas antes disso, o que você pode fazer é testar modelos menores, você pode encontrar bastante modelos de linguagem bem menores aqui: https://ollama.com/library
na aula foi usado o Phi3 que é considerado um modelo pequeno (SLM) mas mesmo assim há outros bem menores, com menos de 1 bilhão de parâmetros. Acredito que vale a pena fazer o teste antes.
Olá Wendel! Que bom que concluiu o projeto final. Quanto à lentidão que você notou na detecção facial, isso provavelmente está relacionado ao poder de processamento do seu notebook sim, especialmente ao usar a webcam integrada. Você usou para o reconhecimento a solução apresentada no curso onde é usada a biblioteca face_recognition, né? Ela é bastante precisa, mas também pode ser computacionalmente intensiva, principalmente em dispositivos com hardware mais limitado.
Seu processador e a GPU acredito que são muito bons para tarefas do dia a dia, mas quando se trata de reconhecimento facial em tempo real eles podem ter dificuldade para lidar com o processamento das imagens de forma rápida, especialmente sem otimizações. Para dispositivos embarcados, essa questão é ainda mais crítica, pois eles geralmente possuem recursos computacionais ainda mais limitados. Nesse cenário, vale a pena explorar soluções mais leves, como a otimização do código, o uso de bibliotecas mais rápidas como o Mediapipe, ou até usar redes neurais menores e mais otimizadas para dispositivos de baixo desempenho.
Para tentar otimizar com essa configuração e código que já tem, você também pode tentar ajustar alguns parâmetros para melhorar o desempenho, como reduzir o tamanho do vídeo capturado pela webcam, caso isso seja viável. Outra estratégia seria redimensionar as faces detectadas para um tamanho menor antes de processar o reconhecimento, o que pode diminuir a carga de processamento. Além disso, você pode realizar o reconhecimento facial a cada “x” frames, em vez de em todos os frames do vídeo, o que alivia significativamente o custo computacional. Mudanças como essas podem aumentar a eficiência do seu projeto sem comprometer muito a precisão.
Olá Flávio!
Boa observação, nesse caso a diferença de formato impossibilita o cálculo correto da acurácia. O problema parece ocorrer quando a face não é detectada em uma das imagens, o que faz com que um dos valores seja uma string e por isso ele precisa automaticamente salvar nesse formato, que é diferente daquele definido para a variável “previsoes”.
Creio que passou despercebido pelo fato de que com o teste usando confiança=0.3 nenhuma das faces em questão foram detectadas, então coincidentemente nesse caso deveria retornar 0 mesmo.Obrigado pela sua colaboração
Olá Murilo!
Na verdade ainda é possível continuar usando essa função nas versões mais recentes, apesar do aviso.
Mas recomendamos já alterar para esse novo método só por garantia, atualmente está na versão 0.3.x mas segundo os autores será removido na 1.0Quanto à mudança, já atualizamos no Colab, você pode conferir aqui.
O que muda basicamente são apenas alguns detalhes na sintaxe. Considerando o código dos últimos projetos, basta alterar de:
llm = HuggingFaceHub( repo_id=model, model_kwargs={ "temperature": temperature, "return_full_text": False, "max_new_tokens": 512, } )para:
llm = HuggingFaceEndpoint( repo_id=model, temperature=temperature, max_new_tokens=512, return_full_text=False, )
