ValueError: Нет значений, не поддерживаемых в model.fit

Question

Я пытаюсь реализовать набор данных Liar Liar Pants on Fire . Это поддельный набор данных для обнаружения новостей. Код, который я написал до сих пор, приведен ниже.

nltk.download('stopwords')
nlp = spacy.load('en')

drive.mount("/content/drive")
train = "/content/drive/My Drive/Deep Learning/train.tsv"
vl = "/content/drive/My Drive/Deep Learning/valid.tsv"
tst = "/content/drive/My Drive/Deep Learning/test.tsv"

train_data = pd.read_table(train, names = ["id", "label", "statement", "subject", "speaker", "job", "state", "party", "barely-true", "false", "half-true", "mostly-true", "pants-fire", "venue"])

val_data = pd.read_table(vl, names = ["id", "label", "statement", "subject", "speaker", "job", "state", "party", "barely-true", "false", "half-true", "mostly-true", "pants-fire", "venue"])

test_data = pd.read_table(tst, names = ["id", "label", "statement", "subject", "speaker", "job", "state", "party", "barely-true", "false", "half-true", "mostly-true", "pants-fire", "venue"])

y_label_dict = {"pants-fire" : 0, "false" : 1, "barely-true" : 2, "half-true" : 3, "mostly-true" : 4, "true" : 5}

train_data['output'] = train_data['label'].apply(lambda x: y_label_dict[x])
val_data['output'] = val_data['label'].apply(lambda x: y_label_dict[x])
test_data['output'] = test_data['label'].apply(lambda x: y_label_dict[x])

def update_yld(k):
  yld, i = {}, 1
  for s in train_data[k].unique():
    if isinstance(s, str):
      yld[s] = i
      i+=1
    else:
      yld[s] = 0
  return yld


def get_ylabel(k, yld):
  if k in yld.keys():
    return yld[k]
  else:
    return 0

def add_data(k):
  yld = update_yld(k)
  train_data[k+"_id"] = train_data[k].apply(lambda x: get_ylabel(x, yld))
  val_data[k+"_id"] = val_data[k].apply(lambda x: get_ylabel(x, yld))
  test_data[k+"_id"] = test_data[k].apply(lambda x: get_ylabel(x, yld)) 

add_data("speaker")
add_data("job")
add_data("party")
add_data("state")
add_data("subject")
add_data("venue")

tokenizer = Tokenizer()
tokenizer.fit_on_texts(train_data['statement'])
vocabulary_dict = tokenizer.word_index

def preprocess_statement(statement):
  statement = [w for w in statement.split(' ') if w not in stopwords.words('english')]
  statement = ' '.join(statement)
  text = text_to_word_sequence(statement)
  val = [vocabulary_dict[t] for t in text if t in vocabulary_dict]
  return val

train_data['word_id'] = train_data['statement'].apply(preprocess_statement)
val_data['word_id'] = val_data['statement'].apply(preprocess_statement)
test_data['word_id'] = test_data['statement'].apply(preprocess_statement)

pos_dict = {'ADV': 8, 'NOUN': 5, 'ADP': 7, 'PRON': 9, 'PROPN': 3, 'SPACE': 17, 'DET': 2, 'SYM': 12, 'INTJ': 14, 'PART': 10, 'PUNCT': 6, 'VERB': 1, 'X': 16, 'AUX': 15, 'CCONJ': 13, 'NUM': 11, 'ADJ': 4}
# i=1
# for l in train_data["statement"]:
#   doc = nlp(l.decode('utf-8', 'ignore'))
#   for token in doc:
#     if token.pos_ not in pos_dict.keys():
#       pos_dict[token.pos_] = i
#       i += 1
# print(pos_dict)

def get_pos(statement):
  doc = nlp(statement)
  taglist = []
  for token in doc:
    taglist.append(pos_dict.get(token.pos_, 0))
  return taglist

train_data['pos_id'] = train_data['statement'].apply(get_pos)
val_data['pos_id'] = val_data['statement'].apply(get_pos)
test_data['pos_id'] = test_data['statement'].apply(get_pos)

