public override void SetProperties()
{
properties.Key = VampirismInfectionKey;
properties.ShowSpellIcon = false;
classicDiseaseType = Diseases.None;
diseaseData = new DiseaseData(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF); // Permanent no-effect disease, will manage custom lifecycle
}
public override void SetProperties()
{
properties.ShowSpellIcon = false;
classicDiseaseType = Diseases.None;
diseaseData = new DiseaseData(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF); // Permanent no-effect disease, will manage custom lifecycle
bypassSavingThrows = true;
}
public async Task <IActionResult> PostDisease(DiseaseData disease)
{
if (!ModelState.IsValid)
{
return(BadRequest());
}
var check = await _context.Diseases
.Where(d => d.Name == disease.Disease.Name)
.FirstOrDefaultAsync();
var type = await _context.Specialties.FindAsync(disease.Type);
if (check != null || type == null)
{
return(BadRequest());
}
disease.Disease.Specialty = type;
await _context.Diseases.AddAsync(disease.Disease);
foreach (var id in disease.Symptoms)
{
var symptomDiseases = new SymptomDisease
{
DiseaseID = disease.Disease.ID,
SymptomID = id
};
await _context.SymptomDiseases.AddAsync(symptomDiseases);
}
await _context.SaveChangesAsync();
return(Ok(disease));
}
protected DiseaseData GetClassicDiseaseData(Diseases diseaseType)
{
// Only supports classic diseases, otherwise effect must provide own disease data
if (diseaseType == Diseases.None)
{
return(new DiseaseData());
}
// Disease data. Found in FALL.EXE (1.07.213) from offset 0x1C0053.
DiseaseData[] diseaseDataSources = new DiseaseData[]
{ // STR INT WIL AGI END PER SPD LUC HEA FAT SPL MIND MAXD MINS MAXS
new DiseaseData(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 2, 10, 0xFF, 0xFF), // Witches' Pox
new DiseaseData(1, 0, 1, 1, 1, 1, 1, 1, 1, 1, 1, 3, 30, 0xFF, 0xFF), // Plague
new DiseaseData(0, 0, 1, 0, 1, 0, 0, 0, 1, 0, 0, 5, 10, 0xFF, 0xFF), // Yellow Fever
new DiseaseData(0, 0, 0, 0, 0, 0, 0, 0, 1, 0, 0, 1, 5, 0xFF, 0xFF), // Stomach Rot
new DiseaseData(1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 10, 0xFF, 0xFF), // Consumption
new DiseaseData(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 1, 5, 0xFF, 0xFF), // Brain Fever
new DiseaseData(1, 0, 1, 1, 0, 0, 0, 0, 0, 0, 0, 2, 10, 0xFF, 0xFF), // Swamp Rot
new DiseaseData(1, 0, 0, 1, 0, 0, 1, 0, 0, 0, 0, 5, 10, 3, 18), // Caliron's Curse
new DiseaseData(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 5, 30, 0xFF, 0xFF), // Cholera
new DiseaseData(1, 1, 1, 1, 1, 1, 1, 1, 1, 1, 0, 5, 30, 0xFF, 0xFF), // Leprosy
new DiseaseData(1, 0, 0, 0, 1, 0, 0, 0, 1, 0, 0, 2, 4, 0xFF, 0xFF), // Wound Rot
new DiseaseData(0, 0, 0, 0, 1, 1, 0, 0, 0, 1, 0, 2, 10, 0xFF, 0xFF), // Red Death
new DiseaseData(0, 0, 1, 0, 0, 1, 0, 0, 1, 0, 0, 5, 10, 3, 18), // Blood Rot
new DiseaseData(0, 1, 0, 0, 1, 0, 0, 0, 1, 0, 0, 2, 10, 0xFF, 0xFF), // Typhoid Fever
new DiseaseData(0, 1, 1, 0, 0, 1, 0, 0, 0, 0, 0, 2, 10, 0xFF, 0xFF), // Dementia
new DiseaseData(0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 5, 10, 0xFF, 0xFF), // Chrondiasis
new DiseaseData(0, 1, 0, 0, 0, 0, 0, 0, 0, 0, 1, 2, 4, 3, 18), // Wizard Fever
};
return(diseaseDataSources[(int)diseaseType]);
}
public override void SetProperties()
{
properties.Key = GetClassicDiseaseEffectKey(diseaseType);
properties.ShowSpellIcon = false;
classicDiseaseType = diseaseType;
diseaseData = new DiseaseData(0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0, 0xFF, 0xFF, 30, 30); // Skooma (Drug)
bypassSavingThrows = true;
}
public DiseaseData()
{
if (Instance == null)
{
Instance = this;
}
else
{
return;
}
}
static DB()
{
Patient = new PatientData();
Companion = new CompanionData();
Employee = new EmployeeData();
Breeds = new BreedsData();
Species = new SpeciesData();
Operation = new OperationData();
Disease = new DiseaseData();
Drug = new DrugData();
Prescription = new PrescriptionData();
}
public async Task <IActionResult> PutDisease(int id, DiseaseData item)
{
if (!ModelState.IsValid || id != item.Disease.ID)
{
return(BadRequest());
}
var disease = await _context.Diseases.FindAsync(id);
var type = await _context.Specialties.FindAsync(item.Type);
var check = await _context.Diseases
.Where(d => d.Name == item.Disease.Name)
.FirstOrDefaultAsync();
if (disease == null || type == null || (check != null && check.ID != item.Disease.ID))
{
return(BadRequest());
}
disease.Name = item.Disease.Name;
disease.Details = item.Disease.Details;
disease.Specialty = type;
var symptomDiseases = await _context.SymptomDiseases
.Where(d => d.DiseaseID == disease.ID)
.Include(s => s.Symptom)
.ToListAsync();
_context.SymptomDiseases.RemoveRange(symptomDiseases);
foreach (var ids in item.Symptoms)
{
var symptomDisease = new SymptomDisease
{
DiseaseID = disease.ID,
SymptomID = ids
};
await _context.SymptomDiseases.AddAsync(symptomDisease);
}
_context.Diseases.Update(disease);
await _context.SaveChangesAsync();
return(Ok(disease));
}
public static void Evaluate(DiseasesData PredictionData, DiseasesData RealData, string wantedFileName = "")
{
//Object to write in JSON
Results results = new Results();
int RP = 0; //RealPositive general
int FP = 0; //FalsePositive general
int FN = 0; //FalseNegative general
//For each existent rare disease
foreach (string orphaNumber in PredictionData.DiseaseDataList.Select(x => x?.Disease?.OrphaNumber))
{
//Find THE diseaseData of ONE disease (real and predicted data)
DiseaseData RealDiseaseData = RealData.DiseaseDataList.Where(x => x?.Disease?.OrphaNumber == orphaNumber).FirstOrDefault();
DiseaseData PredictionDiseaseData = PredictionData.DiseaseDataList.Where(x => x?.Disease?.OrphaNumber == orphaNumber).FirstOrDefault();
//If we don't find the disease in both dataset, we shoud pass to another disease
if (RealDiseaseData != null && PredictionDiseaseData != null)
{
int RP_Disease = 0; //RealPositive of one disease
int FP_Disease = 0; //FalsePositive of one disease
int FN_Disease = 0; //FalseNegative of one disease
//Compute RP and FP
List <string> RelatedEntitiesNamesReal =
RealDiseaseData
.RelatedEntities.RelatedEntitiesList
.Select(x => x.Name)
.ToList();
for (int j = 0; j < PredictionDiseaseData.RelatedEntities.RelatedEntitiesList.Count; j++)
{
//Is my predicted related entity is present in the real data?
if (RelatedEntitiesNamesReal.IndexOf(PredictionDiseaseData.RelatedEntities.RelatedEntitiesList[j].Name) != -1)
{
RP++;
RP_Disease++;
}
else
{
FP++;
FP_Disease++;
}
}
//Compute FN
List <string> RelatedEntitiesNamesPred =
PredictionDiseaseData
.RelatedEntities.RelatedEntitiesList
.Select(x => x.Name)
.ToList();
for (int j = 0; j < RealDiseaseData.RelatedEntities.RelatedEntitiesList.Count; j++)
{
//Is my real related entity is present in the predicted data?
if (RelatedEntitiesNamesPred.IndexOf(RealDiseaseData.RelatedEntities.RelatedEntitiesList[j].Name) == -1)
{
FN++;
FN_Disease++;
}
}
//Compute Precision/recall and F_score
double PrecisionDisease = 0.0;
double RecallDisease = 0.0;
double F_ScoreDisease = 0.0;
if (RP_Disease + FP_Disease != 0)
{
PrecisionDisease = Math.Round((double)RP_Disease / (double)(RP_Disease + FP_Disease), 4);
}
if (RP_Disease + FN_Disease != 0)
{
RecallDisease = Math.Round((double)RP_Disease / (double)(RP_Disease + FN_Disease), 4);
}
if (PrecisionDisease + RecallDisease != 0.0)
{
F_ScoreDisease = Math.Round(2 * PrecisionDisease * RecallDisease / (PrecisionDisease + RecallDisease), 4);
}
//Construct results object
PerDisease OnePerDisease = new PerDisease(orphaNumber,
PredictionDiseaseData.Disease.NumberOfPublications,
PredictionData.Type.ToString(),
RP_Disease,
FP_Disease,
FN_Disease,
PrecisionDisease, //Precision
RecallDisease, //Recall
F_ScoreDisease
);
results.perDisease.Add(OnePerDisease);
}
}
//Compute Precision/recall and F_score general
double Precision = 0.0;
double Recall = 0.0;
double F_Score = 0.0;
if (RP + FP != 0)
{
Precision = Math.Round((double)RP / (double)(RP + FP), 4);
}
if (RP + FN != 0)
{
Recall = Math.Round((double)RP / (double)(RP + FN), 4);
}
if (Precision + Recall != 0.0)
{
F_Score = Math.Round(2 * Precision * Recall / (Precision + Recall), 4);
}
//Construct results object
results.general = new General(
DateTime.Now,
PredictionData.Type.ToString(),
RP,
FP,
FN,
Precision,
Recall,
F_Score);
//Write JSON FILE
WriteJSONFile(results, wantedFileName);
}
public void GetRealData()
{
RealData = new DiseasesData(type.Symptom, new List <DiseaseData>());
var request = (HttpWebRequest)WebRequest.Create(ConfigurationManager.Instance.config.URL_RealSymptomsByDisease);
request.AutomaticDecompression = DecompressionMethods.GZip;
XmlSerializer serializer = new XmlSerializer(typeof(SymptomsEval.JDBOR));
SymptomsEval.JDBOR result = new SymptomsEval.JDBOR();
using (var response = (HttpWebResponse)request.GetResponse())
using (var stream = response.GetResponseStream())
using (var reader = XmlReader.Create(stream, new XmlReaderSettings {
DtdProcessing = DtdProcessing.Ignore
}))
{
result = serializer.Deserialize(reader) as SymptomsEval.JDBOR;
}
var disorders = result.DisorderList[0].Disorder;
foreach (var disorder in disorders)
{
//Constructing DiseaseData
DiseaseData myDiseaseData = new DiseaseData(
Diseases.Where(x => x.OrphaNumber == disorder.OrphaNumber).FirstOrDefault(),
new RelatedEntities(type.Symptom, new List <RelatedEntity>()));
var hpoPhenotypes = disorder.HPODisorderAssociationList[0].HPODisorderAssociation.ToList();
for (int j = 0; j < hpoPhenotypes.Count; j++)
{
string symptomName = hpoPhenotypes[j].HPO[0].HPOTerm.ToLower();
//Frequency
var frequency = hpoPhenotypes[j].HPOFrequency[0].Name[0].Value;
double weight = 0;
if (frequency.Equals("Obligate (100%)"))
{
weight = 100.0;
}
else if (frequency.Equals("Very frequent (99-80%)"))
{
weight = 90.0;
}
else if (frequency.Equals("Frequent (79-30%)"))
{
weight = 55.0;
}
else if (frequency.Equals("Occasional (29-5%)"))
{
weight = 17.5;
}
else if (frequency.Equals("Very rare (<4-1%)"))
{
weight = 2.5;
}
RelatedEntity symptom = new RelatedEntity(type.Symptom, symptomName, weight);
myDiseaseData.RelatedEntities.RelatedEntitiesList.Add(symptom);
}
RealData.DiseaseDataList.Add(myDiseaseData);
}
}
static void RecupSymptomsAndTextMine(List <Disease> lst_diseases, TextMiningEngine textMiningEngine)
{
using (var predictionDataRepository = new MongoRepository.PredictionDataRepository())
{
//Delete ALL prediction disease data...
predictionDataRepository.removeAll();
//Init the new PredictionData
DiseasesData PredictionData = new DiseasesData(type.Symptom, new List <DiseaseData>());
//BatchConfig
int batchSize = ConfigurationManager.Instance.config.BatchSizeTextMining;
int nombreBatch = (lst_diseases.Count / batchSize) + 1;
if ((nombreBatch - 1) * batchSize == lst_diseases.Count)
{
nombreBatch--;
}
//TimeLeft initialization
TimeLeft.Instance.Reset();
TimeLeft.Instance.operationsToDo = nombreBatch;
for (int i = 0; i < nombreBatch; i++)
{
Stopwatch diffTime = new Stopwatch();
diffTime.Start();
//BatchSize adjustement
int realBatchSize = batchSize;
if ((i + 1) * realBatchSize > lst_diseases.Count)
{
realBatchSize = lst_diseases.Count - i * realBatchSize;
}
var selectedDiseases = lst_diseases.GetRange(i * realBatchSize, realBatchSize);
//REAL Process
//Publication recup
//Console.WriteLine("Publications recup...");
publicationsPerDisease = new List <List <Publication> >();
using (var publicationRepository = new MongoRepository.PublicationRepository())
{
//Retrieving publications of selected diseases
//Parallel.ForEach(lst_diseases, (disease) =>
foreach (Disease disease in selectedDiseases)
{
List <Publication> pubs = publicationRepository.getByOrphaNumberOfLinkedDisease(disease.OrphaNumber);
if (pubs.Count != 0)
{
publicationsPerDisease.Add(pubs);
}
}
//Console.WriteLine("Publications recup finished!");
//);
//Extraction Symptomes
//Console.WriteLine("Extraction Symptoms...");
//foreach(List<Publication> pubs in publicationsPerDisease)
Parallel.ForEach(publicationsPerDisease, (pubs) =>
{
if (pubs.Count != 0)
{
//Extract symptoms
DiseaseData dataOneDisease = textMiningEngine.GetPredictionDataFromPublicationsOfOneDisease(
pubs,
selectedDiseases.Where(disease => disease.OrphaNumber == pubs[0].orphaNumberOfLinkedDisease).FirstOrDefault());
PredictionData.DiseaseDataList.Add(dataOneDisease);
}
}
);
}
diffTime.Stop();
TimeLeft.Instance.IncrementOfXOperations(TimeSpan.FromMilliseconds(diffTime.ElapsedMilliseconds).Seconds, 1);
TimeLeft.Instance.CalcAndShowTimeLeft(i + 1, nombreBatch);
}
//Insert in DB
if (PredictionData.DiseaseDataList.Count != 0)
{
try
{
//Cut in 10 parts
int numberOfDocument = 10;
int numberDiseases = PredictionData.DiseaseDataList.Count / numberOfDocument;
int rest = PredictionData.DiseaseDataList.Count % numberOfDocument;
for (int i = 0; i < numberOfDocument; i++)
{
if (rest != 0 && i == numberOfDocument - 1)
{
predictionDataRepository.insert(
new DiseasesData(
type.Symptom,
PredictionData.DiseaseDataList
.Skip(i * numberDiseases)
.Take(rest)
.ToList()
)
);
}
else
{
predictionDataRepository.insert(
new DiseasesData(
type.Symptom,
PredictionData.DiseaseDataList
.Skip(i * numberDiseases)
.Take(numberDiseases)
.ToList()
)
);
}
}
//predictionDataRepository.insert(PredictionData);
}
catch (Exception e)
{
Console.WriteLine(e);
Console.WriteLine("Error on insertion of PredictionData");
}
}
}
}
//Apply to one disease only
public DiseaseData GetPredictionDataCountFromPublicationsOfOneDisease(List <Publication> publications, Disease disease)
{
DiseaseData PredictionData = new DiseaseData(disease,
new RelatedEntities(
type.Symptom,
new List <RelatedEntity>()
)
);
List <RelatedEntity> relatedEntities = PredictionData.RelatedEntities.RelatedEntitiesList;
List <System.String> texts = new List <System.String>();
foreach (Publication publication in publications)
{
stringBuilder.Clear();
stringBuilder.Append(publication.title);
stringBuilder.Append(" ");
stringBuilder.Append(publication.abstractText);
stringBuilder.Append(" ");
stringBuilder.Append(publication.fullText);
string text = stringBuilder.ToString();
//Text preprocessing
text = text.ToLower();
//NAMED ENTITY RECOGNITION
Chunking chunking = chunker.chunk(text);
CharSequence cs = chunking.charSequence();
Set chunkSet = chunking.chunkSet();
Iterator iterator = chunkSet.iterator();
while (iterator.hasNext())
{
Chunk chunk = (Chunk)iterator.next();
int start = chunk.start();
int end = chunk.end();
string str = cs.subSequence(start, end).toString();
int index = relatedEntities.FindIndex(symptom => symptom.Name.Equals(str) || symptom.Synonyms.IndexOf(str) != -1);
if (index != -1)
{
//relatedEntities[index].Weight++;
relatedEntities[index].TermFrequencies.Where(tf => tf.TFType == TFType.RawCount).FirstOrDefault().Value++;
}
else
{
//Find infos from phenotypes lists
Symptom symptomFromPhetotypes = symptomsList.Where(x => x.Name.Equals(str) || x.Synonyms.IndexOf(str) != -1).FirstOrDefault();
//Add the real Symptom if it exists
if (symptomFromPhetotypes != null)
{
RelatedEntity myRealEntity = new RelatedEntity(
type.Symptom,
symptomFromPhetotypes.Name,
1.0,
symptomFromPhetotypes.Synonyms
);
myRealEntity.TermFrequencies.Where(tf => tf.TFType == TFType.RawCount).FirstOrDefault().Value = 1.0;
relatedEntities.Add(myRealEntity);
}
}
}
}
/*
* //Sort and Take only a the best symptoms (see config file)
* PredictionData.RelatedEntities.RelatedEntitiesList =
* PredictionData.RelatedEntities.RelatedEntitiesList
* .OrderByDescending(x => x.TermFrequencies.Where(tf => tf.TFType == TFType.RawCount).FirstOrDefault().Value)
* .Take(ConfigurationManager.Instance.config.MaxNumberSymptoms)
* .ToList();
*/
/*
* ///TEEEEEEEEEEEST
* extractedSymptoms = new List<Symptom>();
* for (int k = 0; k < 42; k++)
* {
* Symptom symptom = new Symptom();
* symptom.Name = "Paul";
* symptom.OrphaNumber = "caca";
* symptom.Weight = 42;
* extractedSymptoms.Add(symptom);
* }*/
return(PredictionData);
}
//Apply to one disease only
public DiseaseData GetPredictionDataFromPublicationsOfOneDisease(List <Publication> publications, Disease disease)
{
DiseaseData PredictionData = new DiseaseData(disease,
new RelatedEntities(
type.Symptom,
new List <RelatedEntity>()
)
);
List <RelatedEntity> relatedEntities = PredictionData.RelatedEntities.RelatedEntitiesList;
List <System.String> texts = new List <System.String>();
foreach (Publication publication in publications)
{
string text = publication.title + " " + publication.abstractText + " " + publication.fullText;
//Text preprocessing
text = text.ToLower();
//NAMED ENTITY RECOGNITION
Chunking chunking = chunkerHMM.chunk(text);
CharSequence cs = chunking.charSequence();
Set chunkSet = chunking.chunkSet();
Iterator iterator = chunkSet.iterator();
while (iterator.hasNext())
{
Chunk chunk = (Chunk)iterator.next();
int start = chunk.start();
int end = chunk.end();
string str = cs.subSequence(start, end).toString();
int index = relatedEntities.FindIndex(symptom => symptom.Name.Equals(str) || symptom.Synonyms.IndexOf(str) != -1);
if (index != -1)
{
relatedEntities[index].Weight++;
}
else
{
//Find infos from phenotypes lists
Symptom symptomFromPhetotypes = symptomsList.Where(x => x.Name.Equals(str) || x.Synonyms.IndexOf(str) != -1).FirstOrDefault();
//Add the real Symptom
relatedEntities.Add(
new RelatedEntity(
type.Symptom,
symptomFromPhetotypes.Name,
1.0,
symptomFromPhetotypes.Synonyms
)
);
}
}
}
//Symptom Weight Normalization from 0 to 100
for (int i = 0; i < relatedEntities.Count; i++)
{
//Find Min and Max for Normalization
double max = relatedEntities.Max(x => x.Weight);
double min = relatedEntities.Min(x => x.Weight);
//Normalization
if (max == min)//If size==1
{
if (relatedEntities[i].Weight > 100.0)
{
relatedEntities[i].Weight = 100.0;
}
}
else
{
relatedEntities[i].Weight = 100 * (relatedEntities[i].Weight - min) / (max - min);
}
}
//Sort related entities by descending weight
PredictionData.RelatedEntities.RelatedEntitiesList.OrderByDescending(x => x.Weight).ToList();
//Take only a the best symptoms (see config file)
PredictionData.RelatedEntities.RelatedEntitiesList =
PredictionData.RelatedEntities.RelatedEntitiesList
.OrderByDescending(x => x.Weight)
.Take(ConfigurationManager.Instance.config.MaxNumberSymptoms)
.ToList();
/*
* ///TEEEEEEEEEEEST
* extractedSymptoms = new List<Symptom>();
* for (int k = 0; k < 42; k++)
* {
* Symptom symptom = new Symptom();
* symptom.Name = "Paul";
* symptom.OrphaNumber = "caca";
* symptom.Weight = 42;
* extractedSymptoms.Add(symptom);
* }*/
return(PredictionData);
}
public static Results Evaluate(DiseasesData PredictionData, DiseasesData RealData,
Tuple <TFType, IDFType> WeightCombinaison,
double threshold = -1.0)
{
//Object to write in JSON
Results results = new Results();
int RP = 0; //RealPositive general
int FP = 0; //FalsePositive general
int FN = 0; //FalseNegative general
int NumberOfDiseasesWithKnownPhenotypes = RealData.DiseaseDataList.Count;
int NumberOfDiseasesWithPublicationsInPredictionData = PredictionData.DiseaseDataList.Count(x => x.Disease.NumberOfPublications != 0);
int NumberOfDiseasesEvaluatedForReal = 0;
//For each existent rare disease
foreach (string orphaNumber in PredictionData.DiseaseDataList.Select(x => x?.Disease?.OrphaNumber))
{
//Find THE diseaseData of ONE disease (real and predicted data)
DiseaseData RealDiseaseData = RealData.DiseaseDataList.Where(x => x?.Disease?.OrphaNumber == orphaNumber).FirstOrDefault();
DiseaseData PredictionDiseaseData = PredictionData.DiseaseDataList.Where(
x => x?.Disease?.OrphaNumber == orphaNumber &&
x.Disease.NumberOfPublications != 0).FirstOrDefault();
//If we don't find the disease in both dataset, we shoud pass to another disease
if (RealDiseaseData != null && PredictionDiseaseData != null)
{
NumberOfDiseasesEvaluatedForReal++;//Increase number of diseases evaluated
Dictionary <RelatedEntity, double> RealWeightOfPhenotypes = new Dictionary <RelatedEntity, double>();
List <RelatedEntity> RealPhenotypes = new List <RelatedEntity>();
double MR_Disease = 0.0; //MeanRank RealPhenotype of one disease
int RP_Disease = 0; //RealPositive of one disease
int FP_Disease = 0; //FalsePositive of one disease
int FN_Disease = 0; //FalseNegative of one disease
//Compute RP and FP
List <string> RelatedEntitiesNamesReal =
RealDiseaseData
.RelatedEntities.RelatedEntitiesList
.Select(x => x.Name)
.ToList();
int NumberOfRelatedEntitiesFound = PredictionDiseaseData.RelatedEntities.RelatedEntitiesList.Count;
for (int j = 0; j < NumberOfRelatedEntitiesFound; j++)
{
double realWeight = PredictionDiseaseData.RelatedEntities.RelatedEntitiesList[j]
.CalcFinalWeight(WeightCombinaison.Item1, WeightCombinaison.Item2);
RealWeightOfPhenotypes.Add(PredictionDiseaseData.RelatedEntities.RelatedEntitiesList[j], realWeight);
if (threshold == -1.0 || realWeight >= threshold)
{
//Is my predicted related entity is present in the real data?
if (RelatedEntitiesNamesReal.IndexOf(PredictionDiseaseData.RelatedEntities.RelatedEntitiesList[j].Name) != -1)
{
RP++;
RP_Disease++;
RealPhenotypes.Add(PredictionDiseaseData.RelatedEntities.RelatedEntitiesList[j]);
}
else
{
FP++;
FP_Disease++;
}
}
}
//Compute FN
List <string> RelatedEntitiesNamesPred =
PredictionDiseaseData
.RelatedEntities.RelatedEntitiesList
.Select(x => x.Name)
.ToList();
for (int j = 0; j < RealDiseaseData.RelatedEntities.RelatedEntitiesList.Count; j++)
{
//Is my real related entity is present in the predicted data?
if (RelatedEntitiesNamesPred.IndexOf(RealDiseaseData.RelatedEntities.RelatedEntitiesList[j].Name) == -1)
{
FN++;
FN_Disease++;
}
}
//Compute Precision/recall and F_score
double PrecisionDisease = 0.0;
double RecallDisease = 0.0;
double F_ScoreDisease = 0.0;
if (RP_Disease + FP_Disease != 0)
{
PrecisionDisease = Math.Round((double)RP_Disease / (double)(RP_Disease + FP_Disease), 4);
}
if (RP_Disease + FN_Disease != 0)
{
RecallDisease = Math.Round((double)RP_Disease / (double)(RP_Disease + FN_Disease), 4);
}
if (PrecisionDisease + RecallDisease != 0.0)
{
F_ScoreDisease = Math.Round(2 * PrecisionDisease * RecallDisease / (PrecisionDisease + RecallDisease), 4);
}
////////////////////
//Compute MeanRank//
////////////////////
//Compute Ranks
Dictionary <RelatedEntity, double> RanksPhenotypes = new Dictionary <RelatedEntity, double>();
RanksPhenotypes = RealWeightOfPhenotypes.OrderByDescending(p => p.Value).Select((p, i) => new KeyValuePair <RelatedEntity, double>(p.Key, i + 1.0)).ToDictionary(p => p.Key, p => p.Value);
//Keep Only real Phenotypes
RanksPhenotypes =
RanksPhenotypes
.Where(elem => RealPhenotypes.Select(x => x.Name).ToList().IndexOf(elem.Key.Name) != -1)
.ToDictionary(p => p.Key, p => p.Value);
//MeanRank of Real Phenotypes in one disease
if (RanksPhenotypes.Count != 0)
{
MR_Disease = RanksPhenotypes.Average(p => p.Value);
}
//Construct results object
PerDisease OnePerDisease = new PerDisease(orphaNumber,
PredictionDiseaseData.Disease.NumberOfPublications,
PredictionData.Type,
NumberOfRelatedEntitiesFound,
RP_Disease,
FP_Disease,
FN_Disease,
PrecisionDisease, //Precision
RecallDisease, //Recall
F_ScoreDisease,
MR_Disease
);
results.perDisease.Add(OnePerDisease);
}
}
//Compute Precision/recall and F_score general
double Precision = 0.0;
double Recall = 0.0;
double F_Score = 0.0;
if (RP + FP != 0)
{
Precision = Math.Round((double)RP / (double)(RP + FP), 4);
}
if (RP + FN != 0)
{
Recall = Math.Round((double)RP / (double)(RP + FN), 4);
}
if (Precision + Recall != 0.0)
{
F_Score = Math.Round(2 * Precision * Recall / (Precision + Recall), 4);
}
//Compute MeanRank general
double MeanRankRealPositiveGeneral = 0.0;//MeanRank RealPhenotype general
//Compute standard deviation
double StandardDeviationRankRealPositivesGeneral = 0.0;
//Filter PerDisease where MeanRankRealPositives = 0.0
List <PerDisease> perdiseasesFiltered = results.perDisease.Where(pd => pd.MeanRankRealPositives != 0.0).ToList();
if (perdiseasesFiltered.Count != 0)
{
MeanRankRealPositiveGeneral = perdiseasesFiltered.Average(pd => pd.MeanRankRealPositives);
StandardDeviationRankRealPositivesGeneral =
Math.Sqrt
(
perdiseasesFiltered.Average
(
pd => Math.Pow(pd.MeanRankRealPositives - MeanRankRealPositiveGeneral, 2)
)
);
}
//Compute MeanNumberOfRelatedEntitiesFound
double MeanNumberOfRelatedEntitiesFound = results.perDisease.Average(pd => pd.NumberOfRelatedEntitiesFound);
//Compute standard deviation
double StandardDeviationNumberOfRelatedEntitiesFound =
Math.Sqrt
(
results.perDisease.Average
(
pd => Math.Pow(pd.NumberOfRelatedEntitiesFound - MeanNumberOfRelatedEntitiesFound, 2)
)
);
//Construct results object
results.general = new General(
DateTime.Now,
NumberOfDiseasesWithKnownPhenotypes,
NumberOfDiseasesWithPublicationsInPredictionData,
NumberOfDiseasesEvaluatedForReal,
PredictionData.Type,
MeanNumberOfRelatedEntitiesFound,
StandardDeviationNumberOfRelatedEntitiesFound,
WeightCombinaison.Item1,
WeightCombinaison.Item2,
threshold,
RP,
FP,
FN,
Precision,
Recall,
F_Score,
MeanRankRealPositiveGeneral,
StandardDeviationRankRealPositivesGeneral);
return(results);
}
static void LaunchBatchs_Recup_Count(
int nombreBatch, //Batch config
int batchSize, //Batch config
List <Disease> lst_diseases, //Complete list of diseases to select diseases
TextMiningEngine textMiningEngine, //Engine to text mine (count here)
DiseasesData PredictionData //Var to complete
)
{
for (int i = 0; i < nombreBatch; i++)
{
Stopwatch diffTime = new Stopwatch();
diffTime.Start();
//BatchSize adjustement
int realBatchSize = batchSize;
if ((i + 1) * realBatchSize > lst_diseases.Count)
{
realBatchSize = lst_diseases.Count - i * realBatchSize;
}
var selectedDiseases = lst_diseases.GetRange(i * realBatchSize, realBatchSize);
//REAL Process
//Publication recup
//Console.WriteLine("Publications recup...");
publicationsPerDisease = new Dictionary <string, List <Publication> >();
using (var publicationRepository = new MongoRepository.PublicationRepository())
{
//Retrieving publications of selected diseases
//Parallel.ForEach(lst_diseases, (disease) =>
foreach (Disease disease in selectedDiseases)
{
List <Publication> pubs = publicationRepository.getByOrphaNumberOfLinkedDisease(disease.OrphaNumber);
if (pubs.Count != 0)
{
publicationsPerDisease.Add(disease.OrphaNumber, pubs);
}
else
{
publicationsPerDisease.Add(disease.OrphaNumber, new List <Publication>());
}
}
//Console.WriteLine("Publications recup finished!");
//);
//Extraction Symptomes
//Console.WriteLine("Extraction Symptoms...");
//foreach(var pubs in publicationsPerDisease)
Parallel.ForEach(publicationsPerDisease, (pubs) =>
{
if (pubs.Value.Count != 0)
{
//Extract symptoms
DiseaseData dataOneDisease = textMiningEngine.GetPredictionDataCountFromPublicationsOfOneDisease(
pubs.Value,
selectedDiseases.Where(disease => disease.OrphaNumber == pubs.Key).FirstOrDefault());
PredictionData.DiseaseDataList.Add(dataOneDisease);
}
else
{
DiseaseData dataOneDisease = new DiseaseData(
selectedDiseases.Where(disease => disease.OrphaNumber == pubs.Key).FirstOrDefault(),
new RelatedEntities(type.Symptom, new List <RelatedEntity>()));
PredictionData.DiseaseDataList.Add(dataOneDisease);
}
}
);
}
diffTime.Stop();
TimeLeft.Instance.IncrementOfXOperations(TimeSpan.FromMilliseconds(diffTime.ElapsedMilliseconds).Seconds, 1);
TimeLeft.Instance.CalcAndShowTimeLeft(i + 1, nombreBatch);
}
}
