File size: 9,405 Bytes
183c8ed
 
 
 
 
 
 
 
 
 
335e69e
183c8ed
 
 
 
 
 
 
 
 
 
 
 
 
 
 
49b5798
 
 
 
 
 
 
 
183c8ed
335e69e
183c8ed
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
49b5798
183c8ed
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
49b5798
183c8ed
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
 
49b5798
 
79ca289
 
 
 
 
 
 
49b5798
 
 
 
 
 
 
 
 
 
 
 
 
 
183c8ed
 
 
 
 
 
 
 
 
 
 
 
 
49b5798
183c8ed
 
 
 
 
 
 
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
44
45
46
47
48
49
50
51
52
53
54
55
56
57
58
59
60
61
62
63
64
65
66
67
68
69
70
71
72
73
74
75
76
77
78
79
80
81
82
83
84
85
86
87
88
89
90
91
92
93
94
95
96
97
98
99
100
101
102
103
104
105
106
107
108
109
110
111
112
113
114
115
116
117
118
119
120
121
122
123
124
125
126
127
128
129
130
131
132
133
134
135
136
137
138
139
140
141
142
143
144
145
146
147
148
149
150
151
152
153
154
155
156
157
158
159
160
161
162
163
164
165
166
167
168
169
170
171
172
173
174
175
176
177
178
179
180
181
182
183
184
185
186
187
188
189
190
191
192
193
194
195
196
197
198
199
200
201
202
203
204
205
206
207
208
209
210
211
212
213
214
215
216
217
218
219
220
221
222
223
224
225
226
227
228
229
230
from fastapi import FastAPI, UploadFile, File
from deep_translator import GoogleTranslator
import pandas as pd
import numpy as np
import pickle
import tensorflow as tf
import PyPDF2
import io
import urllib.parse
import os
from groq import Groq

original_dense_init = tf.keras.layers.Dense.__init__

def safe_dense_init(self, *args, **kwargs):
    kwargs.pop('quantization_config', None)
    original_dense_init(self, *args, **kwargs)

tf.keras.layers.Dense.__init__ = safe_dense_init

app = FastAPI(title="NextStep AI API")

@app.get("/")
async def root():
    return {"message": "Selamat datang di NextStep AI API! Silakan akses /docs untuk dokumentasi."}

print(" Memuat Dataset, Model & AI...")

groq_api_key = os.getenv("GROQ_API_KEY")
if groq_api_key:
    groq_client = Groq(api_key=groq_api_key)
else:
    groq_client = None
    print("Peringatan: GROQ_API_KEY tidak ditemukan")

# LOAD DATASET
df_job = pd.read_csv('Dataset/english_jobs.csv')
print("-> Kolom di english_jobs.csv:", df_job.columns.tolist())

try:
    if os.path.exists('Dataset/jobs.csv'):
        df_metadata = pd.read_csv('Dataset/jobs.csv')
        df_metadata_clean = df_metadata.drop_duplicates(subset=['title'])[['title', 'company', 'url']]
        
        df_job = pd.merge(
            left=df_job, 
            right=df_metadata_clean, 
            left_on='raw_job_title', 
            right_on='title', 
            how='left'
        )
        print("-> Sukses! Berhasil menggabungkan dataset dengan jobs.csv!")
except Exception as e:
    print(f"-> Peringatan: Gagal menggabungkan jobs.csv: {e}")

df_job = df_job.dropna(subset=['extracted_skills', 'job_category']) 

# LOAD MODEL KLASIFIKASI 
with open('models/tfidf_text.pkl', 'rb') as f:
    tfidf_text = pickle.load(f)

with open('models/mlb.pkl', 'rb') as f:
    mlb = pickle.load(f)

model_klasifikasi = tf.keras.models.load_model('models/best_model.h5')

with open('models/model_prediksi_kategori.pkl', 'rb') as f:
    model_kategori = pickle.load(f)

#  LOAD MODEL SIAMESE 
class CosineSimilarityLayer(tf.keras.layers.Layer):
    def __init__(self, **kwargs):
        super(CosineSimilarityLayer, self).__init__(**kwargs)
    def call(self, inputs):
        cv_vec, job_vec = inputs
        cv_norm = tf.nn.l2_normalize(cv_vec, axis=-1)
        job_norm = tf.nn.l2_normalize(job_vec, axis=-1)
        return tf.reduce_sum(cv_norm * job_norm, axis=-1, keepdims=True)

with open('Siamese/vectorizer_siamese_final.pkl', 'rb') as f:
    vectorizer_siamese = pickle.load(f)
with open('Siamese/pca_siamese_final.pkl', 'rb') as f:
    pca_siamese = pickle.load(f)

recommender_model = tf.keras.models.load_model(
    'Siamese/recommender_model_final.keras',
    custom_objects={'CosineSimilarityLayer': CosineSimilarityLayer}
)
print("Semua Model Berhasil Dimuat!")

# HELPER FUNCTIONS 
def ekstrak_teks_pdf(file_bytes):
    teks_lengkap = ""
    reader = PyPDF2.PdfReader(io.BytesIO(file_bytes))
    for page in reader.pages:
        teks_lengkap += page.extract_text() + " "
    return teks_lengkap

def terjemahkan_cv(teks):
    try:
        if len(teks) > 4900:
            teks = teks[:4900] 
        return GoogleTranslator(source='auto', target='en').translate(teks)
    except Exception as e:
        print(f"Translasi Gagal (Internet down/limit): {e}")
        return teks 

def cari_skill_gap(teks_cv, syarat_skill):
    clean_syarat = str(syarat_skill).replace('[','').replace(']','').replace("'", "").split(',')
    gap = [skill.strip() for skill in clean_syarat if skill.strip().lower() not in teks_cv.lower()]
    return [g for g in gap if g]

