Update app.py

app.py

@@ -1,133 +1,44 @@
-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 os
-import time
-from pathlib import Path
-
-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(),
-    ])
+import openai
+import sys
 
-    input_data = transform(img).unsqueeze(0).to(device='cpu')
+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
 
-    class_to_label = dict_for_inference
+sys.path.append('../..')
 
-    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)
+from dotenv import load_dotenv, find_dotenv
+_ = load_dotenv(find_dotenv()) # read local .env file
 
-    # Create a dictionary of class labels and their probabilities
-    output_dict = {"predicted_label": class_to_label[predicted_class.item()], "probability": conf.item()}
+openai.api_key  = os.environ['OPENAI_API_KEY']
 
-    # 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()])
+llm = OpenAI(temperature=0)
+text_splitter = CharacterTextSplitter()
 
-    return output_json, output_bentuk_text, output_response
+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
 
-# 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"
+def main():
+    output_summary = gr.Textbox(label="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 = 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.",
+    )
 
-# Start the Gradio app
-interface.launch(share=True, debug=True)
+    iface.launch(share=True)
 
-# ---- End of your code ----
+if __name__ == "__main__":
+    main()