output fix

app.py

@@ -1,4 +1,4 @@
-### 1. Imports and class names setup ### 
+### 1. Imports and class names setup ###
 from ast import Interactive
 import gradio as gr
 import os
@@ -13,6 +13,8 @@ import pytesseract
 import re
 import shutil
 import solver
+import glob
+from PIL import Image
 
 from model import create_model
 from timeit import default_timer as timer
@@ -30,81 +32,83 @@ def parse_args() -> argparse.Namespace:
                         action='store_false')
     return parser.parse_args()
 
+
 def set_example_image(example: list) -> dict:
     return gr.Image.update(value=example[0])
 
 
+def update_dataset(example: list) -> dict:
+    return gr.Gallery.update(value=example[0])
+
+
 # Setup class names
-with open("class_names.txt", "r") as f: # reading them in from class_names.txt
-    class_names = [names.strip() for names in  f.readlines()]
-    
-### 2. Model and transforms preparation ###    
-
-# Create model
-model_base, model_transforms = create_model(
-    num_classes=len(class_names),
-)
-
-model_created = model_base(input_shape=1, hidden_units=10, output_shape=len(class_names))
-
-model_1 = model_created.load_state_dict(
-    torch.load(
-        f="model_1.pth",
-        map_location=torch.device("cpu"),  # load to CPU
-    )
-)
+with open("class_names.txt", "r") as f:  # reading them in from class_names.txt
+    class_names = [names.strip() for names in f.readlines()]
+
+
+def get_images():
+    images_list = []
+    for filename in glob.glob('wordsPuzzle/*.jpg'):  # assuming png
+        im = Image.open(filename)
+        images_list.append(im)
+    return images_list
 
 
 def main():
     args = parse_args()
     args.device = 'cuda' if torch.cuda.is_available() else 'cpu'
-    print('*** Now using %s.'%(args.device))
+    print('*** Now using %s.' % (args.device))
 
     with gr.Blocks(theme=args.theme, css='style.css') as demo:
         gr.Markdown('''# World Puzzle Solver 🧩''')
+        gr.Markdown('''## (Works in Spanish too!) 🇪🇸''')
 
         with gr.Box():
-            gr.Markdown('''### Insert a Word Puzzle Image in both boxes and crop the board and words''')
-            with gr.Row():    
+            gr.Markdown(
+                '''### Insert a Word Puzzle Image in both boxes and crop the board and words''')
+            with gr.Row():
                 with gr.Box():
                     with gr.Column():
-                        gr.Markdown('''Images 🖼️''')                
+                        gr.Markdown('''Images 🖼️''')
                         with gr.Row():
-                            input_board= gr.Image(label='Board',
-                                                           type='filepath',
-														   interactive=True,)
+                            input_board = gr.Image(label='Board',
+                                                   type='filepath',
+                                                   interactive=True,)
                         with gr.Row():
                             crop_board_button = gr.Button('Crop Board ✂️')
                         with gr.Row():
                             input_words = gr.Image(label='Words',
-                                                          type='filepath',
-														  interactive=True,)  
+                                                   type='filepath',
+                                                   interactive=True, height="auto")
                         with gr.Row():
                             crop_words_button = gr.Button('Crop Words ✂️')
-                        with gr.Column():
-					# Create examples list from "examples/" directory
-                            paths = [["examples/" + example] for example in os.listdir("examples")]
+                        with gr.Row():
+                            # Create examples list from "examples/" directory
+                            paths = [["examples/" + example]
+                                     for example in os.listdir("examples")]
                             example_images = gr.Dataset(components=([input_board]),
-                                            samples=[[path] for path in paths],
-                                            label='Image Examples (Drag and drop into both boxes) then crop using the tool button')
+                                                        samples=[[path]
+                                                                 for path in paths],
+                                                        label='Image Examples (Drag and drop into both boxes) then crop using the tool button')
 
                 with gr.Box():
                     with gr.Column():
                         gr.Markdown('''Cropped Images ✂️''')
                         with gr.Row():
                             cropped_board = gr.Image(label='Board Cropped',
-                                            type='filepath',
-                                            interactive=False)
+                                                     type='filepath',
+                                                     interactive=False, height="auto")
                             instyle = gr.Variable()
                         with gr.Row():
                             cropped_words = gr.Image(label='Words Cropped',
-                                            type='filepath',
-                                            interactive=False)
+                                                     type='filepath',
+                                                     interactive=False)
                             instyle = gr.Variable()
                         with gr.Row():
                             find_words_button = gr.Button('Find Words 🔍')
                         with gr.Row():
-                            words_found = gr.Textbox(label='Words detected (edit if wrong)', interactive=True, value='')
+                            words_found = gr.Textbox(
+                                label='Words detected (edit if wrong)', interactive=True, value='')
                         with gr.Row():
                             solve_button = gr.Button('Solve! 📝')
 
@@ -112,36 +116,36 @@ def main():
                     with gr.Column():
                         gr.Markdown('''Solution ✅''')
                         with gr.Row():
-                            board_solved = gr.Image(label='Solved Word Puzzle',
-                                            type='filepath',
-                                            interactive=False)
-                        with gr.Column():
-					# Create examples list from "examples/" directory
-                            paths = [["examples/" + example] for example in os.listdir("examples")]
-                            example_images = gr.Dataset(components=([board_solved]),
-                                            samples=[[path] for path in paths],
-                                            label='World puzzle solved and words found')
+                            board_solved = gr.Image(
+                                type='filepath',
+                                interactive=False)
+                        with gr.Row():
+                            show_words_board = gr.Button(
+                                'Show words seperately 📝')
+                        with gr.Row():
+                            gallery = gr.Gallery(
+                                label=None, show_label=True, elem_id="gallery"
+                            ).style(grid=[4], height="auto")
+
 
                 crop_board_button.click(fn=None,
-                                inputs=[input_board],
-                                outputs=[cropped_board])
+                                        inputs=[input_board],
+                                        outputs=[cropped_board])
                 crop_words_button.click(fn=None,
-								inputs=[input_words],
-								outputs=[cropped_words])
+                                        inputs=[input_words],
+                                        outputs=[cropped_words])
                 find_words_button.click(solver.get_words,
-								inputs=cropped_words,
-								outputs=words_found)
+                                        inputs=cropped_words,
+                                        outputs=words_found)
                 solve_button.click(solver.solve_puzzle,
-								inputs=[cropped_board, words_found],
-								outputs=board_solved)
-
+                                   inputs=[cropped_board, words_found],
+                                   outputs=board_solved)
 
         example_images.click(fn=set_example_image,
-                                 inputs=example_images,
-                                 outputs=example_images.components)
-				
+                             inputs=example_images,
+                             outputs=example_images.components)
+        show_words_board.click(get_images, None, gallery)
 
