Sure, here is the code to train and infer a deep learning model based on LLM model that can take more than 4096 tokens, with proper hyper-parameters and callbacks to handle unevenly distributed label classes and use macro F1 score as the evaluation metric.
```python
import pandas as pd
import numpy as np
from sklearn.metrics import f1_score
from transformers import (
    AutoTokenizer,
    AutoModelForSequenceClassification,
    Trainer,
    TrainingArguments,
)

# Set up data
train_data = pd.read_csv('train.csv')
test_data = pd.read_csv('test.csv')

# Set up model and tokenizer
model_name = 'typeform/distilbert-base-uncased-mnli'
tokenizer = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=8)

# Tokenize inputs
train_encodings = tokenizer(list(train_data['text']), truncation=True, padding=True, max_length=4096)
test_encodings = tokenizer(list(test_data['text']), truncation=True, padding=True, max_length=4096)

# Set up training arguments and callbacks
training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=10,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    evaluation_strategy='epoch',
    load_best_model_at_end=True,
    metric_for_best_model='eval_macro_f1',
)

def compute_metrics(pred):
    labels = pred.label_ids
    preds = pred.predictions.argmax(-1)
    macro_f1 = f1_score(labels, preds, average='macro')
    return {'macro_f1': macro_f1}

trainer = Trainer(
    model=model,
    args=training_args,
    train_dataset=train_encodings,
    eval_dataset=train_encodings,
    compute_metrics=compute_metrics,
)

# Train the model
trainer.train()

# Evaluate the model on the test set
eval_results = trainer.evaluate(test_encodings)
print(eval_results)
```
Explanation:

1. The code starts by importing the required libraries, including pandas, numpy, sklearn.metrics, and transformers from Hugging Face.
2. The train.csv and test.csv files are read into pandas dataframes.
3. The LLM model and tokenizer are set up using the `AutoModelForSequenceClassification` and `AutoTokenizer` classes from Hugging Face.
4. The text data is tokenized using the tokenizer, and the resulting encodings are stored in variables.
5. The training arguments and callbacks are set up using the `TrainingArguments` class from Hugging Face. The callbacks include an evaluation strategy of 'epoch', which means the model will be evaluated on the validation set after every epoch.
6. A custom `compute_metrics` function is defined to compute the macro F1 score for validation.
7. The `Trainer` class from Hugging Face is used to train the model on the training data using the `train()` method.
8. After training, the `evaluate()` method of the trainer is called on the test set to compute the final evaluation metrics.

Note that the hyper-parameters used in this code are just examples and may not be optimal for the given task and dataset. The hyper-parameters should be tuned using a validation set to achieve the best performance. Also, the `load_best_model_at_end` and `metric_for_best_model` arguments in the `TrainingArguments` class ensure that the best model based on the validation metric is saved and loaded at the end of training. This ensures that the final evaluated model is the best model based on the validation metric.
물론, 다음은 고르지 않게 분포된 라벨 클래스를 처리하고 매크로 F1 점수를 평가 지표로 사용하기 위해 적절한 하이퍼 파라미터와 콜백을 사용하여 4096개 이상의 토큰을 사용할 수 있는 LLM 모델을 기반으로 딥러닝 모델을 훈련하고 추론하는 코드입니다.
```python
임포트 팬더로 pd
numpy를 np로 가져옵니다.
sklearn.metrics에서 f1_score를 가져옵니다.
에서 트랜스포머 임포트 (
    AutoTokenizer,
    AutoModelForSequenceClassification,
    Trainer,
    TrainingArguments,
)

# 데이터 설정
train_data = pd.read_csv('train.csv')
test_data = pd.read_csv('test.csv')

# 모델 및 토큰화 설정
model_name = 'typeform/distilbert-base-uncased-mnli'
토큰화기 = AutoTokenizer.from_pretrained(model_name)
model = AutoModelForSequenceClassification.from_pretrained(model_name, num_labels=8)

# 입력 토큰화
train_encodings = tokenizer(list(train_data['text']), truncation=True, padding=True, max_length=4096)
test_encodings = tokenizer(list(test_data['text']), truncation=True, padding=True, max_length=4096)

# 훈련 인수 및 콜백 설정
training_args = TrainingArguments(
    output_dir='./results',
    num_train_epochs=10,
    per_device_train_batch_size=16,
    per_device_eval_batch_size=64,
    warmup_steps=500,
    weight_decay=0.01,
    logging_dir='./logs',
    logging_steps=10,
    evaluation_strategy='epoch',
    load_best_model_at_end=True,
    metric_for_best_model='eval_macro_f1',
)

def compute_metrics(pred):
    labels = pred.label_ids
    pred = pred.predictions.argmax(-1)
    macro_f1 = f1_score(labels, preds, average='macro')
    반환 {'macro_f1': macro_f1}

트레이너 = 트레이너(
    모델=모델,
    args=training_args,
    train_dataset=train_encoding,
    eval_dataset=train_encoding,
    compute_metrics=compute_metrics,
)

# 모델 훈련
trainer.train()

# 테스트 세트에서 모델 평가
eval_results = trainer.evaluate(test_encoding)
print(eval_results)
```
설명:

1. 이 코드는 포옹하는 얼굴에서 pandas, numpy, sklearn.metrics 및 transformers를 포함한 필수 라이브러리를 가져오는 것으로 시작합니다.
2. train.csv 및 test.csv 파일을 판다 데이터 프레임으로 읽습니다.
3. Hugging Face의 `AutoModelForSequenceClassification` 및 `AutoTokenizer` 클래스를 사용하여 LLM 모델과 토큰화기를 설정합니다.
4. 토큰화기를 사용하여 텍스트 데이터를 토큰화하고 결과 인코딩을 변수에 저장합니다.
5. 훈련 인자와 콜백은 Hugging Face의 `TrainingArguments` 클래스를 사용하여 설정합니다. 콜백에는 'epoch'의 평가 전략이 포함되어 있으며, 이는 모델이 모든 에포크 후에 유효성 검사 세트에서 평가된다는 것을 의미합니다.
6. 검증을 위한 매크로 F1 점수를 계산하기 위해 사용자 정의 `compute_metrics` 함수가 정의됩니다.
7. Hugging Face의 `Trainer` 클래스는 `train()` 메서드를 사용하여 훈련 데이터에 대한 모델을 훈련하는 데 사용됩니다.
8. 훈련이 끝나면 테스트 세트에서 트레이너의 `evaluate()` 메서드를 호출하여 최종 평가 메트릭을 계산합니다.

이 코드에 사용된 하이퍼 파라미터는 예시일 뿐이며 주어진 작업과 데이터 세트에 최적화되지 않을 수 있습니다. 최상의 성능을 얻으려면 검증 세트를 사용하여 하이퍼파라미터를 조정해야 합니다. 또한, `TrainingArguments` 클래스의 `load_best_model_at_end` 및 `metric_for_best_model` 인수는 훈련이 끝날 때 검증 메트릭에 기반한 최적의 모델이 저장되고 로드되도록 합니다. 이렇게 하면 최종적으로 평가된 모델이 유효성 검사 메트릭에 기반한 최상의 모델이 됩니다.