From 293a9f9e0811f35f30ab037a5d2b242ed9deef9c Mon Sep 17 00:00:00 2001
From: stasysp <stasysp.96@gmail.com>
Date: Tue, 6 Dec 2016 10:09:54 +0300
Subject: [PATCH] Add files via upload

---
 classifier.cpp | 174 ++++++++++++++++++++++++++++++++++++++++++++++---
 classifier.hpp |   8 ++-
 main.cpp       |  46 ++++---------
 3 files changed, 185 insertions(+), 43 deletions(-)

diff --git a/classifier.cpp b/classifier.cpp
index a9371c6..4e7f066 100644
--- a/classifier.cpp
+++ b/classifier.cpp
@@ -1,4 +1,7 @@
 #include "classifier.hpp"
+#include <cassert>
+#include <map>
+
 
 Classifier::Classifier(){
     mathModel = 0;
@@ -11,9 +14,29 @@ Classifier::Classifier(){
     ExH[0]=0; ExH[1]=0;
     DxH[0]=0; DxH[1]=0;
     H = 1e-7;
+    k = 0;
 }
 Classifier::~Classifier(){}
 
+Classifier::Classifier(const Classifier &A){
+    mathModel = A.mathModel;
+    H=A.H;
+    for (int i=0; i<2; i++){
+        p[i]=A.p[i];
+        counts[i]=A.counts[i];
+        ExW[i]=A.ExW[i];
+        DxW[i]=A.DxW[i];
+        ExH[i]=A.ExH[i];
+        DxH[i]=A.DxH[i];
+        for (int j=0; j<250; j++){
+            pWeight[i][j]=A.pWeight[i][j];
+            pHeight[i][j]=A.pHeight[i][j];
+        }
+    }
+    for (int i=0; i<A.train_set.size(); i++)
+        train_set.push_back(A.train_set[i]);
+}
+
 void Classifier:: readTrainFile(ifstream &F){
     while (!F.eof()){
         d tmp;
@@ -25,7 +48,7 @@ void Classifier:: readTrainFile(ifstream &F){
 vector<pair<double, double>> Classifier::readTestFile(ifstream &F){
     vector<pair<double, double>> r;
     while (!F.eof()){
-        int x, y;
+        double x, y;
         F>>x>>y;
         r.push_back(make_pair(x, y));
     }
@@ -35,7 +58,7 @@ vector<pair<double, double>> Classifier::readTestFile(ifstream &F){
 
 int Classifier::findNext(int i, double *arr){
     for (; i<250; i++){
-        if (arr[i] > 10e-8) return i;
+        if (arr[i] > 1e-9) return i;
     }
     return 0;
 }
@@ -49,6 +72,21 @@ double kernel(double _h, int index, int label, vector<d>data){
     }
     return f;
 }
+double kernel1(double _h, int index, int label, vector<d>data){
+    //     sqrt((x-xi)^2+(y-yi)^2)
+    //K(x)=----------------------- if sqrt((x-xi)^2+(y-yi)^2) < h
+    //             pi*h^2
+    //
+    const double pi = 3.14159265;
+    double f=0.0;
+    for (int i=0; i<data.size(); i++){
+        if (i!=index && data[i].label==label){
+            double tmp = sqrt(pow(data[index].weight-data[i].weight, 2)+pow(data[index].height-data[i].height, 2));
+            if (tmp<_h) f+= tmp/(pi*pow(_h, 2));
+        }
+    }
+    return f;
+}
 double Classifier::probability(double h, double w, int label){
     // P(x|yi)=P(x)*P(yi|x)/P(yi)
     // события yi независимые 
@@ -65,7 +103,8 @@ double Classifier::probability(double h, double w, int label){
         double pW = pow(exp, (-pow(w-ExW[label], 2)/(2*DxW[label])))/(sqrt(2*pi*DxW[label]));
         double pH = pow(exp, (-pow(h-ExH[label], 2)/(2*DxH[label])))/(sqrt(2*pi*DxH[label]));
         return pW*pH*p[label];
-    } else{
+    }
+    else if (mathModel == 3){
         double f=0.0;
         const double exp = 2.718;
         for (int i=0; i<train_set.size(); i++){
@@ -74,21 +113,43 @@ double Classifier::probability(double h, double w, int label){
             }
         }
         return p[label]*f/(counts[label]*H);
+    } else{ //mathModel == 5
+        const double pi = 3.14159265;
+        double f=0.0;
+        for (int i=0; i<train_set.size(); i++){
+            if (train_set[i].label==label){
+            double tmp = sqrt(pow(h-train_set[i].height, 2)+pow(w-train_set[i].weight, 2));
+                if (tmp<H) f+= tmp/(pi*pow(H, 2));
+            }
+        }
+        return p[label]*f/(counts[label]*(pi*pow(H, 2)));
     }
 }
+int findAns(int _k, vector<pair<double, int>> data){
+    int count = 0;
+    for (int i=0; i<_k; i++)
+        if (data[i].second == 1) count++;
+    if (count > _k-count) return 1;
+    return 0;
+}
+
 Classifier barChart(Classifier A){
     A.mathModel = 1;
-    int weight[2][250], heihgt[2][250];
+    int weight[2][250], height[2][250];
     const double eps = 1e-8;
     for (int i=0; i<2; i++){
         for (int j=0; j<250; j++){
             weight[i][j]=0;
-            heihgt[i][j]=0;
+            height[i][j]=0;
         }
     }
     for (int i=0; i<A.train_set.size(); i++){
         A.counts[A.train_set[i].label]++;
-        heihgt[A.train_set[i].label][int(A.train_set[i].height)]++;
+   //     assert(int(A.train_set[i].height) >= 0 && int(A.train_set[i].height) < 250);
+   //     assert(int(A.train_set[i].weight) >= 0 && int(A.train_set[i].weight) < 250);
+        if (A.train_set[i].height>249) A.train_set[i].height = 249;
+        if (A.train_set[i].weight>249) A.train_set[i].weight = 249;
+        height[A.train_set[i].label][int(A.train_set[i].height)]++;
         weight[A.train_set[i].label][int(A.train_set[i].weight)]++;
     }
     
@@ -99,7 +160,7 @@ Classifier barChart(Classifier A){
     for (int i=0; i<2; i++)
         for (int j=0; j<250; j++){
             A.pWeight[i][j] = double(weight[i][j])/double(A.counts[i]);
-            A.pHeight[i][j] = double(heihgt[i][j])/double(A.counts[i]);
+            A.pHeight[i][j] = double(height[i][j])/double(A.counts[i]);
         }
     A.pWeight[0][0]=eps;
     A.pWeight[1][0]=eps;
@@ -166,12 +227,15 @@ Classifier parzanRozenblatt (Classifier A){
     if (A.counts[0] == 0 && A.counts[1]==0)
         for (int i=0; i<A.train_set.size(); i++)
             A.counts[A.train_set[i].label]++;
+    A.p[0] = double(A.counts[0])/double(A.train_set.size());
+    A.p[1] = double(A.counts[1])/double(A.train_set.size());
     srand(time(NULL));
-    int c = (int)(A.train_set.size()/2);
+   // int c = (int)(A.train_set.size()/10);
+    int c = 30;
     int count = 0;
     double countTMP = 0;
     double tmpH = A.H;
-    double const eps = 0.01;
+    double const eps = 0.1;
     for (int i=0; i<(10.00-A.H)/eps; i++){
         countTMP = 0;
         for (int j = 0; j < c; j++){
@@ -189,12 +253,92 @@ Classifier parzanRozenblatt (Classifier A){
     return A;
 }
 
+Classifier KNN(Classifier A){
+    A.mathModel = 4;
+    random_shuffle(A.train_set.begin(), A.train_set.end());
+    int c = int(A.train_set.size()/10);
+    vector<pair<double, int>> *mydata;
+    mydata = new vector<pair<double, int>> [c];
+    for (int i=0; i<c; i++){
+        for (int j=0; j<A.train_set.size(); j++){
+            if (i!=j) {
+                mydata[i].push_back(make_pair(sqrt(pow(A.train_set[i].height-A.train_set[j].height, 2)+pow(A.train_set[i].weight-A.train_set[j].weight, 2)), A.train_set[j].label));
+            }
+        }
+        sort(mydata[i].begin(), mydata[i].end());
+    }
+    int **ans;
+    *ans = new int [c];
+    for (int i=0; i<c; i++)
+        ans[i]= new int [15];
+    for (int i=0; i<c; i++){
+        for (int j=0; j<15; j++){
+            ans[i][j] = findAns(j, mydata[i]);
+        }
+    }
+    int mycounts[15];
+    int tmpK = 0;
+    int max = 0;
+    for (int i=1; i<15; i++){
+        mycounts[i]=0;
+        for (int j=0; j<c; j++){
+            if (ans[j][i] == A.train_set[j].label) mycounts[i]++;
+        }
+        if (mycounts[i]>max) {
+            max = mycounts[i];
+            tmpK = i;
+        }
+    }
+    A.k = tmpK;
+    return A;
+}
+
+Classifier parzanRozenblatt2 (Classifier A){
+    //        1              X-Xi
+    //P(x)=--------- * sum K(-----)
+    //     n*pi*h^2            h
+    //
+    //     sqrt((x-xi)^2+(y-yi)^2)
+    //K(x)=----------------------- if sqrt((x-xi)^2+(y-yi)^2) < h
+    //             pi*h^2
+    //
+    const double pi = 3.14159265;
+    A.mathModel = 5;
+    if (A.counts[0] == 0 && A.counts[1]==0)
+        for (int i=0; i<A.train_set.size(); i++)
+            A.counts[A.train_set[i].label]++;
+    A.p[0] = double(A.counts[0])/double(A.train_set.size());
+    A.p[1] = double(A.counts[1])/double(A.train_set.size());
+    // int c = (int)(A.train_set.size()/10);
+    int c = 30;
+    int count = 0;
+    double countTMP = 0;
+    double tmpH = A.H;
+    double const eps = 0.1;
+    for (int i=0; i<(10.00-A.H)/eps; i++){
+        countTMP = 0;
+        for (int j = 0; j < c; j++){
+            //сократим на 1/pi*h^2
+            if (kernel1(tmpH, j, 0, A.train_set)/A.counts[0] >= kernel(tmpH, j, 1, A.train_set)/A.counts[1] && A.train_set[j].label == 0) countTMP++;
+            if (kernel1(tmpH, j, 1, A.train_set)/A.counts[1] > kernel(tmpH, j, 0, A.train_set)/A.counts[0] && A.train_set[j].label == 1) countTMP++;
+        }
+        if (countTMP > count){
+            count = countTMP;
+            A.H = tmpH;
+        }
+        tmpH+=eps;
+    }
+    
+    return A;
+}
+
 void Classifier::train(ifstream &F, Classifier (*f)(Classifier A)){
     readTrainFile(F);
     train(this->train_set, f);
 }
 void Classifier::train(vector<d> input, Classifier (*f)(Classifier A)){
     *this = f(*this);
+
 }
 
 vector<int> Classifier::classify(ifstream &F){
@@ -203,11 +347,23 @@ vector<int> Classifier::classify(ifstream &F){
 
 vector<int> Classifier::classify(vector<pair<double, double>>input){
     vector<int>rez;
+    if (mathModel == 4){
+        vector<pair<double, int>> mydata;
+        for (int i=0; i<input.size(); i++){
+            for (int j=0; j<train_set.size(); j++){
+                    mydata.push_back(make_pair(sqrt(pow(train_set[j].height-input[i].first, 2)+pow(train_set[j].weight-input[i].second, 2)), train_set[j].label));
+                }
+            sort(mydata.begin(), mydata.end());
+            rez.push_back(findAns(13, mydata));
+            mydata.clear();
+        }
+    } else {
     for (int i=0; i<input.size(); i++){
         double a = probability(input[i].first, input[i].second, 0);
         double b = probability(input[i].first, input[i].second, 1);
         if (a > b) rez.push_back(0);
         else rez.push_back(1);
+        }
     }
     return rez;
 }
diff --git a/classifier.hpp b/classifier.hpp
index 7abea6d..c6b458a 100644
--- a/classifier.hpp
+++ b/classifier.hpp
@@ -24,8 +24,9 @@ class Classifier{
     double p[2];
     double pWeight[2][250], pHeight[2][250];
     int counts[2];
-    double ExW[2], DxW[2], ExH[2], DxH[2]; //матожидание&дисперсия
+    double ExW[2], DxW[2], ExH[2], DxH[2];//матожидание&дисперсия
     double H; //коэфф сглаживания
+    int k;//knn
     vector<d>train_set;
     
     void readTrainFile(ifstream &F);
@@ -35,7 +36,10 @@ class Classifier{
 public:
     Classifier();
     ~Classifier();
+    Classifier(const Classifier &A);
     friend Classifier barChart(Classifier A);
+    friend Classifier KNN(Classifier A);
+    friend Classifier parzanRozenblatt2(Classifier A);
     friend Classifier normalDistribution (Classifier A);
     friend Classifier parzanRozenblatt (Classifier A);
     void train(ifstream &F, Classifier (*f)(Classifier A));
@@ -46,5 +50,7 @@ class Classifier{
 Classifier barChart(Classifier A);
 Classifier normalDistribution (Classifier A);
 Classifier parzanRozenblatt (Classifier A);
+Classifier KNN(Classifier A);
+Classifier parzanRozenblatt2(Classifier A);
 
 #endif /* classifier_hpp */
diff --git a/main.cpp b/main.cpp
index 755ed8f..7b88e02 100644
--- a/main.cpp
+++ b/main.cpp
@@ -14,40 +14,20 @@ using namespace std;
 int main() {
     Classifier my;
     
-    vector<pair<double, double>> myTest;
-    myTest.push_back(make_pair(190, 90));
-    myTest.push_back(make_pair(185, 86));
-    myTest.push_back(make_pair(165, 46));
-    myTest.push_back(make_pair(164, 49));
-    myTest.push_back(make_pair(179, 76));
-    myTest.push_back(make_pair(155, 42));
-    
-    vector<d>test1;
-    
-    ifstream F;
-    F.open("/Users/anastasiapopova/Desktop/YANDEX/lab2_Bayes/lab2/train_test_set");
-    
-    my.train(F, barChart);
-    vector<int>ans = my.classify(myTest);
-    for (int i=0; i<ans.size(); i++){
-        cout<<ans[i]<<" ";
-    }
-    cout<<endl;
-    
-    my.train(F, normalDistribution);
-    ans = my.classify(myTest);
+    ifstream F, F1;
+    ofstream A;
+    F.open("/Users/anastasiapopova/Desktop/YANDEX/lab2_Bayes/lab2/train_set.txt");
+    F1.open("/Users/anastasiapopova/Desktop/YANDEX/lab2_Bayes/lab2/test_set.txt");
+    
+    A.open("/Users/anastasiapopova/Desktop/YANDEX/lab2_Bayes/lab2/new");
+    my.train(F, parzanRozenblatt2);
+    cout<<"train"<<endl;
+    vector<int>ans = my.classify(F1);
+    cout<<"classify"<<endl;
     for (int i=0; i<ans.size(); i++){
-        cout<<ans[i]<<" ";
+            A<<ans[i]<<endl;
     }
-    cout<<endl;
-    
-    my.train(F, parzanRozenblatt);
-    ans = my.classify(myTest);
-    
-    for (int i=0; i<ans.size(); i++){
-        cout<<ans[i]<<" ";
-    }
-    cout<<endl;
-    
+    A.close();
+  
     return 0;
 }