Machine learning project module

mzLib/MachineLearning/DeepTorch.cs

@@ -0,0 +1,155 @@
+using MathNet.Numerics.Statistics;
+using Proteomics.PSM;
+using TorchSharp;
+using TorchSharp.Modules;
+
+namespace MachineLearning
+{
+    /// <summary>
+    /// Abstract class for one dimensional input size TorchSharp models.
+    /// </summary>
+    public abstract class DeepTorch : torch.nn.Module<torch.Tensor, torch.Tensor>
+    {
+        public DeepTorch(string preTrainedModelPath = null, bool evalMode = true,
+            DeviceType device = DeviceType.CPU)
+            : base(nameof(DeepTorch))
+        {
+            RegisterComponents();
+
+            if (preTrainedModelPath != null)
+                LoadPreTrainedModel(preTrainedModelPath);
+
+            if (evalMode)
+                EvaluationMode();
+            else
+                TrainingMode();
+
+            this.to(device);
+        }
+
+        /// <summary>
+        /// Defines the computation performed at every call. Do not use for inferring, use .Predict() instead.
+        /// </summary>
+        /// <param name="input"></param>
+        /// <returns></returns>
+        public abstract override torch.Tensor forward(torch.Tensor input);
+
+        public virtual torch.Tensor Predict(torch.Tensor input)
+        {
+            return this.call(input);
+        }
+
+        /// <summary>
+        /// Defines the behavior of the module during training phase.
+        /// </summary>
+        public abstract void Train(string modelSavingPath, List<PsmFromTsv> trainingData,
+            Dictionary<(char, string), int> dictionary, DeviceType device, float validationFraction,
+            float testingFraction, int batchSize, int epochs, int patience);
+
+        /// <summary>
+        /// Defines the behavior of the model when loading pre-trained weights.
+        /// </summary>
+        /// <param name="weightsPath"></param>
+        /// <param name="strict"></param>
+        public virtual void LoadPreTrainedModel(string weightsPath, bool strict = true)
+        {
+            this.load(weightsPath, strict);
+        }
+
+        /// <summary>
+        /// Stipulates an early stop condition to prevent overfitting.
+        /// </summary>
+        protected virtual bool EarlyStop(double score, double currentBestScore, int currentPatience,
+            out double bestScore, out int patience)
+        {
+            if (score < currentBestScore && currentPatience > 0)
+            {
+                bestScore = score;
+                patience = currentPatience - 1;
+                return false;
+            }
+
+            bestScore = currentBestScore;
+            patience = 0;
+            return true;
+
+        }
+
+        /// <summary>
+        /// Generates a checkpoint to save the model at indicated step.
+        /// </summary>
+        protected virtual void Checkpoint(string checkPointPath, int epoch)
+        {
+
+            Directory.CreateDirectory(checkPointPath);
+            Directory.CreateDirectory(checkPointPath + "/Model" + epoch);
+            SaveModel(checkPointPath + "/Model" + epoch + "checkpointModel");
+        }
+
+        protected virtual void ModelPerformance(string savingPath, double bestScore, double accuracy,
+            List<double> predictions,
+            List<double> labels)
+        {
+            using (var writter = new System.IO.StreamWriter(savingPath + ".txt"))
+            {
+                writter.WriteLine($"Best score: {bestScore}");
+                writter.WriteLine($"Accuracy: {accuracy}");
+                writter.WriteLine($"R^2: " + Correlation.Pearson(predictions, labels));
+                writter.WriteLine($"Predictions: {predictions}");
+                writter.WriteLine($"Labels: {labels}");
+            }
+        }
+        /// <summary>
+        /// Learning Rate Decay.
+        /// </summary>
+        protected virtual torch.optim.lr_scheduler.LRScheduler _scheduler =>
+            torch.optim.lr_scheduler.StepLR(new Adam(this.parameters()), 25, 0.1);
+
+        /// <summary>
+        /// Sets model into training mode.
+        /// </summary>
+        public virtual void TrainingMode()
+        {
+            this.train(true);
+        }
+
+        /// <summary>
+        /// Sets model into evaluation mode.
+        /// </summary>
+        public virtual void EvaluationMode()
+        {
+            this.eval();
+            this.train(false);
+        }
+
+        /// <summary>
+        /// Saves the trained weights as a .dat file (TorchSharp format).
+        /// </summary>
+        /// <param name="modelSavingPath"></param>
+        public virtual void SaveModel(string modelSavingPath)
+        {
+            EvaluationMode();
+
+            if (modelSavingPath.EndsWith(".dat"))
+                this.save(modelSavingPath);
+            else
+                this.save(modelSavingPath + ".dat");
+        }
+
+        protected abstract double Validate(DataLoader? validationDataLoader,
+            torch.nn.Module<torch.Tensor, torch.Tensor, torch.Tensor> criterion, DeviceType device);
+        protected abstract (double, List<double>, List<double>) Test(DataLoader? testingDataLoader,
+                       torch.nn.Module<torch.Tensor, torch.Tensor, torch.Tensor> criterion, DeviceType device);
+        public abstract TorchDataset? TrainingDataset { get; set; }
+        public abstract TorchDataset? TestingDataset { get; set; }
+        public abstract TorchDataset? ValidationDataset { get; set; }
+        public abstract torch.Tensor Tensorize(object toTensoize);
+
+        // public abstract Dictionary<string, torch.Tensor> GetTensor(long index);
+
+        // sets nullable filed Dataset to a new instance of a TorchDataset
+        public abstract void CreateDataSet(List<PsmFromTsv> data, float validationFraction, float testingFraction, int batchSize);
+
+        protected abstract void CreateDataLoader(int batchSize);
+    }
+}

