tensorflow python

tensorflow python

 

 

Tutorial do TensorFlow para iniciantes com exemplo de Python 

 

Em novembro, TensorFlow  comemorará seu quinto aniversário. Ao longo dos anos, tornou-se um dos frameworks e reuniu uma enorme quantidade de seguidores. O Google fez um ótimo trabalho e incorporou essa estrutura em Java, C++, JavaScript e, mais importante, na principal linguagem de ciência de dados Python .

Se você perguntar à comunidade quais são suas combinações favoritas de ferramentas, a resposta mais comum seria TensorFlow e Python. Graças a isso, chegamos ao ponto em que essa tecnologia está madura o suficiente para facilitar seu uso e “atravessar o abismo”. No entanto, vamos começar do início e descobrir do que se trata essa tecnologia. 

 

Noções básicas do TensorFlow

Então, como o TensorFlow funciona? Bem, para começar, toda a solução deles gira em torno de tensores, unidade primitiva no TensorFlow. O TensorFlow usa uma estrutura de dados de tensor para representar todos os dados.

Em matemática, tensores são objetos geométricos que descrevem relações lineares entre outros objetos geométricos. No TesnsorFlow são arrays ou dados multidimensionais, ou seja. matrizes. Ok, não é tão simples assim, mas este é todo o conceito de tensor que se aprofunda na álgebra linear que eu gostaria de ir agora.

De qualquer forma, podemos observar tensores como matrizes n-dimensionais usando quais operações de matriz são feitas de maneira fácil e eficaz. Por exemplo, no código abaixo, definimos dois tensores constantes e adicionamos um valor ao outro:

import tensorflow as tf

const1 = tf.constant([[1,2,3], [1,2,3]]);
const2 = tf.constant([[3,4,5], [3,4,5]]);

result = tf.add(const1, const2);

with tf.Session() as sess:
  output = sess.run(result)
  print(output)

As constantes, como você já percebeu, são valores que não mudam. No entanto, o TensorFlow possui uma API rica, bem documentada e com ela podemos definir outros tipos de dados, como variáveis:

import tensorflow as tf

var1 = tf.Variable([[1, 2], [1, 2]], name="variable1")
var2 = tf.Variable([[3, 4], [3, 4]], name="variable2")

result = tf.matmul(var1, var2)

with tf.Session() as sess:
  output = sess.run(result)
  print(output)

Além dos tensores, o TensorFlow usa gráficos de fluxo de dados. Os nós no gráfico representam operações matemáticas, enquanto as arestas representam os tensores comunicados entre eles.

2. Ecossistema TensorFlow

Claro, não queremos apenas fazer operações aritméticas simples, queremos usar esta biblioteca para construir preditores, classificadores, modelos generativos, redes neurais e assim por diante. Em geral, quando você está construindo essas soluções, temos que passar por  várias etapas :

• Análise  e pré-processamento dos dados
• Construindo  e  treinando  um modelo (modelo de aprendizado de máquina, rede neural, …)
• de avaliação  Modelo
• Fazendo novas previsões

Como o treinamento desses modelos pode ser um processo caro e longo, podemos usar máquinas diferentes para fazer isso. O treinamento desses modelos na CPU pode levar muito tempo, portanto, usar a GPU é sempre uma opção melhor.

A opção mais rápida para treinar esses modelos é  unidade de processamento de tensores  ou  TPUs . Eles foram introduzidos pelo Google em 2016. e são um circuito integrado específico de aplicativo (ASIC) do acelerador de IA. No entanto, eles ainda são bastante caros.

Além disso, queremos implantar nosso modelo em diferentes plataformas, como nuvem, sistemas embarcados (IoT) ou integrá-lo em outras linguagens. É por isso que  TensorFlow  se parece com isso:

Podemos ver que todos esses pontos principais do desenvolvimento dessas soluções estão contemplados nesse  ecossistema . Quando se trata de Python, geralmente analisamos e tratamos dados usando bibliotecas como  numpy  e  pandas . Em seguida, usamos esses dados para empurrá-los para o modelo que construímos.

