Respostas no Fórum

Visualizando 15 posts - 1 até 15 (de 407 do total)
  • Autor
    Posts
  • em resposta a: Tentei usar OpenAI ao invés de Gemini e não tive sucesso #51525
    Gabriel Alves
    Moderador

      Olá Geilson! Isso ocorre nos 2 subnós do OpenAI ligados aos 2 nós ‘Supabase Vector Store’ (tanto do fluxo de indexação quanto do de agente)?

      Quando você criou sua tabela no Supabase você deixou a dimensão igual a 3072 (valor padrão que estava no comando disponibilizado) ou alterou? Usamos 3072 devido à compatibilidade com o modelo de embedding Gemini, mas para modelos da OpenAI o valor padrão é 1536. Portanto você deve criar uma tabela especificando esse valor (alterando no comando de criação de tabela, nos dois lugares onde especifica as dimensões). Uma outra opção seria manter o 3072 como já está, mas aí dentro das configurações do nó de embedding você precisa especificar as dimensões clicando no campo “Add Option” e selecionando “Dimensions”, assim:

      Se mesmo assim persistir o problema: Você consegue executar e mandar um print dos logs, que aparecem na parte inferior do painel? E também se possível abra o nó Supabase e tire print, para observar o painel de output.

      Recomendo verificar também se o nó do OpenAI roda se for conectado ao Model do AI Agent (apenas para checar que a conexão com sua conta está ok). Se funcionar, seria um problema com o nó de embeddings somente.

      em resposta a: Sobre o Projeto 1 #51194
      Gabriel Alves
      Moderador

        Olá Paulo!

        Qual erro está dando para você? Se estiver carregando o modelo pelo Hugging Face Hub (método “HuggingFaceEndpoint”) pode ser instabilidade no servidor, ou algum problema ao carregar com sua key.

        Uma dica que temos recomendado recentemente é implementar a LLM com o serviço da Groq, que disponibiliza o Llama 4 e outros modelos modernos via API de forma gratuita também. A única linha que precisa alterar é a que chama o método da LLM. Você deve então substituir esse método do Hugging Face por: llm = ChatGroq(model=”llama-3.3-70b-versatile”, temperature=0.7, max_tokens=None, timeout=None, max_retries=2)

        e antes de executar essa linha acima você precisa:

        * instalar o langchain-groq, usando o comando !pip install -q langchain-groq

        * fazer a importação com from langchain_groq import ChatGroq

        * adicionar a Key do Groq às variáveis de ambiente, com esse comando os.environ[“GROQ_API_KEY”] = getpass.getpass()

        e aí no campo que aparecer você cola a key

         

        Para criar API do Groq​

        1) Acesse: https://groq.com ​ -> clique em DEV CONSOLE (menu do topo)

        2) Crie sua conta. Você pode criar/logar com sua conta Google, para ser mais prático​

        3) Após o login, no menu lateral acesse API Keys https://console.groq.com/playground

        4) E clique no botão ‘Create API Key​’

        Aqui você pode escolher qualquer nome.​

        Após criar, clique no botão Copy para copiar a chave e salve em um local seguro

         

        Modelos disponíveis pelo Groq https://console.groq.com/docs/rate-limits (ver os gratuitos – dentro da aba free tier)

         

        Quanto ao código com Streamlit, deixei aqui ao final do Colab https://colab.research.google.com/drive/1jul2su9c7QGJSzpe9D0T3kZB8FxWeFfg#scrollTo=g9yi7myGxHXW

        em resposta a: Erro #50924
        Gabriel Alves
        Moderador

          Olá! Fica apenas uma tela de carregando, sem aparecer nenhuma mensagem de erro? Pelo que você descreveu pode ser alguma instabilidade no localtunnel, há alguns relatos dizendo que desde sexta os servidores se encontram instáveis.

          Como alternativa, você pode ou executar localmente (conforme demonstrado na aula “Execução local 1”, da seção “Marketing”) ou continuar executando pelo Colab mas usando o ngrok ao invés do localtunnel. Para saber como fazer isso veja a aula “Aviso sobre uso no Colab”, que adicionamos logo antes da aula “Interface com Streamlit”, dentro da seção de Marketing (link aqui).

          Em breve adicionaremos uma aula gravada, mas pela aula de texto já é possível conseguir realizar tudo o que precisa para implementar no ngrok direto pelo Colab!

          Quanto à parte do agente, acho que é mais fácil se basear direto no Colab da seção pois lá tem todas as alterações recentes da biblioteca (acesse  https://colab.research.google.com/drive/1U4UexvWpa93yPZtRHxWnco0Nk5mFTmwV)

          Se ocorrer algum erro durante a execução, peço que por favor me informe qual a mensagem apareceu e a linha de código que deu o erro

          em resposta a: Erro #50910
          Gabriel Alves
          Moderador

            Olá Elisabeth! Que bom, se ainda ficou alguma dúvida basta avisar aqui no tópico

            em resposta a: Detecção de descritores faciais #50667
            Gabriel Alves
            Moderador

              Olá Elisabeth!

              Este problema se deve a uma incompatibilidade recente entre o dlib e a versão CUDA atribuída no Colab, parece que até o momento não há uma solução oficial (e também tentamos alterar a versão CUDA da instância do Colab, porém atualmente parece que não é mais permitido). Estamos tentando encontrar uma alternativa para que a função funcione corretamente sem essas mensagens. Como alternativa, você tem algumas opções:

              1) Executar em sua máquina local. Você pode usar o mesmo código, apenas certifique-se de instalar as bibliotecas necessárias antes de rodar. Recomendamos o uso do Jupyter Notebook para que você possa reutilizar o notebook fornecido na aula.

              2) Usar outra técnica de reconhecimento facial, como por exemplo o LBPH (que foi mostrado nessa seção do curso).

              3) Usar o Kaggle em vez do Colab. Para isso, faça o seguinte:

              * Acesse os Notebooks do Kaggle (link). Faça login ou cadastre-se rápido caso não tenha uma conta.

              * Clique em “New Notebook”

              * Selecione File > Import Notebook  (se não encontrar a opção, veja essa imagem) 

              * Selecione o arquivo .ipynb nos materiais da aula (ou baixe-o diretamente clicando em Arquivo > Fazer Download > Baixar o .ipynb , dentro do Colab da aula).

              * Arraste e solte o arquivo .ipynb e clique em Importar.

              Como alternativa, você pode usar a biblioteca face_recognition, que oferece funcionalidade semelhante (repositório do GitHub), ou o DeepFace, outra opção ótima (repositório).

              em resposta a: ExpatError ao carregar infos do video do youtube no projeto1 #50543
              Gabriel Alves
              Moderador

                Olá Aline!

                Para evitar esse erro, ao invés de executar esses códigos:

                video_loader = YoutubeLoader.from_youtube_url("https://www.youtube.com/watch?v=II28i__Tf3M", language = ["pt", "pt-BR", "en"],)
                infos = video_loader.load()
                transcricao = infos[0].page_content

                Use esse código abaixo:

                from youtube_transcript_api import YouTubeTranscriptApi
                from youtube_transcript_api.formatters import TextFormatter
                
                # ID do vídeo do YouTube. Verifique pela URL, é o que vem logo após /watch?v=
                id_video = "II28i__Tf3M"
                
                # Busca a transcrição, tentando em português e inglês
                result = YouTubeTranscriptApi().fetch(id_video, languages=["pt", "pt-BR", "en"])
                
                #Formata a transcrição como texto
                formatter = TextFormatter()
                transcricao = formatter.format_transcript(result)
                
                # opcional: Substitui quebras de linha por espaços para manter tudo em uma só linha (Se não quiser isso, remova essa linha abaixo)
                transcricao = transcricao.replace('\n', ' ')
                print(transcricao)
                

                Importante: para isso é necessário que use pelo menos a versão 1.1.0 do youtube-transcript-api, o que pode ser garantido executando esse comando antes dos imports em seu código: !pip install youtube-transcript-api==1.1.0

                (tudo isso já está atualizado no Colab dessa seção, pode conferir aqui se preferir)

                 

                Recentemente, o YouTube passou a exigir o uso de um novo tipo de token, o que afeta diretamente bibliotecas que dependem da API de transcrição, como a youtube-transcript-api (mais detalhes aqui). Para lidar com isso, é necessário utilizar uma versão atualizada dessa biblioteca.

                Porém, a biblioteca Langchain ainda não é compatível com a nova versão da youtube-transcript-api. Internamente, o YoutubeLoader do Langchain utiliza essa biblioteca, mas está vinculado a uma versão anterior, o que leva a erros de execução ao tentar obter a transcrição de vídeos recentes. Até o momento, a equipe do Langchain ainda não anunciou uma previsão de atualização para resolver essa incompatibilidade.

                Por esse motivo nós decidimos achar um modo de implementar o processo de forma direta, utilizando os métodos da própria biblioteca youtube-transcript-api, o que nos permite maior controle e compatibilidade com a versão mais recente.

                Além disso, utilizamos a classe TextFormatter, que ajuda a extrair a transcrição limpa, sem timestamps ou metadados (somente o texto). Para tornar o texto ainda mais fluido, como adicional nós removemos as quebras de linha (\n), unificando toda a transcrição em um único bloco contínuo, igual como é obtido quando usava pelo método YoutubeLoader do Langchain.

                em resposta a: Proteger dados Proprietários (RAG) #50491
                Gabriel Alves
                Moderador

                  Disponha, Douglas!

                  Abraço!

                  em resposta a: Proteger dados Proprietários (RAG) #50435
                  Gabriel Alves
                  Moderador

                    Olá Douglas! tudo bem? Primeiramente, obrigado pelo elogio ao curso, que bom que esteja aproveitando =)

                    Sobre sua dúvida: proteger dados sensíveis em soluções com RAG é uma preocupação bem válida, é totalmente possível isolar e proteger esses dados tomando algumas medidas importantes.

                    Primeiro, é fundamental entender que os dados usados na etapa de recuperação (retrieval) ficam sob seu controle, normalmente armazenados em bancos vetoriais como Chroma, Pinecone, entre outros. Eles não são enviados ou incorporados ao modelo base, a menos que você explicitamente envie esse conteúdo para uma API de terceiros sem cuidados. Mas, para uma camada a mais de segurança, prefira banco de dados que rodem totalmente em ambiente local e não na nuvem (as soluções mais conhecidas cloud na verdade são seguras, então aqui tem que avaliar se está disposto a perder velocidade de resposta por uma camada a mais de segurança).

                    Sobre a ideia de que “a IA pode usar seus dados com outros usuários”, isso não é verdade se você estiver usando o modelo corretamente em ambiente privado. Modelos de empresas sérias como OpenAI ou Google geralmente não utilizam os dados das requisições para treinar ou compartilhar outputs, desde que esteja desabilitado o uso para treinamento (o que é o padrão e desejado em ambientes corporativos e APIs pagas). Mas se você usar interfaces públicas ou APIs gratuitas sem configurar isso, aí sim existe esse risco. É bom checar as páginas de políticas e termos de uso dessas provedoras de LLMs.

                    Então, para proteger seus dados sensíveis, se o modelo for via API certifique-se que uso de dados para treinamento esteja desativado.

                    Alguns especialistas também não acham tão seguro usar APIs mesmo que esteja desabilitado isso, digamos que nós “temos que confiar” que as empresas não usarão esses dados para treinamento. Mas caso queira um modo totalmente seguro e mais controlável então vai precisar rodar o LLM localmente, com modelos como Llama, DeepSeek ou outros open source. Desse modo, seus dados não são processados em um servidor externo, será tudo processado em ambiente local (e por esse motivo inclusive pode ser usado sem necessidade de conexão com a internet). Note que para isso será necessário um ótimo hardware, ou usar modelos mais eficientes, como por exemplo Small Language Models (SLM) ou modelos quantizados.

                    em resposta a: Não carrega as multiplas imgens #50326
                    Gabriel Alves
                    Moderador

                      Olá Jefferson!

                      Isso ocorre pois em versões recentes da biblioteca Pillow esse atributo “ANTIALIAS” (que foi usado nesse código criado para exibir imagens em grid) foi descontinuado. Você tem duas maneiras de resolver:

                      Solução 1: (É a que eu recomendo) Simplesmente alterar no código de Image.ANTIALIAS para Image.LANCZOS   – que irá exibir a imagem e funcionar do mesmo modo.

                      Se desejar pode conferir aqui o Colab atualizado, é necessário apenas essa pequena mudança.

                      Solução 2: Fazer o downgrade da biblioteca Pillow; para isso pode usar esse comando antes de executar o restante do código: !pip install Pillow==9.5.0

                      em resposta a: projeto 3 não funciona #50308
                      Gabriel Alves
                      Moderador

                        Olá! Infelizmente esses erros podem acontecer, conforme mencionado o LangChain é um ótimo framework mas algumas atualizações podem quebrar certas funcionalidades. Essa em questão é devido a uma alteração recente na API. Mas vamos te ajudar sim.

                        Essa versão do Python não parece ser incompatível, mas em último caso (se o que vou mencionar abaixo não resolver) eu sugiro testar com a 3.11.x ou até a 3.12.x, já que apresenta menos possibilidade de erros.

                        Primeiro, baixe o script atualizado presente no Drive compartilhado na introdução, esse link aqui.

                        Se o erro persistir, adicione esse trecho de código no início de seu arquivo .py

                        import os 
                        
                        import torch 
                        
                        import streamlit 
                        
                        torch.classes.__path__ = [os.path.join(torch.__path__[0], torch.classes.__file__)] 
                        
                        # ou simplesmente: 
                        
                        torch.classes.__path__ = []

                         

                        Imagino que isso deva resolver. Mas caso persista me avise, e poste aqui o erro atualizado.

                        Você também pode estar testando pelo Colab da seção, acabei de testar e está funcionando ok.

                        em resposta a: teste1.py não funciona mais #50307
                        Gabriel Alves
                        Moderador

                          Olá Eduardo!

                          Parece ser uma limitação recente nos servidores do Hugging Face, que especificamente está com problemas para rodar os modelos Llama 3 publicados no repositório, mesmo o modelo oficial publicado pela Meta. Ainda não houve uma solução oficial pela equipe responsável pela biblioteca, então recomendo não usar por enquanto o Hugging Face Hub para o Llama 3. Nós estamos terminando de criar uma aula de aviso para colocar no curso, já que está causando essa confusão.

                          Para usar o modelo Phi 3 por exemplo, faça assim:

                          from langchain_huggingface import HuggingFaceEndpoint
                          
                          # Exemplo com Hugging Face
                          llm = HuggingFaceEndpoint(
                              repo_id="microsoft/Phi-3-mini-4k-instruct",
                              temperature = 0.1,
                              return_full_text = False,
                              max_new_tokens = 1024,
                              task="text-generation"
                          )
                          
                          system_prompt = "Você é um assistente prestativo e está respondendo perguntas gerais."
                          user_prompt = "{input}"
                          
                          token_s, token_e = "<|system|>", "<|end|><|assistant|>"
                          
                          prompt = ChatPromptTemplate.from_messages([
                              ("system", token_s + system_prompt),
                              ("user", user_prompt + token_e)
                          ])
                          
                          chain = prompt | llm
                          
                          input = "Explique para mim em até 1 parágrafo o conceito de redes neurais, de forma clara e objetiva"
                          
                          res = chain.invoke({"input": input})
                          print(res)

                           

                          Veja aqui o arquivo teste1.py atualizado, acabei de testar e está funcionando.

                           

                          Por enquanto, estamos recomendando implementar o Llama (e outros modelos ainda mais modernos) com o serviço da Groq. Esse provedor disponibiliza o Llama 4 e outros modelos modernos via API de forma gratuita também, inclusive o plano grátis tem uma quota ainda mais generosa. A única linha que precisa alterar é a que chama o método da LLM. Você deve então substituir esse método do Hugging Face por:

                          llm = ChatGroq(model="llama3-70b-8192", temperature=0.7, max_tokens=None, timeout=None, max_retries=2)

                          e antes de executar essa linha acima você precisa:

                          * instalar o langchain-groq, usando o comando !pip install -q langchain-groq

                          * fazer a importação com from langchain_groq import ChatGroq

                          * adicionar a Key do Groq às variáveis de ambiente, com  os.environ[“GROQ_API_KEY”] = getpass.getpass()

                          (ou, adicionando GROQ_API_KEY=SUA_CHAVE_AQUI   – dentro do .env)

                           

                          Para criar API do Groq​

                          1) Acesse: https://groq.com ​ -> clique em DEV CONSOLE (menu do topo)

                          2) Crie sua conta. Você pode criar/logar com sua conta Google, para ser mais prático​

                          3) Após o login, no menu lateral acesse API Keys https://console.groq.com/playground

                          4) E clique no botão ‘Create API Key​’

                          Aqui você pode escolher qualquer nome.​

                          Após criar, clique no botão Copy para copiar a chave e salve em um local seguro

                           

                          Modelos disponíveis pelo Groq https://console.groq.com/docs/rate-limits (ver os gratuitos – dentro da aba free tier)

                          em resposta a: Erro na detecção de faces com Mmod #50196
                          Gabriel Alves
                          Moderador

                            Olá! Você está executando direto no Colab mesmo, isso?

                            Verifique se você selecionou para usar GPU ao invés de CPU, para conferir acesse o menu do topo: Ambiente de execução > Alterar o tipo de ambiente de execução.

                            Este erro que você mostrou também pode ocorrer quando o módulo do driver de vídeo em execução não corresponde à versão da biblioteca CUDA no disco, ou quando não é compatível com o dlib. Atualizar o driver da placa de vídeo pode resolver este problema.

                            Uma alternativa seria executar o dlib na CPU. Ou, se você quiser executar em sua máquina local em vez do Colab, também seria uma solução, pois evitará este erro que apareceu para você. Para rodar na CPU, pode usar esse comando de instalação abaixo:

                            !pip uninstall dlib
                            !sudo pip install -v –install-option=”–no” –install-option=”DLIB_USE_CUDA” dlib

                            em resposta a: problemas com a chamada “cv2.waitKey()” #49528
                            Gabriel Alves
                            Moderador

                              Ah sim entendo, bom saber que pelo menos funciona em ambiente local. No Colab podem ocorrer alguns erros de incompatibilidade como esse que você comentou, porém (quando não é um bug na sessão) geralmente se resolve executando aqueles comandos que te passei. Você tentou eles e continuou aparecendo o mesmo erro?

                              Caso seja viável, pode compartilhar aqui o seu Colab? Assim consigo verificar melhor, já que podem haver outros comandos ou códigos que poderiam estar interferindo também

                              em resposta a: problemas com a chamada “cv2.waitKey()” #49494
                              Gabriel Alves
                              Moderador

                                Olá! Você está executando localmente ou pelo Colab?

                                Este erro pode ser resolvido desinstalando o OpenCV e instalando-o novamente. É mais garantido que seja resolvido se você instalar a biblioteca com contrib. Então, desinstale

                                !pip uninstall opencv-python

                                e instale (agora com +contrib)

                                pip install opencv-contrib-python

                                se você estiver rodando localmente e no Linux, pode ser necessário executar também este comando

                                sudo apt-get install libgtk2.0-dev pkg-config

                                ou, se não funcionar, tente isto:

                                sudo apt-get install cmake cmake-curses-gui libgtk2.0-dev
                                em resposta a: INPAINTING #49040
                                Gabriel Alves
                                Moderador

                                  Que bom! Disponha

                                Visualizando 15 posts - 1 até 15 (de 407 do total)