Verstehen des LSTM-Modells mit Tensorflow für die Stimmungsanalyse

Ich versuche, LSTM-Modell für die Stimmungsanalyse mit Tensorflow zu lernen, habe ich das LSTM-Modell durchgemacht.

Der folgende Code (create_sentiment_featuresets.py) erzeugt das Lexikon aus 5000 positiven Sätzen und 5000 negativen Sätzen .

import nltk from nltk.tokenize import word_tokenize import numpy as np import random from collections import Counter from nltk.stem import WordNetLemmatizer lemmatizer = WordNetLemmatizer() def create_lexicon(pos, neg): lexicon = [] with open(pos, 'r') as f: contents = f.readlines() for l in contents[:len(contents)]: l= l.decode('utf-8') all_words = word_tokenize(l) lexicon += list(all_words) f.close() with open(neg, 'r') as f: contents = f.readlines() for l in contents[:len(contents)]: l= l.decode('utf-8') all_words = word_tokenize(l) lexicon += list(all_words) f.close() lexicon = [lemmatizer.lemmatize(i) for i in lexicon] w_counts = Counter(lexicon) l2 = [] for w in w_counts: if 1000 > w_counts[w] > 50: l2.append(w) print("Lexicon length create_lexicon: ",len(lexicon)) return l2 def sample_handling(sample, lexicon, classification): featureset = [] print("Lexicon length Sample handling: ",len(lexicon)) with open(sample, 'r') as f: contents = f.readlines() for l in contents[:len(contents)]: l= l.decode('utf-8') current_words = word_tokenize(l.lower()) current_words= [lemmatizer.lemmatize(i) for i in current_words] features = np.zeros(len(lexicon)) for word in current_words: if word.lower() in lexicon: index_value = lexicon.index(word.lower()) features[index_value] +=1 features = list(features) featureset.append([features, classification]) f.close() print("Feature SET------") print(len(featureset)) return featureset def create_feature_sets_and_labels(pos, neg, test_size = 0.1): global m_lexicon m_lexicon = create_lexicon(pos, neg) features = [] features += sample_handling(pos, m_lexicon, [1,0]) features += sample_handling(neg, m_lexicon, [0,1]) random.shuffle(features) features = np.array(features) testing_size = int(test_size * len(features)) train_x = list(features[:,0][:-testing_size]) train_y = list(features[:,1][:-testing_size]) test_x = list(features[:,0][-testing_size:]) test_y = list(features[:,1][-testing_size:]) return train_x, train_y, test_x, test_y def get_lexicon(): global m_lexicon return m_lexicon 

