'
with open("QuestionAnswerTeaser.png", "rb") as f:
encoded = base64.b64encode(f.read()).decode()
QA_IMAGE_HTML = f''
with open("SummarisationTeaser.png", "rb") as f:
encoded = base64.b64encode(f.read()).decode()
SUMMARISATION_IMAGGE_HTML = f''
with open("Text2ImageTeaser.png", "rb") as f:
encoded = base64.b64encode(f.read()).decode()
TEXT2IMAGE_IMAGE_HTML = f''
with open("SyntheticImage.png", "rb") as f:
encoded = base64.b64encode(f.read()).decode()
SYNTHETIC_HTML = f''
with open("RealImage.jpeg", "rb") as f:
encoded = base64.b64encode(f.read()).decode()
REAL_HTML = f''
client = OpenAI(api_key=os.getenv("OPENAI_API_KEY"))
# ---- GPT explanation backend ----
def explain_text(selected_text):
if selected_text is None:
return ""
selected_text = selected_text.strip()
if not selected_text:
return "Please select or enter some text first."
try:
response = client.chat.completions.create(
model="gpt-4o",
messages=[
{"role": "system", "content": "You are an expert machine learning instructor. Explain concepts clearly and intuitively for learners with basic ML knowledge. Keep explanations concise and educational."},
{"role": "user", "content": f"Explain this text from a learning resource:\n\n\"\"\"\n{selected_text}\n\"\"\""}
],
temperature=0.7,
max_tokens=500
)
return response.choices[0].message.content
except Exception as e:
return f"Error: {str(e)}"
# ---- Your work content ----
YOUR_WORK_HTML = """
Text generation is the task of producing natural language text given an input prompt. It is commonly used for chatbots, creative writing, summarization, and code generation.
Most modern text generation models are based on the transformer architecture and are trained using next-token prediction.
During inference, the model repeatedly samples the most likely next token until a stopping condition is reached.
Imagine your phone's autocomplete feature, but much more advanced. That's what text generation is like. You start typing a few words, and the model, like a smart assistant, continues the text for you. It can finish your sentences, answer questions, rewrite text, or follow instructions.
{IMAGE_HTML}""" + """There are two main types of models for text generation: text generation (which continues the text you start) and text-to-text generation (which changes one text into another, like translating or summarizing). These models are also used for chatting and following instructions. You can find a list of popular models here.
Some models are designed to follow everyday instructions, like “Write a friendly email to my landlord.” You can try models like Mixtral 8x7B, Cohere Command R+, and Meta Llama 3 70B in Hugging Chat.
Models can also help with coding by writing code snippets from descriptions or continuing your code. StarCoder is a popular model for writing code in many languages. Try it here.
Start with a line like “Once upon a time,” and the model can continue with a story. Try a story-focused app by MosaicML here. If you have very specific needs, you can train a model from scratch. Learn how in the free Transformers course.
These models predict the next words, one after another, to build longer text. They can:
These models turn one piece of text into another. For example, they can summarize, translate, or answer questions in a fixed format. Well-known examples include FLAN-T5 and BART. You tell the model the task in the input (like “Summarize: …”), and it returns the result.
When you pick a model, you’ll often see three broad types:
Some models can look at images and text together, then write text as the answer. IDEFICS 2 and MiniCPM Llama 3 V are good examples. They work like other text models but also accept images. Use them with the image-to-text tools. You can learn more on the image-to-text task page.
You can use the 🤗 Transformers text-generation helper to run a model.
Give it a starting prompt, and it will continue from there.
from transformers import pipeline
generator = pipeline("text-generation", model="gpt2")
generator("Hello, I'm a language model,", max_length=30, num_return_sequences=3)
Text-to-text models use a separate text2text-generation helper.
You include the task in the input, and the model returns the result.
from transformers import pipeline
text2text_generator = pipeline("text2text-generation")
text2text_generator("question: What is 42? context: 42 is the answer to life, the universe and everything")
# [{'generated_text': 'the answer to life, the universe and everything'}]
text2text_generator("translate from English to French: I'm very happy")
# [{'generated_text': 'Je suis très heureux'}]
You can also use huggingface.js to run text generation models from the browser or Node.js.
import { InferenceClient } from "@huggingface/inference";
const inference = new InferenceClient(HF_TOKEN);
const result = await inference.textGeneration({
model: "gpt2",
inputs: "Write a cheerful greeting about summer:",
parameters: { max_new_tokens: 50 }
});
console.log(result.generated_text);
Think of these models as smart helpers that guess what should come next based on patterns they’ve seen. To get strong, useful answers:
Text Generation Inference (TGI) is an open toolkit for serving large models with fast responses. It powers services like Inference Endpoints and Hugging Chat, and many community projects. You can use it to deploy supported open models of your choice.
Hugging Face Spaces has templates to spin up your own chat app with just a few clicks. ChatUI is an open interface for building a conversational experience around a large language model. Under the hood, Spaces can use TGI for faster replies. Start from a template, customize it, and launch your own model-backed chat in minutes.
Imagine you have a big book and you want to find a specific piece of information. Instead of reading the whole book, you ask a question and a tool helps you find the answer quickly. This is what Question Answering (QA) does. It helps you get answers from a text you provide, like a digital assistant that reads for you.
QA can be used to automatically answer questions people often ask. For example, a customer service chatbot can use QA to find answers in product manuals or help articles. To make it faster, you can first find the most relevant part of the text and then use QA on that smaller section.
QA can work in a few different ways, depending on what you give it and what you want:
You can try QA using a tool called the 🤗 Transformers library. If you don’t pick a specific tool, it uses a small default one. You give it a question and a piece of text with the answer, and it will find the answer for you.
from transformers import pipeline
qa_model = pipeline("question-answering")
question = "Where do I live?"
context = "My name is Merve and I live in İstanbul."
result = qa_model(question=question, context=context)
print(result)
# Example: {'answer': 'İstanbul', 'start': 31, 'end': 39, 'score': 0.953}
Summarization is like creating a short version of a long story. Imagine you watched a movie and then told a friend just the main parts in a few sentences. That's what summarization does with text. Some tools pick out the most important sentences, while others rewrite the main ideas in their own words.
Summarizing research papers helps people quickly decide if they want to read the whole thing. Here are some simple ways to do it:
To get clear and reliable summaries:
It's important to know what summarization can and cannot do:
You can use the 🤗 Transformers summarization tool to run existing models. If you don’t provide a model name, it uses a default model called sshleifer/distilbart-cnn-12-6.
from transformers import pipeline
summarizer = pipeline("summarization")
result = summarizer(
"Paris is the capital and most populous city of France, with an estimated population of 2,175,601 residents as of 2018, "
"in an area of more than 105 square kilometres (41 square miles). The City of Paris is the centre and seat of government "
"of the region and province of Île-de-France, or Paris Region, which has an estimated population of 12,174,880, or about "
"18 percent of the population of France as of 2017."
)
print(result)
## [{{ "summary_text": "Paris is the capital and most populous city of France..." }}]
You can also use huggingface.js to run summarization models hosted on Hugging Face Hub.
import {{ InferenceClient }} from "@huggingface/inference";
const inference = new InferenceClient(HF_TOKEN);
const inputs =
"Paris is the capital and most populous city of France, with an estimated population of 2,175,601 residents as of 2018, "
+ "in an area of more than 105 square kilometres (41 square miles). The City of Paris is the centre and seat of government of "
+ "the region and province of Île-de-France, or Paris Region, which has an estimated population of 12,174,880, or about 18 percent "
+ "of the population of France as of 2017.";
await inference.summarization({{
model: "sshleifer/distilbart-cnn-12-6",
inputs,
}});
Imagine you could describe a scene to an artist, and they instantly paint it for you. That's what text-to-image tools do! You type out what you want to see, and the computer creates a picture based on your description. You can also use these tools to make changes to existing photos by giving simple instructions.
{TEXT2IMAGE_IMAGE_HTML}Think of these tools as a digital artist at your service. You can ask them to:
Businesses can quickly make example images from text to plan ideas, test layouts, or create prototypes without needing a photo shoot.
Chatbots can show helpful images during conversations, like illustrating a cozy reading corner or a recipe’s final dish, making interactions more engaging.
Fashion designers can explore different patterns, colors, and styles before making real samples. It's like sketching hundreds of options instantly to see what stands out.
Architects and interior designers can visualize rooms from rough descriptions, like floor plans or furniture styles, to quickly explore different looks and layouts.
You can change an image by writing simple instructions, like turning it into sunset lighting or adding a plant next to the sofa.
Personalization means teaching the tool about a new subject, like your pet or a product, using a few example photos. After that, you can ask for new images of that subject in different scenes, like your dog as an astronaut.
You can use text-to-image tools on your computer or through the internet. Start with a short, simple idea. If the result is close to what you want, add more details in small steps.
from diffusers import StableDiffusionPipeline, EulerDiscreteScheduler
import torch
model_id = "stabilityai/stable-diffusion-2"
scheduler = EulerDiscreteScheduler.from_pretrained(model_id, subfolder="scheduler")
pipe = StableDiffusionPipeline.from_pretrained(model_id, scheduler=scheduler, torch_dtype=torch.float16)
pipe = pipe.to("cuda") # Use GPU if available for faster, higher-quality results
prompt = "a photo of an astronaut riding a horse on mars"
image = pipe(prompt).images[0]
You can also use huggingface.js to run text-to-image models on Hugging Face Hub.
import {{ InferenceClient }} from "@huggingface/inference";
const inference = new InferenceClient(HF_TOKEN);
await inference.textToImage({{
model: "stabilityai/stable-diffusion-2",
inputs: "award winning high resolution photo of a giant tortoise/((ladybird)) hybrid, [trending on artstation]",
parameters: {{
negative_prompt: "blurry",
}},
}});