!pip install datasets!pip install transformers!pip install evaluate!pip install torch!pip install peft
from datasets import load_dataset, DatasetDict, Dataset
from transformers import (    AutoTokenizer,    AutoConfig,     AutoModelForSequenceClassification,    DataCollatorWithPadding,    TrainingArguments,    Trainer)
from peft import PeftModel, PeftConfig, get_peft_model, LoraConfigimport evaluateimport torchimport numpy as np

# # load imdb dataimdb_dataset = load_dataset("stanfordnlp/imdb")
# # define subsample sizeN = 1000 # # generate indexes for random subsamplerand_idx = np.random.randint(24999, size=N) 
# # extract train and test datax_train = imdb_dataset['train'][rand_idx]['text']y_train = imdb_dataset['train'][rand_idx]['label']
x_test = imdb_dataset['test'][rand_idx]['text']y_test = imdb_dataset['test'][rand_idx]['label']
# # create new datasetdataset = DatasetDict({'train':Dataset.from_dict({'label':y_train,'text':x_train}),                       'validation':Dataset.from_dict({'label':y_test,'text':x_test})})
import numpy as np  # Import the NumPy librarynp.array(dataset['train']['label']).sum()/len(dataset['train']['label']) # 0.508

{  "label": 0,  "text": "Not a fan, don't recommed."}

from transformers import AutoModelForSequenceClassificationmodel_checkpoint = 'distilbert-base-uncased'# model_checkpoint = 'roberta-base' # you can alternatively use roberta-base but this model is bigger thus training will take longer
# define label mapsid2label = {0: "Negative", 1: "Positive"}label2id = {"Negative":0, "Positive":1}
# generate classification model from model_checkpointmodel = AutoModelForSequenceClassification.from_pretrained(    model_checkpoint, num_labels=2, id2label=id2label, label2id=label2id)# display architecturemodel

DistilBertForSequenceClassification(  (distilbert): DistilBertModel(    (embeddings): Embeddings(      (word_embeddings): Embedding(30522, 768, padding_idx=0)      (position_embeddings): Embedding(512, 768)      (LayerNorm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)      (dropout): Dropout(p=0.1, inplace=False)    )    (transformer): Transformer(      (layer): ModuleList(        (0-5): 6 x TransformerBlock(          (attention): MultiHeadSelfAttention(            (dropout): Dropout(p=0.1, inplace=False)            (q_lin): Linear(in_features=768, out_features=768, bias=True)            (k_lin): Linear(in_features=768, out_features=768, bias=True)            (v_lin): Linear(in_features=768, out_features=768, bias=True)            (out_lin): Linear(in_features=768, out_features=768, bias=True)          )          (sa_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)          (ffn): FFN(            (dropout): Dropout(p=0.1, inplace=False)            (lin1): Linear(in_features=768, out_features=3072, bias=True)            (lin2): Linear(in_features=3072, out_features=768, bias=True)            (activation): GELUActivation()          )          (output_layer_norm): LayerNorm((768,), eps=1e-12, elementwise_affine=True)        )      )    )  )  (pre_classifier): Linear(in_features=768, out_features=768, bias=True)  (classifier): Linear(in_features=768, out_features=2, bias=True)  (dropout): Dropout(p=0.2, inplace=False))

# create tokenizerfrom transformers import AutoTokenizer # Import AutoTokenizertokenizer = AutoTokenizer.from_pretrained(model_checkpoint, add_prefix_space=True)
# add pad token if none existsif tokenizer.pad_token is None:    tokenizer.add_special_tokens({'pad_token': '[PAD]'})    model.resize_token_embeddings(len(tokenizer))
# create tokenize functiondef tokenize_function(examples):    # extract text    text = examples["text"]
    #tokenize and truncate text    tokenizer.truncation_side = "left"    tokenized_inputs = tokenizer(        text,        return_tensors="np",        truncation=True,        max_length=512,  # Change max_length to 512 to match model's expected input length        padding='max_length' # Pad shorter sequences to the maximum length    )
    return tokenized_inputs    # tokenize training and validation datasetstokenized_dataset = dataset.map(tokenize_function, batched=True)
from transformers import DataCollatorWithPadding # Import DataCollatorWithPaddingdata_collator = DataCollatorWithPadding(tokenizer=tokenizer)
tokenized_dataset

import torch  # Import PyTorch
model_untrained = AutoModelForSequenceClassification.from_pretrained(    model_checkpoint, num_labels=2, id2label=id2label, label2id=label2id)
# define list of examplestext_list = ["It was good.", "Not a fan, don't recommed.", "Better than the first one.", "This is not worth watching even once.", "This one is a pass."]
print("Untrained model predictions:")print("----------------------------")for text in text_list:    # tokenize text    inputs = tokenizer.encode(text, return_tensors="pt")    # compute logits    logits = model_untrained(inputs).logits    # convert logits to label    predictions = torch.argmax(logits)
    print(text + " - " + id2label[predictions.tolist()])

import evaluate  # Import the evaluate module
# import accuracy evaluation metricaccuracy = evaluate.load("accuracy")# define an evaluation function to pass into trainer laterdef compute_metrics(p):    predictions, labels = p    predictions = np.argmax(predictions, axis=1)
    return {"accuracy": accuracy.compute(predictions=predictions, references=labels)}
from peft import LoraConfig, get_peft_model # Import the missing functionpeft_config = LoraConfig(task_type="SEQ_CLS",                        r=1,                        lora_alpha=32,                        lora_dropout=0.01,                        target_modules = ['q_lin'])

model = get_peft_model(model, peft_config)model.print_trainable_parameters()

# hyperparameterslr = 1e-3batch_size = 4num_epochs = 10
from transformers import TrainingArguments # Import Trainer
# define training argumentstraining_args = TrainingArguments(    output_dir= model_checkpoint + "-lora-text-classification",    learning_rate=lr,    per_device_train_batch_size=batch_size,    per_device_eval_batch_size=batch_size,    num_train_epochs=num_epochs,    weight_decay=0.01,    evaluation_strategy="epoch",    save_strategy="epoch",    load_best_model_at_end=True,)
from transformers import Trainer# creater trainer objecttrainer = Trainer(    model=model,    args=training_args,    train_dataset=tokenized_dataset["train"],    eval_dataset=tokenized_dataset["validation"],    tokenizer=tokenizer,    data_collator=data_collator, # this will dynamically pad examples in each batch to be equal length    compute_metrics=compute_metrics,)
# train modeltrainer.train()