C.I.I.A.

Associação de Investigação e Inovação

LOGÓTIPO

versão 19out24

A equipa da C.I.I.A. é formada por profissionais capacitados e consagrados nas suas disciplinas. Muitos dos nossos docentes também têm formação complementar em estratégias alternativas de aprendizagem.

Um assistente virtual é um trabalhador autónomo especializado em oferecer serviços administrativos a clientes de um local remoto, geralmente um serviço público cujos clientes são os habitantes da cidade, por exemplo.

As tarefas típicas que um assistente virtual pode realizar incluem agendar compromissos, fazer ligações, organizar roteiros, prestar informações sobre projetos em curso e gerir contas de e-mail.

Alguns assistentes virtuais são especializados em oferecer serviços de design gráfico, redação de blogs, contabilidade, redes sociais e marketing.

Para uma organização pública ou privada, uma vantagem de contratar um assistente virtual é a flexibilidade de contratar apenas os serviços de que necessita.

TAGLINE

RECURSOS

Portugal à procura do seu "ESPAÇO"

Agência Espacial Portuguesa quer levar para a ilha de Santa Maria o Space Rider, um vaivém europeu que faz experiências com microgravidade, aproveitando o aeroporto daquela ilha.

“O Space Rider é um laboratório de microgravidade”, que permite “desenvolver novos produtos e sistemas”.

As experiências feitas com este vaivém vão, por exemplo, “transformar completamente a indústria farmacêutica”, já que permitem “fazer novos produtos de uma forma mais rápida”.

“Isso exige que, onde o Space Rider aterra, tem de haver laboratórios das empresas farmacêuticas”, acrescenta o responsável pela tutela; “trazer o Space Rider não é apenas usar um aeroporto magnífico e uma localização magnífica, é também trazer novas pessoas e criar empregos aqui em Santa Maria”.

Na página na internet da Portugal Space, esclarece-se que se trata de um veículo que permite “o acesso e retorno de cargas úteis para e do Espaço, possibilitando a investigação e desenvolvimento de novos produtos em ambiente de microgravidade”.

Este é, por isso, um projeto que “depende, em grande medida, da capacidade de ligar os sectores espaciais e não espaciais”.

Santa Maria surge como um local de desembarque para este sistema da Agência Espacial Europeia, “que permitirá à Europa ter um transporte viável para operações espaciais para e do Espaço, garantido à indústria europeia a capacidade de abrir novos mercados”, lê-se no ‘site’ da agência espacial portuguesa.

O impacto das ferramentas de IA na experiência dos participantes em workshops de programação:

Ferramentas de IA como o ChatGPT têm benefícios significativos para os participantes: permitem que se trabalhe de forma construtiva de acordo com a sua própria programação e fornecem uma maneira fácil de pedir ajuda. No entanto, antes que estas ferramentas possam ser introduzidas de forma que exprima com clareza, expressiva, eloquente, num seminário ou workshop, o seu impacto na capacidade de aprendizagem do aluno, cada um deve ser avaliado e serem abordadas as preocupações que conduzam a menores competências de programação.

Realizamos um estudo preliminar para compreender as experiências de estudantes do ensino superior ao aprender a programar usando ferramentas de IA.

Os participantes são solicitados a realizar tarefas de programação sob uma das três condições:

· Sem ajuda externa

· Com a ajuda de um chatbot de IA

· Com a ajuda de uma ferramenta generativa de IA como GitHub Copilot

A nossa série de workshops de 2024 tem como tema o ensino de programação (com ou sem IA). Nesta atividade, exploramos as pesquisas mais recentes sobre como os professores podem apoiar melhor os alunos em idade escolar (ou não) no desenvolvimento das suas habilidades de programação.

Atualmente, tem havido muito interesse acerca do recurso ao ChatGPT (inteligência artificial generativa). Na engenharia de “prompt,” escolhemos os formatos, frases, palavras e símbolos mais adequados para orientar a IA a interagir com os seus utilizadores de forma mais significativa.

Linguagem PYTHON

versão 06abr24

Uma das características de um(a) engenheiro(a) é a capacidade para resolver problemas técnicos. A resolução deste tipo de problemas envolve uma combinação de arte e ciência. Por ciência  entende-se um conhecimento dos princípios matemáticos, físicos e dos aspetos técnicos que têm de ser bem compreendidos, para que sejam aplicados corretamente. Por arte entende-se a avaliação correta, a experiência, o bom senso e o conhecimento que permitem representar um problema do mundo real por um modelo ao qual o conhecimento técnico pode ser aplicado para produzir uma solução.

A engenharia da computação utiliza os fundamentos da engenharia eletrotécnica e aplica-os especificamente aos computadores, concentrado-se no projeto de componentes de hardware e software. A engenharia computacional tem por objetivo formar profissionais com sólida preparação em física, matemática e informática, capazes de desenvolver e utilizar software que estude, modele e simule fenómenos naturais. A engenharia informática difere das engenharias tradicionais, no sentido em que trabalha com entidades imateriais. Ao passo que as engenharias tradicionais lidam com forças físicas, diretamente mensuráveis (por exemplo, a gravidade, os campos elétricos e magnéticos) e com objetos materiais que interagem com essas forças (por exemplo rodas dentadas, vigas, circuitos), a engenharia informática lida com entidades intangíveis que apenas podem ser observadas indiretamente através dos efeitos que produzem.

A engenharia informática tem como finalidade a concepção e realização de abstrações ou modelos de entidadesabstratas que, quando utilizadas por um computador, fazem com que este apresente um comportamento que corresponde à solução de um dado problema.

Por informação entende-se qualquer coisa que pode ser transmitida ou registada e que tem um significado associado à sua representação simbólica. Uma das características que distinguem o computador de outras máquinas que lidam com informação é o facto de este poder manipular a informação, para além de a armazenar e transmitir. A manipulação da informação levada a cabo pelo computador segue uma sequência de instruções a que se chama um programa.

Um dos objetivos da informática corresponde ao estudo e desenvolvimento de entidades abstratas durante a execução de programas - os processos computacionais.

Um processo computacional é um ente imaterial pode afetar objetos existentes no mundo real (por exemplo, guiar a aterragem de um avião, distribuir dinheiro em caixas MB, comprar e vender ações na bolsa), pode responder a perguntas num "assistente virtual" existente no átrio da Câmara Municipal, responder à nossa pergunta colocada num motor de busca da internet, etc.etc.etc.

A programação é uma atividade intelectual fascinante, que não é tão difícil como alguns apregoam, mas que requer muita disciplina. Utiliza muitas atividades e técnicas que são comuns em projetos de vários ramos de engenharia e ciências sociais:

· a compreensão do problema;

·  a separação entre a informação essencial ao problema e a informação acessória;

· a criação de especificação pormenorizadas para o resolver;

·  a verificação e os testes.

A tarefa de programação corresponde a dividir um problema grande e complexo em vários sub-problemas, cada vez mais simples e mais concentrados que podem ser expressos em termos de operações elementares.

A análise do sistema é uma revisão de um sistema tecnológico, como um pacote de software, para fins de encontrar solução de problemas, desenvolvimento ou melhoria. Através de análises aprofundadas, os analistas podem descobrir erros no código, problemas de acessibilidade para os utilizadores finais ou incompatibilidades de design/projeto.

O que é um algoritmo?

Um algoritmo é um procedimento usado para resolver um problema ou realizar um cálculo. Os algoritmos atuam como uma lista exata de instruções que conduzem diversas ações específicas passo a passo em rotinas baseadas em hardware ou software.

Algoritmos são amplamente utilizados em todas as áreas de computação/informática. Em matemática, programação de computadores e ciência da computação, um algoritmo geralmente refere-se a um pequeno procedimento que resolve um problema recorrente. Algoritmos também são usados ​​como especificações para realizar o processamento de dados e desempenham um papel importante em sistemas automatizados.

Um algoritmo pode ser usado para classificar conjuntos de números ou para tarefas mais complicadas, como recomendar o conteúdo de um utilizador nas redes sociais. Os algoritmos normalmente começam com entradas iniciais e instruções que descrevem um cálculo específico. Quando a computação é executada, o processo produz uma saída.

Como funcionam os algoritmos?

Os algoritmos funcionam seguindo um conjunto de instruções ou regras para concluir uma tarefa ou resolver um problema. Podem ser expressos como linguagens naturais, linguagens de programação, pseudocódigo, fluxogramas e tabelas de controlo. Expressões em linguagem natural são raras, pois são mais ambíguas. Linguagens de programação são normalmente usadas para expressar algoritmos executados por um computador.

Os algoritmos usam uma entrada inicial junto com um conjunto de instruções. A entrada são os dados iniciais necessários para a tomada de decisões e podem ser representados na forma de números ou palavras. Os dados de entrada são submetidos a um conjunto de instruções, ou cálculos, que podem incluir processos aritméticos e de tomada de decisão. A saída é a última etapa de um algoritmo e normalmente é expressa como "mais dados".

Por exemplo, um algoritmo de pesquisa agarra numa consulta de pesquisa como entrada e executa essa pesquisa por meio de um conjunto de instruções para pesquisar numa base de dados, itens relevantes para a consulta. O software de automação atua como outro exemplo de algoritmos, pois a automação segue um conjunto de regras para concluir tarefas. Muitos algoritmos constituem softwares de automação e todos funcionam para automatizar um determinado processo.

Quais são os diferentes tipos de algoritmos?

Existem vários tipos de algoritmos, todos projetados para realizar tarefas diferentes:

