Create app.py

app.py

@@ -0,0 +1,113 @@
+import gradio as gr
+import numpy as np
+from tensorflow.keras.models import load_model, save_model
+from tensorflow.keras.preprocessing.sequence import pad_sequences
+from tensorflow.keras.preprocessing.text import tokenizer_from_json
+from tensorflow.keras.utils import to_categorical
+import json
+
+# Load the pre-trained model and tokenizer
+model = load_model("code_language_cnn.keras")  # Replace with your model path
+with open("tokenizer.json", "r") as f:
+    tokenizer_data = f.read()  # Read the JSON file as a string
+tokenizer = tokenizer_from_json(tokenizer_data)
+
+max_sequence_length = 500  # Adjust based on your model
+languages = ["C", "C++", "JAVA", "Python"]  # Replace with your language labels
+
+# Load or initialize feedback data
+try:
+    with open("feedback.json", "r") as f:
+        feedback_data = json.load(f)
+except FileNotFoundError:
+    feedback_data = []
+
+# Define the prediction function
+def predict_language(code_snippet):
+    seq = tokenizer.texts_to_sequences([code_snippet])
+    padded_seq = pad_sequences(seq, maxlen=max_sequence_length, padding='post', truncating='post')
+    predictions = model.predict(padded_seq)[0]
+    confidence_scores = {languages[i]: f"{predictions[i] * 100:.2f}%" for i in range(len(languages))}
+    predicted_language = languages[np.argmax(predictions)]
+    return predicted_language, confidence_scores
+
+# Feedback handling function
+def provide_feedback(code_snippet, predicted_language, feedback, correct_language=None):
+    global feedback_data
+
+    feedback_entry = {
+        "code": code_snippet,
+        "predicted_language": predicted_language,
+        "feedback": feedback,
+        "correct_language": correct_language if feedback == "Incorrect" else predicted_language
+    }
+    feedback_data.append(feedback_entry)
+
+    # Save feedback to file
+    with open("feedback.json", "w") as f:
+        json.dump(feedback_data, f, indent=4)
+
+    # If feedback is "Incorrect", retrain the model
+    if feedback == "Incorrect":
+        retrain_model(code_snippet, correct_language)
+
+    return "Thank you for your feedback!"
+
+# Retraining the model based on feedback
+def retrain_model():
+    global model
+    # Prepare the feedback data (new training data)
+    if feedback_data.count("Incorrect") < 10: # Minimum 10 incorrect feedbacks required to retrain
+        return
+    feedback_texts = [entry["code"] for entry in feedback_data]
+    feedback_labels = [entry["correct_language"] for entry in feedback_data]
+
+    # Tokenize and pad the new data
+    seq = tokenizer.texts_to_sequences(feedback_texts)
+    padded_seq = pad_sequences(seq, maxlen=max_sequence_length, padding='post', truncating='post')
+
+    # Convert labels to categorical (one-hot encoding)
+    labels = [languages.index(lang) for lang in feedback_labels]
+    labels = to_categorical(labels, num_classes=len(languages))
+
+    # Retrain the model
+    model.fit(padded_seq, labels, epochs=2, batch_size=32, verbose=1)
+    feedback_data = []  # Clear the feedback data after retraining
+    # Save the retrained model
+    # model.save("code_language_cnn_retrained.keras")
+    print("Model retrained")
+
+# Define Gradio components
+def interface_func(code_snippet):
+    predicted_language, confidence_scores = predict_language(code_snippet)
+    return predicted_language, confidence_scores
+
+# Build Gradio interface
+with gr.Blocks() as demo:
+    gr.Markdown("### Programming Language Detection with Feedback")
+    code_input = gr.Textbox(label="Enter Code Snippet")
+    predict_button = gr.Button("Predict")
+    predicted_label = gr.Label(label="Predicted Language")
+    confidence_output = gr.JSON(label="Confidence Scores")
+
+    feedback_dropdown = gr.Radio(["Correct", "Incorrect"], label="Was the prediction correct?")
+    correct_language_dropdown = gr.Dropdown(languages, label="If incorrect, select the correct language (optional)")
+    feedback_button = gr.Button("Submit Feedback")
+    feedback_message = gr.Label(label="Feedback Status")
+
+    # Prediction workflow
+    predict_button.click(
+        interface_func,
+        inputs=[code_input],
+        outputs=[predicted_label, confidence_output]
+    )
+
+    # Feedback workflow
+    feedback_button.click(
+        provide_feedback,
+        inputs=[code_input, predicted_label, feedback_dropdown, correct_language_dropdown],
+        outputs=[feedback_message]
+    )
+
+# Launch the interface
+demo.launch(share=True)