# ENDPOINT API 
@app.post("/api/predict-cv")
async def predict_cv(file: UploadFile = File(...)):
    try:
        file_bytes = await file.read()
        teks_cv = ekstrak_teks_pdf(file_bytes)

        vektor_cv_ai = tfidf_text.transform([teks_cv]).toarray()
        vektor_dummy = np.zeros((1, 50)) 
        vektor_input_klasifikasi = [vektor_cv_ai, vektor_dummy]
        
        raw_pred = model_klasifikasi.predict(vektor_input_klasifikasi, verbose=0)
        if isinstance(raw_pred, list):
            raw_pred = raw_pred[0]
        
        prediksi_prob = np.array(raw_pred).flatten()
        y_pred_binary = (prediksi_prob > 0.50).astype(int)
        skills_pelamar = mlb.inverse_transform(y_pred_binary.reshape(1, -1))[0]
        list_skill_pelamar = list(skills_pelamar)

        kategori_prediksi = model_kategori.predict(vektor_cv_ai)[0]
        df_filtered = df_job[df_job['job_category'] == kategori_prediksi]

        if df_filtered.empty:
            df_filtered = df_job

        df_sample = df_filtered.sample(min(100, len(df_filtered)))

        array_mentah = vectorizer_siamese.transform([teks_cv]).toarray()
        vektor_input_siamese = pca_siamese.transform(array_mentah)
        
        hasil_rekomendasi = []
        for index, row in df_sample.iterrows():
            teks_job = str(row['extracted_skills'])
            array_job = vectorizer_siamese.transform([teks_job]).toarray()
            vektor_job = pca_siamese.transform(array_job)
            
            skor_ai = recommender_model.predict([vektor_input_siamese, vektor_job], verbose=0)[0][0]
            persentase = round(float(((skor_ai + 1) / 2) * 100), 2)

            posisi_loker = row.get('raw_job_title', f"Lowongan {index}")
            perusahaan_loker = row.get('company') 
            
            if pd.isna(perusahaan_loker) or str(perusahaan_loker).strip() == "":
                perusahaan_loker = "Perusahaan Mitra"
            
            link_asli = row.get('url')
            
            if pd.isna(link_asli) or str(link_asli).strip() == "":
                if perusahaan_loker == "Perusahaan Mitra":
                    kata_kunci = str(posisi_loker)
                else:
                    kata_kunci = f"{posisi_loker} {perusahaan_loker}"
                
                link_lamaran = f"https://www.linkedin.com/jobs/search/?keywords={urllib.parse.quote(kata_kunci)}"
            else:
                link_lamaran = str(link_asli)

            hasil_rekomendasi.append({
                "posisi": posisi_loker if pd.notna(posisi_loker) else f"Lowongan {index}",
                "perusahaan": perusahaan_loker,
                "industri": kategori_prediksi, 
                "skor_match": persentase,
                "syarat_skill": teks_job,
                "link_lamaran": link_lamaran
            })
            
        hasil_rekomendasi = sorted(hasil_rekomendasi, key=lambda x: x['skor_match'], reverse=True)[:3]
        
        final_rekomendasi = []
        for loker in hasil_rekomendasi:
            gap = cari_skill_gap(teks_cv, loker['syarat_skill'])
            loker['saran_belajar'] = gap[:5]

            #PROSES GENERASI REVIEW DARI GROQ 
            try:
                prompt = f"""Kamu adalah Senior Recruiter dan Praktisi Ahli di industri {loker['industri']}.
                Keahlian pelamar saat ini: {list_skill_pelamar}
                Posisi yang dilamar: {loker['posisi']} di {loker['perusahaan']}
                Kekurangan skill (Gap): {gap[:5]}
                
                Tugas: Buat maksimal 3 kalimat evaluasi profesional berbahasa Indonesia. Analisis bagaimana keahlian pelamar saat ini dapat diintegrasikan dengan skill gap tersebut. Jelaskan fungsi spesifik atau peran dari skill gap tersebut dalam standar operasional (workflow) nyata untuk posisi {loker['posisi']}.
                Aturan: Gunakan terminologi teknis atau istilah profesional yang sangat akurat sesuai dengan industri {loker['industri']}. Langsung berikan evaluasi analitis tanpa basa-basi atau salam pembuka."""
                
                chat_completion = groq_client.chat.completions.create(
                    messages=[{"role": "user", "content": prompt}],
                    model="llama-3.1-8b-instant",
                    temperature=0.7,
                    max_tokens=150
                )
                review = chat_completion.choices[0].message.content.strip()
                loker['review_deskriptif'] = review
            except Exception as e:
                print(f"Peringatan: Gagal mendapatkan review dari Groq: {e}")
                loker['review_deskriptif'] = f"Kamu memiliki dasar yang baik. Untuk memaksimalkan peluangmu sebagai {loker['posisi']}, sangat disarankan untuk mempelajari {', '.join(gap[:3])}."

            # Membuat link Coursera
            link_belajar = []
            for skill in gap[:5]:
                url_belajar = f"https://www.coursera.org/search?query={urllib.parse.quote(skill)}"
                link_belajar.append(url_belajar)
                
            loker['link_belajar'] = link_belajar 
            
            del loker['syarat_skill'] 
            final_rekomendasi.append(loker)
            
        return {
            "status": "success",
            "data_pelamar": {
                "skill_terdeteksi": list_skill_pelamar
            },
            "rekomendasi_utama_bidang": kategori_prediksi,
            "top_3_loker": final_rekomendasi
        }
    
    except Exception as e:
        return {"status": "error", "message": f"Terjadi kesalahan pada server: {str(e)}"}