tained ml

.history/app_20240217161705.py

@@ -0,0 +1,35 @@
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+
+# Load the trained model and tokenizer
+model_path = "path/to/save/model"
+tokenizer_path = "path/to/save/tokenizer"
+
+model = AutoModelForSequenceClassification.from_pretrained(model_path)
+tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
+model.eval()  # Set model to evaluation mode
+
+def predict_paraphrase(sentence1, sentence2):
+    # Tokenize the input sentences
+    inputs = tokenizer(sentence1, sentence2, return_tensors="pt", padding=True, truncation=True)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    
+    # Get probabilities
+    probs = torch.nn.functional.softmax(outputs.logits, dim=-1).tolist()[0]
+    
+    # Assuming the first class (index 0) is 'not paraphrase' and the second class (index 1) is 'paraphrase'
+    return {"Not Paraphrase": probs[0], "Paraphrase": probs[1]}
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict_paraphrase,
+    inputs=[gr.inputs.Textbox(lines=2, placeholder="Enter Sentence 1 Here..."),
+            gr.inputs.Textbox(lines=2, placeholder="Enter Sentence 2 Here...")],
+    outputs=gr.outputs.Label(num_top_classes=2),
+    title="Paraphrase Identification",
+    description="This model predicts whether two sentences are paraphrases of each other."
+)
+
+iface.launch()

.history/app_20240217161710.py

@@ -0,0 +1,35 @@
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
+
+# Load the trained model and tokenizer
+model_path = "path/to/save/model"
+tokenizer_path = "path/to/save/tokenizer"
+
+model = AutoModelForSequenceClassification.from_pretrained(model_path)
+tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
+model.eval()  # Set model to evaluation mode
+
+def predict_paraphrase(sentence1, sentence2):
+    # Tokenize the input sentences
+    inputs = tokenizer(sentence1, sentence2, return_tensors="pt", padding=True, truncation=True)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    
+    # Get probabilities
+    probs = torch.nn.functional.softmax(outputs.logits, dim=-1).tolist()[0]
+    
+    # Assuming the first class (index 0) is 'not paraphrase' and the second class (index 1) is 'paraphrase'
+    return {"Not Paraphrase": probs[0], "Paraphrase": probs[1]}
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict_paraphrase,
+    inputs=[gr.inputs.Textbox(lines=2, placeholder="Enter Sentence 1 Here..."),
+            gr.inputs.Textbox(lines=2, placeholder="Enter Sentence 2 Here...")],
+    outputs=gr.outputs.Label(num_top_classes=2),
+    title="Paraphrase Identification",
+    description="This model predicts whether two sentences are paraphrases of each other."
+)
+
+iface.launch()

.history/trainml_20240217161632.py