Isso está um pouco fora do escopo deste artigo, e a análise de dados é um tópico por si só. No entanto,  o TensorFlow  está nos fornecendo alguns  módulos  com os quais podemos fazer algum pré-processamento e engenharia de recursos. Além disso, fornece  dados  ( tensorflow.datasets ) que podemos usar para treinar algumas de nossas soluções personalizadas e para pesquisas em geral.

A parte mais importante do  TensorFlow  é  o TensorFlow Hub . Lá podemos encontrar vários módulos e  APIs de baixo nível  que podemos usar. Além desses, digamos, módulos principais, podemos encontrar API de alto nível –  Keras . Podemos dizer que o caminho para a versão 2.0 foi pavimentado no  TensorFlow  1.10.0 quando  Keras  foi incorporado como API de alto nível padrão.

Antes disso, o Keras era uma biblioteca separada e  tensorflow.contrib  era usado para esse propósito. Com o TensorFlow 1.10.0, recebemos a notícia de que  tensorflow.contrib  será  removido  e que o  Keras  está assumindo. E esse foi um dos principais focos do TensorFlow 2.0,  facilitar o uso e limpar a API . Na verdade, muitas APIs da versão 1.0 são movidas ou completamente removidas. Por exemplo,  tf.app  e  tf.flags  não existem mais e algumas funções menos usadas de  tf.*  são movidas para outros módulos.

Além dessa API de alto nível que usaremos mais adiante neste artigo, existem vários  pré-treinados  modelos Esses modelos são treinados em algum conjunto de dados e podem ser personalizados para sua solução.

Essa abordagem no desenvolvimento de uma solução de aprendizado de máquina também é chamada de  aprendizado transferido . O aprendizado transferido está ganhando popularidade entre os engenheiros de inteligência artificial porque está acelerando o processo. Obviamente, você pode optar por usar esses modelos pré-treinados como soluções prontas para uso.

Também existem várias  distribuição  opções de  TensorFlow  , para que possamos escolher em qual plataforma queremos treinar nossos modelos. Isso é decidido durante a instalação da estrutura, portanto, investigaremos mais nos capítulos posteriores. Podemos escolher  TensorFlow  que roda em CPU, GPU ou TPU.

Finalmente, uma vez que construímos nosso modelo, podemos salvá-lo. Este modelo pode ser incorporado em outras aplicações em diferentes  plataformas . Aqui estamos entrando no mundo da  implantação . É importante observar que a construção de um modelo é um processo completamente diferente do restante do desenvolvimento do aplicativo. Em geral, o cientista de dados constrói esses modelos e os salva. Posteriormente, esses modelos são chamados de componentes de lógica de negócios do aplicativo.

3. Instalação e configuração do TensorFlow

O TensorFlow fornece APIs para uma ampla variedade de linguagens, como Python, C++, Java, Go, Haskell e R (na forma de uma biblioteca de terceiros). Além disso, ele suporta diferentes tipos de sistemas operacionais. Neste artigo, usaremos o Python no Windows 10, portanto, apenas o processo de instalação nesta plataforma será abordado.

O TensorFlow oferece suporte apenas ao Python 3.5 acima , portanto, certifique-se de ter uma dessas versões instaladas em seu sistema. Para outros sistemas operacionais e idiomas, você pode consultar o guia de instalação oficial . Outra coisa que precisamos saber é a configuração de hardware do nosso sistema. Existem duas opções para instalar o TensorFlow:

• TensorFlow apenas com suporte para CPU.
• TensorFlow com suporte a GPU.

Se o seu sistema tiver uma GPU NVIDIA®, você poderá instalar o TensorFlow com suporte a GPU. Claro, a versão da GPU é mais rápida, mas a CPU é mais fácil de instalar e configurar.

Se você estiver usando o Anaconda , a instalação do TensorFlow pode ser feita seguindo estas etapas:

1. Crie um ambiente conda “tensorflow” executando o comando:

   conda create -n tensorflow pip python=3.5 

2. Ative o ambiente criado emitindo o comando:

   ativar tensorflow 

3. Invoque o comando para instalar o TensorFlow em seu ambiente. Para a versão da CPU, execute este comando:

   pip install --ignore-installed --upgrade tensorflow 

   Para a versão GPU execute o comando:

   pip install --ignore-installed --upgrade tensorflow-gpu 

