Το TensorFlow είναι μια βιβλιοθήκη λογισμικού ανοιχτού κώδικα που δημιουργήθηκε από την Google και χρησιμοποιείται για την εφαρμογή συστημάτων μηχανικής μάθησης και βαθιάς μάθησης. Αυτά τα δύο ονόματα περιέχουν μια σειρά ισχυρών αλγορίθμων που μοιράζονται μια κοινή πρόκληση - για να επιτρέψει σε έναν υπολογιστή να μάθει πώς να εντοπίζει αυτόματα σύνθετα μοτίβα ή / και να λαμβάνει τις καλύτερες δυνατές αποφάσεις.

Εάν ενδιαφέρεστε για λεπτομέρειες σχετικά με αυτά τα συστήματα, μπορείτε να μάθετε περισσότερα από τις αναρτήσεις ιστολογίου ApeeScape μηχανική εκμάθηση και βαθιά μάθηση .

Το TensorFlow, στην καρδιά του, είναι μια βιβλιοθήκη για προγραμματισμό ροής δεδομένων. Αξιοποιεί διάφορες τεχνικές βελτιστοποίησης για να κάνει τον υπολογισμό των μαθηματικών εκφράσεων ευκολότερο και πιο αποδοτικό.

Μερικά από τα βασικά χαρακτηριστικά του TensorFlow είναι:

• Λειτουργεί αποτελεσματικά με μαθηματικές εκφράσεις που περιλαμβάνουν πολυδιάστατους πίνακες
• Καλή υποστήριξη βαθιών νευρωνικών δικτύων και έννοιας μηχανικής μάθησης
• Υπολογισμός GPU / CPU όπου μπορεί να εκτελεστεί ο ίδιος κώδικας και στις δύο αρχιτεκτονικές
• Υψηλή επεκτασιμότητα υπολογισμού σε μηχανήματα και τεράστια σύνολα δεδομένων

Μαζί, αυτά τα χαρακτηριστικά καθιστούν το TensorFlow το τέλειο πλαίσιο για την ευφυΐα του μηχανήματος σε κλίμακα παραγωγής.

Σε αυτό το σεμινάριο TensorFlow, θα μάθετε πώς μπορείτε να χρησιμοποιήσετε απλές αλλά ισχυρές μεθόδους μηχανικής εκμάθησης στο TensorFlow και πώς μπορείτε να χρησιμοποιήσετε μερικές από τις βοηθητικές βιβλιοθήκες του για εντοπισμό σφαλμάτων, οπτικοποίηση και τροποποίηση των μοντέλων που δημιουργήθηκαν με αυτό.

Εγκατάσταση του TensorFlow

Θα χρησιμοποιούμε το TensorFlow Python API, το οποίο λειτουργεί με Python 2.7 και Python 3.3+. Η έκδοση GPU (μόνο Linux) απαιτεί το Cuda Toolkit 7.0+ και cuDNN v2 +.

Θα χρησιμοποιήσουμε το σύστημα διαχείρισης εξαρτήσεων πακέτων Conda για να εγκαταστήσουμε το TensorFlow. Το Conda μας επιτρέπει να διαχωρίζουμε πολλά περιβάλλοντα σε ένα μηχάνημα. Μπορείτε να μάθετε πώς να εγκαταστήσετε το Conda από εδώ .

Μετά την εγκατάσταση του Conda, μπορούμε να δημιουργήσουμε το περιβάλλον που θα χρησιμοποιήσουμε για την εγκατάσταση και χρήση του TensorFlow. Η ακόλουθη εντολή θα δημιουργήσει το περιβάλλον μας με κάποιες επιπλέον βιβλιοθήκες όπως NumPy , το οποίο είναι πολύ χρήσιμο μόλις αρχίσουμε να χρησιμοποιούμε το TensorFlow.

Η έκδοση Python που είναι εγκατεστημένη σε αυτό το περιβάλλον είναι 2,7 και θα χρησιμοποιήσουμε αυτήν την έκδοση σε αυτό το άρθρο.

conda create --name TensorflowEnv biopython

Για να κάνουμε τα πράγματα εύκολα, εγκαθιστούμε το biopython αντί για το NumPy. Αυτό περιλαμβάνει το NumPy και μερικά άλλα πακέτα που θα χρειαζόμασταν. Μπορείτε πάντα να εγκαταστήσετε τα πακέτα όπως τα χρειάζεστε χρησιμοποιώντας το conda install ή το pip install εντολές.

Η ακόλουθη εντολή θα ενεργοποιήσει το δημιουργημένο περιβάλλον Conda. Θα είμαστε σε θέση να χρησιμοποιήσουμε πακέτα που είναι εγκατεστημένα σε αυτό, χωρίς ανάμειξη με πακέτα που είναι εγκατεστημένα παγκοσμίως ή σε κάποια άλλα περιβάλλοντα.

source activate TensorFlowEnv

Το εργαλείο εγκατάστασης pip είναι ένα τυπικό μέρος ενός περιβάλλοντος Conda. Θα το χρησιμοποιήσουμε για να εγκαταστήσουμε τη βιβλιοθήκη TensorFlow. Πριν από αυτό, ένα καλό πρώτο βήμα είναι η ενημέρωση του pip στην πιο πρόσφατη έκδοση, χρησιμοποιώντας την ακόλουθη εντολή:

pip install --upgrade pip

Τώρα είμαστε έτοιμοι να εγκαταστήσουμε το TensorFlow, εκτελώντας:

pip install tensorflow

Η λήψη και η κατασκευή του TensorFlow μπορεί να διαρκέσει αρκετά λεπτά. Κατά τη στιγμή της σύνταξης, αυτό εγκαθιστά το TensorFlow 1.1.0.

Γραφήματα ροής δεδομένων

Στο TensorFlow, ο υπολογισμός περιγράφεται χρησιμοποιώντας γραφήματα ροής δεδομένων. Κάθε κόμβος του γραφήματος αντιπροσωπεύει μια παρουσία μιας μαθηματικής λειτουργίας (όπως προσθήκη, διαίρεση ή πολλαπλασιασμός) και κάθε άκρη είναι ένα πολυδιάστατο σύνολο δεδομένων (τανυστής) στο οποίο εκτελούνται οι λειτουργίες.

Καθώς το TensorFlow λειτουργεί με υπολογιστικά γραφήματα, διαχειρίζονται όπου κάθε κόμβος αντιπροσωπεύει το παράδειγμα μιας λειτουργίας όπου κάθε λειτουργία έχει μηδενικές ή περισσότερες εισόδους και μηδέν ή περισσότερες εξόδους.

