O que é TensorFlow? Como funciona? Archiarquitetura e recursos

O que é TensorFlow?

TensorFlow é uma plataforma ponta a ponta de código aberto para a criação de aplicativos de aprendizado de máquina. É uma biblioteca matemática simbólica que utiliza fluxo de dados e programação diferenciável para realizar diversas tarefas focadas no treinamento e inferência de redes neurais profundas. Ele permite que os desenvolvedores criem aplicativos de aprendizado de máquina usando várias ferramentas, bibliotecas e recursos da comunidade.

Atualmente, a biblioteca de aprendizado profundo mais famosa do mundo é Google's TensorFlow. Google Aplica aprendizado de máquina em seus produtos para aprimorar buscas, traduções, legendagem de imagens e recomendações.

Exemplo de TensorFlow

Para dar um exemplo concreto, Google Com a IA, os usuários podem desfrutar de uma experiência de busca mais rápida e refinada. Se o usuário digitar uma palavra-chave na barra de pesquisa, Google Oferece uma recomendação sobre qual poderia ser a próxima palavra.

Google desejam usar aprendizado de máquina para aproveitar seus enormes conjuntos de dados e oferecer aos usuários a melhor experiência possível. Três grupos diferentes utilizam aprendizado de máquina:

• Pesquisadores
• Cientistas de Dados
• Programadores

Todos eles podem usar o mesmo conjunto de ferramentas para colaborar entre si e melhorar sua eficiência.

Google O sistema não apenas armazena grandes conjuntos de dados, como também executa uma enorme infraestrutura computacional; portanto, o TensorFlow foi projetado para ser escalável desde o início. O TensorFlow é uma biblioteca desenvolvida pela Microsoft. Google A equipe Brain Team pretende acelerar a pesquisa em aprendizado de máquina e redes neurais profundas.

Ele foi criado para rodar em múltiplas CPUs ou GPUs e até mesmo em sistemas operacionais móveis, e possui vários wrappers em diversas linguagens como Python, C++ or Java.

História do TensorFlow

Há alguns anos, o aprendizado profundo começou a superar todos os outros algoritmos de aprendizado de máquina ao lidar com uma quantidade massiva de dados. Google viu que poderia usar essas redes neurais profundas para melhorar seus serviços:

• Gmail
• Ensaio
• Google motor de busca

Eles construíram uma estrutura chamada TensorFlow para que pesquisadores e desenvolvedores pudessem trabalhar no mesmo modelo e, em seguida, implantá-lo em uma escala que muitas pessoas pudessem usar.

O TensorFlow foi lançado publicamente em novembro de 2015, e a versão 1.0 foi lançada em fevereiro de 2017. A mudança muito mais significativa veio com TensorFlow 2.0 em setembro de 2019, que tornou a execução imediata o padrão e adotou o Keras como a API de alto nível padrão. A partir da versão 2.16, o Keras 3 é o padrão, e o mesmo código de modelo também pode ser executado em JAX ou Py.Torbackends ch.

O TensorFlow é distribuído sob a licença Apache 2.0, portanto você pode usá-lo, modificá-lo e redistribuí-lo, inclusive comercialmente, sem pagar nada. Google.

Como funciona o TensorFlow

O TensorFlow permite criar gráficos e estruturas de fluxo de dados para definir como os dados se movem por um gráfico, considerando as entradas como uma matriz multidimensional chamada Tensor. Ele permite construir um fluxograma de operações que podem ser realizadas nessas entradas, que vai em uma ponta e chega na outra como saída.

TensorFlow Archiarquitetura

A arquitetura do TensorFlow funciona em três partes:

• Pré-processando os dados
• Construa o modelo
• Treine e estime o modelo

É chamado de TensorFlow porque recebe como entrada uma matriz multidimensional, também conhecida como tensores. Você pode construir uma espécie de fluxograma de operações (chamadas de Gráfico) que você deseja realizar nessa entrada. A entrada entra por uma extremidade e depois flui através desse sistema de múltiplas operações e sai pela outra extremidade como saída.