Der folgende Code (sentiment_analysis.py) ist für die Stimmungsanalyse mit einfachem neuronalen Netzwerkmodell und funktioniert gut

 from create_sentiment_featuresets import create_feature_sets_and_labels from create_sentiment_featuresets import get_lexicon import tensorflow as tf import numpy as np # extras for testing from nltk.tokenize import word_tokenize from nltk.stem import WordNetLemmatizer lemmatizer = WordNetLemmatizer() #- end extras train_x, train_y, test_x, test_y = create_feature_sets_and_labels('pos.txt', 'neg.txt') # pt A------------- n_nodes_hl1 = 1500 n_nodes_hl2 = 1500 n_nodes_hl3 = 1500 n_classes = 2 batch_size = 100 hm_epochs = 10 x = tf.placeholder(tf.float32) y = tf.placeholder(tf.float32) hidden_1_layer = {'f_fum': n_nodes_hl1, 'weight': tf.Variable(tf.random_normal([len(train_x[0]), n_nodes_hl1])), 'bias': tf.Variable(tf.random_normal([n_nodes_hl1]))} hidden_2_layer = {'f_fum': n_nodes_hl2, 'weight': tf.Variable(tf.random_normal([n_nodes_hl1, n_nodes_hl2])), 'bias': tf.Variable(tf.random_normal([n_nodes_hl2]))} hidden_3_layer = {'f_fum': n_nodes_hl3, 'weight': tf.Variable(tf.random_normal([n_nodes_hl2, n_nodes_hl3])), 'bias': tf.Variable(tf.random_normal([n_nodes_hl3]))} output_layer = {'f_fum': None, 'weight': tf.Variable(tf.random_normal([n_nodes_hl3, n_classes])), 'bias': tf.Variable(tf.random_normal([n_classes]))} def nueral_network_model(data): l1 = tf.add(tf.matmul(data, hidden_1_layer['weight']), hidden_1_layer['bias']) l1 = tf.nn.relu(l1) l2 = tf.add(tf.matmul(l1, hidden_2_layer['weight']), hidden_2_layer['bias']) l2 = tf.nn.relu(l2) l3 = tf.add(tf.matmul(l2, hidden_3_layer['weight']), hidden_3_layer['bias']) l3 = tf.nn.relu(l3) output = tf.matmul(l3, output_layer['weight']) + output_layer['bias'] return output # pt B-------------- def train_neural_network(x): prediction = nueral_network_model(x) cost = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits= prediction, labels= y)) optimizer = tf.train.AdamOptimizer(learning_rate= 0.001).minimize(cost) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for epoch in range(hm_epochs): epoch_loss = 0 i = 0 while i < len(train_x): start = i end = i+ batch_size batch_x = np.array(train_x[start: end]) batch_y = np.array(train_y[start: end]) _, c = sess.run([optimizer, cost], feed_dict= {x: batch_x, y: batch_y}) epoch_loss += c i+= batch_size print('Epoch', epoch+ 1, 'completed out of ', hm_epochs, 'loss:', epoch_loss) correct= tf.equal(tf.argmax(prediction, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct, 'float')) print('Accuracy:', accuracy.eval({x:test_x, y:test_y})) # testing -------------- m_lexicon= get_lexicon() print('Lexicon length: ',len(m_lexicon)) input_data= "David likes to go out with Kary" current_words= word_tokenize(input_data.lower()) current_words = [lemmatizer.lemmatize(i) for i in current_words] features = np.zeros(len(m_lexicon)) for word in current_words: if word.lower() in m_lexicon: index_value = m_lexicon.index(word.lower()) features[index_value] +=1 features = np.array(list(features)).reshape(1,-1) print('features length: ',len(features)) result = sess.run(tf.argmax(prediction.eval(feed_dict={x:features}), 1)) print(prediction.eval(feed_dict={x:features})) if result[0] == 0: print('Positive: ', input_data) elif result[0] == 1: print('Negative: ', input_data) train_neural_network(x) 

Ich versuche, das obige (sentiment_analysis.py) für das LSTM-Modell nach dem Lesen des RNN w / LSTM-Zellenbeispiels in TensorFlow und Python zu modifizieren, das für LSTM auf mnist Bilddatensatz ist :

