private DataModel ProcessRequest(ProjectCandidateRequirement candidateRequirement)
{
var skills = _skillRepository.GetAllSkills();
var dataModel = new DataModel();
if (CsvHeaders.Count == 0)
{
var estimatedExpertises = _skillRepository.GetSkillEstimatedExpertise();
CsvHeaders.Add("candidateId");
CsvHeaders.AddRange(estimatedExpertises.Select(exp => exp.Skill.Name).Distinct().ToList());
}
foreach (var skill in candidateRequirement.SkillsFilter)
{
var skillInfo = skills.FirstOrDefault(s => s.Id == skill.RequiredSkillId);
if (skillInfo != null)
{
var index = CsvHeaders.IndexOf(skillInfo.Name);
if (index > -1)
{
index += 1;
var fieldInfo = dataModel.GetType().GetField("attr" + index);
fieldInfo.SetValue(dataModel, Convert.ChangeType(skill.Weight, fieldInfo.FieldType));
}
}
}
return(dataModel);
}
public async Task <IActionResult> GetProjectCandidatesMachineLearning([FromBody] ProjectCandidateRequirement pcr)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var skillIds = pcr.SkillsFilter.Select(sf => sf.RequiredSkillId).Distinct().ToList();
var analysisResult = await _analyzer.GetRecommendationsAsync(pcr, false);
var candidateIds = analysisResult.Matches.Keys.ToList();
var candidates = _candidateRepository.GetCandidateByIds(candidateIds);
var candidateExpertises = _skillRepository.GetSkillEstimatedExpertiseByCandidateAndSkillIds(candidateIds, skillIds);
var query = candidates.AsQueryable();
if ((pcr.InBenchFilter.HasValue) && (pcr.InBenchFilter.Value))
{
query = query.Where(c => c.InBench);
}
if (pcr.DeliveryUnitIdFilter.HasValue)
{
query = query.Where(c => c.DeliveryUnit.Id.Equals(pcr.DeliveryUnitIdFilter.Value));
}
if (pcr.RoleIdFilter.HasValue)
{
query = query.Where(c => c.CandidateRoleId.Equals(pcr.RoleIdFilter.Value));
}
if (pcr.RelationTypeFilter.HasValue)
{
query = query.Where(c => c.RelationType.Equals(pcr.RelationTypeFilter.Value));
}
if (pcr.Max != 0)
{
query = query.Take(pcr.Max);
}
var result = query.Select(candidate => new ProjectCandidate
{
Candidate = candidate,
Ranking = candidateExpertises.Where(c => c.Candidate.Id == candidate.Id).Select(c => c.Expertise).Sum() / candidateExpertises.Where(c => c.Candidate.Id == candidate.Id).Count(),
SkillExpertises = candidateExpertises
.Where(exp => exp.Candidate.Id == candidate.Id)
.Select(exp => new ProjectCandidateSkill()
{
Skill = exp.Skill,
Expertise = exp.Expertise,
}).ToList(),
})
.OrderByDescending(r => r.Ranking)
.ToList();
return(Ok(result));
}
public IActionResult GetProjectCandidatesWeightedAverage([FromBody] ProjectCandidateRequirement pcr)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
return(Ok(SearchProjectCandidatesEngine.GetProjectCandidatesWeightedAverage(pcr, _skillRepository)));
}
public Task <RecommendationResponse> GetRecommendationsAsync(ProjectCandidateRequirement candidateRequirement, bool createDataSet)
{
// if (createDataSet) GenerateDataset();
var predictionData = PredictValue(candidateRequirement);
return(Task.FromResult(new RecommendationResponse
{
Matches = predictionData
}));
}
public async Task <IActionResult> Candidates([FromBody] ProjectCandidateRequirement model)
{
if (!ModelState.IsValid)
{
return(BadRequest(ModelState));
}
var analysisResult = await _analyzer.GetRecommendationsAsync(model, false);
ProjectRecommendationsModel result = ProjectRecommendationsModel.FromRecommendationResponse(analysisResult, _linkGenerator, _httpContextAccessor);
return(Ok(result));
}
public static List <ProjectCandidate> GetProjectCandidatesWeightedAverage(ProjectCandidateRequirement pcr, ISkillRepository skillRepository)
{
pcr.Normalize();
var estimated = skillRepository.GetSkillEstimatedExpertiseForProject(pcr);
var filteredCandidates = estimated.Select(e => e.Candidate).Distinct().ToList();
var res = filteredCandidates.Select(fc => new ProjectCandidate()
{
Candidate = fc,
Ranking = getRanking(pcr.SkillsFilter, getCandidateSkillEstimatedExpertise(fc, estimated)),
SkillExpertises = getSkillExpertises(pcr.SkillsFilter, getCandidateSkillEstimatedExpertise(fc, estimated)),
}).Where(pc => pc.Ranking > 0).OrderByDescending(pc => pc.Ranking).Take(pcr.Max).ToList();
return(res);
}
// The sum of Weight in SkillFilter list should be 1.
public static void Normalize(this ProjectCandidateRequirement pcr)
{
if ((pcr == null) || (pcr.SkillsFilter == null) || (pcr.SkillsFilter.Count == 0))
{
return;
}
var totalWeight = pcr.SkillsFilter.Sum(sf => sf.Weight);
if (totalWeight == 1M)
{
return;
}
foreach (var sf in pcr.SkillsFilter)
{
sf.Weight /= totalWeight;
}
}
private Dictionary <int, float> PredictValue(ProjectCandidateRequirement candidateRequirement)
{
string modelPath = Path.Combine(Environment.CurrentDirectory, "Data", "trainedModel.zip");
try
{
var result = GenerateNames();
var textLoader = MLContext.Data.CreateTextLoader(result.Item1, hasHeader: true, separatorChar: ',');
var data = textLoader.Load(InputPath);
var responseValues = new Dictionary <int, float>();
ITransformer trainedModel = MLContext.Model.Load(modelPath, out var modelSchema);
var transformedDataView = trainedModel.Transform(data);
var predictionEngine = MLContext.Model.CreatePredictionEngine <DataModel, ClusteringPrediction>(trainedModel);
var prediction = predictionEngine.Predict(ProcessRequest(candidateRequirement));
ClusteringPrediction[] userData = MLContext.Data
.CreateEnumerable <ClusteringPrediction>(transformedDataView, false)
.ToArray();
userData = userData
.Where(u => u.SelectedClusterId == prediction.SelectedClusterId)
.OrderBy(x => x.Distance[prediction.SelectedClusterId - 1])
.ToArray();
foreach (var u in userData)
{
responseValues.Add(int.Parse(u.CandidateId), u.Distance[u.SelectedClusterId - 1]);
}
return(responseValues);
}
catch (Exception ex)
{
throw ex;
}
}