Claro, você também pode instalar o TensorFlow usando “pip nativo”. Para a versão da CPU, execute:

pip3 install --upgrade tensorflow 

Para a versão do GPU TensorFlow, execute o comando:

pip3 install --upgrade tensorflow-gpu 

Legal, agora temos nosso TensorFlow instalado. Vamos analisar o problema que vamos resolver.

4. Usando módulos TensorFlow predefinidos

4.1 Problema de Classificação do Conjunto de Dados da Íris

O conjunto de dados Iris, juntamente com o dados MNIST , é provavelmente um dos conjuntos de dados mais conhecidos encontrados na literatura de reconhecimento de padrões. É uma espécie de exemplo “Hello World” para problemas de classificação de aprendizado de máquina. Foi introduzido pela primeira vez por Ronald Fisher em 1936. Ele era estatístico e botânico britânico e usou este exemplo neste artigo O uso de medições múltiplas em problemas taxonômicos, que é frequentemente referenciado até hoje. O conjunto de dados contém 3 classes de 50 instâncias cada. Cada classe refere-se a um tipo de planta de íris: Iris setosa , Iris virginica e Iris versicolor . A primeira classe é linearmente separável das outras duas, mas as duas últimas não são linearmente separáveis ​​uma da outra. Cada registro tem cinco atributos:

• Comprimento da sépala em cm
• Largura da sépala em cm
• Comprimento da pétala em cm
• Largura da pétala em cm
• Classe ( Iris setosa , Iris virginica, Iris versicolor )

O objetivo da rede neural que vamos criar é prever a classe da flor Iris com base em outros atributos. Ou seja, ele precisa criar um modelo , que descreverá um relacionamento entre os valores dos atributos e a classe.

4.2 Fluxo de trabalho do TensorFlow

A maioria dos códigos do TensorFlow segue este fluxo de trabalho:

• Importar o conjunto de dados
• Estenda o conjunto de dados com colunas adicionais para descrever os dados
• Selecione o tipo de modelo
• Treinamento
• Avalie a precisão do modelo
• Prever resultados usando o modelo

Se você seguiu meus posts , pode notar que os processos de treinamento e avaliação são partes importantes do desenvolvimento de qualquer Rede Neural Artificial. Esses processos geralmente são feitos em dois conjuntos de dados, um para treinamento e outro para testar a precisão da rede treinada. Muitas vezes, obtemos apenas um conjunto de dados, que precisamos dividir em dois conjuntos de dados separados e que usamos um para treinamento e outro para teste. A proporção é geralmente de 80% a 20%. Desta vez, isso já está feito para nós. Você pode baixar o conjunto de treinamento e o conjunto de teste com o código que acompanha este artigo.

4.3 Código Python

Vamos mergulhar! A primeira coisa que precisamos fazer é importar o conjunto de dados e analisá-lo. Para isso, vamos usar outra biblioteca Python – Pandas . Esta é outra biblioteca de código aberto que fornece estruturas de dados fáceis de usar e ferramentas de análise de dados para o Python.

# Import `tensorflow` and `pandas`
import tensorflow as tf
import pandas as pd

COLUMN_NAMES = [
        'SepalLength', 
        'SepalWidth',
        'PetalLength', 
        'PetalWidth', 
        'Species'
        ]

# Import training dataset
training_dataset = pd.read_csv('iris_training.csv', names=COLUMN_NAMES, header=0)
train_x = training_dataset.iloc[:, 0:4]
train_y = training_dataset.iloc[:, 4]

# Import testing dataset
test_dataset = pd.read_csv('iris_test.csv', names=COLUMN_NAMES, header=0)
test_x = test_dataset.iloc[:, 0:4]
test_y = test_dataset.iloc[:, 4]

Como você pode ver, primeiro usamos read_csv para importar o conjunto de dados para variáveis ​​locais e, em seguida, separamos as entradas (train_x, test_x) e as saídas esperadas (train_y, test_y) criando quatro matrizes separadas. Aqui está como eles se parecem:

Excelente! Preparamos dados que serão usados ​​para treinamento e teste. Agora, precisamos definir colunas de recursos, que vão ajudar nossa Rede Neural.

