Aula 07 – Tensor Flow – Redes Neurais – Session

toticavalcanti

Aula 07 – Tensor Flow – Redes Neurais – Session

Voltar para página principal do blog

Meu github:

https://github.com/toticavalcanti

Documentação oficial do TensorFlow:

Link para o notebook da aula:

Se gostarem do conteúdo dêem um joinha 👍 na página do Código Fluente no
Facebook

Link do código fluente no Pinterest

Aproveito para deixar meus link de afiliados:

Toti:

https://www.youtube.com/channel/UCUEtjLuDpcOvR3mIUr-viOA

Backing track / Play-along:

https://www.youtube.com/channel/UCT3TryVMqTqYBjf5g5WAHfA

Código Fluente

https://www.youtube.com/channel/UCgn-O-88XBAwdG9gUWkkb0w

Putz!

https://www.youtube.com/channel/UCZXop2-CECwyFYmHbhnAkAw

Fiquem a vontade para me adicionar ao linkedin.

Aula 07 – Tensor Flow – Redes Neurais – Session

Agora que o gráfico tem todos os nós no lugar, o que precisamos fazer é garantir a execução de todos esses nós.

As operações, incluindo as variáveis e marcadores de posição, ou seja, os Placeholders, dentro da sessão na ordem certa.

Iremos usar uma travessia de árvore de pós-pedido( post order tree traversal ), para garantir que os nós serão executados na ordem correta.

Você não precisa se preocupar em entender como o post order traversal funciona.

Mas, se quiser se aprofundar, ou pelo menos dá uma sacada sem compromisso, é só acessar a página da Wikipedia sobre a travessia de árvores.

Chamaremos o método de traverse_postorder().

O que o traverse_postorder() faz basicamente é garantir que os cálculos serão executados na ordem certa.

Então, por exemplo, precisamos executar A vezes x primeiro e depois disso podemos fazer x mais b.

Então, tudo isso é recursivo e acaba retornando uma lista de todos os nós na ordem correta.

O código do traverse_postorder()


# Garante a ordem de execução correta das computações
def traverse_postorder(operation):
  """
  Percorre os nós na ordem correta, executando portanto a 
  computação na ordem correta, primeiro Ax depois Ax + b.
  """
    
    nodes_postorder = []
    
    def recurse(node):
    	# verifica se o nó é uma instância de Operation
        if isinstance(node, Operation):
        	# se entrou, é porque no nó é uma operação
        	# percorre a lista input_nodes do nó da classe Operation
            for input_node in node.input_nodes:
            	# Chama recursivamente a recurse() passando cada elemento
            	# da lista input_nodes do nó da classe Operation
                recurse(input_node)
        # quando sai do if faz o append na lista nodes_postorder,
        # de um dicionário onde o nome do nó é a chave
        # e o valor é o próprio nó, o payload do nó.
        nodes_postorder.append({node.name: node})
      # chamada da função recurse() passando a operação   
      recurse(operation)
      return nodes_postorder

Algoritmo Postorder(tree)

1. Atravessa a subárvore esquerda, ou seja, chama a Postorder(left-subtree)
2. Atravessa a subárvore direita, ou seja, chama a Postorder(right-subtree)
3. Visita o nó

Agora vamos ao Session

Vamos criar um método na classe de Sessão chamado run(), recebe o self, a instância dele mesmo, recebe a operação, e vamos ter também um dicionário, usando a mesma terminologia( feed_dict ) usada no tensorflow.

Portanto, a Operation em si é a operação a calcular e o dicionário de feed_dict é um dicionário mapeando placeholders para valores de entrada.

Em nosso grafo, só temos valores para as variáveis, não temos nenhum valor para o placeholder ainda.

Usaremos o feed_dict para receber esses valores para placeholders.

A razão do dicionário feed, é porque vamos alimentar nossa rede com lotes de dados mais na frente, e é por isso que o tensorflow adotou o feed na terminologia.

O código da Session


#Executa o grafo com a classe Session
class Session():
    # O termo feed_dict é pra manter a mesma terminologia do tensorflow
    def run(self, operation, feed_dict={}):
        # Recebe a ordem da execução
        nodes_postorder = traverse_postorder(operation)
        
        for node_d in nodes_postorder:
            
            node = list(node_d.values())[0]
            print(node.name)
            
            if isinstance(node, Placeholder):
                #Nó Placeholder
                node.value = feed_dict[node]
            elif isinstance(node, Operation):
                #Nó Operation
                node.inputs = [input_node.value for input_node in node.input_nodes]
                #computa
                node.value = node.compute(*node.inputs) 
                # * infere que o número de parâmetros é determinado 
                # pelo tamanho da lista
                print(node.name, " Inputs :", node.inputs, "Out: ", node.value)
                # Converte a lista para um numpy array
                if type(node.value) == list:
                    # Para matmul funcionar
                    node.value = np.array(node.value)
                
        return operation.value


#Criando uma Session
sess = Session()
result = sess.run(operation = z, feed_dict = { x: 10 })
result

#Multiplicação de matriz
g = Graph()
g.set_as_default()
A = Variable([[10, 20],[30, 40]])
b = Variable([1, 1])