python_lecture_bayes_classifier

    from __future__ import print_function
    # !/usr/bin/python
    # -*- coding: utf-8 -*-

    import re
    import math


    def getwords(doc):
        # regularen izraz koj ke go deli stringot na zborovi
        # stringot se deli na zborovi na site prazni mesta i interpunkciski znaci
        splitter = re.compile('\\W*')
        # podeli go dokumentot na zborovi
        # i konvertiraj gi vo mali bukvi
        # pa potoa stavi gi vo lista
        # ako nivnata dolzina e >2 i <20
        words = set()
        for word in splitter.split(doc):
            if 2 < len(word) < 20:
                words.add(word.lower())
        return words
        # words = [word.lower() for word in splitter.split(doc) if len(word) > 2 and len(word) < 20]
        # # se vrakja recnik cii klucevi se zborovite koi
        # # se vo dokumentot, a eden zbor duri i da se
        # # srekjava poveke pati vo recnikot ke bide samo ednas
        # # vrednosta (1) vo recnikot ne e potrebna
        # return dict([(word, 1) for word in words])


    # {'python': {'bad': 0, 'good': 6}, 'the': {'bad': 3, 'good': 3}}
    w = getwords("""
        # # se vrakja recnik cii klucevi se zborovite koi
        # # se vo dokumentot, a eden zbor duri i da se
        # # srekjava poveke pati vo recnikot ke bide samo ednas
        # # vrednosta (1) vo recnikot ne e potrebna
    """)


    # print(w)
    # exit(1)

    class documentClassifier:
        def __init__(self, getfeatures, filename=None):
            # Broj na parovi atribut/kategorija (feature/category)
            self.featureCountsPerCategory = {}
            # Broj na dokumenti vo sekoja kategorija
            self.categoryCounts = {}
            # funkcija za dobivanje na atributite (zborovite) vo dokumentot
            self.getfeatures = getfeatures

        # Zgolemuvanje na brojot na parovi atribut/kategorija
        def incrementFeatureCountsPerCategory(self, currentFeature, currentCategory):
            self.featureCountsPerCategory.setdefault(currentFeature, {})
            self.featureCountsPerCategory[currentFeature].setdefault(currentCategory, 0)
            self.featureCountsPerCategory[currentFeature][currentCategory] += 1

        # Zgolemuvanje na brojot na predmeti(dokumenti) vo kategorija
        def incrementCategoryCounts(self, cat):
            self.categoryCounts.setdefault(cat, 0)
            self.categoryCounts[cat] += 1

        # Dobivanje na brojot kolku pati
        # odreden atribut se ima pojaveno vo odredena kategorija
        def getFeatureCountsPerCategory(self, currentFeature, currentCategory):
            if currentFeature in self.featureCountsPerCategory and currentCategory in self.featureCountsPerCategory[
                currentFeature]:
                return float(self.featureCountsPerCategory[currentFeature][currentCategory])
            return 0.0

        # Dobivanje na brojot na predmeti(dokumenti) vo kategorija
        def getCategoryCount(self, currentCategory):
            if currentCategory in self.categoryCounts:
                return float(self.categoryCounts[currentCategory])
            return 0

        # Dobivanje na vkupniot broj na predmeti
        def getTotalCount(self):
            return sum(self.categoryCounts.values())

        # Dobivanje na lista na site kategorii
        def categories(self):
            return self.categoryCounts.keys()

        # Treniranje na klasifikatorot
        # Noviot predmet (dokument) item pripagja na kategorijata cat
        def train(self, item, currentCategory):
            # Se zemaat atributite (zborovite) vo predmetot(dokumentot)
            features = self.getfeatures(item)
            # Se zgolemuva brojot na sekoj atribut vo ovaa kategorija
            for currentFeature in features:
                self.incrementFeatureCountsPerCategory(currentFeature, currentCategory)

            # Se zgolemuva brojot na predmeti (dokumenti) vo ovaa kategorija
            self.incrementCategoryCounts(currentCategory)

        def getFeaturePerCategoryProbability(self, currentFeature, currentCategory):
            if self.getCategoryCount(currentCategory) == 0: return 0
            # Verojatnosta e vkupniot broj na pati koga
            # ovoj atribut f (zbor) se pojavil vo ovaa
            # kategorija podeleno so vkupniot broj na
            # predmeti (dokumenti) vo ovaa kategorija
            return self.getFeatureCountsPerCategory(currentFeature, currentCategory) / self.getCategoryCount(
                currentCategory)

        def weightedprob(self, currentFeature, currentCategory, prf, weight=1.0, ap=0.5):
            # Presmetaj ja osnovnata verojatnost
            basicprob = prf(currentFeature, currentCategory)
            # Izbroj kolku pati se ima pojaveno ovoj atribut (zbor)
            # vo site kategorii
            totals = sum([self.getFeatureCountsPerCategory(currentFeature, currentCategory) for currentCategory in
                          self.categories()])
            # Presmetaj ja tezinski usrednetata verojatnost
            bp = ((weight * ap) + (totals * basicprob)) / (weight + totals)
            return bp


    dc = documentClassifier(getwords)
    dc.train("sistemi na znaenje e dosaden predmet", "tracevi")
    dc.train("asistentot po sistemi na znaenje e isto taka dosaden", "tracevi")
    dc.train("vezbite po sistemi na znaenje moze da se podobrat na sledniov nacin...", "kritiki")
    dc.train("predvanjata po sistemi na znaenje ne moze da se podobrat bidejki se najdobri...", "kritiki")


    class naivebayes(documentClassifier):
        def __init__(self, getfeatures):
            documentClassifier.__init__(self, getfeatures)
            self.thresholds = {}

        def setThreshold(self, currentCategory, threshold):
            self.thresholds[currentCategory] = threshold

        def getThreshold(self, currentCategory):
            if currentCategory not in self.thresholds: return 1.0
            return self.thresholds[currentCategory]

        # ja vrakja verojatnosta na dokumentot da e od klasata cat (cat e odnapred poznata)
        def caclulateDocumentProbabilityInClass(self, item, currentCategory):
            # zemi gi zborovite vo dokumentot item
            features = self.getfeatures(item)
            # pomnozi gi verojatnostite na site zborovi
            p = 1
            for currentFeature in features:
                p *= self.weightedprob(currentFeature, currentCategory,
                                       self.getFeaturePerCategoryProbability)

            return p

        # Ja vrakja verojatnosta na klasata ako e poznat dokumentot
        def getCategoryProbabilityForDocument(self, item, currentCategory):
            catprob = self.getCategoryCount(currentCategory) / self.getTotalCount()
            caclulateDocumentProbabilityInClass = self.caclulateDocumentProbabilityInClass(item, currentCategory)
            # Bayes Theorem
            return caclulateDocumentProbabilityInClass * catprob / (1.0 / self.getTotalCount())

        # klasificiranje na dokument
        def classifyDocument(self, item, default=None):
            probs = {}
            # najdi ja kategorijata (klasata)
            # so najgolema verojatnost
            max = 0.0
            for cat in self.categories():
                probs[cat] = self.getCategoryProbabilityForDocument(item, cat)
                if probs[cat] > max:
                    max = probs[cat]
                    best = cat

            # proveri dali verojatnosta e pogolema od
            # threshold*next best (sledna najdobra)
            for cat in probs:
                if cat == best: continue
                if probs[cat] * self.getThreshold(best) > probs[best]: return default

            return best


    def sampletrain(cl):
        cl.train("Dali zakate da zarabotite brzi pari? Podignete ja vasata nagrada sega! Online zarabotka.", "bad")
        cl.train("""Od vasata smetka e napravena transakcija vo iznos od 1000 denari.
                Javete se vo najbliskata ekspozitura za podetalni informacii.""", "good")
        cl.train("Online marketing! Brzi pari bez trud!", "bad")
        cl.train("""Bez da ucam dobiv desetka po ekspertni sistemi""", "good")
        cl.train("""Desetka so kromid za samo 100 denari. Vo vasata maalska kafeana!""", "bad")

        # cl.train("Sistemi i kombinacii za sigurni tipovi. Online oblozuvanje","bad")


    cl = documentClassifier(getwords)
    sampletrain(cl)

    print(cl.getFeatureCountsPerCategory("online", "bad"), cl.getFeaturePerCategoryProbability("online", "bad"))
    print(cl.getFeatureCountsPerCategory("vasata", "good"), cl.getFeaturePerCategoryProbability("vasata", "good"))
    print(cl.getFeatureCountsPerCategory("desetka", "good"), cl.getFeaturePerCategoryProbability("desetka", "good"))
    print(cl.getFeatureCountsPerCategory("denari", "bad"), cl.getFeaturePerCategoryProbability("denari", "bad"))
    print(cl.getFeatureCountsPerCategory("online", "good"), cl.getFeaturePerCategoryProbability("online", "good"))
    print(cl.getFeatureCountsPerCategory("sistemi", "good"), cl.getFeaturePerCategoryProbability("sistemi",
                                                                                                 "good"), cl.weightedprob(
        "sistemi", "good", cl.getFeaturePerCategoryProbability))
    print(cl.getFeatureCountsPerCategory("sistemi", "bad"), cl.getFeaturePerCategoryProbability("sistemi",
                                                                                                "bad"), cl.weightedprob(
        "sistemi", "bad", cl.getFeaturePerCategoryProbability))

    exit(1)
    cl = naivebayes(getwords)
    sampletrain(cl)
    cl.setThreshold('bad', 2)
    print(cl.classifyDocument('ekspertni sistemi finki', default='unknown'), cl.getCategoryProbabilityForDocument(
        'ekspertni sistemi finki', 'bad'), cl.getCategoryProbabilityForDocument('ekspertni sistemi finki', 'good'))
    print(cl.classifyDocument('Sistemi i kombinacii za sigurni tipovi. Online oblozuvanje',
                              default='unknown'), cl.getCategoryProbabilityForDocument(
        'Sistemi i kombinacii za sigurni tipovi. Online oblozuvanje', 'bad'), cl.getCategoryProbabilityForDocument(
        'Sistemi i kombinacii za sigurni tipovi. Online oblozuvanje', 'good'))
    print(cl.classifyDocument('cudna recenica za koja ne znam od koja klasa e',
                              default='unknown'), cl.getCategoryProbabilityForDocument(
        'cudna recenica za koja ne znam od koja klasa e', 'bad'), cl.getCategoryProbabilityForDocument(
        'cudna recenica za koja ne znam od koja klasa e', 'good'))

    wrd = getwords('cudna recenica za koja ne znam od koja klasa e')
    for w in wrd:
        print(w)
    # 0.05
    # 0.01875
    # (weight*assumedprob + count*getFeaturePerCategoryProbability)/(count+weight)
    # = (1*1.0+1*0.5)/(1.0 + 1.0)
    # = 0.75

    # 1.0 0.5 0.5
    # 0.0 0.0 0.25