Onde o TensorFlow pode ser executado?

Os requisitos de hardware e software do TensorFlow se dividem em duas fases:

Fase de desenvolvimentoÉ nessa etapa que você treina o modelo, geralmente em um computador desktop ou laptop.

Fase de execução ou inferênciaApós a conclusão do treinamento, o modelo pode ser executado em diversas plataformas:

• Área de trabalho em execução Windows, macOS ou Linux
• Nuvem como serviço web
• Dispositivos móveis como iOS e Android

Você pode treiná-lo em várias máquinas e executá-lo em uma máquina diferente, depois de ter o modelo treinado.

O modelo pode ser treinado e usado tanto em GPUs quanto em CPUs. As GPUs foram inicialmente projetadas para videogames. Por volta de 2009, pesquisadores de Stanford demonstraram que as GPUs são extremamente eficientes em operações de matrizes e álgebra linear, das quais as redes neurais dependem. O aprendizado profundo depende muito da multiplicação de matrizes. O TensorFlow é muito rápido no cálculo da multiplicação de matrizes porque é escrito em linguagem de programação. C++. Embora seja implementado em C++, o TensorFlow pode ser acessado e controlado principalmente por outras linguagens, Python.

Outra característica importante é TensorBoard, que visualiza o gráfico, as métricas de treinamento e a distribuição dos pesos enquanto o modelo está em execução.

Componentes do TensorFlow

tensor

O nome TensorFlow deriva diretamente de sua estrutura principal: tensorEm TensorFlow, todos os cálculos envolvem tensores. Um tensor é uma grandeza numérica ou um número inteiro. vetor or matriz de n dimensões que representa todos os tipos de dados. Todos os valores em um tensor contêm tipo de dados idêntico a um conhecido (ou parcialmente conhecido) forma. A forma dos dados é a dimensionalidade da matriz ou array.

Um tensor pode ser originado dos dados de entrada ou do resultado de um cálculo. No TensorFlow, todas as operações são conduzidas dentro de um gráfico. O gráfico é um conjunto de cálculos que ocorrem sucessivamente. Cada operação é chamada de nó operacional e estão conectados entre si.

O gráfico descreve as operações e conexões entre os nós. No entanto, ele não exibe os valores. A borda dos nós é o tensor, ou seja, uma forma de preencher a operação com dados.

Gráficos

O TensorFlow faz uso de uma estrutura gráfica. O gráfico reúne e descreve todos os cálculos das séries feitos durante o treinamento. O gráfico tem muitas vantagens:

• Ele funciona em várias CPUs ou GPUs, e até mesmo em sistemas operacionais móveis.
• A portabilidade do gráfico permite preservar os cálculos para uso imediato ou posterior. O gráfico pode ser salvo para ser executado no futuro.
• Todos os cálculos no gráfico são feitos conectando tensores entre si
  • Um grafo possui nós e arestas. Cada nó realiza uma operação matemática e produz uma saída, enquanto as arestas descrevem as relações de entrada e saída entre os nós. Os tensores em si percorrem as arestas.

Por que o TensorFlow é popular?

O TensorFlow é amplamente adotado por ser acessível a todos os níveis de conhecimento. Suas APIs abrangem desde um modelo Keras de três linhas até uma CNN ou RNN construída manualmente. Como a computação é expressa como um grafo, o TensorBoard pode visualizar a rede e facilitar muito a depuração. Ele também pode ser implementado em grande escala, executando em CPU, GPU e TPU, e em dispositivos móveis por meio do TensorFlow Lite.

O TensorFlow continua sendo uma das duas estruturas de aprendizado profundo mais usadas no GitHub, juntamente com o Py.Torcap.

TensorFlow Algorithms

O TensorFlow inclui estimadores de alto nível para diversos algoritmos clássicos. No TensorFlow 1.x, esses estimadores estavam disponíveis em `tf.estimator`.

