Bevorzugte Netzwerkes Distributed Deep Strengthing Learning Ich möchte so etwas machen, indem ich mir die Nachrichten ansehe! Ich habe mit Deep Learning begonnen. Das ist Ikki. Neulich ging ich zu Robot Exhibition und stellte bei Preferred Networks aus. Ich habe an Dingen und Workshops teilgenommen und es ist wunderbar, dass die Technologie schnell und die Denkweise gut ist. Ich respektiere dich. Dann benutze Chainer! Es gibt eine Meinung, aber das war's. Ich denke daran, hart zu lernen.
Dieses Mal werde ich den Inhalt aufzeichnen (ich vergesse), als ich neulich mit TensorFlow angefangen habe. Zuerst habe ich über die Installationsmethode nachgedacht, aber ich habe es auf dem Weg satt, also habe ich aufgehört. Es ist anderswo gut organisiert. Ich habe mich übrigens darauf bezogen. Vielen Dank. "Ich habe [TensorFlow (GPU-Version) unter Ubuntu] installiert (http://qiita.com/naomi7325/items/789b256a2c61dbe8ed00)"
Ich habe [Deep MNIST for Experts] ausprobiert (https://www.tensorflow.org/versions/master/tutorials/mnist/pros/index.html). Viele dieser Tutorials sind jedoch ausgezeichnet, so dass es fast so ist, als würde man Notizen schreiben. Ich bin mit meinem Programm zufrieden. Es ist fast eine Kopie. Diesmal habe ich darauf hingewiesen. Vielen Dank. "Erstellen Sie einen Klassifikator mit einer Handschrifterkennungsrate von 99,2% unter Verwendung des neuronalen TensorFlow-Faltungsnetzwerks"
mnist_expert.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
####################################################################
#Implementieren Sie mnist mit Tensorflow
#Es ist etwas schwer zu erkennen, da der Code nicht geteilt ist.
####################################################################
from __future__ import absolute_import,unicode_literals
import input_data
import tensorflow as tf
#Lesen Sie die wichtigsten Daten
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
# cross_Implementieren Sie Entropie
sess = tf.InteractiveSession() #Starten Sie eine interaktive Sitzung(Nicht für Langzeitprogramme geeignet)
#In Ausdrücken verwendete Variableneinstellungen
x = tf.placeholder("float", shape=[None,784]) #Eingang
y_ = tf.placeholder("float", shape=[None,10]) #Variable für Fehlerfunktion True Class Distribution
W = tf.Variable(tf.zeros([784,10])) #Gewicht
b = tf.Variable(tf.zeros([10])) #vorspannen
sess.run(tf.initialize_all_variables()) #Variable Initialisierung(Muss erforderlich sein, wenn Variablen verwendet werden)
y = tf.nn.softmax(tf.matmul(x,W)+b) # y=softmax(Wx+b)Die Differenzierung erfolgt ebenfalls ohne Erlaubnis
cross_entropy = -tf.reduce_sum(y_*tf.log(y)) #Kreuzentropie definieren
#Lernalgorithmus und Minimierungsproblem
#Die steilste Abstiegsmethode hier(Gradientenabstiegsmethode)Lösen Sie die Minimierung von. Lernrate 0.01
train_step = tf.train.GradientDescentOptimizer(0.01).minimize(cross_entropy)
#1000-mal lernen Losgröße 50(Die Verarbeitung dieses Inhalts ist noch unzureichend untersucht)
for i in range(1000):
batch = mnist.train.next_batch(50)
train_step.run(feed_dict={x:batch[0],y_:batch[1]})
#Ergebnisse anzeigen
correct_prediction = tf.equal(tf.argmax(y,1),tf.argmax(y_,1))#Plausible Klasse oder Argmax(y)Entspricht dem Lehreretikett
accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float"))#Bewerten Sie jede Probe und berechnen Sie den Durchschnitt
print accuracy.eval(feed_dict={x: mnist.test.images,y_: mnist.test.labels})#Bild y auf x_Ersetzen Sie dieses Etikett durch
#Das Ergebnis, das herauskommt, ist zu diesem Zeitpunkt genau 91%Vorher und nachher
###############################################################
#Das neuronale Netzwerk mit tiefer Faltung ist unten aufgebaut.
#Genauigkeit 99 durch Vertiefung%Es zielt darauf ab.
###############################################################
#Initialisierung von Gewicht und Bias
#Eine Funktion, die die Gewichte mit einem geringen Rauschen für das Problem des Verschwindens des Gradienten initialisiert? Was meinst du?
def weight_variable(shape): #Gewichtsinitialisierung
initial = tf.truncated_normal(shape,stddev=0.1)
return tf.Variable(initial)
def bias_variable(shape): #Bias-Initialisierung
initial = tf.constant(0.1,shape=shape)
return tf.Variable(initial)
#Definition von Faltung und Pooling
def conv2d(x,W):
return tf.nn.conv2d(x,W,strides=[1,1,1,1],padding='SAME')
def max_pool_2x2(x):
return tf.nn.max_pool(x,ksize=[1,2,2,1],strides=[1,2,2,1],padding='SAME')
#Berechnen Sie 32 Features mit dem 5x5-Patch der ersten Ebene
# [5,5,1,32]Ist 5,5 ist die Patchgröße, 1 ist die Anzahl der Eingangskanäle, 32 ist der Ausgangskanal
W_conv1 = weight_variable([5,5,1,32]) #Variablendefinition
b_conv1 = bias_variable([32]) #Variablendefinition
x_image = tf.reshape(x,[-1,28,28,1]) #28 Bilder*In 28 Schwarzweißbilder konvertieren
h_conv1 = tf.nn.relu(conv2d(x_image,W_conv1)+b_conv1) #ReLU-Verarbeitung?
h_pool1 = max_pool_2x2(h_conv1)#Erstellung der Pooling-Schicht 1
#Berechnen Sie 64 Features mit dem 5x5-Patch der 2. Ebene
W_conv2 = weight_variable([5,5,32,64]) #Variablendefinition
b_conv2 = bias_variable([64]) #Variablendefinition
h_conv2 = tf.nn.relu(conv2d(h_pool1,W_conv2)+b_conv2)
h_pool2 = max_pool_2x2(h_conv2)#Erstellung der Pooling-Schicht 2
#Konvertierung in eine vollständig verbundene Schicht (vollständige Verbindungsschicht)
W_fc1 = weight_variable([7*7*64,1024]) #Was für eine Bekehrung?
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2,[-1,7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat,W_fc1)+b_fc1)
#Dropout machen
keep_prob = tf.placeholder("float")
h_fc1_drop = tf.nn.dropout(h_fc1,keep_prob)
#Ebene lesen
W_fc2 = weight_variable([1024,10])
b_fc2 = bias_variable([10])
y_conv = tf.nn.softmax(tf.matmul(h_fc1_drop,W_fc2)+b_fc2)
#Modelllernen und Evaluieren
cross_entropy = -tf.reduce_sum(y_*tf.log(y_conv))
train_step = tf.train.AdamOptimizer(1e-4).minimize(cross_entropy)#Verwendet die Adam-Methode.
correct_prediction = tf.equal(tf.argmax(y_conv,1),tf.argmax(y_,1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction,"float")) # cast?
sess.run(tf.initialize_all_variables())
for i in range(20000):
batch = mnist.train.next_batch(50)
if i % 100 == 0:
train_accuracy = accuracy.eval(feed_dict={x: batch[0], y_: batch[1], keep_prob:1.0})
print "step %d, training accuracy %g" % (i,train_accuracy)
train_step.run(feed_dict={x:batch[0],y_:batch[1],keep_prob:0.5})# 0.Ich halte es auf 5?
#Ergebnisanzeige
print "test accuracy %g" % accuracy.eval(feed_dict={x:mnist.test.images,y_:mnist.test.labels,keep_prob:1.0})
Hmmm, ich habe das Programm bestanden, aber ist es schwierig, TensorBoard zu verwenden, das die Killer-App von TensorFlow sein wird? Oder besser gesagt, es ist schwer als Programm zu sehen.
Also habe ich versucht, es zu verbessern. Vielen Dank für Ihre Hilfe dieses Mal. Ich denke, diese Person ist jung, aber wirklich exzellent und macht immer interessante Dinge. Vielen Dank. "Kivantium-Aktivitätstagebuch: Identifizieren Sie die Produktionsfirma von Anime Yuruyuri mit TensorFlow"
mnist_expert_kai.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
####################################################################
#Implementieren Sie mnist mit Tensorflow
#Es ist etwas schwer zu erkennen, da der Code nicht geteilt ist.(->Repariert)
####################################################################
import sys
import cv2
import numpy as np
import tensorflow as tf
import tensorflow.python.platform
import input_data
#Lesen Sie die wichtigsten Daten
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
NUM_CLASSES = 10 #Anzahl der Modellklassen
def inference(images_placeholder, keep_prob):
####################################################################
#Funktionen, die Vorhersagemodelle erstellen
#Streit:
# images_placeholder:Platzhalter fuer Bild
# keep_prob:Platzhalter für Abbrecherquote
#Rückgabewert:
# y_conv:Wahrscheinlichkeit jeder Klasse(Etwas wie)
####################################################################
#Gewichtsstandardabweichung 0.Initialisiert mit einer Normalverteilung von 1
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#Vorspannung zur Standardabweichung 0.Initialisiert mit einer Normalverteilung von 1
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
#Erstellen einer Faltungsschicht
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
#Erstellen einer Poolebene
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')
#Transformiere den Eingang in 28x28x1
x_image = tf.reshape(images_placeholder, [-1, 28, 28, 1])
#Erzeugung der Faltungsschicht 1
with tf.name_scope('conv1') as scope:
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_image, W_conv1) + b_conv1)
#Erstellung der Pooling-Schicht 1
with tf.name_scope('pool1') as scope:
h_pool1 = max_pool_2x2(h_conv1)
#Erzeugung der Faltungsschicht 2
with tf.name_scope('conv2') as scope:
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
#Erstellung der Pooling-Schicht 2
with tf.name_scope('pool2') as scope:
h_pool2 = max_pool_2x2(h_conv2)
#Erstellung der vollständig verbundenen Schicht 1
with tf.name_scope('fc1') as scope:
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
#Dropout-Einstellungen
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#Erstellung der vollständig verbundenen Schicht 2
with tf.name_scope('fc2') as scope:
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
#Normalisierung durch Softmax-Funktion
with tf.name_scope('softmax') as scope:
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
#Gibt so etwas wie die Wahrscheinlichkeit jedes Etiketts zurück
return y_conv
def loss(logits, labels):
####################################################################
#Funktion zur Berechnung des Verlustes
#Streit:
# logits:Logit Tensor, float - [batch_size, NUM_CLASSES]
# labels:Tensor beschriften, int32 - [batch_size, NUM_CLASSES]
#Rückgabewert:
# cross_entropy:Gekreuzter Entropietensor, float
####################################################################
#Berechnung der Kreuzentropie
cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
#Geben Sie an, dass in TensorBoard angezeigt werden soll
tf.scalar_summary("cross_entropy", cross_entropy)
return cross_entropy
def training(loss, learning_rate):
####################################################################
#Funktionen, die Trainingsoperationen definieren
#Streit:
# loss:Verlusttensor, loss()Ergebnis von
# learning_rate:Lernkoeffizient
#Rückgabewert:
# train_step:Training op
####################################################################
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
return train_step
def accuracy(logits, labels):
####################################################################
#Richtige Antwortrate(accuracy)Funktion zum Berechnen
#Streit:
# logits: inference()Ergebnis von
# labels:Tensor beschriften, int32 - [batch_size, NUM_CLASSES]
#Rückgabewert:
# accuracy:Richtige Antwortrate(float)
####################################################################
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
tf.scalar_summary("accuracy", accuracy)
return accuracy
if __name__ == '__main__':
#In Ausdrücken verwendete Variableneinstellungen
x_image = tf.placeholder("float", shape=[None,784]) #Eingang
y_label = tf.placeholder("float", shape=[None,10])
W = tf.Variable(tf.zeros([784,10])) #Gewicht
b = tf.Variable(tf.zeros([10])) #vorspannen
#y_label = tf.nn.softmax(tf.matmul(x_image,W)+b) # y=softmax(Wx+b)Die Differenzierung erfolgt ebenfalls ohne Erlaubnis
keep_prob = tf.placeholder("float")
#init_op = tf.initialize_all_variables() #Variable Initialisierung(Muss erforderlich sein, wenn Variablen verwendet werden)
with tf.Session() as sess:
logits = inference(x_image,keep_prob) # inference()So erstellen Sie ein Modell
loss_value = loss(logits,y_label) # loss()Den Verlust berechnen
train_op = training(loss_value,1e-4) # training()Rufen Sie an und trainieren Sie (1e-4 ist die Lernrate)
accur = accuracy(logits,y_label) # accuracy()Berechnung der Genauigkeit
init_op = tf.initialize_all_variables()
sess.run(init_op)
for step in range(20001):
batch = mnist.train.next_batch(50)
if step % 100 == 0:
train_accur = accur.eval(feed_dict={x_image: batch[0], y_label: batch[1], keep_prob:1.0})
print "step %d, training accuracy %g" % (step,train_accur)
train_op.run(feed_dict={x_image:batch[0],y_label:batch[1],keep_prob:0.5})# 0.Ich halte es auf 5?
#Ergebnisanzeige
print "test accuracy %g" % accur.eval(feed_dict={x_image:mnist.test.images,y_label:mnist.test.labels,keep_prob:1.0})
Ich habe darauf Bezug genommen, weil es besser ist, es wie Inferenz (), Verlust (), Training (), Genauigkeit () zu teilen. Hier gab es zwei Probleme. Der erste Punkt ist init_op in main. Beim Definieren von init_op außerhalb von Session () tritt ein Fehler auf. Ich habe irgendwo gesehen, dass es in Session () bestanden hat, also habe ich es in Session () umgeschrieben. Der zweite Punkt ist der Anzeigeteil für das Endergebnis. Ich habe den Fehler ** Out of GPU Memory ** erhalten, den ich oben geschrieben habe. In diesem Fall habe ich es gelöst, indem ich convolutional.py hier neu geschrieben habe (Github TensorFlow # 157). Ich verstehe nicht, warum beide Fehler behoben wurden. .. .. Ich kann Englisch sprechen ...
Hier ist eine verbesserte Version des obigen Programms, die Sie auf TensorBoard sehen können:
mnist_expert_kai2.py
#!/usr/bin/env python
# -*- coding: utf-8 -*-
####################################################################
#Implementieren Sie mnist mit Tensorflow
#Es ist etwas schwer zu erkennen, da der Code nicht geteilt ist.(->Repariert)
####################################################################
import sys
import cv2
import numpy as np
import tensorflow as tf
import tensorflow.python.platform
import input_data
#Lesen Sie die wichtigsten Daten
mnist = input_data.read_data_sets("MNIST_data/", one_hot=True)
NUM_CLASSES = 10 #Anzahl der Modellklassen
def inference(images_placeholder, keep_prob):
####################################################################
#Funktionen, die Vorhersagemodelle erstellen
#Streit:
# images_placeholder:Platzhalter fuer Bild
# keep_prob:Platzhalter für Abbrecherquote
#Rückgabewert:
# y_conv:Wahrscheinlichkeit jeder Klasse(Etwas wie)
####################################################################
#Gewichtsstandardabweichung 0.Initialisiert mit einer Normalverteilung von 1
def weight_variable(shape):
initial = tf.truncated_normal(shape, stddev=0.1)
return tf.Variable(initial)
#Vorspannung zur Standardabweichung 0.Initialisiert mit einer Normalverteilung von 1
def bias_variable(shape):
initial = tf.constant(0.1, shape=shape)
return tf.Variable(initial)
#Erstellen einer Faltungsschicht
def conv2d(x, W):
return tf.nn.conv2d(x, W, strides=[1, 1, 1, 1], padding='SAME')
#Erstellen einer Poolebene
def max_pool_2x2(x):
return tf.nn.max_pool(x, ksize=[1, 2, 2, 1],strides=[1, 2, 2, 1], padding='SAME')
#Transformiere den Eingang in 28x28x1
x_images = tf.reshape(images_placeholder, [-1, 28, 28, 1])
#Erzeugung der Faltungsschicht 1
with tf.name_scope('conv1') as scope:
W_conv1 = weight_variable([5, 5, 1, 32])
b_conv1 = bias_variable([32])
h_conv1 = tf.nn.relu(conv2d(x_images, W_conv1) + b_conv1)
#Erstellung der Pooling-Schicht 1
with tf.name_scope('pool1') as scope:
h_pool1 = max_pool_2x2(h_conv1)
#Erzeugung der Faltungsschicht 2
with tf.name_scope('conv2') as scope:
W_conv2 = weight_variable([5, 5, 32, 64])
b_conv2 = bias_variable([64])
h_conv2 = tf.nn.relu(conv2d(h_pool1, W_conv2) + b_conv2)
#Erstellung der Pooling-Schicht 2
with tf.name_scope('pool2') as scope:
h_pool2 = max_pool_2x2(h_conv2)
#Erstellung der vollständig verbundenen Schicht 1
with tf.name_scope('fc1') as scope:
W_fc1 = weight_variable([7*7*64, 1024])
b_fc1 = bias_variable([1024])
h_pool2_flat = tf.reshape(h_pool2, [-1, 7*7*64])
h_fc1 = tf.nn.relu(tf.matmul(h_pool2_flat, W_fc1) + b_fc1)
#Dropout-Einstellungen
h_fc1_drop = tf.nn.dropout(h_fc1, keep_prob)
#Erstellung der vollständig verbundenen Schicht 2
with tf.name_scope('fc2') as scope:
W_fc2 = weight_variable([1024, NUM_CLASSES])
b_fc2 = bias_variable([NUM_CLASSES])
#Normalisierung durch Softmax-Funktion
with tf.name_scope('softmax') as scope:
y_conv=tf.nn.softmax(tf.matmul(h_fc1_drop, W_fc2) + b_fc2)
#Gibt so etwas wie die Wahrscheinlichkeit jedes Etiketts zurück
return y_conv
def loss(logits, labels):
####################################################################
#Funktion zur Berechnung des Verlustes
#Streit:
# logits:Logit Tensor, float - [batch_size, NUM_CLASSES]
# labels:Tensor beschriften, int32 - [batch_size, NUM_CLASSES]
#Rückgabewert:
# cross_entropy:Gekreuzter Entropietensor, float
####################################################################
#Berechnung der Kreuzentropie
cross_entropy = -tf.reduce_sum(labels*tf.log(logits))
#Geben Sie an, dass in TensorBoard angezeigt werden soll
tf.scalar_summary("cross_entropy", cross_entropy)
return cross_entropy
def training(loss, learning_rate):
####################################################################
#Funktionen, die Trainingsoperationen definieren
#Streit:
# loss:Verlusttensor, loss()Ergebnis von
# learning_rate:Lernkoeffizient
#Rückgabewert:
# train_step:Training op
####################################################################
train_step = tf.train.AdamOptimizer(learning_rate).minimize(loss)
return train_step
def accuracy(logits, labels):
####################################################################
#Richtige Antwortrate(accuracy)Funktion zum Berechnen
#Streit:
# logits: inference()Ergebnis von
# labels:Tensor beschriften, int32 - [batch_size, NUM_CLASSES]
#Rückgabewert:
# accuracy:Richtige Antwortrate(float)
####################################################################
correct_prediction = tf.equal(tf.argmax(logits, 1), tf.argmax(labels, 1))
accuracy = tf.reduce_mean(tf.cast(correct_prediction, "float"))
tf.scalar_summary("accuracy", accuracy)
return accuracyｄ
if __name__ == '__main__':
with tf.Graph().as_default():
x_image = tf.placeholder("float", shape=[None,784]) #Eingang
y_label = tf.placeholder("float", shape=[None,10]) #Variable für Fehlerfunktion True Class Distribution
W = tf.Variable(tf.zeros([784,10])) #Gewicht
b = tf.Variable(tf.zeros([10])) #vorspannen
#y_label = tf.nn.softmax(tf.matmul(x_image,W)+b) # y=softmax(Wx+b)Die Differenzierung erfolgt ebenfalls ohne Erlaubnis
keep_prob = tf.placeholder("float")
#init_op = tf.initialize_all_variables() #Variable Initialisierung(Muss erforderlich sein, wenn Variablen verwendet werden)
logits = inference(x_image,keep_prob) # inference()So erstellen Sie ein Modell
loss_value = loss(logits,y_label) # loss()Den Verlust berechnen
train_op = training(loss_value,1e-4) # training()Rufen Sie an und trainieren Sie (1e-4 ist die Lernrate)
accur = accuracy(logits,y_label) # accuracy()Berechnung der Genauigkeit
init_op = tf.initialize_all_variables()
sess = tf.Session()
sess.run(init_op)
#Festlegen des Werts, der auf TensorBoard angezeigt werden soll
summary_op = tf.merge_all_summaries()
summary_writer = tf.train.SummaryWriter('/tmp/mnist_data', sess.graph_def)
#Durchführung von Schulungen
for step in range(20001):
batch = mnist.train.next_batch(50)
if step % 100 == 0:
train_accur = sess.run(accur,feed_dict={x_image: batch[0], y_label: batch[1], keep_prob:1.0})
print "step %d, training accuracy %g" % (step,train_accur)
sess.run(train_op,feed_dict={x_image:batch[0],y_label:batch[1],keep_prob:0.5})# 0.Ich halte es auf 5?
#Fügen Sie nach jedem Schritt den Wert hinzu, der auf dem TensorBoard angezeigt werden soll
summary_str = sess.run(summary_op, feed_dict={
x_image: batch[0],
y_label: batch[1],
keep_prob: 1.0})
summary_writer.add_summary(summary_str, step)
#Ergebnisanzeige
print "test accuracy %g"%sess.run(accur, feed_dict={
x_image:mnist.test.images,
y_label:mnist.test.labels,
keep_prob:1.0})
Die einzige Änderung ist der Inhalt von main. Es beginnt mit tf.Graph (). As_default () :. Darüber hinaus gibt es verschiedene Änderungen wie Zusammenfassung, aber ich kann es nicht schreiben, weil ich nicht genug verstehe, um zu erklären. .. .. Es tut mir Leid. Es funktioniert vorerst.
Führen Sie es danach wie folgt im Terminal aus. Dieses Mal befindet sich das Diagramm in '/ tmp / mnist_data'.
tensorboard --logdir /tmp/mnist_data/
Wenn Sie in Google Chrome eine Verbindung zu http: // localhost: 6006 / herstellen, werden einige coole Grafiken angezeigt.
Es gibt noch viele Teile, die ich nicht eingeholt habe. Wenn Sie also Probleme haben, kommentieren Sie diese bitte.
Recommended Posts