@@ -0,0 +1,89 @@
+# First, we grab tools from our toolbox. These tools help us with different tasks like reading books (datasets),
+# learning new languages (tokenization), and solving puzzles (models).
+from datasets import load_dataset  # This tool helps us get our book, where the puzzles are.
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, AdamW, get_scheduler  # These help us understand and solve puzzles.
+from transformers import DataCollatorWithPadding  # This makes sure all puzzle pieces are the same size.
+from torch.utils.data import DataLoader  # This helps us handle one page of puzzles at a time.
+import torch  # This is like the brain of our operations, helping us think through puzzles.
+from tqdm.auto import tqdm  # This is our progress bar, showing us how far we've come in solving the book.
+import evaluate  # This tells us how well we did in solving puzzles.
+from accelerate import Accelerator  # This makes everything go super fast, like a rocket!
+
+# Now, let's pick up the book we're going to solve today.
+raw_datasets = load_dataset("glue", "mrpc")  # This is a book filled with puzzles about matching sentences.
+
+# Before we start solving puzzles, we need to understand the language they're written in.
+checkpoint = "bert-base-uncased"  # This is a guidebook to help us understand the puzzles' language.
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)  # This tool helps us read and understand the language in our book.
+
+# To solve puzzles, we need to make sure we understand each sentence properly.
+def tokenize_function(example):  # This is like reading each sentence carefully and understanding each word.
+    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)
+
+# We prepare all puzzles in the book so they're ready to solve.
+tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)  # This is like marking all the important parts of the sentences.
+
+# Puzzles can be different sizes, but our puzzle solver works best when all puzzles are the same size.
+data_collator = DataCollatorWithPadding(tokenizer=tokenizer)  # This adds extra paper to smaller puzzles to make them all the same size.
+
+# We're setting up our puzzle pages, making sure we're ready to solve them one by one.
+tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"])  # We remove stuff we don't need.
+tokenized_datasets = tokenized_datasets.rename_column("label", "labels")  # We make sure the puzzle answers are labeled correctly.
+tokenized_datasets.set_format("torch")  # We make sure our puzzles are in the right format for our brain to understand.
+
+# Now, we're ready to start solving puzzles, one page at a time.
+train_dataloader = DataLoader(
+    tokenized_datasets["train"], shuffle=True, batch_size=8, collate_fn=data_collator
+)  # This is our training puzzles.
+eval_dataloader = DataLoader(
+    tokenized_datasets["validation"], batch_size=8, collate_fn=data_collator
+)  # These are puzzles we use to check our progress.
+
+# We need a puzzle solver, which is specially trained to solve these types of puzzles.
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)  # This is our puzzle-solving robot.
+
+# Our robot needs instructions on how to get better at solving puzzles.
+optimizer = AdamW(model.parameters(), lr=5e-5)  # This tells our robot how to improve.
+num_epochs = 3  # This is how many times we'll go through the whole book of puzzles.
+num_training_steps = num_epochs * len(train_dataloader)  # This is the total number of puzzles we'll solve.
+lr_scheduler = get_scheduler(
+    "linear",
+    optimizer=optimizer,
+    num_warmup_steps=0,
+    num_training_steps=num_training_steps,
+)  # This adjusts how quickly our robot learns over time.
+
+# To solve puzzles super fast, we're going to use a rocket!
+accelerator = Accelerator()  # This is our rocket that makes everything go faster.
+model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
+    model, optimizer, train_dataloader, eval_dataloader
+)  # We make sure our robot, our puzzles, and our instructions are all ready for the rocket.
+
+# It's time to start solving puzzles!
+progress_bar = tqdm(range(num_training_steps))  # This shows us our progress.
+model.train()  # We tell our robot it's time to start learning.
+for epoch in range(num_epochs):  # We go through our book of puzzles multiple times to get really good.
+    for batch in train_dataloader:  # Each time, we take a page of puzzles to solve.
+        outputs = model(**batch)  # Our robot tries to solve the puzzles.
+        loss = outputs.loss  # We check how many mistakes it made.
+        accelerator.backward(loss)  # We give feedback to our robot so it can learn from its mistakes.
+        optimizer.step()  # We update our robot's puzzle-solving strategy.
+        lr_scheduler.step()  # We adjust how quickly our robot is learning.
+        optimizer.zero_grad()  # We reset some settings to make sure our robot is ready for the next page.
+        progress_bar.update(1)  # We update our progress bar to show how many puzzles we've solved.
+
+# After all that practice, it's time to test how good our robot has become at solving puzzles.
+metric = evaluate.load("glue", "mrpc")  # This is like the answer key to check our robot's work.
+model.eval()  # We tell our robot it's time to show what it's learned.
+for batch in eval_dataloader:  # We take a page of puzzles we haven't solved yet.
+    with torch.no_grad():  # We make sure we're just testing, not learning anymore.
+        outputs = model(**batch)  # Our robot solves the puzzles.
+    logits = outputs.logits  # We look at our robot's answers.
+    predictions = torch.argmax(logits, dim=-1)  # We decide which answer our robot thinks is right.
+    metric.add_batch(predictions=predictions, references=batch["labels"])  # We compare our robot's answers to the correct answers.
+
+final_score = metric.compute()  # We calculate how well our robot did.
+print(final_score)  # We print out the score to see how well our robot solved the puzzles!
+
+model.save_pretrained("path/to/save/model")
+tokenizer.save_pretrained("path/to/save/tokenizer")