-        
     demo.launch(
         enable_queue=args.enable_queue,
         server_port=args.port,

helper/data_setup.py

@@ -1,66 +0,0 @@
-"""
-Contains functionality for creating PyTorch DataLoaders for 
-image classification data.
-"""
-import os
-
-from torchvision import datasets, transforms
-from torch.utils.data import DataLoader
-
-NUM_WORKERS = os.cpu_count()
-
-def create_dataloaders(
-    train_dir: str, 
-    test_dir: str, 
-    train_transform: transforms.Compose,
-    test_transform: transforms.Compose, 
-    batch_size: int, 
-    num_workers: int=NUM_WORKERS
-):
-  """Creates training and testing DataLoaders.
-
-  Takes in a training directory and testing directory path and turns
-  them into PyTorch Datasets and then into PyTorch DataLoaders.
-
-  Args:
-    train_dir: Path to training directory.
-    test_dir: Path to testing directory.
-    transform: torchvision transforms to perform on training and testing data.
-    batch_size: Number of samples per batch in each of the DataLoaders.
-    num_workers: An integer for number of workers per DataLoader.
-
-  Returns:
-    A tuple of (train_dataloader, test_dataloader, class_names).
-    Where class_names is a list of the target classes.
-    Example usage:
-      train_dataloader, test_dataloader, class_names = \
-        = create_dataloaders(train_dir=path/to/train_dir,
-                             test_dir=path/to/test_dir,
-                             transform=some_transform,
-                             batch_size=32,
-                             num_workers=4)
-  """
-  # Use ImageFolder to create dataset(s)
-  train_data = datasets.ImageFolder(train_dir, transform=train_transform)
-  test_data = datasets.ImageFolder(test_dir, transform=test_transform)
-
-  # Get class names
-  class_names = train_data.classes
-
-  # Turn images into data loaders
-  train_dataloader = DataLoader(
-      train_data,
-      batch_size=batch_size,
-      shuffle=True,
-      num_workers=num_workers,
-      pin_memory=True,
-  )
-  test_dataloader = DataLoader(
-      test_data,
-      batch_size=batch_size,
-      shuffle=False,
-      num_workers=num_workers,
-      pin_memory=True,
-  )
-
-  return train_dataloader, test_dataloader, class_names

helper/engine.py

@@ -1,195 +0,0 @@
-"""
-Contains functions for training and testing a PyTorch model.
-"""
-import torch
-
-from tqdm.auto import tqdm
-from typing import Dict, List, Tuple
-
-def train_step(model: torch.nn.Module, 
-               dataloader: torch.utils.data.DataLoader, 
-               loss_fn: torch.nn.Module, 
-               optimizer: torch.optim.Optimizer,
-               device: torch.device) -> Tuple[float, float]:
-    """Trains a PyTorch model for a single epoch.
-
-    Turns a target PyTorch model to training mode and then
-    runs through all of the required training steps (forward
-    pass, loss calculation, optimizer step).
-
-    Args:
-    model: A PyTorch model to be trained.
-    dataloader: A DataLoader instance for the model to be trained on.
-    loss_fn: A PyTorch loss function to minimize.
-    optimizer: A PyTorch optimizer to help minimize the loss function.
-    device: A target device to compute on (e.g. "cuda" or "cpu").
-
-    Returns:
-    A tuple of training loss and training accuracy metrics.
-    In the form (train_loss, train_accuracy). For example:
-
-    (0.1112, 0.8743)
-    """
-    # Put model in train mode
-    model.train()
-
-    # Setup train loss and train accuracy values
-    train_loss, train_acc = 0, 0
-
-    # Loop through data loader data batches
-    for batch, (X, y) in enumerate(dataloader):
-        # Send data to target device
-        X, y = X.to(device), y.to(device)
-
-        # 1. Forward pass
-        y_pred = model(X)
-
-        # 2. Calculate  and accumulate loss
-        loss = loss_fn(y_pred, y)
-        train_loss += loss.item() 
-
-        # 3. Optimizer zero grad
-        optimizer.zero_grad()
-
-        # 4. Loss backward
-        loss.backward()
-
-        # 5. Optimizer step
-        optimizer.step()
-
-        # Calculate and accumulate accuracy metric across all batches
-        y_pred_class = torch.argmax(torch.softmax(y_pred, dim=1), dim=1)
-        train_acc += (y_pred_class == y).sum().item()/len(y_pred)
-
-    # Adjust metrics to get average loss and accuracy per batch 
-    train_loss = train_loss / len(dataloader)
-    train_acc = train_acc / len(dataloader)
-    return train_loss, train_acc
-
-def test_step(model: torch.nn.Module, 
-              dataloader: torch.utils.data.DataLoader, 
-              loss_fn: torch.nn.Module,
-              device: torch.device) -> Tuple[float, float]:
-    """Tests a PyTorch model for a single epoch.
-
-    Turns a target PyTorch model to "eval" mode and then performs
-    a forward pass on a testing dataset.
-
-    Args:
-    model: A PyTorch model to be tested.
-    dataloader: A DataLoader instance for the model to be tested on.
-    loss_fn: A PyTorch loss function to calculate loss on the test data.
-    device: A target device to compute on (e.g. "cuda" or "cpu").
-
-    Returns:
-    A tuple of testing loss and testing accuracy metrics.
-    In the form (test_loss, test_accuracy). For example:
-
-    (0.0223, 0.8985)
-    """
-    # Put model in eval mode
-    model.eval() 
-
-    # Setup test loss and test accuracy values
-    test_loss, test_acc = 0, 0
-
-    # Turn on inference context manager
-    with torch.inference_mode():
-        # Loop through DataLoader batches
-        for batch, (X, y) in enumerate(dataloader):
-            # Send data to target device
-            X, y = X.to(device), y.to(device)
-
-            # 1. Forward pass
-            test_pred_logits = model(X)
-
-            # 2. Calculate and accumulate loss
-            loss = loss_fn(test_pred_logits, y)
-            test_loss += loss.item()
-
-            # Calculate and accumulate accuracy
-            test_pred_labels = test_pred_logits.argmax(dim=1)
-            test_acc += ((test_pred_labels == y).sum().item()/len(test_pred_labels))
-
-    # Adjust metrics to get average loss and accuracy per batch 
-    test_loss = test_loss / len(dataloader)
-    test_acc = test_acc / len(dataloader)
-    return test_loss, test_acc
-
-def train(model: torch.nn.Module, 
-          train_dataloader: torch.utils.data.DataLoader, 
-          test_dataloader: torch.utils.data.DataLoader, 
-          optimizer: torch.optim.Optimizer,
-          loss_fn: torch.nn.Module,
-          epochs: int,
-          device: torch.device) -> Dict[str, List]:
-    """Trains and tests a PyTorch model.
-
-    Passes a target PyTorch models through train_step() and test_step()
-    functions for a number of epochs, training and testing the model
-    in the same epoch loop.
-
-    Calculates, prints and stores evaluation metrics throughout.
-
-    Args:
-    model: A PyTorch model to be trained and tested.
-    train_dataloader: A DataLoader instance for the model to be trained on.
-    test_dataloader: A DataLoader instance for the model to be tested on.
-    optimizer: A PyTorch optimizer to help minimize the loss function.
-    loss_fn: A PyTorch loss function to calculate loss on both datasets.
-    epochs: An integer indicating how many epochs to train for.
-    device: A target device to compute on (e.g. "cuda" or "cpu").
-
-    Returns:
-    A dictionary of training and testing loss as well as training and
-    testing accuracy metrics. Each metric has a value in a list for 
-    each epoch.
-    In the form: {train_loss: [...],
-              train_acc: [...],
-              test_loss: [...],
-              test_acc: [...]} 
-    For example if training for epochs=2: 
-             {train_loss: [2.0616, 1.0537],
-              train_acc: [0.3945, 0.3945],
-              test_loss: [1.2641, 1.5706],
-              test_acc: [0.3400, 0.2973]} 
-    """
-    # Create empty results dictionary
-    results = {"train_loss": [],
-               "train_acc": [],
-               "test_loss": [],
-               "test_acc": []
-    }
-    
-    # Make sure model on target device
-    model.to(device)
-
-    # Loop through training and testing steps for a number of epochs
-    for epoch in tqdm(range(epochs)):
-        train_loss, train_acc = train_step(model=model,
-                                          dataloader=train_dataloader,
-                                          loss_fn=loss_fn,
-                                          optimizer=optimizer,
-                                          device=device)
-        test_loss, test_acc = test_step(model=model,
-          dataloader=test_dataloader,
-          loss_fn=loss_fn,
-          device=device)
-
-        # Print out what's happening
-        print(
-          f"Epoch: {epoch+1} | "
-          f"train_loss: {train_loss:.4f} | "
-          f"train_acc: {train_acc:.4f} | "
-          f"test_loss: {test_loss:.4f} | "
-          f"test_acc: {test_acc:.4f}"
-        )
-
-        # Update results dictionary
-        results["train_loss"].append(train_loss)
-        results["train_acc"].append(train_acc)
-        results["test_loss"].append(test_loss)
-        results["test_acc"].append(test_acc)
-
-    # Return the filled results at the end of the epochs
-    return results

helper/helper_functions.py

@@ -1,294 +0,0 @@
-"""
-A series of helper functions used throughout the course.
-
-If a function gets defined once and could be used over and over, it'll go in here.
-"""
-import torch
-import matplotlib.pyplot as plt
-import numpy as np
-
-from torch import nn
-
-import os
-import zipfile
-
-from pathlib import Path
-
-import requests
-
-# Walk through an image classification directory and find out how many files (images)
-# are in each subdirectory.
-import os
-
-def walk_through_dir(dir_path):
-    """
-    Walks through dir_path returning its contents.
-    Args:
-    dir_path (str): target directory
-
-    Returns:
-    A print out of:
-      number of subdiretories in dir_path
-      number of images (files) in each subdirectory
-      name of each subdirectory
-    """
-    for dirpath, dirnames, filenames in os.walk(dir_path):
-        print(f"There are {len(dirnames)} directories and {len(filenames)} images in '{dirpath}'.")
-
-def plot_decision_boundary(model: torch.nn.Module, X: torch.Tensor, y: torch.Tensor):
-    """Plots decision boundaries of model predicting on X in comparison to y.
-
-    Source - https://madewithml.com/courses/foundations/neural-networks/ (with modifications)
-    """
-    # Put everything to CPU (works better with NumPy + Matplotlib)
-    model.to("cpu")
-    X, y = X.to("cpu"), y.to("cpu")
-
-    # Setup prediction boundaries and grid
-    x_min, x_max = X[:, 0].min() - 0.1, X[:, 0].max() + 0.1
-    y_min, y_max = X[:, 1].min() - 0.1, X[:, 1].max() + 0.1
-    xx, yy = np.meshgrid(np.linspace(x_min, x_max, 101), np.linspace(y_min, y_max, 101))
-
-    # Make features
-    X_to_pred_on = torch.from_numpy(np.column_stack((xx.ravel(), yy.ravel()))).float()
-
-    # Make predictions
-    model.eval()
-    with torch.inference_mode():
-        y_logits = model(X_to_pred_on)
-
-    # Test for multi-class or binary and adjust logits to prediction labels
-    if len(torch.unique(y)) > 2:
-        y_pred = torch.softmax(y_logits, dim=1).argmax(dim=1)  # mutli-class
-    else:
-        y_pred = torch.round(torch.sigmoid(y_logits))  # binary
-
-    # Reshape preds and plot
-    y_pred = y_pred.reshape(xx.shape).detach().numpy()
-    plt.contourf(xx, yy, y_pred, cmap=plt.cm.RdYlBu, alpha=0.7)
-    plt.scatter(X[:, 0], X[:, 1], c=y, s=40, cmap=plt.cm.RdYlBu)
-    plt.xlim(xx.min(), xx.max())
-    plt.ylim(yy.min(), yy.max())
-
-
-# Plot linear data or training and test and predictions (optional)
-def plot_predictions(
-    train_data, train_labels, test_data, test_labels, predictions=None
-):
-    """
-  Plots linear training data and test data and compares predictions.
-  """
-    plt.figure(figsize=(10, 7))
-
-    # Plot training data in blue
-    plt.scatter(train_data, train_labels, c="b", s=4, label="Training data")
-
-    # Plot test data in green
-    plt.scatter(test_data, test_labels, c="g", s=4, label="Testing data")
-
-    if predictions is not None:
-        # Plot the predictions in red (predictions were made on the test data)
-        plt.scatter(test_data, predictions, c="r", s=4, label="Predictions")
-
-    # Show the legend
-    plt.legend(prop={"size": 14})
-
-
-# Calculate accuracy (a classification metric)
-def accuracy_fn(y_true, y_pred):
-    """Calculates accuracy between truth labels and predictions.
-
-    Args:
-        y_true (torch.Tensor): Truth labels for predictions.
-        y_pred (torch.Tensor): Predictions to be compared to predictions.
-
-    Returns:
-        [torch.float]: Accuracy value between y_true and y_pred, e.g. 78.45
-    """
-    correct = torch.eq(y_true, y_pred).sum().item()
-    acc = (correct / len(y_pred)) * 100
-    return acc
-
-
-def print_train_time(start, end, device=None):
-    """Prints difference between start and end time.
-
-    Args:
-        start (float): Start time of computation (preferred in timeit format). 
-        end (float): End time of computation.
-        device ([type], optional): Device that compute is running on. Defaults to None.
-
-    Returns:
-        float: time between start and end in seconds (higher is longer).
-    """
-    total_time = end - start
-    print(f"\nTrain time on {device}: {total_time:.3f} seconds")
-    return total_time
-
-
-# Plot loss curves of a model
-def plot_loss_curves(results):
-    """Plots training curves of a results dictionary.
-
-    Args:
-        results (dict): dictionary containing list of values, e.g.
-            {"train_loss": [...],
-             "train_acc": [...],
-             "test_loss": [...],
-             "test_acc": [...]}
-    """
-    loss = results["train_loss"]
-    test_loss = results["test_loss"]
-
-    accuracy = results["train_acc"]
-    test_accuracy = results["test_acc"]
-
-    epochs = range(len(results["train_loss"]))
-
-    plt.figure(figsize=(15, 7))
-
-    # Plot loss
-    plt.subplot(1, 2, 1)
-    plt.plot(epochs, loss, label="train_loss")
-    plt.plot(epochs, test_loss, label="test_loss")
-    plt.title("Loss")
-    plt.xlabel("Epochs")
-    plt.legend()
-
-    # Plot accuracy
-    plt.subplot(1, 2, 2)
-    plt.plot(epochs, accuracy, label="train_accuracy")
-    plt.plot(epochs, test_accuracy, label="test_accuracy")
-    plt.title("Accuracy")
-    plt.xlabel("Epochs")
-    plt.legend()
-
-
-# Pred and plot image function from notebook 04
-# See creation: https://www.learnpytorch.io/04_pytorch_custom_datasets/#113-putting-custom-image-prediction-together-building-a-function
-from typing import List
-import torchvision
-
-
-def pred_and_plot_image(
-    model: torch.nn.Module,
-    image_path: str,
-    class_names: List[str] = None,
-    transform=None,
-    device: torch.device = "cuda" if torch.cuda.is_available() else "cpu",
-):
-    """Makes a prediction on a target image with a trained model and plots the image.
-
-    Args:
-        model (torch.nn.Module): trained PyTorch image classification model.
-        image_path (str): filepath to target image.
-        class_names (List[str], optional): different class names for target image. Defaults to None.
-        transform (_type_, optional): transform of target image. Defaults to None.
-        device (torch.device, optional): target device to compute on. Defaults to "cuda" if torch.cuda.is_available() else "cpu".
-    
-    Returns:
-        Matplotlib plot of target image and model prediction as title.
-
-    Example usage:
-        pred_and_plot_image(model=model,
-                            image="some_image.jpeg",
-                            class_names=["class_1", "class_2", "class_3"],
-                            transform=torchvision.transforms.ToTensor(),
-                            device=device)
-    """
-
-    # 1. Load in image and convert the tensor values to float32
-    target_image = torchvision.io.read_image(str(image_path)).type(torch.float32)
-
-    # 2. Divide the image pixel values by 255 to get them between [0, 1]
-    target_image = target_image / 255.0
-
-    # 3. Transform if necessary
-    if transform:
-        target_image = transform(target_image)
-
-    # 4. Make sure the model is on the target device
-    model.to(device)
-
-    # 5. Turn on model evaluation mode and inference mode
-    model.eval()
-    with torch.inference_mode():
-        # Add an extra dimension to the image
-        target_image = target_image.unsqueeze(dim=0)
-
-        # Make a prediction on image with an extra dimension and send it to the target device
-        target_image_pred = model(target_image.to(device))
-
-    # 6. Convert logits -> prediction probabilities (using torch.softmax() for multi-class classification)
-    target_image_pred_probs = torch.softmax(target_image_pred, dim=1)
-
-    # 7. Convert prediction probabilities -> prediction labels
-    target_image_pred_label = torch.argmax(target_image_pred_probs, dim=1)
-
-    # 8. Plot the image alongside the prediction and prediction probability
-    plt.imshow(
-        target_image.squeeze().permute(1, 2, 0)
-    )  # make sure it's the right size for matplotlib
-    if class_names:
-        title = f"Pred: {class_names[target_image_pred_label.cpu()]} | Prob: {target_image_pred_probs.max().cpu():.3f}"
-    else:
-        title = f"Pred: {target_image_pred_label} | Prob: {target_image_pred_probs.max().cpu():.3f}"
-    plt.title(title)
-    plt.axis(False)
-
-def set_seeds(seed: int=42):
-    """Sets random sets for torch operations.
-
-    Args:
-        seed (int, optional): Random seed to set. Defaults to 42.
-    """
-    # Set the seed for general torch operations
-    torch.manual_seed(seed)
-    # Set the seed for CUDA torch operations (ones that happen on the GPU)
-    torch.cuda.manual_seed(seed)
-
-def download_data(source: str, 
-                  destination: str,
-                  remove_source: bool = True) -> Path:
-    """Downloads a zipped dataset from source and unzips to destination.
-
-    Args:
-        source (str): A link to a zipped file containing data.
-        destination (str): A target directory to unzip data to.
-        remove_source (bool): Whether to remove the source after downloading and extracting.
-    
-    Returns:
-        pathlib.Path to downloaded data.
-    
-    Example usage:
-        download_data(source="https://github.com/mrdbourke/pytorch-deep-learning/raw/main/data/pizza_steak_sushi.zip",
-                      destination="pizza_steak_sushi")
-    """
-    # Setup path to data folder
-    data_path = Path("data/")
-    image_path = data_path / destination
-
-    # If the image folder doesn't exist, download it and prepare it... 
-    if image_path.is_dir():
-        print(f"[INFO] {image_path} directory exists, skipping download.")
-    else:
-        print(f"[INFO] Did not find {image_path} directory, creating one...")
-        image_path.mkdir(parents=True, exist_ok=True)
-        
-        # Download pizza, steak, sushi data
-        target_file = Path(source).name
-        with open(data_path / target_file, "wb") as f:
-            request = requests.get(source)
-            print(f"[INFO] Downloading {target_file} from {source}...")
-            f.write(request.content)
-
-        # Unzip pizza, steak, sushi data
-        with zipfile.ZipFile(data_path / target_file, "r") as zip_ref:
-            print(f"[INFO] Unzipping {target_file} data...") 
-            zip_ref.extractall(image_path)
-
-        # Remove .zip file
-        if remove_source:
-            os.remove(data_path / target_file)
-    
-    return image_path

helper/model_builder.py

@@ -1,56 +0,0 @@
-"""
-Contains PyTorch model code to instantiate a TinyVGG model.
-"""
-import torch
-from torch import nn 
-
-class TinyVGG(nn.Module):
-    """Creates the TinyVGG architecture.
-
-    Replicates the TinyVGG architecture from the CNN explainer website in PyTorch.
-    See the original architecture here: https://poloclub.github.io/cnn-explainer/
-
-    Args:
-    input_shape: An integer indicating number of input channels.
-    hidden_units: An integer indicating number of hidden units between layers.
-    output_shape: An integer indicating number of output units.
-    """
-    def __init__(self, input_shape: int, hidden_units: int, output_shape: int) -> None:
-        super().__init__()
-        self.conv_block_1 = nn.Sequential(
-          nn.Conv2d(in_channels=input_shape, 
-                    out_channels=hidden_units, 
-                    kernel_size=3, 
-                    stride=1, 
-                    padding=0),  
-          nn.ReLU(),
-          nn.Conv2d(in_channels=hidden_units, 
-                    out_channels=hidden_units,
-                    kernel_size=3,
-                    stride=1,
-                    padding=0),
-          nn.ReLU(),
-          nn.MaxPool2d(kernel_size=2,
-                        stride=2)
-        )
-        self.conv_block_2 = nn.Sequential(
-          nn.Conv2d(hidden_units, hidden_units, kernel_size=3, padding=0),
-          nn.ReLU(),
-          nn.Conv2d(hidden_units, hidden_units, kernel_size=3, padding=0),
-          nn.ReLU(),
-          nn.MaxPool2d(2)
-        )
-        self.classifier = nn.Sequential(
-          nn.Flatten(),
-          # Where did this in_features shape come from? 
-          # It's because each layer of our network compresses and changes the shape of our inputs data.
-          nn.Linear(in_features=hidden_units*13*13,
-                    out_features=output_shape)
-        )
-    
-    def forward(self, x: torch.Tensor):
-        x = self.conv_block_1(x)
-        x = self.conv_block_2(x)
-        x = self.classifier(x)
-        return x
-        # return self.classifier(self.block_2(self.block_1(x))) # <- leverage the benefits of operator fusion

helper/predictions.py

@@ -1,83 +0,0 @@
-"""
-Utility functions to make predictions.
-
-Main reference for code creation: https://www.learnpytorch.io/06_pytorch_transfer_learning/#6-make-predictions-on-images-from-the-test-set 
-"""
-import torch
-import torchvision
-from torchvision import transforms
-import matplotlib.pyplot as plt
-
-from typing import List, Tuple
-
-from PIL import Image
-
-# Set device
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-# Predict on a target image with a target model
-# Function created in: https://www.learnpytorch.io/06_pytorch_transfer_learning/#6-make-predictions-on-images-from-the-test-set
-def pred_and_plot_image(
-    model: torch.nn.Module,
-    class_names: List[str],
-    image_path: str,
-    image_size: Tuple[int, int] = (224, 224),
-    transform: torchvision.transforms = None,
-    device: torch.device = device,
-):
-    """Predicts on a target image with a target model.
-
-    Args:
-        model (torch.nn.Module): A trained (or untrained) PyTorch model to predict on an image.
-        class_names (List[str]): A list of target classes to map predictions to.
-        image_path (str): Filepath to target image to predict on.
-        image_size (Tuple[int, int], optional): Size to transform target image to. Defaults to (224, 224).
-        transform (torchvision.transforms, optional): Transform to perform on image. Defaults to None which uses ImageNet normalization.
-        device (torch.device, optional): Target device to perform prediction on. Defaults to device.
-    """
-
-    # Open image
-    img = Image.open(image_path)
-
-    # Create transformation for image (if one doesn't exist)
-    if transform is not None:
-        image_transform = transform
-    else:
-        image_transform = transforms.Compose(
-            [
-                transforms.Resize(image_size),
-                transforms.ToTensor(),
-                transforms.Normalize(
-                    mean=[0.485, 0.456, 0.406], std=[0.229, 0.224, 0.225]
-                ),
-            ]
-        )
-
-    ### Predict on image ###
-
-    # Make sure the model is on the target device
-    model.to(device)
-
-    # Turn on model evaluation mode and inference mode
-    model.eval()
-    with torch.inference_mode():
-        # Transform and add an extra dimension to image (model requires samples in [batch_size, color_channels, height, width])
-        transformed_image = image_transform(img).unsqueeze(dim=0)
-
-        # Make a prediction on image with an extra dimension and send it to the target device
-        target_image_pred = model(transformed_image.to(device))
-
-    # Convert logits -> prediction probabilities (using torch.softmax() for multi-class classification)
-    target_image_pred_probs = torch.softmax(target_image_pred, dim=1)
-
-    # Convert prediction probabilities -> prediction labels
-    target_image_pred_label = torch.argmax(target_image_pred_probs, dim=1)
-
-    # Plot image with predicted label and probability
-    plt.figure()
-    plt.imshow(img)
-    plt.title(
-        f"Pred: {class_names[target_image_pred_label]} | Prob: {target_image_pred_probs.max():.3f}"
-    )
-    plt.axis(False)
-

helper/train.py

@@ -1,62 +0,0 @@
-"""
-Trains a PyTorch image classification model using device-agnostic code.
-"""
-
-import os
-import torch
-import data_setup, engine, model_builder, utils
-
-from torchvision import transforms
-
-# Setup hyperparameters
-NUM_EPOCHS = 5
-BATCH_SIZE = 32
-HIDDEN_UNITS = 10
-LEARNING_RATE = 0.001
-
-# Setup directories
-train_dir = "data/pizza_steak_sushi/train"
-test_dir = "data/pizza_steak_sushi/test"
-
-# Setup target device
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
-# Create transforms
-data_transform = transforms.Compose([
-  transforms.Resize((64, 64)),
-  transforms.ToTensor()
-])
-
-# Create DataLoaders with help from data_setup.py
-train_dataloader, test_dataloader, class_names = data_setup.create_dataloaders(
-    train_dir=train_dir,
-    test_dir=test_dir,
-    transform=data_transform,
-    batch_size=BATCH_SIZE
-)
-
-# Create model with help from model_builder.py
-model = model_builder.TinyVGG(
-    input_shape=3,
-    hidden_units=HIDDEN_UNITS,
-    output_shape=len(class_names)
-).to(device)
-
-# Set loss and optimizer
-loss_fn = torch.nn.CrossEntropyLoss()
-optimizer = torch.optim.Adam(model.parameters(),
-                             lr=LEARNING_RATE)
-
-# Start training with help from engine.py
-engine.train(model=model,
-             train_dataloader=train_dataloader,
-             test_dataloader=test_dataloader,
-             loss_fn=loss_fn,
-             optimizer=optimizer,
-             epochs=NUM_EPOCHS,
-             device=device)
-
-# Save the model with help from utils.py
-utils.save_model(model=model,
-                 target_dir="models",
-                 model_name="05_going_modular_script_mode_tinyvgg_model.pth")

helper/utils.py

@@ -1,35 +0,0 @@
-"""
-Contains various utility functions for PyTorch model training and saving.
-"""
-import torch
-from pathlib import Path
-
-def save_model(model: torch.nn.Module,
-               target_dir: str,
-               model_name: str):
-    """Saves a PyTorch model to a target directory.
-
-    Args:
-    model: A target PyTorch model to save.
-    target_dir: A directory for saving the model to.
-    model_name: A filename for the saved model. Should include
-      either ".pth" or ".pt" as the file extension.
-
-    Example usage:
-    save_model(model=model_0,
-               target_dir="models",
-               model_name="05_going_modular_tingvgg_model.pth")
-    """
-    # Create target directory
-    target_dir_path = Path(target_dir)
-    target_dir_path.mkdir(parents=True,
-                        exist_ok=True)
-
-    # Create model save path
-    assert model_name.endswith(".pth") or model_name.endswith(".pt"), "model_name should end with '.pt' or '.pth'"
-    model_save_path = target_dir_path / model_name
-
-    # Save the model state_dict()
-    print(f"[INFO] Saving model to: {model_save_path}")
-    torch.save(obj=model.state_dict(),
-             f=model_save_path)

model.py

@@ -1,68 +0,0 @@
-import torch
-import torchvision
-from torch import nn
-from torchvision import transforms
-
-
-def create_model(num_classes: int = 32,
-                          seed: int = 42):
-    """Creates a feature extractor model and transforms.
-
-    Args:
-        num_classes (int, optional): number of classes in the classifier head.
-            Defaults to 32.
-        seed (int, optional): random seed value. Defaults to 42.
-
-    Returns:
-        model (torch.nn.Module): vit feature extractor model.
-        transforms (torchvision.transforms): vit image transforms.
-    """
-    IMG_SIZE = 28
-    model_transforms = transforms.Compose([
-        transforms.Resize((IMG_SIZE, IMG_SIZE)),
-        transforms.Grayscale(num_output_channels=1),
-        transforms.ToTensor()])
-
-        # Create a convolutional neural network
-    class Model(nn.Module):
-            def __init__(self, input_shape: int, hidden_units: int, output_shape: int):
-                super().__init__()
-                self.block_1 = nn.Sequential(
-                        nn.Conv2d(in_channels=input_shape,
-                                        out_channels=hidden_units,
-                                  kernel_size=3,  # how big is the square that's going over the image?
-                                  stride=1,  # default
-                                        padding=1),  # options = "valid" (no padding) or "same" (output has same shape as input) or int for specific number
-                    nn.ReLU(),
-                        nn.Conv2d(in_channels=hidden_units,
-                                  out_channels=hidden_units,
-                                  kernel_size=3,
-                                  stride=1,
-                                  padding=1),
-                    nn.ReLU(),
-                    nn.MaxPool2d(kernel_size=2,
-                                     stride=2)  # default stride value is same as kernel_size
-                )
-                self.block_2 = nn.Sequential(
-                    nn.Conv2d(hidden_units, hidden_units, 3, padding=1),
-                    nn.ReLU(),
-                    nn.Conv2d(hidden_units, hidden_units, 3, padding=1),
-                    nn.ReLU(),
-                    nn.MaxPool2d(2)
-                )
-                self.classifier = nn.Sequential(
-                    nn.Flatten(),
-                        nn.Linear(in_features=hidden_units*7*7,
-                                  out_features=output_shape)
-                )
-
-            def forward(self, x: torch.Tensor):
-                # x = self.block_1(x)
-                # print(x.shape)
-                # x = self.block_2(x)
-                # print(x.shape)
-                # x = self.classifier(x)
-                # print(x.shape)
-                x = self.classifier(self.block_2(self.block_1(x)))
-                return x
-    return Model, model_transforms

model/2model28.h5

@@ -1,3 +0,0 @@
-version https://git-lfs.github.com/spec/v1
-oid sha256:9ec76d2434f8cb24f08df038ecb93ca91b15db9110df2ba340488c24c123b64b
-size 14480208

solver.py

@@ -3,32 +3,25 @@ from PIL import ImageFont, ImageDraw, Image
 import cv2
 import numpy as np
 import os
-import model
 import src.solve as solve
 from typing import Tuple
 import pytesseract
 import re
 import shutil
-import torch
-import torch.nn as nn
-import torchvision
-from torchvision import transforms
-from model import create_model
 import tensorflow as tf
 from tensorflow import keras
+import random
 
 
-device = "cuda" if torch.cuda.is_available() else "cpu"
-
 # Setup class names
-with open("class_names.txt", "r") as f: # reading them in from class_names.txt
-    class_names = [names.strip() for names in  f.readlines()]
-
+with open("class_names.txt", "r") as f:  # reading them in from class_names.txt
+    class_names = [names.strip() for names in f.readlines()]
 
-model1 = tf.keras.models.load_model('model/model2.h5')
-model2 = tf.keras.models.load_model('model/model30.h5')
-model3 = tf.keras.models.load_model('model/model15.h5')
+model1 = tf.keras.models.load_model('model/model30.h5')
+model2 = tf.keras.models.load_model('model/model15.h5')
+model3 = tf.keras.models.load_model('model/model2.h5')
 
+palabras_1 = []
 # Borrar el directorio de imagenes
 folder = 'output'
 for filename in os.listdir(folder):
@@ -52,18 +45,25 @@ for filename in os.listdir(folder):
         print('Failed to delete %s. Reason: %s' % (file_path, e))
 
 
-def get_words(img) -> str:
-    print(type(img))
+def get_words(img):
+    #print(type(img))
 	# str to filepath
     img = Image.open(img)
 	# Display image
-    #img.show()
+    # img.show()
     text = pytesseract.image_to_string(img, lang="spa+eng", config="--psm 11")
     text = text.upper()
     text = re.split('\W+', text)
     text.pop()
+    #palabras_1 = text
+    #print(palabras_1)
+    # array to string text
+    text = ' '.join(text)
+    # add comma to text
+    text = text.replace(" ", ",")
     return text
 
+
 def getmat(listaCuadrados, filas, columnas):
     matrix = [[0 for i in range(columnas)] for j in range(filas)]
     matrixT = [[0 for i in range(columnas)] for j in range(filas)]
@@ -94,40 +94,50 @@ def get_colums_and_rows(listaCuadrados):
             columnas = columnas + 1
     return filas, columnas
 
+
 def read_board(img, words):
-    print(type(img))
+    #(type(img))
 	# str to filepath
     img = Image.open(img)
 	# Display image
     img.show()
-	#Print words
-    print("Palabras a buscar: ", words)
+	# Print words
+    #print("Palabras a buscar: ", palabras_1)
+
 
 def solve_puzzle(img, words):
-    #print(type(img))
+    # print(type(img))
 	# str to filepath
-    #img = Image.open(img)
+    #print(type(words))
+    #print(words)
+    # img = Image.open(img)
 	# Pil to opencv compatible
-    pil_image = Image.open(img).convert('RGB') 
-    open_cv_image = np.array(pil_image) 
-    # Convert RGB to BGR 
-    open_cv_image = open_cv_image[:, :, ::-1].copy() 
+    pil_image = Image.open(img).convert('RGB')
+    open_cv_image = np.array(pil_image)
+    # Convert RGB to BGR
+    open_cv_image = open_cv_image[:, :, ::-1].copy()
 	# Display image
-	#Print words
+	# Print words
     img = open_cv_image
-    print("Palabras a buscar: ", words)
+    # string to array
+    words = words.split(",")
+    # remove last ,
+    #print(words)
+
     imgc = img.copy()
     imgsol = img.copy()
-    imgc = cv2.cvtColor(imgc, cv2.COLOR_BGR2GRAY)
+    imgc = cv2.cvtColor(imgc, cv2.COLOR_RGB2GRAY)
     imgc = np.invert(imgc)
-    gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)
-    #blur = cv2.GaussianBlur(gray, (5, 5), 0)
+    gray = cv2.cvtColor(img, cv2.COLOR_RGB2GRAY)
+    blur = cv2.GaussianBlur(gray, (5, 5), 0)
 	# save the blurred image
