De eerste tests met de 'graantjes' waren veelbelovend. Een meting op de betrouwbaarheid zat rond de
98,4%. Toch al aardig. Wel blijkbaar afhankelijk van de het formaat (4x4) van de graankorrels. Een kleine korrel (2x2 pixels) geeft 99,8% !!!! 1 pixel doet het dan weer heel veel slechter (46,8%). Bij grotere graankorrels zal de kans van overlapping natuurlijk toenemen.
Omdat het graan-formaat zoveel uitmaakt is het ook interessant om te kijken wat een variable formaat doet. Ik kies een formaat van 1 tot 9 pixels (3x3). De betrouwbaarheid holt achteruit. (48%). Daar een convolutional network meer naar 'features' kijkt dan naar vormen zou dat hiervoor geschikter moeten zijn. Hoewel mijn videokaart nog onbetrouwbaar is (Nieuw binnengekomen voeding lijkt niet te werken) ga ik het toch maar proberen. Na enig passen en meten (sleutelen aan de vorm van input dataset met de graantjes en de resultaat dataset met de aantallen) lukt het om het programma draaiende te krijgen. Na 100 zenuwslopende leer-loops (blijft de kaart het volhouden?!) blijft de stand steken op 91% Nog niet hoog maar heel wat beter dan het skikit SVC algoritme. Blijkbaar is graantjes tellen ingewikkelder dan het lijkt. Misschien moet ik de logische fout (graantjes boven op elkaar) er eerst nog even uithalen om het echt te kunnen beoordelen.
Hier weer het gebruikte programma:
import theano
from theano import tensor as T
from theano.sandbox.rng_mrg import MRG_RandomStreams as RandomStreams
import numpy as np
from theano.tensor.nnet.conv import conv2d
from theano.tensor.signal.downsample import max_pool_2d
import time
srng = RandomStreams()
####################################
si = 5000 # Aantal oefenafbeeldingen
t_si = -.1 * si # testset 10%
h = 28 # hoogte
b = 28 # breedte
r = 3 # (max) graan-grootte
a = 5 # (max) aantal graantjes
ima = np.zeros((si, h * b))
ima.shape = si, h , b
grains = np.floor(np.random.rand(si) * a)
num = np.zeros((si,10))
for i in range(si):
num[i,int(grains[i])]=1.
for i in range(0,si):
for j in range(0,int(grains[i])):
ho = np.floor(np.random.rand() * (h-r))
br = np.floor(np.random.rand() * (b-r))
vr = 1 + np.floor(np.random.rand() * r)
#vr = r
for x in range(int(ho),int(ho+vr)):
for y in range(int(br),int(br+vr)):
ima[i,x,y] = 1
ima.shape = si, h * b
trX,trY = ima[:t_si], num[:t_si]
teX,teY = ima[t_si:], num[t_si:]
####################################
def floatX(X):
return np.asarray(X, dtype=theano.config.floatX)
def init_weights(shape):
return theano.shared(floatX(np.random.randn(*shape) * 0.01))
def rectify(X):
return T.maximum(X, 0.)
def softmax(X):
e_x = T.exp(X - X.max(axis=1).dimshuffle(0, 'x'))
return e_x / e_x.sum(axis=1).dimshuffle(0, 'x')
def dropout(X, p=0.):
if p > 0:
retain_prob = 1 - p
X *= srng.binomial(X.shape, p=retain_prob, dtype=theano.config.floatX)
X /= retain_prob
return X
def RMSprop(cost, params, lr=0.001, rho=0.9, epsilon=1e-6):
grads = T.grad(cost=cost, wrt=params)
updates = []
for p, g in zip(params, grads):
acc = theano.shared(p.get_value() * 0.)
acc_new = rho * acc + (1 - rho) * g ** 2
gradient_scaling = T.sqrt(acc_new + epsilon)
g = g / gradient_scaling
updates.append((acc, acc_new))
updates.append((p, p - lr * g))
return updates
def model(X, w, w2, w3, w4, p_drop_conv, p_drop_hidden):
l1a = rectify(conv2d(X, w, border_mode='full'))
l1 = max_pool_2d(l1a, (2, 2))
l1 = dropout(l1, p_drop_conv)
l2a = rectify(conv2d(l1, w2))
l2 = max_pool_2d(l2a, (2, 2))
l2 = dropout(l2, p_drop_conv)
l3a = rectify(conv2d(l2, w3))
l3b = max_pool_2d(l3a, (2, 2))
l3 = T.flatten(l3b, outdim=2)
l3 = dropout(l3, p_drop_conv)
l4 = rectify(T.dot(l3, w4))
l4 = dropout(l4, p_drop_hidden)
pyx = softmax(T.dot(l4, w_o))
return l1, l2, l3, l4, pyx
trX = trX.reshape(-1, 1, 28, 28)
teX = teX.reshape(-1, 1, 28, 28)
X = T.ftensor4()
Y = T.fmatrix()
w = init_weights((32, 1, 3, 3))
w2 = init_weights((64, 32, 3, 3))
w3 = init_weights((128, 64, 3, 3))
w4 = init_weights((128 * 3 * 3, 625))
w_o = init_weights((625, 10))
noise_l1, noise_l2, noise_l3, noise_l4, noise_py_x = model(X, w, w2, w3, w4, 0.2, 0.5)
l1, l2, l3, l4, py_x = model(X, w, w2, w3, w4, 0., 0.)
y_x = T.argmax(py_x, axis=1)
cost = T.mean(T.nnet.categorical_crossentropy(noise_py_x, Y))
params = [w, w2, w3, w4, w_o]
updates = RMSprop(cost, params, lr=0.001)
train = theano.function(inputs=[X, Y], outputs=cost, updates=updates, allow_input_downcast=True)
predict = theano.function(inputs=[X], outputs=y_x, allow_input_downcast=True)
t0 = time.time()
for i in range(100):
for start, end in zip(range(0, len(trX), 128), range(128, len(trX), 128)):
cost = train(trX[start:end], trY[start:end])
#print np.mean(np.argmax(teY, axis=1) == predict(teX))
print i, time.time() - t0, "seconds / reliability: ", np.mean(np.argmax(teY, axis=1) == predict(teX))
t0 = time.time()
#time.sleep(60)