Οι άκρες στο TensorFlow μπορούν να ομαδοποιηθούν σε δύο κατηγορίες: Κανονική δομή μεταφοράς δεδομένων άκρων (τεντωτές) όπου είναι πιθανό η έξοδος μιας λειτουργίας να γίνει η είσοδος για άλλη λειτουργία και ειδικά άκρα, τα οποία χρησιμοποιούνται για τον έλεγχο της εξάρτησης μεταξύ δύο κόμβων για να ορίσουν σειρά λειτουργίας όπου ένας κόμβος περιμένει να ολοκληρωθεί ο άλλος.

Απλές εκφράσεις

Πριν προχωρήσουμε για να συζητήσουμε στοιχεία του TensorFlow, θα κάνουμε πρώτα μια συνεδρία εργασίας με το TensorFlow, για να πάρουμε μια αίσθηση του πώς φαίνεται ένα πρόγραμμα TensorFlow.

Ας ξεκινήσουμε με απλές εκφράσεις και ας υποθέσουμε ότι, για κάποιο λόγο, θέλουμε να αξιολογήσουμε τη συνάρτηση y = 5*x + 13 με τον τρόπο TensorFlow.

Σε απλό κώδικα Python, θα μοιάζει με:

x = -2.0 y = 5*x + 13 print y

που μας δίνει σε αυτήν την περίπτωση αποτέλεσμα 3.0.

Τώρα θα μετατρέψουμε την παραπάνω έκφραση σε όρους TensorFlow.

Σταθερές

Στο TensorFlow, οι σταθερές δημιουργούνται χρησιμοποιώντας τη σταθερά συνάρτησης, η οποία έχει την υπογραφή constant(value, dtype=None, shape=None, name='Const', verify_shape=False), όπου value είναι μια πραγματική σταθερή τιμή που θα χρησιμοποιηθεί σε περαιτέρω υπολογισμούς, dtype είναι η παράμετρος τύπου δεδομένων (π.χ. float32 / 64, int8 / 16, κ.λπ.), shape είναι προαιρετικές διαστάσεις, name είναι ένα προαιρετικό όνομα για τον τανυστή και η τελευταία παράμετρος είναι ένα boolean που δείχνει την επαλήθευση του σχήματος των τιμών.

Εάν χρειάζεστε σταθερές με συγκεκριμένες τιμές μέσα στο μοντέλο προπόνησής σας, τότε το constant αντικείμενο μπορεί να χρησιμοποιηθεί όπως στο ακόλουθο παράδειγμα:

z = tf.constant(5.2, name='x', dtype=tf.float32)

Μεταβλητές

Οι μεταβλητές στο TensorFlow είναι ενδιάμεσες μνήμες που περιέχουν τανυστές που πρέπει να αρχικοποιηθούν ρητά και να χρησιμοποιηθούν στο γράφημα για να διατηρηθεί η κατάσταση κατά τη διάρκεια της περιόδου λειτουργίας. Καλώντας απλώς τον κατασκευαστή η μεταβλητή προστίθεται σε υπολογιστικό γράφημα.

Οι μεταβλητές είναι ιδιαίτερα χρήσιμες μόλις ξεκινήσετε με εκπαιδευτικά μοντέλα και χρησιμοποιούνται για τη διατήρηση και την ενημέρωση παραμέτρων. Μια αρχική τιμή που μεταβιβάστηκε ως όρισμα ενός κατασκευαστή αντιπροσωπεύει έναν τανυστή ή αντικείμενο που μπορεί να μετατραπεί ή να επιστραφεί ως τανυστής. Αυτό σημαίνει ότι εάν θέλουμε να συμπληρώσουμε μια μεταβλητή με ορισμένες προκαθορισμένες ή τυχαίες τιμές που θα χρησιμοποιηθούν στη συνέχεια στη διαδικασία προπόνησης και να ενημερωθούν μέσω επαναλήψεων, μπορούμε να την ορίσουμε με τον ακόλουθο τρόπο:

k = tf.Variable(tf.zeros([1]), name='k')

Ένας άλλος τρόπος για να χρησιμοποιήσετε μεταβλητές στο TensorFlow είναι οι υπολογισμοί όπου η μεταβλητή δεν είναι εκπαιδευμένη και μπορεί να οριστεί με τον ακόλουθο τρόπο:

k = tf.Variable(tf.add(a, b), trainable=False)

Συνεδρίες

Για να αξιολογήσουμε πραγματικά τους κόμβους, πρέπει να εκτελέσουμε ένα υπολογιστικό γράφημα μέσα σε μια περίοδο λειτουργίας.

Μια συνεδρία ενσωματώνει τον έλεγχο και την κατάσταση του χρόνου εκτέλεσης του TensorFlow. Μια περίοδος λειτουργίας χωρίς παραμέτρους θα χρησιμοποιήσει το προεπιλεγμένο γράφημα που δημιουργήθηκε στην τρέχουσα περίοδο λειτουργίας, διαφορετικά η κλάση συνεδρίας δέχεται μια παράμετρο γραφήματος, η οποία χρησιμοποιείται σε αυτήν την περίοδο λειτουργίας που θα εκτελεστεί.

Ακολουθεί ένα σύντομο απόσπασμα κώδικα που δείχνει πώς μπορούν να χρησιμοποιηθούν οι όροι που ορίζονται παραπάνω στο TensorFlow για τον υπολογισμό μιας απλής γραμμικής συνάρτησης.

import tensorflow as tf x = tf.constant(-2.0, name='x', dtype=tf.float32) a = tf.constant(5.0, name='a', dtype=tf.float32) b = tf.constant(13.0, name='b', dtype=tf.float32) y = tf.Variable(tf.add(tf.multiply(a, x), b)) init = tf.global_variables_initializer() with tf.Session() as session: session.run(init) print session.run(y)

Χρήση του TensorFlow: Καθορισμός υπολογιστικών γραφημάτων

Το καλό πράγμα για την εργασία με γραφήματα ροής δεδομένων είναι ότι το μοντέλο εκτέλεσης διαχωρίζεται από την εκτέλεση του (σε CPU, GPU ή σε κάποιο συνδυασμό) όπου, όταν εφαρμοστεί, λογισμικό στο TensorFlow μπορεί να χρησιμοποιηθεί στην CPU ή στην GPU όπου όλη η πολυπλοκότητα σχετίζεται με τον κώδικα η εκτέλεση είναι κρυφή.

