Added more documentation

Author: ooples

src/Enums/PredictionType.cs

@@ -1,7 +1,52 @@
 namespace AiDotNet.Enums;
 
+/// <summary>
+/// Specifies the type of prediction task that a machine learning model performs.
+/// </summary>
+/// <remarks>
+/// For Beginners: This enum helps you tell the library what kind of prediction you're trying to make.
+/// Think of it as telling the AI system what type of question you're asking:
+/// 
+/// - Are you asking a yes/no question? Use Binary.
+/// - Are you asking "how much" or "what value"? Use Regression.
+/// 
+/// Choosing the right prediction type helps the AI model understand what you're trying to accomplish
+/// and use the appropriate techniques for your specific problem.
+/// </remarks>
 public enum PredictionType
 {
+    /// <summary>
+    /// Represents a binary classification task where the output is one of two possible classes.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: Use this when your prediction has only two possible outcomes, like:
+    /// - Yes or No
+    /// - True or False
+    /// - Spam or Not Spam
+    /// - Positive or Negative
+    /// 
+    /// Binary predictions typically output a probability between 0 and 1, where:
+    /// - Values closer to 0 indicate the first class (e.g., "No")
+    /// - Values closer to 1 indicate the second class (e.g., "Yes")
+    /// 
+    /// Examples: Email spam detection, disease diagnosis, fraud detection
+    /// </remarks>
     Binary,
+
+    /// <summary>
+    /// Represents a regression task where the output is a continuous numerical value.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: Use this when your prediction is a number that can take any value within a range, like:
+    /// - Price of a house
+    /// - Temperature tomorrow
+    /// - Number of sales next month
+    /// - Age of a person from their photo
+    /// 
+    /// Unlike Binary prediction, Regression doesn't have fixed categories - it predicts
+    /// actual numerical values that can be any number (like 42.5, 1000, or -3.14).
+    /// 
+    /// Examples: Price prediction, weather forecasting, age estimation, stock market prediction
+    /// </remarks>
     Regression
 }

src/Enums/RegularizationType.cs

@@ -1,9 +1,104 @@
 namespace AiDotNet.Enums;
 
+/// <summary>
+/// Specifies the type of regularization to apply to a machine learning model.
+/// </summary>
+/// <remarks>
+/// For Beginners: Regularization is like adding training wheels to your AI model.
+/// 
+/// When models learn too much from their training data, they might become too specialized
+/// (this is called "overfitting"). Regularization helps prevent this by encouraging the model
+/// to keep things simple.
+/// 
+/// Think of it like this:
+/// - Without regularization: The model might create very complex rules that work perfectly for
+///   training data but fail on new data.
+/// - With regularization: The model is encouraged to create simpler rules that work well enough
+///   for training data and are more likely to work on new data too.
+/// 
+/// Different regularization types use different approaches to encourage simplicity.
+/// </remarks>
 public enum RegularizationType
 {
+    /// <summary>
+    /// No regularization is applied to the model.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: This option turns off regularization completely.
+    /// 
+    /// Use this when:
+    /// - You have lots of training data compared to model complexity
+    /// - Your model is already simple and unlikely to overfit
+    /// - You want to see how the model performs without any restrictions
+    /// 
+    /// It's like removing the training wheels - sometimes it works fine,
+    /// but there's a higher risk the model might become too specialized to your training data.
+    /// </remarks>
     None,
+
+    /// <summary>
+    /// L1 regularization (also known as Lasso regularization) that encourages sparsity in the model parameters.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: L1 regularization encourages the model to completely ignore less important features.
+    /// 
+    /// It works by penalizing the absolute size of the model's parameters, which often results in
+    /// many parameters becoming exactly zero.
+    /// 
+    /// Think of it like a strict teacher who says: "If a feature isn't clearly helpful, don't use it at all."
+    /// 
+    /// Benefits:
+    /// - Automatically selects the most important features
+    /// - Creates simpler models that are easier to interpret
+    /// - Works well when you suspect many features aren't relevant
+    /// 
+    /// Example: If you're predicting house prices with 100 features, L1 might decide that only 20 features
+    /// (like size, location, and age) actually matter and ignore the rest.
+    /// </remarks>
     L1,
+
+    /// <summary>
+    /// L2 regularization (also known as Ridge regularization) that discourages large parameter values.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: L2 regularization encourages the model to use all features, but keep their influence small.
+    /// 
+    /// It works by penalizing the squared size of the model's parameters, which results in
+    /// all parameters becoming smaller but rarely exactly zero.
+    /// 
+    /// Think of it like a balanced teacher who says: "Use all the information available, but don't rely too much on any single piece."
+    /// 
+    /// Benefits:
+    /// - Handles correlated features well
+    /// - Generally prevents overfitting without eliminating features
+    /// - Usually the safest default choice for regularization
+    /// 
+    /// Example: For house price prediction, L2 might keep all 100 features but ensure that no single feature
+    /// (like having a swimming pool) has an excessively large impact on the prediction.
+    /// </remarks>
     L2,
+
+    /// <summary>
+    /// A combination of L1 and L2 regularization that balances their properties.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: ElasticNet combines the best of both L1 and L2 regularization.
+    /// 
+    /// It works by applying both types of penalties at the same time, with adjustable weights
+    /// to control how much of each to use.
+    /// 
+    /// Think of it like a flexible teacher who says: "Let's mostly keep all features but with limited influence,
+    /// while still completely removing the least useful ones."
+    /// 
+    /// Benefits:
+    /// - Can eliminate irrelevant features (like L1)
+    /// - Handles groups of correlated features well (like L2)
+    /// - Provides more flexibility through adjustable balance between L1 and L2
+    /// 
+    /// Example: For house price prediction, ElasticNet might eliminate 30 truly irrelevant features
+    /// while keeping the remaining 70 with appropriately controlled influence.
+    /// 
+    /// This is often the best choice when you're not sure which regularization to use.
+    /// </remarks>
     ElasticNet
 }