# Setup feature columns
columns_feat = [
    tf.feature_column.numeric_column(key='SepalLength'),
    tf.feature_column.numeric_column(key='SepalWidth'),
    tf.feature_column.numeric_column(key='PetalLength'),
    tf.feature_column.numeric_column(key='PetalWidth')
]

Agora precisamos escolher o modelo que vamos usar. Em nosso problema, estamos tentando prever uma classe de Iris Flower com base nos dados de atributos. É por isso que vamos escolher um dos estimadores da API do TensorFlow.

Um objeto da classe Estimator encapsula a lógica que cria um gráfico do TensorFlow e executa uma sessão do TensorFlow. Para isso, vamos usar DNNClassifier . Vamos adicionar duas camadas ocultas com dez neurônios em cada uma.

# Build Neural Network - Classifier
classifier = tf.estimator.DNNClassifier(
    feature_columns=columns_feat,
    # Two hidden layers of 10 nodes each.
    hidden_units=[10, 10],
    # The model is classifying 3 classes
    n_classes=3)

Depois disso, treinaremos nossa rede neural com os dados que escolhemos no conjunto de dados de treinamento. Primeiramente, vamos definir a função de treinamento. Essa função precisa fornecer à rede neural dados do conjunto de treinamento, estendendo-o e criando vários lotes.

O treinamento funciona melhor se os exemplos de treinamento estiverem em ordem aleatória. É por isso que a shuffle foi chamada. Para resumir, train_function cria lotes de dados usando o conjunto de dados de treinamento passado, selecionando dados aleatoriamente dele e fornecendo-os de volta ao train método DNNClassifier.

# Define train function
def train_function(inputs, outputs, batch_size):
    dataset = tf.data.Dataset.from_tensor_slices((dict(inputs), outputs))
    dataset = dataset.shuffle(1000).repeat().batch(batch_size)
    return dataset.make_one_shot_iterator().get_next()

# Train the Model.
classifier.train(
    input_fn=lambda:train_function(train_x, train_y, 100),
    steps=1000)

Finalmente, chamamos avaliação que avaliará nossa rede neural e nos devolverá a precisão da rede.

# Define evaluation function
def evaluation_function(attributes, classes, batch_size):
    attributes=dict(attributes)
    if classes is None:
        inputs = attributes
    else:
        inputs = (attributes, classes)
    dataset = tf.data.Dataset.from_tensor_slices(inputs)
    assert batch_size is not None, "batch_size must not be None"
    dataset = dataset.batch(batch_size)
    return dataset.make_one_shot_iterator().get_next()

# Evaluate the model.
eval_result = classifier.evaluate(
    input_fn=lambda:evaluation_function(test_x, test_y, 100))

Quando executamos este código, tenho estes resultados:

Então, obtive a precisão de 0,93 para minha rede neural, o que é muito bom. Depois disso, podemos chamar nosso classificador usando dados únicos e obter previsões para ele.

5. Keras – API de alto nível do TensorFlow

Hoje,  Keras  é a API de alto nível padrão do  TensorFlow . Neste artigo, usaremos essa API para construir uma rede neural simples mais tarde, então vamos explorar um pouco como ela funciona. Dependendo do tipo de problema, podemos usar uma variedade de camadas para a rede neural que queremos construir.

Essencialmente, Keras está fornecendo diferentes tipos de camadas ( tensorflow.keras.layers ) que precisamos conectar em um gráfico significativo que resolverá nosso problema. Existem várias maneiras de fazer essa API ao criar modelos de aprendizado profundo:

• Usando a classe sequencial
• Como usar a API funcional
• Subclassificação do modelo

A primeira abordagem é a mais simples. Estamos usando a  Sequential  classe  espaço reservado  para camadas e adicionamos camadas na ordem que queremos. Podemos querer escolher essa abordagem quando queremos construir redes neurais da  mais rápida  possível.

Existem muitos tipos de camadas Keras que podemos escolher também. O mais básico e o que vamos usar neste artigo chama-se  Dense.  Tem muitas  opções  para configurar as entradas,  funções de ativação  e assim por diante. Além de  Dense, Keras API fornece diferentes tipos de camadas para  Redes Neurais Convolucionais ,  Neurais Recorrentes , etc. Isso está fora do escopo deste post. Então, vamos ver como se pode construir uma  Rede Neural  usando  Sequencial e Densa.

