fast_api.py

import whisper
from fastapi import FastAPI, UploadFile, File, Form
from pydantic import BaseModel
import gensim.downloader as api
from gensim.models import KeyedVectors
import torch
import pickle
import numpy as np
from gensim.models import KeyedVectors

def load_whisper_model(model_path, device='cpu'):
    # Load model architecture
    model = whisper.model.Whisper(
        whisper.model.ModelDimensions(
            n_mels=80,
            n_audio_ctx=1500,
            n_audio_state=384,
            n_audio_head=6,
            n_audio_layer=4,
            n_vocab=51865,
            n_text_ctx=448,
            n_text_state=384,
            n_text_head=6,
            n_text_layer=4
        )
    )
    
    # Load state dict
    state_dict = torch.load(model_path, map_location=device)
    model.load_state_dict(state_dict)
    model.eval()
    return model
    
# Load the saved Word2Vec model
word2vec_model = KeyedVectors.load("word2vec-google-news-300.model")
model = load_whisper_model("whisper_tiny_model.pt")

def load_model(pickle_file_path: str):
    """Load a model from a pickle file."""
    with open(pickle_file_path, 'rb') as file:
        model = pickle.load(file)
    return model

pronunciation_fluency_model = load_model("pronunciation_fluency_v2.pkl")

app = FastAPI()

def transcribe(audio_file_path: str, model):
    # Load audio and run inference
    result = model.transcribe(audio_file_path)
    return result["text"]

@app.post("/transcribe")
async def transcribe_audio(file: UploadFile = File(...)):

    # SAVE THE UPLOAD FILE TEMPORARILY
    with open(file.filename, "wb") as buffer:

        buffer.write(await file.read())

    # TRANSCRIBE THE AUDIO
    transcription = transcribe(file.filename, model)

    return { "transcription" : transcription }


def Get_P_F_Score( transcription : str ):
    words = transcription.split()

    cumulative_vector_representation = [0] * 300
    for word in words:
        if word in word2vec_model:
            cumulative_vector_representation += word2vec_model[word]

    print( cumulative_vector_representation[ 0 : 5] )

    print( len( cumulative_vector_representation) )

    if np.any(np.isnan(cumulative_vector_representation)):
        print("Input contains NaN values, handle missing values before prediction.")


    print("\n\n")

    output = pronunciation_fluency_model.predict( [ cumulative_vector_representation] )

    print( output )

    return output


def get_average_vector(sentence):
    # TOKENIZE THE SENTENCE INTO WORDS
    words = sentence.lower().split()

    # FILTER OUT WORDS NOT IN THE WORD2VEC VOCABULARY
    valid_words = [word for word in words if word in word2vec_model]

    # RETURN ZERO VECTOR IF NO VALID WORDS FOUND
    if not valid_words:
        return np.zeros(word2vec_model.vector_size)

    # COMPUTE AVERAGE VECTOR FOR VALID WORDS
    return np.mean([word2vec_model[word] for word in valid_words], axis=0)

from sklearn.metrics.pairwise import cosine_similarity

def get_similarity_score(topic, transcription ):
    # GET AVERAGE VECTORS FOR BOTH STRINGS
    topic_vector = get_average_vector(topic)
    transcription_vector = get_average_vector(transcription)

    print("topic vector: " , topic_vector)

    print(" transcription vector: " , transcription_vector )

    # RESHAPE VECTORS FOR COSINE SIMILARITY
    topic_vector = topic_vector.reshape(1, -1)
    transcription_vector = transcription_vector.reshape(1, -1)

    print(" reshaping done ")

    # COMPUTE COSINE SIMILARITY
    similarity = cosine_similarity(topic_vector, transcription_vector)

    print(" Similarity: " , similarity )

    output = similarity[ 0 ][ 0 ]

    output = max( output , 0 )

    output = min( 100 , output )

    # RETURN SIMILARITY SCORE (IT'S A SINGLE VALUE)
    return output



@app.post("/pronunciation_fluency_score")

async def pronunciation_fluency_scoring(
    file: UploadFile = File(...),
    topic: str = File(...)
):
    # SAVE THE UPLOAD FILE TEMPORARILY
    with open(file.filename, "wb") as buffer:

        buffer.write(await file.read())

    # TRANSCRIBE THE AUDIO
    transcription = transcribe(file.filename, model)

    pronunciation_fluency_score = Get_P_F_Score( transcription )

    print( pronunciation_fluency_score)

    print( type( pronunciation_fluency_score ) )

    content_score = get_similarity_score( topic , transcription) * 100




    return {

        "pronunciation score" : pronunciation_fluency_score[ 0 ][ 0 ] * 10 ,
        "fluency score" : pronunciation_fluency_score[ 0 ][ 1 ] * 10 ,
        "content score" : content_score
    }