Einige, wie durch viele Hit und Run Trails, konnte ich den unten laufenden Code (sentiment_demo_lstm.py) :

 import tensorflow as tf from tensorflow.contrib import rnn from create_sentiment_featuresets import create_feature_sets_and_labels from create_sentiment_featuresets import get_lexicon import numpy as np # extras for testing from nltk.tokenize import word_tokenize from nltk.stem import WordNetLemmatizer lemmatizer = WordNetLemmatizer() #- end extras train_x, train_y, test_x, test_y = create_feature_sets_and_labels('pos.txt', 'neg.txt') n_steps= 100 input_vec_size= len(train_x[0]) hm_epochs = 8 n_classes = 2 batch_size = 128 n_hidden = 128 x = tf.placeholder('float', [None, input_vec_size, 1]) y = tf.placeholder('float') def recurrent_neural_network(x): layer = {'weights': tf.Variable(tf.random_normal([n_hidden, n_classes])), # hidden_layer, n_classes 'biases': tf.Variable(tf.random_normal([n_classes]))} h_layer = {'weights': tf.Variable(tf.random_normal([1, n_hidden])), # hidden_layer, n_classes 'biases': tf.Variable(tf.random_normal([n_hidden], mean = 1.0))} x = tf.transpose(x, [1,0,2]) x = tf.reshape(x, [-1, 1]) x= tf.nn.relu(tf.matmul(x, h_layer['weights']) + h_layer['biases']) x = tf.split(x, input_vec_size, 0) lstm_cell = rnn.BasicLSTMCell(n_hidden, state_is_tuple=True) outputs, states = rnn.static_rnn(lstm_cell, x, dtype= tf.float32) output = tf.matmul(outputs[-1], layer['weights']) + layer['biases'] return output def train_neural_network(x): prediction = recurrent_neural_network(x) cost = tf.reduce_mean( tf.nn.softmax_cross_entropy_with_logits(logits= prediction, labels= y)) optimizer = tf.train.AdamOptimizer(learning_rate= 0.001).minimize(cost) with tf.Session() as sess: sess.run(tf.global_variables_initializer()) for epoch in range(hm_epochs): epoch_loss = 0 i = 0 while (i+ batch_size) < len(train_x): start = i end = i+ batch_size batch_x = np.array(train_x[start: end]) batch_y = np.array(train_y[start: end]) batch_x = batch_x.reshape(batch_size ,input_vec_size, 1) _, c = sess.run([optimizer, cost], feed_dict= {x: batch_x, y: batch_y}) epoch_loss += c i+= batch_size print('--------Epoch', epoch+ 1, 'completed out of ', hm_epochs, 'loss:', epoch_loss) correct= tf.equal(tf.argmax(prediction, 1), tf.argmax(y, 1)) accuracy = tf.reduce_mean(tf.cast(correct, 'float')) print('Accuracy:', accuracy.eval({x:np.array(test_x).reshape(-1, input_vec_size, 1), y:test_y})) # testing -------------- m_lexicon= get_lexicon() print('Lexicon length: ',len(m_lexicon)) input_data= "Mary does not like pizza" #"he seems to to be healthy today" #"David likes to go out with Kary" current_words= word_tokenize(input_data.lower()) current_words = [lemmatizer.lemmatize(i) for i in current_words] features = np.zeros(len(m_lexicon)) for word in current_words: if word.lower() in m_lexicon: index_value = m_lexicon.index(word.lower()) features[index_value] +=1 features = np.array(list(features)).reshape(-1, input_vec_size, 1) print('features length: ',len(features)) result = sess.run(tf.argmax(prediction.eval(feed_dict={x:features}), 1)) print('RESULT: ', result) print(prediction.eval(feed_dict={x:features})) if result[0] == 0: print('Positive: ', input_data) elif result[0] == 1: print('Negative: ', input_data) train_neural_network(x) 

Ausgabe von

 print(train_x[0]) [0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 1.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0, 0.0] print(train_y[0]) [0, 1] 

len(train_x)= 9596 , len(train_x[0]) = 423 bedeutet train_x ist eine Liste von 9596×423?

Tough ich habe jetzt einen laufenden Code, ich habe noch viele Zweifel.

  1. In sentiment_demo_lstm kann ich den folgenden Teil nicht verstehen

     x = tf.transpose(x, [1,0,2]) x = tf.reshape(x, [-1, 1]) x = tf.split(x, input_vec_size, 0) 

    Ich habe die folgenden Formen gedruckt:

     x = tf.placeholder('float', [None, input_vec_size, 1]) ==> TensorShape([Dimension(None), Dimension(423), Dimension(1)])) x = tf.transpose(x, [1,0,2]) ==> TensorShape([Dimension(423), Dimension(None), Dimension(1)])) x = tf.reshape(x, [-1, 1]) ==> TensorShape([Dimension(None), Dimension(1)])) x = tf.split(x, input_vec_size, 0) ==> ? 
  2. Hier habe ich die Anzahl der versteckten Schichten als 128 genommen, muss es dasselbe sein wie die Anzahl der Eingaben dh len(train_x)= 9596

  3. Der Wert 1 in

     x = tf.placeholder('float', [None, input_vec_size, 1]) 

    und

     x = tf.reshape(x, [-1, 1]) 

    train_x[0] weil train_x[0] ist 428x 1 ?

  4. Folgendes ist, um dem Platzhalter zu entsprechen

     batch_x = np.array(train_x[start: end]) ==> (128, 423) batch_x = batch_x.reshape(batch_size ,input_vec_size, 1) ==> (128, 423, 1) 

    x = tf.placeholder('float', [None, input_vec_size, 1]) Dimensionen, richtig?

  5. Wenn ich den Code geändert habe:

     while (i+ batch_size) < len(train_x): 

    wie

     while i < len(train_x): 

    Ich bekomme folgende Fehlermeldung:

     Traceback (most recent call last): File "sentiment_demo_lstm.py", line 131, in <module> train_neural_network(x) File "sentiment_demo_lstm.py", line 86, in train_neural_network batch_x = batch_x.reshape(batch_size ,input_vec_size, 1) ValueError: cannot reshape array of size 52452 into shape (128,423,1) 