dep_dict = {'': 46, 'cc': 29, 'agent': 39, 'ccomp': 7, 'prt': 14, 'mark': 32, 'nsubjpass': 34, 'csubj': 37, 'conj': 30, 'amod': 5, 'neg': 23, 'meta': 47, 'csubjpass': 45, 'relcl': 24, 'auxpass': 31, 'advcl': 13, 'aux': 15, 'ROOT': 1, 'prep': 10, 'parataxis': 43, 'case': 38, 'nsubj': 6, 'nummod': 21, 'advmod': 12, 'punct': 8, 'quantmod': 28, 'acomp': 19, 'compound': 3, 'pcomp': 17, 'subtok': 33, 'intj': 40, 'poss': 20, 'npadvmod': 26, 'xcomp': 16, 'attr': 25, 'dep': 36, 'appos': 27, 'det': 2, 'nmod': 4, 'dobj': 9, 'dative': 18, 'pobj': 11, 'expl': 42, 'predet': 41, 'preconj': 44, 'oprd': 35, 'acl': 22}
# i=1
# for l in train_data["statement"]:
#   doc = nlp(l.decode('utf-8', 'ignore'))
#   for token in doc:
#     if token.dep_ not in dep_dict.keys():
#       dep_dict[token.dep_] = i
#       i += 1
# print(dep_dict)

def get_dep_parse(statement):
  doc = nlp(statement)
  deplist = []
  for token in doc:
    deplist.append(dep_dict.get(token.dep_, max(dep_dict.values())))
  return deplist


train_data['dep_id'] = train_data['statement'].apply(get_dep_parse)
val_data['dep_id'] = val_data['statement'].apply(get_dep_parse)
test_data['dep_id'] = test_data['statement'].apply(get_dep_parse)

num_classes = 6

train_data.head()

embeddings = {}
with open("/content/drive/My Drive/Deep Learning/glove.6B.100d.txt") as file_object:
  for line in file_object:
    word_embed = line.split()
    word = word_embed[0]
    embed = np.array(word_embed[1:], dtype="float32")
    embeddings[word.lower()]= embed

EMBED_DIM = 100
print(len(embeddings), " : Word Embeddings Found")
print(len(embeddings[word]), " : Embedding Dimension")

num_words = len(vocabulary_dict)
embedding_matrix = np.zeros((num_words, EMBED_DIM))

for word, i in vocabulary_dict.items():
    embedding_vector = embeddings.get(word)
    if embedding_vector is not None:
        embedding_matrix[i] = embedding_vector

pos_embeddings = np.identity(max(pos_dict.values()), dtype=int)
dep_embeddings = np.identity(max(dep_dict.values()), dtype=int)

vocab_length = len(vocabulary_dict.keys())
hidden_size = EMBED_DIM
size = 100
num_steps = 15
num_epochs = 30
batch_size = 100

num_party = len(train_data.party_id.unique())
num_state = len(train_data.state_id.unique())
num_venue = len(train_data.venue_id.unique())
num_job = len(train_data.job_id.unique())
num_sub = len(train_data.subject_id.unique())
num_speaker = len(train_data.speaker_id.unique())

X_train = train_data['word_id']
X_val = val_data['word_id']
X_test = test_data['word_id']

Y_train = train_data['output']
Y_train = keras.utils.to_categorical(Y_train, num_classes=6)

Y_val = val_data['output']
Y_val = keras.utils.to_categorical(Y_val, num_classes=6)

X_train = sequence.pad_sequences(X_train, maxlen=num_steps, padding='post',truncating='post')
X_val = sequence.pad_sequences(X_val, maxlen=num_steps, padding='post',truncating='post')
X_test = sequence.pad_sequences(X_test, maxlen=num_steps, padding='post',truncating='post')

X_train_pos = train_data['pos_id']
X_val_pos = val_data['pos_id']
X_test_pos = test_data['pos_id']

X_train_pos = sequence.pad_sequences(X_train_pos, maxlen=num_steps, padding='post',truncating='post')
X_val_pos = sequence.pad_sequences(X_val_pos, maxlen=num_steps, padding='post',truncating='post')
X_test_pos = sequence.pad_sequences(X_test_pos, maxlen=num_steps, padding='post',truncating='post')


X_train_dep = train_data['dep_id']
X_val_dep = val_data['dep_id']
X_test_dep = test_data['dep_id']

X_train_dep = sequence.pad_sequences(X_train_dep, maxlen=num_steps, padding='post',truncating='post')
X_val_dep = sequence.pad_sequences(X_val_dep, maxlen=num_steps, padding='post',truncating='post')
X_test_dep = sequence.pad_sequences(X_test_dep, maxlen=num_steps, padding='post',truncating='post')

party_train = keras.utils.to_categorical(train_data['party_id'], num_classes=num_party)
state_train = keras.utils.to_categorical(train_data['state_id'], num_classes=num_state)
venue_train = keras.utils.to_categorical(train_data['venue_id'], num_classes=num_venue)
job_train = keras.utils.to_categorical(train_data['job_id'], num_classes=num_job)
subject_train = keras.utils.to_categorical(train_data['subject_id'], num_classes=num_sub)
speaker_train = keras.utils.to_categorical(train_data['speaker_id'], num_classes=num_speaker)

