Aula 07 - Tensor Flow - Redes Neurais - Session
Meu github:
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:
Backing track / Play-along:
Código Fluente
Putz!
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])
Ficamos por aqui e até a próxima.
Meu github:
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
Novamente deixo meus link de afiliados:
Obrigado, até a próxima e bons estudos. ;)
