diff --git a/src/template_project/application/resume/interactors/predict_salary.py b/src/template_project/application/resume/interactors/predict_salary.py new file mode 100644 index 0000000..dcd006c --- /dev/null +++ b/src/template_project/application/resume/interactors/predict_salary.py @@ -0,0 +1,208 @@ +from collections import defaultdict +from decimal import Decimal +from operator import itemgetter + +from Levenshtein import ratio + +from template_project.application.common.data_structure import to_data_structure +from template_project.application.common.interactor import to_interactor +from template_project.application.resume.entity import ResumeId + + +@to_data_structure +class VacancyInput: + vacancy_id: str + from_salary: Decimal + to_salary: Decimal + key_skills: list[str] + resume_similarity: float + + +@to_data_structure +class PredictSalaryRequest: + resume_id: ResumeId + key_skills: list[str] + vacancies: list[VacancyInput] + + +@to_data_structure +class PredictSalaryResponse: + salary_from: Decimal + salary_to: Decimal + recommended_skills: list[str] + + +@to_interactor +class PredictSalaryInteractor: + async def execute(self, request: PredictSalaryRequest) -> PredictSalaryResponse: + salary_from, salary_to = self._predict_salary(request.vacancies, request.key_skills) + recommended_skills = self._recommend_skills(request.vacancies, request.key_skills) + + return PredictSalaryResponse( + salary_from=salary_from, + salary_to=salary_to, + recommended_skills=recommended_skills, + ) + + def _predict_salary(self, vacancies: list[VacancyInput], resume_skills: list[str]) -> tuple[Decimal, Decimal]: + if not vacancies: + return Decimal(50000), Decimal(80000) + + vacancy_weights: list[float] = [] + for vacancy in vacancies: + skills_similarity = self._calculate_skills_similarity(resume_skills, vacancy.key_skills) + vacancy_weight = 0.8 * vacancy.resume_similarity + 0.2 * skills_similarity + vacancy_weights.append(vacancy_weight) + + total_weight = sum(vacancy_weights) + if total_weight == 0: + return Decimal(50000), Decimal(80000) + + weighted_from_sum = Decimal(0) + weighted_to_sum = Decimal(0) + + for vacancy, weight in zip(vacancies, vacancy_weights, strict=False): + weighted_from_sum += vacancy.from_salary * Decimal(str(weight)) + weighted_to_sum += vacancy.to_salary * Decimal(str(weight)) + + predicted_from = weighted_from_sum / Decimal(str(total_weight)) + predicted_to = weighted_to_sum / Decimal(str(total_weight)) + + return predicted_from.quantize(Decimal("0.01")), predicted_to.quantize(Decimal("0.01")) + + def _recommend_skills( + self, + vacancies: list[VacancyInput], + resume_skills: list[str], + ) -> list[str]: + if not vacancies: + return [] + + skill_salaries, skill_frequencies = self._collect_skill_statistics(vacancies) + + filtered_skills = self._filter_skills_by_frequency(skill_frequencies, min_frequency=3) + + candidate_skills = self._filter_skills_by_resume_similarity(filtered_skills, resume_skills) + + if not candidate_skills: + return [] + + skill_scores = self._calculate_skill_scores(candidate_skills, skill_salaries, skill_frequencies) + + return self._get_top_skills(skill_scores, top_n=3) + + def _collect_skill_statistics( + self, vacancies: list[VacancyInput] + ) -> tuple[dict[str, list[Decimal]], dict[str, int]]: + skill_salaries: dict[str, list[Decimal]] = defaultdict(list) + skill_frequencies: dict[str, int] = defaultdict(int) + + for vacancy in vacancies: + avg_salary = (vacancy.from_salary + vacancy.to_salary) / Decimal(2) + + for skill in vacancy.key_skills: + normalized_skill = skill.lower().strip() + skill_salaries[normalized_skill].append(avg_salary) + skill_frequencies[normalized_skill] += 1 + + return skill_salaries, skill_frequencies + + def _filter_skills_by_frequency( + self, + skill_frequencies: dict[str, int], + min_frequency: int = 3, + ) -> set[str]: + return {skill for skill, frequency in skill_frequencies.items() if frequency >= min_frequency} + + def _filter_skills_by_resume_similarity( + self, + skills: set[str], + resume_skills: list[str], + ) -> list[str]: + resume_skills_normalized = {skill.lower().strip() for skill in resume_skills} + + candidate_skills: list[str] = [] + for skill in skills: + is_already_in_resume = any( + self._is_skill_similar(skill, resume_skill) for resume_skill in resume_skills_normalized + ) + if not is_already_in_resume: + candidate_skills.append(skill) + + return candidate_skills + + def _calculate_skill_scores( + self, + candidate_skills: list[str], + skill_salaries: dict[str, list[Decimal]], + skill_frequencies: dict[str, int], + ) -> list[tuple[str, float]]: + skill_avg_salaries: dict[str, Decimal] = { + skill: sum(salaries) / Decimal(str(len(salaries))) + for skill, salaries in skill_salaries.items() + if skill in candidate_skills + } + + frequencies = [skill_frequencies[skill] for skill in candidate_skills] + avg_salaries = [float(skill_avg_salaries[skill]) for skill in candidate_skills] + + min_freq = min(frequencies) + max_freq = max(frequencies) + min_salary = min(avg_salaries) + max_salary = max(avg_salaries) + + skill_scores: list[tuple[str, float]] = [] + for skill in candidate_skills: + normalized_freq = self._normalize(float(skill_frequencies[skill]), min_freq, max_freq) + normalized_salary = self._normalize(float(skill_avg_salaries[skill]), min_salary, max_salary) + score = normalized_freq + normalized_salary + skill_scores.append((skill, score)) + + return skill_scores + + def _get_top_skills(self, skill_scores: list[tuple[str, float]], top_n: int = 3) -> list[str]: + skill_scores.sort(key=itemgetter(1), reverse=True) + return [skill for skill, _ in skill_scores[:top_n]] + + def _normalize(self, value: float, min_val: float, max_val: float) -> float: + if max_val == min_val: + return 0.0 + return (value - min_val) / (max_val - min_val) + + def _is_skill_similar(self, skill1: str, skill2: str, threshold: float = 0.7) -> bool: + return ratio(skill1.lower().strip(), skill2.lower().strip()) >= threshold + + def _calculate_skills_similarity(self, resume_skills: list[str], vacancy_skills: list[str]) -> float: + if not resume_skills or not vacancy_skills: + return 0.0 + + resume_skills_normalized = {skill.lower().strip() for skill in resume_skills} + vacancy_skills_normalized = {skill.lower().strip() for skill in vacancy_skills} + + matched_resume_skills = set() + matched_vacancy_skills = set() + + for resume_skill in resume_skills_normalized: + best_match_ratio = 0.0 + best_match_skill = None + + for vacancy_skill in vacancy_skills_normalized: + if vacancy_skill in matched_vacancy_skills: + continue + + similarity_ratio = ratio(resume_skill, vacancy_skill) + if similarity_ratio > best_match_ratio: + best_match_ratio = similarity_ratio + best_match_skill = vacancy_skill + + if best_match_ratio >= 0.7 and best_match_skill is not None: + matched_resume_skills.add(resume_skill) + matched_vacancy_skills.add(best_match_skill) + + intersection_size = len(matched_resume_skills) + union_size = len(resume_skills_normalized | vacancy_skills_normalized) + + if union_size == 0: + return 0.0 + + return intersection_size / union_size diff --git a/src/template_project/ml/entry_point.py b/src/template_project/ml/entry_point.py index 110ebf7..5814523 100644 --- a/src/template_project/ml/entry_point.py +++ b/src/template_project/ml/entry_point.py @@ -14,7 +14,7 @@ from fastapi.middleware.cors import CORSMiddleware from template_project.ml.configuration import load_configuration from template_project.ml.ioc.make import make_ioc -from template_project.ml.routes import embedding, healthcheck, predict +from template_project.ml.routes import embed, healthcheck, predict LOG_CONFIG: Final = { "version": 1, @@ -55,7 +55,7 @@ def make_asgi_application( allow_headers=["*"], ) app.include_router(healthcheck.router) - app.include_router(embedding.router) + app.include_router(embed.router) app.include_router(predict.router) setup_dishka(container=ioc, app=app) diff --git a/src/template_project/ml/interactors/predict_salary.py b/src/template_project/ml/interactors/predict_salary.py deleted file mode 100644 index 0775113..0000000 --- a/src/template_project/ml/interactors/predict_salary.py +++ /dev/null @@ -1,38 +0,0 @@ -from decimal import Decimal - -from template_project.application.common.data_structure import to_data_structure -from template_project.application.common.interactor import to_interactor -from template_project.application.resume.entity import ResumeId - - -@to_data_structure -class VacancyInput: - vacancy_id: str - from_salary: Decimal - to_salary: Decimal - key_skills: list[str] - resume_similarity: float - - -@to_data_structure -class PredictSalaryRequest: - resume_id: ResumeId - key_skills: list[str] - vacancies: list[VacancyInput] - - -@to_data_structure -class PredictSalaryResponse: - salary_from: Decimal - salary_to: Decimal - recommended_skills: list[str] - - -@to_interactor -class PredictSalaryInteractor: - async def execute(self, request: PredictSalaryRequest) -> PredictSalaryResponse: - return PredictSalaryResponse( - salary_from=Decimal(50000), - salary_to=Decimal(80000), - recommended_skills=["python", "django", "postgresql"], - ) diff --git a/src/template_project/ml/ioc/interactor.py b/src/template_project/ml/ioc/interactor.py index c56095d..6092b5a 100644 --- a/src/template_project/ml/ioc/interactor.py +++ b/src/template_project/ml/ioc/interactor.py @@ -1,6 +1,6 @@ from dishka import BaseScope, Provider, Scope, provide_all -from template_project.ml.interactors.predict_salary import PredictSalaryInteractor +from template_project.application.resume.interactors.predict_salary import PredictSalaryInteractor class InteractorProvider(Provider): diff --git a/src/template_project/ml/routes/embedding.py b/src/template_project/ml/routes/embed.py similarity index 100% rename from src/template_project/ml/routes/embedding.py rename to src/template_project/ml/routes/embed.py diff --git a/src/template_project/ml/routes/predict.py b/src/template_project/ml/routes/predict.py index 8db98ef..3a15592 100644 --- a/src/template_project/ml/routes/predict.py +++ b/src/template_project/ml/routes/predict.py @@ -6,7 +6,7 @@ from fastapi import APIRouter from pydantic import BaseModel, Field from template_project.application.resume.entity import ResumeId -from template_project.ml.interactors.predict_salary import ( +from template_project.application.resume.interactors.predict_salary import ( PredictSalaryInteractor, PredictSalaryRequest, VacancyInput, @@ -82,14 +82,17 @@ class PredictSalaryResponseModel(BaseModel): @router.post( - "/predict_salary", - summary="Predict salary", + "/predict", + summary="Predict salary and recommend skills", description="Predict salary range and recommend skills based on resume and relevant vacancies", responses={ - 200: {"description": "Salary prediction generated successfully", "model": PredictSalaryResponseModel}, + 200: { + "description": "Salary prediction and skills recommendation generated successfully", + "model": PredictSalaryResponseModel, + }, }, ) -async def predict_salary( +async def predict( request: PredictSalaryRequestModel, interactor: FromDishka[PredictSalaryInteractor], ) -> PredictSalaryResponseModel: