@@ -66,14 +66,26 @@ auto ETL::Std(Eigen::MatrixXd data) -> decltype(((data.array().square().colwise(
 return ((data.array().square().colwise().sum())/(data.rows()-1)).sqrt();
 }
 
-Eigen::MatrixXd ETL::Normalize(Eigen::MatrixXd data){
+Eigen::MatrixXd ETL::Normalize(Eigen::MatrixXd data, bool normalizeTarget){
 
-auto mean = Mean(data);
-Eigen::MatrixXd scaled_data = data.rowwise() - mean;
+Eigen::MatrixXd dataNorm;
+if(normalizeTarget==true) {
+dataNorm = data;
+} else {
+dataNorm = data.leftCols(data.cols()-1);
+}
+
+auto mean = Mean(dataNorm);
+Eigen::MatrixXd scaled_data = dataNorm.rowwise() - mean;
 auto std = Std(scaled_data);
 
 Eigen::MatrixXd norm = scaled_data.array().rowwise()/std;
 
+if(normalizeTarget==false) {
+norm.conservativeResize(norm.rows(), norm.cols()+1);
+norm.col(norm.cols()-1) = data.rightCols(1);
+}
+
 return norm;
 }
 

@@ -19,7 +19,7 @@ class ETL
 std::vector<std::vector<std::string>> readCSV();
 Eigen::MatrixXd CSVtoEigen(std::vector<std::vector<std::string>> dataset, int rows, int cols);
 
-Eigen::MatrixXd Normalize(Eigen::MatrixXd data);
+Eigen::MatrixXd Normalize(Eigen::MatrixXd data, bool normalizeTarget);
 auto Mean(Eigen::MatrixXd data) -> decltype(data.colwise().mean());
 auto Std(Eigen::MatrixXd data) -> decltype(((data.array().square().colwise().sum())/(data.rows()-1)).sqrt());
 

@@ -0,0 +1,76 @@
+#include "LogisticRegression.h"
+
+#include <eigen3/Eigen/Dense>
+#include <iostream>
+#include <map>
+#include <list>
+
+Eigen::MatrixXd LogisticRegression::Sigmoid(Eigen::MatrixXd Z) {
+return 1/(1+(-Z.array()).exp());
+}
+
+std::tuple<Eigen::MatrixXd, double, double> LogisticRegression::Propagate(Eigen::MatrixXd W, double b, Eigen::MatrixXd X, Eigen::MatrixXd y, double lambda) {
+
+int m = y.rows();
+
+Eigen::MatrixXd Z = (W.transpose() * X.transpose()).array() + b;
+Eigen::MatrixXd A = Sigmoid(Z);
+
+auto cross_entropy = -(y.transpose()*(Eigen::VectorXd)A.array().log().transpose() + ((Eigen::VectorXd)(1-y.array())).transpose() * (Eigen::VectorXd)(1-A.array()).log().transpose())/m;
+
+double l2_reg_cost = W.array().pow(2).sum() * (lambda/(2*m));
+
+double cost = static_cast<const double>((cross_entropy.array()[0])) + l2_reg_cost;
+
+Eigen::MatrixXd dw = (Eigen::MatrixXd)(((Eigen::MatrixXd)(clearA-y.transpose()) * X)/m) + ((Eigen::MatrixXd)(lambda/m*W)).transpose();
+
+double db = (A-y.transpose()).array().sum()/m;
+
+return std::make_tuple(dw,db,cost);
+}
+
+std::tuple<Eigen::MatrixXd, double, Eigen::MatrixXd, double, std::list<double>> LogisticRegression::Optimize(Eigen::MatrixXd W, double b, Eigen::MatrixXd X, Eigen::MatrixXd y, int num_iter, double learning_rate, double lambda, bool log_cost) {
+
+std::list<double> costsList;
+
+Eigen::MatrixXd dw;
+double db, cost;
+
+for(int i=0; i<num_iter; i++){
+std::tuple<Eigen::MatrixXd, double, double> propagate = Propagate(W, b, X, y, lambda);
+std::tie(dw, db, cost) = propagate;
+
+W = W - (learning_rate*dw).transpose();
+b = b - (learning_rate*db);
+
+if(i%100==0) {
+costsList.push_back(cost);
+}
+
+if(log_cost && i%100==0) {
+std::cout << "Cost after iteration " << i << ": " << cost << std::endl;
+}
+}
+
+return std::make_tuple(W,b,dw,db,costsList);
+}
+
+Eigen::MatrixXd LogisticRegression::Predict(Eigen::MatrixXd W, double b, Eigen::MatrixXd X) {
+
+int m = X.rows();
+
+Eigen::MatrixXd y_pred = Eigen::VectorXd::Zero(m).transpose();
+
+Eigen::MatrixXd Z = (W.transpose() * X.transpose()).array() + b;
+Eigen::MatrixXd A = Sigmoid(Z);
+
+for(int i=0; i<A.cols(); i++) {
+if(A(0,i) <= 0.5) {
+y_pred(0,i) = 0;
+} else {
+y_pred(0,i) = 1;
+}
+}
+
+return y_pred.transpose();
+}

@@ -0,0 +1,20 @@
+#ifndef LogisticRegression_h
+#define LogisticRegression_h
+
+#include <eigen3/Eigen/Dense>
+#include <list>
+
+class LogisticRegression
+{
+public:
+LogisticRegression()
+{}
+
+Eigen::MatrixXd Sigmoid(Eigen::MatrixXd Z);
+
+std::tuple<Eigen::MatrixXd, double, double> Propagate(Eigen::MatrixXd W, double b, Eigen::MatrixXd X, Eigen::MatrixXd y, double lambda);
+std::tuple<Eigen::MatrixXd, double, Eigen::MatrixXd, double, std::list<double>> Optimize(Eigen::MatrixXd W, double b, Eigen::MatrixXd X, Eigen::MatrixXd y, int num_iter, double learning_rate, double lambda, bool log_cost);
+Eigen::MatrixXd Predict(Eigen::MatrixXd W, double b, Eigen::MatrixXd X);
+};
+
+#endif

@@ -4,10 +4,24 @@ In this repository, you can find all the code from my series of tutorials of Mac
 
 # Usage
 
-Fork and clone/download the repository. To compile simply run the code:
+Fork and clone/download the repository.
 
-`g++ -std=c++11 LinearRegression/LinearRegression.cpp ETL/ETL.cpp main.cpp -o main`
+## Linear Regression
+
+To compile simply run the code:
+
+`g++ -std=c++11 LinearRegression/LinearRegression.cpp ETL/ETL.cpp main/LinearRegression.cpp -o linregr`
+
+To run and test:
+
+`./linregr datasets/winedata.csv ","`
+
+## Logistic Regression
+
+To compile simply run the code:
+
+`g++ -std=c++11 LogisticRegression/LogisticRegression.cpp ETL/ETL.cpp main/LogisticRegression.cpp -o logregr`
 
 To run and test:
 
-`./main datasets/winedata.csv ","`
+`./logregr datasets/adult_data.csv ","`