6. Construindo uma rede neural com TensorFlow, Keras e Python

Para resolver este problema, vamos seguir os passos que definimos em um dos capítulos anteriores:

• Análise e pré-processamento dos dados
• Construindo e treinando um modelo
• Modelo de avaliação
• Fazendo novas previsões

6.1 Análise e Pré-processamento de Dados

A análise de dados é um tópico por si só. Aqui, não nos aprofundaremos tanto na  engenharia  e análise de recursos, mas observaremos alguns passos básicos:

• Análise Univariada  – Analisando tipos e natureza de cada recurso.
• Tratamento de dados ausentes  – Detectando dados ausentes e fazendo uma estratégia sobre isso.
• Análise de Correlação  – Comparando características entre si.
• Dividindo dados  – Como temos um conjunto de informações, precisamos fazer um conjunto separado de dados para treinar a rede neural e um conjunto de dados para avaliar a rede neural.

Usando as informações que coletamos durante esta análise, podemos tomar as ações apropriadas durante a criação do próprio modelo. Primeiro,  importamos  os dados:

COLUMN_NAMES = [
        'SepalLength', 
        'SepalWidth',
        'PetalLength', 
        'PetalWidth', 
        'Species'
        ]

data = pd.read_csv('iris_data.csv', names=COLUMN_NAMES, header=0)
data.head()

Como você pode ver, usamos Pandas para isso e também imprimimos as primeiras cinco linhas de dados. Aqui está como isso se parece:

Feito isso, queremos ver qual é a  natureza  de cada recurso. Para isso, podemos usar  Pandas  também:

data.dtypes 

A saída fica assim:

Como podemos ver o  Species  ou a saída tem o tipo  int64 . No entanto, entendemos que não é isso que queremos que seja. Queremos que esse recurso seja uma  variável categórica . Isso significa que precisamos modificar um pouco esses dados, novamente usando  Pandas :

data['Species'] = data['Species'].astype("category")
data.dtypes

Feito isso, verificamos se há  dados ausentes  em nosso conjunto de dados. Isso é feito usando esta função:

print(data.isnull().sum()) 

A saída desta chamada é:

Dados ausentes podem ser um problema para nossa rede neural. Se houver dados ausentes em nosso conjunto de dados, precisamos definir uma  estratégia  de como lidar com isso. Algumas das abordagens são que os valores ausentes são substituídos pelo  médio  do recurso ou seu  máximo  .

No entanto, não há bala de prata e, às vezes, estratégias diferentes dão melhores resultados do que as outras. Ok, vamos para a  análise de correlação . Durante esta etapa, estamos verificando como os recursos se relacionam entre si. Usando  Pandas  e  Seaborn  conseguimos obter uma imagem que mostra a matriz com níveis de dependência entre alguns dos recursos –  matriz de correlação :

corrMatt = data[["SepalLength","SepalWidth","PetalLength","PetalWidth","Species"]].corr()
mask = np.array(corrMatt)
mask[np.tril_indices_from(mask)] = False
fig,ax= plt.subplots()
fig.set_size_inches(20,10)
sn.heatmap(corrMatt, mask=mask,vmax=.8, square=True,annot=True)

Veja como essa matriz se parece:

Queríamos encontrar a relação entre  Spices  e alguns dos recursos usando essa matriz de correlação. Os valores, como você pode ver, estão entre -1 e 1. Estamos apontando para aqueles que tenham um valor próximo de 1 ou -1, o que significa que essas características têm muito em comum,  ou seja. muita  influência  uns sobre os outros.

Se tivermos essa situação, sugere-se fornecer apenas um desses recursos para um modelo. Dessa forma, evitaríamos a situação em que nosso modelo fornece previsões excessivamente otimistas (ou simplesmente erradas  ) . No entanto, neste conjunto de dados, temos poucas informações de uma forma ou de outra, portanto, se removêssemos todas as dependências, não teríamos dados  

