Sure, here is a Python code that should accomplish the tasks you mentioned:
```python
import pandas as pd
import numpy as np
import re
import nltk
from nltk.corpus import stopwords
from nltk.tokenize import word_tokenize
from nltk.stem import WordNetLemmatizer
from sklearn.feature_extraction.text import TfidfVectorizer
from sklearn.model_selection import KFold
from sklearn.utils.class_weight import compute_class_weight
from sklearn.svm import SVC
from sklearn.metrics import f1_score
from tqdm import tqdm

# Set seed value
np.random.seed(42)

# Load data
train_df = pd.read_csv('train.csv')
test_df = pd.read_csv('test.csv')

# Compute class weights
class_weights = compute_class_weight(class_weight='balanced', classes=np.unique(train_df['label']), y=train_df['label'])

# Define text pre-processing functions
def preprocess_text(text):
    # Remove non-alphabetic characters
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    # Convert to lowercase
    text = text.lower()
    # Tokenize
    tokens = word_tokenize(text)
    # Remove stopwords
    tokens = [token for token in tokens if token not in stopwords.words('english')]
    # Lemmatize
    lemmatizer = WordNetLemmatizer()
    tokens = [lemmatizer.lemmatize(token) for token in tokens]
    # Join tokens back into a string
    text = ' '.join(tokens)
    return text

# Preprocess train and test text data
train_df['text'] = train_df['text'].apply(preprocess_text)
test_df['text'] = test_df['text'].apply(preprocess_text)

# Define KFold cross-validation
kf = KFold(n_splits=5, shuffle=True, random_state=42)

# Define TF-IDF vectorizer
tfidf = TfidfVectorizer()

# Initialize F1 scores
f1_scores = []

# Train and evaluate model for each fold
for fold, (train_index, val_index) in enumerate(kf.split(train_df)):
    # Get train and validation data
    X_train, y_train = train_df.iloc[train_index]['text'], train_df.iloc[train_index]['label']
    X_val, y_val = train_df.iloc[val_index]['text'], train_df.iloc[val_index]['label']

    # Compute TF-IDF features
    X_train_tfidf = tfidf.fit_transform(X_train)
    X_val_tfidf = tfidf.transform(X_val)

    # Train SVM model with class weights
    svm = SVC(class_weight={i: w for i, w in enumerate(class_weights)}, kernel='linear', random_state=42)
    svm.fit(X_train_tfidf, y_train)

    # Evaluate on validation set
    y_val_pred = svm.predict(X_val_tfidf)
    f1 = f1_score(y_val, y_val_pred, average='weighted')
    f1_scores.append(f1)
    print(f'Fold {fold+1} F1 score: {f1:.4f}')

    # Save predictions on test set for this fold
    X_test_tfidf = tfidf.transform(test_df['text'])
    y_test_pred = svm.predict(X_test_tfidf)
    test_df[f'fold{fold+1}'] = y_test_pred

# Compute average F1 score
print(f'Average F1 score: {np.mean(f1_scores):.4f}')

# Ensemble predictions from all folds
test_df['label'] = test_df[[f'fold{fold+1}' for fold in range(5)]].mode(axis=1)[0]

# Save predictions to file
test_df[['id', 'label']].to
```
말씀하신 작업을 수행할 수 있는 Python 코드는 다음과 같습니다:
'''python
임포트 팬더로 PD
import numpy as np
import re
import nltk
nltk.corpus에서 중지어 가져오기
nltk.tokenize에서 단어_토큰화 가져오기
nltk.stem에서 WordNetLemmatizer를 가져옵니다.
sklearn.feature_extraction.text에서 TfidfVectorizer를 가져옵니다.
sklearn.model_selection에서 KFold를 가져옵니다.
sklearn.utils.class_weight에서 compute_class_weight를 가져옵니다.
sklearn.svm에서 SVC를 가져옵니다.
sklearn.metrics에서 f1_score 임포트
tqdm에서 tqdm 가져오기

# 시드 값 설정
np.random.seed(42)

# 데이터 로드
train_df = pd.read_csv('train.csv')
test_df = pd.read_csv('test.csv')

# 클래스 가중치 계산
class_weights = compute_class_weight(class_weight='balanced', classes=np.unique(train_df['label']), y=train_df['label'])

# 텍스트 전처리 함수 정의
def preprocess_text(text):
    # 알파벳이 아닌 문자 제거
    text = re.sub(r'[^a-zA-Z\s]', '', text)
    # 소문자로 변환
    text = text.lower()
    # 토큰화
    tokens = word_tokenize(text)
    # 중지어 제거
    tokens = [token이 stopwords.words('english')에 없는 경우 토큰의 토큰에 대한 토큰]
    # 렘매타이저
    lemmatizer = WordNetLemmatizer()
    토큰 = [lemmatizer.lemmatize(token) for token in tokens] # 토큰을 다시 결합합니다.
    # 토큰을 다시 문자열로 조인
    text = ' '.join(tokens)
    텍스트 반환

# 텍스트 데이터 훈련 및 테스트 전처리
train_df['text'] = train_df['text'].apply(preprocess_text)
test_df['text'] = test_df['text'].apply(preprocess_text)

# KFold 교차 검증 정의하기
kf = KFold(n_splits=5, shuffle=True, random_state=42)

# TF-IDF 벡터라이저 정의
tfidf = TfidfVectorizer()

# F1 점수 초기화
F1_SCORES = []

# 각 폴드에 대한 모델 훈련 및 평가
for fold, (train_index, val_index) in enumerate(kf.split(train_df)):
    # 훈련 및 검증 데이터 가져오기
    X_train, y_train = train_df.iloc[train_index]['text'], train_df.iloc[train_index]['label']
    X_val, y_val = train_df.iloc[val_index]['text'], train_df.iloc[val_index]['label']

    # TF-IDF 기능 계산
    X_train_tfidf = tfidf.fit_transform(X_train)
    X_val_tfidf = tfidf.transform(X_val)

    # 클래스 가중치로 SVM 모델 훈련
    svm = SVC(class_weight={i: w for i, w in enumerate(class_weights)}, kernel='linear', random_state=42)
    svm.fit(X_train_tfidf, y_train)

    # 유효성 검사 집합에서 평가
    y_val_pred = svm.predict(X_val_tfidf)
    f1 = f1_score(y_val, y_val_pred, average='weighted')
    f1_scores.append(f1)
    print(f'Fold {fold+1} F1 점수: {f1:.4f}')

    # 이 폴드에 대한 테스트 세트에 예측 저장
    X_test_tfidf = tfidf.transform(test_df['text'])
    y_test_pred = svm.predict(X_test_tfidf)
    test_df[f'fold{fold+1}'] = y_test_pred

# 평균 F1 점수 계산
print(f'평균 F1 점수: {np.mean(f1_scores):.4f}')

# 모든 폴드에서 앙상블 예측
test_df['label'] = test_df[[f'fold{fold+1}' for fold in range(5)]].mode(axis=1)[0]

# 파일에 예측 저장
test_df[['id', 'label']].to
```