Το γράφημα υπολογισμού μπορεί να ενσωματωθεί στη διαδικασία χρήσης της βιβλιοθήκης TensorFlow χωρίς να χρειάζεται Γραφική παράσταση αντικείμενα.

Ένα αντικείμενο γραφήματος στο TensorFlow μπορεί να δημιουργηθεί ως αποτέλεσμα μιας απλής γραμμής κώδικα όπως c = tf.add(a, b). Αυτό θα δημιουργήσει έναν κόμβο λειτουργίας που παίρνει δύο τανυστές a και b που παράγουν το άθροισμά τους c ως έξοδος.

Το γράφημα υπολογισμού είναι μια ενσωματωμένη διαδικασία που χρησιμοποιεί τη βιβλιοθήκη χωρίς να χρειάζεται να καλέσει το γραφική παράσταση αντικείμενο απευθείας. Ένα αντικείμενο γραφήματος στο TensorFlow, το οποίο περιέχει ένα σύνολο λειτουργιών και τανυστών ως μονάδες δεδομένων, χρησιμοποιείται μεταξύ λειτουργιών που επιτρέπουν την ίδια διαδικασία και περιέχει περισσότερα από ένα γραφήματα όπου κάθε γράφημα θα αντιστοιχιστεί σε διαφορετική περίοδο λειτουργίας. Για παράδειγμα, η απλή γραμμή κώδικα c = tf.add(a, b) θα δημιουργήσει έναν κόμβο λειτουργίας που παίρνει δύο τανυστές a και b ως είσοδος και παράγει το άθροισμά τους c ως έξοδος.

Το TensorFlow παρέχει επίσης έναν μηχανισμό τροφοδοσίας για την επιδιόρθωση ενός τανυστή σε οποιαδήποτε λειτουργία στο γράφημα, όπου η τροφοδοσία αντικαθιστά την έξοδο μιας λειτουργίας με την τιμή του τανυστή. Τα δεδομένα ροής μεταβιβάζονται ως όρισμα στο run() κλήση λειτουργίας.

Το placeholder είναι ο τρόπος της TensorFlow να επιτρέπει στους προγραμματιστές να εισάγουν δεδομένα στο γράφημα υπολογισμού μέσω placeholder που είναι δεσμευμένα μέσα σε ορισμένες εκφράσεις. Η υπογραφή του placeholder είναι:

placeholder(dtype, shape=None, name=None)

όπου dtype είναι ο τύπος των στοιχείων των τανυστών και μπορεί να παρέχει τόσο το σχήμα των τανυστών που θα τροφοδοτηθούν όσο και το όνομα της λειτουργίας.

Εάν το σχήμα δεν περάσει, αυτός ο τανυστής μπορεί να τροφοδοτηθεί με οποιοδήποτε σχήμα. Μια σημαντική σημείωση είναι ότι ο τανυστής placeholder πρέπει να τροφοδοτείται με δεδομένα, διαφορετικά, κατά την εκτέλεση της περιόδου σύνδεσης και εάν λείπει αυτό το μέρος, το placeholder δημιουργεί ένα σφάλμα με την ακόλουθη δομή:

InvalidArgumentError (see above for traceback): You must feed a value for placeholder tensor 'y' with dtype float

Το πλεονέκτημα των placeholder είναι ότι επιτρέπουν στους προγραμματιστές να δημιουργούν λειτουργίες και το υπολογιστικό γράφημα γενικά, χωρίς να χρειάζεται να παρέχουν τα δεδομένα εκ των προτέρων για αυτό, και τα δεδομένα μπορούν να προστεθούν σε χρόνο εκτέλεσης από εξωτερικές πηγές.

Ας πάρουμε ένα απλό πρόβλημα πολλαπλασιασμού δύο ακέραιων x και y με τον τρόπο TensorFlow, όπου ένα σύμβολο κράτησης θέσης θα χρησιμοποιηθεί μαζί με έναν μηχανισμό τροφοδοσίας μέσω της περιόδου σύνδεσης run μέθοδος.

import tensorflow as tf x = tf.placeholder(tf.float32, name='x') y = tf.placeholder(tf.float32, name='y') z = tf.multiply(x, y, name='z') with tf.Session() as session: print session.run(z, feed_dict={x: 2.1, y: 3.0})

Οπτικοποίηση του υπολογιστικού γραφήματος με το TensorBoard

Το TensorBoard είναι ένα εργαλείο οπτικοποίησης για την ανάλυση γραφημάτων ροής δεδομένων. Αυτό μπορεί να είναι χρήσιμο για την καλύτερη κατανόηση των μοντέλων μηχανικής μάθησης.

Με το TensorBoard, μπορείτε να αποκτήσετε πληροφορίες σχετικά με διαφορετικούς τύπους στατιστικών στοιχείων σχετικά με τις παραμέτρους και τις λεπτομέρειες σχετικά με τα μέρη του υπολογιστικού γραφήματος γενικά. Δεν είναι ασυνήθιστο ότι ένα βαθύ νευρωνικό δίκτυο έχει μεγάλο αριθμό κόμβων. Το TensorBoard επιτρέπει στους προγραμματιστές να λαμβάνουν πληροφορίες για κάθε κόμβο και πώς εκτελείται ο υπολογισμός κατά τη διάρκεια του χρόνου εκτέλεσης του TensorFlow.

Τώρα ας επιστρέψουμε στο παράδειγμά μας από την αρχή αυτού του σεμιναρίου TensorFlow όπου ορίσαμε μια γραμμική συνάρτηση με τη μορφή y = a*x + b.

Για να καταγράψετε συμβάντα από την περίοδο λειτουργίας που αργότερα μπορούν να χρησιμοποιηθούν στο TensorBoard, το TensorFlow παρέχει το FileWriter τάξη. Μπορεί να χρησιμοποιηθεί για τη δημιουργία ενός αρχείου συμβάντων για αποθήκευση περιλήψεις και εκδηλώσεις όπου ο κατασκευαστής δέχεται έξι παραμέτρους και μοιάζει με:

__init__(logdir, graph=None, max_queue=10, flush_secs=120, graph_def=None, filename_suffix=None)

όπου απαιτείται η παράμετρος logdir και άλλοι έχουν προεπιλεγμένες τιμές. Η παράμετρος γραφήματος θα περάσει από το αντικείμενο συνεδρίας που δημιουργήθηκε στο εκπαιδευτικό πρόγραμμα. Ο πλήρης κωδικός παραδείγματος μοιάζει με:

