FSANE yi güneş enerjili araba yarışlarına yetiştiremedik. moraller bozuk kafa ve beden yorgunluğumu salıdan beri uyuşukluk yaparak anca atabildim. birşeyler öğrenip yazmaya devam edicem ancak bu aralar sınavlarım var (elimde linuxta ağ yönetimiyle ilgili 3 kitap var onlara çalışıp pythonla birleştirmeye kasıcam bir de asıl amacım olan pentiumda gömülü sistem nasıl oluşturabilirim ve görüntü işleme üzerine bakıcağım tabi tembellik hakkımı da kullana kullana, ağır ağır olcak bunlar =)) ). güzel haberse fizik bölümüyle çift anadal programına başladım. kuantum çok güzel olucak =)

çizgi izleyen robotumuz

itü ve boğaziçi robot günlerine katıldı. itüde finale kaldı.

Python yapay sinir ağı modülü

yeni savaşımım bu kodla olucak. pythonda yapay sinir ağı çalışması (bpnn.py) bakalım çözebilcem mi=)

# Back-Propagation Neural Networks
#
# Written in Python. See http://www.python.org/
# Placed in the public domain.
# Neil Schemenauer

import math
import random
import string

random.seed(0)

# calculate a random number where: a <= rand < b
def rand(a, b):
return (b-a)*random.random() + a

# Make a matrix (we could use NumPy to speed this up)
def makeMatrix(I, J, fill=0.0):
m = []
for i in range(I):
m.append([fill]*J)
return m

# our sigmoid function, tanh is a little nicer than the standard 1/(1+e^-x)
def sigmoid(x):
return math.tanh(x)

# derivative of our sigmoid function
def dsigmoid(y):
return 1.0-y*y

class NN:
def __init__(self, ni, nh, no):
# number of input, hidden, and output nodes
self.ni = ni + 1 # +1 for bias node
self.nh = nh
self.no = no

# activations for nodes
self.ai = [1.0]*self.ni
self.ah = [1.0]*self.nh
self.ao = [1.0]*self.no

# create weights
self.wi = makeMatrix(self.ni, self.nh)
self.wo = makeMatrix(self.nh, self.no)
# set them to random vaules
for i in range(self.ni):
for j in range(self.nh):
self.wi[i][j] = rand(-2.0, 2.0)
for j in range(self.nh):
for k in range(self.no):
self.wo[j][k] = rand(-2.0, 2.0)

# last change in weights for momentum
self.ci = makeMatrix(self.ni, self.nh)
self.co = makeMatrix(self.nh, self.no)

def update(self, inputs):
if len(inputs) != self.ni-1:
raise ValueError, 'wrong number of inputs'

# input activations
for i in range(self.ni-1):
#self.ai[i] = sigmoid(inputs[i])
self.ai[i] = inputs[i]

# hidden activations
for j in range(self.nh):
sum = 0.0
for i in range(self.ni):
sum = sum + self.ai[i] * self.wi[i][j]
self.ah[j] = sigmoid(sum)

# output activations
for k in range(self.no):
sum = 0.0
for j in range(self.nh):
sum = sum + self.ah[j] * self.wo[j][k]
self.ao[k] = sigmoid(sum)

return self.ao[:]


def backPropagate(self, targets, N, M):
if len(targets) != self.no:
raise ValueError, 'wrong number of target values'

# calculate error terms for output
output_deltas = [0.0] * self.no
for k in range(self.no):
error = targets[k]-self.ao[k]
output_deltas[k] = dsigmoid(self.ao[k]) * error

# calculate error terms for hidden
hidden_deltas = [0.0] * self.nh
for j in range(self.nh):
error = 0.0
for k in range(self.no):
error = error + output_deltas[k]*self.wo[j][k]
hidden_deltas[j] = dsigmoid(self.ah[j]) * error

# update output weights
for j in range(self.nh):
for k in range(self.no):
change = output_deltas[k]*self.ah[j]
self.wo[j][k] = self.wo[j][k] + N*change + M*self.co[j][k]
self.co[j][k] = change
#print N*change, M*self.co[j][k]

