Sure, here's an example code that you can use to create a classification model with TF-IDF and LSTM:
```python
from keras.preprocessing.text import Tokenizer
from keras.preprocessing.sequence import pad_sequences
from keras.models import Sequential
from keras.layers import Dense, Dropout, Embedding, LSTM
from keras.utils import to_categorical
from sklearn.utils.class_weight import compute_class_weight
from tqdm import tqdm

# Set the maximum number of words to consider in the dataset
MAX_NB_WORDS = 10000
# Set the maximum length of each document (in words)
MAX_DOC_LEN = 100
# Set the embedding dimension
EMBEDDING_DIM = 100

# Tokenize the text data
tokenizer = Tokenizer(num_words=MAX_NB_WORDS)
tokenizer.fit_on_texts(X_train_fold)

# Convert the text data to sequence of tokens
X_train_seq = tokenizer.texts_to_sequences(X_train_fold)
X_val_seq = tokenizer.texts_to_sequences(X_val_fold)
X_test_seq = tokenizer.texts_to_sequences(X_test)

# Pad the sequences to have the same length
X_train_pad = pad_sequences(X_train_seq, maxlen=MAX_DOC_LEN)
X_val_pad = pad_sequences(X_val_seq, maxlen=MAX_DOC_LEN)
X_test_pad = pad_sequences(X_test_seq, maxlen=MAX_DOC_LEN)

# Convert the target labels to one-hot encoding
y_train_one_hot = to_categorical(y_train_fold, num_classes=8)
y_val_one_hot = to_categorical(y_val_fold, num_classes=8)

# Compute class weights
class_weights = compute_class_weight(class_weight='balanced', classes=np.unique(y_train_fold), y=y_train_fold)

# Define the model architecture
model = Sequential()
model.add(Embedding(MAX_NB_WORDS, EMBEDDING_DIM, input_length=MAX_DOC_LEN))
model.add(LSTM(64, dropout=0.2, recurrent_dropout=0.2))
model.add(Dense(8, activation='softmax'))

# Compile the model
model.compile(loss='categorical_crossentropy', optimizer='adam', metrics=['accuracy'])

# Train the model
epochs = 10
batch_size = 64
history = None
for epoch in range(epochs):
    print(f'Epoch {epoch + 1}/{epochs}')
    # Train the model on the current fold
    history = model.fit(X_train_pad, y_train_one_hot, epochs=1, batch_size=batch_size,
                        validation_data=(X_val_pad, y_val_one_hot),
                        class_weight=class_weights,
                        verbose=0)
    # Print the training and validation accuracy
    print(f'Train accuracy: {history.history["accuracy"][0]:.4f}')
    print(f'Val accuracy: {history.history["val_accuracy"][0]:.4f}')

# Make predictions on the test set
y_test_pred = model.predict_classes(X_test_pad)

# Save the predictions to a file
df_test_pred = pd.DataFrame({'id': test_data['id'], 'label': y_test_pred})
df_test_pred.to_csv('./0317_test.csv', index=False, columns=['id', 'label'])
```
This code uses Keras to define a simple LSTM model with an embedding layer for word embeddings. The model is trained on the training set (`X_train_fold` and `y_train_fold`) and validated on the validation set (`X_val_fold` and `y_val_fold`). The class weights are computed using the `compute_class_weight` function from scikit-learn to balance the class distribution in the training data.