import tensorflow as tf x = tf.constant(-2.0, name='x', dtype=tf.float32) a = tf.constant(5.0, name='a', dtype=tf.float32) b = tf.constant(13.0, name='b', dtype=tf.float32) y = tf.Variable(tf.add(tf.multiply(a, x), b)) init = tf.global_variables_initializer() with tf.Session() as session: merged = tf.summary.merge_all() // new writer = tf.summary.FileWriter('logs', session.graph) // new session.run(init) print session.run(y)

Προσθέσαμε μόνο δύο νέες γραμμές. Συγχωνεύουμε όλες τις περιλήψεις που συλλέγονται στο προεπιλεγμένο γράφημα και FileWriter χρησιμοποιείται για την απόρριψη συμβάντων στο αρχείο όπως περιγράψαμε παραπάνω, αντίστοιχα.

Αφού εκτελέσετε το πρόγραμμα, έχουμε το αρχείο στα αρχεία καταλόγου καταλόγου και το τελευταίο βήμα είναι να εκτελέσετε tensorboard:

tensorboard --logdir logs/

Τώρα το TensorBoard ξεκινά και λειτουργεί στην προεπιλεγμένη θύρα 6006. Μετά το άνοιγμα http://localhost:6006 και κάνοντας κλικ στο στοιχείο μενού Γραφήματα (που βρίσκεται στην κορυφή της σελίδας), θα μπορείτε να δείτε το γράφημα, όπως αυτό στην παρακάτω εικόνα:

Το TensorBoard επισημαίνει σταθερές και συγκεκριμένους συμβόλους περιληπτικών κόμβων, που περιγράφονται παρακάτω.

Μαθηματικά με TensorFlow

Tensors είναι οι βασικές δομές δεδομένων στο TensorFlow και αντιπροσωπεύουν τις συνδετικές ακμές σε ένα γράφημα ροής δεδομένων.

Ένας τανυστής προσδιορίζει απλά έναν πολυδιάστατο πίνακα ή λίστα. Η δομή του τανυστή μπορεί να αναγνωριστεί με τρεις παραμέτρους: κατάταξη, σχήμα και τύπο.

• Rank: Προσδιορίζει τον αριθμό των διαστάσεων του τανυστή. Μια τάξη είναι γνωστή ως η τάξη ή οι διαστάσεις ενός τανυστή, όπου για παράδειγμα η τάξη τάξης 1 είναι ένας φορέας ή ο τανυστής κατάταξης 2 είναι μήτρα.
• Σχήμα: Το σχήμα ενός τανυστή είναι ο αριθμός των σειρών και των στηλών που έχει.
• Τύπος: Ο τύπος δεδομένων που εκχωρείται σε στοιχεία τανυστή.

Για να δημιουργήσουμε έναν τανυστή στο TensorFlow, μπορούμε να χτίσουμε έναν η-διαστατικό πίνακα. Αυτό μπορεί να γίνει εύκολα χρησιμοποιώντας τη βιβλιοθήκη NumPy ή μετατρέποντας έναν πίνακα διαστάσεων Python σε έναν τανυστή TensorFlow.

Για να δημιουργήσουμε έναν τανυστή 1-d, θα χρησιμοποιήσουμε έναν πίνακα NumPy, τον οποίο θα κατασκευάσουμε περνώντας μια ενσωματωμένη λίστα Python.

import numpy as np tensor_1d = np.array([1.45, -1, 0.2, 102.1])

Η εργασία με αυτόν τον τύπο συστοιχίας είναι παρόμοια με την εργασία με μια ενσωματωμένη λίστα Python. Η κύρια διαφορά είναι ότι ο πίνακας NumPy περιέχει επίσης ορισμένες πρόσθετες ιδιότητες, όπως διάσταση, σχήμα και τύπο.

> > print tensor1d [ 1.45 -1. 0.2 102.1 ] > > print tensor1d[0] 1.45 > > print tensor1d[2] 0.2 > > print tensor1d.ndim 1 > > print tensor1d.shape (4,) > > print tensor1d.dtype float64

Ένας πίνακας NumPy μπορεί εύκολα να μετατραπεί σε τανυστή TensorFlow με τη βοηθητική λειτουργία μετατροπή_to_tensor , που βοηθά τους προγραμματιστές να μετατρέψουν αντικείμενα Python σε αντικείμενα τεντώματος. Αυτή η λειτουργία δέχεται αντικείμενα τανυστή, πίνακες NumPy, λίστες Python και κλίμακες Python.

tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64)

Τώρα, εάν συνδέσουμε τον τανυστή μας με τη συνεδρία TensorFlow, θα είμαστε σε θέση να δούμε τα αποτελέσματα της μετατροπής μας.

tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64) with tf.Session() as session: print session.run(tensor) print session.run(tensor[0]) print session.run(tensor[1])

Παραγωγή:

[ 1.45 -1. 0.2 102.1 ] 1.45 -1.0

Μπορούμε να δημιουργήσουμε έναν τανυστή 2-d ή μια μήτρα με παρόμοιο τρόπο:

tensor_2d = np.array(np.random.rand(4, 4), dtype='float32') tensor_2d_1 = np.array(np.random.rand(4, 4), dtype='float32') tensor_2d_2 = np.array(np.random.rand(4, 4), dtype='float32') m1 = tf.convert_to_tensor(tensor_2d) m2 = tf.convert_to_tensor(tensor_2d_1) m3 = tf.convert_to_tensor(tensor_2d_2) mat_product = tf.matmul(m1, m2) mat_sum = tf.add(m2, m3) mat_det = tf.matrix_determinant(m3) with tf.Session() as session: print session.run(mat_product) print session.run(mat_sum) print session.run(mat_det)

Λειτουργίες Tensor

Στο παραπάνω παράδειγμα, παρουσιάζουμε μερικές λειτουργίες TensorFlow στα διανύσματα και τους πίνακες. Οι λειτουργίες εκτελούν ορισμένους υπολογισμούς στον τανυστή. Ποιοι υπολογισμοί εμφανίζονται στον παρακάτω πίνακα.

Χειριστής TensorFlow	Περιγραφή
tf.add	x + ε
tf. αφαίρεση	x-ε
tf πολλαπλάσια	x * ε
tf.div	x / ε
tf.mod	x% ε
tf.abs	| x |
αρνητικό	-Χ
tf.sign	σύμβολο (x)
tf. τετράγωνο	x * x
στ. γύρο	στρογγυλό (x)
tf.sqrt	τετραγωνικά (x)
tf.pow	x ^ ε
tf.exp	ε ^ x
tf.log	ημερολόγιο (x)
tf. μέγιστο	μέγ. (x, y)
ελάχιστο	ελάχ. (x, y)
tf.cos	cos (x)
tf.sin	αμαρτία (x)

