Skip to content
TheChatArchiveThe Chat Archive
gpt-3.5-turbo-0301· OpenAIAi2 WildChat-4.8M (AI2)

Есть многоклассовая классификация текстов from sklearn.modelselection import…

  1. User

    Есть многоклассовая классификация текстов from sklearn.model_selection import train_test_split

    разбиваем выборку на тренировочную и тестовую

    train_df, test_df = train_test_split(train_data, test_size=0.2, random_state=42)

    разбиваем тестовую выборку на тестовую и валидационную

    test_df, val_df = train_test_split(test_df, test_size=0.5, random_state=42) import tensorflow as tf from tensorflow import keras from tensorflow.keras import layers from tensorflow.keras.preprocessing.text import Tokenizer from tensorflow.keras.preprocessing.sequence import pad_sequences

    max_len = 600 # максимальная длина последовательности num_classes = 13 # число классов для классификации

    создаем токенизатор

    tokenizer = Tokenizer() tokenizer.fit_on_texts(train_df['text'])

    преобразуем текст в последовательность чисел

    train_sequences = tokenizer.texts_to_sequences(train_df['text']) test_sequences = tokenizer.texts_to_sequences(test_df['text']) val_sequences = tokenizer.texts_to_sequences(val_df['text'])

    добавляем паддинг

    train_sequences = pad_sequences(train_sequences, maxlen=max_len) test_sequences = pad_sequences(test_sequences, maxlen=max_len) val_sequences = pad_sequences(val_sequences, maxlen=max_len)

    создаем модель seq2seq

    input_dim = len(tokenizer.word_index) + 1 embedding_dim = 50

    model = keras.Sequential([ layers.Embedding(input_dim=input_dim, output_dim=embedding_dim, input_length=max_len), layers.LSTM(units=64, dropout=0.2, recurrent_dropout=0.2), layers.Dense(num_classes, activation='softmax') ])

    model.summary() # выводим информацию о модели from sklearn.metrics import f1_score import tensorflow.keras.backend as K from tensorflow.keras.losses import CategoricalCrossentropy

    import numpy as np

    from keras import backend as K

    def recall_m(y_true, y_pred): true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) possible_positives = K.sum(K.round(K.clip(y_true, 0, 1))) recall = true_positives / (possible_positives + K.epsilon()) return recall

    def precision_m(y_true, y_pred): true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1))) predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1))) precision = true_positives / (predicted_positives + K.epsilon()) return precision

    def f1_m(y_true, y_pred): precision = precision_m(y_true, y_pred) recall = recall_m(y_true, y_pred) return 2*((precision*recall)/(precision+recall+K.epsilon()))

    #model.compile(loss=CategoricalCrossentropy(), optimizer='adam', metrics=['acc',f1_m,precision_m, recall_m]) model.compile(loss=CategoricalCrossentropy(), optimizer='adam', metrics=['acc',f1_m,precision_m, recall_m])

    history = model.fit(train_sequences, train_df['category'], epochs=10, batch_size=1000, validation_data=(val_sequences, val_df['category'])) Получаем ошибку history = model.fit(train_sequences, train_df['category'], 33 epochs=10, batch_size=1000, 34 validation_data=(val_sequences, val_df['category'])) ValueError: Shapes (None, 1) and (None, 13) are incompatible

  2. Assistant

    Ошибка возникает из-за того, что форма выходных данных модели не соответствует форме целевых меток. В данном случае модель имеет 1 выходной нейрон, а количество классов для классификации равно 13.

    Для решения проблемы необходимо изменить число выходных нейронов на число классов в задаче классификации:

    num_classes = 13 # число классов для классификации
    
    model = keras.Sequential([
        layers.Embedding(input_dim=input_dim, output_dim=embedding_dim, input_length=max_len),
        layers.LSTM(units=64, dropout=0.2, recurrent_dropout=0.2),
        layers.Dense(num_classes, activation='softmax')
    ])
    

    Затем необходимо изменить форму целевых меток с помощью One-Hot Encoding:

    from sklearn.preprocessing import OneHotEncoder
    
    # One-Hot Encoding для целевых меток
    enc = OneHotEncoder(handle_unknown='ignore')
    train_y = enc.fit_transform(train_df['category'].values.reshape(-1, 1)).toarray()
    val_y = enc.transform(val_df['category'].values.reshape(-1, 1)).toarray()
    test_y = enc.transform(test_df['category'].values.reshape(-1, 1)).toarray()
    

    И изменить функцию потерь на CategoricalCrossentropy:

    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc', f1_m, precision_m, recall_m])
    

    В результате, код должен выглядеть следующим образом:

    from sklearn.metrics import f1_score
    import tensorflow.keras.backend as K
    from tensorflow.keras.losses import CategoricalCrossentropy
    from sklearn.preprocessing import OneHotEncoder
    
    import numpy as np
    
    # One-Hot Encoding для целевых меток
    enc = OneHotEncoder(handle_unknown='ignore')
    train_y = enc.fit_transform(train_df['category'].values.reshape(-1, 1)).toarray()
    val_y = enc.transform(val_df['category'].values.reshape(-1, 1)).toarray()
    test_y = enc.transform(test_df['category'].values.reshape(-1, 1)).toarray()
    
    def recall_m(y_true, y_pred):
        true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
        possible_positives = K.sum(K.round(K.clip(y_true, 0, 1)))
        recall = true_positives / (possible_positives + K.epsilon())
        return recall
    
    def precision_m(y_true, y_pred):
        true_positives = K.sum(K.round(K.clip(y_true * y_pred, 0, 1)))
        predicted_positives = K.sum(K.round(K.clip(y_pred, 0, 1)))
        precision = true_positives / (predicted_positives + K.epsilon())
        return precision
    
    def f1_m(y_true, y_pred):
        precision = precision_m(y_true, y_pred)
        recall = recall_m(y_true, y_pred)
        return 2*((precision*recall)/(precision+recall+K.epsilon()))
    
    num_classes = 13 # число классов для классификации
    
    # создаем модель seq2seq
    input_dim = len(tokenizer.word_index) + 1
    embedding_dim = 50
    
    model = keras.Sequential([
        layers.Embedding(input_dim=input_dim, output_dim=embedding_dim, input_length=max_len),
        layers.LSTM(units=64, dropout=0.2, recurrent_dropout=0.2),
        layers.Dense(num_classes, activation='softmax')
    ])
    
    model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['acc', f1_m, precision_m, recall_m])
    
    history = model.fit(train_sequences, train_y, 
                        epochs=10, batch_size=1000, 
                        validation_data=(val_sequences, val_y))
    

Responses were produced in different, uncontrolled contexts (system prompts, settings, prior turns). This is not a benchmark.