tensorflow Zelfstudie
Aan de slag met tensorflow

Opmerkingen

Installatie of instellingen

Vanaf versie 1.0 van Tensorflow is de installatie veel eenvoudiger uit te voeren. Om TensorFlow minimaal te installeren, moet men pip op hun machine hebben geïnstalleerd met een python-versie van minimaal 2.7 of 3.3+.

pip install --upgrade tensorflow      # for Python 2.7
pip3 install --upgrade tensorflow     # for Python 3.n

Voor tensorflow op een GPU-machine (vanaf 1.0 vereist CUDA 8.0 en cudnn 5.1, AMD GPU niet ondersteund)

pip install --upgrade tensorflow-gpu  # for Python 2.7 and GPU
pip3 install --upgrade tensorflow-gpu # for Python 3.n and GPU

Om te testen of het werkte, open je de juiste versie van python 2 of 3 en voer je het uit

import tensorflow

Als dat zonder fouten is gelukt, hebt u tensorflow op uw machine geïnstalleerd.

* Let op: dit verwijst naar de master branch, men kan dit veranderen op de bovenstaande link om te verwijzen naar de huidige stabiele release.)

Basis voorbeeld

Tensorflow is meer dan alleen een diepgaand leerkader. Het is een algemeen berekeningsraamwerk om algemene wiskundige bewerkingen op een parallelle en gedistribueerde manier uit te voeren. Een voorbeeld hiervan wordt hieronder beschreven.

Lineaire regressie

Een statistisch basisvoorbeeld dat vaak wordt gebruikt en vrij eenvoudig te berekenen is, is het aanpassen van een lijn aan een gegevensset. De methode om dit te doen in tensorflow wordt hieronder beschreven in code en opmerkingen.

De belangrijkste stappen van het (TensorFlow) -script zijn:

1. Verklaar tijdelijke aanduidingen ( x_ph , y_ph ) en variabelen ( W , b )
2. Definieer de initialisatie-operator ( init )
3. Geef bewerkingen aan op de tijdelijke aanduidingen en variabelen ( y_pred , loss , train_op )
4. Maak een sessie ( sess )
5. Voer de initialisatie-operator uit ( sess.run(init) )
6. Voer enkele grafiekbewerkingen uit (bijv. sess.run([train_op, loss], feed_dict={x_ph: x, y_ph: y}) )

De grafische constructie wordt gedaan met behulp van de Python TensorFlow API (kan ook worden gedaan met de C ++ TensorFlow API). Het uitvoeren van de grafiek roept C ++ routines op laag niveau aan.

'''
function: create a linear model which try to fit the line 
          y = x + 2 using SGD optimizer to minimize 
          root-mean-square(RMS) loss function

'''
import tensorflow as tf
import numpy as np

# number of epoch
num_epoch = 100

# training data x and label y
x = np.array([0., 1., 2., 3.], dtype=np.float32)
y = np.array([2., 3., 4., 5.], dtype=np.float32)

# convert x and y to 4x1 matrix
x = np.reshape(x, [4, 1])
y = np.reshape(y, [4, 1])

# test set(using a little trick)
x_test = x + 0.5
y_test = y + 0.5

# This part of the script builds the TensorFlow graph using the Python API

# First declare placeholders for input x and label y
# Placeholders are TensorFlow variables requiring to be explicitly fed by some 
# input data
x_ph = tf.placeholder(tf.float32, shape=[None, 1])
y_ph = tf.placeholder(tf.float32, shape=[None, 1])

# Variables (if not specified) will be learnt as the GradientDescentOptimizer
# is run
# Declare weight variable initialized using a truncated_normal law
W = tf.Variable(tf.truncated_normal([1, 1], stddev=0.1))
# Declare bias variable initialized to a constant 0.1
b = tf.Variable(tf.constant(0.1, shape=[1]))

# Initialize variables just declared 
init = tf.initialize_all_variables()

# In this part of the script, we build operators storing operations
# on the previous variables and placeholders.
# model: y = w * x + b
y_pred = x_ph * W + b

# loss function
loss = tf.mul(tf.reduce_mean(tf.square(tf.sub(y_pred, y_ph))), 1. / 2)
# create training graph
train_op = tf.train.GradientDescentOptimizer(0.1).minimize(loss)

# This part of the script runs the TensorFlow graph (variables and operations
# operators) just built.
with tf.Session() as sess:
    # initialize all the variables by running the initializer operator
    sess.run(init)
    for epoch in xrange(num_epoch):
        # Run sequentially the train_op and loss operators with
        # x_ph and y_ph placeholders fed by variables x and y
        _, loss_val = sess.run([train_op, loss], feed_dict={x_ph: x, y_ph: y})
        print('epoch %d: loss is %.4f' % (epoch, loss_val))

    # see what model do in the test set
    # by evaluating the y_pred operator using the x_test data
    test_val = sess.run(y_pred, feed_dict={x_ph: x_test})
    print('ground truth y is: %s' % y_test.flatten())
    print('predict y is     : %s' % test_val.flatten())

