tensorflow Handledning
Komma igång med tensorflow

Anmärkningar

Installation eller installation

Från Tensorflow version 1.0 har installationen blivit mycket lättare att utföra. För att installera TensorFlow måste man minst installera pip på sin maskin med en pythonversion av minst 2,7 eller 3,3+.

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

För tensorflöde på en GPU-maskin (från 1.0 krävs CUDA 8.0 och cudnn 5.1, AMD GPU stöds inte)

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

För att testa om det fungerade öppna upp rätt version av python 2 eller 3 och kör

import tensorflow

Om det lyckades utan fel har du tensorflow installerat på din maskin.

* Var medveten om att detta refererar till mastergrenen, man kan ändra detta på länken ovan för att referera till den nuvarande stabila utgåvan.)

Grundläggande exempel

Tensorflow är mer än bara en djup ram för lärande. Det är ett allmänt beräkningsramverk att utföra allmänna matematiska operationer på ett parallellt och distribuerat sätt. Ett exempel på sådant beskrivs nedan.

Linjär regression

Ett grundläggande statistiskt exempel som vanligtvis används och är ganska enkelt att beräkna är att anpassa en linje till ett datasæt. Metoden för att göra det i tensorflow beskrivs nedan i kod och kommentarer.

Huvudstegen i (TensorFlow) -skriptet är:

1. Förklara platshållare ( x_ph , y_ph ) och variabler ( W , b )
2. Definiera initialiseringsoperatören ( init )
3. Förklara operationer på platshållare och variabler ( y_pred , loss , train_op )
4. Skapa en session ( sess )
5. Kör initialiseringsoperatören ( sess.run(init) )
6. Kör några sess.run([train_op, loss], feed_dict={x_ph: x, y_ph: y}) (t.ex. sess.run([train_op, loss], feed_dict={x_ph: x, y_ph: y}) )

Grafkonstruktionen görs med Python TensorFlow API (kan också göras med C ++ TensorFlow API). Om du kör grafen kallas C ++ - rutiner på låg nivå.

'''
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 fungerar enligt principen för dataflödesdiagram. För att utföra någon beräkning finns det två steg:

1. Representera beräkningen som en graf.
2. Kör grafen.

Representation: Liksom alla riktade diagram består ett Tensorflow-diagram av noder och riktningskanter.

Nod: En nod kallas också en Op (står för drift). En nod kan ha flera inkommande kanter men en enda utgående kant.

Edge: Ange inkommande eller utgående data från en nod. I detta fall ingång (ar) och utgång från vissa Node (Op).

När vi säger data menar vi en n-dimensionell vektor känd som Tensor. En Tensor har tre egenskaper: Rang, form och typ

• Rank betyder antal dimensioner för Tensorn (en kub eller låda har rang 3).
• Form betyder värden för dessa dimensioner (rutan kan ha form 1x1x1 eller 2x5x7).
• Typ betyder datatyp i varje koordinat för Tensor.

Utförande: Även om en graf är konstruerad är den fortfarande en abstrakt enhet. Ingen beräkning sker faktiskt förrän vi kör den. För att köra en graf måste vi allokera CPU-resurs till Ops inuti diagrammet. Detta görs med hjälp av Tensorflow Sessions. Steg är:

1. Skapa en ny session.
2. Kör valfri Op inne i diagrammet. Vanligtvis kör vi den sista Op där vi förväntar oss resultatet från vår beräkning.

En inkommande kant på en Op är som ett beroende för data på en annan Op. Så när vi kör någon Op, spåras alla inkommande kanter på den och ops på andra sidan körs också.

Obs: Speciella noder som kallas att spela roll för datakälla eller diskbänk är också möjliga. Till exempel kan du ha en Op som ger ett konstant värde och därmed inga inkommande kanter (se värdet 'matris1' i exemplet nedan) och på liknande sätt Op utan utgående kanter där resultaten samlas (se värdet 'produkt' i exemplet nedan).

Exempel:

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()

Räknar till 10

I det här exemplet använder vi Tensorflow för att räkna till 10. Ja, det här är total överkill, men det är ett trevligt exempel att visa en absolut minimal inställning som krävs för att använda Tensorflow

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)

Det viktiga att inse här är att tillstånd, en, tillägg och uppdatering faktiskt inte innehåller värden. Istället är de referenser till Tensorflow-objekt. Det slutliga resultatet är inte tillstånd , utan istället hämtas genom att använda en Tensorflow för att utvärdera det med hjälp av sess.run (tillstånd)

Detta exempel är från https://github.com/panchishin/learn-to-tensorflow . Det finns flera andra exempel där och en fin graderad inlärningsplan för att bekanta dig med att manipulera Tensorflowgrafen i python.