·  Algoritmo do mecanismo de pesquisa. Este algoritmo usa sequências de pesquisa de palavras-chave e operadores como entrada, pesquisa na sua base de dados associada páginas da web relevantes e retorna resultados.

·  Algoritmo de criptografia. Este algoritmo de computação transforma os dados de acordo com ações específicas para protegê-los. Um algoritmo de chave simétrica, como o Data Encryption Standard, por exemplo, usa a mesma chave para criptografar e descriptografar dados. Se o algoritmo for suficientemente sofisticado, ninguém sem a chave poderá descriptografar os dados.

·  Algoritmo ganancioso. Este algoritmo resolve problemas de otimização encontrando a solução localmente ótima, esperando que seja a solução ótima em nível global. No entanto, não garante a solução ideal.

·  Algoritmo recursivo. Este algoritmo chama a si mesmo repetidamente até resolver um problema. Algoritmos recursivos chamam a si mesmos com um valor menor toda vez que uma função recursiva é invocada.

·  Algoritmo de retrocesso. Este algoritmo encontra uma solução para um determinado problema em abordagens incrementais e resolve-o (uma parte de cada vez).

·  Algoritmo de dividir e conquistar. Este algoritmo comum é dividido em duas partes. Uma parte divide um problema em subproblemas menores. A segunda parte resolve esses problemas e depois vai combina-los para produzir uma solução.

·  Algoritmo de programação dinâmica. Este algoritmo resolve problemas dividindo-os em subproblemas. Os resultados são então armazenados para serem aplicados em futuros problemas correspondentes.

·  Algoritmo de força bruta. Este algoritmo vai faze iterações cegamente, na procura de todas as soluções possíveis para um problema, procurando uma ou mais soluções para uma função.

·  Algoritmo de classificação. Algoritmos de classificação são usados ​​para reorganizar estruturas de dados com base num operador de comparação, que é usado para decidir uma nova ordem para os dados.

·  Algoritmo aleatório. Este algoritmo reduz os tempos de execução e as complexidades baseadas no tempo. Usa elementos aleatórios como parte de sua lógica.

·  Algoritmo de hash. Este algoritmo pega nos dados e converte-os numa mensagem uniforme com hash.

Para que serve o hash?

Recuperação de dados - Hashing usa funções ou algoritmos para mapear dados de objetos para um valor inteiro representativo. Um hash pode então ser usado para restringir pesquisas ao localizar esses itens no mapa de dados do objeto.

Por exemplo, em tabelas hash, os desenvolvedores armazenam dados – que pode ser um registo de cliente – na forma de pares de chave e valor. A chave ajuda a identificar os dados e funciona como uma entrada para a função hash, enquanto o código hash ou o inteiro é então mapeado para um tamanho fixo.

As tabelas hash suportam funções que incluem o seguinte:

inserir (chave, valor)

pegar (chave)

excluir (chave)

Exemplos de algoritmos?

A aprendizagem automática (ML) é um bom exemplo de algoritmo, pois usa vários algoritmos para prever resultados sem ter sido explicitamente programado para o fazer.

A aprendizagem automática usa aprendizagem supervisionada ou aprendizagem não supervisionada. Na aprendizagem supervisionada, os cientistas de dados fornecem algoritmos complexos com dados de treino rotulados e definem as variáveis ​​que desejam que o algoritmo seja capaz de avaliar em busca de correlações. Tanto a entrada quanto a saída do algoritmo são especificadas. A aprendizagem automática não supervisionada envolve algoritmos que treinam com dados não rotulados e os examinam em busca de padrões que possam ser usados ​​para agrupar pontos de dados em subconjuntos. A maioria dos tipos de aprendizagem profunda, incluindo redes neuronais, são algoritmos não supervisionados.

A aprendizagem automática usada na inteligência artificial também depende de algoritmos. No entanto, os sistemas baseados em aprendizagem automática podem ter preconceitos inerentes aos dados que alimentam o algoritmo de aprendizagem automática. Isso pode resultar em sistemas não confiáveis ​​e potencialmente prejudiciais.

Embora os algoritmos sejam amplamente usados ​​em cenários de ciência da computação, IA e aprendizagem automática (ML), também são empregados com frequência na vida cotidiana.

A seguir estão alguns exemplos de algoritmos usados ​​na vida real:

·  Seguindo uma receita. As receitas fornecem uma série de etapas para atingir um objetivo específico, como preparar pudins de mirtilo ou fazer molho de espaguete a partir do zero. As receitas visam produzir resultados consistentes e ajudar os indivíduos - independentemente da sua formação - a criar um prato específico seguindo instruções detalhadas. Dessa forma, as receitas refletem algoritmos da ciência da computação, que descrevem etapas para gerar resultados reprodutíveis.

·  Atar cordões é outro exemplo de como seguir um algoritmo. Por exemplo, há um número finito de etapas que levam a um nó de cordão tradicional devidamente amarrado, que é frequentemente chamado de nó ou "laçar, mergulhar e puxar".

·  Reconhecimento facial. O reconhecimento facial é amplamente utilizado em logins do iPhone, bem como em filtros do Snapchat e Instagram. Funciona projetando traços faciais de uma foto ou vídeo num mapa biométrico usando um algoritmo.

O programa então procura uma correspondência entre este mapa e uma base de dados de rostos para confirmar a identificação do utilizador. Se o reconhecimento facial for usado para filtros do Snapchat ou Instagram, não há necessidade de pesquisar na base de dados porque o algoritmo simplesmente constrói um mapa do rosto e aplica-lhe o filtro.

·  Sinais de trânsito. Os sinais de trânsito usam algoritmos inteligentes para gerir o fluxo de tráfego. Esses algoritmos agrupam diferentes algoritmos ou movimentos, como seguir em frente ou virar à direita, em fases, o que ajuda a garantir segurança e eficiência. Por exemplo, quando um motorista se aproxima de um sinal vermelho, o semáforo passa por essas fases. Ao avaliar o volume de tráfego, um algoritmo decide quando é seguro para o veículo avançar.

·  Separação de documentos e papéis. Este é um ótimo exemplo de como algoritmos podem ser usados ​​para diversas tarefas e propósitos, como classificar arquivos por ordem alfabética, por contagem de palavras, por data ou por quaisquer outras especificações. Quando alguém organiza os seus documentos pessoais ou profissionais de acordo com um conjunto de instruções, está a aplicar o pensamento algorítmico para simplificar o processo de organização por meio de pequenas tarefas.

·  Procurar um livro na biblioteca. Encontrar um livro na biblioteca é como seguir um algoritmo ou um plano passo a passo. Por exemplo, existem diferentes formas de fazer isso, como utilizar o sistema de informática da biblioteca ou procurar nas estantes etiquetas que indiquem o género, assunto ou autor do livro. Não importa qual método escolher, se puder ser explicado e feito por outros, então pode ser classificado como um algoritmo.

Python é o quê ?

Python é uma linguagem de programação popular. Foi criado por Guido van Rossum e lançado em 1991.

É usado para:

· desenvolvimento web (lado do servidor),

· desenvolvimento de software,

· matemática,

· script do sistema.

O que pode fazer o Python ?

· Python pode ser usado num servidor para criar aplicativos web.

· Python pode ser usado junto com outro software para criar fluxos de trabalho.

· Python pode-se conectar a sistemas de banco (base) de dados. Também pode ler e modificar arquivos.

· Python pode ser usado para lidar com big data e realizar operações de matemática complexa.

· Python pode ser usado para prototipagem rápida ou para desenvolvimento de software pronto para produção.

Python Porquê ?

· Python funciona em diferentes plataformas (Windows, Mac, Linux, Raspberry Pi, etc).

· Python possui uma sintaxe simples semelhante à da língua inglesa.

· Python possui sintaxe que permite aos desenvolvedores escrever programas com menos linhas do que algumas outras linguagens de programação.

· Python é executado num sistema interpretador, o que significa que o código pode ser executado assim que for escrito. Isso significa que a prototipagem pode ser muito rápida.

· Python pode ser tratado de forma processual, orientada a objetos ou funcional.

É bom saber que:

A versão principal mais recente do Python é o Python 3, que usaremos neste tutorial. No entanto, o Python 2, embora não seja atualizado para além de atualizações de segurança, ainda é bastante popular.

INSTALAR a linguagem PYTHON (1)

------------------------------------------------------------------------------------------------------------------------------------------------------------

Instalação

Normalmente, o pip é instalado automaticamente se o programador:

trabalhar num ambiente virtual e estiver a usar Python que foi baixado de python.org

Métodos Suportados

Se o seu ambiente Python não tiver o pip instalado, existem 2 mecanismos para instalar o pip suportados diretamente pela equipa de manutenção do pip (pip é um sistema de gestão de pacotes padrão de facto, usado para instalar e gerir pacotes de software escritos em Python. Muitos pacotes podem ser encontrados na fonte padrão para pacotes e suas dependências - Python Package Index. A maioria das distribuições do Python vem com o pip pré-instalado):

