Je suis nouveau dans l'apprentissage automatique et j'apprends simplement. TensorFlow semble facile à comprendre et a des exemples simples. Mais je ne trouve pas comment créer un modèle qui peut prendre un tableau booléen (0 et 1) en entrée. Dans tous les exemples que j'ai trouvés, l'entrée est un tableau de nombres plus grands que 1. Quelqu'un peut-il s'il vous plaît me montrer comment construire un modèle avec 100 couches d'entrée booléennes et 1 sortie. Ou du moins, dites-moi où rechercher la solution.
MODIFIER
Mon code:
[[0.9999987 ] [0.9999964 ] [0.99999917] [0.9999995 ] [0.99999833] [1. ] [1. ] [1. ] [0.9999993 ] [0.9999999 ] [0.5781495 ] [1. ]]
Résumé:
32/2000 [..............................] - ETA: 2s 2000/2000 [==============================] - 0s 38us/step [6.117830600942398e-07, 1.0]
Historique des ajustements:
Epoch 1/2 32/2000 [..............................] - ETA: 11s - loss: 0.1560 - acc: 0.9688 1664/2000 [=======================>......] - ETA: 0s - loss: 0.0039 - acc: 0.9994 2000/2000 [==============================] - 0s 120us/step - loss: 0.0033 - acc: 0.9995 Epoch 2/2 32/2000 [..............................] - ETA: 0s - loss: 2.7940e-07 - acc: 1.0000 1696/2000 [========================>.....] - ETA: 0s - loss: 2.6042e-07 - acc: 1.0000 2000/2000 [==============================] - 0s 30us/step - loss: 2.5141e-07 - acc: 1.0000
Évaluer:
Total params: 19,821 Trainable params: 19,821 Non-trainable params: 0
Prédire :
array = []
with open("C:/temp/out.txt") as file:
for line in file:
array.append(list(map(int, list(line.rstrip('\n')))))
train_data = array[:2000]
test_data = array[2000:4000]
train_labels = [1] * 2000
test_labels = [1] * 2000
# Array for prediction check
check_data = array[4000:4010] # 10 correct inputs
check_data.append([0] * 100) # Incorrect data
check_data.append([1] * 100) # Incorrect data
# Converting to numpy array
check_data = np.asarray(check_data)
train_data = np.asarray(train_data)
test_data = np.asarray(test_data)
train_labels = np.asarray(train_labels)
test_labels = np.asarray(test_labels)
model = keras.Sequential()
model.add(keras.layers.Dense(100, input_shape=(100,)))
model.add(keras.layers.Dense(80))
model.add(keras.layers.Dense(20))
model.add(keras.layers.Dense(1, activation=tf.nn.sigmoid))
model.compile(optimizer=tf.train.AdamOptimizer(),
loss='binary_crossentropy',
metrics=['accuracy'])
model.summary()
history = model.fit(train_data,
train_labels,
epochs=2)
results = model.evaluate(test_data, test_labels)
predict = model.predict(check_data)
Comme vous pouvez le voir, seuls 100 zéros ne sont pas corrects, mais 100 uns (dernière entrée incorrecte) sont solides 1. Quelqu'un peut-il me montrer ce que je manque ici?
3 Réponses :
J'ai donc essayé le code ci-dessus avec des données générées aléatoirement. Au lieu de 1 et 0, ses 10 et 11
array=np.round(np.random.rand(4010,100))+10 #change in data
train_data = array[:2000]
test_data = array[2000:4000]
train_labels = [1] * 2000
test_labels = [1] * 2000
# Array for prediction check
check_data = [list(item) for item in array[4000:4010]] # 10 correct inputs
check_data.append([10] * 100) # Incorrect data
check_data.append([11] * 100) # Incorrect data
Predicted Output:
array([[1.],
[1.],
[1.],
[1.],
[1.],
[1.],
[1.],
[1.],
[1.],
[1.],
[1.],
[1.]], dtype=float32)
Donc, à partir de là, vous pouvez en déduire que 0 est pris à sa valeur nominale.
Dans les réseaux de neurones, chaque neurone résout l'équation y = wx + b
où y: sortie du neurone, w = poids, x = entrée du neurone, b = biais
Quand x = 0, y = b et x = 1, y = w + b
Par conséquent, chaque fois que l'entrée est 0, le neurone est presque éteint (les valeurs de biais sont généralement très petit)
Le modèle n'apprend pas que tous les 0 et tous les 1 sont des données erronées. La sortie pour tous les 0 est juste par coïncidence et la sortie pour tous les 1 nous indique que c'est une coïncidence et que quelque chose ne va pas.
De plus, vos données contiennent des 0 et des 1 avec l'étiquette 1 attachée. Vous ne pouvez pas vous attendre à donner tous les 1 et tous les 0 et vous attendre à ce que le modèle le prédise comme de mauvaises données.
Pour l'instant, je n'ai que des données qui sont correctes et devraient afficher 1 (vrai). Comment puis-je dire au modèle de trouver un modèle dans les données que j'ai et d'utiliser ce modèle dans la prédiction? Dois-je convertir les 0 et les 1 en un certain nombre comme vous l'avez fait? J'étais en train de sauter que tensorFlow a une méthode de prétraitement à cela, mais je ne l'ai pas trouvée.
Je ne pense pas qu'il soit possible de faire ce que vous voulez avec ces données. C'est comme apprendre une addition simple et ensuite essayer de résoudre un problème de statistiques. Vous savez quels sont les nombres et tout ce que vous avez appris à faire est de les additionner au hasard. Cela vous donnera une réponse, mais les chances que ce soit exact sont très faibles. Je vous conseillerais d'obtenir de meilleures données. Rappelez-vous toujours que le modèle est aussi bon que ses données.
Il semble que j'ai mal compris tout le concept des réseaux de neurones. Merci pour votre explication.
Heureux d'avoir pu aider. Si vous l'avez trouvé utile, auriez-vous l'amabilité de le voter.
Regardez vos libellés:
train_labels = [1] * 2000 test_labels = [1] * 2000
Tout est 1, tout vaut 1.
Bien sûr, votre modèle prédira 1 et seulement 1.
Vous devez entraîner votre modèle avec des données correctes.
Pour l'instant, je n'ai que des données qui sont correctes et devraient afficher 1 (vrai). Comment puis-je dire au modèle de trouver un modèle dans les données que j'ai et d'utiliser ce modèle dans la prédiction?
Vous devez avoir des données. Il est impossible de former un modèle sans données.
Comme vous pouvez le voir dans mon code, j'ai un tableau de données 'train_data' pour l'entraînement et 'test_data' pour l'évaluation. Aussi petit check_data pour le test de prédiction. Toutes les données sont des tableaux à 2 dimensions avec des tableaux de 0 et de 1. Ou tu veux dire autre chose?
Vous n'avez pas un seul exemple avec le résultat 0. Votre modèle n'apprendra jamais le résultat 0. Les réseaux neuronaux semblent intelligents, mais ce ne sont que des mémorisateurs. Il n'apprendra jamais quelque chose qu'il n'a jamais vu.
Il semble que j'ai mal compris tout le concept des réseaux de neurones. Merci pour votre explication.
Eh bien ... j'ai peut-être exagéré ici ... ils peuvent devenir assez intelligents, mais ils ont besoin de suffisamment d'exemples de tous les types de sorties.
S'ils ne peuvent pas trouver de modèle ou de dépendances dans les données, ce n'est pas ce que je cherchais. Au moins maintenant je le sais.
Ils le peuvent, mais vous avez d'abord besoin d'exemples pour la formation.
J'ai des exemples (environ 100 000), mais comme je l'ai dit je n'ai que des données correctes (vraies). J'utilisais juste une petite quantité de données pour tester si cela fonctionne même du tout. Selon moi, pour trouver le modèle correct, vous n'avez besoin que de données correctes.
Si vous ne disposez que de données correctes, votre modèle apprendra que tout est correct.
from keras.models import Sequential
from keras.layers import Dense
import numpy
def generate_data(n_samples):
X = np.zeros((n_samples,100))
y = np.zeros((n_samples))
for i in range(n_samples):
X[i] = np.random.randint(0,2,100)
r = xor(X[i])
y[i] = xor(X[i])
return X, y
def xor(a):
b = np.array(a,dtype=bool)
r = b[0]
for x in b[1:]:
r = r ^x
return int(r)
X, y = generate_data(1000)
model = Sequential()
model.add(Dense(100, input_dim=100, activation='relu'))
model.add(Dense(8, activation='relu'))
model.add(Dense(1, activation='sigmoid'))
# Compile model
model.compile(loss='binary_crossentropy', optimizer='adam', metrics=['accuracy'])
# Fit the model
model.fit(X, y, epochs=150, batch_size=10)
# evaluate the model
scores = model.evaluate(X, Y)
print("\n%s: %.2f%%" % (model.metrics_names[1], scores[1]*100))
Train data
We are generating a random array of size 100 of only 0'(False) and
1's (Trues). These are the samples (X's a we call in ML)
The label/target of the sample is the logical XOR of the sample. (called y in ML). As you can the the possible label values are 1 and 0 which makes it a binary classification problem
ModelA simple NN of 3 layers with 100 neurons in 1's layer, 8 neurons in second layer and 1 neuron in last layer.We have choosen 1 neuron in the last layer because we have 2 classes and we are using sigmoid activation so the last neuron > 0.5 we will assign the sample to class 1 else to class 0Then we train the model using binary crossentropy loss using adam optimizer for 150 epochs.
Avez-vous simplement essayé de former un modèle avec des entrées booléennes? Comme juste les nombres 0 ou 1?
S'agit-il vraiment de valeurs booléennes (True / False) ou entières (0/1)? Dans ce dernier cas, vous pouvez les utiliser immédiatement comme fonctionnalités. L'utilisation des fonctionnalités d'entrée binaire est très pratique pour les DNN (donc, les couches cachées denses).
@MatiasValdenegro Oui, j'ai essayé d'obtenir une précision 1 en seulement quelques entrées, ce qui est clairement faux. Et confirme que c'est faux quand je lance model.predict
@DmytroPrylipko J'ai essayé avec (0/1), mais je peux le convertir en (True / False) si cela peut aider. Mais quel type de couche d'entrée dois-je utiliser? Couche dense simple ou autre chose? Et quel type d'activation?
Veuillez ajouter des détails sur ce qui ne va pas exactement, obtenir une précision de 100% n'est pas faux en soi, peut-être voulez-vous dire sur-ajustement?
Si j'ai bien compris, model.evaluate doit montrer un surajustement, mais j'obtiens une précision de 1 lors de l'évaluation. Une autre chose, que j'ai principalement des données positives et juste une petite liste de données erronées pour enseigner le modèle. Je pense que c'est peut-être pourquoi le modèle prédit presque toutes les entrées comme 1.