Added Temperature, Top-p (Nucleus Sampling), Repetition Penalty with one click example and basic user guide

app.py

@@ -1,12 +1,14 @@
 # Hey its your saiyan Utkarsh Shukla. I gonna write my custom comments after each line of code. So even a beginner (previous me) can read and get whats going on.
 # Bear with me, I got your Back buddy
 
+
 import streamlit as st  
 # The saviour web app creator, easy peasy web app creation by few lines of codes. 
-# No HTML, CSS, or JS needed!"
+# No HTML, CSS, or JS needed!
+
 
 from transformers import AutoTokenizer, AutoModelForCausalLM
-# transformers here is just library which gives us access to Transformer architecture based pretrained models for natural language processing and other tasks. For now, Think of Tranformer Architecture, as mystery Architecture which makes models way cooler.
+# transformers here is just library which gives us access to Transformer architecture based pretrained models for natural language processing and other tasks. For now, Think of Transformer Architecture, as mystery Architecture which makes models way cooler.
 
 
 # AutoTokenizer helps in Text input -> Sentences -> Words -> Even subwords like ['un', 'break', 'able'] -> Integer IDs that model expects.
@@ -16,22 +18,27 @@ from transformers import AutoTokenizer, AutoModelForCausalLM
 # The cooler part of these Auto* classes are you don't need to know exact class name of model(like GPT2LMHeadModel, CTRLLMHeadModel, ReformerLMHeadModel, etc.).
 # Meaning The AutoModelForCausalLM automatically determine the correct model architecture based on the pretrained_model_name_or_path you provide. AutoModelForCausalLM infers this from the configuration files associated with the pre-trained model.
 
+
 from wordcloud import WordCloud
 # This will help us in knowing which words have large frequency. It creates a visual representation of words used, know as Word Cloud.
 # More the frequency + More the importance -> Word will appear larger in Word Cloud.
 # Mostly it avoids our stop words like it, is, are etc
-
+# More frequency = more importance → bigger word in the cloud.
 
 import matplotlib.pyplot as plt
 # This guy helps us to plot. So wait till you see it.
+# We’ll use it to show our Word Cloud in style.
+
 
 import torch
-# This import makes a library pyTorch available in our python code. 
+# This import makes a library pyTorch available in our python code.
+# This makes the PyTorch library available — a powerful math engine and deep learning framework our model runs on.
 # Think of it as a toolkit which can do maths very very efficiently is being available for our code now.
 
+
 @st.cache_resource
 # A decorator in python is a way to enhance a function or a class. As they are followed by @ symbol
-# The function above whome they are specified the decorator code is executed both before and after of function code on function call.
+# The function above whome they are specified, the decorator code is executed both before and after of function code, on function call.
 # Now here @st.cache_resource decorator is used before loading AutoTokenizer and AutoModelForCasualLM from gemm-2b.
 # Cache the model and tokenizer to avoid reloading on every run
 # So first run will load and save resources to global cache, and as user interact and causes rerun of load_model_and_tokenizer(), instead of loading again it will directly use cached resources from memory
@@ -39,12 +46,15 @@ def load_model_and_tokenizer():
     model_name = "google/gemma-2b"  # using gemma-2b for prototype for my GSOC Proposal. Wish me luck.
     tokenizer = AutoTokenizer.from_pretrained(model_name)
     # Responsible for automatically downloading and loading the tokenizer configuration and vocabulary associated with the specified pre-trained model.
+     # Downloads and loads the tokenizer config and vocab for the given model
     model = AutoModelForCausalLM.from_pretrained(model_name)
     # As we discussed, this class is designed for loading pre-trained language models for causal (next-token prediction) tasks.
+    # Loads the actual model used for causal (next-word) prediction tasks
     return tokenizer, model
 
+
 # Function to generate text with Gemma
-def generate_text(prompt, tone, max_length):
+def generate_text(prompt, tone, max_length, temperature=0.5, top_p=0.8, repetition_penalty=1.0):
     tokenizer, model = load_model_and_tokenizer()
     # Adjust prompt based on tone
     tone_prompts = {
@@ -57,9 +67,11 @@ def generate_text(prompt, tone, max_length):
     inputs = tokenizer(input_text, return_tensors="pt")
     outputs = model.generate(
         inputs["input_ids"],
-        max_length=max_length + len(input_text.split()),  # Account for prompt length
+        max_length=max_length + len(input_text.split()),
+        temperature=temperature,
+        top_p=top_p,
+        repetition_penalty=repetition_penalty,
         num_return_sequences=1,
-        temperature=0.7,  # Creativity level
         do_sample=True
     )
     return tokenizer.decode(outputs[0], skip_special_tokens=True)
@@ -86,6 +98,33 @@ st.markdown("""
     </p>
 """, unsafe_allow_html=True)
 
+
+# Beginner friendly explanation block
+with st.expander("\U0001F9E0 How does this work? Click to peek inside."):
+    st.markdown("""
+    - This app uses **Gemma-2B**, a language model from Google DeepMind.
+    - You give it a prompt, and it predicts the next words one-by-one (aka causal language modeling).
+    - The **tone** you choose adds flavor to the prompt before it hits the model.
+    - Parameters like **temperature** control how wild or safe the answers are.
+    - The output is visualized in a **Word Cloud** so you can see which words stand out!
+    """)
+
+# One-click examples
+example_clicked = None
+col1, col2 = st.columns(2)
+with col1:
+    if st.button("Try Funny Cat Story"):
+        prompt = "The cat hacked my WiFi"
+        tone = "Funny"
+        example_clicked = True
+with col2:
+    if st.button("Try Poetic Goodbye"):
+        prompt = "As the sun set on our final day"
+        tone = "Poetic"
+        example_clicked = True
+
+
+
 # User input section
 with st.form(key="input_form"):
     prompt = st.text_input("Enter a prompt", placeholder="e.g., 'The future of AI is'")