src/Enums/SamplingType.cs

@@ -1,8 +1,80 @@
 namespace AiDotNet.Enums;
 
+/// <summary>
+/// Specifies the method used to sample or combine values when reducing data dimensions.
+/// </summary>
+/// <remarks>
+/// For Beginners: Sampling is how we summarize a group of numbers into a single value.
+/// 
+/// In AI, we often need to take a collection of values (like a grid of pixels in an image)
+/// and represent them with fewer values. This process is called "downsampling" or "pooling".
+/// 
+/// Think of it like summarizing a neighborhood on a map:
+/// - You could pick the tallest building (Max)
+/// - You could calculate the average building height (Average)
+/// - You could use a special mathematical formula (L2Norm)
+/// 
+/// Different sampling types give different results and are useful in different situations.
+/// </remarks>
 public enum SamplingType
 {
+    /// <summary>
+    /// Takes the maximum value from the input region.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: Max sampling simply picks the largest number from a group of values.
+    /// 
+    /// For example, if you have these numbers: [2, 5, 1, 3], Max sampling would give you 5.
+    /// 
+    /// This is commonly used in neural networks for:
+    /// - Detecting if a feature is present anywhere in the region
+    /// - Reducing the size of images while preserving important details
+    /// - Making the model less sensitive to the exact position of features
+    /// 
+    /// Think of it like looking at a group of mountains and recording only the height of the tallest one.
+    /// It's good at preserving strong signals and ignoring weaker ones.
+    /// </remarks>
     Max,
+
+    /// <summary>
+    /// Takes the average (mean) value from the input region.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: Average sampling calculates the mean of all values in a group.
+    /// 
+    /// For example, if you have these numbers: [2, 5, 1, 3], Average sampling would give you 2.75.
+    /// 
+    /// This is useful for:
+    /// - Smoothing out noise in the data
+    /// - Capturing the general trend of all values in the region
+    /// - Reducing the impact of outliers or extreme values
+    /// 
+    /// Think of it like measuring the average temperature across a city instead of just the hottest spot.
+    /// It gives you a more balanced representation of the entire region.
+    /// </remarks>
     Average,
+
+    /// <summary>
+    /// Calculates the L2 norm (Euclidean norm) of the values in the input region.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: L2Norm sampling uses a special mathematical formula to combine values.
+    /// 
+    /// It works by:
+    /// 1. Squaring each number
+    /// 2. Adding up all the squared values
+    /// 3. Taking the square root of the sum
+    /// 
+    /// For example, if you have these numbers: [2, 5, 1, 3], L2Norm sampling would give you:
+    /// √(2² + 5² + 1² + 3²) = √(4 + 25 + 1 + 9) = √39 ≈ 6.24
+    /// 
+    /// This is useful for:
+    /// - Measuring the overall "energy" or "strength" of a signal
+    /// - Giving more weight to larger values without ignoring smaller ones
+    /// - Certain specialized neural network architectures
+    /// 
+    /// Think of it like measuring how "impactful" a group of values is collectively,
+    /// with larger values having more influence than smaller ones.
+    /// </remarks>
     L2Norm
 }

src/Enums/SpikingNeuronType.cs

@@ -1,10 +1,131 @@
 namespace AiDotNet.Enums;
 