Οι λειτουργίες TensorFlow που αναφέρονται στον παραπάνω πίνακα λειτουργούν με αντικείμενα τανυστή και πραγματοποιούνται με βάση το στοιχείο. Επομένως, εάν θέλετε να υπολογίσετε το συνημίτονο για ένα διάνυσμα x, η λειτουργία TensorFlow θα κάνει υπολογισμούς για κάθε στοιχείο στον περασμένο τανυστή.

tensor_1d = np.array([0, 0, 0]) tensor = tf.convert_to_tensor(tensor_1d, dtype=tf.float64) with tf.Session() as session: print session.run(tf.cos(tensor))

Παραγωγή:

[ 1. 1. 1.]

Λειτουργίες Matrix

Οι λειτουργίες Matrix είναι πολύ σημαντικές για μοντέλα μηχανικής μάθησης, όπως η γραμμική παλινδρόμηση, καθώς χρησιμοποιούνται συχνά σε αυτά. Το TensorFlow υποστηρίζει όλες τις πιο κοινές λειτουργίες matrix, όπως πολλαπλασιασμός , μεταφορά , επένδυση , τον υπολογισμό του καθοριστικός , επίλυση γραμμικές εξισώσεις , και πολλά περισσότερα .

Στη συνέχεια, θα εξηγήσουμε μερικές από τις λειτουργίες του πίνακα. Τείνουν να είναι σημαντικά όταν πρόκειται για μοντέλα μηχανικής μάθησης, όπως στη γραμμική παλινδρόμηση. Ας γράψουμε έναν κώδικα που θα κάνει βασικές λειτουργίες μήτρας όπως πολλαπλασιασμό, λήψη του μεταθέτω , λήψη του καθοριστικού παράγοντα, πολλαπλασιασμός, sol και πολλά άλλα.

Ακολουθούν βασικά παραδείγματα κλήσης αυτών των λειτουργιών.

import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) m1 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m2 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m3 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m4 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m5 = convert(np.array(np.random.rand(4, 4), dtype='float32')) m_tranpose = tf.transpose(m1) m_mul = tf.matmul(m1, m2) m_det = tf.matrix_determinant(m3) m_inv = tf.matrix_inverse(m4) m_solve = tf.matrix_solve(m5, [[1], [1], [1], [1]]) with tf.Session() as session: print session.run(m_tranpose) print session.run(m_mul) print session.run(m_inv) print session.run(m_det) print session.run(m_solve)

Μετασχηματισμός δεδομένων

Μείωση

Το TensorFlow υποστηρίζει διαφορετικά είδη μείωσης. Η μείωση είναι μια λειτουργία που αφαιρεί μία ή περισσότερες διαστάσεις από έναν τανυστή εκτελώντας ορισμένες λειτουργίες σε αυτές τις διαστάσεις. Εδώ μπορείτε να βρείτε μια λίστα με τις υποστηριζόμενες μειώσεις για την τρέχουσα έκδοση του TensorFlow. Θα παρουσιάσουμε μερικά από αυτά στο παρακάτω παράδειγμα.

import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) x = convert( np.array( [ (1, 2, 3), (4, 5, 6), (7, 8, 9) ]), tf.int32) bool_tensor = convert([(True, False, True), (False, False, True), (True, False, False)], tf.bool) red_sum_0 = tf.reduce_sum(x) red_sum = tf.reduce_sum(x, axis=1) red_prod_0 = tf.reduce_prod(x) red_prod = tf.reduce_prod(x, axis=1) red_min_0 = tf.reduce_min(x) red_min = tf.reduce_min(x, axis=1) red_max_0 = tf.reduce_max(x) red_max = tf.reduce_max(x, axis=1) red_mean_0 = tf.reduce_mean(x) red_mean = tf.reduce_mean(x, axis=1) red_bool_all_0 = tf.reduce_all(bool_tensor) red_bool_all = tf.reduce_all(bool_tensor, axis=1) red_bool_any_0 = tf.reduce_any(bool_tensor) red_bool_any = tf.reduce_any(bool_tensor, axis=1) with tf.Session() as session: print 'Reduce sum without passed axis parameter: ', session.run(red_sum_0) print 'Reduce sum with passed axis=1: ', session.run(red_sum) print 'Reduce product without passed axis parameter: ', session.run(red_prod_0) print 'Reduce product with passed axis=1: ', session.run(red_prod) print 'Reduce min without passed axis parameter: ', session.run(red_min_0) print 'Reduce min with passed axis=1: ', session.run(red_min) print 'Reduce max without passed axis parameter: ', session.run(red_max_0) print 'Reduce max with passed axis=1: ', session.run(red_max) print 'Reduce mean without passed axis parameter: ', session.run(red_mean_0) print 'Reduce mean with passed axis=1: ', session.run(red_mean) print 'Reduce bool all without passed axis parameter: ', session.run(red_bool_all_0) print 'Reduce bool all with passed axis=1: ', session.run(red_bool_all) print 'Reduce bool any without passed axis parameter: ', session.run(red_bool_any_0) print 'Reduce bool any with passed axis=1: ', session.run(red_bool_any)

Παραγωγή:

Reduce sum without passed axis parameter: 45 Reduce sum with passed axis=1: [ 6 15 24] Reduce product without passed axis parameter: 362880 Reduce product with passed axis=1: [ 6 120 504] Reduce min without passed axis parameter: 1 Reduce min with passed axis=1: [1 4 7] Reduce max without passed axis parameter: 9 Reduce max with passed axis=1: [3 6 9] Reduce mean without passed axis parameter: 5 Reduce mean with passed axis=1: [2 5 8] Reduce bool all without passed axis parameter: False Reduce bool all with passed axis=1: [False False False] Reduce bool any without passed axis parameter: True Reduce bool any with passed axis=1: [ True True True]

Η πρώτη παράμετρος των τελεστών μείωσης είναι ο τανυστής που θέλουμε να μειώσουμε. Η δεύτερη παράμετρος είναι οι δείκτες διαστάσεων κατά τις οποίες θέλουμε να πραγματοποιήσουμε τη μείωση. Αυτή η παράμετρος είναι προαιρετική και, εάν δεν περάσει, η μείωση θα πραγματοποιηθεί σε όλες τις διαστάσεις.

Μπορούμε να ρίξουμε μια ματιά στο μείωση_ αθροίσματος λειτουργία. Περνάμε έναν τανυστή 2-d και θέλουμε να τον μειώσουμε κατά τη διάσταση 1.

