Htydjtk

In the code below, I'm using a sequence to sequence approach as a prediction model for anomaly detection, The data set I'm working with is ADFA-LD. The training phase is done using only normal sequences. After predicting the next sequence , I want to add a classifier, which will detect abnormal sequences (the test data contains normal and abnormal sequences). To do this, I used oneClass SVM as a classifier.
I don't know why but, the program run normally sometimes and display this error sometimes else:

ValueError: setting an array element with a sequence

at line: fraud_pred = oneclass.predict(np.array(x_test))

The code:
# Train - Test Split
X=lines[['eng','Class1']]
y=lines[['fr','Class2']]
X_train, X_test, y_train, y_test = train_test_split(X, y, test_size = 0.2)

#fonction pour charger le data par lot (batch size)

#séquence du générateur utilisée pour entraîner le réseau de neurones 

def generate_batch(X = X_train, y = y_train, batch_size = 128):

  ''' Generate a batch of data '''



encoder_inputs = Input(shape=(None,))           

en_x=  Embedding(num_encoder_tokens, embedding_size,mask_zero = True) 

(encoder_inputs) #convertit chaque mot en un vecteur de taille fix

encoder = GRU(256, return_state=True)

encoder_outputs, state_h = encoder(en_x) 

decoder_inputs = Input(shape=(None,))

dex=  Embedding(num_decoder_tokens, embedding_size,mask_zero = 

          True)#convertit chaque mot en un vecteur de taille fix

final_dex= dex(decoder_inputs)

decoder_gru = GRU(256, return_sequences=True)

decoder_gru2 = GRU(256, return_sequences=True,return_state=True)

decoder_outputs= decoder_gru(final_dex,initial_state=encoder_states)

decoder_dense = Dense(num_decoder_tokens, activation='softmax')

decoder_outputs = decoder_dense(decoder_outputs)

model = Model([encoder_inputs, decoder_inputs], decoder_outputs)

start = time.time()

model.compile(optimizer='rmsprop', loss='categorical_crossentropy', metrics= 

      ['acc'])



train_samples = len(X_train)

val_samples = len(X_test) 



batch_size = 128

epochs = 1

mod_train=model.fit_generator(generator = generate_batch(X_train, y_train, 

              batch_size = batch_size),

                steps_per_epoch = train_samples//batch_size,

                epochs=epochs,

                validation_data = generate_batch(X_test, y_test, batch_size 

               = batch_size),

                validation_steps = val_samples//batch_size)

  df_history = pd.DataFrame (mod_train.history)

  print(df_history)

 #####################################

#modeles de prédiction

# define inference encoder

encoder_model = Model(encoder_inputs,encoder_states)

# define inference decoder

decoder_state_input_h = Input(shape=(256,))

decoder_states_inputs = [decoder_state_input_h]

final_dex2= dex(decoder_inputs)

print(final_dex2)

decoder_outputs2,state_h2 = decoder_gru2(final_dex2, 

initial_state=decoder_states_inputs)

decoder_states2 = [state_h2]

decoder_outputs2 = decoder_dense(decoder_outputs2)

decoder_model = Model([decoder_inputs] + decoder_states_inputs, 

     [decoder_outputs2] + decoder_states2)







def decode_sequence(input_seq):

   # Encode the input as state vectors.

   states_value = encoder_model.predict(input_seq)

   print(len(states_value),states_value.shape)

   # Generate empty target sequence of length 1.

   target_seq = np.zeros((1,1))

   # Populate the first word of target sequence with the start word.

   target_seq[0,0] = target_token_index['0000']



   stop_condition = False

   decoded_sentence = ''

   while not stop_condition:

      output_tokens,h= decoder_model.predict([target_seq]+[states_value]) 

      sampled_token_index = np.argmax(output_tokens[0, -1, :])

      sampled_char = reverse_target_char_index[sampled_token_index]

      decoded_sentence +=' '+sampled_char



      # Exit condition: either hit max length

      # or find stop character.

        if (sampled_char =='1111' or len(decoded_sentence.split(' '))> 

            max_len_fr-2):#critere d'arret (la fin de la phrase en français)

            stop_condition = True



      # Update the target sequence (of length 1).

      target_seq = np.zeros((1,1))

      target_seq[0] = sampled_token_index



      # Update states

      states_value = h 

   return decoded_sentence



y_true=

NN=

test_gen = generate_batch(X_train, y_train, batch_size = 1)

k=0

while k<300:

     (input_seq, actual_output), _ = next(test_gen)

     decoded_sentence = decode_sequence(input_seq)

     exp=map(float, str(decoded_sentence).split())

     NN.append(list(exp))

     k+=1



#seq_preditN = np.transpose(NN)

seq_preditN = NN

"""------Classification--- """



seq_preditA=

path1="abnormal.csv"

abnor_data=load_data(path1)

abnor_data.insert(1, 'Class1',1)

abnor_data.insert(3, 'Class2',1)

X_attck=abnor_data[['eng','Class1']]

y_attck=abnor_data[['fr','Class2']]

#X_trainA, X_testA, y_trainA, y_testA = train_test_split(X, y, test_size = 

   0.2)



test_gen = generate_batch(X_attck, y_attck, batch_size = 1)

k=-1

k+=1

while k<300:

     (input_seq, actual_output), _ = next(test_gen)

     decoded_sentence = decode_sequence(input_seq)

     print('Input English sentence:', X_attck[k:k+1].values[0])

print('Actual Marathi Translation:', y_attck.fr[k:k+1].values[0])

print('Predicted Marathi Translation:', decoded_sentence)

exp=map(float, str(decoded_sentence).split())

seq_preditA.append(list(exp))

k+=1 

#seq_preditN = seq_preditN[0:300]

#seq_preditA = np.transpose(seq_preditA)



 X_test = seq_preditA + seq_preditN

X_test = np.transpose(X_test)

#X_test = np.concatenate((seq_preditA, seq_preditN), axis =0)

print ("X_test")

print (X_test)

print("kkkkkkk", len(X_test))



oneclass = svm.OneClassSVM(kernel='linear', gamma=0.001, nu=0.95)

y=np.array([np.array(item) for item in seq_preditN])

oneclass.fit(np.array(y))

fraud_pred = oneclass.predict(np.array(X_test))

unique, counts = np.unique(fraud_pred, return_counts=True)

print (np.asarray((unique, counts)).T)

fraud_pred = pd.DataFrame(fraud_pred)

print("fraus.......",fraud_pred)

y1=y_attck.Class2[0:300]

y2=y_test.Class2[0:300]

Y_test=y1.append(y2)

print(Y_test)

If anyone can help me , I'll be sooo thankful