Persönliche Blog Navigationsseite (klicken Sie auf der rechten Seite Link einen persönlichen Blog zu öffnen): Daniel nehmen Sie mit auf Technologie - Stack
TensorFlow Eintrag
Dieser Artikel beschreibt , wie Sie den ursprünglichen Code TensorFlow an die Landwirte und Verfahren Yuan verwenden sind programmiert. Vor dem Lesen bitte TensorFlow installieren , zusätzlich , um besser zu verstehen , den Inhalt des Artikels, müssen Sie ein wenig Wissen verstehen , bevor die folgende Lektüre:
- Python Grundprogrammierung. Kann Python-Code verstehen, ist es am besten, ein Werkzeug oder PyCharm IDC-Skript zu verwenden, wie das Schreiben von Code.
- Zumindest ist die Idee der Anordnung.
- Idealzustand ist die Grundlage des Wissens mit maschinellem Lernen. Aber wenn es nicht verstehen, bevor sie ein maschinelles Lernen bezogenes Wissen keine ernsthaftes Problem zu lesen, wie Sie die Papiermaschine Lernstart verstehen können. Es wird eine weitere später mit MNIST verstehen öffnen, die Grundlagen des maschinellen Lernens.
TensorFlow bietet eine Vielzahl von API - Schnittstelle, die TensorFlow Kern ist die niedrigste Ebene Schnittstelle , die für die Entwicklung von TensorFlow grundlegende Unterstützung bietet. Die offizielle Empfehlung TensorFlow Kern als Maschinenlernforschung und die damit verbundene Datenmodellierung. Darüber hinaus gibt es eine Abstraktion höher TensorFlow Core - API - Schnittstelle, die API - Schnittstellen einfacher zu bedienen als TensorFlow Kern, einfacher zu schnell geschäftliche Anforderungen zu erzielen. Zum Beispiel tf.contrib.learn - Schnittstelle , die eine Reihe von Datenmanagement, Datenauswertung, Schulungen und anderen Inferenz - Funktionen zur Verfügung stellt. Erfordern besondere Aufmerksamkeit bei der Entwicklung des Einsatzes von TensorFlow zu contrib Beginn der API - Schnittstelle noch noch in der Entwicklung ist, ist es wahrscheinlich in einer zukünftigen Version oder totale Streichung angepasst werden.
Dieses Papier stellt TensorFlow Core und wird zeigen, wie tf.contrib.learn einfache Modellierung zu verwenden. Erfahren TensorFlow Core ist damit Entwickler verstehen, wie die zugrunde liegende Arbeit, wenn die abstrakte Schnittstelle, um ein geeigneteres Modell in den Trainingsdaten zu erstellen.
TensorFlow
TensorFlow Basisdateneinheit ein Tensor (Tensor). Ein Tensor, der einen Satz von Vektoren von dem Punkt ist zu verstehen, dass diese Datenstruktur in eine Reihe von Werten in einem Satz aus der Vielzahl von Warteschlangen (Tensor keine Möglichkeit deutlicher wenige Worte, um zu-Tal gespeicherten entspricht Bruder des Mädchens oder für „Tensoranalysis“ suchen kann einfach aus) mehrdimensionaler als Array gedacht werden. Ein Tensor Tensor Dimension Tensor ausgedrückt Hier sind einige Beispiele:
3 # 0阶张量，可以用图形[]来表示 [1. ,2., 3.] # 1阶张量，是一个图形为[3]的向量 [[1., 2., 3.], [4., 5., 6.]] # 2阶张量，是一个图形为[2,3]的矩阵 [[[1., 2., 3.]], [[7., 8., 9.]]] # 图形为[2,1,3]的三阶张量
TensorFlow Core-Kurs
Import TensorFlow
Im Folgenden werden in einer Standardweise TensorFlow Paket eingeführt:
import tensorflow as tfNach Python von der Einleitung stellt tf Zugriff auf alle Einlass TensorFlow Klassen, Methoden und Symbole.
Fig berechnet (Computational Graph)
Programmierung Entwicklung TensorFlow Kern ist zu sehen, zwei Dinge zu tun:
- Konstruktion Berechnung Fig. (Modelling)
- Run Berechnung Diagramm. (Ausführung)
Fig. (Graph, kann auch ein Verbindungsdiagramm bezeichnet wird) zeigt an, dass die Verbindung durch eine Vielzahl von Punkten in der Figur gebildet. Fig bezieht sich hier auf den Pfad TensorFlow Modellierungsoperationen, siehe die gesamte Form TensorBoard Fig verwendet werden.
Knoten (node) in den Zeichnungen, die jeweils von Punkten dargestellt, die von einer Rechenaufgabe repräsentativ sind.
Also kurz gesagt : Programmierung TensorFlow Kern ist eine Reihe von vorarrangierten Knoten Rechenaufgaben gut, und dann diese Aufgaben auszuführen.
Im Folgenden zunächst eine einfache grafische Darstellung konstruieren, werden die Knoten in dem Graphen (Knoten) 0 oder mehr Tensoren als Eingabe und erzeugt als Ausgabe einen Tensor. Ein typischer Knoten ist eine „Konstante“ (konstant). TensorFlow Konstanten im Gebäude Berechnungsmodell existiert hat, macht es keinen Eingang erfordern , wenn die laufende Berechnung. Der folgende Code erstellt zwei Gleitkommazahlen Konstanten Konstante Werte node1 und node2:
node1 = tf.constant(3.0, tf.float32)
node2 = tf.constant(4.0) # also tf.float32 implicitly
print(node1, node2)Nach dem Lauf wird ausgedruckt:
Tensor("Const:0", shape=(), dtype=float32) Tensor("Const_1:0", shape=(), dtype=float32)Beobachten Sie das Ergebnis des Druckens wird feststellen , dass es nicht in Übereinstimmung mit dem erwarteten Ausgang wie 3,0 oder 4,0 Wert. Hier ist der Ausgang einer Knoten Objektinformation. Denn hier hat zweite Aufgabe nicht ausgeführt worden ist - , um das Berechnungsmodell Diagramm laufen. Erst zur Laufzeit wird auf den realen Wert des Knotens verwendet werden , 3,0 und 4,0 . Um eine Session Fig Operation (session), eine Sitzungssteuerverfahren und ein Paket von verschiedenen Zustandsgrößen TensorFlow Laufzeit (Rahmen) zu erzeugen.
Der folgende Code würde eine (session) -Sitzung Objektinstanz erstellen und dann Durchführen run des Verfahrens , das Modell zu berechnen:
sess = tf.Session()
print(sess.run([node1, node2]))Nach dem Lauf werden wir feststellen, dass die gedruckten Ergebnisse sind 3.0 und 4.0:
[3.0, 4.0]Dann node1 und node2 für Summenoperation, und dieser Vorgang ist das Berechnungsmodell der Fig. Der folgende Code ist ein Konstrukt node1 , node2 für node3 Summenoperationsmodell , das den Betrieb darstellt , und, nach dem Gebrauch Build sess.run Run:
node3 = tf.add(node1, node2)
print("node3: ", node3)
print("sess.run(node3): ",sess.run(node3))Nach der Operation ausgeben wird folgende:
node3: Tensor("Add_2:0", shape=(), dtype=float32)
sess.run(node3): 7.0Dies schloss der Prozess der TensorFlow erstellen Diagramme und Grafiken Ausführung.
Erwähnt TensorFlow stellt ein Werkzeug genannt TensorBoard, das Werkzeug ist in der Lage Anzeigeoperation Knoten von Fig. Im Folgenden ist ein Beispiel für eine Berechnung TensorBoard visuelle siehe Abb:
Diese Konstante Betriebsergebnisse und von geringen Wert, denn er war immer eine Konstante erzeugt ein festes Ergebnis. Fig Knoten in eine Weise fähig ist, einen externen Eingabeparameter zu akzeptieren - wie die Verwendung Platzhalter. Platzhalter kann, bis die Anzahl warten und dann dynamisch berechnet, wenn das Modell läuft:
a = tf.placeholder(tf.float32)
b = tf.placeholder(tf.float32)
adder_node = a + b # + 可以代替tf.add(a, b)构建模型Oberhalb dieser Linie 3 mit etwas wie eine Funktion oder ein Lambda-Ausdruck die Eingangsparameter zu erhalten. Wir können Eingabe verschiedene Parameter zur Laufzeit der Zahl berechnen:
print(sess.run(adder_node, {a: 3, b:4.5}))
print(sess.run(adder_node, {a: [1,3], b: [2, 4]}))Die Ausgabe lautet:
7.5
[ 3. 7.]In TensorBoard wird berechnet Grafik dargestellt:
Wir können komplexere Ausdrücke verwenden, um Inhalte hinzufügen berechnet:
add_and_triple = adder_node * 3.
print(sess.run(add_and_triple, {a: 3, b:4.5}))Berechnen Sie die Ausgabe:
22.5TensorBoard Anzeige:
In einem Modell des maschinellen Lernens erfordert häufig verschiedene Arten von Daten als Eingabe empfängt. Um ein kontinuierliches Trainingsmodell zu machen normalerweise müssen Sie eine neue Ausgabe für das gleiche Eingang modifizierte Modell von Figur erhalten zu können. Variablen (Variablen) kann die Trainingsparameter auf die Figur erhöhen, werden sie von der ursprünglichen Art erstellt werden , und einen Standardwert angeben:
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
x = tf.placeholder(tf.float32)
linear_model = W * x + bWie bereits in der Aufforderung genannten tf.constant initialisiert , wenn unveränderliche Konstante. Und hier durch die anrufende tf.Variable Variablen erstellt werden nicht (vor TensorFlow laufen , um initialisiert werden , sess.runbevor Sie das Betriebsmodell durchführen) initialisiert alle Variablen müssen den Schritt erhöhen init Betrieb:
init = tf.global_variables_initializer()
sess.run(init)Überlastung kann init alle Variablen TensorFlow Figur global initialisiert werden. In dem obigen Code, rufen wir sess.run vor, alle Variablen nicht initialisiert werden.
Das Folgende x ist ein Platzhalter, {x:[1,2,3,4]} steht der Ersatzwert für die Berechnung von x [1,2,3,4]:
print(sess.run(linear_model, {x:[1,2,3,4]}))Ausgang:
[ 0. 0.30000001 0.60000002 0.90000004]Nun , da Sie haben ein Rechenmodell erstellt, aber es ist nicht klar , ob oder nicht wirksam genug , um ihn effektiver, wodurch die Notwendigkeit für diese Ausbildung Modelldaten zu machen. Der folgende Code definiert benannt y den gewünschten Wert liefern Platzhalter und dann schreibe eine „Verlustfunktion“ (Verlustfunktion).
Eine „Verlustfunktion“ wird verwendet , um das aktuelle Modell für diejenigen zu messen, die das Ziel, wie viel Leistung aus dem Werkzeug erreichen wollen. Im folgenden Beispiel wird eine lineare Regressionsmodell als Verlust. Regressionsverfahren sind: Verlustberechnung Modellausgangsgröße ( yDifferenz) und dann quadriert diese Differenz (Abweichung), und dann wird der Ergebnisvektor und die Varianz - Berechnung durchgeführt wird . Der folgende Code, linear_model - y einen Vektor erstellen, stellt jeder Vektor , der einen Wert an die Fehler Inkrement entspricht. Dann rufen Sie tf.square auf der Zwischen Fehler Quadrierung. Schließlich werden alle der Varianz Ergebnisse addiert einen skalaren Wert zu abstrahieren einer Fehlerdifferenz zu erzeugen, verwenden Sie tf.reduce_sumdiese Arbeit zu tun. Wie der folgenden Code:
# 定义占位符
y = tf.placeholder(tf.float32)
# 方差运算
squared_deltas = tf.square(linear_model - y)
# 定义损益模型
loss = tf.reduce_sum(squared_deltas)
# 输出损益计算结果
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))Nach der Berechnung des Differenzwertes ist:
23.66Sie können manuell W und b ändern Sie den Wert -1 und 1 reduzieren Unterschiede in den Ergebnissen. TensorFlow verwendeten tf.Variable Variablen zu erstellen, unter Verwendung tf.assign modifizierter Variablen. Zum Beispiel W=-1 , b=1 ist es die aktuell beste Wert - Modell, so dass Sie ihre Werte ändern können , wie folgt:
fixW = tf.assign(W, [-1.])
fixb = tf.assign(b, [1.])
sess.run([fixW, fixb])
print(sess.run(loss, {x:[1,2,3,4], y:[0,-1,-2,-3]}))Die endgültigen Ausgabeergebnisse geändert, nachdem Sie wie folgt vor:
0.0tf.train Schnittstelle
Füllen Sie das Verfahren des maschinellen Lernens sprengt den Rahmen dieses Artikels sprengen , nur den Prozess der Ausbildung zu veranschaulichen. TensorFlow bietet viele Optimierer nach und nach (oder Iterationsschleife) jeden Parameter, anzupassen und letztlich den Verlust Wert so gering wie möglich. Eine der einfachsten Optimierung ist „gradient descent“ ( gradient descent von ), wäre es Verlustberechnungsmodell Ableitung und den Wert der Eingangsvariablen eingestellt entsprechend einem Ergebnis der Ableitung ( Wund b), so dass der Endzweck der Ableitung Folge schrittweise bewegenden 0. den Derivats von Hand Berechnung ist sehr mühsam und fehleranfällig, TensorFlow stellt auch Funktionen tf.gradients für die automatischen Ableitungsprozess. Das folgende Beispiel veranschaulicht den Prozess einen Gradienten abnehmender Trainingsmuster unter Verwendung von :
# 设定优化器，这里的0.01表示训练时的步进值
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
sess.run(init) # 初始化变量值.
for i in range(1000): # 遍历1000次训练数据，每次都重新设置新的W和b值
sess.run(train, {x:[1,2,3,4], y:[0,-1,-2,-3]})
print(sess.run([W, b]))Das Ergebnis dieser Betriebsart ist:
[array([-0.9999969], dtype=float32), array([ 0.99999082], dtype=float32)]Nun, da haben wir den gesamten Prozess des maschinellen Lernens abgeschlossen. Obwohl einfache Berechnung der linearen Regression nicht braucht zu viel TensorFlow Code zu verwenden, aber das ist nur der Fall, zum Beispiel, müssen oft mehr Code schreiben, komplexe Musteranpassung Operationen in der Praxis umzusetzen. TensorFlow eine höhere Abstraktionsebene Schnittstelle gemeinsamen Muster, Struktur und Funktion.
Eine komplette Schulung
Im Folgenden wird auf der Grundlage der vorstehenden Beschreibung, Vorbereitung eines vollständigen linearen Regressionsmodells:
import numpy as np
import tensorflow as tf
# 模型参数
W = tf.Variable([.3], tf.float32)
b = tf.Variable([-.3], tf.float32)
# 模型输入
x = tf.placeholder(tf.float32)
# 模型输出
linear_model = W * x + b
# 损益评估参数
y = tf.placeholder(tf.float32)
# 损益模式
loss = tf.reduce_sum(tf.square(linear_model - y)) # 方差和
# 优化器
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = optimizer.minimize(loss)
# 训练数据
x_train = [1,2,3,4]
y_train = [0,-1,-2,-3]
# 定义训练的循环
init = tf.global_variables_initializer()
sess = tf.Session()
sess.run(init) # reset values to wrong
for i in range(1000):
sess.run(train, {x:x_train, y:y_train})
# 评估训练结果的精确性
curr_W, curr_b, curr_loss = sess.run([W, b, loss], {x:x_train, y:y_train})
print("W: %s b: %s loss: %s"%(curr_W, curr_b, curr_loss))Nach dem Ausführen Ausgänge:
W: [-0.9999969] b: [ 0.99999082] loss: 5.69997e-11Dieses komplexe Programm kann immer noch die visuelle Darstellung TensorBoard:
tf.contrib.learn
Wie bereits erwähnt, bietet TensorFlow zusätzlich TensorFlow Kern, um auch viele weitere abstrakte Schnittstellen Geschäftsentwicklung zu erleichtern. tf.contrib.learn Ist eine High-Level - Bibliothek TensorFlow, sofern er einen vereinfachte Maschinenmechanismen Lernen, einschließlich:
- Run Trainingszyklus
- Run Bewertungszyklus
- Management Datenerfassung
- Data Management Schulung
tf.contrib.learn definiert einige gemeinsame Module.
Grundsätzliche Verwendung
Schauen Sie sich mit tf.contrib.learn linearen Regressionsverfahren zu erreichen.
import tensorflow as tf
# NumPy常用语加载、操作、预处理数据.
import numpy as np
# 定义一个特性列表features。
# 这里仅仅使用了real-valued特性。还有其他丰富的特性功能
features = [tf.contrib.layers.real_valued_column("x", dimension=1)]
# 一个评估者（estimator）是训练（fitting）与评估（inference）的开端。
# 这里预定于了许多类型的训练评估方式，比如线性回归（linear regression）、
# 逻辑回归（logistic regression）、线性分类（linear classification）和回归（regressors）
# 这里的estimator提供了线性回归的功能
estimator = tf.contrib.learn.LinearRegressor(feature_columns=features)
# TensorFlow提供了许多帮助类来读取和设置数据集合
# 这里使用了‘numpy_input_fn’。
# 我们必须告诉方法我们许多多少批次的数据，以及每次批次的规模有多大。
x = np.array([1., 2., 3., 4.])
y = np.array([0., -1., -2., -3.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x":x}, y, batch_size=4,
num_epochs=1000)
# ‘fit’方法通过指定steps的值来告知方法要训练多少次数据
estimator.fit(input_fn=input_fn, steps=1000)
# 最后我们评估我们的模型价值。在一个实例中，我们希望使用单独的验证和测试数据集来避免过度拟合。
estimator.evaluate(input_fn=input_fn)Nach dem Ausführen Ausgabe:
{'global_step': 1000, 'loss': 1.9650059e-11}benutzerdefinierte Modelle
tf.contrib.learn Es ist nicht nur das Standardmodell verwenden begrenzt. Wir nehmen nun ein Preset TensorFlow nicht im Modell erstellen müssen. Wir können immer noch verwenden tf.contrib.learnsehr abstrakten Satz von Datenretention, Trainingsdaten, den Trainingsprozess. Wir werden unser Wissen über niedrigere Ebene TensorFlow API verwenden, die zeigen , wie das Ersatzmodell verwenden LinearRegressor ihre eigenen erreichen.
Verwenden Sie tf.contrib.learn ein eigenes Modell Bedarf erstellen ihre Unterklassen zu verwenden tf.contrib.learn.Estimator . Und tf.contrib.learn.LinearRegressor ist tf.contrib.learn.Estimator Unterklasse. Der folgende Code Estimator eine Add - model_fn Funktion, die erzählt , tf.contrib.learn wie Ausbildung und die Gewinn- und Verlustrechnung bewerten:
import numpy as np
import tensorflow as tf
# 定义一个特征数组，这里仅提供实数特征
def model(features, labels, mode):
# 构建线性模型和预设值
W = tf.get_variable("W", [1], dtype=tf.float64)
b = tf.get_variable("b", [1], dtype=tf.float64)
y = W*features['x'] + b
# 损益子图
loss = tf.reduce_sum(tf.square(y - labels))
# 训练子图
global_step = tf.train.get_global_step()
optimizer = tf.train.GradientDescentOptimizer(0.01)
train = tf.group(optimizer.minimize(loss),
tf.assign_add(global_step, 1))
# ModelFnOps方法将创建我们自定义的一个抽象模型。
return tf.contrib.learn.ModelFnOps(
mode=mode, predictions=y,
loss=loss,
train_op=train)
estimator = tf.contrib.learn.Estimator(model_fn=model)
# 定义数据集
x = np.array([1., 2., 3., 4.])
y = np.array([0., -1., -2., -3.])
input_fn = tf.contrib.learn.io.numpy_input_fn({"x": x}, y, 4, num_epochs=1000)
# 训练数据
estimator.fit(input_fn=input_fn, steps=1000)
# 评估模型
print(estimator.evaluate(input_fn=input_fn, steps=10))Nach dem Ausführen Ausgabe:
{'loss': 5.9819476e-11, 'global_step': 1000}Befestigt Java / C / C ++ / Maschinelles Lernen / Algorithmen und Datenstrukturen / Front-End / Android / Python / Programmierer Lesen / Einzel Bücher Bücher Daquan:
(Klicken Sie auf der rechten Seite im trockenen persönlichen Blog zu öffnen dort): Technische trocken Blüte
===== >> ① [Java Daniel Sie auf dem Weg zur erweiterten nehmen] << ====
===== >> ② [+ acm Algorithmus Datenstruktur Daniel nehmen Sie auf dem Weg zur erweiterten] << ===
===== >> ③ [Datenbank Daniel Sie auf dem Weg zur erweiterten nehmen] << == ===
===== >> ④ [Daniel Web-Frontend Sie auf dem Weg zur erweiterten nehmen] << ====
===== >> ⑤ [maschinelles Lernen python und Daniel nehmen Sie Eintritt in die advanced road] << ====
===== >> ⑥ [Architekt Daniel nehmen Sie auf dem Weg zur erweiterten] << =====
===== >> ⑦ [C ++ Daniel voran Sie auf der Straße nehmen] << ====
===== >> ⑧ [ios Daniel nehmen Sie auf dem Weg zur erweiterten] << ====
=====> > ⑨ [Websicherheit Daniel Sie auf dem Weg zur erweiterten nehmen] << =====
===== >> ⑩ [Linux - Betriebssystem und Daniel Sie auf dem Weg zur erweiterten nehmen] << = ====Es gibt keine unearned Früchte, hoffen, dass Sie junge Freunde, wollen Freunde Techniken lernen, von der Straße in der Art und Weise, alle Hindernisse zu überwinden bestimmt in Technologie zu binden, zu verstehen, das Buch, und dann auf den Code klopfen, verstehen das Prinzip und Praxis gehen, werden es bringt Ihnen das Leben, Ihre Arbeit, Ihre Zukunft einen Traum.