.history/trainml_20240217161633.py

@@ -0,0 +1,89 @@
+# First, we grab tools from our toolbox. These tools help us with different tasks like reading books (datasets),
+# learning new languages (tokenization), and solving puzzles (models).
+from datasets import load_dataset  # This tool helps us get our book, where the puzzles are.
+from transformers import AutoTokenizer, AutoModelForSequenceClassification, AdamW, get_scheduler  # These help us understand and solve puzzles.
+from transformers import DataCollatorWithPadding  # This makes sure all puzzle pieces are the same size.
+from torch.utils.data import DataLoader  # This helps us handle one page of puzzles at a time.
+import torch  # This is like the brain of our operations, helping us think through puzzles.
+from tqdm.auto import tqdm  # This is our progress bar, showing us how far we've come in solving the book.
+import evaluate  # This tells us how well we did in solving puzzles.
+from accelerate import Accelerator  # This makes everything go super fast, like a rocket!
+
+# Now, let's pick up the book we're going to solve today.
+raw_datasets = load_dataset("glue", "mrpc")  # This is a book filled with puzzles about matching sentences.
+
+# Before we start solving puzzles, we need to understand the language they're written in.
+checkpoint = "bert-base-uncased"  # This is a guidebook to help us understand the puzzles' language.
+tokenizer = AutoTokenizer.from_pretrained(checkpoint)  # This tool helps us read and understand the language in our book.
+
+# To solve puzzles, we need to make sure we understand each sentence properly.
+def tokenize_function(example):  # This is like reading each sentence carefully and understanding each word.
+    return tokenizer(example["sentence1"], example["sentence2"], truncation=True)
+
+# We prepare all puzzles in the book so they're ready to solve.
+tokenized_datasets = raw_datasets.map(tokenize_function, batched=True)  # This is like marking all the important parts of the sentences.
+
+# Puzzles can be different sizes, but our puzzle solver works best when all puzzles are the same size.
+data_collator = DataCollatorWithPadding(tokenizer=tokenizer)  # This adds extra paper to smaller puzzles to make them all the same size.
+
+# We're setting up our puzzle pages, making sure we're ready to solve them one by one.
+tokenized_datasets = tokenized_datasets.remove_columns(["sentence1", "sentence2", "idx"])  # We remove stuff we don't need.
+tokenized_datasets = tokenized_datasets.rename_column("label", "labels")  # We make sure the puzzle answers are labeled correctly.
+tokenized_datasets.set_format("torch")  # We make sure our puzzles are in the right format for our brain to understand.
+
+# Now, we're ready to start solving puzzles, one page at a time.
+train_dataloader = DataLoader(
+    tokenized_datasets["train"], shuffle=True, batch_size=8, collate_fn=data_collator
+)  # This is our training puzzles.
+eval_dataloader = DataLoader(
+    tokenized_datasets["validation"], batch_size=8, collate_fn=data_collator
+)  # These are puzzles we use to check our progress.
+
+# We need a puzzle solver, which is specially trained to solve these types of puzzles.
+model = AutoModelForSequenceClassification.from_pretrained(checkpoint, num_labels=2)  # This is our puzzle-solving robot.
+
+# Our robot needs instructions on how to get better at solving puzzles.
+optimizer = AdamW(model.parameters(), lr=5e-5)  # This tells our robot how to improve.
+num_epochs = 3  # This is how many times we'll go through the whole book of puzzles.
+num_training_steps = num_epochs * len(train_dataloader)  # This is the total number of puzzles we'll solve.
+lr_scheduler = get_scheduler(
+    "linear",
+    optimizer=optimizer,
+    num_warmup_steps=0,
+    num_training_steps=num_training_steps,
+)  # This adjusts how quickly our robot learns over time.
+
+# To solve puzzles super fast, we're going to use a rocket!
+accelerator = Accelerator()  # This is our rocket that makes everything go faster.
+model, optimizer, train_dataloader, eval_dataloader = accelerator.prepare(
+    model, optimizer, train_dataloader, eval_dataloader
+)  # We make sure our robot, our puzzles, and our instructions are all ready for the rocket.
+
+# It's time to start solving puzzles!
+progress_bar = tqdm(range(num_training_steps))  # This shows us our progress.
+model.train()  # We tell our robot it's time to start learning.
+for epoch in range(num_epochs):  # We go through our book of puzzles multiple times to get really good.
+    for batch in train_dataloader:  # Each time, we take a page of puzzles to solve.
+        outputs = model(**batch)  # Our robot tries to solve the puzzles.
+        loss = outputs.loss  # We check how many mistakes it made.
+        accelerator.backward(loss)  # We give feedback to our robot so it can learn from its mistakes.
+        optimizer.step()  # We update our robot's puzzle-solving strategy.
+        lr_scheduler.step()  # We adjust how quickly our robot is learning.
+        optimizer.zero_grad()  # We reset some settings to make sure our robot is ready for the next page.
+        progress_bar.update(1)  # We update our progress bar to show how many puzzles we've solved.
+
+# After all that practice, it's time to test how good our robot has become at solving puzzles.
+metric = evaluate.load("glue", "mrpc")  # This is like the answer key to check our robot's work.
+model.eval()  # We tell our robot it's time to show what it's learned.
+for batch in eval_dataloader:  # We take a page of puzzles we haven't solved yet.
+    with torch.no_grad():  # We make sure we're just testing, not learning anymore.
+        outputs = model(**batch)  # Our robot solves the puzzles.
+    logits = outputs.logits  # We look at our robot's answers.
+    predictions = torch.argmax(logits, dim=-1)  # We decide which answer our robot thinks is right.
+    metric.add_batch(predictions=predictions, references=batch["labels"])  # We compare our robot's answers to the correct answers.
+
+final_score = metric.compute()  # We calculate how well our robot did.
+print(final_score)  # We print out the score to see how well our robot solved the puzzles!
+
+model.save_pretrained("path/to/save/model")
+tokenizer.save_pretrained("path/to/save/tokenizer")

