मैं simpleRNN मॉडल का परीक्षण कर रहा हूँ

मेरा परीक्षण डेटा सुपर सरल दोहराए जाने वाला ट्रिपल 2 बिट * 12 . है

[1,0,0,0,1,0,0,1,0,0,0,0],[1,0,0,0,0,1,0,0,0,1,0,0],[0,0,1,0,0,0,0,1,0,0,0,1]

for i in range(0,100):
    temp = [[1,0,0,0,1,0,0,1,0,0,0,0],
        [1,0,0,0,0,1,0,0,0,1,0,0],
        [0,0,1,0,0,0,0,1,0,0,0,1]]
    line.extend(temp)
total = []
for j in range(0,500):
    total.append(line)
total = np.array(total)
print(total.shape) # (500, 300, 12)

यह (500, 300, 12) को सुन्न कर देता है। सभी डेटा बस दोहरा रहे हैं, इसलिए मुझे उम्मीद है कि प्रशिक्षण और भविष्यवाणी पूरी तरह से काम करेगी।

हालांकि val_loss घटता नहीं है और भविष्यवाणी प्रभावी रूप से काम नहीं करती है।

Epoch 1/5
743/743 [==============================] - 5s 5ms/step - loss: 0.1386 - val_loss: 0.1305
Epoch 2/5
743/743 [==============================] - 3s 4ms/step - loss: 0.1305 - val_loss: 0.1294
Epoch 3/5
743/743 [==============================] - 3s 4ms/step - loss: 0.1299 - val_loss: 0.1292
Epoch 4/5
743/743 [==============================] - 3s 4ms/step - loss: 0.1300 - val_loss: 0.1291
Epoch 5/5
743/743 [==============================] - 3s 4ms/step - loss: 0.1299 - val_loss: 0.1293
[[ 0.67032564 -0.0020391   0.3332582  -0.0095186   0.35370785  0.3042156
   0.00809216  0.7059332   0.00199411  0.30952734 -0.0021943   0.333712  ]]
tf.Tensor([[1 0 0 0 0 0 0 1 0 0 0 0]], shape=(1, 12), dtype=int32)

मुझे उम्मीद है कि परिणाम स्मिलर [1,0,0,0,1,0,0,1,0,0,0,0] के रूप में होगा, हालांकि,,,,

मुझे कहीं बदलने की जरूरत है या मेरा कोड गलत है ??

ये मेरी पूरी डोर हैं।

import tensorflow as tf
from django.core.management.base import BaseCommand, CommandError
from tensorflow.keras.models import Sequential
from tensorflow.keras.layers import LSTM,Dropout,Dense
from tensorflow.keras.layers import SimpleRNN
import numpy as np
from tensorflow.keras.optimizers import SGD
from tensorflow.keras.optimizers import Adam
from sklearn.model_selection import train_test_split

def makeModel(input_len,n_in):
    n_hidden = 512
    model = Sequential()
    model.add(SimpleRNN(n_hidden, input_shape=(input_len, n_in), return_sequences=False))
    model.add(Dense(n_hidden, activation="relu")) 
    model.add(Dense(n_in, activation="relu"))
    opt = Adam(lr=0.001)
    model.compile(loss='mse', optimizer=opt)
    model.summary()
    return model
 

line = []
    
for i in range(0,100):
    temp = [[1,0,0,0,1,0,0,1,0,0,0,0],
        [1,0,0,0,0,1,0,0,0,1,0,0],
        [0,0,1,0,0,0,0,1,0,0,0,1]]
    line.extend(temp)
total = []
for j in range(0,500):
    total.append(line)
total = np.array(total)
print(total.shape) # (500, 300, 12)

chordIdList = total
n_in = 12 # dimention
input_len = 3 # length to use prediction.
model = makeModel(input_len,n_in)

input_=[]
target_=[]
for C in chordIdList:
    for i in range(0, len(C) - input_len):  
        input_.append( C[i:i+input_len] )  
        target_.append( C[i+input_len] )  
        
X = np.array(input_)
Y = np.array(target_).reshape((len(input_),1,n_in))

from sklearn.model_selection import train_test_split
x, x_val,y, y_val = train_test_split(X, Y, train_size=0.8, random_state=1)
print(x.shape) # (23760, 3, 12)
print(y.shape) # (23760, 1, 12)
print(x_val.shape) #(5940, 3, 12)
print(y_val.shape) # (5940, 1, 12)

epoch = 5
history = model.fit(x, y, epochs=epoch,validation_data=(x_val, y_val))

in_ = np.array([[1,0,0,0,1,0,0,1,0,0,0,0],
        [1,0,0,0,0,1,0,0,0,1,0,0],
        [0,0,1,0,0,0,0,1,0,0,0,1]]).reshape(1,3,12) 
        
print(in_.shape)
out_ = model.predict(in_)
print(out_)
0
whitebear 12 जिंदा 2021, 16:01
fit() को कॉल करने से पहले कृपया x.shape, y.shape दिखाएं
 – 
Andrey
12 जिंदा 2021, 16:39
मैंने लेख अपडेट किया।
 – 
whitebear
12 जिंदा 2021, 17:20
मानक एडम सीखने की दर 1e-5 . का उपयोग करने का प्रयास करें
 – 
Andrey
12 जिंदा 2021, 17:27
आपकी सलाह के लिए धन्यवाद, मैंने एडम (0.1 ~ 0.000001) के कई पैटर्न का परीक्षण किया, लेकिन इतना नहीं बदला। अद्यतन लेख
 – 
whitebear
12 जिंदा 2021, 18:46

1 उत्तर

सबसे बढ़िया उत्तर

ठीक है, यहाँ आपको एक बड़ी समस्या है, आप प्रतिगमन करने का प्रयास कर रहे हैं जबकि आपकी समस्या शुद्ध वर्गीकरण है।

कोड के इस भाग में आपको क्या करने की आवश्यकता है:

def makeModel(input_len,n_in):
    n_hidden = 512
    model = Sequential()
    model.add(SimpleRNN(n_hidden, input_shape=(input_len, n_in), return_sequences=False))
    model.add(Dense(n_hidden, activation="relu")) 
    model.add(Dense(n_in, activation="relu"))
    opt = Adam(lr=0.001)
    model.compile(loss='mse', optimizer=opt)
    model.summary()
    return model

अंतिम परत को सिग्मॉइड सक्रियण में बदलें (0 और 1 के बीच आउटपुट, जैसे आपके मामले में)

model.add(Dense(n_in, activation="sigmoid"))

नुकसान को बाइनरी क्रॉसेंट्रॉपी में बदलें

model.compile(loss='binary_crossentropy', optimizer=opt)

Relu का उपयोग करके आप एक अनंत फ़ंक्शन के लिए मान को मैप करने का प्रयास कर रहे हैं, जो सीखने को जटिल बनाता है, मैं कहूंगा।

इसके अलावा, वाई का उपयोग करके निचोड़ें

history = model.fit(x, np.squeeze(y), epochs=epoch,validation_data=(x_val, np.squeeze(y_val)))

1
Orphee Faucoz 12 जिंदा 2021, 20:18
देर से उत्तर के लिए क्षमा करें, लेकिन आपकी व्याख्या बिल्कुल स्पष्ट है और मेरी समस्या हल हो गई है !!!
 – 
whitebear
30 जिंदा 2021, 18:46