Στην περίπτωσή μας, το ποσό που προκύπτει θα είναι:

[1 + 2 + 3 = 6, 4 + 5 + 6 = 15, 7 + 8 + 9 = 24]

Εάν περάσαμε την ιδιότητα 0, το αποτέλεσμα θα ήταν:

[1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 18]

Εάν δεν περάσουμε κανέναν άξονα, το αποτέλεσμα είναι μόνο το συνολικό άθροισμα:

1 + 4 + 7 = 12, 2 + 5 + 8 = 15, 3 + 6 + 9 = 45

Όλες οι λειτουργίες μείωσης έχουν παρόμοια διεπαφή και παρατίθενται στο TensorFlow τεκμηρίωση μείωσης .

Κατάτμηση

Τμηματοποίηση είναι μια διαδικασία στην οποία μία από τις διαστάσεις είναι η διαδικασία χαρτογράφησης διαστάσεων σε παρεχόμενα ευρετήρια τμημάτων και τα προκύπτοντα στοιχεία καθορίζονται από μια σειρά ευρετηρίου.

Η τμηματοποίηση ομαδοποιεί τα στοιχεία κάτω από επαναλαμβανόμενα ευρετήρια, οπότε για παράδειγμα, στην περίπτωσή μας, έχουμε τμηματοποιημένα αναγνωριστικά [0, 0, 1, 2, 2] εφαρμόζεται στον tensor tens1, που σημαίνει ότι η πρώτη και η δεύτερη σειρά θα μετασχηματιστούν μετά τη λειτουργία τμηματοποίησης (στην περίληψη περιπτώσεων) και θα λάβουν μια νέα συστοιχία, η οποία μοιάζει με (2, 8, 1, 0) = (2+0, 5+3, 3-2, -5+5). Το τρίτο στοιχείο στον τανυστή tens1 είναι άθικτο επειδή δεν ομαδοποιείται σε κανένα επαναλαμβανόμενο ευρετήριο και οι δύο τελευταίες συστοιχίες αθροίζονται με τον ίδιο τρόπο όπως συνέβη για την πρώτη ομάδα. Εκτός από το άθροισμα, το TensorFlow υποστηρίζει προϊόν , σημαίνω , Μέγιστη , και ελάχ .

import tensorflow as tf import numpy as np def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) seg_ids = tf.constant([0, 0, 1, 2, 2]) tens1 = convert(np.array([(2, 5, 3, -5), (0, 3, -2, 5), (4, 3, 5, 3), (6, 1, 4, 0), (6, 1, 4, 0)]), tf.int32) tens2 = convert(np.array([1, 2, 3, 4, 5]), tf.int32) seg_sum = tf.segment_sum(tens1, seg_ids) seg_sum_1 = tf.segment_sum(tens2, seg_ids) with tf.Session() as session: print 'Segmentation sum tens1: ', session.run(seg_sum) print 'Segmentation sum tens2: ', session.run(seg_sum_1) Segmentation sum tens1: [[ 2 8 1 0] [ 4 3 5 3] [12 2 8 0]] Segmentation sum tens2: [3 3 9]

Βοηθητικά προγράμματα ακολουθίας

Τα βοηθητικά προγράμματα ακολουθίας περιλαμβάνουν μεθόδους όπως:

• αργίν συνάρτηση, η οποία επιστρέφει το δείκτη με ελάχιστη τιμή στους άξονες του τανυστή εισόδου,
• argmax συνάρτηση, η οποία επιστρέφει το δείκτη με τη μέγιστη τιμή στους άξονες του τανυστή εισόδου,
• setdiff , που υπολογίζει τη διαφορά μεταξύ δύο λιστών αριθμών ή συμβολοσειρών,
• που συνάρτηση, η οποία θα επιστρέψει στοιχεία είτε από δύο στοιχεία που έχουν περάσει x ή y, η οποία εξαρτάται από την κατάσταση που πέρασε, ή
• μοναδικός λειτουργία, η οποία θα επιστρέψει μοναδικά στοιχεία σε 1-D τανυστή.

Παρακάτω παρουσιάζουμε μερικά παραδείγματα εκτέλεσης:

import numpy as np import tensorflow as tf def convert(v, t=tf.float32): return tf.convert_to_tensor(v, dtype=t) x = convert(np.array([ [2, 2, 1, 3], [4, 5, 6, -1], [0, 1, 1, -2], [6, 2, 3, 0] ])) y = convert(np.array([1, 2, 5, 3, 7])) z = convert(np.array([1, 0, 4, 6, 2])) arg_min = tf.argmin(x, 1) arg_max = tf.argmax(x, 1) unique = tf.unique(y) diff = tf.setdiff1d(y, z) with tf.Session() as session: print 'Argmin = ', session.run(arg_min) print 'Argmax = ', session.run(arg_max) print 'Unique_values = ', session.run(unique)[0] print 'Unique_idx = ', session.run(unique)[1] print 'Setdiff_values = ', session.run(diff)[0] print 'Setdiff_idx = ', session.run(diff)[1] print session.run(diff)[1]

Παραγωγή:

Argmin = [2 3 3 3] Argmax = [3 2 1 0] Unique_values = [ 1. 2. 5. 3. 7.] Unique_idx = [0 1 2 3 4] Setdiff_values = [ 5. 3. 7.] Setdiff_idx = [2 3 4]

Μηχανική εκμάθηση με TensorFlow

Σε αυτήν την ενότητα, θα παρουσιάσουμε μια περίπτωση χρήσης μηχανικής μάθησης με το TensorFlow. Το πρώτο παράδειγμα θα είναι ένας αλγόριθμος για την ταξινόμηση δεδομένων με το kNN προσέγγιση, και το δεύτερο θα χρησιμοποιήσει το γραμμικός αλγόριθμος παλινδρόμησης .

kNN

Ο πρώτος αλγόριθμος είναι το k-Nearest Neighbours (kNN). Είναι ένας εποπτευόμενος αλγόριθμος μάθησης που χρησιμοποιεί μετρήσεις απόστασης, για παράδειγμα Euclidean απόσταση, για να ταξινομήσει τα δεδομένα σε σχέση με την εκπαίδευση. Είναι ένας από τους απλούστερους αλγόριθμους, αλλά εξακολουθεί να είναι πολύ ισχυρός για την ταξινόμηση των δεδομένων. Πλεονεκτήματα αυτού του αλγορίθμου:

• Δίνει υψηλή ακρίβεια όταν το μοντέλο προπόνησης είναι αρκετά μεγάλο και
• Δεν είναι συνήθως ευαίσθητο σε ακραίες τιμές και δεν χρειάζεται να έχουμε υποθέσεις σχετικά με τα δεδομένα.

Μειονεκτήματα αυτού του αλγορίθμου:

• Υπολογιστικά ακριβό, και
• Απαιτεί πολλή μνήμη όπου πρέπει να προστεθούν νέα διαβαθμισμένα δεδομένα σε όλες τις αρχικές εκπαιδευτικές εμφανίσεις.

Η απόσταση που θα χρησιμοποιήσουμε σε αυτό το δείγμα κώδικα είναι Euclidean, η οποία καθορίζει την απόσταση μεταξύ δύο σημείων όπως αυτή:

Σε αυτόν τον τύπο, n είναι ο αριθμός των διαστάσεων του χώρου, x είναι το διάνυσμα των δεδομένων εκπαίδευσης και y είναι ένα νέο σημείο δεδομένων που θέλουμε να ταξινομήσουμε.

import os import numpy as np import tensorflow as tf ccf_train_data = 'train_dataset.csv' ccf_test_data = 'test_dataset.csv' dataset_dir = os.path.abspath(os.path.join(os.path.dirname(__file__), '../datasets')) ccf_train_filepath = os.path.join(dataset_dir, ccf_train_data) ccf_test_filepath = os.path.join(dataset_dir, ccf_test_data) def load_data(filepath): from numpy import genfromtxt csv_data = genfromtxt(filepath, delimiter=',', skip_header=1) data = [] labels = [] for d in csv_data: data.append(d[:-1]) labels.append(d[-1]) return np.array(data), np.array(labels) train_dataset, train_labels = load_data(ccf_train_filepath) test_dataset, test_labels = load_data(ccf_test_filepath) train_pl = tf.placeholder('float', [None, 28]) test_pl = tf.placeholder('float', [28]) knn_prediction = tf.reduce_sum(tf.abs(tf.add(train_pl, tf.negative(test_pl))), axis=1) pred = tf.argmin(knn_prediction, 0) with tf.Session() as tf_session: missed = 0 for i in xrange(len(test_dataset)): knn_index = tf_session.run(pred, feed_dict={train_pl: train_dataset, test_pl: test_dataset[i]}) print 'Predicted class {} -- True class {}'.format(train_labels[knn_index], test_labels[i]) if train_labels[knn_index] != test_labels[i]: missed += 1 tf.summary.FileWriter('../samples/article/logs', tf_session.graph) print 'Missed: {} -- Total: {}'.format(missed, len(test_dataset))

Το σύνολο δεδομένων που χρησιμοποιήσαμε στο παραπάνω παράδειγμα είναι αυτό που μπορεί να βρεθεί στο Σύνολα δεδομένων Kaggle Ενότητα. Χρησιμοποιήσαμε το ένας το οποίο περιέχει συναλλαγές που πραγματοποιούνται από πιστωτικές κάρτες ευρωπαίων κατόχων καρτών. Χρησιμοποιούμε τα δεδομένα χωρίς καθαρισμό ή φιλτράρισμα και σύμφωνα με την περιγραφή στο Kaggle για αυτό το σύνολο δεδομένων, είναι εξαιρετικά ανισορροπημένο. Το σύνολο δεδομένων περιέχει 31 μεταβλητές: Time, V1,…, V28, Amount και Class. Σε αυτό το δείγμα κώδικα χρησιμοποιούμε μόνο V1,…, V28 και Class. Η τάξη επισημαίνει συναλλαγές που είναι δόλιες με 1 και αυτές που δεν είναι με 0.

Το δείγμα κώδικα περιέχει κυρίως τα πράγματα που περιγράψαμε σε προηγούμενες ενότητες με εξαίρεση όπου παρουσιάσαμε τη συνάρτηση φόρτωσης ενός συνόλου δεδομένων. Η συνάρτηση load_data(filepath) θα πάρει ένα αρχείο CSV ως όρισμα και θα επιστρέψει μια πλειάδα με δεδομένα και ετικέτες που ορίζονται στο CSV.

Ακριβώς κάτω από αυτήν τη λειτουργία, έχουμε ορίσει σύμβολα κράτησης θέσης για τη δοκιμή και εκπαιδευμένα δεδομένα. Τα εκπαιδευμένα δεδομένα χρησιμοποιούνται στο μοντέλο πρόβλεψης για την επίλυση των ετικετών για τα δεδομένα εισαγωγής που πρέπει να ταξινομηθούν. Στην περίπτωσή μας, το kNN χρησιμοποιεί την ευκλείδια απόσταση για να πάρει την πλησιέστερη ετικέτα.

Το ποσοστό σφάλματος μπορεί να υπολογιστεί με απλή διαίρεση με τον αριθμό όταν ένας ταξινομητής χάθηκε από τον συνολικό αριθμό παραδειγμάτων που στην περίπτωσή μας για αυτό το σύνολο δεδομένων είναι 0,2 (δηλαδή, ο ταξινομητής μας δίνει λάθος ετικέτα δεδομένων για το 20% των δεδομένων δοκιμής).

Γραμμικής παλινδρόμησης

Ο αλγόριθμος γραμμικής παλινδρόμησης αναζητά μια γραμμική σχέση μεταξύ δύο μεταβλητών. Εάν επισημάνουμε την εξαρτημένη μεταβλητή ως y και την ανεξάρτητη μεταβλητή ως x, προσπαθούμε να εκτιμήσουμε τις παραμέτρους της συνάρτησης y = Wx + b.

Η γραμμική παλινδρόμηση είναι ένας ευρέως χρησιμοποιούμενος αλγόριθμος στον τομέα των εφαρμοσμένων επιστημών. Αυτός ο αλγόριθμος επιτρέπει την προσθήκη στην εφαρμογή δύο σημαντικών εννοιών της μηχανικής μάθησης: Λειτουργία κόστους και το μέθοδος διαβάθμισης κλίσης για να βρείτε το ελάχιστο της συνάρτησης.

Ένας αλγόριθμος μηχανικής εκμάθησης που εφαρμόζεται με αυτήν τη μέθοδο πρέπει να προβλέπει τιμές y ως συνάρτηση του x όπου ένας αλγόριθμος γραμμικής παλινδρόμησης θα καθορίσει τιμές W και b, που είναι πραγματικά άγνωστα και καθορίζονται κατά τη διάρκεια της εκπαιδευτικής διαδικασίας. Επιλέγεται μια συνάρτηση κόστους, και συνήθως χρησιμοποιείται το μέσο τετράγωνο σφάλμα όπου η κάθοδος κλίσης είναι ο αλγόριθμος βελτιστοποίησης που χρησιμοποιείται για την εύρεση ενός τοπικού ελάχιστου συντελεστή κόστους.

