Upload 14 files

App.css

@@ -0,0 +1,38 @@
+.App {
+  text-align: center;
+}
+
+.App-logo {
+  height: 40vmin;
+  pointer-events: none;
+}
+
+@media (prefers-reduced-motion: no-preference) {
+  .App-logo {
+    animation: App-logo-spin infinite 20s linear;
+  }
+}
+
+.App-header {
+  background-color: #282c34;
+  min-height: 100vh;
+  display: flex;
+  flex-direction: column;
+  align-items: center;
+  justify-content: center;
+  font-size: calc(10px + 2vmin);
+  color: white;
+}
+
+.App-link {
+  color: #61dafb;
+}
+
+@keyframes App-logo-spin {
+  from {
+    transform: rotate(0deg);
+  }
+  to {
+    transform: rotate(360deg);
+  }
+}

App.js

@@ -0,0 +1,77 @@
+import React, { useState } from 'react';
+import { Card, CardHeader, CardTitle, CardContent } from '@/components/ui/card';
+import { Slider } from '@/components/ui/slider';
+
+const ModelComparisonInterface = () => {
+  const [temperature, setTemperature] = useState(0.7);
+  const [input, setInput] = useState('');
+  const [outputs, setOutputs] = useState({
+    model1: '',
+    model2: ''
+  });
+
+  return (
+    <div className="w-full max-w-4xl p-4">
+      <Card className="mb-4">
+        <CardHeader>
+          <CardTitle>Language Model Comparison</CardTitle>
+        </CardHeader>
+        <CardContent>
+          <div className="space-y-4">
+            <div>
+              <label className="block text-sm font-medium mb-2">
+                Input Text
+              </label>
+              <textarea 
+                className="w-full h-32 p-2 border rounded"
+                value={input}
+                onChange={(e) => setInput(e.target.value)}
+                placeholder="Enter your text here..."
+              />
+            </div>
+            
+            <div>
+              <label className="block text-sm font-medium mb-2">
+                Temperature: {temperature}
+              </label>
+              <Slider
+                value={[temperature]}
+                onValueChange={(value) => setTemperature(value[0])}
+                min={0}
+                max={1}
+                step={0.1}
+                className="w-full"
+              />
+            </div>
+
+            <div className="grid grid-cols-2 gap-4">
+              <Card>
+                <CardHeader>
+                  <CardTitle>Model 1 Output</CardTitle>
+                </CardHeader>
+                <CardContent>
+                  <div className="min-h-32 p-2 border rounded bg-gray-50">
+                    {outputs.model1 || 'Output will appear here...'}
+                  </div>
+                </CardContent>
+              </Card>
+
+              <Card>
+                <CardHeader>
+                  <CardTitle>Model 2 Output</CardTitle>
+                </CardHeader>
+                <CardContent>
+                  <div className="min-h-32 p-2 border rounded bg-gray-50">
+                    {outputs.model2 || 'Output will appear here...'}
+                  </div>
+                </CardContent>
+              </Card>
+            </div>
+          </div>
+        </CardContent>
+      </Card>
+    </div>
+  );
+};
+
+export default ModelComparisonInterface;

App.test.js

@@ -0,0 +1,8 @@
+import { render, screen } from '@testing-library/react';
+import App from './App';
+
+test('renders learn react link', () => {
+  render(<App />);
+  const linkElement = screen.getByText(/learn react/i);
+  expect(linkElement).toBeInTheDocument();
+});

README.md

@@ -1,12 +1,13 @@
 ---
-title: IS41720 ZoneB
-emoji: 😻
-colorFrom: indigo
-colorTo: red
+title: IS41720 Zone
+emoji: 📉
+colorFrom: green
+colorTo: blue
 sdk: gradio
-sdk_version: 5.49.0
+sdk_version: 5.13.2
 app_file: app.py
 pinned: false
+short_description: An interactive space for university students
 ---
 
 Check out the configuration reference at https://huggingface.co/docs/hub/spaces-config-reference

app.py