-    #cv2.imwrite("output/blur.png", blur)
+    cv2.imwrite("output/blur.png", blur)
 	# display blurred image
-    threshten = cv2.threshold(gray, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
+    threshten = cv2.threshold(
+        blur, 0, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
     thresh = cv2.adaptiveThreshold(threshten, 255, 1, 1, 11, 2)
-    contours, hierarchy = cv2.findContours(thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
+    contours, hierarchy = cv2.findContours(
+        thresh, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE)
 	# Draw contours and save the image
 
     characters = np.array([
@@ -164,7 +174,6 @@ def solve_puzzle(img, words):
                 cv2.rectangle(img, (x0, y0), (x1, y1), (0, 255, 0), 2)
                 img2 = imgc[y0:y1, x0:x1]
                 img2 = cv2.resize(img2, (28, 28))
-                img2 = cv2.resize(img2,(28,28))
                 img_array = img2.reshape(1, 28, 28, 1)
                 prediction1 = np.argmax(model1.predict(img_array))
                 prediction2 = np.argmax(model2.predict(img_array))
@@ -175,11 +184,12 @@ def solve_puzzle(img, words):
                 elif  prediction1 == prediction2:
                    pred = prediction1
                 elif  prediction2 == prediction3:
-                    pred = prediction2
+                   pred = prediction2
                 elif  prediction1 == prediction3:
-                    pred = prediction3
+                   pred = prediction3
                 else:
                    pred = 32
+                #print(characters[pred])
                 contCuadrados["anchura"] = x
                 contCuadrados["altura"] = y
                 contCuadrados["centrox"] = (x + x + w)/2
@@ -191,20 +201,30 @@ def solve_puzzle(img, words):
                 draw.text(((x0+x1)/2, y0-10),
                           characters[pred], font=fnt, fill=(255, 0, 0, 0))
                 img = np.array(img_pil)
-                cv2.imwrite("output/"+str(i)+".png", img2)
+    #cv2.imwrite("output/Tablero_Labels.png", img)
     filas, columnas = get_colums_and_rows(listaCuadrados)
-
+    # print listaCuadrados
+    # print(listaCuadrados)
     matrix, matrixT = getmat(listaCuadrados, filas, columnas)
     palabrasxy = []
 
-
+    # print()
+    # print("Palabras a buscar:")
+    # for i in words:
+    #    print(i)
+    # print()
+    # for i in range(filas):
+    #     for j in range(columnas):
+    #        print(matrix[i][j], end = " ")
+    #     print()
+    # print()
+    # print()
     image_new = imgsol.copy()
     overlay = imgsol.copy()
-    import random
     index = 0
     index2 = 0
     for i in words:
-
+        #(i)
         xy_positionsvec, find = solve.find_word(matrix, i)
         if find:
             palabrasxy.append(xy_positionsvec)
@@ -212,8 +232,8 @@ def solve_puzzle(img, words):
             # print(len(xy_positionsvec))
             xy = xy_positionsvec[0]
             xy2 = xy_positionsvec[len(xy_positionsvec)-1]
-            #print(xy["x"], " ",xy["y"])
-            #print(xy2["x"], " ",xy2["y"])
+            # print(xy["x"], " ",xy["y"])
+            # print(xy2["x"], " ",xy2["y"])
             coordreal = matrixT[xy["x"]][xy["y"]]
             coordreal2 = matrixT[xy2["x"]][xy2["y"]]
             centrox = coordreal["centrox"]
@@ -232,11 +252,15 @@ def solve_puzzle(img, words):
             cv2.line(overlay2, (centrox, centroy), (centrox2, centroy2), color,
                      thickness=int(abs(coordreal["altura"] - coordreal["centroy"])*2))
             image_word = cv2.addWeighted(overlay2, 0.4, image_new, 1 - 0.4, 0)
-            cv2.imwrite("palabrasSopa/" + words[index2] + ".png", image_word)
+            cv2.imwrite("wordsPuzzle/" + words[index2] + ".jpg", image_word)
+            # append the image into a numpy array
+            
+            #print(words[index2])
     
             index += 1
         index2 += 1
     alpha = 0.4  # Transparency factor
     image_new = cv2.addWeighted(overlay, alpha, image_new, 1 - alpha, 0)
-    final = cv2.imwrite("output/Tablero_solucion.png", image_new)
-    return final
+    cv2.imwrite("output/Tablero_solucion.png", image_new)
+    # return the images in wordsPuzzle folder as numpy arrays
+    return image_new

src/solve.py

@@ -18,7 +18,7 @@ def find_word (wordsearch, word):
 			# Word foundf
 			return xy_positionsvec,True
 	# Word not found
-	print(word, ' No encontrada')
+	#print(word, ' No encontrada')
 	return xy_positionsvec,False
 
 def check_start (wordsearch, word, start_pos):
@@ -40,9 +40,9 @@ def check_dir (wordsearch, word, start_pos, dir):
 	while (chars_match(found_chars, word)):
 		if (len(found_chars) == len(word)):
 			# If found all characters and all characters found are correct, then word has been found
-			print('')
-			print(word, ' Encontrada en:')
-			print('')
+			#print('')
+			#print(word, ' Encontrada en:')
+			#print('')
 			# Draw wordsearch on command line. Display found characters and '-' everywhere else
 			index =1 
 			for x in range(0, len(wordsearch)):
@@ -68,8 +68,8 @@ def check_dir (wordsearch, word, start_pos, dir):
 					else:
 						line = line + " -"
 		
-				print(line)
-			print('')
+				#print(line)
+			#print('')
 			return True, xy_positionsvec
 		# Have not found enough letters so look at the next one
 		current_pos = [current_pos[0] + dir[0], current_pos[1] + dir[1]]