def f(state,params):
bnet = Sequential()
arch = params["arch"]
bnet.add(Dense(arch[0],input_shape=(width,),activation=params["activation"]))
for layer in arch[1:]:
bnet.add(Dense(int(layer),activation=params["activation"]))
bnet.add(Dense(4,activation="softmax"))
optimizer = get_optimizer(params["optimizer"])
bnet.compile(loss="categorical_crossentropy",
optimizer=optimizer(lr=params["lr"]), metrics=["accuracy"])
history = bnet.fit(btrain[0], btrain_y,
validation_data=(bvalid[0], bvalid_y),
epochs=params["epochs"], batch_size=params["batch_size"])
classify = bnet.predict_classes(test_bdata)
print(theautil.classifications(classify,test_blabels))
score = bnet.evaluate(test_bdata, btest_y)
print("Scores: %s" % score)
return score[1]
# my solution
def in_circle(x, y, cx, cy, radius):
return (x - float(cx))**2 + (y - float(cy))**2 < radius**2
def mysolution(pt, outer=0.3):
return in_circle(pt[0], pt[1], 0.5, 0.5,
outer) and not in_circle(pt[0], pt[1], 0.5, 0.5, 0.1)
# apply my classifier
myclasses = np.apply_along_axis(mysolution, 1, test[0])
print "My classifier!"
print "%s / %s " % (sum(myclasses == test[1]), len(test[1]))
print theautil.classifications(myclasses, test[1])
def euclid(pt1, pt2):
return sum([(pt1[i] - pt2[i])**2 for i in range(0, len(pt1))])
def oneNN(data, labels):
def func(input):
distance = None
label = None
for i in range(0, len(data)):
d = euclid(input, data[i])
if distance == None or d < distance:
distance = d
label = labels[i]
########################################################################
# Part 3. Let's start using neural networks!
########################################################################
# try different combos here
archi=1;
print "Architecture 1: [11,15,15,15,2]"
print "Architecture 2: [11,30,30,30,2]"
print "Architecture 3: [11,30,30,30,30,30,30,2]"
archi = input('choose one of these three architecture(input 1, 2 or 3):')
if archi==2:
architecture = '[11,30,30,30,2]'
net = theanets.Classifier([11,30,30,30,2])
elif archi==3:
architecture = '[11,30,30,30,30,30,30,2]'
net = theanets.Classifier([11,30,30,30,30,30,30,2])
else:
architecture = '[11,15,15,15,2]'
net = theanets.Classifier([11,15,15,15,2])
net.train(train, valid, algo='layerwise', max_updates=mupdates, patience=1)
#net.train(train, valid, algo='rprop', max_updates=mupdates, patience=1)
print architecture
print "Learner on the test set"
classify = net.classify(test[0])
print "%s / %s " % (sum(classify == test[1]),len(test[1]))
print collections.Counter(classify)
print theautil.classifications(classify,test[1])
cnet.add(Dense(4, activation="softmax"))
copt = SGD(lr=0.1)
# opt = Adam(lr=0.1)
cnet.compile(loss="categorical_crossentropy",
optimizer=copt,
metrics=["accuracy"])
history = cnet.fit(train1[0],
train1_y,
validation_data=(valid1[0], valid1_y),
epochs=100,
batch_size=16)
#score = cnet.evaluate(test_data, test_labels)
#print("Scores: %s" % score)
classify = cnet.predict_classes(test_data)
print(theautil.classifications(classify, test_labels))
score = cnet.evaluate(test_data, test1_y)
print("Scores: %s" % score)
# now that's kind of interesting, an accuracy of .3 to .5 max
# still pretty inaccurate, but 1 sample might never be enough.
print(
"We could train longer and we might get better results, but there's ambiguity in each. As a human we might have a hard time determining them."
)
print('''
########################################################################
# Experiment 2: can we classify a sample of data?
#
#
# my solution
def in_circle(x, y, cx, cy, radius):
return (x - float(cx))**2 + (y - float(cy))**2 < radius**2
def mysolution(pt, outer=0.3):
return in_circle(pt[0], pt[1], 0.5, 0.5,
outer) and not in_circle(pt[0], pt[1], 0.5, 0.5, 0.1)
# apply my classifier
myclasses = np.apply_along_axis(mysolution, 1, mltest[0])
print("My classifier!")
print("%s / %s " % (sum(myclasses == mltest[1]), len(mltest[1])))
print(theautil.classifications(myclasses, mltest[1]))
def euclid(pt1, pt2):
return sum([(pt1[i] - pt2[i])**2 for i in range(0, len(pt1))])
def oneNN(data, labels):
def func(input):
distance = None
label = None
for i in range(0, len(data)):
d = euclid(input, data[i])
if distance == None or d < distance:
distance = d
label = labels[i]
train = (train[0],linit(train[1]))
valid = (valid[0],linit(valid[1]))
test = (test[0] ,linit(test[1]))
# my solution
def in_circle(x,y,cx,cy,radius):
return (x - float(cx)) ** 2 + (y - float(cy)) ** 2 < radius**2
def mysolution(pt,outer=0.3):
return in_circle(pt[0],pt[1],0.5,0.5,outer) and not in_circle(pt[0],pt[1],0.5,0.5,0.1)
# apply my classifier
myclasses = np.apply_along_axis(mysolution,1,test[0])
print "My classifier!"
print "%s / %s " % (sum(myclasses == test[1]),len(test[1]))
print theautil.classifications(myclasses,test[1])
def euclid(pt1,pt2):
return sum([ (pt1[i] - pt2[i])**2 for i in range(0,len(pt1)) ])
def oneNN(data,labels):
def func(input):
distance = None
label = None
for i in range(0,len(data)):
d = euclid(input,data[i])
if distance == None or d < distance:
distance = d
label = labels[i]
return label
return func
train = (train[0],linit(train[1])) valid = (valid[0],linit(valid[1])) #test = (test[0] ,linit(test[1])) #first cnet = theanets.Classifier([8,2,2]) cnet.train(train,valid, algo='layerwise', patience=1, max_updates=mupdates) cnet.train(train,valid, algo='rprop', patience=1, max_updates=mupdates) print "%s / %s " % (sum(cnet.classify(inputs) == outputs),len(outputs)) classify = cnet.classify(valid[0]) print "%s / %s " % (sum(classify == valid[1]),len(valid[1])) print collections.Counter(classify) print theautil.classifications(classify,valid[1]) #Second cnet = theanets.Classifier([8,4,8,2]) cnet.train(train,valid, algo='layerwise', patience=1, max_updates=mupdates) cnet.train(train,valid, algo='rprop', patience=1, max_updates=mupdates) print "%s / %s " % (sum(cnet.classify(inputs) == outputs),len(outputs)) classify = cnet.classify(valid[0]) print "%s / %s " % (sum(classify == valid[1]),len(valid[1])) print collections.Counter(classify) print theautil.classifications(classify,valid[1]) #Third cnet = theanets.Classifier([8,6,5,8,2]) cnet.train(train,valid, algo='layerwise', patience=1, max_updates=mupdates)