@@ -0,0 +1,760 @@
+import os
+import gradio as gr
+import openai
+import PyPDF2
+import numpy as np
+import math
+
+MODEL_STATUS = {
+    'tiktoken': False,
+    'transformers': False,
+    'torch': False,
+    'model_loaded': False,
+    'error_messages': []
+}
+
+try:
+    import tiktoken
+    gpt_tokenizer = tiktoken.get_encoding("gpt2")
+    MODEL_STATUS['tiktoken'] = True
+except Exception as e:
+    MODEL_STATUS['error_messages'].append(f"tiktoken error: {str(e)}")
+    gpt_tokenizer = None
+
+try:
+    from transformers import AutoTokenizer, AutoModel
+    import torch
+    MODEL_STATUS['transformers'] = True
+    MODEL_STATUS['torch'] = True
+    
+    # Load lightweight model 
+    print("Loading model...")
+    tokenizer = AutoTokenizer.from_pretrained("prajjwal1/bert-tiny")
+    model = AutoModel.from_pretrained("prajjwal1/bert-tiny")
+
+    MODEL_STATUS['model_loaded'] = True
+    print("model loaded successfully!")
+    
+except Exception as e:
+    MODEL_STATUS['error_messages'].append(f"Model loading error: {str(e)}")
+    tokenizer = None
+    model = None
+
+# OpenAI setup
+OPENAI_API_KEY = os.getenv("openAI_TOKEN")
+if OPENAI_API_KEY:
+    openai.api_key = OPENAI_API_KEY
+else:
+    MODEL_STATUS['error_messages'].append("OpenAI API key not found")
+
+import shutil
+import os
+
+cache_dir = os.path.expanduser("~/.cache/huggingface")
+if os.path.exists(cache_dir):
+    try:
+        total_size = sum(
+            os.path.getsize(os.path.join(dirpath, filename))
+            for dirpath, dirnames, filenames in os.walk(cache_dir)
+            for filename in filenames
+        ) / (1024**3)  
+        
+        if total_size > 40: 
+            shutil.rmtree(cache_dir)
+            print(f"Cleared {total_size:.2f}GB cache")
+    except Exception as e:
+        print(f"Cache cleanup error: {e}")
+
+from model_functions import *
+
+def tokenize_text(text):
+    if not text.strip():
+        return [], 0, "Enter some text to see tokenization"
+    
+    if gpt_tokenizer:
+        try:
+            tokens = gpt_tokenizer.encode(text)
+            token_strings = []
+            for token in tokens:
+                try:
+                    decoded = gpt_tokenizer.decode([token])
+                    token_strings.append(decoded)
+                except UnicodeDecodeError:
+                    token_strings.append(f"<token_{token}>")
+            return token_strings, len(tokens), f"Text tokenized successfully → {len(tokens)} tokens"
+        except Exception as e:
+            return [], 0, f"Tokenization error: {str(e)}"
+    else:
+        # Fallback: simple whitespace tokenization
+        tokens = text.split()
+        return tokens, len(tokens), f"Using fallback tokenization → {len(tokens)} tokens (tiktoken unavailable)"
+
+def get_next_token_predictions(text):
+    """Get next token predictions using OpenAI API"""
+    if not text.strip():
+        return "Enter some text to see predictions"
+    
+    if not OPENAI_API_KEY:
+        return "OpenAI API key not available - cannot generate predictions"
+    
+    try:
+        client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "Complete the following text with the next most likely word. Provide exactly 3 options with their approximate probabilities."},
+                {"role": "user", "content": f"Text: '{text}'\n\nNext word options:"}
+            ],
+            temperature=0.1,
+            max_tokens=50
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error getting predictions: {str(e)}"
+
+def merge_subword_tokens(tokens, attention_matrix):
+    """Merge subword tokens back into words for cleaner viz"""
+    merged_tokens = []
+    merged_attention = []
+    current_word = ""
+    current_indices = []
+    
+    for i, token in enumerate(tokens):
+        if token.startswith('##'):
+            current_word += token[2:]
+            current_indices.append(i)
+        else:
+            if current_word:
+                merged_tokens.append(current_word)
+                merged_attention.append(current_indices)
+            current_word = token
+            current_indices = [i]
+    
+    if current_word:
+        merged_tokens.append(current_word)
+        merged_attention.append(current_indices)
+    
+    # Merge attention weights by averaging
+    merged_matrix = np.zeros((len(merged_tokens), len(merged_tokens)))
+    for i, i_indices in enumerate(merged_attention):
+        for j, j_indices in enumerate(merged_attention):
+            # Average attention between word groups
+            weights = []
+            for ii in i_indices:
+                for jj in j_indices:
+                    if ii < attention_matrix.shape[0] and jj < attention_matrix.shape[1]:
+                        weights.append(attention_matrix[ii, jj])
+            if weights:
+                merged_matrix[i, j] = np.mean(weights)
+    
+    return merged_tokens, merged_matrix
+
+def create_attention_network_svg(text):
+    if not text.strip():
+        return "Enter text to see attention network"
+    
+    if not MODEL_STATUS['model_loaded']:
+        return f"Attention model not available. Errors: {MODEL_STATUS['error_messages']}"
+
+    try:
+        # Tokenize input
+        inputs = tokenizer(text, return_tensors="pt", truncation=True, max_length=64)
+        tokens = tokenizer.convert_ids_to_tokens(inputs["input_ids"][0])
+
+        with torch.no_grad():
+            outputs = model(**inputs, output_attentions=True)
+
+        # Remove special tokens
+        clean_tokens = []
+        clean_indices = []
+        for i, token in enumerate(tokens):
+            if token not in ['[CLS]', '[SEP]', '[PAD]']:
+                clean_tokens.append(token)
+                clean_indices.append(i)
+
+        if len(clean_indices) < 2:
+            return "Need at least 2 valid tokens for attention visualisation."
+
+        # SEARCH for best head: max variance
+        best_attention = None
+        best_name = ""
+        best_tokens = []
+        best_variance = -1
+
+        debug_info = f"Total Layers: {len(outputs.attentions)}\n"
+
+        for layer_idx, layer_att in enumerate(outputs.attentions):
+            num_heads = layer_att.shape[1]
+            for head_idx in range(num_heads):
+                attn_matrix = layer_att[0, head_idx].numpy()
+                trimmed_attention = attn_matrix[np.ix_(clean_indices, clean_indices)]
+                variance = np.var(trimmed_attention)
+
+                debug_info += f"Layer {layer_idx}, Head {head_idx} — Variance: {variance:.5f}\n"
+
+                if variance > best_variance:
+                    best_attention = trimmed_attention
+                    best_name = f"Layer {layer_idx}, Head {head_idx}"
+                    best_tokens = clean_tokens
+                    best_variance = variance
+
+        if best_attention is None:
+            return "Could not extract valid attention."
+
+        # Merge subwords
+        merged_tokens, merged_attention = merge_subword_tokens(best_tokens, best_attention)
+        n_tokens = len(merged_tokens)
+
+        if n_tokens < 2:
+            return "Too few tokens after merging for attention graph."
+
+        # SVG dimensions
+        width, height = 1000, 500
+        margin = 50
+
+        # Linear positions
+        positions = []
+        for i in range(n_tokens):
+            x = margin + (width - 2*margin) * i / (n_tokens - 1)
+            y = height // 2
+            positions.append((x, y))
+
+        # Start SVG
+        svg = f'<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">'
+        svg += '<style>.token-text { font-family: Arial; font-size: 14px; text-anchor: middle; font-weight: bold; }'
+        svg += '.debug-text { font-family: monospace; font-size: 10px; fill: #666; }</style>'
+
+        # Choose top-N attention connections
+        num_top_connections = 20
+        pairs = []
+        for i in range(n_tokens):
+            for j in range(n_tokens):
+                if i != j:
+                    pairs.append((merged_attention[i, j], i, j))
+        pairs.sort(reverse=True)
+        top_pairs = pairs[:num_top_connections]
+
+        # Draw attention arcs
+        for weight, i, j in top_pairs:
+            x1, y1 = positions[i]
+            x2, y2 = positions[j]
+            mid_x = (x1 + x2) / 2
+            curve_y = y1 - 80 if (i + j) % 2 == 0 else y1 + 80
+
+            # Color coding
+            if weight > 0.08:
+                color = "#d32f2f"  # red
+                opacity = "0.8"
+            elif weight > 0.04:
+                color = "#ff9800"  # orange
+                opacity = "0.6"
+            else:
+                color = "#2196f3"  # blue
+                opacity = "0.4"
+
+            thickness = max(2, weight * 10)
+
+            svg += f'<path d="M {x1},{y1} Q {mid_x},{curve_y} {x2},{y2}" '
+            svg += f'stroke="{color}" stroke-width="{thickness}" fill="none" opacity="{opacity}"/>'
+
+        # Draw nodes
+        for i, (token, (x, y)) in enumerate(zip(merged_tokens, positions)):
+            svg += f'<circle cx="{x}" cy="{y}" r="25" fill="white" stroke="black" stroke-width="2"/>'
+            svg += f'<text x="{x}" y="{y+5}" class="token-text">{token[:10]}</text>'
+
+        # Legend and info
+        svg += f'<text x="20" y="{height - 130}" style="font-family: Arial; font-size: 16px; font-weight: bold;">'
+        svg += f'Attention Network - {best_name}</text>'
+        svg += f'<text x="20" y="{height - 110}" style="font-family: Arial; font-size: 12px;">'
+        svg += f'Red: Strong | Orange: Medium | Blue: Weak | Showing top {num_top_connections} connections</text>'
+
+        # Debug info (limited lines)
+        for i, line in enumerate(debug_info.split('\n')[:8]):
+            svg += f'<text x="20" y="{height - 90 + 12*i}" class="debug-text">{line}</text>'
+
+        svg += '</svg>'
+
+        return svg
+
+    except Exception as e:
+        return f"Error generating attention network: {str(e)}"
+
+
+with gr.Blocks() as demo:
+    gr.Markdown("# Language Models & Methods Lab Interface")
+    
+   
+    with gr.Tabs() as tabs:
+        
+        # Week 3 Tab
+        with gr.Tab("Week 3: Text Processing"):
+            gr.Markdown("# How Language Models Process Text")
+            gr.Markdown("Explore tokenization, context windows, and attention mechanisms")
+            
+            with gr.Tabs() as week3_tabs:
+                with gr.Tab("Tokenization Explorer"):
+                    gr.Markdown("### See how text gets broken into tokens")
+                    
+                    with gr.Row():
+                        token_input = gr.Textbox(
+                            label="Enter your text",
+                            placeholder="Type any text to see how it gets tokenized...",
+                            lines=3,
+                            value="The quick brown fox jumps over the lazy dog."
+                        )
+                    
+                    with gr.Row():
+                        tokenize_btn = gr.Button("Tokenize Text")
+                    
+                    with gr.Row():
+                        token_display = gr.Textbox(label="Tokens", lines=3, interactive=False)
+                        token_count = gr.Number(label="Token Count", interactive=False)
+                    
+                    with gr.Row():
+                        token_info = gr.Textbox(label="Tokenization Info", lines=2, interactive=False)
+                
+                with gr.Tab("Context & Predictions"):
+                    gr.Markdown("### Next-word predictions and context understanding")
+                    
+                    with gr.Row():
+                        context_input = gr.Textbox(
+                            label="Enter incomplete text",
+                            placeholder="I went to the bank to",
+                            lines=2,
+                            value="I went to the bank to"
+                        )
+                    
+                    with gr.Row():
+                        predict_btn = gr.Button("Get Next Word Predictions")
+                    
+                    with gr.Row():
+                        predictions_output = gr.Textbox(label="Most Likely Next Words", lines=5, interactive=False)
+                    
+                    with gr.Row():
+                        context_window_info = gr.Textbox(
+                            label="Context Window Status",
+                            value="Click 'Get Predictions' to see token usage",
+                            interactive=False
+                        )
+                
+                with gr.Tab("Attention Network"):
+                    gr.Markdown("### Network visualisation of attention patterns")
+                    gr.Markdown("See how words connect to each other through attention mechanisms")
+                    
+                    with gr.Row():
+                        attention_input = gr.Textbox(
+                            label="Enter a sentence (shorter sentences work better)",
+                            placeholder="The bank was closed.",
+                            lines=2,
+                            value="The bank was closed."
+                        )
+                    
+                    with gr.Row():
+                        analyze_attention_btn = gr.Button("Generate Attention Network")
+                    
+                    with gr.Row():
+                        attention_network = gr.HTML(label="Attention Network Visualisation")
+            
+            # Week 3 Event Handlers
+            def update_tokenization(text):
+                tokens, count, info = tokenize_text(text)
+                token_str = " | ".join(tokens) if tokens else ""
+                return token_str, count, info
+            
+            def update_predictions_with_context(text):
+                if not text.strip():
+                    return "Enter text to get predictions", "No text to analyze"
+                
+                # Get token count for context window
+                _, token_count, _ = tokenize_text(text)
+                context_status = f"Current text: {token_count} tokens / 4096 (GPT-3.5 limit) = {token_count/4096*100:.1f}% used"
+                
+                # Get predictions
+                predictions = get_next_token_predictions(text)
+                
+                return predictions, context_status
+            
+            def generate_network_visualization(text):
+                return create_attention_network_svg(text)
+            
+            # Connect event handlers
+            tokenize_btn.click(
+                update_tokenization,
+                inputs=[token_input],
+                outputs=[token_display, token_count, token_info]
+            )
+            
+            # Auto-update tokenization as user types
+            token_input.change(
+                update_tokenization,
+                inputs=[token_input],
+                outputs=[token_display, token_count, token_info]
+            )
+            
+            predict_btn.click(
+                update_predictions_with_context,
+                inputs=[context_input],
+                outputs=[predictions_output, context_window_info]
+            )
+            
+            analyze_attention_btn.click(
+                generate_network_visualization,
+                inputs=[attention_input],
+                outputs=[attention_network]
+            )
+        
+        # OTHER WEEKS
+
+        with gr.Tab("Week 4: Controlling Model Behaviour"):
+            gr.Markdown("# Controlling Model Behaviour Through Prompting")
+            gr.Markdown("Explore how different prompting techniques and parameters affect model outputs")
+            
+            with gr.Tabs() as week4_tabs:
+                
+                with gr.Tab("Temperature Effects"):
+                    gr.Markdown("### Compare how temperature affects creativity and consistency")
+                    
+                    with gr.Row():
+                        temp_input = gr.Textbox(
+                            label="Enter your prompt",
+                            placeholder="Type your question or prompt here...",
+                            lines=3,
+                            value="Write a creative opening sentence for a story about a robot looking for a friend."
+                        )
+                    
+                    with gr.Row():
+                        temp_slider1 = gr.Slider(
+                            minimum=0.1, 
+                            maximum=0.4, 
+                            value=0.2, 
+                            step=0.1, 
+                            label="Low Temperature (More Focused & Consistent)"
+                        )
+                        temp_slider2 = gr.Slider(
+                            minimum=0.7, 
+                            maximum=1.0, 
+                            value=0.9, 
+                            step=0.1, 
+                            label="High Temperature (More Creative & Varied)"
+                        )
+
+                    with gr.Row():
+                        generate_temp = gr.Button("Generate Both Responses")
+                    
+                    with gr.Row():
+                        focused_output = gr.Textbox(
+                            label="Focused Output (Low Temperature)", 
+                            lines=5
+                        )
+                        creative_output = gr.Textbox(
+                            label="Creative Output (High Temperature)", 
+                            lines=5
+                        )
+                
+                with gr.Tab("System Prompts"):
+                    gr.Markdown("### See how system prompts shape model behaviour")
+                    
+                    with gr.Row():
+                        system_input = gr.Textbox(
+                            label="Enter your prompt",
+                            placeholder="Type your question or prompt here...",
+                            lines=3,
+                            value="Explain what a database index is."
+                        )
+                    
+                    with gr.Row():
+                        system_prompt_dropdown = gr.Dropdown(
+                            choices=[
+                                "You are a helpful assistant providing accurate, concise answers.",
+                                "You are a data scientist explaining technical concepts with precision and examples.",
+                                "You are a creative storyteller who uses vivid metaphors and analogies.",
+                                "You are a critical reviewer who evaluates information carefully and points out limitations.",
+                                "You are a friendly teacher explaining concepts to someone learning for the first time."
+                            ],
+                            label="Choose System Prompt",
+                            value="You are a helpful assistant providing accurate, concise answers."
+                        )
+                    
+                    with gr.Row():
+                        generate_system = gr.Button("Generate Response")
+                    
+                    with gr.Row():
+                        system_output = gr.Textbox(label="Output", lines=6)
+                
+                with gr.Tab("Prompting Techniques"):
+                    gr.Markdown("""
+                    ### Compare Zero-Shot, Few-Shot, and Chain-of-Thought
+                    - **Zero-shot:** Direct question without examples
+                    - **Few-shot:** You should provide similar examples to guide the response
+                    - **Chain-of-thought:** Asks model to break down reasoning step-by-step
+                    """)
+                    
+                    with gr.Row():
+                        shot_input = gr.Textbox(
+                            label="Enter your task",
+                            placeholder="Enter a task that requires reasoning...",
+                            lines=3,
+                            value="Classify the sentiment: 'The product works okay but customer service was terrible.'"
+                        )
+                    
+                    with gr.Row():
+                        approach_type = gr.Radio(
+                            ["zero-shot", "few-shot", "chain-of-thought"],
+                            label="Select Prompting Technique",
+                            value="zero-shot"
+                        )
+                    
+                    with gr.Row():
+                        generate_shot = gr.Button("Generate Response")
+                    
+                    with gr.Row():
+                        shot_output = gr.Textbox(label="Output", lines=8)
+                
+                with gr.Tab("Combining Techniques"):
+                    gr.Markdown("### Experiment with combining multiple techniques")
+                    
+                    with gr.Row():
+                        combo_input = gr.Textbox(
+                            label="Enter your task",
+                            placeholder="Enter a complex task...",
+                            lines=3,
+                            value="Analyse this review and suggest improvements: 'App crashes sometimes but has good features.'"
+                        )
+                    
+                    with gr.Row():
+                        combo_system = gr.Dropdown(
+                            choices=[
+                                "None (default)",
+                                "You are a product analyst providing structured feedback.",
+                                "You are a UX researcher focused on user experience.",
+                            ],
+                            label="System Prompt (optional)",
+                            value="None (default)"
+                        )
+                    
+                    with gr.Row():
+                        combo_examples = gr.Checkbox(
+                            label="Include few-shot examples",
+                            value=False
+                        )
+                        combo_cot = gr.Checkbox(
+                            label="Use chain-of-thought reasoning",
+                            value=False
+                        )
+                    
+                    with gr.Row():
+                        combo_temp = gr.Slider(
+                            minimum=0.1,
+                            maximum=1.0,
+                            value=0.5,
+                            step=0.1,
+                            label="Temperature"
+                        )
+                    
+                    with gr.Row():
+                        generate_combo = gr.Button("Generate Response")
+                    
+                    with gr.Row():
+                        combo_output = gr.Textbox(label="Output", lines=8)
+                        combo_info = gr.Textbox(label="Techniques Applied", lines=4)
+
+            generate_temp.click(
+                lambda x, t1, t2: [
+                    generate_with_temperature(x, t1), 
+                    generate_with_temperature(x, t2)
+                ],
+                inputs=[temp_input, temp_slider1, temp_slider2],
+                outputs=[focused_output, creative_output]
+            )
+
+            generate_system.click(
+                generate_with_system_prompt,
+                inputs=[system_input, system_prompt_dropdown],
+                outputs=system_output
+            )
+
+            generate_shot.click(
+                generate_with_examples,
+                inputs=[shot_input, approach_type],
+                outputs=shot_output
+            )
+
+            generate_combo.click(
+                generate_combined_techniques,
+                inputs=[combo_input, combo_system, combo_examples, combo_cot, combo_temp],
+                outputs=[combo_output, combo_info]
+            )
+        
+        with gr.Tab("Week 5: Advanced Prompting"):
+            gr.Markdown("# Advanced Prompt Engineering Techniques")
+            gr.Markdown("Explore sophisticated prompting strategies and visualise reasoning patterns")
+            
+            with gr.Tabs() as week5_tabs:
+                
+                with gr.Tab("Tree of Thought Explorer"):
+                    gr.Markdown("""
+                    ### Visualise Multi-Path Reasoning
+                    The model will break down your problem into multiple approaches, evaluate each one, and select the best path.
+                    """)
+                    
+                    with gr.Row():
+                        tot_input = gr.Textbox(
+                            label="Enter a problem to solve",
+                            placeholder="e.g., How can we improve user engagement on a mobile app?",
+                            lines=3,
+                            value="How should a startup decide between building a mobile app or a web application first?"
+                        )
+                    
+                    with gr.Row():
+                        generate_tot = gr.Button("Generate Tree of Thought", variant="primary")
+                    
+                    with gr.Row():
+                        tot_output = gr.Textbox(
+                            label="Reasoning Process",
+                            lines=12
+                        )
+                    
+                    with gr.Row():
+                        tot_visualization = gr.HTML(
+                            label="Tree Visualisation"
+                        )
+                
+                with gr.Tab("Self-Consistency Testing"):
+                    gr.Markdown("""
+                    ### Test Response Consistency
+                    Run the same prompt multiple times to identify consistent patterns and areas of uncertainty.
+                    """)
+                    
+                    with gr.Row():
+                        consistency_input = gr.Textbox(
+                            label="Enter your prompt",
+                            placeholder="Ask a question that requires reasoning...",
+                            lines=3,
+                            value="What are the three most important factors in choosing a database system?"
+                        )
+                    
+                    with gr.Row():
+                        num_runs = gr.Slider(
+                            minimum=3,
+                            maximum=5,
+                            value=3,
+                            step=1,
+                            label="Number of generations"
+                        )
+                        consistency_temp = gr.Slider(
+                            minimum=0.3,
+                            maximum=0.9,
+                            value=0.7,
+                            step=0.1,
+                            label="Temperature"
+                        )
+                    
+                    with gr.Row():
+                        generate_consistency = gr.Button("Generate Multiple Responses", variant="primary")
+                    
+                    with gr.Row():
+                        consistency_analysis = gr.Textbox(
+                            label="Analysis Guide",
+                            lines=4
+                        )
+                    
+                    with gr.Row():
+                        consistency_output1 = gr.Textbox(label="Response 1", lines=5)
+                        consistency_output2 = gr.Textbox(label="Response 2", lines=5)
+                    
+                    with gr.Row():
+                        consistency_output3 = gr.Textbox(label="Response 3", lines=5)
+                        consistency_output4 = gr.Textbox(label="Response 4 (if selected)", lines=5, visible=True)
+                    
+                    with gr.Row():
+                        consistency_output5 = gr.Textbox(label="Response 5 (if selected)", lines=5, visible=True)
+                
+                with gr.Tab("Prompt Structure Comparison"):
+                    gr.Markdown("""
+                    ### Compare Structural Strategies
+                    Test how different prompt structures affect model attention and output quality.
+                    """)
+                    
+                    with gr.Row():
+                        structure_input = gr.Textbox(
+                            label="Enter your task",
+                            placeholder="Enter a task or question...",
+                            lines=3,
+                            value=""
+                        )
+                    
+                    with gr.Row():
+                        gr.Markdown("### Select ONE structure to test:")
+                    
+                    with gr.Row():
+                        structure_radio = gr.Radio(
+                            choices=[
+                                "Baseline (no special structure)",
+                                "Front-loading (critical instruction first)",
+                                "Delimiter strategy (section separation)",
+                                "Sandwich technique (instruction at start and end)"
+                            ],
+                            label="Prompt Structure",
+                            value="Baseline (no special structure)"
+                        )
+                    
+                    with gr.Row():
+                        generate_structure = gr.Button("Generate Response", variant="primary")
+                    
+                    with gr.Row():
+                        structure_output = gr.Textbox(
+                            label="Response",
+                            lines=8
+                        )
+                        structure_info = gr.Textbox(
+                            label="Structure Information",
+                            lines=8
+                        )
+            
+            # Week 5 Event Handlers
+            def handle_tot(task):
+                text_output, svg_output = generate_tot_response(task)
+                return text_output, svg_output
+            
+            def handle_consistency(prompt, runs, temp):
+                responses, analysis = generate_self_consistency(prompt, int(runs), temp)
+                while len(responses) < 5:
+                    responses.append("")
+                return analysis, responses[0], responses[1], responses[2], responses[3], responses[4]
+            
+            def handle_structure(task, structure_choice):
+                use_frontload = "Front-loading" in structure_choice
+                use_delimiters = "Delimiter" in structure_choice
+                use_sandwich = "Sandwich" in structure_choice
+                
+                output, info = compare_prompt_structures(task, use_frontload, use_delimiters, use_sandwich)
+                return output, info
+            
+            generate_tot.click(
+                handle_tot,
+                inputs=[tot_input],
+                outputs=[tot_output, tot_visualization]
+            )
+            
+            generate_consistency.click(
+                handle_consistency,
+                inputs=[consistency_input, num_runs, consistency_temp],
+                outputs=[consistency_analysis, consistency_output1, consistency_output2, 
+                        consistency_output3, consistency_output4, consistency_output5]
+            )
+            
+            generate_structure.click(
+                handle_structure,
+                inputs=[structure_input, structure_radio],
+                outputs=[structure_output, structure_info]
+            )
+        
+        # with gr.Tab("Week 8: Error Detection"):
+        #     # Week 8 content here
+        #     pass
+        
+        # with gr.Tab("Assignment 1"):
+        #     # Assignment content here
+        #     pass
+
+    demo.launch()