[pip =

garantir pip

get-pip.py

garantir pip

Python vem com um módulo securepip[1], que pode instalar o pip num ambiente Python.

Mac OS

Windows

Mais detalhes sobre como o assegurar que pip funciona e como ele pode ser usado estão disponíveis na documentação da biblioteca padrão.

get-pip.py

Este é um script Python que usa alguma lógica de inicialização para instalar o pip.

Baixar o script em https://bootstrap.pypa.io/get-pip.py.

Abrir um terminal/prompt de comando, fazer cd para a pasta que contém o arquivo get-pip.py e executar:

Mac OS

Windows

Mais detalhes sobre este script podem ser encontrados no README do pypa/get-pip.

Além de instalar o pip no seu ambiente, o pip está disponível como um aplicativo zip independente. Isso pode ser baixado em https://bootstrap.pypa.io/pip/pip.pyz. Existem também aplicativos zip para versões específicas do pip, chamados pip-X.Y.Z.pyz.

O aplicativo zip pode ser executado usando qualquer versão suportada do Python:

Mac OS

Windows

Se executado diretamente:

Mac OS

Windows

então o interpretador Python atualmente ativo será usado.

How to install pip in macOS ?

Before we start with how to install pip for Python on macOS, let’s first go through the basic introduction to Python. 

Python is a widely-used general-purpose, high-level programming language. Python is a programming language that lets you work quickly and integrate systems more efficiently. PIP is a package management system used to install and manage software packages/libraries written in Python. These files are stored in a large “on-line repository” termed as Python Package Index (PyPI). pip uses PyPI as the default source for packages and their dependencies. In this article, we will see How to Install PIP on a Mac. Using pip you can install any package using the following syntax:

Syntax of pip

pip install package_name

Download and Install Pip on macOS

pip can be downloaded and installed usingthe command line by going through the following steps:

Step 1: Download the get-pip.py(https://bootstrap.pypa.io/get-pip.py) file and store it in the same directory as python is installed. or Use the following command to download pip directly

curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py

Step 2: Now execute the downloaded file using the below command

python3 get-pip.py

Step 3: Wait through the installation process. 

Voila! pip is now installed on your system.

curl https://bootstrap.pypa.io/get-pip.py -o get-pip.py

Step 2: Now execute the downloaded file using the below command

python3 get-pip.py

Step 3: Wait through the installation process. 

Voila! pip is now installed on your system.

• Install Homebrew
• 
/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"
• 📋
• 
  
  Paste that in a macOS Terminal or Linux shell prompt.
• The script explains what it will do and then pauses before it does it. Read about other installation options.
• If you're on macOS, try our new           .pkg          installer.
• Download it from Homebrew's latest GitHub release.
• What Does Homebrew Do?
• 
  Homebrew installs the stuff you need that Apple (or your Linux system) didn’t.
• $ brew install wget
• Homebrew installs packages to their own directory and then symlinks their files into           /opt/homebrew          (on Apple Silicon).
• $ cd /opt/homebrew
• $ find Cellar
• Cellar/wget/1.16.1
• Cellar/wget/1.16.1/bin/wget
• Cellar/wget/1.16.1/share/man/man1/wget.1
• 
  
• $ ls -l bin
• bin/wget -> ../Cellar/wget/1.16.1/bin/wget
• Homebrew won’t install files outside its prefix and you can place a Homebrew installation wherever you like.
• Trivially create your own Homebrew packages.
• $ brew create https://foo.com/foo-1.0.tgz
• Created /opt/homebrew/Library/Taps/homebrew/homebrew-core/Formula/foo.rb
• It’s all Git and Ruby underneath, so hack away with the knowledge that you can easily revert your modifications and merge upstream updates.
• $ brew edit wget # opens in $EDITOR!
• Homebrew formulae are simple Ruby scripts:
• class Wget < Formula
• homepage "https://www.gnu.org/software/wget/"
• url "https://ftp.gnu.org/gnu/wget/wget-1.15.tar.gz"
• sha256 "52126be8cf1bddd7536886e74c053ad7d0ed2aa89b4b630f76785bac21695fcd"
• 
  
• def install
• system "./configure", "--prefix=#{prefix}"
• system "make", "install"
• end
• end
• Homebrew complements macOS (or your Linux system).
• Install your RubyGems with           gem          and their dependencies with           brew         .
• “To install, drag this icon…” no more. Homebrew Cask installs macOS apps, fonts and plugins and other non-open source software.
• $ brew install --cask firefox
• Making a cask is as simple as creating a formula.
• $ brew create --cask https://foo.com/foo-1.0.dmg
• Editing /opt/homebrew/Library/Taps/homebrew/homebrew-cask/Casks/foo.rb
• brew          command documentation
• docs.brew.sh/Manpage

INSTALAR/TRABALHAR com Jupyter (2)

------------------------------------------------------------------------------------------------------------------------------------------------------------

As ferramentas do Projeto Jupyter estão disponíveis para instalação por meio do Python Package Index, o principal repositório de software criado para a linguagem de programação Python.

Esta página usa instruções com pip, a ferramenta de instalação recomendada para Python. Se precisar de gerir o ambiente em vez de apenas "instalação", <<look into conda, mamba, pipenv, and Homebrew>>

consultar conda, mamba, pipenv e Homebrew.

JupyterLab

Install JupyterLab with           pip           :

pip install jupyterlab

Note: If you install JupyterLab with conda or mamba, we recommend using the conda-forge channel.

Once installed, launch JupyterLab with:

jupyter lab

Jupyter Notebook

Install the classic Jupyter Notebook with:

pip install notebook

To run the notebook:

jupyter notebook

Voilà

Install Voilà with:

pip install voila

Once installed, launch Voilà with:

voila

Homebrew

Homebrew is a package manager for macOS and Linux. You can use it to install Jupyter by running:

brew install jupyterlab

https://jupyter.org/

................................... 

• Install

JupyterLab: A Next-Generation Notebook Interface

JupyterLab is the latest web-based interactive development environment for notebooks, code, and data. Its flexible interface allows users to configure and arrange workflows in data science, scientific computing, computational journalism, and machine learning. A modular design invites extensions to expand and enrich functionality.

• Install JupyterLab

INSTALAR/TRABALHAR com COLAB (3)

------------------------------------------------------------------------------------------------------------------------------------------------------------

Ensinar a trabalhar com Colab (Parte 2 de 2)

https://colab.research.google.com/

+ Código + Texto  Copiar para o Drive

Nota Técnica: Deve ter ativado o seu Google Drive

<<Acesso fácil e seguro ao seu conteúdo

Armazenar, partilhar e colaborar em ficheiros e pastas a partir do seu dispositivo móvel, tablet ou computador

Experimentar o Drive para o trabalho

Aceder ao Drive

Não tem uma conta? Inscreva-se sem qualquer custo>>

Files... código... dados são arquivados na CLOUD (Google Drive)

Vamos começar... https://colab.research.google.com/

https://medium.com/google-colab/teaching-with-colab-part-2-841c4de526e9

Na Parte 1, explicamos por que o Colab é ótimo para ensinar programação Python.

Neste blog entraremos em detalhes - mostraremos alguns exemplos específicos de como o Colab pode melhorar o seu kit de ferramentas de ensino linguagem Python.

Notas de aula interativas

Muitos professores partilham as suas anotações de aula como slides ou documentos, o que é bom, mas esses são decididamente artefactos somente de leitura. Não seria bom se as suas anotações de aula pudessem ser interativas, como este exemplo:

Exemplo de notas de aula interativas

Os alunos também podem verificar sua compreensão, como no exemplo a seguir:

We can also do arithmetic with variables right inside the print function:

> Print (“weight in pounds:”, 2.2 * weight_kg

Note that the above function call did not change the value of weight_kg:

[ ] print (weight_kg)

<<Também podemos praticar aritmética com variáveis ​​dentro da função de impressão

> imprimir ("peso em libras: ", 2.2 * peso_kg)

Observar que a chamada de função acima não alterou o valor>>

Os alunos também podem verificar a sua compreensão, como no exemplo a seguir:

§ Verificar a sua compreensão

Que valores têm as variáveis ​​massa e idade após cada uma das afirmações a seguir?

Adivinhe antes de executar as linhas abaixo…

[ ] massa = 47.5

print(“massa é”, massa)

print(“idade é”, idade)

As notas de aula interativas oferecem múltiplas vantagens sobre as suas partes contrárias:

Durante a aula, em vez de apenas afirmar que algo é verdade, podemos provar isso executando o código incorporado diretamente nas nossas anotações.

Depois da aula, os alunos podem rever ativamente as suas anotações executando o caderno e vendo como funcionam por si próprios.

Os alunos podem experimentar, fazer alterações no código e ver os resultados.

Os alunos podem fazer anotações, tudo numa cópia digital.

Com esta abordagem, as notas da aula ganham vida, o que leva à aprendizagem ativa – proporcionando aos alunos um campo interativo onde podem experimentar e aprender fazendo.

Certifique-se de que os alunos começam do zero - desejamos que cada aluno comece com a sua própria cópia de um determinado "bloco de notas" da aula para que possam alterar, anotar e experimentar livremente sem afetar a sua cópia oficial. Para encorajar essa abordagem, todos os nossos cadernos começam com as seguintes orientações:

Lição 1 - Variáveis ​​e Tipos

 Link para este notebook (bloco de notas) mco.fyi/py1    <<https://mco.fyi/py1>>

Deve fazer a sua própria cópia deste notebook selecionando Arquivo > Salvar uma cópia no Drive na barra de menu acima

Lição de casa digital

Os cadernos interativos são ótimos para tarefas de casa, porque pode sempre:

· Dispor a meta da tarefa e as instruções em células de marcação (blocos de programação).

· Incluir todas as etapas de configuração (por exemplo, instalação dos pacotes necessários) numa célula de código.

· Fornecer quaisquer funções auxiliares necessárias ou outro código utilitário.

· Incluir sugestões de código e blocos de construção.

Aqui está um exemplo de pergunta do trabalho de casa:

Questão 1

 Escrever uma função chamada total que retorne a soma de um intervalo de inteiros começando com o primeiro valor passado e terminando com um a menos que o segundo valor passado.

Por exemplo, total(4, 7) retorna 15  (4 + 5 + 6).

[ ] # Adicionar o seu código aqui

        def total(a,b):

Variáveis

Qualquer interpretador Python pode ser usado como calculadora:

[ ]

print(3 + 5 * 4)

Isso é ótimo, mas não muito interessante. Para fazer algo útil com os dados, precisamos atribuir o seu valor a uma variável.

Em Python, podemos atribuir um valor a uma variável usando o sinal de igual =.

Se uma variável ainda não existir, quando lhe atríbuímos um valor, o Python vai criá-la instantaneamente. Se atribuir um valor a uma variável que já existe, o Python substituirá o seu valor atual por um novo valor.

Exemplos

instructor = "marc"     # valor da sequência (string)

instructor = "my evil twin" # mesmo nome, valor de string diferente

instructor = 42       # mesmo nome, valor inteiro

todays_high_temp = 71.3   # nome diff, valor de ponto flutuante

Podemos rastrear o peso de um paciente que pesa 60 quilos atribuindo o valor 60 a uma variável peso_kg:

[ ]

peso_kg = 60

print(peso_kg)

A partir de agora, sempre que usarmos peso_kg, o Python substituirá o valor que lhe atribuímos. Em termos mais simples, "uma variável é uma referência a um valor".

Em Python, nomes de variáveis:

· pode incluir letras, dígitos e sublinhados

· não é possível começar com um dígito

· distinguem maiúsculas de minúsculas

Isto significa que, por exemplo:

· peso0 é um nome válido de variável, enquanto 0peso não é

· peso e Peso são variáveis ​​diferentes

Palavras reservadas

As palavras a seguir têm um significado especial em Python. Nós chamamos-lhe "palavras-chave" ou "palavras reservadas" e não podemos usar esses nomes para variáveis ​​do nosso programa.

and, as, assert, break, class, continue, def, del, elif, else, except, False, finally, for, from, global, if, import, in, is, lambda, nonlocal, None, not, or, pass, raise, return, True, try, while, with, yield

Tipos de dados

Python conhece vários tipos de dados. Três deles - mais comuns - são:

· Números inteiros

· Números de ponto (vírgula) flutuante

· Cadeias de caracteres ou strings

No exemplo acima, à variável peso_kg foi atribuído um valor inteiro de 60.

Se quisermos rastrear com mais precisão o peso do nosso paciente, podemos usar um valor de ponto flutuante executando:

[ ]

peso_kg = 60,0

print(peso_kg)

Para criar uma string, adicionamos aspas simples ou duplas em algum texto. Para identificar e rastrear um paciente ao longo do nosso estudo, podemos atribuir a cada pessoa um identificador exclusivo, armazenando-o numa string:

[ ]

id_paciente = "001"

print(paciente_id)

Tipos Numéricos

Python suporta dois tipos principais de números

int, números inteiros assinados de tamanho arbitrário, como estes:

2011

-999999999999

float, números de ponto (vírgula) flutuante de precisão arbitrária, como estes:

3.14159  ou  3,14159

3.8*10**6  ou  3,8*10**6

Na maioria das vezes, não precisamos de nos preocuparmos com que tipo de número usar - o Python cuidará disso para nós.

O ponto decimal informa ao Python qual terá de usar.

A mistura de floats e ints resulta num float, então, por exemplo, 2011 * 3.14 resulta em número de ponto flutuante.

Tente inserir essas expressões na seguinte célula (linha de código):

 print(5 - 6)  
print(8 * 9)
print(6 / 2) 
print(5.0 / 2)
print(5 % 2)  
print(2 * 10 + 3)  
print(2 * (10 + 3))  
print(2 ** 4)

Houve algum resultado que não estivesse à espera?

[ ]

 print(5 - 6) 

  print(8 * 9)

  print(6 / 2)   

  print(5.0 / 2)

  print(5 % 2) 

  print(2 * 10 + 3) 

  print(2 * (10 + 3)) 

  print(2 ** 4)

  print(8 % 3)

©      -1

72

3.0

2.5

1

23

26

16

2

Usar variáveis ​​em Python

Assim que tivermos os dados armazenados com nomes de variáveis, podemos fazer uso dessas variáveis ​​ao longo dos nossos cálculos. Chamamos expressões a essas combinações de variáveis ​​e valores. Ao avaliar uma expressão, o Python substitui internamente os nomes das variáveis ​​pelos valores aos quais elas se referem.

Podemos querer armazenar o peso do nosso paciente em libras e também em quilogramas:

[ ]  peso_lb = 2.2 * peso_kg

    print(peso_lb)

Também podemos decidir adicionar um prefixo ao nosso identificador de paciente:

[ ]  patient_id = "inflam_" + patient_id

print(patient_id)

Funções Python integradas

Para realizar tarefas comuns com dados e variáveis ​​em Python, a linguagem fornece-nos diversas funções integradas.

Para exibir informações no ecrã, usamos a função print:

[ ]  print(peso_lb)

print(patient_id)

Quando queremos fazer uso de uma função, chamada de função, seguimos o seu nome entre parênteses. Os parênteses são importantes:

 - se queremos deixá-los desligados, a função não será executada de facto!

Às vezes incluiremos valores ou variáveis ​​entre parênteses para a função usar.

No caso de print, usamos os parênteses para informar à função qual é o valor que queremos exibir.

Aprenderemos mais sobre como as funções funcionam e como criar as nossas próprias funções em lições posteriores.

Podemos exibir várias coisas ao mesmo tempo que usamos apenas uma chamada de função de impressão:

[ ]  print(patient_id, "peso em quilogramas:", peso_kg)

Observemos que a chamada de função acima não alterou o valor de peso_kg:

[ ]  print(peso_kg)

Para alterar o valor da variável peso_kg, temos que atribuir um novo valor a peso_kg usando o sinal de igual =:

[ ] peso_kg = 65,0

      print("peso em quilogramas agora é:", peso_kg)

------------------------------------------------------------------------------------------------------------------------------------------------------------

Neste tutorial a linguagem Python será usada numa plataforma TensorFlow

Sintaxe Python em comparação com outras linguagens de programação:

· Python foi projetado para ser legível e tem algumas semelhanças com a língua inglesa com influência da matemática.

· Python usa novas linhas para completar um comando, ao contrário de outras linguagens de programação que costumam usar ponto e vírgula ou parênteses.

· Python depende de indentação, usando espaços em branco, para definir o âmbito; como o limite do trabalho, sejam "loops", funções e classes. Outras linguagens de programação costumam usar chaves ou parênteses para essa finalidade.

Colab: uma maneira fácil de aprender e usar o TensorFlow

Colaboratory é um ambiente de notebook Jupyter hospedado de uso gratuito e que não requer configuração. Provavelmente, já deve ter visto isso nalguma introdução ao Machine Learning, ou num tutorial de execução do tensorflow.org ou em vários textos de pesquisa (como este). Deixamos aqui 5 sugestões úteis para usar:

1. O TensorFlow já está pré-instalado

Quando criar um novo notebook em colab.research.google.com, o TensorFlow já vem pré-instalado e otimizado para o hardware em curso. Basta importar o tensorflow como tf e começar a codificar.

2. Configurar as suas bibliotecas e dependências de dados em células de código (são os locais onde escreve o seu código Python)

Criar uma célula com !pip install ou !apt-get funciona conforme o esperado. Também torna mais fácil para outras pessoas reproduzirem a sua configuração.

Para obter os dados de treino, pode seguir estes tutoriais para fontes de dados populares: BigQuery, Drive, folhas de cálculo Google Cloud Storage. Também tem acesso ao shell com !, então !wget, !pwd, etc. também podem ajudar.

<<O acesso Shell, comumente referido como SSH (Secure SHell), é o acesso remoto de linha de comando a um servidor. Ter acesso à linha de comando (se estiver familiarizado com o seu uso) pode ser muito útil.>>

3. Usar com Github

Se tiver um bom .ipynb no Github, é fácil criar o link de um clique para os seus leitores/alunos começarem a brincar com ele.

Basta adicionar o caminho do Github a colab.research.google.com/github/ .

Por exemplo, colab.research.google.com/github/tensorflow/tensor2tensor/blob/master/tensor2tensor/notebooks/hello_t2t.ipynb carregará este ipynb armazenado no Github.

Também pode gravar facilmente uma cópia do seu notebook Colab no Github usando Arquivo > Salvar uma cópia no Github…

4. Partilhar e editar de forma colaborativa

Os cadernos Colab são como Documentos e folhas de cálculo Google. São armazenados no Google Drive e podem ser partilhados, editados e comentados de forma colaborativa. Basta clicar no botão "Share button" (partilhar) no canto superior direito de qualquer bloco de notas que tenha criado.

5. Aceleração de hardware

Por padrão, os notebooks Colab são executados na CPU. Pode mudar o seu notebook para funcionar com GPU acedendo Runtime > Change runtime type e selecionando GPU. Também pode fazer com que um notebook Colab use o hardware da sua máquina local seguindo estas instruções.

Usar o link colab.research.google.com

O que é o Colab?

O Colab, ou "Colaboratory", permite-lhe escrever e executar código Python no seu navegador com

· Sem configuração necessária

· Acesso às GPUs sem custo financeiro

· Partilha fácil

· Quer seja aluno, cientista de dados ou investigador de IA, o Colab pode facilitar o seu trabalho.

Veja a Introdução ao Colab para saber mais ou simplesmente comece a utilizá-lo abaixo!

Introdução

O documento que está a ler não é uma página Web estática, mas sim um ambiente interativo chamado bloco de notas do Colab que lhe permite escrever e executar código.

Por exemplo, eis uma célula de código com um curto script do Python que calcula um valor, armazena-o numa variável e imprime o resultado:

[ ]

 seconds_in_a_day = 24 * 60 * 60

 seconds_in_a_day

 86400

Para executar o código na célula acima, selecione-a com um clique e, em seguida, prima o botão Play à esquerda do código ou utilize o atalho de teclado "Command/Ctrl+Enter". Para editar o código, basta clicar na célula e começar a editar.

As variáveis que define numa célula podem ser utilizadas noutras células posteriormente:

[ ]

 seconds_in_a_week = 7 * seconds_in_a_day

 seconds_in_a_week

 604800

Os blocos de notas do Colab permitem-lhe combinar código executável e texto num único documento, juntamente com imagens, HTML, LaTeX e muito mais. Quando criar os seus próprios blocos de notas do Colab, estes são armazenados na sua conta do Google Drive.

Pode partilhar facilmente os seus blocos de notas do Colab com colegas de trabalho ou amigos, permitindo que estes comentem os seus blocos de notas ou até mesmo que os editem. Para saber mais, consulte Vista geral do Colab.

Para criar um novo bloco de notas do Colab, pode utilizar o menu Ficheiro acima ou o seguinte link:

criar um novo bloco de notas do Colab.

Os blocos de notas do Colab são blocos de notas do Jupyter alojados pelo Colab. Para saber mais acerca do projeto Jupyter, consultar jupyter.org.

## Ciência de dados

</div>

Com o Colab, pode aproveitar todo o poder das populares bibliotecas do Python para analisar e visualizar dados. A célula de código abaixo utiliza <strong>numpy</strong> para gerar alguns dados aleatórios e <strong>matplotlib</strong> para os visualizar. Para editar o código, basta clicar na célula e começar a editar.

 import numpy as np

 import IPython.display as display

 from matplotlib import pyplot as plt

 import io

 import base64

 ys = 200 + np.random.randn(100)

 x = [x for x in range(len(ys))]

 fig = plt.figure(figsize=(4, 3), facecolor='w')

 plt.plot(x, ys, '-')

 plt.fill_between(x, ys, 195, where=(ys > 195), facecolor='g', alpha=0.6)

 plt.title("Sample Visualization", fontsize=10)

 data = io.BytesIO()

 plt.savefig(data)

 image = F"data:image/png;base64,{base64.b64encode(data.getvalue()).decode()}"

 alt = "Sample Visualization"

 display.display(display.Markdown(F""""""))

 plt.close(fig)

Pode importar os seus próprios dados para os blocos de notas do Colab a partir da sua conta do Google Drive, incluindo de folhas de cálculo, assim como do GitHub e de muitas outras fontes. Para saber mais acerca da importação de dados e de como o Colab pode ser utilizado para ciência de dados, consulte os links abaixo em <a href="#working-with-data">Trabalhar com dados</a>.

##Aprendizagem automática

Com o Colab, pode importar um conjunto de dados de imagem, preparar um classificador de imagens e avaliar o modelo, tudo isto com apenas algumas linhas de código. Os blocos de notas do Colab executam código nos servidores na nuvem da Google, o que significa que pode tirar partido da potência do hardware da Google, incluindo GPUs e TPUs, independentemente da potência da sua máquina. Só precisa de um navegador.

O Colab é utilizado extensivamente na comunidade de aprendizagem automática com aplicações que incluem:

· Começar a utilizar o TensorFlow

· Desenvolver e preparar redes neurais

· Experiências com TPUs.

· Divulgar a investigação em IA

· Criar tutoriais

Para ver exemplos de blocos de notas do Colab que demonstram aplicações de aprendizagem automática, consulte os exemplos de aprendizagem automática  abaixo.

Preparar novamente um classificador de imagens: crie um modelo do Keras baseado num classificador de imagens pré-preparado para distinguir flores.

Retreinando um classificador de imagens

Introdução

Os modelos de classificação de imagens têm milhões de parâmetros. Treiná-los do zero requer muitos dados de treino rotulados e muito poder de computação. A aprendizagem por transferência é uma técnica que reduz muito disso, pegando uma parte de um modelo que já foi treinado em uma tarefa relacionada e reutilizando-o em um novo modelo.

Este Colab demonstra como construir um modelo Keras para classificar cinco espécies de flores usando um TF2 SavedModel pré-treinado do TensorFlow Hub para extração de recursos de imagem, treinado no conjunto de dados ImageNet muito maior e mais geral. Opcionalmente, o extrator de recursos pode ser treinado ("ajustado") junto com o classificador recém-adicionado.

Procurando uma ferramenta?

Este é um tutorial de codificação do TensorFlow. Se você quer uma ferramenta que só constrói o modelo TensorFlow ou TFLite para, dê uma olhada no make_image_classifier ferramenta de linha de comando que fica instalado pelo pacote PIP tensorflow-hub[make_image_classifier] , ou pelo presente colab TFLite.

Configurar

import itertools

import os

import matplotlib.pylab as plt

import numpy as np

import tensorflow as tf

import tensorflow_hub as hub

print("TF version:", tf.__version__)

print("Hub version:", hub.__version__)

print("GPU is", "available" if tf.config.list_physical_devices('GPU') else "NOT AVAILABLE")

Selecione o módulo TF2 SavedModel para usar

Para começar, use https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/4 . A mesma URL pode ser usada no código para identificar o SavedModel e em seu navegador para mostrar sua documentação. (Observe que os modelos no formato TF1 Hub não funcionam aqui.)

Você pode encontrar mais modelos TF2 que geram a imagem de vetores de características aqui .

Existem vários modelos possíveis para experimentar. Tudo o que você precisa fazer é selecionar um diferente na célula abaixo e acompanhar com o notebook.

model_name = "efficientnetv2-xl-21k" # @param ['efficientnetv2-s', 'efficientnetv2-m', 'efficientnetv2-l', 'efficientnetv2-s-21k', 'efficientnetv2-m-21k', 'efficientnetv2-l-21k', 'efficientnetv2-xl-21k', 'efficientnetv2-b0-21k', 'efficientnetv2-b1-21k', 'efficientnetv2-b2-21k', 'efficientnetv2-b3-21k', 'efficientnetv2-s-21k-ft1k', 'efficientnetv2-m-21k-ft1k', 'efficientnetv2-l-21k-ft1k', 'efficientnetv2-xl-21k-ft1k', 'efficientnetv2-b0-21k-ft1k', 'efficientnetv2-b1-21k-ft1k', 'efficientnetv2-b2-21k-ft1k', 'efficientnetv2-b3-21k-ft1k', 'efficientnetv2-b0', 'efficientnetv2-b1', 'efficientnetv2-b2', 'efficientnetv2-b3', 'efficientnet_b0', 'efficientnet_b1', 'efficientnet_b2', 'efficientnet_b3', 'efficientnet_b4', 'efficientnet_b5', 'efficientnet_b6', 'efficientnet_b7', 'bit_s-r50x1', 'inception_v3', 'inception_resnet_v2', 'resnet_v1_50', 'resnet_v1_101', 'resnet_v1_152', 'resnet_v2_50', 'resnet_v2_101', 'resnet_v2_152', 'nasnet_large', 'nasnet_mobile', 'pnasnet_large', 'mobilenet_v2_100_224', 'mobilenet_v2_130_224', 'mobilenet_v2_140_224', 'mobilenet_v3_small_100_224', 'mobilenet_v3_small_075_224', 'mobilenet_v3_large_100_224', 'mobilenet_v3_large_075_224']

model_handle_map = {

 "efficientnetv2-s": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet1k_s/feature_vector/2",

 "efficientnetv2-m": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet1k_m/feature_vector/2",

 "efficientnetv2-l": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet1k_l/feature_vector/2",

 "efficientnetv2-s-21k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_s/feature_vector/2",

 "efficientnetv2-m-21k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_m/feature_vector/2",

 "efficientnetv2-l-21k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_l/feature_vector/2",

 "efficientnetv2-xl-21k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_xl/feature_vector/2",

 "efficientnetv2-b0-21k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_b0/feature_vector/2",

 "efficientnetv2-b1-21k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_b1/feature_vector/2",

 "efficientnetv2-b2-21k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_b2/feature_vector/2",

 "efficientnetv2-b3-21k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_b3/feature_vector/2",

 "efficientnetv2-s-21k-ft1k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_ft1k_s/feature_vector/2",

 "efficientnetv2-m-21k-ft1k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_ft1k_m/feature_vector/2",

 "efficientnetv2-l-21k-ft1k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_ft1k_l/feature_vector/2",

 "efficientnetv2-xl-21k-ft1k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_ft1k_xl/feature_vector/2",

 "efficientnetv2-b0-21k-ft1k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_ft1k_b0/feature_vector/2",

 "efficientnetv2-b1-21k-ft1k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_ft1k_b1/feature_vector/2",

 "efficientnetv2-b2-21k-ft1k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_ft1k_b2/feature_vector/2",

 "efficientnetv2-b3-21k-ft1k": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_ft1k_b3/feature_vector/2",

 "efficientnetv2-b0": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet1k_b0/feature_vector/2",

 "efficientnetv2-b1": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet1k_b1/feature_vector/2",

 "efficientnetv2-b2": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet1k_b2/feature_vector/2",

 "efficientnetv2-b3": "https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet1k_b3/feature_vector/2",

 "efficientnet_b0": "https://tfhub.dev/tensorflow/efficientnet/b0/feature-vector/1",

 "efficientnet_b1": "https://tfhub.dev/tensorflow/efficientnet/b1/feature-vector/1",

 "efficientnet_b2": "https://tfhub.dev/tensorflow/efficientnet/b2/feature-vector/1",

 "efficientnet_b3": "https://tfhub.dev/tensorflow/efficientnet/b3/feature-vector/1",

 "efficientnet_b4": "https://tfhub.dev/tensorflow/efficientnet/b4/feature-vector/1",

 "efficientnet_b5": "https://tfhub.dev/tensorflow/efficientnet/b5/feature-vector/1",

 "efficientnet_b6": "https://tfhub.dev/tensorflow/efficientnet/b6/feature-vector/1",

 "efficientnet_b7": "https://tfhub.dev/tensorflow/efficientnet/b7/feature-vector/1",

 "bit_s-r50x1": "https://tfhub.dev/google/bit/s-r50x1/1",

 "inception_v3": "https://tfhub.dev/google/imagenet/inception_v3/feature-vector/4",

 "inception_resnet_v2": "https://tfhub.dev/google/imagenet/inception_resnet_v2/feature-vector/4",

 "resnet_v1_50": "https://tfhub.dev/google/imagenet/resnet_v1_50/feature-vector/4",

 "resnet_v1_101": "https://tfhub.dev/google/imagenet/resnet_v1_101/feature-vector/4",

 "resnet_v1_152": "https://tfhub.dev/google/imagenet/resnet_v1_152/feature-vector/4",

 "resnet_v2_50": "https://tfhub.dev/google/imagenet/resnet_v2_50/feature-vector/4",

 "resnet_v2_101": "https://tfhub.dev/google/imagenet/resnet_v2_101/feature-vector/4",

 "resnet_v2_152": "https://tfhub.dev/google/imagenet/resnet_v2_152/feature-vector/4",

 "nasnet_large": "https://tfhub.dev/google/imagenet/nasnet_large/feature_vector/4",

 "nasnet_mobile": "https://tfhub.dev/google/imagenet/nasnet_mobile/feature_vector/4",

 "pnasnet_large": "https://tfhub.dev/google/imagenet/pnasnet_large/feature_vector/4",

 "mobilenet_v2_100_224": "https://tfhub.dev/google/imagenet/mobilenet_v2_100_224/feature_vector/4",

 "mobilenet_v2_130_224": "https://tfhub.dev/google/imagenet/mobilenet_v2_130_224/feature_vector/4",

 "mobilenet_v2_140_224": "https://tfhub.dev/google/imagenet/mobilenet_v2_140_224/feature_vector/4",

 "mobilenet_v3_small_100_224": "https://tfhub.dev/google/imagenet/mobilenet_v3_small_100_224/feature_vector/5",

 "mobilenet_v3_small_075_224": "https://tfhub.dev/google/imagenet/mobilenet_v3_small_075_224/feature_vector/5",

 "mobilenet_v3_large_100_224": "https://tfhub.dev/google/imagenet/mobilenet_v3_large_100_224/feature_vector/5",

 "mobilenet_v3_large_075_224": "https://tfhub.dev/google/imagenet/mobilenet_v3_large_075_224/feature_vector/5",

}

model_image_size_map = {

 "efficientnetv2-s": 384,

 "efficientnetv2-m": 480,

 "efficientnetv2-l": 480,

 "efficientnetv2-b0": 224,

 "efficientnetv2-b1": 240,

 "efficientnetv2-b2": 260,

 "efficientnetv2-b3": 300,

 "efficientnetv2-s-21k": 384,

 "efficientnetv2-m-21k": 480,

 "efficientnetv2-l-21k": 480,

 "efficientnetv2-xl-21k": 512,

 "efficientnetv2-b0-21k": 224,

 "efficientnetv2-b1-21k": 240,

 "efficientnetv2-b2-21k": 260,

 "efficientnetv2-b3-21k": 300,

 "efficientnetv2-s-21k-ft1k": 384,

 "efficientnetv2-m-21k-ft1k": 480,

 "efficientnetv2-l-21k-ft1k": 480,

 "efficientnetv2-xl-21k-ft1k": 512,

 "efficientnetv2-b0-21k-ft1k": 224,

 "efficientnetv2-b1-21k-ft1k": 240,

 "efficientnetv2-b2-21k-ft1k": 260,

 "efficientnetv2-b3-21k-ft1k": 300, 

 "efficientnet_b0": 224,

 "efficientnet_b1": 240,

 "efficientnet_b2": 260,

 "efficientnet_b3": 300,

 "efficientnet_b4": 380,

 "efficientnet_b5": 456,

 "efficientnet_b6": 528,

 "efficientnet_b7": 600,

 "inception_v3": 299,

 "inception_resnet_v2": 299,

 "nasnet_large": 331,

 "pnasnet_large": 331,

}

model_handle = model_handle_map.get(model_name)

pixels = model_image_size_map.get(model_name, 224)

print(f"Selected model: {model_name} : {model_handle}")

IMAGE_SIZE = (pixels, pixels)

print(f"Input size {IMAGE_SIZE}")

BATCH_SIZE = 16

Selected model: efficientnetv2-xl-21k : https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_xl/feature_vector/2

Input size (512, 512)

Configure o conjunto de dados do Flowers

As entradas são redimensionadas adequadamente para o módulo selecionado. O aumento do conjunto de dados (ou seja, distorções aleatórias de uma imagem cada vez que ela é lida) melhora o treinamento, esp. durante o ajuste fino.

data_dir = tf.keras.utils.get_file(

  'flower_photos',

  'https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz',

  untar=True)

Downloading data from https://storage.googleapis.com/download.tensorflow.org/example_images/flower_photos.tgz

228818944/228813984 [==============================] - 1s 0us/step

228827136/228813984 [==============================] - 1s 0us/step

Alternar código

Found 3670 files belonging to 5 classes.

Using 2936 files for training.

Found 3670 files belonging to 5 classes.

Using 734 files for validation.

Definindo o modelo

Tudo o que precisamos é colocar um classificador linear no topo do feature_extractor_layer com o módulo de Hub.

Para a velocidade, começamos com um não-treinável feature_extractor_layer , mas você também pode ativar o ajuste fino para maior precisão.

do_fine_tuning = False

print("Building model with", model_handle)

model = tf.keras.Sequential([

  # Explicitly define the input shape so the model can be properly

  # loaded by the TFLiteConverter

  tf.keras.layers.InputLayer(input_shape=IMAGE_SIZE + (3,)),

  hub.KerasLayer(model_handle, trainable=do_fine_tuning),

  tf.keras.layers.Dropout(rate=0.2),

  tf.keras.layers.Dense(len(class_names),

             kernel_regularizer=tf.keras.regularizers.l2(0.0001))

])

model.build((None,)+IMAGE_SIZE+(3,))

model.summary()

Building model with https://tfhub.dev/google/imagenet/efficientnet_v2_imagenet21k_xl/feature_vector/2

Model: "sequential_1"

_________________________________________________________________

 Layer (type)        Output Shape       Param # 

=================================================================

 keras_layer (KerasLayer)  (None, 1280)       207615832 

 dropout (Dropout)      (None, 1280)       0     

 dense (Dense)        (None, 5)         6405   

=================================================================

Total params: 207,622,237

Trainable params: 6,405

Non-trainable params: 207,615,832

_________________________________________________________________

Treinando o modelo

model.compile(

 optimizer=tf.keras.optimizers.SGD(learning_rate=0.005, momentum=0.9), 

 loss=tf.keras.losses.CategoricalCrossentropy(from_logits=True, label_smoothing=0.1),

 metrics=['accuracy'])

steps_per_epoch = train_size // BATCH_SIZE

validation_steps = valid_size // BATCH_SIZE

hist = model.fit(

  train_ds,

  epochs=5, steps_per_epoch=steps_per_epoch,

  validation_data=val_ds,

  validation_steps=validation_steps).history

Epoch 1/5

183/183 [==============================] - 133s 543ms/step - loss: 0.9221 - accuracy: 0.8996 - val_loss: 0.6271 - val_accuracy: 0.9597

Epoch 2/5

183/183 [==============================] - 94s 514ms/step - loss: 0.6072 - accuracy: 0.9521 - val_loss: 0.5990 - val_accuracy: 0.9528

Epoch 3/5

183/183 [==============================] - 94s 513ms/step - loss: 0.5590 - accuracy: 0.9671 - val_loss: 0.5362 - val_accuracy: 0.9722

Epoch 4/5

183/183 [==============================] - 94s 514ms/step - loss: 0.5532 - accuracy: 0.9726 - val_loss: 0.5780 - val_accuracy: 0.9639

Epoch 5/5

183/183 [==============================] - 94s 513ms/step - loss: 0.5618 - accuracy: 0.9699 - val_loss: 0.5468 - val_accuracy: 0.9556

plt.figure()

plt.ylabel("Loss (training and validation)")

plt.xlabel("Training Steps")

plt.ylim([0,2])

plt.plot(hist["loss"])

plt.plot(hist["val_loss"])

plt.figure()

plt.ylabel("Accuracy (training and validation)")

plt.xlabel("Training Steps")

plt.ylim([0,1])

plt.plot(hist["accuracy"])

plt.plot(hist["val_accuracy"])

[<matplotlib.lines.Line2D at 0x7f607ad6ad90>]

png

png

Experimente o modelo em uma imagem dos dados de validação:

x, y = next(iter(val_ds))

image = x[0, :, :, :]

true_index = np.argmax(y[0])

plt.imshow(image)

plt.axis('off')

plt.show()

# Expand the validation image to (1, 224, 224, 3) before predicting the label

prediction_scores = model.predict(np.expand_dims(image, axis=0))

predicted_index = np.argmax(prediction_scores)

print("True label: " + class_names[true_index])

print("Predicted label: " + class_names[predicted_index])

png

True label: sunflowers

Predicted label: sunflowers

Finalmente, o modelo treinado pode ser salvo para implantação no TF Serving ou TFLite (no celular) da seguinte forma.

saved_model_path = f"/tmp/saved_flowers_model_{model_name}"

tf.saved_model.save(model, saved_model_path)

2021-11-05 13:09:44.225508: W tensorflow/python/util/util.cc:368] Sets are not currently considered sequences, but this may change in the future, so consider avoiding using them.

WARNING:absl:Found untraced functions such as restored_function_body, restored_function_body, restored_function_body, restored_function_body, restored_function_body while saving (showing 5 of 3985). These functions will not be directly callable after loading.

INFO:tensorflow:Assets written to: /tmp/saved_flowers_model_efficientnetv2-xl-21k/assets

INFO:tensorflow:Assets written to: /tmp/saved_flowers_model_efficientnetv2-xl-21k/assets

Classificação básica: classificação de imagens de roupas

Ver em TensorFlow.orgExecutar no Google ColabVer fonte no GitHub Baixar notebook

https://github.com/tensorflow/docs-l10n/blob/master/site/pt-br/tutorials/keras/classification.ipynb

Este guia treina um modelo de rede neural para classificar imagens de roupas, como tênis e camisetas. Não tem problema se você não entender todos os detalhes. Esta é uma visão geral rápida de um programa completo do TensorFlow, e os detalhes são explicados aos poucos.

Este guia usa o tf.keras, uma API de alto nível, para criar e treinar modelos no TensorFlow.

[ ]

# TensorFlow and tf.keras
import tensorflow as tf
# Helper libraries
import numpy as np
import matplotlib.pyplot as plt
print(tf.__version__)

keyboard_arrow_down

Importar o dataset Fashion MNIST

dataset Fashion MNIST

Este guia usa o dataset Fashion MNIST, que contém 70 mil imagens em escala de cinza, em 10 categorias. As imagens mostram artigos de vestuário individuais com resolução baixa (28x28 pixels), conforme visto aqui:

Imagem 1. Amostras do Fashion MNIST (por Zalando, Licença MIT).

O Fashion MNIST é usado como substituto do dataset MNIST clássico, geralmente utilizado como o "Olá, mundo" dos programas de aprendizado de máquina para visão computacional. O dataset MNIST contém imagens de dígitos escritos à mão (0, 1, 2, etc.) em um formato idêntico ao dos artigos de vestuário que você usará aqui.

Este tutorial usa o Fashion MNIST por ser variado e por ser um problema um pouco mais desafiador que o MNIST comum. Os dois datasets são relativamente pequenos e são usados para verificar se um algoritmo funciona como esperado. Eles são bons pontos de partida para testar e depurar o código.

Aqui, 60 mil imagens são usadas para treinar a rede, e 10 mil imagens são usadas para avaliar com que exatidão a rede aprendeu a classificar as imagens. Você pode acessar o dataset Fashion MNIST diretamente no TensorFlow. Importe e carregue os dados do Fashion MNIST diretamente do TensorFlow:

[ ]

fashion_mnist = tf.keras.datasets.fashion_mnist
(train_images, train_labels), (test_images, test_labels) = fashion_mnist.load_data()

Ao carregar o dataset, são retornadas quatro matrizes NumPy:

• As matrizes             train_images            e             train_labels            são o conjunto de treinamento — os dados que o modelo usa para aprender.
• O modelo é estado com um conjunto de teste,             test_images           , e matrizes             test_labels           .

As imagens são matrizes NumPy 28x28, sendo que os valores de pixel variam de 0 a 255. Os rótulos são uma matriz de números inteiros, que variam de 0 a 9. Eles correspondem à classe de roupas que a imagem representa:

RótuloClasse0Camiseta/Top1Calça2Suéter3Vestido4Casaco5Sandália6Camisa7Tênis8Bolsa9Botim

Cada imagem é mapeada para um único rótulo. Como os nomes das classes não estão incluídos no dataset, armazene-os aqui par usá-los posteriormente ao plotar as imagens:

[ ]

class_names = ['T-shirt/top', 'Trouser', 'Pullover', 'Dress', 'Coat',
               'Sandal', 'Shirt', 'Sneaker', 'Bag', 'Ankle boot']

keyboard_arrow_down

Explorar os dados

Vamos explorar o formato do dataset antes de treinar o modelo. O código abaixo mostra que há 60 mil imagens no conjunto de treino, com cada imagem representada como pixels 28x28.

[ ]

train_images.shape

Da mesma forma, há 60 mil rótulos no conjunto de treinamento:

[ ]

len(train_labels)

Cada rótulo é um número inteiro entre 0 e 9:

[ ]

train_labels

Há 10 mil imagens no conjunto de teste. Novamente, cada imagem é representada por pixels de 28x28:

[ ]

test_images.shape

E o conjunto de teste contém 10 mil rótulos de imagens:

[ ]

len(test_labels)

keyboard_arrow_down

Pré-processar os dados

Os dados precisam ser pré-processados antes de treinar a rede. Se você conferir a primeira imagem no conjunto de treinamento, verá que os valores de pixel ficam no intervalo de 0 a 255:

[ ]

plt.figure()
plt.imshow(train_images[0])
plt.colorbar()
plt.grid(False)
plt.show()

Mude a escala desses valores para o intervalo de 0 a 1 antes de alimentá-los no modelo da rede neural. Para fazer isso, divida os valores por 255. É importante que o conjunto de treinamento e o conjunto de teste sejam pré-processados da mesma forma:

[ ]

train_images = train_images / 255.0
test_images = test_images / 255.0

Para verificar se os dados estão no formato correto e se está tudo pronto para criar e treinar a rede, vamos exibir as 25 primeiras imagens do conjunto de treinamento e vamos exibir também o nome da classe abaixo de cada imagem.

[ ]

plt.figure(figsize=(10,10))
for i in range(25):
    plt.subplot(5,5,i+1)
    plt.xticks([])
    plt.yticks([])
    plt.grid(False)
    plt.imshow(train_images[i], cmap=plt.cm.binary)
    plt.xlabel(class_names[train_labels[i]])
plt.show()

keyboard_arrow_down

Criar o modelo

Criar a rede neural requer a configuração das camadas do modelo e depois a compilação do modelo.

keyboard_arrow_down

Configurar as camadas

O bloco de construção básico de uma rede neural é a camada. As camadas extraem representações dos dados alimentados nela. Espera-se que essas representações tenham um significado para o problema em questão.

A maioria dos aprendizados profundos consiste da combinação de camadas simples. A maioria das camadas, como             tf.keras.layers.Dense           , têm parâmetros que são aprendidos durante o treino.

[ ]

model = tf.keras.Sequential([
    tf.keras.layers.Flatten(input_shape=(28, 28)),
    tf.keras.layers.Dense(128, activation='relu'),
    tf.keras.layers.Dense(10)
])

A primeira camada desta rede,             tf.keras.layers.Flatten           , transforma o formato das imagens de uma matriz bidimensional (de pixels 28x28) em uma matriz unidimensional (de 28 * 28 = 784 pixels). Pense nessa camada como pegar as linhas de pixels da imagem e enfileirá-las. Essa camada não tem parâmetros a aprender, ela somente reformata os dados.

Após os pixels serem achatados, a rede consiste de uma sequência de duas camadas             tf.keras.layers.Dense           , que são camadas neurais densamente conectadas, ou totalmente conectadas. A primeira camada             Dense            tem 128 nós (ou neurônios). A segunda (e última) camada retorna uma matriz de logits, com tamanho igual a 10. Cada nó contém uma pontuação que indica que a imagem atual pertence a uma das 10 classes.

keyboard_arrow_down

Compilar o modelo

Antes que o modelo fique pronto para o treinamento, é preciso fazer mais algumas configurações, que são adicionadas durante o passo de compilação do modelo:

• Função de perda — Mensura a exatidão do modelo durante o treinamento. Você vai querer minimizar essa função para "guiar" o modelo para a direção certa.
• Otimizador — Indica como o modelo é atualizado com base nos dados que vê e em sua função de perda.
• Métricas — Usadas para monitorar os passos de treinamento e teste. O exemplo abaixo usa exatidão, a fração das imagens que estão classificadas corretamente.

[ ]

model.compile(optimizer='adam',
              loss=tf.keras.losses.SparseCategoricalCrossentropy(from_logits=True),
              metrics=['accuracy'])

keyboard_arrow_down

Treinar o modelo

O treinamento da modelo de rede neural requer os seguintes passos:

1. Alimentar os dados de treinamento no modelo. Neste exemplo, os dados de treinamento estão nas matrizes             train_images            e             train_labels           .
2. O modelo aprende a associar imagens e rótulos.
3. Você pede para o modelo fazer previsões sobre um conjunto de teste. Neste exemplo, é a matriz             test_images           .
4. Verifique se as previsões correspondem aos rótulos da matriz             test_labels           .

keyboard_arrow_down

Alimentar o modelo

Para iniciar o treinamento, faça uma chamada ao método             model.fit           , chamado de "fit" (adequar) porque ele faz o modelo "se adequar" aos dados de treinamento:

[ ]

model.fit(train_images, train_labels, epochs=10)

À medida que o modelo é treinado, as métricas de perda e exatidão são exibidas. Este modelo atinge uma exatidão de cerca de 0,91 (91%) para os dados de treinamento.

keyboard_arrow_down

Avaliar a exatidão

Agora, compare o desempenho do modelo para o dataset de teste:

[ ]

test_loss, test_acc = model.evaluate(test_images,  test_labels, verbose=2)
print('\nTest accuracy:', test_acc)

Percebe-se que a exatidão para o dataset de teste é um pouco menor do que para o dataset de treinamento. Essa discrepância entre a exatidão do treinamento e a exatidão do teste representa o overfitting. O overfitting acontece quando um modelo de aprendizado de máquina tem um desempenho inferior com entradas novas, nunca vistas anteriormente, em comparação aos dados de treinamento. Um modelo com overfitting "memoriza" o ruído e os detalhes do dataset de treinamento a ponto de impactar negativamente o desempenho do modelo para novos dados. Se quiser saber mais, confira:

• Demonstração do overfitting
• Estratégias para evitar o overfitting

keyboard_arrow_down

Fazer previsões

Com o modelo treinado, você pode usá-lo para fazer previsões sobre algumas imagens. Anexe uma camada softmax para converter as saídas lineares do modelo (logits) em probabilidades, que devem ser mais fáceis de interpretar.

[ ]

probability_model = tf.keras.Sequential([model, 
                                        tf.keras.layers.Softmax()])

[ ]

predictions = probability_model.predict(test_images)

Aqui, o modelo previu o rótulo de cada imagem no conjunto de teste. Vamos conferir a primeira previsão:

[ ]

predictions[0]

Uma previsão é uma matriz com 10 números. Eles representam a "confiança" do modelo de que a imagem corresponde a cada um dos 10 diferentes artigos de vestuário. Você pode ver qual rótulo tem o maior valor de confiança:

[ ]

np.argmax(predictions[0])

Portanto, o modelo tem maior confiança de que esta imagem é um botim, ou             class_names[9]           . Ao avaliar o rótulo de teste, vemos que essa classificação está correta:

[ ]

test_labels[0]

Gerar um gráfico para ver o conjunto completo das 10 previsões de classe:

[ ]

def plot_image(i, predictions_array, true_label, img):
  true_label, img = true_label[i], img[i]
  plt.grid(False)
  plt.xticks([])
  plt.yticks([])

  plt.imshow(img, cmap=plt.cm.binary)

  predicted_label = np.argmax(predictions_array)
  if predicted_label == true_label:
    color = 'blue'
  else:
    color = 'red'

  plt.xlabel("{} {:2.0f}% ({})".format(class_names[predicted_label],
                                100*np.max(predictions_array),
                                class_names[true_label]),
                                color=color)

def plot_value_array(i, predictions_array, true_label):
  true_label = true_label[i]
  plt.grid(False)
  plt.xticks(range(10))
  plt.yticks([])
  thisplot = plt.bar(range(10), predictions_array, color="#777777")
  plt.ylim([0, 1])
  predicted_label = np.argmax(predictions_array)

  thisplot[predicted_label].set_color('red')
  thisplot[true_label].set_color('blue')

keyboard_arrow_down

Verificar as previsões

Com o modelo treinado, podemos usá-lo para fazer previsões sobre algumas imagens.

Vamos conferir a imagem, previsão e matriz de previsões na posição 0. Os rótulos com previsão correta são azuis, e os rótulos com previsão incorreta são vermelhos. O número dá a porcentagem (até 100) do rótulo previsto.

[ ]

i = 0
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

[ ]

i = 12
plt.figure(figsize=(6,3))
plt.subplot(1,2,1)
plot_image(i, predictions[i], test_labels, test_images)
plt.subplot(1,2,2)
plot_value_array(i, predictions[i],  test_labels)
plt.show()

Vamos desenhar (plot) diversas imagens com suas previsões. Observe que o modelo pode errar mesmo quando tiver confiança alta.

[ ]

# Plot the first X test images, their predicted labels, and the true labels.
# Color correct predictions in blue and incorrect predictions in red.
num_rows = 5
num_cols = 3
num_images = num_rows*num_cols
plt.figure(figsize=(2*2*num_cols, 2*num_rows))
for i in range(num_images):
  plt.subplot(num_rows, 2*num_cols, 2*i+1)
  plot_image(i, predictions[i], test_labels, test_images)
  plt.subplot(num_rows, 2*num_cols, 2*i+2)
  plot_value_array(i, predictions[i], test_labels)
plt.tight_layout()
plt.show()

keyboard_arrow_down

Usar o modelo treinado

Por fim, use o modelo treinado para fazer uma previsão sobre uma única imagem.

[ ]

# Grab an image from the test dataset.
img = test_images[1]
print(img.shape)

Os modelos do             tf.keras            são otimizados para fazer previsões para um lote, ou coleção, de exemplos ao mesmo tempo. Mesmo que você esteja usando uma única imagem, precisa adicioná-la a uma lista:

[ ]

# Add the image to a batch where it's the only member.
img = (np.expand_dims(img,0))
print(img.shape)

Agora, faça a previsão do rótulo correto para essa imagem:

[ ]

predictions_single = probability_model.predict(img)
print(predictions_single)

[ ]

plot_value_array(1, predictions_single[0], test_labels)
_ = plt.xticks(range(10), class_names, rotation=45)
plt.show()

tf.keras.Model.predict            retorna uma lista de listas:

uma lista para cada imagem no lote de dados. Obtenha as previsões para nossa única imagem no lote:

[ ]

np.argmax(predictions_single[0])

E o modelo prevê um rótulo conforme esperado

Nota Técnica:

TensorFlow é uma estrutura de código aberto desenvolvida por investigadores do Google para executar aprendizagem automática (ML), aprendizagem profunda e outras cargas de trabalho de análise estatística e preditiva.

Como plataformas semelhantes, foi projetada para agilizar o processo de desenvolvimento e execução de aplicativos analíticos avançados para utilizadores como cientistas de dados, estatísticos e modeladores preditivos.

O software TensorFlow lida com conjuntos de dados organizados como "nós computacionais" em forma de gráfico. As arestas que conectam os nós num gráfico podem representar vetores ou matrizes multi-dimensionais, criando o que é conhecido como tensores. Como os programas TensorFlow usam uma arquitetura de fluxo de dados que funciona com resultados intermediários generalizados dos cálculos, são especialmente abertos a aplicações de processamento paralelo em grande escala, sendo as redes neuronais um exemplo comum.

A estrutura inclui conjuntos de APIs (application programming interface) de alto e baixo nível. O Google recomenda usar os de alto nível sempre que possível para simplificar o desenvolvimento do pipeline de dados e a programação de aplicativos. No entanto, saber como usar APIs de baixo nível – chamadas TensorFlow Core – pode ser valioso para experimentação e depuração de aplicativos, dizem os autores; também oferece aos utilizadores um “modelo mental” do funcionamento interno da tecnologia de aprendizagem automática, nas palavras do Google.

O TensorFlow pode ser usado para desenvolver modelos para diversas tarefas, incluindo processamento de linguagem natural, reconhecimento de imagem, reconhecimento de escrita e diferentes simulações baseadas em computação, como equações diferenciais parciais.

Embora o TensorFlow ofereça suporte a outras linguagens de programação, Python e JavaScript são as mais populares. Além disso, o TensorFlow oferece suporte a Swift, C, Go, C# e Java. Python não é necessário para funcionar com o TensorFlow; no entanto, torna o trabalho com o TensorFlow extremamente simples.

Como funciona o TensorFlow  com Python?

O TensorFlow oferece tudo o que for necessário aos programadores por meio da linguagem de programação Python. Python é simples de aprender e executar e oferece métodos diretos para representar o acoplamento de abstrações de alto nível.

Nós e tensores do TensorFlow são objetos Python; portanto, os aplicativos TensorFlow também são programas Python. No entanto, cálculos matemáticos reais não são feitos em Python. As bibliotecas de transformação acessíveis por meio do TensorFlow são criadas como binários C++ eficientes. Python controla apenas o fluxo de informações entre os componentes e oferece estruturas de codificação de alto nível para conectá-los.

Referências:

1. Artificial Intelligence with Python (2th Ed.); Alberto Artasanchez, Prateek Joshi - Published by Packt Publishing Ltd.; 2020
2. Programação em Python (5th Ed.); João Pavão Martins - Editora IST Press; 2023
3. Introdução à Algoritmia e Programação com Python; Filipe Portela, Tiago C. Pereira - FCA-Editora de Informática; 2023
4. Programação em Python "Fundamentos e Resolução de Problemas"; Ernesto Costa - FCA-Editora de Informática; 2022

O Arduino tem a missão de tornar o Machine Learning (aprendizagem automática) simples o suficiente para qualquer pessoa usar.

Temos trabalhado com a equipa do TensorFlow Lite nos últimos meses e estamos entusiasmados

em mostrar o que temos feito juntos: trazer o TensorFlow Lite Micro para o Arduino Nano 33 BLE Sense.

Mais à frente, mostraremos como instalar e executar vários exemplos do TensorFlow Lite Micro que estão agora disponíveis no Arduino Library Manager

O primeiro tutorial que será publicado mostra como instalar uma rede neuronal na placa Arduino para reconhecer comandos de voz simples.