Update app.py

app.py

@@ -1,77 +1,26 @@
-from huggingface_hub import from_pretrained_keras
+import gradio as gr
+from transformers import AutoTokenizer, AutoModelForSeq2SeqLM
 
-# Assuming your model is a standard Keras model on Hugging Face Hub
-model = from_pretrained_keras("Bajiyo/Malayalam_transliteration")  # Replace with your model name
+# Model and Tokenizer Names (replace if needed)
+MODEL_NAME = "Bajiyo/Malayalam_transliteration"
+TOKENIZER_NAME = f"{MODEL_NAME}-vocab"
 
-def predict(text):
-  """
-  This function preprocesses the input text, makes predictions using the loaded model,
-  and returns the predictions.
-  """
-  # Preprocess the input text (tokenization, etc.) - Implement your pre-processing logic here
-  processed_text = preprocess_text(text)
-
-  # Make predictions using the model
-  predictions = model.predict(processed_text)
-
-  # Post-process predictions (optional)
-  # This might involve converting probabilities to classes, decoding sequences, etc.
-  # Implement your post-processing logic here
-  processed_predictions = postprocess_predictions(predictions)
-
-  return processed_predictions
-
-def preprocess_text(text):
-  """
-  This function implements your specific logic for pre-processing the input text.
-  You'll need to replace this with your actual pre-processing steps, which might include:
-
-  - Tokenization (converting text into numerical representations)
-  - Padding sequences to a fixed length
-  - Adding special tokens (e.g., start/end of sequence)
-
-  Here's an example structure (replace with your actual implementation):
-  """
-  # Import necessary libraries (e.g., tokenizers)
-  from transformers import AutoTokenizer
-
-  # Replace with your actual tokenizer name from Hugging Face Hub (if applicable)
-  tokenizer = AutoTokenizer.from_pretrained("Bajiyo/YourTokenizerName")  # Adjust based on your model
-
-  # Tokenize the text
-  tokenized_text = tokenizer(text, return_tensors="tf")  # Assuming TensorFlow backend
-
-  # Pad the sequence (if necessary)
-  # ... (implement padding logic)
+# Load the tokenizer and model
+tokenizer = AutoTokenizer.from_pretrained(TOKENIZER_NAME)
+model = AutoModelForSeq2SeqLM.from_pretrained(MODEL_NAME)
 
-  return tokenized_text
-
-def postprocess_predictions(predictions):
-  """
-  This function implements your specific logic for post-processing the model predictions.
-  You'll need to replace this with your actual post-processing steps, which might include:
-
-  - Converting probabilities to class labels (if applicable)
-  - Decoding predicted sequences (if applicable)
-  - Selecting the most likely prediction
-
-  Here's an example structure (replace with your actual implementation):
-  """
-  # Assuming predictions are probabilities for each class
-  predicted_class = np.argmax(predictions, axis=1)  # Get the index of the highest probability class
-
-  # You can further process the predicted class index here (e.g., convert to label name)
-
-  return predicted_class
-
-# Integrate the predict function into your Space UI (Streamlit or Gradio)
-# This part will depend on the specific framework you're using (Streamlit or Gradio)
-# Here's an example using Streamlit:
-
-import streamlit as st
-
-st.title("Malayalam Transliteration Model")
-text_input = st.text_input("Enter Malayalam text to transliterate:")
-if st.button("Predict"):
-  prediction = predict(text_input)
-  st.write("Transliterated English:", prediction)
+def predict(text):
+    input_ids = tokenizer.encode(text, return_tensors="pt")
+    outputs = model.generate(input_ids)
+    decoded_text = tokenizer.decode(outputs[0], skip_special_tokens=True)
+    return decoded_text
+
+interface = gr.Interface(
+    fn=predict,
+    inputs=gr.Textbox(label="Enter Malayalam Text"),
+    outputs=gr.Textbox(label="Predicted English Text"),
+    title="Malayalam to English Transliteration",
+    description="Enter Malayalam text in the box and click 'Predict' to get the English transliteration.",
+)
+
+interface.launch()