import string
import asyncio
import re
from textblob import TextBlob
import nltk

def is_valid_summary_format(summary: str) -> bool:
    # CHECK IF THE SUMMARY CONTAINS ONLY BULLET POINTS
    if '-' in summary or '*' in summary:
        return True

    # CHECK IF THE SUMMARY CONSISTS ONLY OF VERY SHORT SENTENCES
    sentences = re.split(r'[.!?]', summary)
    short_sentences = sum(len(sentence.split()) <= 70 for sentence in sentences if sentence.strip())

    print(" Short Sentences: " , short_sentences )

    # CONSIDER IT A VALID FORMAT IF MORE THAN HALF OF THE SENTENCES ARE SHORT
    return short_sentences >= len(sentences) / 2

def form_score_summary(summary: str) -> float:
    # CONVERT THE SUMMARY TO UPPERCASE
    summary_upper = summary.upper()

    # REMOVE PUNCTUATION
    summary_clean = re.sub(r'[^\w\s]', '', summary_upper)

    # COUNT THE NUMBER OF WORDS
    word_count = len(summary_clean.split())

    # CHECK IF THE SUMMARY FORMAT IS VALID
    valid_format = is_valid_summary_format(summary)

    print("\n\n word count: ", word_count, " valid_format: ", valid_format)

    # CALCULATE SCORE BASED ON WORD COUNT AND FORMAT
    if valid_format:
        if 45 <= word_count <= 75:
            if word_count < 50:
                score = 50 + (word_count - 45) * (50 / 5)  # Gradual increase from 50
            elif word_count <= 75:
                score = 100  # Best score range
            else:
                score = 100 - (word_count - 70) * (50 / 5)  # Gradual decrease from 100
        else:
            score = 0  # Worst score if word count is out of acceptable range
    else:
        score = 0  # Worst score if format is invalid

    # CLAMP SCORE BETWEEN 0 AND 100

    score = float( score )

    return max(0.0, min(100.0, score))




def grammar_score(text: str) -> int:
    # Create a TextBlob object
    blob = TextBlob(text)

    # Check for grammatical errors
    errors = 0
    for sentence in blob.sentences:
        if sentence.correct() != sentence:
            errors += 1

    print(" \n\n Number of grammatical errors: " , errors )

    errors *= 5

    result = 100 - errors

    return max( 0 , result)


def vocabulary_score(text: str) -> float:

    print(" Performing vocabulary score \n\n")

    # Create a TextBlob object
    blob = TextBlob(text)

    # Extract words from the text
    words = blob.words

    # Count the total words and correctly spelled words
    total_words = len(words)
    correctly_spelled = sum(1 for word in words if word == TextBlob(word).correct())

    # Calculate the percentage of correctly spelled words
    if total_words == 0:
        return 0.0  # Avoid division by zero if there are no words

    percentage_correct = (correctly_spelled / total_words) * 100

    percentage_correct = min( percentage_correct , 100)
    percentage_correct = max( 0 , percentage_correct )

    percentage_correct = round( percentage_correct , 2 )


    print(" Percentage Correct: " , percentage_correct )


    return percentage_correct


@app.post("/summarization_scoring/")
def summarization_score( essay : str = Form() , summarization : str = Form() ):

    content_score_result, form_score_result, grammar_score_result, vocabulary_score_result = (
        float( get_similarity_score(essay, summarization) ) * 100,
        float( form_score_summary(summarization) ),
        float( grammar_score(summarization) ),
        float( vocabulary_score(summarization) )
    )

    print(" Completed \n\n\n ")

    response  = {

        "Content Score: " : content_score_result ,
        "Form Score: " : form_score_result  ,
        "Grammar Score: " : grammar_score_result ,
        "Vocabulary Score: " : vocabulary_score_result ,
        "Overall Summarization Score: " : round( (content_score_result + form_score_result + grammar_score_result + vocabulary_score_result) / 4 , 2)
    }

    print( response )

    return response



'''
transitional words can significantly contribute to the development, structure, and coherence of a text.

    Development: Transitional words help to show how ideas build upon each other and progress
        throughout the essay. They can introduce new points, provide examples, or signal a shift in focus.

    Structure: Transitional words help to organize the text by indicating relationships between
        ideas. They can show cause and effect, compare and contrast, or signal a sequence of events.

    Coherence: Transitional words help to create a smooth flow between sentences and paragraphs,
        making the text easier to understand and follow. They can clarify connections between
        ideas and prevent the text from feeling disjointed.
'''