• Regressão linear: tf.estimator.LinearRegressor
• Classificação: tf.estimator.LinearClassifier
• Classificação de aprendizagem profunda: tf.estimator.DNNClassifier
• Aprendizado amplo e profundo: tf.estimator.DNNLinearCombinedClassifier
• Regressão de árvore impulsionada: tf.estimator.BoostedTreesRegressor
• Classificação de árvore otimizada: tf.estimator.BoostedTreesClassifier

TensorFlow vs PyTorQual você deve escolher?

TensorFlow e PyTorExistem dois frameworks de aprendizado profundo dominantes, e as diferenças práticas entre eles diminuíram consideravelmente desde que o TensorFlow 2.0 adotou a execução imediata (eager execution).

A resposta pragmática: escolha TensorFlow quando o modelo precisar ser distribuído para dispositivos móveis, navegadores ou plataformas de distribuição gerenciada, e escolha Py.TorAo iterar na arquitetura do modelo, o Keras 3, padrão a partir do TensorFlow 2.16, torna essa decisão ainda mais complexa, pois o mesmo código Keras pode ser executado em TensorFlow, JAX ou Py.Torch backend.

Como funcionam os cálculos no TensorFlow

import numpy as np
import tensorflow as tf

Nas duas primeiras linhas de código, importamos tensorflow como tf. Com Python, é uma prática comum usar um nome abreviado para uma biblioteca. A vantagem é evitar digitar o nome completo da biblioteca quando precisarmos utilizá-la. Por exemplo, podemos importar tensorflow como tf e chamar tf quando quisermos usar uma função tensorflow

Vamos praticar o fluxo de trabalho básico do TensorFlow com exemplos simples. Vamos criar um grafo computacional que multiplica dois números.

Durante o exemplo, multiplicaremos X_1 e X_2. O TensorFlow criará um nó para conectar a operação. Em nosso exemplo, esse nó se chama `multiply`. Quando o grafo for determinado, os mecanismos computacionais do TensorFlow multiplicarão X_1 e X_2.

Por fim, executaremos uma sessão do TensorFlow que executará o gráfico computacional com os valores de X_1 e X_2 e imprimirá o resultado da multiplicação.

Vamos definir os nós de entrada X_1 e X_2. Ao criar um nó no TensorFlow, precisamos escolher o tipo de nó que queremos criar. Os nós X1 e X2 serão nós de espaço reservado (placeholder). O espaço reservado atribui um novo valor a cada cálculo realizado. Vamos criá-los como nós de espaço reservado do TensorFlow.

Etapa 1: definir a variável

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

Um marcador de posição precisa de um tipo de dados. Como são números, tf.float32 é a escolha certa. O argumento `name` é opcional, mas útil, pois é o rótulo que aparece na visualização do gráfico no TensorBoard. X_2 é definido da mesma forma.

Etapa 2: definir o cálculo

multiply = tf.multiply(X_1, X_2, name = "multiply")

Agora podemos definir o nó que realiza a operação de multiplicação. No TensorFlow, podemos fazer isso criando um nó tf.multiply.

Passaremos os nós X_1 e X_2 para o nó de multiplicação. Ele diz ao tensorflow para vincular esses nós no gráfico computacional, então estamos pedindo para ele extrair os valores de xey e multiplicar o resultado. Vamos também dar ao nó de multiplicação o nome de multiplicação. É a definição completa do nosso gráfico computacional simples.

Passo 3: Execute a operação

Para executar operações no grafo, precisamos criar uma sessão. No TensorFlow, isso é feito com `tf.Session()`. Agora que temos uma sessão, podemos solicitar que ela execute operações em nosso grafo computacional chamando `session`. Para executar a computação, precisamos usar `run`.

Quando a operação de multiplicação é executada, ela precisa dos valores dos nós X_1 e X_2, então você os fornece em tempo de execução. Podemos fazer isso fornecendo um parâmetro chamado feed_dict. Passamos os valores 1, 2, 3 para X_1 e 4, 5, 6 para X_2.

Imprimimos os resultados com print(result). Devemos ver 4, 10 e 18 para 1×4, 2×5 e 3×6

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

multiply = tf.multiply(X_1, X_2, name = "multiply")