=> Ich kann nicht die letzten 124 Datensätze / Feature-Sets während des Trainings enthalten?

One Solution collect form web for “Verstehen des LSTM-Modells mit Tensorflow für die Stimmungsanalyse”

Dies ist geladen Frage. Lassen Sie mich versuchen, es in einfachen englischen verstecken alle komplizierten inneren Details:

Ein einfaches abgerolltes LSTM-Modell mit 3 Schritten ist unten dargestellt. Jede LSTM-Zelle nimmt einen Eingangsvektor und den versteckten Ausgangsvektor der vorherigen LSTM-Zelle und erzeugt einen Ausgangsvektor und die verborgene Ausgabe für die nächste LSTM-Zelle.

Bildbeschreibung hier eingeben

Eine genaue Darstellung des gleichen Modells ist unten gezeigt.

Bildbeschreibung hier eingeben

LSTM-Modelle sind Sequenz-zu-Sequenz-Modelle, dh sie werden für Probleme verwendet, wenn eine Sequenz mit einer anderen Sequenz beschriftet werden muss, wie POS-Tagging oder NER-Tagging jedes Wortes in einem Satz.

Du scheinst es für das Klassifizierungsproblem zu benutzen. Es gibt zwei Möglichkeiten, das LSTM-Modell zur Klassifizierung zu verwenden

1) Nehmen Sie die Ausgabe aller Zustände (O1, O2 und O3 in unserem Beispiel) und wenden Sie eine Softmax-Schicht mit Softmax-Layer-Ausgabe Größe gleich der Anzahl der Klassen (2 in Ihrem Fall)

2) Nehmen Sie den Ausgang des letzten Zustandes (O3) und wenden Sie eine Softmax-Schicht darauf. (Dies ist, was du in deinem Kabel tust. Ausgänge [-1] die letzte Zeile in den Ausgängen zurückgeben)

Also versammeln wir zurück (Backpropagation Through Time – BTT) auf den Fehler der Softmax-Ausgabe.

Kommen Sie zur Implementierung mit Tensorflow, sehen Sie, was ist die Eingabe und Ausgabe an das LSTM-Modell.

Jeder LSTM nimmt einen Eingang, aber wir haben 3 solche LSTM-Zellen, also sollte der Eingang (X Platzhalter) von Größe sein (Inputsize * Zeitschritte). Aber wir berechnen keinen Fehler für Single Input und BTT für ihn, aber stattdessen machen wir es auf einem Batch von Input – Output – Kombinationen. So wird die Eingabe von LSTM (Batch-Größe * Inputsize * Zeitschritte).

Ein LSTM-Zellen wird mit der Größe des versteckten Zustands definiert. Die Größe der Ausgabe und der versteckte Ausgangsvektor der LSTM-Zelle sind gleich wie die Größe der versteckten Zustände (Check LSTM interne Berechnungen für warum!). Wir definieren dann ein LSTM-Modell mit einer Liste dieser LSTM-Zellen, wobei die Größe der Liste gleich der Anzahl der Abwicklung des Modells ist. So definieren wir die Anzahl der Abschlüsse und die Größe der Eingabe bei jedem Abrollen.

Ich habe viele Dinge übersprungen, wie man mit variabler Längenfolge umgehen kann, Sequenz zu Sequenzfehlerberechnungen, wie LSTM die Ausgabe und die verborgene Ausgabe berechnet

