LLM

Large Language Models (LLMs)

LLMs are advanced neural network models trained on massive text data for various NLP tasks like generation, translation, summarization, and more.

1. GPT-3 / GPT-4 (OpenAI)

Generative Pre-trained Transformer models designed for text generation, chat, summarization, and more. GPT-4 offers greater accuracy and reasoning.

import openai

openai.api_key = "your-api-key"

response = openai.ChatCompletion.create(
    model="gpt-4",
    messages=[
        {"role": "user", "content": "Explain quantum computing in simple terms."}
    ]
)

print(response['choices'][0]['message']['content'])

Note: Replace your-api-key with your actual OpenAI API key.

2. BERT (Bidirectional Encoder Representations from Transformers)

BERT understands context from both directions (left and right). It’s great for sentence classification and question answering.

from transformers import BertTokenizer, BertForQuestionAnswering
import torch

tokenizer = BertTokenizer.from_pretrained('bert-base-uncased')
model = BertForQuestionAnswering.from_pretrained('bert-base-uncased')

question = "Where do pandas live?"
context = "Pandas live in bamboo forests in China."

inputs = tokenizer(question, context, return_tensors='pt')
outputs = model(**inputs)
answer_start = torch.argmax(outputs.start_logits)
answer_end = torch.argmax(outputs.end_logits) + 1

answer = tokenizer.convert_tokens_to_string(
    tokenizer.convert_ids_to_tokens(inputs['input_ids'][0][answer_start:answer_end])
)

print("Answer:", answer)

3. T5 (Text-to-Text Transfer Transformer)

T5 converts all NLP tasks into a text-to-text format (e.g., translation, summarization, classification).

from transformers import T5Tokenizer, T5ForConditionalGeneration

model = T5ForConditionalGeneration.from_pretrained("t5-small")
tokenizer = T5Tokenizer.from_pretrained("t5-small")

input_text = "summarize: The food was great but the service was slow and unresponsive."
input_ids = tokenizer(input_text, return_tensors="pt").input_ids

output_ids = model.generate(input_ids)
summary = tokenizer.decode(output_ids[0], skip_special_tokens=True)

print(summary)

4. XLNet

XLNet improves on BERT by using permutation-based training to better capture context. Good for classification and Q&A.

from transformers import XLNetTokenizer, XLNetForSequenceClassification
import torch

tokenizer = XLNetTokenizer.from_pretrained('xlnet-base-cased')
model = XLNetForSequenceClassification.from_pretrained('xlnet-base-cased')

inputs = tokenizer("I love AI and machine learning!", return_tensors="pt")
outputs = model(**inputs)
logits = outputs.logits

print("Predicted class:", torch.argmax(logits))

5. RoBERTa

RoBERTa is a robustly optimized BERT model, trained with more data and longer sequences for better performance.

from transformers import RobertaTokenizer, RobertaForSequenceClassification
import torch

tokenizer = RobertaTokenizer.from_pretrained("roberta-base")
model = RobertaForSequenceClassification.from_pretrained("roberta-base")

inputs = tokenizer("This product is amazing!", return_tensors="pt")
outputs = model(**inputs)

print("Logits:", outputs.logits)

6. GPT-Neo (EleutherAI)

GPT-Neo is an open-source alternative to GPT-3. It can be used for text generation and creative writing tasks.

from transformers import GPTNeoForCausalLM, GPT2Tokenizer

model = GPTNeoForCausalLM.from_pretrained("EleutherAI/gpt-neo-1.3B")
tokenizer = GPT2Tokenizer.from_pretrained("EleutherAI/gpt-neo-1.3B")

prompt = "Once upon a time in a world powered by AI,"
input_ids = tokenizer(prompt, return_tensors="pt").input_ids

output = model.generate(input_ids, max_length=50)
print(tokenizer.decode(output[0], skip_special_tokens=True))