Η μέθοδος διαβάθμισης ντεγκραντέ είναι μόνο μια ελάχιστη τοπική συνάρτηση, αλλά μπορεί να χρησιμοποιηθεί στην αναζήτηση ενός παγκόσμιου ελάχιστου, επιλέγοντας τυχαία ένα νέο σημείο εκκίνησης μόλις βρει ένα τοπικό ελάχιστο και επαναλαμβάνοντας αυτήν τη διαδικασία πολλές φορές. Εάν ο αριθμός των ελαχίστων της συνάρτησης είναι περιορισμένος και υπάρχει πολύ μεγάλος αριθμός προσπαθειών, τότε υπάρχει μια καλή πιθανότητα σε κάποιο σημείο να εντοπιστεί το παγκόσμιο ελάχιστο. Μερικές περισσότερες λεπτομέρειες σχετικά με αυτήν την τεχνική θα φύγουμε για το άρθρο που αναφέραμε στην εισαγωγική ενότητα.

import tensorflow as tf import numpy as np test_data_size = 2000 iterations = 10000 learn_rate = 0.005 def generate_test_values(): train_x = [] train_y = [] for _ in xrange(test_data_size): x1 = np.random.rand() x2 = np.random.rand() x3 = np.random.rand() y_f = 2 * x1 + 3 * x2 + 7 * x3 + 4 train_x.append([x1, x2, x3]) train_y.append(y_f) return np.array(train_x), np.transpose([train_y]) x = tf.placeholder(tf.float32, [None, 3], name='x') W = tf.Variable(tf.zeros([3, 1]), name='W') b = tf.Variable(tf.zeros([1]), name='b') y = tf.placeholder(tf.float32, [None, 1]) model = tf.add(tf.matmul(x, W), b) cost = tf.reduce_mean(tf.square(y - model)) train = tf.train.GradientDescentOptimizer(learn_rate).minimize(cost) train_dataset, train_values = generate_test_values() init = tf.global_variables_initializer() with tf.Session() as session: session.run(init) for _ in xrange(iterations): session.run(train, feed_dict={ x: train_dataset, y: train_values }) print 'cost = {}'.format(session.run(cost, feed_dict={ x: train_dataset, y: train_values })) print 'W = {}'.format(session.run(W)) print 'b = {}'.format(session.run(b))

Παραγωγή:

cost = 3.1083032809e-05 W = [[ 1.99049103] [ 2.9887135 ] [ 6.98754263]] b = [ 4.01742554]

Στο παραπάνω παράδειγμα, έχουμε δύο νέες μεταβλητές, τις οποίες ονομάσαμε cost και train. Με αυτές τις δύο μεταβλητές, ορίσαμε ένα εργαλείο βελτιστοποίησης που θέλουμε να χρησιμοποιήσουμε στο εκπαιδευτικό μας μοντέλο και τη λειτουργία που θέλουμε να ελαχιστοποιήσουμε.

Στο τέλος, οι παράμετροι εξόδου W και b θα πρέπει να είναι ίδια με εκείνα που ορίζονται στο generate_test_values λειτουργία. Στη γραμμή 17, ορίσαμε πραγματικά μια συνάρτηση που χρησιμοποιήσαμε για να δημιουργήσουμε τα γραμμικά σημεία δεδομένων για να εκπαιδεύσουμε όπου w1=2, w2=3, w3=7 και b=4. Η γραμμική παλινδρόμηση από το παραπάνω παράδειγμα είναι πολυπαραλλαγή όπου χρησιμοποιούνται περισσότερες από μία ανεξάρτητες μεταβλητές.

συμπέρασμα

Όπως μπορείτε να δείτε από αυτό το σεμινάριο TensorFlow, το TensorFlow είναι ένα ισχυρό πλαίσιο που κάνει την εργασία με μαθηματικές εκφράσεις και πολυδιάστατες συστοιχίες ένα αεράκι - κάτι βασικά απαραίτητο στη μηχανική μάθηση. Επίσης αφαιρεί τις πολυπλοκότητες της εκτέλεσης των γραφημάτων δεδομένων και της κλιμάκωσης.

Με την πάροδο του χρόνου, το TensorFlow έχει αυξηθεί σε δημοτικότητα και τώρα χρησιμοποιείται από προγραμματιστές για την επίλυση προβλημάτων χρησιμοποιώντας μεθόδους βαθιάς μάθησης για αναγνώριση εικόνας, ανίχνευση βίντεο, επεξεργασία κειμένου όπως ανάλυση συναισθημάτων κ.λπ. στις έννοιες στις οποίες βασίζεται το TensorFlow. Και, μόλις το κάνετε, με τη βοήθεια της τεκμηρίωσης και της υποστήριξης της κοινότητας, η παρουσίαση προβλημάτων ως γραφήματα δεδομένων και η επίλυσή τους με το TensorFlow μπορεί να κάνει τη μηχανική εκμάθηση σε κλίμακα μια λιγότερο κουραστική διαδικασία.

Κατανόηση των βασικών

Πώς δημιουργούνται οι σταθερές TensorFlow;

Στο TensorFlow, οι σταθερές δημιουργούνται χρησιμοποιώντας τη σταθερή συνάρτηση που παίρνει μερικές παραμέτρους: Τιμή, dtype (τύπος δεδομένων), σχήμα, όνομα και (verifikasi_shape) επαλήθευση σχήματος.

Τι είναι η συνεδρία TensorFlow;

Μια συνεδρία ενσωματώνει τον έλεγχο και την κατάσταση του χρόνου εκτέλεσης του TensorFlow. Μια περίοδος λειτουργίας χωρίς παραμέτρους θα χρησιμοποιήσει το προεπιλεγμένο γράφημα που δημιουργήθηκε στην τρέχουσα περίοδο λειτουργίας, διαφορετικά η κλάση συνεδρίας δέχεται μια παράμετρο γραφήματος, η οποία χρησιμοποιείται σε αυτήν την περίοδο λειτουργίας που θα εκτελεστεί.

Τι είναι το TensorBoard;

Το TensorBoard είναι ένα εργαλείο οπτικοποίησης για την ανάλυση γραφημάτων ροής δεδομένων. Αυτό μπορεί να είναι χρήσιμο για την καλύτερη κατανόηση των μοντέλων μηχανικής μάθησης.