addition_transitional_words = [
    "and", "also", "too", "in addition", "furthermore", "moreover", "besides", "likewise",
    "similarly", "equally important", "not to mention", "as well as", "what's more",
    "on top of that", "to boot", "in the same way", "by the same token", "similarly",
    "likewise", "in a similar vein", "correspondingly", "at the same time", "concurrently",
    "simultaneously", "not only... but also", "both... and", "as well", "and then",
    "and so forth", "and so on"
]
contrast_transitional_words = [
    "but", "however", "nevertheless", "nonetheless", "on the other hand", "on the contrary",
    "in contrast", "conversely", "although", "though", "even though", "despite", "in spite of",
    "regardless of", "while", "whereas", "yet", "still", "even so", "even if", "at the same time",
    "by the same token", "equally", "in common", "similarly", "just like", "just as", "as well as",
    "resemble", "equally", "in common", "by the same token"
]
cause_effect_transitional_words = [
    "because", "since", "as", "due to", "owing to", "thanks to", "on account of",
    "as a result", "consequently", "therefore", "hence", "thus", "so", "accordingly",
    "for this reason", "as a consequence", "in consequence", "in that case",
    "that being the case", "for that reason", "as a result of", "because of",
    "on account of", "owing to", "due to", "thanks to"
]
time_transitional_words = [
    "first", "second", "third", "next", "then", "after", "before", "later", "earlier",
    "previously", "subsequently", "following", "meanwhile", "simultaneously",
    "at the same time", "concurrently", "in the meantime", "in the interim", "afterwards",
    "thereafter", "finally", "lastly", "ultimately", "in conclusion", "to conclude",
    "in summary", "to sum up"
]
emphasis_transitional_words = [
    "indeed", "in fact", "certainly", "assuredly", "without a doubt", "undoubtedly",
    "unquestionably", "undeniably", "absolutely", "positively", "emphatically",
    "decisively", "strongly", "forcefully", "with conviction", "with certainty",
    "with assurance", "without hesitation", "without question", "without fail", "without doubt"
]
example_transitional_words = [
    "for example", "for instance", "such as", "like", "as an illustration", "to illustrate",
    "to demonstrate", "to exemplify", "namely", "specifically", "in particular",
    "particularly", "especially"
]
conclusion_transitional_words = [
    "in conclusion", "to conclude", "in summary", "to sum up", "finally", "lastly",
    "ultimately", "therefore", "hence", "thus", "so", "accordingly", "as a result",
    "consequently"
]
transition_between_sections_transitional_words = [
    "in the following section", "moving on to", "now", "let's explore",
    "turning our attention to", "to delve deeper", "we will now examine",
    "next", "at this point", "at this juncture", "furthermore", "moreover",
    "in addition"
]
miscellaneous_transition_words_list = [
    # Clarification
    "in other words", "that is to say", "namely", "to put it another way",
    "in simpler terms", "to clarify", "to explain further", "to elaborate",
    "to be more specific", "to be more exact",

    # Concession
    "admittedly", "granted", "of course", "naturally", "it is true that",
    "it must be admitted that", "it cannot be denied that", "it goes without saying that",

    # Digression
    "by the way", "incidentally", "aside from that", "apart from that",

    # Repetition
    "again", "once again", "still", "further", "furthermore", "moreover", "in addition"
]
contrast_within_sentence_transitional_words = [
    "but", "however", "nevertheless", "nonetheless", "on the other hand",
    "in contrast", "conversely", "although", "though", "even though",
    "despite", "in spite of", "regardless of", "while", "whereas",
    "yet", "still", "even so", "even if"
]
comparison_transitional_words = [
    "similarly", "likewise", "in the same way", "equally", "in common",
    "by the same token", "just like", "just as", "as well as", "resemble"
]
cause_and_effect_within_sentence_transitional_words = [
    "because", "since", "as", "due to", "owing to", "thanks to",
    "on account of", "as a result", "consequently", "therefore",
    "hence", "thus", "so", "accordingly", "for this reason",
    "as a consequence", "in consequence", "in that case",
    "that being the case", "for that reason", "as a result of",
    "because of", "on account of", "owing to", "due to", "thanks to"
]
emphasis_within_sentence_transitional_words = [
    "indeed", "in fact", "certainly", "assuredly", "without a doubt",
    "undoubtedly", "unquestionably", "undeniably", "absolutely",
    "positively", "emphatically", "decisively", "strongly", "forcefully",
    "with conviction", "with certainty", "with assurance",
    "without hesitation", "without question", "without fail", "without doubt"
]
concession_digression_repetition_transitional_words = [
    # Concession
    "admittedly", "granted", "of course", "naturally",
    "it is true that", "it must be admitted that",
    "it cannot be denied that", "it goes without saying that",

    # Digression
    "by the way", "incidentally", "aside from that",
    "apart from that",

    # Repetition
    "again", "once again", "still", "further",
    "furthermore", "moreover", "in addition"
]