# update input weights
for i in range(self.ni):
for j in range(self.nh):
change = hidden_deltas[j]*self.ai[i]
self.wi[i][j] = self.wi[i][j] + N*change + M*self.ci[i][j]
self.ci[i][j] = change

# calculate error
error = 0.0
for k in range(len(targets)):
error = error + 0.5*(targets[k]-self.ao[k])**2
return error


def test(self, patterns):
for p in patterns:
print p[0], '->', self.update(p[0])

def weights(self):
print 'Input weights:'
for i in range(self.ni):
print self.wi[i]
print
print 'Output weights:'
for j in range(self.nh):
print self.wo[j]

def train(self, patterns, iterations=1000, N=0.5, M=0.1):
# N: learning rate
# M: momentum factor
for i in xrange(iterations):
error = 0.0
for p in patterns:
inputs = p[0]
targets = p[1]
self.update(inputs)
error = error + self.backPropagate(targets, N, M)
if i % 100 == 0:
print 'error %-14f' % error


def demo():
# Teach network XOR function
pat = [
[[0,0], [0]],
[[0,1], [1]],
[[1,0], [1]],
[[1,1], [0]]
]

# create a network with two input, two hidden, and one output nodes
n = NN(2, 2, 1)
# train it with some patterns
n.train(pat)
# test it
n.test(pat)



if __name__ == '__main__':
demo()

python kodları.2

x üssü n i hesaplayalım:

• n sıfırsa 1 çıktısı ver
• n mod 2 de 0 yani çift sayı ise
• x in x le çarpımını n/2 sayısıyla bu fonksiyonda yeniden çalıştır.
• böylece n/2k=1 e kadar xler kademeli olarak çarpılmış olacaktır.
• n tek sayı ise (yukardaki işlemlerden sonra elde ettiğimiz n/2k=1 de dahil)
• x çarpanını ayırıp n i çift sayı haline getirir ve çift sayılardaki işlemi uygular.

fields madalyalı bloglar

fields madalyası sahibi iki matematikçinin blogları

• http://noncommutativegeometry.blogspot.com/ (Alain Connes)
• http://terrytao.wordpress.com/ (Terry Tao)

python kodları.1

sıfırdan n e kadar olan sayıların toplanması:



def ile topla isimli ve n girdili bir fonksiyon tanımlanmıştır.

sonuc=0 ve i=1 tanımlamaları yapılmıştır. bunlar ilerde kullanılacak değişkenlerdir. while ile i nden küçük ve eşit olduğu sürece çalışacak bir döngü oluşturulmuştur. her döngüde sonuç i ile toplanıp değeri arttırılacak ve i bir arttırılacaktır bölece i ne kadar artar ve return sonuc ile döngüden çıkıp sonucu elde eder.
mesela n=5 için döngüye bakalım:

• sonuc=s=0 ve i=1, i nden küçük ve döngü başlar:
• s= 0+1, i =1+1=2, n den küçük döngüye devam,
• s=1+2, i=2+1=3, yine nden küçük
• s=3+3, i=3+1, yine,
• s=6+4, i=4+1=5, n e eşit son bir döngü daha,
• s=10+5, i=5+1=6 ve nihayet n den büyük ve döngüden çıkar.
• return sonuc a gelir ve cevabı geri döndürür.

python kodları.0

bi sitede python kodları buldum. burada da anlayabildiklerimi yazmaya çalışacağım.


ilki faktöriyel hesaplama:


def ile fonksiyon tanımlanmış fonksiyonun adı faktoryel kullanılan girdi de n dir.

eğer n sıfıra eşitse program 1 çıktııs verir ve biter bunu return komutu sağlar.
sıfırdan farklı bir değerse n faktoryal (n-1) fonksiyonu ile çarpılıp işlem biter. ancak faktoryel n-1 sıfırdan farklı ise o fonksiyonda da (n-1) le faktoryel(n-1 - 1) işlemi vardır ve bu sıfıra kadar gider. sonuç olarak n(n-1)(n-2)(n-3)...(n-(n-2))(n-(n-1) e kadar sürer işlemimiz ve bu da n! e eşittir.