cek

main.py

@@ -2,9 +2,57 @@ from fastapi import FastAPI
 import pickle
 import uvicorn
 import pandas as pd
+import shutil
+import cv2
+import mediapipe as mp
+from werkzeug.utils import secure_filename
+import tensorflow as tf
+import os
+from flask import Flask, jsonify, request, flash, redirect, url_for
+from pyngrok import ngrok
+from fastapi import FastAPI, HTTPException, File, UploadFile, Request
+from fastapi.staticfiles import StaticFiles
+from fastapi.responses import JSONResponse
+from pydantic import BaseModel
+import subprocess
+
+from file_processing import FileProcess
+from get_load_data import GetLoadData
+from data_preprocess import DataProcessing
+from train_pred import TrainPred
 
 app = FastAPI()
- 
+public_url = "https://lambang0902-test-space.hf.space"
+app.mount("/static", StaticFiles(directory="static"), name="static")
+# Tempat deklarasi variabel-variabel penting
+filepath = ""
+list_class = ['Diamond','Oblong','Oval','Round','Square','Triangle']
+list_folder = ['Training', 'Testing']
+face_crop_img = True
+face_landmark_img = True
+landmark_extraction_img = True
+# #-----------------------------------------------------
+#
+#
+# #-----------------------------------------------------
+# Tempat deklarasi model dan sejenisnya
+selected_model = tf.keras.models.load_model(f'models/fc_model_1.h5', compile=False)
+face_cascade = cv2.CascadeClassifier('haarcascade_frontalface_alt2.xml')
+mp_drawing = mp.solutions.drawing_utils
+mp_face_mesh = mp.solutions.face_mesh
+drawing_spec = mp_drawing.DrawingSpec(thickness=1, circle_radius=1)
+# #-----------------------------------------------------
+#
+#
+# #-----------------------------------------------------
+# Tempat setting server
+UPLOAD_FOLDER = './upload'
+UPLOAD_MODEL = './models'
+ALLOWED_EXTENSIONS = {'png', 'jpg', 'jpeg','zip','h5'}
+# app.config['UPLOAD_FOLDER'] = UPLOAD_FOLDER
+# app.config['UPLOAD_MODEL'] = UPLOAD_MODEL
+# app.config['MAX_CONTENT_LENGTH'] = 500 * 1024 * 1024  # 500 MB
+# #-----------------------------------------------------
 #Endpoints 
 #Root endpoints
 @app.get("/")
@@ -13,5 +61,179 @@ async def root():
     ngrok_url = "Tidak Ada URL Publik (ngrok belum selesai memulai)"
 
     return {"message": "Hello, World!", "ngrok_url": ngrok_url}
-    
 