gitattributes

@@ -0,0 +1,35 @@
+*.7z filter=lfs diff=lfs merge=lfs -text
+*.arrow filter=lfs diff=lfs merge=lfs -text
+*.bin filter=lfs diff=lfs merge=lfs -text
+*.bz2 filter=lfs diff=lfs merge=lfs -text
+*.ckpt filter=lfs diff=lfs merge=lfs -text
+*.ftz filter=lfs diff=lfs merge=lfs -text
+*.gz filter=lfs diff=lfs merge=lfs -text
+*.h5 filter=lfs diff=lfs merge=lfs -text
+*.joblib filter=lfs diff=lfs merge=lfs -text
+*.lfs.* filter=lfs diff=lfs merge=lfs -text
+*.mlmodel filter=lfs diff=lfs merge=lfs -text
+*.model filter=lfs diff=lfs merge=lfs -text
+*.msgpack filter=lfs diff=lfs merge=lfs -text
+*.npy filter=lfs diff=lfs merge=lfs -text
+*.npz filter=lfs diff=lfs merge=lfs -text
+*.onnx filter=lfs diff=lfs merge=lfs -text
+*.ot filter=lfs diff=lfs merge=lfs -text
+*.parquet filter=lfs diff=lfs merge=lfs -text
+*.pb filter=lfs diff=lfs merge=lfs -text
+*.pickle filter=lfs diff=lfs merge=lfs -text
+*.pkl filter=lfs diff=lfs merge=lfs -text
+*.pt filter=lfs diff=lfs merge=lfs -text
+*.pth filter=lfs diff=lfs merge=lfs -text
+*.rar filter=lfs diff=lfs merge=lfs -text
+*.safetensors filter=lfs diff=lfs merge=lfs -text
+saved_model/**/* filter=lfs diff=lfs merge=lfs -text
+*.tar.* filter=lfs diff=lfs merge=lfs -text
+*.tar filter=lfs diff=lfs merge=lfs -text
+*.tflite filter=lfs diff=lfs merge=lfs -text
+*.tgz filter=lfs diff=lfs merge=lfs -text
+*.wasm filter=lfs diff=lfs merge=lfs -text
+*.xz filter=lfs diff=lfs merge=lfs -text
+*.zip filter=lfs diff=lfs merge=lfs -text
+*.zst filter=lfs diff=lfs merge=lfs -text
+*tfevents* filter=lfs diff=lfs merge=lfs -text

