Untitled

import numpy as np
import random
class dogrusal():
    
    def ileri (self,deger):
        return deger
    def geri(self,deger):
        return 1

class Sigmoid():
    
    def ileri(self,deger):
        a= 1/(1+(np.exp(-deger)))
        return a
    
    def geri(self,deger):
        b = self.ileri(deger)*(1-self.ileri(deger))
        return b

        



class RELU():
    
    def ileri(self,deger):
        return max(0,deger)
    
    def geri(self,deger):
        return 1 if deger>0 else 0





class Noron():
        def __init__(self,agirlik=None):
            self.a =0
            self.sabit=0
            self.w =agirlik if agirlik!=None else random.randint(0, 1000)/1000
            
        
        def toplamFonksiyonu(self,dizi,agirlik,bias):
            array = np.array(dizi)
            ayarlanmisArray =agirlik*array + bias
            return ayarlanmisArray.sum()
        
        def ileri(self,girisDegerleri,aktivasyonFonksiyonu):
            self.a+=1
            self.toplanmisGiris=np.array(girisDegerleri).sum()
            self.aktivasyonFonksiyonu=aktivasyonFonksiyonu.ileri
            #Ağırlığımız 0-1 arasına sıkıştırdık :

            #Gelen bilgileri topladığımız yer.
            self.toplam = self.toplamFonksiyonu(girisDegerleri,self.w,self.sabit)
            #print(self.toplam)
            self.cikis = self.aktivasyonFonksiyonu(self.toplam)
            return self.cikis
        



def f():
    x=[]
    y=[]
    for i in range(10000):
        x.append([i])
        y.append(4*i+10)
    return x,y
        
class YapaySinirAgi():

    #Ağ yapısı class'ının yapıcı fonksiyonu :
    def __init__(self,katmanAktivasyonFonksiyonlari,elemanSayilari =[]):
        # self.a =[]
        # a =5
        #Her katmanın aktivasyon fonksiyonunu tuttuğumuz yer :
        self.katmanAktivasyonFonksiyonlari=katmanAktivasyonFonksiyonlari
        
        #Katmanların içindeki Nöron sayısını tuttuğumuz dizi :
        self.elemanSayilari=elemanSayilari
        
        # Katmanlardaki nöronların a değerlerini bu dizide tutuyoruz :
        self.katmanlardanCikanDegerler = [[0 for i in range(sayi)] for sayi in elemanSayilari]
        
        #Biz giriş değeri olarak katmandaki nöron sayılarını veriyoruz. Kendisi katman sayısını çıkarıyor.
        self.katmanSayisi=len(elemanSayilari)
        #Her bir nöronun içindeki duyarlılık.
        self.duyarliliklar =[[[] for i in range(sayi)] for sayi in elemanSayilari]


        self.agYapisi =[]
        for katman in range(len(elemanSayilari)):
            random.seed(katman)
            self.ag =[]
            for i in range(int(elemanSayilari[katman])):
                self.ag.append(Noron())
            self.agYapisi.append(self.ag)
    
    def ileriYayilim(self,giris,istenilenCikis=None):
        
        self.giris =giris
        for i,katman in enumerate(self.agYapisi):
            temp =[]
            for noron in katman:
                temp.append(noron.ileri(giris,self.katmanAktivasyonFonksiyonlari[i]))
            giris =[]
            giris=temp
            self.katmanlardanCikanDegerler[i]=giris
            #print(self.katmanlardanCikanDegerler[i])
            temp =[]
        if istenilenCikis==None:    
            return giris
        else:
            self.hata = (np.array(giris)-np.array(istenilenCikis))

            return giris
    
    
    
    def geriYayilim(self,X,Y,ogrenmeOrani = 0.01,epochSayisi=1):
        for epoch in range(epochSayisi):

            for indis in range(len(X)):
                x=X[indis]
                y=Y[indis]
                ilkIleriYayilim = self.ileriYayilim(x,y) 
                for ilkTurev in range(len(self.duyarliliklar[-1])):
                    self.duyarliliklar[-1][ilkTurev].append((self.hata[ilkTurev])*self.katmanAktivasyonFonksiyonlari[-1].geri(self.agYapisi[-1][ilkTurev].toplam))
                    
                    #self.bKismiTurevler[-1][ilkTurev]=(self.hata[ilkTurev])*self.katmanAktivasyonFonksiyonlari[-1].geri(self.agYapisi[-1][ilkTurev].toplam)
                    #self.agYapisi[-1][ilkTurev].w-=self.wKismiTurevler[-1][ilkTurev]*ogrenmeOrani
                
                #Çıkış katmanın duyarlılığını hesapladığımız için onu tekrar hesaplamaya gerek yok.
                # burada index olarak n-2. indexten başlayıp 0'a kadar gidiyoruz :
                for i in range(self.katmanSayisi-2,-1,-1):
                    
                    #Burayı katmanın içindeki nöron kadar döndürüyoruz. Çünkü her bir nöronun duyarlılığını hesaplayacağız.
                    for j in range(len(self.agYapisi[i])):
                        #Kendisinden sonraki katmanın eleman sayısını kadar döndürüyoruz. Çünkü o katmandaki nöron sayısı kadar elimizde türev değerimiz olacak.
                        
                        for k in range(len(self.agYapisi[i+1])):
                            for b in range(len(self.duyarliliklar[i+1][k])):
                                #print('a')
                                #print(self.wKismiTurevler)
                                self.duyarliliklar[i][j].append(self.duyarliliklar[i+1][k][b]*self.agYapisi[i+1][k].w*self.katmanAktivasyonFonksiyonlari[i].geri(self.agYapisi[i][j].toplam))
    
            
                
                
                
                # Duyarlılık değerlerimizi hesapladık. Şimdi bu değerlerle ağırlıklarımızı güncelleştirme zamanı :
            
                for katman in range(self.katmanSayisi):
                    for noron in range(len(self.agYapisi[katman])):
                        for duyarlilik in self.duyarliliklar[katman][noron]:
                            if katman !=0:
                                delW=duyarlilik*self.agYapisi[katman][noron].toplanmisGiris
                            else:
                                delW=duyarlilik*self.agYapisi[katman][noron].toplanmisGiris

                            #O
                            print(ogrenmeOrani*delW)
                            self.agYapisi[katman][noron].w-=ogrenmeOrani*delW
                            self.agYapisi[katman][noron].sabit-=ogrenmeOrani*duyarlilik
                            
                self.duyarliliklar =[[[] for i in range(sayi)] for sayi in self.elemanSayilari]
        


def main():
    x,y=f()
    model = YapaySinirAgi([Sigmoid(),Sigmoid(),RELU()],[1,2,1])
    #print(model.ileriYayilim([4,5,6]))
    model.geriYayilim(x,y,epochSayisi=10)
    #print(model.wKismiTurevler[-1])
    print(model.ileriYayilim([4]))
    print(model.ileriYayilim([7]))
    print(model.ileriYayilim([500]))
    
    while True:
        x=int(input('Bir değer gir -> '))
        print(f'tahmin değeriniz -> {model.ileriYayilim(x)}')
        print(model.agYapisi[-1][0].sabit)
    

    
    
        
    #print(model.agYapisi[-3][1].w)
    

if __name__=='__main__':
    main()