with tf.Session() as session:
    result = session.run(multiply, feed_dict={X_1:[1,2,3], X_2:[4,5,6]})
    print(result)

[ 4. 10. 18.]

Opções para carregar dados no TensorFlow

O primeiro passo antes de treinar um algoritmo de aprendizado de máquina consiste em carregar os dados. Existem duas maneiras comuns de carregar dados:

1. Carregar dados na memóriaÉ o método mais simples. Você carrega todos os seus dados na memória como um único array. Você escreve o código em texto simples. Python Para isso; nada disso é específico do TensorFlow.

2. Pipeline de dados do TensorFlowO TensorFlow fornece uma API integrada que carrega os dados, aplica transformações e alimenta o modelo. Esse método funciona muito bem, especialmente quando se tem um conjunto de dados grande. Por exemplo, sabe-se que os registros de imagens são enormes e não cabem na memória. O pipeline de dados gerencia a memória automaticamente.

Qual solução usar?

Carregar dados na memória

Se o seu conjunto de dados não for muito grande, ou seja, menos de 10 gigabytes, você poderá usar o primeiro método. Os dados podem caber na memória. Você pode usar uma biblioteca famosa chamada Pandas para importar arquivos CSV. Você aprenderá mais sobre pandas no próximo tutorial.

Carregar dados com o pipeline do TensorFlow

O segundo método funciona melhor se você tiver um grande conjunto de dados. Por exemplo, se você tiver um conjunto de dados de 50 gigabytes e seu computador tiver apenas 16 gigabytes de memória, a máquina irá travar.

Nessa situação, você precisa construir um pipeline do TensorFlow. O pipeline carregará os dados em lotes, ou pequenos fragmentos. Cada lote será enviado para o pipeline e estará pronto para o treinamento. Construir um pipeline é uma excelente solução porque permite o uso de computação paralela. Isso significa que o TensorFlow treinará o modelo em várias CPUs. Isso acelera a computação e torna viável o treinamento de redes maiores.

Resumindo: carregue conjuntos de dados pequenos na memória com o pandas e use um pipeline do TensorFlow quando os dados forem grandes ou quando você quiser carregamento paralelo em várias CPUs.

Como criar um pipeline do TensorFlow

Aqui estão as etapas para criar um pipeline do TensorFlow:

No exemplo anterior, adicionamos manualmente três valores para X_1 e X_2. Agora, veremos como carregar dados no TensorFlow:

Etapa 1) Crie os dados

Primeiro de tudo, vamos usar a biblioteca numpy para gerar dois valores aleatórios.

import numpy as np
x_input = np.random.sample((1,2))
print(x_input)

[[0.8835775 0.23766977]]

Etapa 2) Crie o espaço reservado

Como no exemplo anterior, criamos um espaço reservado com o nome X. Precisamos especificar explicitamente a forma do tensor. Nesse caso, carregaremos um array com apenas dois valores. Podemos escrever a forma como shape=[1,2]

# using a placeholder
x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')

Etapa 3) Definir o método do conjunto de dados

A seguir, precisamos definir o Dataset onde podemos preencher o valor do espaço reservado x. Precisamos usar o método tf.data.Dataset.from_tensor_slices

dataset = tf.data.Dataset.from_tensor_slices(x)

Etapa 4) Crie o pipeline

Na etapa quatro, precisamos inicializar o pipeline por onde os dados fluirão. Precisamos criar um iterador com make_initializable_iterator. Nós o chamamos de iterador. Então precisamos chamar esse iterador para alimentar o próximo lote de dados, get_next. Chamamos esta etapa de get_next. Observe que em nosso exemplo, há apenas um lote de dados com apenas dois valores.

iterator = dataset.make_initializable_iterator() 
get_next = iterator.get_next()

Etapa 5) Execute a operação

A última etapa é semelhante ao exemplo anterior. Iniciamos uma sessão e executamos o iterador de operação. Alimentamos o feed_dict com o valor gerado por numpy. Esses dois valores preencherão o espaço reservado x. Então executamos get_next para imprimir o resultado.