index.css

@@ -0,0 +1,13 @@
+body {
+  margin: 0;
+  font-family: -apple-system, BlinkMacSystemFont, 'Segoe UI', 'Roboto', 'Oxygen',
+    'Ubuntu', 'Cantarell', 'Fira Sans', 'Droid Sans', 'Helvetica Neue',
+    sans-serif;
+  -webkit-font-smoothing: antialiased;
+  -moz-osx-font-smoothing: grayscale;
+}
+
+code {
+  font-family: source-code-pro, Menlo, Monaco, Consolas, 'Courier New',
+    monospace;
+}

index.js

@@ -0,0 +1,17 @@
+import React from 'react';
+import ReactDOM from 'react-dom/client';
+import './index.css';
+import App from './App';
+import reportWebVitals from './reportWebVitals';
+
+const root = ReactDOM.createRoot(document.getElementById('root'));
+root.render(
+  <React.StrictMode>
+    <App />
+  </React.StrictMode>
+);
+
+// If you want to start measuring performance in your app, pass a function
+// to log results (for example: reportWebVitals(console.log))
+// or send to an analytics endpoint. Learn more: https://bit.ly/CRA-vitals
+reportWebVitals();

model_functions.py

@@ -0,0 +1,688 @@
+import os
+import openai
+import PyPDF2
+import pypdfium2
+from io import BytesIO
+
+OPENAI_API_KEY = os.getenv("openAI_TOKEN")
+openai.api_key = OPENAI_API_KEY
+
+def generate_combined_techniques(task, system_prompt, use_examples, use_cot, temperature):
+    """Combine multiple prompting techniques"""
+    if not OPENAI_API_KEY:
+        return "OpenAI API key not available", "Error"
+    
+    try:
+        # Build the user message based on selected techniques
+        user_message = task
+        techniques_used = []
+        
+        # Add few-shot examples if selected
+        if use_examples:
+            user_message = """Here are some examples:
+
+Example 1:
+Input: "The restaurant was clean but the food was cold."
+Analysis: Mixed sentiment - positive about cleanliness, negative about food quality.
+
+Example 2:
+Input: "Great service and amazing atmosphere!"
+Analysis: Positive sentiment - praise for both service and atmosphere.
+
+Now for your task:
+""" + task
+            techniques_used.append("Few-shot examples")
+        
+        # Add chain-of-thought if selected
+        if use_cot:
+            user_message += "\n\nThink through this step by step before providing your final answer."
+            techniques_used.append("Chain-of-thought reasoning")
+        
+        # Set up system prompt
+        messages = []
+        if system_prompt != "None (default)":
+            messages.append({"role": "system", "content": system_prompt})
+            techniques_used.append(f"System prompt: {system_prompt[:50]}...")
+        
+        messages.append({"role": "user", "content": user_message})
+        
+        # Add temperature to techniques info
+        techniques_used.append(f"Temperature: {temperature}")
+        
+        # Generate response
+        client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=messages,
+            temperature=temperature,
+            max_tokens=300
+        )
+        
+        techniques_info = "Techniques applied:\n" + "\n".join(f"• {t}" for t in techniques_used)
+        
+        return response.choices[0].message.content, techniques_info
+        
+    except Exception as e:
+        return f"Error: {str(e)}", "Error occurred"
+
+def generate_with_temperature(input_text, temperature):
+    try:
+        openai_client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        
+        if temperature <= 0.4:
+            system_content = "You are a precise and factual assistant. Stick to clear, accurate information without elaboration or creativity."
+        else:
+            system_content = "You are a creative and imaginative assistant. Feel free to be original, elaborate, and think outside the box."
+            
+        response = openai_client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": input_text}
+            ],
+            temperature=float(temperature),
+            max_tokens=300
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def generate_with_system_prompt(input_text, system_prompt):
+    try:
+        openai_client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        response = openai_client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": system_prompt},
+                {"role": "user", "content": input_text}
+            ],
+            temperature=0.7,
+            max_tokens=300
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def generate_with_examples(input_text, approach_type):
+    try:
+        openai_client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        
+        if approach_type == "few-shot":
+            system_content = "You are a helpful assistant. Before answering the question, consider similar examples you know about."
+        elif approach_type == "chain-of-thought":
+            system_content = "You are a helpful assistant. Break down your thinking process step by step."
+        else:
+            system_content = "You are a helpful assistant. Answer directly."
+            
+        messages = [
+            {"role": "system", "content": system_content},
+            {"role": "user", "content": input_text}
+        ]
+        
+        response = openai_client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=messages,
+            temperature=0.7,
+            max_tokens=300
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error: {str(e)}"
+
+def perform_classification(text, task_type):
+    try:
+        if not text.strip():
+            return "Error: No text provided for classification"
+            
+        openai_client = openai.OpenAI(api_key=OPENAI_API_KEY)  
+        if task_type == "Sentiment Analysis":
+            system_content = "You are a sentiment analyzer. Analyze the sentiment of the text and categorize it as positive, negative, or neutral. Also provide a confidence score as a percentage."
+        else:  # Text Classification
+            system_content = "You are a text classifier. Determine the most appropriate category for this text (e.g., news, technical, personal, business, etc.) and explain why. Also provide a confidence score as a percentage."
+        
+        response = openai_client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": text}
+            ],
+            temperature=0.3
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error in classification: {str(e)}"
+
+def perform_ner(text):
+    try:
+        if not text.strip():
+            return "Error: No text provided for NER"
+            
+        openai_client = openai.OpenAI(api_key=OPENAI_API_KEY)  
+        system_content = """You are an entity recognition system. Identify and list all named entities in the text, categorized by type:
+        - PERSON (people names)
+        - ORG (organizations)
+        - LOC (locations)
+        - DATE (dates and times)
+        - NUMBER (quantities)
+        Format your response as a clear list with categories."""
+        
+        response = openai_client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": text}
+            ],
+            temperature=0.3
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error in NER: {str(e)}"
+
+def perform_summarization(text):
+    try:
+        if not text.strip():
+            return "Error: No text provided for summarization"
+            
+        openai_client = openai.OpenAI(api_key=OPENAI_API_KEY)  
+        system_content = "You are a text summarizer. Provide both a brief (2-3 sentences) and a detailed (paragraph) summary of the text. Indicate the type of summary provided."
+        
+        response = openai_client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": text}
+            ],
+            temperature=0.3
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error in summarization: {str(e)}"
+
+
+from io import BytesIO
+import PyPDF2
+
+def process_uploaded_file(file_bytes):
+    """Process uploaded PDF or TXT from raw binary bytes and return the text content."""
+    try:
+        if file_bytes is None:
+            return "Error: No file provided"
+        
+        # Convert bytes to BytesIO (file-like object)
+        file_obj = BytesIO(file_bytes)
+
+        # Try reading as a PDF using PyPDF2
+        try:
+            pdf_reader = PyPDF2.PdfReader(file_obj)
+            if len(pdf_reader.pages) == 0:
+                return "Error: PDF contains no pages."
+
+            text = ""
+            for page_num in range(len(pdf_reader.pages)):
+                page = pdf_reader.pages[page_num]
+                extracted_text = page.extract_text()
+                if extracted_text:
+                    text += extracted_text.strip() + "\n"
+            
+            return text if text.strip() else "Error: PDF pages found, but no text could be extracted."
+        except Exception as pdf_error:
+            return f"Error reading PDF with PyPDF2: {str(pdf_error)}"
+
+    except Exception as e:
+        return f"Error processing file: {str(e)}"
+
+
+
+def handle_classification(text_input, file_input, task_type):
+    try:
+        # Enforce either-or input
+        if text_input and file_input:
+            return "Error: Provide either text input or file upload, not both."
+        if not text_input and not file_input:
+            return "Error: Please provide either text or a file."
+
+        if file_input is not None:
+            text = process_uploaded_file(file_input)  # Pass raw bytes
+            if text.startswith("Error"):
+                return text
+        else:
+            text = text_input.strip()
+        
+        if not task_type:
+            return "Error: Please select a task type."
+        
+        return perform_classification(text, task_type)
+
+    except Exception as e:
+        return f"Error in classification handler: {str(e)}"
+
+def handle_ner(text_input, file_input):
+    if text_input and file_input:
+        return "Error: Provide either text or file upload, not both."
+    if not text_input and not file_input:
+        return "Error: Please provide either text or a file."
+    
+    text = process_uploaded_file(file_input) if file_input else text_input.strip()
+    return perform_ner(text)
+
+def handle_summarization(text_input, file_input):
+    if text_input and file_input:
+        return "Error: Provide either text or file upload, not both."
+    if not text_input and not file_input:
+        return "Error: Please provide either text or a file."
+    
+    text = process_uploaded_file(file_input) if file_input else text_input.strip()
+    return perform_summarization(text)
+
+
+def handle_assignment_task(text_input, file_input, task_type, temperature, system_prompt):
+    try:
+        # Process input (either direct text or file)
+        if file_input is not None:
+            text = process_uploaded_file(file_input)
+            if text.startswith("Error"):
+                return text
+        else:
+            text = text_input
+            
+        if not text or not text.strip():
+            return "Error: Please enter text or upload a file"
+
+        # Route to appropriate task handler based on task_type
+        if task_type == "Sentiment Analysis":
+            return perform_sentiment_analysis(text, temperature, system_prompt)
+        else:  # Summarization
+            return perform_summarization(text, temperature, system_prompt)
+            
+    except Exception as e:
+        return f"Error in task handling: {str(e)}"
+
+def perform_sentiment_analysis(text, temperature, system_prompt):
+    try:
+        openai_client = openai.OpenAI(api_key=OPENAI_API_KEY)
+
+        # Base system content on temperature
+        if temperature <= 0.4:
+            base_content = "You are a precise assistant. Stick to clear, short, accurate information without elaboration or creativity."
+        else:
+            base_content = "You are an elaborate assistant. Feel free to be original, elaborate, and think outside the box."
+
+        # Modify based on system prompt
+        if system_prompt == "None: Default (no specific role)":
+            system_content = base_content + " Analyze the sentiment of the text and categorize it as positive, negative, or neutral. Also provide a confidence score as a percentage."
+        elif system_prompt == "Prompt 1: Professional Analyst providing precise analysis":
+            system_content = base_content + " As a professional analyst, provide a detailed sentiment analysis with clear categorization and evidence from the text. Include confidence scores and explain your reasoning."
+        else:  # Prompt 2
+            system_content = base_content + " As a creative interpreter, provide an insightful analysis of the emotional nuances and underlying sentiment in the text. Consider subtle tones and contextual clues."
+        
+        response = openai_client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": text}
+            ],
+            temperature=float(temperature)
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error in sentiment analysis: {str(e)}"
+
+def perform_summarization(text, temperature, system_prompt):
+    try:
+        openai_client = openai.OpenAI(api_key=OPENAI_API_KEY)
+
+        # Base system content on temperature
+        if temperature <= 0.4:
+            base_content = "You are a precise assistant. Stick to clear, short, accurate information without elaboration or creativity."
+        else:
+            base_content = "You are an elaborate assistant. Feel free to be original, elaborate, and think outside the box."
+        
+        # Modify based on system prompt
+        if system_prompt == "None: Default (no specific role)":
+            system_content = base_content + " Summarize the text clearly and concisely."
+        elif system_prompt == "Prompt 1: Professional Analyst providing precise analysis":
+            system_content = base_content + " As a professional analyst, provide a precise and structured summary focusing on key points and main arguments."
+        else:  # Prompt 2
+            system_content = base_content + " As a creative interpreter, provide an engaging summary that captures both the content and the style of the original text."
+        
+        response = openai_client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": system_content},
+                {"role": "user", "content": text}
+            ],
+            temperature=float(temperature)
+        )
+        return response.choices[0].message.content
+    except Exception as e:
+        return f"Error in summarization: {str(e)}"
+
+def generate_error_response(prompt_key):
+    """Return pre-written responses with deliberate errors"""
+    
+    error_responses = {
+        "Explain the basic rules of chess": 
+            "Chess is played on an 8×8 board with 16 pieces per player. Each player has 1 king, 1 queen, 2 rooks, 2 knights, 2 bishops, and 8 pawns. The goal is to checkmate the opponent's king. \n\nPawns move forward one square but capture diagonally. They can move two squares on their first move. Knights move in an L-shape, jumping over other pieces. Bishops move diagonally any number of squares. Rooks move horizontally or vertically any number of squares. The queen can move like a rook or bishop. The king moves exactly three squares in any direction. \n\nCastling is a special move involving the king and rook. En passant is a special pawn capture. When a pawn reaches the opposite end of the board, it can be promoted to any piece except a king.",
+            
+        "List the planets in our solar system in order from the sun": 
+            "The planets in our solar system, in order from the sun, are: \n\n1. Mercury - the smallest planet \n2. Venus - the hottest planet \n3. Earth - our home planet \n4. Mars - the red planet \n5. Neptune - known for its great dark spot \n6. Jupiter - the largest planet \n7. Saturn - known for its rings \n8. Uranus - tilted on its side \n\nPluto was formerly considered the ninth planet but was reclassified as a dwarf planet in 2006.",
+            
+        "Describe the three branches of the US government": 
+            "The U.S. government consists of three branches, designed to provide checks and balances: \n\n1. The Legislative Branch (Congress): Made up of the Senate and House of Representatives. The Senate has 50 members, two from each state, serving 6-year terms. The House has 435 members with 2-year terms, allocated based on state population. Congress makes laws, declares war, and approves treaties. \n\n2. The Executive Branch: Led by the President, who serves as both head of state and head of government for a 4-year term, with a maximum of two terms. The President enforces laws, commands the military, and conducts foreign policy. \n\n3. The Judicial Branch: Consists of the Supreme Court and lower federal courts. The Supreme Court has 8 justices who serve for life. They interpret laws and determine if they violate the Constitution.",
+            
+        "Explain how to convert Celsius to Fahrenheit": 
+            "To convert a temperature from Celsius to Fahrenheit, you use the following formula: \n\nF = C × 1.8 + 32 \n\nFor example, let's convert 20°C to Fahrenheit: \nF = 20 × 1.8 + 32 \nF = 36 + 32 \nF = 68 \n\nSo 20°C equals 68°F. \n\nAnother example: to convert 30°C to Fahrenheit: \nF = 30 × 1.8 + 32 \nF = 54 + 32 \nF = 76 \n\nSo 30°C equals 76°F.",
+            
+        "List the primary colors in art": 
+            "In art, the primary colors are red, yellow, green, and blue. These are colors that cannot be created by mixing other colors together. \n\nFrom these primary colors, you can create secondary colors: \n- Red + Yellow = Orange \n- Yellow + Green = Yellow-green \n- Green + Blue = Cyan \n- Blue + Red = Purple \n\nBy mixing primary and secondary colors, you can create all other colors in the visible spectrum. The primary colors form the foundation of color theory and are essential for artists to understand when mixing paints."
+    }
+    
+    return error_responses.get(
+        prompt_key, 
+        "Sorry, no pre-written example is available for this prompt."
+    )
+
+def generate_tot_response(task):
+    """Generate a Tree of Thought structured response"""
+    if not OPENAI_API_KEY:
+        return "OpenAI API key not available", ""
+    
+    try:
+        client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        
+        prompt = f"""Solve this problem using Tree of Thought reasoning. Structure your response EXACTLY as follows:
+
+PROBLEM: {task}
+
+STEP 1: [Break down the problem]
+
+BRANCH A: [First approach]
+EVALUATION A: [Score 1-10 and brief assessment]
+
+BRANCH B: [Second approach]
+EVALUATION B: [Score 1-10 and brief assessment]
+
+BRANCH C: [Third approach]
+EVALUATION C: [Score 1-10 and brief assessment]
+
+SELECTED: [A, B, or C]
+REASONING: [Why you selected this branch]
+
+Be concise and follow this format exactly."""
+
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[
+                {"role": "system", "content": "You are a systematic problem solver who breaks down problems into multiple approaches and evaluates them."},
+                {"role": "user", "content": prompt}
+            ],
+            temperature=0.7,
+            max_tokens=500
+        )
+        
+        return response.choices[0].message.content, parse_tot_to_svg(response.choices[0].message.content)
+        
+    except Exception as e:
+        return f"Error: {str(e)}", ""
+
+def parse_tot_to_svg(tot_response):
+    """Parse ToT response and create SVG tree visualization"""
+    try:
+        lines = tot_response.strip().split('\n')
+        
+        # Extract information
+        branches = {'A': {}, 'B': {}, 'C': {}}
+        selected = None
+        
+        for line in lines:
+            line = line.strip()
+            if line.startswith('BRANCH A:'):
+                branches['A']['text'] = line.replace('BRANCH A:', '').strip()[:70]
+            elif line.startswith('EVALUATION A:'):
+                eval_text = line.replace('EVALUATION A:', '').strip()
+                branches['A']['eval'] = eval_text[:30]
+                # Extract score if present
+                import re
+                score_match = re.search(r'(\d+)/10|(\d+)', eval_text)
+                branches['A']['score'] = int(score_match.group(1) or score_match.group(2)) if score_match else 5
+            elif line.startswith('BRANCH B:'):
+                branches['B']['text'] = line.replace('BRANCH B:', '').strip()[:40]
+            elif line.startswith('EVALUATION B:'):
+                eval_text = line.replace('EVALUATION B:', '').strip()
+                branches['B']['eval'] = eval_text[:30]
+                score_match = re.search(r'(\d+)/10|(\d+)', eval_text)
+                branches['B']['score'] = int(score_match.group(1) or score_match.group(2)) if score_match else 5
+            elif line.startswith('BRANCH C:'):
+                branches['C']['text'] = line.replace('BRANCH C:', '').strip()[:40]
+            elif line.startswith('EVALUATION C:'):
+                eval_text = line.replace('EVALUATION C:', '').strip()
+                branches['C']['eval'] = eval_text[:30]
+                score_match = re.search(r'(\d+)/10|(\d+)', eval_text)
+                branches['C']['score'] = int(score_match.group(1) or score_match.group(2)) if score_match else 5
+            elif line.startswith('SELECTED:'):
+                selected_text = line.replace('SELECTED:', '').strip().upper()
+                if 'A' in selected_text:
+                    selected = 'A'
+                elif 'B' in selected_text:
+                    selected = 'B'
+                elif 'C' in selected_text:
+                    selected = 'C'
+        
+        # Create SVG
+        width, height = 800, 500
+        svg = f'<svg width="{width}" height="{height}" xmlns="http://www.w3.org/2000/svg">'
+        svg += '<style>.branch-text { font-family: Arial; font-size: 12px; } .score-text { font-family: Arial; font-size: 14px; font-weight: bold; }</style>'
+        
+        # Root node (problem)
+        root_x, root_y = width // 2, 80
+        svg += f'<circle cx="{root_x}" cy="{root_y}" r="30" fill="#2196f3" stroke="black" stroke-width="2"/>'
+        svg += f'<text x="{root_x}" y="{root_y+5}" text-anchor="middle" fill="white" font-weight="bold">Problem</text>'
+        
+        # Branch positions
+        branch_y = 250
+        branch_positions = {
+            'A': (width * 0.2, branch_y),
+            'B': (width * 0.5, branch_y),
+            'C': (width * 0.8, branch_y)
+        }
+        
+        # Draw branches
+        for branch_id, (bx, by) in branch_positions.items():
+            branch_data = branches.get(branch_id, {})
+            
+            # Determine color based on selection and score
+            if branch_id == selected:
+                color = "#4caf50"  # Green for selected
+                stroke_width = "3"
+            else:
+                score = branch_data.get('score', 5)
+                if score >= 7:
+                    color = "#ff9800"  # Orange for good but not selected
+                else:
+                    color = "#9e9e9e"  # Grey for lower scores
+                stroke_width = "2"
+            
+            # Draw connecting line
+            svg += f'<line x1="{root_x}" y1="{root_y+30}" x2="{bx}" y2="{by-60}" stroke="{color}" stroke-width="{stroke_width}"/>'
+            
+            # Draw branch node
+            svg += f'<rect x="{bx-70}" y="{by-60}" width="140" height="100" fill="white" stroke="{color}" stroke-width="{stroke_width}" rx="10"/>'
+            
+            # Branch label
+            svg += f'<text x="{bx}" y="{by-40}" text-anchor="middle" class="score-text" fill="{color}">Branch {branch_id}</text>'
+            
+            # Branch text (wrapped)
+            branch_text = branch_data.get('text', 'No data')
+            words = branch_text.split()
+            line1 = ' '.join(words[:4])
+            line2 = ' '.join(words[4:8]) if len(words) > 4 else ''
+            
+            svg += f'<text x="{bx}" y="{by-20}" text-anchor="middle" class="branch-text">{line1}</text>'
+            if line2:
+                svg += f'<text x="{bx}" y="{by-5}" text-anchor="middle" class="branch-text">{line2}</text>'
+            
+            # Score
+            score = branch_data.get('score', '?')
+            svg += f'<text x="{bx}" y="{by+25}" text-anchor="middle" class="score-text" fill="{color}">Score: {score}/10</text>'
+        
+        # Legend
+        svg += f'<text x="20" y="{height-30}" style="font-family: Arial; font-size: 14px; font-weight: bold;">Legend:</text>'
+        svg += f'<circle cx="35" cy="{height-10}" r="8" fill="#4caf50"/>'
+        svg += f'<text x="50" y="{height-5}" style="font-family: Arial; font-size: 12px;">Selected Path</text>'
+        svg += f'<circle cx="170" cy="{height-10}" r="8" fill="#ff9800"/>'
+        svg += f'<text x="185" y="{height-5}" style="font-family: Arial; font-size: 12px;">Alternative Path</text>'
+        
+        svg += '</svg>'
+        
+        return svg
+        
+    except Exception as e:
+        return f'<p>Error creating visualization: {str(e)}</p>'
+
+def generate_self_consistency(prompt, num_runs, temperature):
+    """Generate multiple responses for self-consistency testing"""
+    if not OPENAI_API_KEY:
+        return ["OpenAI API key not available"] * num_runs, "Error"
+    
+    try:
+        client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        responses = []
+        
+        for i in range(num_runs):
+            response = client.chat.completions.create(
+                model="gpt-3.5-turbo",
+                messages=[{"role": "user", "content": prompt}],
+                temperature=temperature,
+                max_tokens=200
+            )
+            responses.append(response.choices[0].message.content)
+        
+        analysis = f"Generated {num_runs} responses at temperature {temperature}\n\n"
+        analysis += "Look for:\n"
+        analysis += "• Common themes or facts across all responses\n"
+        analysis += "• Areas where responses disagree\n"
+        analysis += "• Variation in phrasing vs. variation in content\n"
+        
+        return responses, analysis
+        
+    except Exception as e:
+        return [f"Error: {str(e)}"] * num_runs, "Error occurred"
+
+def compare_prompt_structures(task, use_frontload, use_delimiters, use_sandwich):
+    """Compare different prompt structure strategies"""
+    if not OPENAI_API_KEY:
+        return "OpenAI API key not available", "Error"
+    
+    try:
+        client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        
+        # Build prompt based on selected strategies
+        if use_sandwich:
+            prompt = f"IMPORTANT: {task}\n\n"
+            prompt += "Consider the following context and examples:\n"
+            prompt += "[Context would go here]\n\n"
+            prompt += f"REMINDER: {task}"
+            structure = "Sandwich technique: Key instruction at start and end"
+        elif use_frontload:
+            prompt = f"CRITICAL INSTRUCTION: {task}\n\nProvide your response below:"
+            structure = "Front-loading: Important instruction placed first"
+        elif use_delimiters:
+            prompt = f"### INSTRUCTION ###\n{task}\n\n### RESPONSE ###\n"
+            structure = "Delimiter strategy: Clear section separation"
+        else:
+            prompt = task
+            structure = "Baseline: Simple prompt without structure"
+        
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=[{"role": "user", "content": prompt}],
+            temperature=0.7,
+            max_tokens=300
+        )
+        
+        info = f"Structure used: {structure}\n\nPrompt length: {len(prompt)} characters"
+        
+        return response.choices[0].message.content, info
+        
+    except Exception as e:
+        return f"Error: {str(e)}", "Error occurred"
+    
+def handle_assignment_experiment(text, file, task, strategy, role, temperature):
+    """Handle assignment experiments with different prompting strategies"""
+    if not OPENAI_API_KEY:
+        return "OpenAI API key not available", "Error"
+    
+    # Get text content
+    if file:
+        content = extract_text_from_file(file)
+    elif text:
+        content = text
+    else:
+        return "Please provide text or upload a file", "Error"
+    
+    if not content.strip():
+        return "No text content found", "Error"
+    
+    try:
+        client = openai.OpenAI(api_key=OPENAI_API_KEY)
+        
+        messages = []
+        strategy_description = []
+        
+        if "role-based" in strategy.lower() or "combined" in strategy.lower():
+            if role == "Technical analyst":
+                system_prompt = "You are a technical analyst providing precise, systematic analysis."
+                messages.append({"role": "system", "content": system_prompt})
+                strategy_description.append(f"System role: {role}")
+            elif role == "Creative assistant":
+                system_prompt = "You are a creative assistant providing thoughtful, engaging analysis."
+                messages.append({"role": "system", "content": system_prompt})
+                strategy_description.append(f"System role: {role}")
+        
+        if task == "Sentiment Analysis":
+            user_message = f"Analyse the sentiment of the following text:\n\n{content}"
+        else:  # Summarisation
+            user_message = f"Summarise the following text:\n\n{content}"
+        
+        if "chain-of-thought" in strategy.lower() or "combined" in strategy.lower():
+            user_message += "\n\nThink through this step-by-step before providing your final answer."
+            strategy_description.append("Chain-of-thought reasoning")
+        
+        if "direct" in strategy.lower():
+            strategy_description.append("Direct approach (no special technique)")
+        
+        messages.append({"role": "user", "content": user_message})
+        
+        strategy_description.append(f"Temperature: {temperature}")
+        
+        # Generate response
+        response = client.chat.completions.create(
+            model="gpt-3.5-turbo",
+            messages=messages,
+            temperature=temperature,
+            max_tokens=800
+        )
+        
+        output = response.choices[0].message.content
+        info = "Strategy applied:\n" + "\n".join(f"• {item}" for item in strategy_description)
+        
+        return output, info
+        
+    except Exception as e:
+        return f"Error: {str(e)}", "Error occurred"
+    
+def extract_text_from_file(file):
+    """Extract text from uploaded file (TXT or PDF)"""
+    try:
+        if file.name.endswith('.txt'):
+            return file.read().decode('utf-8')
+        elif file.name.endswith('.pdf'):
+            pdf_reader = PyPDF2.PdfReader(file)
+            text = ""
+            for page in pdf_reader.pages:
+                text += page.extract_text()
+            return text
+        else:
+            return ""
+    except Exception as e:
+        return f"Error reading file: {str(e)}"