Wenn Sie zu Ihrer Implementierung kommen, wenden Sie eine Relu-Schicht vor der Eingabe jeder LSTM-Zelle an. Ich verstehe nicht, warum du das tust, aber ich denke, du machst es, um deine Eingabegröße auf die der LSTM-Eingangsgröße zuzuordnen.

Kommen zu Ihren Fragen:

  1. X ist der Platzhalter (Tensor / Matrix / ndarray) der Größe [Keine, input_vec_size, 1]. Dh es kann eine variable Anzahl von Zeilen annehmen, aber jede Zeile mit input_vec_size-Spalten und jedes Element, das ein Vektor ist, ist Größe 1. Normalerweise werden Platzhalter mit "None" in den Zeilen definiert, so dass wir die Chargengröße des Inputs variieren können.

Lass sagen input_vec_size = 3

Du gehst ein ndarray der Größe [128 * 3 * 1]

X = tf.transpose (x, [1,0,2]) -> [3 * 128 * 1]

X = tf.reshape (x, [-1, 1]) -> [384 * 1]

H_layer ['Gewichte'] -> [1, 128]

X = tf.nn.relu (tf.matmul (x, h_layer ['weights']) + h_layer ['biases']) -> [384 * 128]

  1. Keine Eingabegröße sind versteckte Größe sind unterschiedlich. LSTM führt eine Reihe von Operationen auf dem Eingang und vorherige versteckte Ausgabe und gegeben eine Ausgabe und die nächste versteckte Ausgabe, die beide von Größe versteckte Größe sind.

  2. X = tf.placeholder ('float', [Keine, input_vec_size, 1])

Es definiert eine Tensor oder ndarray oder variable Anzahl von Zeilen, jede Zeile hat input_vec_size Spalten a und jeder Wert ist ein einzelner Wert Vektor.

X = tf.reshape (x, [-1, 1]) -> umgibt den eingegebenen x in eine Matrix mit einer Größe, die auf 1 Spalte und einer beliebigen Anzahl von Zeilen festgelegt ist.

  1. Batch_x = batch_x.reshape (batch_size, input_vec_size, 1)

Batch_x.reshape wird fehlschlagen, wenn die Anzahl der Werte in batch_x! = Batch_size * input_vec_size * 1. Dies könnte für den letzten Batch der Fall sein, weil len (train_x) kein Vielfaches von batch_size sein könnte, was zu dem nicht vollständig gefüllten letzten Batch führt.

Sie können dieses Problem vermeiden, indem Sie verwenden

 batch_x = batch_x.reshape(-1 ,input_vec_size, 1) 

Aber ich bin immer noch nicht sicher, warum Sie Relu vor der Eingabeschicht verwenden.

Sie setzen logistische Regression am Ausgang der letzten Zelle ein, was in Ordnung ist.

Du kannst mein Spielzeug-Beispiel ansehen, das ein Klassifikator ist, der bidirektionales LSTM zum Klassifizieren verwendet, wenn eine Sequenz zunimmt oder abnimmt oder gemischt wird.

Toy sequence_classifier mit LSTM im Tensorflow

  • Verstehen Tensorflow LSTM Modelle Eingabe?
  • TensorFlow ValueError: Kann den Wert der Form (64, 64, 3) nicht für den Tensor u'Placeholder: 0 ', der die Form' (?, 64, 64, 3) 'hat,
  • Wie fügt man Regelungen in TensorFlow hinzu?
  • Random Cropping Datenvergrößerung Faltungsneuronale Netzwerke
  • TensorFlow: alle Staaten aus einem RNN bekommen
  • Mit einem vorprogrammierten Worteinbettung (word2vec oder Handschuh) in TensorFlow
  • Finden Sie die richtigen Parameter für neuronales Netzwerk für Pong-Spiel
  • Ist es möglich, den objektiven Funktionswert bei jedem Trainingsschritt zu erhalten?
  • Keras, Ausgabe des Modells predict_proba
  • Caffe Netzwerk immer sehr geringem Verlust, aber sehr schlechte Genauigkeit beim Testen
  • Wie rekonstruieren Sie die caffe net mit pycaffe
  • Python ist die beste Programmiersprache der Welt.