app.py

# HuggingFace Spaces file to run a Gradio Interface for the ALBERT v2 Steam Review Constructiveness Classifier by Samuel Ruairí Bullard

# Package Imports
import gradio as gr
from transformers import pipeline
import torch

# Checks if CUDA is available on the machine
print("CUDA Available: ", torch.cuda.is_available())

# if not os.path.isfile("./README.md"):
# !git clone https://huggingface.co/spaces/abullard1/albert-v2-steam-review-constructiveness-classifier

# Sets the torch dtype to 16-bit half-precision floating-point format if CUDA is available, otherwise sets it to 32-bit single-precision floating-point format. (Available for GPUs with Tensor Cores like NVIDIA's Volta, Turing, Ampere Architectures have for example)
device = 0 if torch.cuda.is_available() else -1
torch_d_type = torch.float16 if torch.cuda.is_available() else torch.float32
print(f"Device: {device}")

# Defines the name of the base model, the classifier was fine-tuned from
base_model_name = "albert-base-v2"

# Defines the name of the fine-tuned model used for the steam-review constructiveness classification
finetuned_model_name = "abullard1/albert-v2-steam-review-constructiveness-classifier"

# PyTorch classifier pipeline
classifier = pipeline(
    task="text-classification",  # Defines the task
    model=finetuned_model_name,  # Defines the fine-tuned model to use
    tokenizer=base_model_name,  # Defines the tokenizer to use (same as the base model)
    device=device,  # Defines the device the classification will be run on
    top_k=None,  # Returns all scores for all labels, not just the one with the highest score
    truncation=True,  # Truncates the input text if it exceeds the maximum length
    max_length=512,  # Defines the maximum length of the input text (512 for BERT. Explicitly set here)
    torch_dtype=torch_d_type
    # Sets the torch dtype to 16-bit half-precision floating-point format if CUDA is available, otherwise sets it to 32-bit single-precision floating-point format
)


# Extracts the labels and scores from the prediction result
def classify_steam_review(input_text):
    result = classifier(input_text)

    label_1, label_2 = result[0][0]["label"], result[0][1]["label"]
    score_1, score_2 = result[0][0]["score"], result[0][1]["score"]

    return {"label_1": label_1, "score_1": score_1, "label_2": label_2, "score_2": score_2}


# Provides a textual representation of the classification result
def get_steam_review_classification_result_text(label_1, score_1, label_2, score_2):
    # Maps label values to constructiveness
    def label_to_constructiveness(label):
        return "Constructive" if label == "LABEL_1" else "Not Constructive"

    # Formats the output in a readable format
    def format_output(label, score, emoji):
        return f'{label_to_constructiveness(label)} with a score of {score}. {emoji}'

    # Determines the label and score with the highest score
    if score_1 >= score_2:
        return format_output(label_1, score_1, "👍🏻")
    else:
        return format_output(label_2, score_2, "👎🏻")


# Examples Steam Reviews to display in the Gradio Interface using the "examples" parameter
examples = [
    [
        "Review: I think this is a great game but it still has some room for improvement., Playtime: 12, Voted Up: True, Upvotes: 1, Votes Funny: 0"],
    ["Review: Trash game. Deleted., Playtime: 1, Voted Up: False, Upvotes: 0, Votes Funny: 0"],
    ["Review: This game is amazing., Playtime: 100, Voted Up: True, Upvotes: 1, Votes Funny: 0"],
    ["Review: Great game, but the community is toxic., Playtime: 50, Voted Up: True, Upvotes: 1, Votes Funny: 0"]
]

# HTML article to display in the Gradio Interface using the "article" parameter
article = (
    """
    *Format your input as follows for the best results: **Review**: {review_text}, **Playtime**: {author_playtime_at_review}, **Voted Up**: {voted_up}, **Upvotes**: {upvotes}, **Votes Funny**: {votes_funny}.*
    """
)

# Main Gradio Interface using Gradio Blocks
# Docs: https://www.gradio.app/docs/gradio/blocks
with gr.Blocks() as steam_reviews_classifier_block:
    gr.Markdown("## Steam Review Constructiveness Classifier")
    gr.Markdown(article)

    # Main Column
    with gr.Column():
        # Upper Row (Input Textbox, Constructive Label, Not Constructive Label)
        with gr.Row(equal_height=True):
            # Input Textbox Column
            with gr.Column():
                input_textbox = gr.Textbox(
                    lines=8,
                    label="Steam Review",
                    # info="Input Steam Review here",
                    placeholder="Review: I think this is a great game but it still has some room for improvement., Playtime: 12, Voted Up: True, Upvotes: 1, Votes Funny: 0",
                    show_copy_button=False,
                    value="Review: I think this is a great game but it still has some room for improvement., Playtime: 12, Voted Up: True, Upvotes: 1, Votes Funny: 0"
                )

            # Constructive and Not Constructive Labels Column
            with gr.Column():
                constructive_label = gr.Label(label="Constructive")
                not_constructive_label = gr.Label(label="Not Constructive")

        # Examples Component
        example_component = gr.Examples(
            examples=examples,
            inputs=input_textbox
        )

        # Output Textbox which shows the textual representation of the Constructiveness Prediction
        output_textbox = gr.Textbox(
            label="Constructiveness Prediction",
            interactive=False,
            show_copy_button=False,
            # info="Textual representation of the Constructiveness Prediction"
        )

        # Submit Button
        submit_button = gr.Button(value="Submit")

    # Function to run when the Submit Button is clicked (Passes the input text to the classifier and displays the output text)
    def on_submit_click(input_text):
        classification_result = classify_steam_review(input_text)
        classification_result_text = get_steam_review_classification_result_text(
            label_1=classification_result["label_1"],
            score_1=classification_result["score_1"],
            label_2=classification_result["label_2"],
            score_2=classification_result["score_2"]
        )
        output_text = classification_result_text
        constructive, not_constructive = str(classification_result["score_1"]), str(classification_result["score_2"])
        return output_text, constructive, not_constructive


    # onClick event for the Submit Button
    submit_button.click(
        fn=on_submit_click,
        inputs=input_textbox,
        outputs=[output_textbox, not_constructive_label, constructive_label]
    )

# Launches the Gradio Blocks Interface
steam_reviews_classifier_block.launch()