Por fim, vamos dividir os dados em  treinamento  e  teste  . Como um cliente geralmente nos fornece um grande bloco de dados, precisamos deixar alguns dados para o teste. Normalmente, essa proporção é 80:20. Neste artigo, usaremos 70:30, apenas para brincar. Para isso utilizamos uma função da  SciKit Learn  :

output_data = data["Species"]
input_data = data.drop("Species",axis=1)
X_train, X_test, y_train, y_test = train_test_split(input_data, output_data, test_size=0.3, random_state=42)

No final, temos quatro variáveis ​​que contêm entrada  para treinamento e teste e saída  para treinamento e teste. Podemos construir nosso modelo agora.

6.2 Construindo e Treinando uma Rede Neural

Precisamos de uma rede neural bastante simples para esta classificação . Aqui, usamos a abordagem de subclassificação de modelo, mas você também pode experimentar outras abordagens. Aqui está como IrisClassifier se parece:

class IrisClassifier(Model):
  def __init__(self):
    super(IrisClassifier, self).__init__()
    self.layer1 = Dense(10, activation='relu')
    self.layer2 = Dense(10, activation='relu')
    self.outputLayer = Dense(3, activation='softmax')

  def call(self, x):
    x = self.layer1(x)
    x = self.layer2(x)
    return self.outputLayer(x)
  
model = IrisClassifier()

model.compile(optimizer=tf.keras.optimizers.Adam(),
              loss='categorical_crossentropy',
              metrics=['accuracy'])

É a pequena rede neural, com duas camadas de 10 neurônios. A camada final tem 3 neurônios porque existem 3 classes de flor de íris. Além disso, na camada final, a função de ativação está usando softmax .

Isso significa que obteremos uma saída na forma de probabilidade . Vamos treinar  essa rede neural. Para isso, estamos usando o fit e passamos os dados de treinamento preparados:

model.fit(X_train, y_train, epochs=300, batch_size=10)

O número de  épocas  está definindo quanto tempo todo o conjunto de treinamento passará pela rede. Isso pode durar alguns minutos e a saída se parece com isso:

E nós terminamos. Criamos um modelo e o treinamos. Agora, temos que avaliar e ver se temos bons resultados.

6.3 Avaliação e Novas Previsões

avaliação  é feita com a chamada do avaliação . Fornecemos dados de teste para ele e ele executa previsões para cada amostra e compara com o resultado real:

scores = model.evaluate(X_test, y_test)
print("\nAccuracy: %.2f%%" % (scores[1]*100))

Neste caso em particular, obtivemos a precisão de 95,56%:

45/45 [==============================] - 0s 756us/step 
Precisão: 95,56% 

Por fim, vamos a algumas previsões:

prediction = model.predict(X_test)
prediction1 = pd.DataFrame({'IRIS1':prediction[:,0],'IRIS2':prediction[:,1], 'IRIS3':prediction[:,2]})
prediction1.round(decimals=4).head()

Aqui estão os resultados que obtivemos em comparação com os resultados reais:

Esses bons resultados seriam suspeitos se estivéssemos trabalhando em algum outro conjunto de dados com dados reais. Poderíamos suspeitar que o 'overfitting' aconteceu. No entanto, neste conjunto de dados simples, aceitaremos esses resultados como bons resultados.

7. TensorFlow vs PyTorch

TensorFlow/Keras e PyTorch são as estruturas de aprendizado profundo mais populares. No artigo anterior, escrevemos sobre o PyTorch . Em geral, a diferença está na velocidade (os modelos são treinados mais rapidamente com o PyTorch) e o PyTorch parece, bem... mais pythonic, por assim dizer. O PyTorch também é puramente orientado a objetos, enquanto com o TensorFlow você tem opções. Além disso, o TensorFlow está dominando o setor, enquanto o PyTorch é popular em pesquisas.

Conclusão

As redes neurais existem há muito tempo e quase todos os conceitos importantes foram introduzidos nos anos 1970 ou 1980. O problema que impedia todo o campo de decolar era que naquela época não tínhamos computadores e GPUs poderosos para executar esse tipo de processo. Agora, não apenas podemos fazer isso, mas o Google tornou as redes neurais populares ao tornar essa ótima ferramenta – TensorFlow disponível publicamente.

Obrigado por ler!