+/// <summary>
+/// Specifies the type of spiking neuron model to use in neuromorphic computing simulations.
+/// </summary>
+/// <remarks>
+/// For Beginners: Spiking neurons are AI components that work more like real brain cells.
+/// 
+/// Traditional AI neurons output continuous values (like 0.7), but spiking neurons work with
+/// discrete "spikes" or pulses of activity (like a real neuron firing). This makes them more
+/// biologically realistic and potentially more efficient for certain tasks.
+/// 
+/// Think of regular AI neurons as light bulbs with dimmers that can be set to any brightness,
+/// while spiking neurons are more like light bulbs that either flash brightly or stay off.
+/// 
+/// Different spiking neuron types represent different mathematical models of how real neurons work,
+/// with varying levels of biological accuracy and computational complexity.
+/// </remarks>
 public enum SpikingNeuronType
 {
+    /// <summary>
+    /// A simplified neuron model that accumulates input and "leaks" voltage over time.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: This is like a leaky bucket collecting water (electrical charge).
+    /// 
+    /// How it works:
+    /// 1. The neuron collects incoming signals (like water filling a bucket)
+    /// 2. The bucket slowly leaks over time (the "leaky" part)
+    /// 3. When the water level reaches a certain height, the bucket tips over (neuron fires)
+    /// 4. After firing, the bucket is emptied and starts collecting again
+    /// 
+    /// This model is:
+    /// - Computationally efficient (fast to simulate)
+    /// - Simple to understand and implement
+    /// - Good for large-scale neural networks
+    /// 
+    /// It captures the basic behavior of real neurons while being much simpler than more detailed models.
+    /// </remarks>
     LeakyIntegrateAndFire,
+
+    /// <summary>
+    /// A basic neuron model that accumulates input until reaching a threshold, then fires.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: This is like a bucket collecting water without any leaks.
+    /// 
+    /// How it works:
+    /// 1. The neuron collects incoming signals (like water filling a bucket)
+    /// 2. When the water level reaches a certain height, the bucket tips over (neuron fires)
+    /// 3. After firing, the bucket is emptied and starts collecting again
+    /// 
+    /// The key difference from LeakyIntegrateAndFire is that this model doesn't have any "leak" -
+    /// once charge is added, it stays there until the neuron fires.
+    /// 
+    /// This model is:
+    /// - The simplest spiking neuron model
+    /// - Very computationally efficient
+    /// - Less biologically accurate than other models
+    /// 
+    /// It's good for educational purposes and very basic simulations.
+    /// </remarks>
     IntegrateAndFire,
+
+    /// <summary>
+    /// A computationally efficient model that can reproduce many behaviors of biological neurons.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: This model strikes a balance between biological realism and computational efficiency.
+    /// 
+    /// Named after Eugene Izhikevich who developed it, this model can simulate many different
+    /// firing patterns seen in real neurons (like bursting, chattering, or regular spiking)
+    /// while being much faster to compute than fully detailed models.
+    /// 
+    /// Think of it like a sophisticated light switch that can be programmed to blink in
+    /// different patterns that closely resemble real brain activity.
+    /// 
+    /// This model is:
+    /// - More biologically realistic than the simpler models
+    /// - Still computationally efficient
+    /// - Able to reproduce many different neural firing patterns
+    /// 
+    /// It's popular for large-scale brain simulations where both biological realism and
+    /// computational efficiency are important.
+    /// </remarks>
     Izhikevich,
+
+    /// <summary>
+    /// A detailed biophysical model that accurately represents ion channel dynamics in neurons.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: This is the most biologically accurate model, but also the most complex.
+    /// 
+    /// Named after Alan Hodgkin and Andrew Huxley who won a Nobel Prize for this work,
+    /// this model precisely describes how ions flow through channels in the neuron's membrane.
+    /// 
+    /// Think of it like having a detailed engineering blueprint of a neuron that models
+    /// all the important chemical and electrical processes happening inside.
+    /// 
+    /// This model is:
+    /// - Extremely biologically accurate
+    /// - Computationally intensive (slow to simulate)
+    /// - Able to capture subtle details of neural behavior
+    /// 
+    /// It's primarily used in neuroscience research when biological accuracy is more important
+    /// than computational efficiency.
+    /// </remarks>
     HodgkinHuxley,
+
+    /// <summary>
+    /// A model that combines exponential spike generation with adaptive threshold mechanisms.
+    /// </summary>
+    /// <remarks>
+    /// For Beginners: This model adds adaptability to neuron behavior.
+    /// 
+    /// The "Adaptive" part means the neuron can change its sensitivity based on recent activity.
+    /// The "Exponential" part refers to how quickly the neuron responds when close to firing.
+    /// 
+    /// Think of it like a smart thermostat that becomes less sensitive after detecting several
+    /// temperature changes, preventing it from overreacting to small fluctuations.
+    /// 
+    /// This model is:
+    /// - More biologically realistic than basic models
+    /// - Able to capture adaptation behaviors (neurons getting "tired" after firing a lot)
+    /// - Moderately computationally efficient
+    /// 
+    /// It's useful for simulations where you need more realistic neural behavior than simple
+    /// models provide, but can't afford the computational cost of the most detailed models.
+    /// </remarks>
     AdaptiveExponential
 }