.lh/app.py.json

@@ -3,11 +3,19 @@
     "activeCommit": 0,
     "commits": [
         {
-            "activePatchIndex": 0,
+            "activePatchIndex": 2,
             "patches": [
                 {
                     "date": 1708166138917,
                     "content": "Index: \n===================================================================\n--- \n+++ \n"
+                },
+                {
+                    "date": 1708166825700,
+                    "content": "Index: \n===================================================================\n--- \n+++ \n@@ -1,7 +1,35 @@\n import gradio as gr\n+from transformers import AutoTokenizer, AutoModelForSequenceClassification\n+import torch\n \n-def greet(name):\n-    return \"Hello \" + name + \"!!\"\n+# Load the trained model and tokenizer\n\\n+model_path = \"path/to/save/model\"\n+tokenizer_path = \"path/to/save/tokenizer\"\n \n-iface = gr.Interface(fn=greet, inputs=\"text\", outputs=\"text\")\n-iface.launch()\n+model = AutoModelForSequenceClassification.from_pretrained(model_path)\n+tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)\n+model.eval()  # Set model to evaluation mode\n+\n+def predict_paraphrase(sentence1, sentence2):\n+    # Tokenize the input sentences\n+    inputs = tokenizer(sentence1, sentence2, return_tensors=\"pt\", padding=True, truncation=True)\n+    with torch.no_grad():\n+        outputs = model(**inputs)\n+    \n+    # Get probabilities\n+    probs = torch.nn.functional.softmax(outputs.logits, dim=-1).tolist()[0]\n+    \n+    # Assuming the first class (index 0) is 'not paraphrase' and the second class (index 1) is 'paraphrase'\n+    return {\"Not Paraphrase\": probs[0], \"Paraphrase\": probs[1]}\n+\n+# Create Gradio interface\n+iface = gr.Interface(\n+    fn=predict_paraphrase,\n+    inputs=[gr.inputs.Textbox(lines=2, placeholder=\"Enter Sentence 1 Here...\"),\n+            gr.inputs.Textbox(lines=2, placeholder=\"Enter Sentence 2 Here...\")],\n+    outputs=gr.outputs.Label(num_top_classes=2),\n+    title=\"Paraphrase Identification\",\n+    description=\"This model predicts whether two sentences are paraphrases of each other.\"\n+)\n+\n+iface.launch()\n"
+                },
+                {
+                    "date": 1708166830798,
+                    "content": "Index: \n===================================================================\n--- \n+++ \n@@ -31,5 +31,5 @@\n     title=\"Paraphrase Identification\",\n     description=\"This model predicts whether two sentences are paraphrases of each other.\"\n )\n \n-iface.launch()\n\\n+iface.launch()\n"
                 }
             ],
             "date": 1708166138917,

.lh/trainml.py.json

@@ -3,11 +3,15 @@
     "activeCommit": 0,
     "commits": [
         {
-            "activePatchIndex": 0,
+            "activePatchIndex": 1,
             "patches": [
                 {
                     "date": 1708166375103,
                     "content": "Index: \n===================================================================\n--- \n+++ \n"
+                },
+                {
+                    "date": 1708166792627,
+                    "content": "Index: \n===================================================================\n--- \n+++ \n@@ -83,4 +83,7 @@\n     metric.add_batch(predictions=predictions, references=batch[\"labels\"])  # We compare our robot's answers to the correct answers.\n \n final_score = metric.compute()  # We calculate how well our robot did.\n print(final_score)  # We print out the score to see how well our robot solved the puzzles!\n+\n+model.save_pretrained(\"path/to/save/model\")\n+tokenizer.save_pretrained(\"path/to/save/tokenizer\")\n\\n"
                 }
             ],
             "date": 1708166375103,

app.py

@@ -1,7 +1,35 @@
 import gradio as gr
+from transformers import AutoTokenizer, AutoModelForSequenceClassification
+import torch
 
-def greet(name):
-    return "Hello " + name + "!!"
+# Load the trained model and tokenizer
+model_path = "path/to/save/model"
+tokenizer_path = "path/to/save/tokenizer"
 
-iface = gr.Interface(fn=greet, inputs="text", outputs="text")
-iface.launch()
+model = AutoModelForSequenceClassification.from_pretrained(model_path)
+tokenizer = AutoTokenizer.from_pretrained(tokenizer_path)
+model.eval()  # Set model to evaluation mode
+
+def predict_paraphrase(sentence1, sentence2):
+    # Tokenize the input sentences
+    inputs = tokenizer(sentence1, sentence2, return_tensors="pt", padding=True, truncation=True)
+    with torch.no_grad():
+        outputs = model(**inputs)
+    
+    # Get probabilities
+    probs = torch.nn.functional.softmax(outputs.logits, dim=-1).tolist()[0]
+    
+    # Assuming the first class (index 0) is 'not paraphrase' and the second class (index 1) is 'paraphrase'
+    return {"Not Paraphrase": probs[0], "Paraphrase": probs[1]}
+
+# Create Gradio interface
+iface = gr.Interface(
+    fn=predict_paraphrase,
+    inputs=[gr.inputs.Textbox(lines=2, placeholder="Enter Sentence 1 Here..."),
+            gr.inputs.Textbox(lines=2, placeholder="Enter Sentence 2 Here...")],
+    outputs=gr.outputs.Label(num_top_classes=2),
+    title="Paraphrase Identification",
+    description="This model predicts whether two sentences are paraphrases of each other."
+)
+
+iface.launch()

trainml.py

@@ -84,3 +84,6 @@ for batch in eval_dataloader:  # We take a page of puzzles we haven't solved yet
 
 final_score = metric.compute()  # We calculate how well our robot did.
 print(final_score)  # We print out the score to see how well our robot solved the puzzles!
+
+model.save_pretrained("path/to/save/model")
+tokenizer.save_pretrained("path/to/save/tokenizer")