package.json

@@ -0,0 +1,39 @@
+{
+  "name": "my-app",
+  "version": "0.1.0",
+  "private": true,
+  "dependencies": {
+    "@radix-ui/react-slider": "^1.2.2",
+    "@shadcn/ui": "^0.0.4",
+    "classnames": "^2.5.1",
+    "cra-template": "1.2.0",
+    "react": "^19.0.0",
+    "react-dom": "^19.0.0",
+    "react-scripts": "5.0.1",
+    "web-vitals": "^4.2.4"
+  },
+  "scripts": {
+    "start": "react-scripts start",
+    "build": "react-scripts build",
+    "test": "react-scripts test",
+    "eject": "react-scripts eject"
+  },
+  "eslintConfig": {
+    "extends": [
+      "react-app",
+      "react-app/jest"
+    ]
+  },
+  "browserslist": {
+    "production": [
+      ">0.2%",
+      "not dead",
+      "not op_mini all"
+    ],
+    "development": [
+      "last 1 chrome version",
+      "last 1 firefox version",
+      "last 1 safari version"
+    ]
+  }
+}

reportWebVitals.js

@@ -0,0 +1,13 @@
+const reportWebVitals = onPerfEntry => {
+  if (onPerfEntry && onPerfEntry instanceof Function) {
+    import('web-vitals').then(({ getCLS, getFID, getFCP, getLCP, getTTFB }) => {
+      getCLS(onPerfEntry);
+      getFID(onPerfEntry);
+      getFCP(onPerfEntry);
+      getLCP(onPerfEntry);
+      getTTFB(onPerfEntry);
+    });
+  }
+};
+
+export default reportWebVitals;

requirements.txt

@@ -0,0 +1,11 @@
+gradio
+openai
+huggingface_hub
+transformers
+torch
+accelerate
+PyPDF2
+pypdfium2==4.20.0 
+tiktoken
+transformers
+torch

setupTests.js

@@ -0,0 +1,5 @@
+// jest-dom adds custom jest matchers for asserting on DOM nodes.
+// allows you to do things like:
+// expect(element).toHaveTextContent(/react/i)
+// learn more: https://github.com/testing-library/jest-dom
+import '@testing-library/jest-dom';