mzLib/MachineLearning/DictionaryBuilder.cs

@@ -0,0 +1,118 @@
+using System;
+using System.Collections.Generic;
+using System.Linq;
+
+namespace UsefulProteomicsDatabases
+{
+    /// <summary>
+    /// This class provides static methods to build dictionaries for different models.
+    /// </summary>
+    public static class DictionaryBuilder
+    {
+        public static Dictionary<(char, string), int>
+            GetChronologerDictionary(TypeOfDictionary dict)
+        {
+            var dictionary = new Dictionary<(char, string), int>()
+            {
+                { ('A', ""), 1  }, //'Alanine
+                { ('C', ""), 2  }, //'Cysteine
+                { ('D', ""), 3  }, //'Aspartate
+                { ('E', ""), 4  }, //'Glutamate
+                { ('F', ""), 5  }, //'Phenylalaline
+                { ('G', ""), 6  }, //'Glycine
+                { ('H', ""), 7  }, //'Histidine
+                { ('I', ""), 8  }, //'Isoleucine
+                { ('K', ""), 9  }, //'Lysine
+                { ('L', ""), 10 }, //'Leucine
+                { ('M', ""), 11 }, //'Methionine
+                { ('N', ""), 12 }, //'Asparagine
+                { ('P', ""), 13 }, //'Proline
+                { ('Q', ""), 14 }, //'Glutamine
+                { ('R', ""), 15 }, //'Argenine
+                { ('S', ""), 16 }, //'Serine
+                { ('T', ""), 17 }, //'Threonine
+                { ('V', ""), 18 }, //'Valine
+                { ('W', ""), 19 }, //'Tryptophane
+                { ('Y', ""), 20 }, //'Tyrosine
+                {('C', "C-Terminus"), 38},
+                {('N', "N-Terminus"), 44}
+            };
+
+            //todo: change numbers to accession numbers from DB
+            if (dict == TypeOfDictionary.Unimod)
+            {
+                int aaCount = 20;
+
+                var mods =
+                    Loaders.LoadUnimod(@"F:\Research\Data\unimod.xml").ToList();
+
+                var groupedModsByOriginalID =
+                    mods.GroupBy(x => x.Target.ToString()).ToList();
+
+                foreach (var target in groupedModsByOriginalID)
+                {
+                    foreach (var mod in target)
+                    {
+                        aaCount = aaCount + 1;
+
+                        //C-Terminus and N-Terminus
+                        if(aaCount == 38 || aaCount == 44)
+                        {
+                            aaCount = aaCount + 1;
+                        }
+
+                        if (!dictionary.ContainsKey((Char.Parse(target.Key), mod.IdWithMotif)))
+                            dictionary.Add((Char.Parse(target.Key), mod.IdWithMotif), aaCount);
+                    }
+                }
+
+                return dictionary;
+            }
+
+            if (dict == TypeOfDictionary.Chronologer)
+            {
+                var chronologerModsDict = new Dictionary<(char, string), int>()
+                {
+                    { ('C', "Carbamidomethyl on C"), 21 }, //'Carbamidomethyl
+                    { ('M', "Oxidation on M"), 22 }, //'Oxidized
+                    { ('C', "Pyro-carbamidomethyl on C"), 23 },//'S - carbamidomethylcysteine
+                    { ('E', "Glu to PyroGlu"), 24 }, //'Pyroglutamate
+                    { ('S', "Phosphorylation on S"), 25 }, //'Phosphoserine
+                    { ('T', "Phosphorylation on T"), 26 }, //'Phosphothreonine
+                    { ('Y', "Phosphorylation on Y"), 27 }, //'Phosphotyrosine
+                    { ('K', "Accetylation on K"), 28 }, //'Acetylated
+                    { ('K', "Succinylation on K"), 29 }, //'Succinylated
+                    { ('K', "Ubiquitination on K"), 30 }, //'Ubiquitinated
+                    { ('K', "Methylation on K"), 31 }, //'Monomethyl
+                    { ('K', "Dimethylation on K"), 32 }, //'Dimethyl
+                    { ('K', "Trimethylation on K"), 33 }, //'Trimethyl
+                    { ('R', "Methylation on R"), 34 }, //'Monomethyl
+                    { ('R', "Dimethylation on R"), 35 }, //'Dimethyl
+                    { ('K', "TMT on K"), 36 }, //TMT0-modified lysisne
+                    { ('K', "TMT6plex on K"), 37 }, //tmt10-modified lysine
+
+                };
+
+                foreach (var item in chronologerModsDict)
+                {
+                    if (!dictionary.ContainsKey(item.Key))
+                        dictionary.Add(item.Key, item.Value);
+                }
+            }
+
+            if (dict == TypeOfDictionary.CanonicalAA)
+            {
+                return dictionary;
+            }
+
+            return dictionary;
+        }
+
+        public enum TypeOfDictionary
+        {
+            CanonicalAA,
+            Chronologer,
+            Unimod
+        }
+    }
+}