+
+# #-----------------------------------------------------
+#
+data_processor = DataProcessing()
+data_train_pred = TrainPred()
+#
+import random
+def preprocessing(filepath):
+    folder_path = './static/temporary'
+
+    shutil.rmtree(folder_path)
+    os.mkdir(folder_path)
+
+    # data_processor.detect_landmark(data_processor.face_cropping_pred(filepath))
+    data_processor.enhance_contrast_histeq(data_processor.face_cropping_pred(filepath))
+
+    files = os.listdir(folder_path)
+    index = 0
+    for file_name in files:
+        file_ext = os.path.splitext(file_name)[1]
+        new_file_name = str(index) + "_" + str(random.randint(1, 100000)) + file_ext
+        os.rename(os.path.join(folder_path, file_name), os.path.join(folder_path, new_file_name))
+        index += 1
+
+    print("Tungu sampai selesaiii")
+
+train_datagen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1 / 255.)
+test_datagen = tf.keras.preprocessing.image.ImageDataGenerator(rescale=1 / 255.)
+
+## -------------------------------------------------------------------------
+##                   API UNTUK MELAKUKAN PROSES PREDIKSI
+## -------------------------------------------------------------------------
+
+@app.post('/upload/file',tags=["Predicting"])
+async def upload_file(picture: UploadFile):
+    file_extension = picture.filename.split('.')[-1].lower()
+
+
+    if file_extension not in ALLOWED_EXTENSIONS:
+        raise HTTPException(status_code=400, detail='Invalid file extension')
+
+    os.makedirs(UPLOAD_FOLDER, exist_ok=True)
+    file_path = os.path.join(UPLOAD_FOLDER, secure_filename(picture.filename))
+    with open(file_path, 'wb') as f:
+        f.write(picture.file.read())
+    try:
+        processed_img = preprocessing(cv2.imread(file_path))
+    except Exception as e:
+        os.remove(file_path)
+        raise HTTPException(status_code=500, detail=f'Error processing image: {str(e)}')
+
+    return JSONResponse(content={'message': 'File successfully uploaded'}, status_code=200)
+
+@app.get('/get_images', tags=["Predicting"])
+def get_images():
+    folder_path = "./static/temporary"
+    files = [f for f in os.listdir(folder_path) if os.path.isfile(os.path.join(folder_path, f))]
+    urls = []
+    for i in range(0, 3):
+        url = f'{public_url}/static/temporary/{files[i]}'
+        urls.append(url)
+        bentuk, persentase = data_train_pred.prediction(selected_model)
+    return {'urls': urls, 'bentuk_wajah':bentuk[0], 'persen':persentase}
+
+
+## -------------------------------------------------------------------------
+##                   API UNTUK MELAKUKAN PROSES TRAINING
+## -------------------------------------------------------------------------
+
+# Model pydantic untuk validasi body
+class TrainingParams(BaseModel):
+    optimizer: str
+    epoch: int
+    batchSize: int
+
+@app.post('/upload/dataset', tags=["Training"])
+async def upload_data(dataset: UploadFile):
+    if dataset.filename == '':
+        raise HTTPException(status_code=400, detail='No file selected for uploading')
+
+    # Buat path lengkap untuk menyimpan file
+    file_path = os.path.join(UPLOAD_FOLDER, dataset.filename)
+
+    # Simpan file ke folder yang ditentukan
+    with open(file_path, "wb") as file_object:
+        file_object.write(dataset.file.read())
+
+    # Panggil fungsi untuk mengekstrak file jika perlu
+    FileProcess.extract_zip(file_path)
+
+    return {'message': 'File successfully uploaded'}
+
+@app.post('/set_params', tags=["Training"])
+async def set_params(request: Request, params: TrainingParams):
+    global optimizer, epoch, batch_size
+
+    optimizer = params.optimizer
+    epoch = params.epoch
+    batch_size = params.batchSize
+
+    response = {'message': 'Set parameter sukses'}
+    return response
+
+@app.get('/get_info_data', tags=["Training"])
+def get_info_prepro():
+    global optimizer, epoch, batch_size
+    training_counts = GetLoadData.get_training_file_counts().json
+    testing_counts = GetLoadData.get_testing_file_counts().json
+    response = {
+        "optimizer": optimizer,
+        "epoch": epoch,
+        "batch_size": batch_size,
+        "training_counts": training_counts,
+        "testing_counts": testing_counts
+    }
+    return response
+
+@app.get('/get_images_preprocess', tags=["Training"])
+def get_random_images_crop():
+    images_face_landmark = GetLoadData.get_random_images(tahap="Face Landmark",public_url=public_url)
+    images_face_extraction = GetLoadData.get_random_images(tahap="landmark Extraction", public_url=public_url)
+
+    response = {
+        "face_landmark": images_face_landmark,
+        "landmark_extraction": images_face_extraction
+    }
+    return response
+
+@app.get('/do_preprocessing', tags=["Training"])
+async def do_preprocessing():
+    try:
+        data_train_pred.do_pre1(test="")
+        data_train_pred.do_pre2(test="")
+        return {'message': 'Preprocessing sukses'}
+    except Exception as e:
+        # Tangani kesalahan dan kembalikan respons kesalahan
+        error_message = f'Error during preprocessing: {str(e)}'
+        raise HTTPException(status_code=500, detail=error_message)
+
+@app.get('/do_training', tags=["Training"])
+def do_training():
+    global epoch
+    folder = ""
+    if (face_landmark_img == True and landmark_extraction_img == True):
+        folder = "Landmark Extraction"
+    elif (face_landmark_img == True and landmark_extraction_img == False):
+        folder = "Face Landmark"
+    # --------------------------------------------------------------
+    train_dataset_path = f"./static/dataset/{folder}/Training/"
+    test_dataset_path = f"./static/dataset/{folder}/Testing/"
+
+    train_image_df, test_image_df = GetLoadData.load_image_dataset(train_dataset_path, test_dataset_path)
+
+    train_gen, test_gen = data_train_pred.data_configuration(train_image_df, test_image_df)
+    model = data_train_pred.model_architecture()
+
+    result = data_train_pred.train_model(model, train_gen, test_gen, epoch)
+
+    # Mengambil nilai akurasi training dan validation dari objek result
+    train_acc = result.history['accuracy'][-1]
+    val_acc = result.history['val_accuracy'][-1]
+
+    # Plot accuracy
+    data_train_pred.plot_accuracy(result=result, epoch=epoch)
+    acc_url = f'{public_url}/static/accuracy_plot.png'
+
+    # Plot loss
+    data_train_pred.plot_loss(result=result, epoch=epoch)
+    loss_url = f'{public_url}/static/loss_plot.png'
+
+    # Confusion Matrix
+    data_train_pred.plot_confusion_matrix(model, test_gen)
+    conf_url = f'{public_url}/static/confusion_matrix.png'
+
+    return jsonify({'train_acc': train_acc, 'val_acc': val_acc, 'plot_acc': acc_url, 'plot_loss':loss_url,'conf':conf_url})