Respostas no Fórum
- Posts
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, )
Olá! Que ótimo que conseguiu já identificar e resolver, e obrigado pelo aviso!
E quanto ao token do Hugging Face Hub, é isso mesmo, basta usar o mesmo token usado nas primeiras aulas práticas (para mais detalhes, veja a aula “Outros serviços para modelos”, da seção “LLM com LangChain”).
Mas bom saber que após a alteração funcionou corretamente, caso apareça qualquer outro erro basta postar aqui e iremos te ajudar
Olá Douglas,
Pessoalmente não conheço para essa classe específica, mas você vai encontrar imagens prontas em repositórios ou sites que disponibilizam datasets na internet, como Kaggle ou Open Images Dataset (OID), recomendo dar uma olhada em ambos pois lá você vai encontrar datasets prontos não só para sapos mas para muitas outras classes.
No OID eu encontrei aqui já: https://storage.googleapis.com/openimages/web/visualizer/index.html?type=detection&set=train&c=%2Fm%2F09ld4
E no Kaggle, basta procurar por “frog” dentro da página “datasets”. Obs: talvez seja bom durante a pesquisa especificar que se trata de detecção pois desse modo garante que seja um dataset anotado para esse objetivo.
Olá!
Você pode encontrar esse arquivo na pasta do Drive compartilhada na aula “Recursos para download”, no caso esse link aqui.
O script funcoes_desenho.py está dentro da pasta “Atualização YOLOv8”; já o vídeo mencionado se encontra dentro da pasta “videos”.
Olá Brenda! Isso mesmo, nesse contexto o processo de treinamento pode ser chamado de “Fine-tuning”, que é uma técnica onde você pega um modelo pré-treinado (como o YOLOv8) e ajusta ele para a sua tarefa específica, utilizando um conjunto de dados personalizado. Esse ajuste é feito com mais algumas rodadas de treinamento usando os seus dados, em vez de treinar o modelo do zero.
No caso do YOLOv8, o processo mostrado segue esse conceito. Para fazer isso, você só precisa dos seus dados devidamente anotados, um arquivo de configuração .yaml que descreve o dataset, e baixar o modelo pré-treinado do YOLOv8 (como yolov8m.pt, por exemplo). Depois, você carrega o modelo e inicia o treinamento com os seus dados, ajustando o modelo para a sua aplicação específica (mais detalhes são mostrados nas aulas).