mzLib/MachineLearning/MachineLearning.csproj

@@ -0,0 +1,24 @@
+<Project Sdk="Microsoft.NET.Sdk">
+
+  <PropertyGroup>
+    <TargetFramework>net6.0</TargetFramework>
+    <ImplicitUsings>enable</ImplicitUsings>
+    <Nullable>enable</Nullable>
+    <Platforms>x64</Platforms>
+  </PropertyGroup>
+
+  <ItemGroup>
+    <ProjectReference Include="..\Proteomics\Proteomics.csproj" />
+    <ProjectReference Include="..\UsefulProteomicsDatabases\UsefulProteomicsDatabases.csproj" />
+  </ItemGroup>
+
+  <ItemGroup>
+    <None Update="RetentionTimePredictionModels\Chronologer_20220601193755_TorchSharp.dat">
+      <CopyToOutputDirectory>Always</CopyToOutputDirectory>
+    </None>
+    <None Update="unimod.xml">
+      <CopyToOutputDirectory>PreserveNewest</CopyToOutputDirectory>
+    </None>
+  </ItemGroup>
+
+</Project>

mzLib/MachineLearning/MachineLearningDiagram.cd

@@ -0,0 +1,42 @@
+<?xml version="1.0" encoding="utf-8"?>
+<ClassDiagram MajorVersion="1" MinorVersion="1">
+  <Class Name="MachineLearning.DeepTorch">
+    <Position X="8" Y="2" Width="4.5" />
+    <TypeIdentifier>
+      <HashCode>AAAgAgAAAACAAgAAAAAxAAAIICgAIAQAAIAACABCAAg=</HashCode>
+      <FileName>DeepTorch.cs</FileName>
+    </TypeIdentifier>
+  </Class>
+  <Class Name="MachineLearning.TorchDataset">
+    <Position X="14.25" Y="2.5" Width="3" />
+    <TypeIdentifier>
+      <HashCode>AAAAAAACAAAAAAAAAAAAAAQAAAAAABAAAAAAQAAAAAA=</HashCode>
+      <FileName>TorchDataset.cs</FileName>
+    </TypeIdentifier>
+  </Class>
+  <Class Name="MachineLearning.RetentionTimePredictionModels.Chronologer">
+    <Position X="8.75" Y="8" Width="3.25" />
+    <TypeIdentifier>
+      <HashCode>ABIgAgAIAACAAAAAAAAwQAAIOCAAAEAAAIAACAACACg=</HashCode>
+      <FileName>RetentionTimePredictionModels\Chronologer.cs</FileName>
+    </TypeIdentifier>
+  </Class>
+  <Class Name="UsefulProteomicsDatabases.DictionaryBuilder">
+    <Position X="13.75" Y="8" Width="4.25" />
+    <Compartments>
+      <Compartment Name="Nested Types" Collapsed="false" />
+    </Compartments>
+    <NestedTypes>
+      <Enum Name="UsefulProteomicsDatabases.DictionaryBuilder.TypeOfDictionary" Collapsed="true">
+        <TypeIdentifier>
+          <NewMemberFileName>DictionaryBuilder.cs</NewMemberFileName>
+        </TypeIdentifier>
+      </Enum>
+    </NestedTypes>
+    <TypeIdentifier>
+      <HashCode>AAAAAAAAAAACAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA=</HashCode>
+      <FileName>DictionaryBuilder.cs</FileName>
+    </TypeIdentifier>
+  </Class>
+  <Font Name="Segoe UI" Size="9" />
+</ClassDiagram>