with tf.Session() as sess:
    # feed the placeholder with data
    sess.run(iterator.initializer, feed_dict={ x: x_input }) 
    print(sess.run(get_next))

[0.8835775  0.23766978]

TensorFlow 1.x vs TensorFlow 2.x: O que mudou?

O TensorFlow 2.0 representou uma reformulação significativa da API voltada para o usuário. Compreender essa diferença é importante, pois grande parte do código de tutoriais online, incluindo os exemplos acima, utiliza o estilo da versão 1.x.

O exemplo de multiplicação, reescrito. Três etapas e uma sessão se tornam uma única linha, porque a operação é executada no momento em que é chamada:

import tensorflow as tf

X_1 = tf.constant([1, 2, 3], dtype=tf.float32)
X_2 = tf.constant([4, 5, 6], dtype=tf.float32)

result = tf.multiply(X_1, X_2, name="multiply")
print(result.numpy())        # [ 4. 10. 18.]

O pipeline de entrada foi reescrito. Não são necessários marcadores de posição nem objetos iteradores:

import numpy as np
import tensorflow as tf

x_input = np.random.sample((1, 2))
dataset = tf.data.Dataset.from_tensor_slices(x_input)

for batch in dataset:
    print(batch.numpy())

Se você precisa da velocidade de um grafo compilado, encapsule a função em `@tf.function` e use o TensorFlow. tracconverte tudo automaticamente em um só. Scripts legados da versão 1.x também podem ser executados sem alterações por meio do namespace tf.compat.v1, embora esse caminho seja apenas para manutenção e não deva ser usado para novos trabalhos.

TensorFlow: Principais conclusões e Code Referência

• Significado do Tensor Flow: TensorFlow é a biblioteca de aprendizagem profunda mais famosa dos últimos anos. Um profissional que usa o TensorFlow pode construir qualquer estrutura de aprendizado profundo, como CNN, RNN ou uma rede neural artificial simples.
• O TensorFlow é usado principalmente por acadêmicos, startups e grandes empresas. Google usa TensorFlow em quase tudo Google produtos de uso diário, incluindo Gmail, Foto e Google Mecanismo de busca.
• O Google A equipe do Brain desenvolveu o TensorFlow para diminuir a distância entre pesquisadores e desenvolvedores de produtos. Em 2015, eles tornaram o TensorFlow público e, desde então, sua popularidade tem crescido rapidamente. Atualmente, o TensorFlow é a biblioteca de aprendizado profundo com o maior número de repositórios no GitHub.
• Os profissionais usam o TensorFlow porque ele pode ser implementado facilmente em grande escala, na nuvem, no navegador ou em dispositivos móveis com iOS e iOS. Android.

O TensorFlow funciona em sessões. Cada sessão é definida por um grafo com diferentes cálculos. Um exemplo simples seria a multiplicação de dois números. No TensorFlow, são necessários três passos:

1. Defina a variável

X_1 = tf.placeholder(tf.float32, name = "X_1")
X_2 = tf.placeholder(tf.float32, name = "X_2")

2. Defina o cálculo

multiply = tf.multiply(X_1, X_2, name = "multiply")

3. Execute a operação

with tf.Session() as session:
    result = session.run(multiply, feed_dict={X_1: [1, 2, 3], X_2: [4, 5, 6]})
    print(result)

Uma prática comum no TensorFlow é criar um pipeline para carregar os dados. Seguindo estes cinco passos, você conseguirá carregar dados no TensorFlow:

1. Crie os dados

import numpy as np
x_input = np.random.sample((1,2))
print(x_input)

2. Crie o espaço reservado

x = tf.placeholder(tf.float32, shape=[1,2], name = 'X')

3. Definir o método do conjunto de dados

dataset = tf.data.Dataset.from_tensor_slices(x)

4. Criar o pipeline

iterator = dataset.make_initializable_iterator()
get_next = iterator.get_next()

5. Execute o programa

with tf.Session() as sess:
    sess.run(iterator.initializer, feed_dict={x: x_input})
    print(sess.run(get_next))

Perguntas Frequentes