X_train_meta = np.hstack((party_train, state_train, venue_train, job_train, subject_train, speaker_train))

party_val = keras.utils.to_categorical(val_data['party_id'], num_classes=num_party)
state_val = keras.utils.to_categorical(val_data['state_id'], num_classes=num_state)
venue_val = keras.utils.to_categorical(val_data['venue_id'], num_classes=num_venue)
job_val = keras.utils.to_categorical(val_data['job_id'], num_classes=num_job)
subject_val = keras.utils.to_categorical(val_data['subject_id'], num_classes=num_sub)
speaker_val = keras.utils.to_categorical(val_data['speaker_id'], num_classes=num_speaker)

X_val_meta = np.hstack((party_val, state_val, venue_val, job_val, subject_val, speaker_val))

party_test = keras.utils.to_categorical(test_data['party_id'], num_classes=num_party)
state_test = keras.utils.to_categorical(test_data['state_id'], num_classes=num_state)
venue_test = keras.utils.to_categorical(test_data['venue_id'], num_classes=num_venue)
job_test = keras.utils.to_categorical(test_data['job_id'], num_classes=num_job)
subject_test = keras.utils.to_categorical(test_data['subject_id'], num_classes=num_sub)
speaker_test = keras.utils.to_categorical(test_data['speaker_id'], num_classes=num_speaker)

X_test_meta = np.hstack((party_test, state_test, venue_test, job_test, subject_test, speaker_test))

def train(model, name):
  # sgd = optimizers.SGD(lr=0.025, clipvalue=0.3, nesterov=True)
  adam = optimizers.Adam(lr=0.000075, beta_1=0.9, beta_2=0.999, epsilon=None, decay=0.0, amsgrad=False)
  model.compile(optimizer=adam,loss='categorical_crossentropy',metrics=['categorical_accuracy'])
  tb = TensorBoard()
  csv_logger = keras.callbacks.CSVLogger('training.log')
  filepath= name+"_weights_best.hdf5"
  checkpoint = keras.callbacks.ModelCheckpoint(filepath, monitor='val_categorical_accuracy', verbose=1, save_best_only=True, mode='max')

  history = model.fit({'main_input': X_train, 'pos_input': X_train_pos, 'aux_input': X_train_meta, 'dep_input': X_train_dep}, {'main_output': Y_train}, epochs = num_epochs, batch_size = batch_size, validation_data = (
 {'main_input': X_val, 'pos_input': X_val_pos, 'aux_input': X_val_meta, 'dep_input' : X_val_dep},
 {'main_output': Y_val}), callbacks=[tb,csv_logger,checkpoint])

statement_input = Input(shape=(num_steps,), dtype='int32', name='main_input')
x = Embedding(vocab_length,EMBED_DIM,weights=[embedding_matrix],input_length=num_steps,trainable=False)(statement_input) 
in1 = LSTM(size,dropout=0.2)(x)

pos_input = Input(shape=(num_steps,), dtype='int32', name='pos_input')
x2 = Embedding(max(pos_dict.values()), max(pos_dict.values()), weights=[pos_embeddings], input_length=num_steps, trainable=False)(pos_input)
in2 = LSTM(size, dropout=0.2)(x2)

dep_input = Input(shape=(num_steps,), dtype='int32', name='dep_input')
x3 = Embedding(max(dep_dict.values()), max(dep_dict.values()), weights=[dep_embeddings], input_length=num_steps, trainable=False)(dep_input)
in3 = LSTM(size, dropout=0.2)(x3)

meta_input = Input(shape=(X_train_meta.shape[1],), name='aux_input')
x_meta = Dense(64, activation='relu')(meta_input)

x = keras.layers.concatenate([in1, in2, in3, x_meta])

main_output = Dense(6, activation='softmax', name='main_output')(x)

model = Model(inputs=[statement_input, pos_input, dep_input, meta_input], outputs=[main_output])

print(model.summary())

train(model,'lstm')

Я получаю ошибку в model.fit. Это говорит о том, что:

Я не знаю, что я делаю неправильно. Я проверил все значения, которые model.fit использует, и там нет значения None. Я проверил все значения с помощью этого фрагмента кода.

for i in range(len(Y_val)):
  for j in range(len(Y_val[i])):
    if Y_val[i][j] == None:
      print(i)
      print(j)

И, очевидно, нет значения None во всех переменных. Переменные, которые я проверил, это X_train, X_train_pos, X_train_meta, X_train_dep, Y_train, X_val, X_val_pos, X_val_meta, X_val_dep, Y_val.