Add README with explanation

Author: ph1ps

Naive Bayes Classifier/NaiveBayes.playground/Contents.swift

@@ -2,13 +2,13 @@ import Foundation
 
 /*:
  ## Naive Bayes Classifier
- 
+
  This playground uses the given algorithm and utilizes its features with some example datasets
- 
+
  ### Gaussian Naive Bayes
  - Note:
  When using Gaussian NB you have to have continuous features (Double).
- 
+
  For this example we are going to use a famous dataset with different types of wine. The labels of the features can be viewed [here](https://gist.github.com/tijptjik/9408623)
  */
 guard let wineCSV = Bundle.main.path(forResource: "wine", ofType: "csv") else {
@@ -27,7 +27,7 @@ guard let csv = try? String(contentsOfFile: wineCSV) else {
 let rows = csv.characters.split(separator: "\r\n").map { String($0) }
 /*:
  Splitting on the ; sign and converting the value to a Double
- 
+
  - Important:
  Do not force unwrap the mapped values in your real application. Carefully convert them! This is just for the sake of showing how the algorithm works.
  */
@@ -47,31 +47,31 @@ let data = wineData.map { row in
 
 /*:
  Again use `guard` on the result of a `try?` or simply `do-try-catch` because this would crash your application if an error occured.
- 
+
  The array in the `classifyProba` method I passed is a former entry in the .csv file which I removed in order to classify it.
  */
 let wineBayes = try! NaiveBayes(type: .gaussian, data: data, classes: classes).train()
 let result = wineBayes.classifyProba(with: [12.85, 1.6, 2.52, 17.8, 95, 2.48, 2.37, 0.26, 1.46, 3.93, 1.09, 3.63, 1015])
 /*:
  I can assure you that ***class 1*** is the correct result and as you can see the classifier thinks that its ***99.99%*** likely too.
- 
+
  ### Multinomial Naive Bayes
- 
+
  - Note:
  When using Multinomial NB you have to have categorical features (Int).
- 
+
  Now this dataset is commonly used to describe the classification problem and it is categorical which means you don't have real values you just have categorical data as stated before. The structure of this dataset is as follows.
- 
+
  Outlook,Temperature,Humidity,Windy
- 
+
  ***Outlook***: 0 = rainy, 1 = overcast, 2 = sunny
- 
+
  ***Temperature***: 0 = hot, 1 = mild, 2 = cool
- 
+
  ***Humidity***: 0 = high, 1 = normal
- 
+
  ***Windy***: 0 = false, 1 = true
- 
+
  The classes are either he will play golf or not depending on the weather conditions. (0 = won't play, 1 = will play)
  */
 

Naive Bayes Classifier/NaiveBayes.playground/Sources/NaiveBayes.swift

@@ -11,186 +11,186 @@ import Foundation
 extension String: Error {}
 
 extension Array where Element == Double {
-    
+
     func mean() -> Double {
         return self.reduce(0, +) / Double(count)
     }
-    
+
     func standardDeviation() -> Double {
         let calculatedMean = mean()
-        
+
         let sum = self.reduce(0.0) { (previous, next) in
             return previous + pow(next - calculatedMean, 2)
         }
-        
+
         return sqrt(sum / Double(count - 1))
     }
 }
 
 extension Array where Element == Int {
-    
+
     func uniques() -> Set<Element> {
         return Set(self)
     }
-    
+
 }
 
 public enum NBType {
-    
+
     case gaussian
     case multinomial
     //case bernoulli --> TODO
-    
+
     func calcLikelihood(variables: [Any], input: Any) -> Double? {
-        
+
         if case .gaussian = self {
-            
+
             guard let input = input as? Double else {
                 return nil
             }
-            
+
             guard let mean = variables[0] as? Double else {
                 return nil
             }
-            
+
             guard let stDev = variables[1] as? Double else {
                 return nil
             }
-            
+
             let eulerPart = pow(M_E, -1 * pow(input - mean, 2) / (2 * pow(stDev, 2)))
             let distribution = eulerPart / sqrt(2 * .pi) / stDev
-            
+
             return distribution
-            
+
         } else if case .multinomial = self {
-            
+
             guard let variables = variables as? [(category: Int, probability: Double)] else {
                 return nil
             }
-            
+
             guard let input = input as? Int else {
                 return nil
             }
-            
+
             return variables.first { variable in
                 return variable.category == input
                 }?.probability
-            
+
         }
-        
+
         return nil
     }
-    
+
     func train(values: [Any]) -> [Any]? {
-        
+
         if case .gaussian = self {
-            
+
             guard let values = values as? [Double] else {
                 return nil
             }
-            
+
             return [values.mean(), values.standardDeviation()]
-            
+
         } else if case .multinomial = self {
-            
+
             guard let values = values as? [Int] else {
                 return nil
             }
-            
+
             let count = values.count
             let categoryProba = values.uniques().map { value -> (Int, Double) in
                 return (value, Double(values.filter { $0 == value }.count) / Double(count))
             }
             return categoryProba
         }
-        
+
         return nil
     }
 }
 
 public class NaiveBayes<T> {
-    
+
     var variables: [Int: [(feature: Int, variables: [Any])]]
     var type: NBType
-    
+
     var data: [[T]]
     var classes: [Int]
-    
+
     public init(type: NBType, data: [[T]], classes: [Int]) throws {
         self.type = type
         self.data = data
         self.classes = classes
         self.variables = [Int: [(Int, [Any])]]()
-        
+
         if case .gaussian = type, T.self != Double.self {
             throw "When using Gaussian NB you have to have continuous features (Double)"
         } else if case .multinomial = type, T.self != Int.self {
             throw "When using Multinomial NB you have to have categorical features (Int)"
         }
     }
-    
+
     public func train() throws -> Self {
-        
+
         for `class` in classes.uniques() {
             variables[`class`] = [(Int, [Any])]()
-            
+
             let classDependent = data.enumerated().filter { (offset, _) in
                 return classes[offset] == `class`
             }
-            
+
             for feature in 0..<data[0].count {
-                
+
                 let featureDependent = classDependent.map { $0.element[feature] }
-                
+
                 guard let trained = type.train(values: featureDependent) else {
                     throw "Critical! Data could not be casted even though it was checked at init"
                 }
-                
+
                 variables[`class`]?.append((feature, trained))
             }
         }
-        
+
         return self
     }
-    
+
     public func classify(with input: [T]) -> Int {
         let likelihoods = classifyProba(with: input).max { (first, second) -> Bool in
             return first.1 < second.1
         }
-        
+
         guard let `class` = likelihoods?.0 else {
             return -1
         }
-        
+
         return `class`
     }
-    
+
     public func classifyProba(with input: [T]) -> [(Int, Double)] {
-        
+
         var probaClass = [Int: Double]()
         let amount = classes.count
-        
+
         classes.forEach { `class` in
             let individual = classes.filter { $0 == `class` }.count
             probaClass[`class`] = Double(individual) / Double(amount)
         }
-        
+
         let classesAndFeatures = variables.map { (`class`, value) -> (Int, [Double]) in
             let distribution = value.map { (feature, variables) -> Double in
                 return type.calcLikelihood(variables: variables, input: input[feature]) ?? 0.0
             }
             return (`class`, distribution)
         }
-        
+
         let likelihoods = classesAndFeatures.map { (`class`, distribution) in
             return (`class`, distribution.reduce(1, *) * (probaClass[`class`] ?? 0.0))
         }
-        
+
         let sum = likelihoods.map { $0.1 }.reduce(0, +)
         let normalized = likelihoods.map { (`class`, likelihood) in
             return (`class`, likelihood / sum)
         }
-        
+
         return normalized
     }
 }

Naive Bayes Classifier/NaiveBayes.playground/contents.xcplayground

@@ -1,4 +1,4 @@
 <?xml version="1.0" encoding="UTF-8" standalone="yes"?>
-<playground version='5.0' target-platform='ios' display-mode='raw'>
+<playground version='5.0' target-platform='ios' display-mode='rendered'>
     <timeline fileName='timeline.xctimeline'/>
 </playground>

Naive Bayes Classifier/NaiveBayes.playground/timeline.xctimeline

@@ -17,5 +17,15 @@
          selectedRepresentationIndex = "0"
          shouldTrackSuperviewWidth = "NO">
       </LoggerValueHistoryTimelineItem>
+      <LoggerValueHistoryTimelineItem
+         documentLocation = "#CharacterRangeLen=10&amp;CharacterRangeLoc=3410&amp;EndingColumnNumber=15&amp;EndingLineNumber=100&amp;StartingColumnNumber=5&amp;StartingLineNumber=100&amp;Timestamp=514208705.303681"
+         selectedRepresentationIndex = "0"
+         shouldTrackSuperviewWidth = "NO">
+      </LoggerValueHistoryTimelineItem>
+      <LoggerValueHistoryTimelineItem
+         documentLocation = "#CharacterRangeLen=6&amp;CharacterRangeLoc=1931&amp;EndingColumnNumber=11&amp;EndingLineNumber=53&amp;StartingColumnNumber=5&amp;StartingLineNumber=53&amp;Timestamp=514208705.303681"
+         selectedRepresentationIndex = "0"
+         shouldTrackSuperviewWidth = "NO">
+      </LoggerValueHistoryTimelineItem>
    </TimelineItems>
 </Timeline>

Naive Bayes Classifier/NaiveBayes.swift

@@ -11,186 +11,186 @@ import Foundation
 extension String: Error {}
 
 extension Array where Element == Double {
-    
+
     func mean() -> Double {
         return self.reduce(0, +) / Double(count)
     }
-    
+
     func standardDeviation() -> Double {
         let calculatedMean = mean()
-        
+
         let sum = self.reduce(0.0) { (previous, next) in
             return previous + pow(next - calculatedMean, 2)
         }
-        
+
         return sqrt(sum / Double(count - 1))
     }
 }
 
 extension Array where Element == Int {
-    
+
     func uniques() -> Set<Element> {
         return Set(self)
     }
-    
+
 }
 
 enum NBType {
-    
+
     case gaussian
     case multinomial
     //case bernoulli --> TODO
-    
+
     func calcLikelihood(variables: [Any], input: Any) -> Double? {
-        
+
         if case .gaussian = self {
-            
+
             guard let input = input as? Double else {
                 return nil
             }
-            
+
             guard let mean = variables[0] as? Double else {
                 return nil
             }
-            
+
             guard let stDev = variables[1] as? Double else {
                 return nil
             }
-            
+
             let eulerPart = pow(M_E, -1 * pow(input - mean, 2) / (2 * pow(stDev, 2)))
             let distribution = eulerPart / sqrt(2 * .pi) / stDev
-            
+
             return distribution
-            
+
         } else if case .multinomial = self {
-            
+
             guard let variables = variables as? [(category: Int, probability: Double)] else {
                 return nil
             }
-            
+
             guard let input = input as? Int else {
                 return nil
             }
-            
+
             return variables.first { variable in
                 return variable.category == input
                 }?.probability
-            
+
         }
-        
+
         return nil
     }
-    
+
     func train(values: [Any]) -> [Any]? {
-        
+
         if case .gaussian = self {
-            
+
             guard let values = values as? [Double] else {
                 return nil
             }
-            
+
             return [values.mean(), values.standardDeviation()]
-            
+
         } else if case .multinomial = self {
-            
+
             guard let values = values as? [Int] else {
                 return nil
             }
-            
+
             let count = values.count
             let categoryProba = values.uniques().map { value -> (Int, Double) in
                 return (value, Double(values.filter { $0 == value }.count) / Double(count))
             }
             return categoryProba
         }
-        
+
         return nil
     }
 }
 
 class NaiveBayes<T> {
-    
+
     var variables: [Int: [(feature: Int, variables: [Any])]]
     var type: NBType
-    
+
     var data: [[T]]
     var classes: [Int]
-    
+
     init(type: NBType, data: [[T]], classes: [Int]) throws {
         self.type = type
         self.data = data
         self.classes = classes
         self.variables = [Int: [(Int, [Any])]]()
-        
+
         if case .gaussian = type, T.self != Double.self {
             throw "When using Gaussian NB you have to have continuous features (Double)"
         } else if case .multinomial = type, T.self != Int.self {
             throw "When using Multinomial NB you have to have categorical features (Int)"
         }
     }
-    
+
     func train() throws -> Self {
-        
+
         for `class` in classes.uniques() {
             variables[`class`] = [(Int, [Any])]()
-            
+
             let classDependent = data.enumerated().filter { (offset, _) in
                 return classes[offset] == `class`
             }
-            
+
             for feature in 0..<data[0].count {
-                
+
                 let featureDependent = classDependent.map { $0.element[feature] }
-                
+
                 guard let trained = type.train(values: featureDependent) else {
                     throw "Critical! Data could not be casted even though it was checked at init"
                 }
-                
+
                 variables[`class`]?.append((feature, trained))
             }
         }
-        
+
         return self
     }
-    
+
     func classify(with input: [T]) -> Int {
         let likelihoods = classifyProba(with: input).max { (first, second) -> Bool in
             return first.1 < second.1
         }
-        
+
         guard let `class` = likelihoods?.0 else {
             return -1
         }
-        
+
         return `class`
     }
-    
+
     func classifyProba(with input: [T]) -> [(Int, Double)] {
-        
+
         var probaClass = [Int: Double]()
         let amount = classes.count
-        
+
         classes.forEach { `class` in
             let individual = classes.filter { $0 == `class` }.count
             probaClass[`class`] = Double(individual) / Double(amount)
         }
-        
+
         let classesAndFeatures = variables.map { (`class`, value) -> (Int, [Double]) in
             let distribution = value.map { (feature, variables) -> Double in
                 return type.calcLikelihood(variables: variables, input: input[feature]) ?? 0.0
             }
             return (`class`, distribution)
         }
-        
+
         let likelihoods = classesAndFeatures.map { (`class`, distribution) in
             return (`class`, distribution.reduce(1, *) * (probaClass[`class`] ?? 0.0))
         }
-        
+
         let sum = likelihoods.map { $0.1 }.reduce(0, +)
         let normalized = likelihoods.map { (`class`, likelihood) in
             return (`class`, likelihood / sum)
         }
-        
+
         return normalized
     }
 }

Naive Bayes Classifier/README.md

@@ -0,0 +1,99 @@
+# Naive Bayes Classifier
+
+> ***Disclaimer:*** Do not get scared of complicated formulas or terms, I will describe them right after I use them. Also the math skills you need to understand this are very basic.
+
+The goal of a classifier is to predict the class of a given data entry based on previously fed data and its features. 
+
+Now what is a class or a feature? The best I can do is to describe it with a table. 
+This is a dataset that uses height, weight and foot size of a person to illustrate the relationship between those values and the sex.
+
+| Sex       | height (feet)          | weight(lbs)  | foot size (inches) |
+| ------------- |:-------------:|:-----:|:---:|
+| male      | 6     | 180 | 12  |
+| male      | 5.92  | 190 | 11  |
+| male      | 5.58  | 170 | 12  |
+| male      | 5.92  | 165 | 10  |
+| female    | 5     | 100 | 6   |
+| female    | 5.5   | 150 | 8   |
+| female    | 5.42  | 130 | 7   |
+| female    | 5.75  | 150 | 9   |
+
+The ***classes*** of this table is the data in the sex column (male/female). You "classify" the rest of the data and bind them to a sex.
+
+The ***features*** of this table are the labels of the other columns (height, weight, foot size) and the numbers right under the labels.
+
+Now that I've told you what a classifier is I will tell you what exactly a ***Naive Bayes classifier*** is. There are a lot of other classifiers out there but what's so special about this specific is that it only needs a very small dataset to get good results. The others like Random Forests normally need a very large dataset.
+
+Why isn't this algorithm used more you might ask (or not). Because it is normally ***outperformed*** in accuracy by ***Random Forests*** or ***Boosted Trees***.
+
+## Theory
+
+The Naive Bayes classifier utilizes the ***Bayes Theorem*** (as its name suggests) which looks like this.
+
+![](images/bayes.gif)
+
+***P*** always means the probability of something.
+
+***A*** is the class, ***B*** is the data depending on a feature and the ***pipe*** symbol means given. 
+
+P(A | B) therefore is: probability of the class given the data (which is dependent on the feature).
+
+This is all you have to know about the Bayes Theorem. The important thing for us is now how to calculate all those variables, plug them into this formula and you are ready to classify data.
+
+### **P(A)**
+This is the probability of the class. To get back to the example I gave before: Let's say we want to classify this data entry:
+
+| height (feet)          | weight(lbs)  | foot size (inches) |
+|:-------------:|:-----:|:---:|
+| 6     | 130 | 8  |
+
+What Naive Bayes classifier now does: it checks the probability for every class possible which is in our case either male or female. Look back at the original table and count the male and the female entries. Then divide them by the overall count of data entries.
+
+P(male) = 4 / 8 = 0.5
+
+P(female) = 4 / 8 = 0.5
+
+This should be a very easy task to do. Basically just the probability of all classes.
+
+### **P(B)**
+This variable is not needed in a Naive Bayes classifier. It is the probability of the data. It does not change, therefore it is a constant. And what can you do with a constant? Exactly! Discard it. This saves time and code.
+
+### **P(B | A)**
+This is the probability of the data given the class. To calculate this I have to introduce you to the subtypes of NB. You have to decide which you use depending on your data which you want to classify.
+
+### **Gaussian Naive Bayes**
+If you have a dataset like the one I showed you before (continuous features -> `Double`s) you have to use this subtype. There are 3 formulas you need for Gaussian NB to calculate P(B | A).
+
+![mean](images/mean.gif)
+
+![standard deviation](images/standard_deviation.gif)
+
+![normal distribution](images/normal_distribution.gif)
+
+and **P(x | y) = P(B | A)**
+
+Again, very complicated looking formulas but they are very easy. The first formula with µ is just the mean of the data (adding all data points and dividing them by the count). The second with σ is the standard deviation. You might have heard of it somewhen in school. It is just the sum of all values minus the mean, squared and that divided by the count of the data minus 1 and a sqaure root around it. The third equation is the Gaussian or normal distribution if you want to read more about it I suggest reading [this](https://en.wikipedia.org/wiki/Normal_distribution).
+
+Why the Gaussian distribution? Because we assume that the continuous values associated with each class are distributed according to the Gaussian distribution. Simple as that.
+
+### **Multinomial Naive Bayes**
+
+What do we do if we have this for examples:
+
+![tennis or golf](images/tennis_dataset.png)
+
+We can't just calculate the mean of sunny, overcast and rainy. This is why we need the categorical model which is the multinomial NB. This is the last formula, I promise!
+
+![multinomial](images/multinomial.gif)
+
+Now this is the number of times feature **i** appears in a sample **N** of class **y** in the data set divided by the count of the sample just depending on the class **y**. That θ is also just a fancy way of writing P(B | A).
+
+You might have noticed that there is still the α in this formula. This solves a problem called "zero-frequency-problem". Because what happens if there is no sample with feature **i** and class **y**? The whole equation would result in 0 (because 0 / something is always 0). This is a huge problem but there is a simple solution to this. Just add 1 to any count of the sample (α = 1).
+
+## Those formulas in action
+
+Enough talking! This is the code. If you want a deeper explanation of how the code works just look at the Playground I provided.
+
+![code example](images/code_example.png)
+
+*Written for Swift Algorithm Club by Philipp Gabriel*