Tensorflow Basics

Tensorflow werkt volgens het principe van dataflowgrafieken. Om een berekening uit te voeren, zijn er twee stappen:

1. Vertegenwoordig de berekening als een grafiek.
2. Voer de grafiek uit.

Weergave: zoals elke gerichte grafiek bestaat een Tensorflow-grafiek uit knooppunten en richtingsranden.

Knooppunt: een knooppunt wordt ook een Op genoemd (staat voor bewerking). Een knooppunt kan meerdere binnenkomende randen hebben, maar één uitgaande rand.

Edge: geef inkomende of uitgaande gegevens van een knooppunt aan. In dit geval invoer (s) en uitvoer van sommige Node (Op).

Wanneer we gegevens zeggen, bedoelen we een n-dimensionale vector die Tensor wordt genoemd. Een Tensor heeft drie eigenschappen: Rank, Shape en Type

• Rang betekent aantal dimensies van de Tensor (een kubus of doos heeft rang 3).
• Vorm betekent waarden van die dimensies (vak kan vorm 1x1x1 of 2x5x7 hebben).
• Type betekent datatype in elke coördinaat van Tensor.

Uitvoering: Hoewel een grafiek is geconstrueerd, is deze nog steeds een abstracte entiteit. Er vindt pas een berekening plaats als we deze uitvoeren. Om een grafiek uit te voeren, moeten we CPU-bronnen toewijzen aan Ops in de grafiek. Dit wordt gedaan met behulp van Tensorflow Sessions. Stappen zijn:

1. Maak een nieuwe sessie aan.
2. Voer elke bewerking in de grafiek uit. Meestal voeren we de laatste Op uit waar we de uitvoer van onze berekening verwachten.

Een inkomende edge op een Op is als een afhankelijkheid voor gegevens op een andere Op. Dus als we een Op uitvoeren, worden alle binnenkomende randen erop getraceerd en worden de ops aan de andere kant ook uitgevoerd.

Opmerking: speciale knooppunten die de rol van gegevensbron of sink worden genoemd, zijn ook mogelijk. U kunt bijvoorbeeld een Op hebben die een constante waarde geeft, dus geen binnenkomende randen (verwijs naar waarde 'matrix1' in het onderstaande voorbeeld) en op dezelfde manier zonder uitgaande randen waar resultaten worden verzameld (verwijs naar waarde 'product' in het onderstaande voorbeeld).

Voorbeeld:

import tensorflow as tf

# Create a Constant op that produces a 1x2 matrix.  The op is
# added as a node to the default graph.
#
# The value returned by the constructor represents the output
# of the Constant op.
matrix1 = tf.constant([[3., 3.]])

# Create another Constant that produces a 2x1 matrix.
matrix2 = tf.constant([[2.],[2.]])

# Create a Matmul op that takes 'matrix1' and 'matrix2' as inputs.
# The returned value, 'product', represents the result of the matrix
# multiplication.
product = tf.matmul(matrix1, matrix2)

# Launch the default graph.
sess = tf.Session()

# To run the matmul op we call the session 'run()' method, passing 'product'
# which represents the output of the matmul op.  This indicates to the call
# that we want to get the output of the matmul op back.
#
# All inputs needed by the op are run automatically by the session.  They
# typically are run in parallel.
#
# The call 'run(product)' thus causes the execution of three ops in the
# graph: the two constants and matmul.
#
# The output of the op is returned in 'result' as a numpy `ndarray` object.
result = sess.run(product)
print(result)
# ==> [[ 12.]]

# Close the Session when we're done.
sess.close()

Tellen tot 10

In dit voorbeeld gebruiken we Tensorflow om tot 10 te tellen. Ja, dit is totale overkill, maar het is een mooi voorbeeld om een absoluut minimale installatie te tonen die nodig is om Tensorflow te gebruiken

import tensorflow as tf

# create a variable, refer to it as 'state' and set it to 0
state = tf.Variable(0)

# set one to a constant set to 1
one = tf.constant(1)

# update phase adds state and one and then assigns to state
addition = tf.add(state, one)
update = tf.assign(state, addition )

# create a session
with tf.Session() as sess:
  # initialize session variables
  sess.run( tf.global_variables_initializer() )

  print "The starting state is",sess.run(state)

  print "Run the update 10 times..."
  for count in range(10):
    # execute the update
    sess.run(update)

  print "The end state is",sess.run(state)

Het belangrijkste om hier te realiseren is dat status, één, toevoeging en update geen waarden bevatten. In plaats daarvan zijn het verwijzingen naar Tensorflow-objecten. Het uiteindelijke resultaat is geen status , maar wordt in plaats daarvan opgehaald met een Tensorflow om het te evalueren met sess.run (status)

Dit voorbeeld is afkomstig van https://github.com/panchishin/learn-to-tensorflow . Er zijn daar verschillende andere voorbeelden en een leuk afgestudeerd leerplan om kennis te maken met het manipuleren van de Tensorflow-grafiek in python.