The progress of the training process is displayed using tqdm, and the final predictions on the test set are saved to a CSV file named `0317_test.csv` in the current directory, with columns `id` and `
TF-IDF와 LSTM으로 분류 모델을 생성하는 데 사용할 수 있는 예제 코드는 다음과 같습니다:'''pythonfrom keras.preprocessing.text import Tokenizerfrom keras.preprocessing.sequence import pad_sequenceskeras.models에서 Sequential을 가져옵니다.keras.layers에서 밀도, 드롭아웃, 임베딩, LSTM을 임포트합니다.keras.utils에서 to_categorical 가져오기sklearn.utils.class_weight에서 compute_class_weight를 가져옵니다.tqdm에서 tqdm을 가져옵니다.# 데이터 집합에서 고려할 최대 단어 수를 설정합니다.max_nb_words = 10000# 각 문서의 최대 길이(단어 단위)를 설정합니다.max_doc_len = 100# 임베딩 차원 설정embedding_dim = 100# 텍스트 데이터 토큰화토큰화기 = 토큰화기(num_words=MAX_NB_WORDS)tokenizer.fit_on_texts(X_train_fold)# 텍스트 데이터를 토큰 시퀀스로 변환합니다.X_train_seq = 토큰화기.텍스트_투_시퀀스(X_train_fold)X_val_seq = 토큰화기.텍스트_투_시퀀스(X_val_fold)X_test_seq = 토큰화기.텍스트_투_시퀀스(X_test)# 시퀀스의 길이가 같도록 패딩하기X_train_pad = pad_sequences(X_train_seq, maxlen=MAX_DOC_LEN)X_val_pad = pad_sequences(X_val_seq, maxlen=MAX_DOC_LEN)X_test_pad = pad_sequences(X_test_seq, maxlen=MAX_DOC_LEN)# 대상 레이블을 원핫 인코딩으로 변환Y_TRAIL_ONE_HOT = TO_CATAGORICAL(Y_TRAIL_FOLD, NUM_CLASSES=8)Y_VAL_ONE_HOT = TO_CATAGORICAL(Y_VAL_FOLD, NUM_CLASSES=8)# 클래스 가중치 계산class_weights = compute_class_weight(class_weight='balanced', classes=np.unique(y_train_fold), y=y_train_fold)# 모델 아키텍처 정의model = Sequential()model.add(Embedding(MAX_NB_WORDS, EMBEDDING_DIM, input_length=MAX_DOC_LEN))model.add(LSTM(64, dropout=0.2, recurrent_dropout=0.2))model.add(Dense(8, activation='softmax'))# 모델 컴파일model.compile(loss='범주형_크로센트로피', optimizer='adam', metrics=['accuracy'])# 모델 훈련epochs = 10batch_size = 64history = 없음for epoch in range(epochs):    print(f'에포크 {에포크 + 1}/{에포크}')    # 현재 폴드에서 모델 훈련    history = model.fit(X_train_pad, y_train_one_hot, epochs=1, batch_size=batch_size,                        validation_data=(X_val_pad, y_val_one_hot),                        class_weight=class_weights,                        verbose=0)    # 훈련 및 검증 정확도 인쇄    print(f'Train accuracy: {history.history["accuracy"][0]:.4f}')    print(f'Val accuracy: {history.history["val_accuracy"][0]:.4f}')# 테스트 세트에 대한 예측 만들기y_test_pred = model.predict_classes(X_test_pad)# 예측을 파일에 저장df_test_pred = pd.DataFrame({'id': test_data['id'], 'label': y_test_pred})df_test_pred.to_csv('./0317_test.csv', index=False, columns=['id', 'label'])```이 코드는 Keras를 사용하여 단어 임베딩을 위한 임베딩 레이어가 있는 간단한 LSTM 모델을 정의합니다. 이 모델은 훈련 세트(`X_train_fold` 및 `y_train_fold`)에서 훈련되고 검증 세트(`X_val_fold` 및 `y_val_fold`)에서 검증됩니다. 클래스 가중치는 훈련 데이터의 클래스 분포의 균형을 맞추기 위해 scikit-learn의 `compute_class_weight` 함수를 사용하여 계산됩니다.훈련 과정의 진행 상황은 tqdm을 사용하여 표시되며, 테스트 세트에 대한 최종 예측은 현재 디렉터리에 `0317_test.csv`라는 이름의 CSV 파일에 `id` 및 `