def dsc_score( essay: str ):
    # Normalize the essay
    essay_lower = essay.lower()

    # Helper function to count occurrences of transitional words
    def count_transitional_words(word_list):
        return sum(essay_lower.count(word) for word in word_list)

    # Calculate counts for each type of transitional word list
    addition_count = count_transitional_words(addition_transitional_words)
    contrast_count = count_transitional_words(contrast_transitional_words)
    cause_effect_count = count_transitional_words(cause_effect_transitional_words)
    time_count = count_transitional_words(time_transitional_words)
    emphasis_count = count_transitional_words(emphasis_transitional_words)
    example_count = count_transitional_words(example_transitional_words)
    conclusion_count = count_transitional_words(conclusion_transitional_words)
    transition_between_sections_count = count_transitional_words(transition_between_sections_transitional_words)
    misc_count = count_transitional_words(miscellaneous_transition_words_list)
    contrast_within_sentence_count = count_transitional_words(contrast_within_sentence_transitional_words)
    comparison_count = count_transitional_words(comparison_transitional_words)
    cause_and_effect_within_sentence_count = count_transitional_words(cause_and_effect_within_sentence_transitional_words)
    emphasis_within_sentence_count = count_transitional_words(emphasis_within_sentence_transitional_words)
    concession_digression_repetition_count = count_transitional_words(concession_digression_repetition_transitional_words)

    # Calculate total transitional word count
    total_transitional_count = (
        addition_count + contrast_count + cause_effect_count + time_count +
        emphasis_count + example_count + conclusion_count +
        transition_between_sections_count + misc_count +
        contrast_within_sentence_count + comparison_count +
        cause_and_effect_within_sentence_count + emphasis_within_sentence_count +
        concession_digression_repetition_count
    )

    print("\n\n\n Total Transitional Words Count: " , total_transitional_count )

    words = essay.split()
    word_count = len(words)

    transitional_words_percentage = round( (  total_transitional_count / ( word_count * 1.00)  ) * 100  , 2 )

    print("]n\n\n transitional_words_percentage: " , transitional_words_percentage)

    '''
    Since a transition_words_percentage of 10% is considered as the ideal percentage of transitional words in an essay,
    we are deducting points with respect to how much is it deviating from its ideal percentage value.

    This have proven to be powerful to determine the Development, Structure and Coherence in essays

    '''
    return 100 - abs( transitional_words_percentage - 10 )


def is_capitalized(text: str) -> bool:
    """Check if the entire text is in capital letters."""
    return text.isupper()

def contains_punctuation(text: str) -> bool:
    """Check if the text contains any punctuation."""
    return bool(re.search(r'[.,!?;:]', text))

def is_bullet_points(text: str) -> bool:
    """Check if the text consists only of bullet points or very short sentences."""
    sentences = text.split('\n')
    bullet_points = any(line.strip().startswith('-') for line in sentences)
    short_sentences = sum(len(sentence.split()) <= 2 for sentence in sentences if sentence.strip())
    return bullet_points or short_sentences > len(sentences) / 2


def form_score_essay(essay: str) -> float:
    # REMOVE PUNCTUATION AND COUNT WORDS
    word_count = len(re.findall(r'\b\w+\b', essay))

    # CHECK ESSAY FORMAT
    is_capital = is_capitalized(essay)
    has_punctuation = contains_punctuation(essay)
    bullet_points_or_short = is_bullet_points(essay)

    # CALCULATE SCORE
    if 200 <= word_count <= 300 and has_punctuation and not is_capital and not bullet_points_or_short:
        score = 100.0  # BEST SCORE
    elif (120 <= word_count <= 199 or 301 <= word_count <= 380) and has_punctuation and not is_capital and not bullet_points_or_short:
        score = 50.0  # AVERAGE SCORE
    else:
        score = 0.0  # WORST SCORE

    return score


@app.post("/essay_scoring/")
async def essay_score( prompt : str = Form() , essay : str = Form() ):
    content_score_result, form_score_result, dsc_score_result, grammar_score_result = (
        float( get_similarity_score( prompt , essay ) ) * 100,
        float( form_score_essay( essay ) ),
        float( dsc_score( essay ) ),
        float( grammar_score( essay ) )
    )

    print( essay )

    return {

        "Content Score: " : content_score_result,
        "Form Score: " : form_score_result,
        "DSC Score: " : dsc_score_result,
        "Grammar Score: " : grammar_score_result,
        "Overall Essay Score" : ( content_score_result + form_score_result + dsc_score_result + grammar_score_result) / 4.0
    }