Create app.py

app.py

@@ -1,44 +1,133 @@
-import os
+import gradio as gr
+import json
+import requests
+
+import torch
+import torchvision
+import torchvision.models as models
+
+from torchvision import datasets, transforms
+from torchvision.models import mobilenet_v2
+from torch import nn, optim
+from torch.utils.data import DataLoader, TensorDataset
+
+from tqdm.auto import tqdm
+from jcopdl.callback import Callback, set_config
+
+import pandas as pd
+import numpy as np
+device = torch.device("cuda:0" if torch.cuda.is_available() else "cpu")
+device
+
+
 import openai
-import sys
+import os
+import time
+from pathlib import Path
 
-import gradio as gr
-from langchain import OpenAI, PromptTemplate
-from langchain.text_splitter import CharacterTextSplitter
-from langchain.chains.summarize import load_summarize_chain
-from langchain.document_loaders import PyPDFLoader
-from langchain.chains import RetrievalQA
+from PIL import Image
+import io
+import cv2
+
+torch.manual_seed(0)
+
+class CustomMobileNetv2(nn.Module):
+    def __init__(self, output_size):
+        super().__init__()
+        self.mnet = mobilenet_v2(pretrained=True)
+        self.freeze()
+
+        self.mnet.classifier = nn.Sequential(
+            nn.Linear(1280, output_size),
+            nn.LogSoftmax()
+            )
+
+    def forward(self, x):
+        return self.mnet(x)
+
+    def freeze(self):
+        for param in self.mnet.parameters():
+            param.requires_grad = False
+
+    def unfreeze(self):
+        for param in self.mnet.parameters():
+            param.requires_grad = True
+
+kue_lokal_model = torch.load('rickyig_mobilenetv2_kue_lokal_classifier_entire_model.pth', map_location=torch.device('cpu'))
+
+dict_for_inference = {0: 'kue dadar gulung',
+                      1: 'kue kastengel',
+                      2: 'kue klepon',
+                      3: 'kue lapis',
+                      4: 'kue lumpur',
+                      5: 'kue putri salju',
+                      6: 'kue risoles',
+                      7: 'kue serabi'}
+
+def get_completion(prompt, model="gpt-3.5-turbo"):
+    messages = [{"role": "user", "content": prompt}]
+    response = openai.ChatCompletion.create(
+        model=model,
+        messages=messages,
+        temperature=0,
+        )
+    return response.choices[0].message["content"]
+
+def get_response(classify_result):
+    prompt = "Apa itu {} dan sebutkan resep dari {}.".format(classify_result, classify_result)
+    response = get_completion(prompt)
+    return response
+
+def classify_image(input_image):
+    
+    kue_lokal_model.eval()
+
+    image_for_testing = input_image
+    img = Image.open(image_for_testing)
+
+    transform = transforms.Compose([
+        transforms.Resize((224, 224)),
+        transforms.ToTensor(),
+    ])
+
+    input_data = transform(img).unsqueeze(0).to(device='cpu')
 
-sys.path.append('../..')
+    class_to_label = dict_for_inference
 
-from dotenv import load_dotenv, find_dotenv
-_ = load_dotenv(find_dotenv()) # read local .env file
+    with torch.no_grad():
+        output = kue_lokal_model(input_data)
+        probs = torch.nn.functional.softmax(output, dim=1)
+    conf, predicted_class = torch.max(probs, 1)
 
-openai.api_key  = os.environ['OPENAI_API_KEY']
+    # Create a dictionary of class labels and their probabilities
+    output_dict = {"predicted_label": class_to_label[predicted_class.item()], "probability": conf.item()}
 
-llm = OpenAI(temperature=0)
-text_splitter = CharacterTextSplitter()
+    # Convert the dictionary to JSON format
+    output_json = json.dumps(output_dict)
+    output_bentuk_text = "Hasil Klasifikasi Gambar \nKue : {} \nProbability: {:.2f}%".format(class_to_label[predicted_class.item()], conf.item()*100)
+    output_response = get_response(class_to_label[predicted_class.item()])
 
-def summarize_pdf(pdf_file):
-    pdf_file = pdf_file.name
-    loader = PyPDFLoader(pdf_file)
-    docs = loader.load_and_split()
-    chain = load_summarize_chain(llm, chain_type="map_reduce")
-    summary = chain.run(docs)
-    return summary
+    return output_json, output_bentuk_text, output_response
 
-def main():
-    output_summary = gr.Textbox(label="Summary")
+# Create a Gradio interface
+input_image = gr.Image(label="input_image", type="filepath")
+output_json = gr.JSON(label="Output (JSON)")
+output_bentuk_text = gr.Textbox(label="Hasil Output")
+output_response = gr.Textbox(label="Resep Kue")
+example_input_image = "3.jpg"
 
-    iface = gr.Interface(
-        fn=summarize_pdf,
-        inputs=["file"],
-        outputs=[output_summary],
-        title="PDF Summarizer",
-        description="Langchain based summarization application that's given a PDF file, then create a summary of the text content. <br> Enter the PDF file and get its summary.",
-    )
+interface = gr.Interface(
+    fn=classify_image,
+    inputs=input_image,
+    outputs=[output_json, output_bentuk_text, output_response],  # Use JSON output
+    title="Resep Kue Lokal",
+    examples=[
+        [example_input_image]
+    ],
+    description="Unggah foto kue lokal dan dapatkan hasil klasifikasi gambar beserta resep kue.<br>Kue yang tersedia: kue dadar gulung, kue kastengel, kue klepon, kue lapis, kue lumpur, kue putri salju, kue risoles, kue serabi.",
+)
 
-    iface.launch(share=True)
+# Start the Gradio app
+interface.launch(share=True, debug=True)
 
-if __name__ == "__main__":
-    main()
+# ---- End of your code ----