def partialTraining(result_queue, li_pair):
length = li_pair[0]
index = li_pair[1]
print length
print index
actualLength = 0
t_set = []
for i in range(index, index + length):
try:
t_set.append(numpy.loadtxt(filename + str(i + 1) + ".txt"))
actualLength += 1
except Exception as e:
break
d_set = SupervisedDataSet(window, window)
for i in range(0, actualLength - 1):
d_set.addSample(t_set[i], t_set[i + 1])
network = buildNetwork(window,
window - 1,
window,
outclass=LinearLayer,
bias=True,
recurrent=True)
bpTrainer = BackpropTrainer(network, d_set)
bpTrainer.trainEpochs(100)
t_s = UnsupervisedDataSet(window, )
#add the sample to be predicted
t_s.addSample(t_set[actualLength - 1])
result = network.activateOnDataset(t_s)
result_queue.put(result[0])
def __init__(self,inp, words):
self.length = len(inp)
UnsupervisedDataSet.__init__(self, self.length)
self.setField('input', inp)
self.addField('words',1)
self.setField('words', words)
self.annotationSets = {}
def predict_net(self, net, input_table, daily):
real_plot = []
predict_plot = []
error_abs_sum = []
error_actual_sum = []
for date, value in input_table.iterrows():
ts = UnsupervisedDataSet(input_table.shape[1], )
ts.addSample(input_table.loc[date])
pre = [int(i) for i in net.activateOnDataset(ts)[0]]
actual = np.array(daily.loc[date])
error_abs, error_actual = self.cal_error(pre, actual)
error_abs_sum.append(error_abs)
error_actual_sum.append(error_actual)
for i in range(len(pre)):
predict_plot.append(pre[i])
real_plot.append(actual[i])
mape_error = np.array(error_abs_sum).sum() / np.array(
error_actual_sum).sum()
print 'Mape= ', mape_error
return np.array(error_abs_sum).sum(), np.array(
error_actual_sum).sum(), real_plot, predict_plot
def get_nn_dom_prediction(train_data,
train_truth,
test_data,
test_truth,
hidden=(5, ),
weight_decay=0.0):
# Convert data to capture dominance.
train_data, test_data = tuple(
map(_convert_to_individual_alleles, [train_data, test_data]))
mean = np.mean(train_truth)
sd = np.std(train_truth)
# Supervised training dataset.
ds = SupervisedDataSet(train_data.shape[1], 1)
ds.setField('input', train_data)
ds.setField('target', (train_truth[:, np.newaxis] - mean) / sd)
net = _get_nn(train_data.shape[1], hidden)
_train_nn(net, ds, weight_decay)
# Unsupervised (test) dataset.
test_ds = UnsupervisedDataSet(test_data.shape[1])
test_ds.setField('sample', test_data)
predicted = net.activateOnDataset(test_ds) * sd + mean
return predicted.ravel()
def process_symbol(net, symbol): settings = load(symbol+'.set') if(len(settings)==0): return yahoo = Share(symbol) mp = 2.0*settings['maxc'] p = float(yahoo.get_price())/mp d = yahoo.get_trade_datetime() wd = datetime.datetime.strptime(d[:10],"%Y-%m-%d").weekday()/6.0 v = float(yahoo.get_volume())/(2*settings['maxv']) ts = UnsupervisedDataSet(3,) ts.addSample((wd,p,v),) ret = net.activate([wd,p,v]) print "IK, K, V ", ret
class RAE(object): def __init__(self, in_dims, out_dims): self.dataset = UnsupervisedDataSet(in_dims) cfg = RbmGibbsTrainerConfig() cfg.maxIter = 5 self.model = Rbm.fromDims(in_dims, out_dims) self.trainer = RbmBernoulliTrainer(self.model, self.dataset, cfg) def add_data(self, data): for d in data: self.dataset.addSample(d) def _train(self, iterations): for _ in xrange(iterations): self.trainer.train()
def train(self):
# We will build up a network piecewise in order to create a new dataset
# for each layer.
dataset = self.dataset
piecenet = FeedForwardNetwork()
piecenet.addInputModule(copy.deepcopy(self.net.inmodules[0]))
# Add a bias
bias = BiasUnit()
piecenet.addModule(bias)
# Add the first visible layer
firstRbm = self.iterRbms().next()
visible = copy.deepcopy(firstRbm.visible)
piecenet.addModule(visible)
# For saving the rbms and their inverses
self.invRbms = []
self.rbms = []
for rbm in self.iterRbms():
self.net.sortModules()
# Train the first layer with an rbm trainer for `epoch` epochs.
trainer = self.trainerKlass(rbm, dataset, self.cfg)
for _ in xrange(self.epochs):
trainer.train()
self.invRbms.append(trainer.invRbm)
self.rbms.append(rbm)
# Add the connections and the hidden layer of the rbm to the net.
hidden = copy.deepcopy(rbm.hidden)
biascon = FullConnection(bias, hidden)
biascon.params[:] = rbm.biasWeights
con = FullConnection(visible, hidden)
con.params[:] = rbm.weights
piecenet.addConnection(biascon)
piecenet.addConnection(con)
piecenet.addModule(hidden)
# Overwrite old outputs
piecenet.outmodules = [hidden]
piecenet.outdim = rbm.hiddenDim
piecenet.sortModules()
dataset = UnsupervisedDataSet(rbm.hiddenDim)
for sample, in self.dataset:
new_sample = piecenet.activate(sample)
dataset.addSample(new_sample)
visible = hidden
def train(self):
# We will build up a network piecewise in order to create a new dataset
# for each layer.
dataset = self.dataset
piecenet = FeedForwardNetwork()
piecenet.addInputModule(copy.deepcopy(self.net.inmodules[0]))
# Add a bias
bias = BiasUnit()
piecenet.addModule(bias)
# Add the first visible layer
firstRbm = self.iterRbms().next()
visible = copy.deepcopy(firstRbm.visible)
piecenet.addModule(visible)
# For saving the rbms and their inverses
self.invRbms = []
self.rbms = []
for rbm in self.iterRbms():
self.net.sortModules()
# Train the first layer with an rbm trainer for `epoch` epochs.
trainer = self.trainerKlass(rbm, dataset, self.cfg)
for _ in xrange(self.epochs):
trainer.train
self.invRbms.append(trainer.invRbm)
self.rbms.append(rbm)
# Add the connections and the hidden layer of the rbm to the net.
hidden = copy.deepcopy(rbm.hidden)
biascon = FullConnection(bias, hidden)
biascon.params[:] = rbm.biasWeights
con = FullConnection(visible, hidden)
con.params[:] = rbm.weights
piecenet.addConnection(biascon)
piecenet.addConnection(con)
piecenet.addModule(hidden)
# Overwrite old outputs
piecenet.outmodules = [hidden]
piecenet.outdim = rbm.hiddenDim
piecenet.sortModules()
dataset = UnsupervisedDataSet(rbm.hiddenDim)
for sample, in self.dataset:
new_sample = piecenet.activate(sample)
dataset.addSample(new_sample)
visible = hidden
def polynomialRegression(train_file, predict_file, res):
X_train, y_train = load_svmlight_file(train_file)
dim = X_train.shape[1]
X_test, y_test = load_svmlight_file(predict_file,
n_features=X_train.shape[1])
train = SupervisedDataSet(dim, 1)
test = UnsupervisedDataSet(dim)
trainM = X_train.todense()
for x, y in zip(trainM, y_train):
train.addSample(x, y)
testM = X_test.todense()
for x in testM:
test.addSample(x)
from pybrain.structure import SigmoidLayer, LinearLayer
from pybrain.tools.shortcuts import buildNetwork
print X_train.shape[1]
net = buildNetwork(
dim,
100, # number of hidden units
1,
bias=True,
hiddenclass=SigmoidLayer,
outclass=LinearLayer)
#----------
# train
#----------
from pybrain.supervised.trainers import BackpropTrainer
trainer = BackpropTrainer(net, train, verbose=True)
trainer.trainUntilConvergence(maxEpochs=100)
#----------
# evaluate
#----------
result = []
for x in testM:
result.append(net.activate(np.asarray(x).flatten())[0])
print result
print y_train
for i in result:
with open(res, "a") as myfile:
myfile.write(str(i) + ' ')
def polynomialRegression(train_file,predict_file,res):
X_train, y_train = load_svmlight_file(train_file)
dim=X_train.shape[1]
X_test,y_test=load_svmlight_file(predict_file,n_features=X_train.shape[1])
train = SupervisedDataSet(dim, 1)
test=UnsupervisedDataSet(dim)
trainM=X_train.todense()
for x, y in zip(trainM, y_train):
train.addSample(x, y)
testM=X_test.todense()
for x in testM:
test.addSample(x)
from pybrain.structure import SigmoidLayer, LinearLayer
from pybrain.tools.shortcuts import buildNetwork
print X_train.shape[1]
net = buildNetwork(dim,
100, # number of hidden units
1,
bias = True,
hiddenclass = SigmoidLayer,
outclass = LinearLayer
)
#----------
# train
#----------
from pybrain.supervised.trainers import BackpropTrainer
trainer = BackpropTrainer(net, train, verbose = True)
trainer.trainUntilConvergence(maxEpochs = 100)
#----------
# evaluate
#----------
result=[]
for x in testM:
result.append(net.activate(np.asarray(x).flatten())[0])
print result
print y_train
for i in result:
with open(res, "a") as myfile:
myfile.write(str(i)+' ')
def createUnsupervisedDataSetFromCSVFile(input_file): # init the dataset print "Creating an unsupervised dataset from", input_file ds = UnsupervisedDataSet(nFeatures) with open(input_file) as training_data: reader = csv.reader(training_data) for row in reader: row_data = [] for data in row: try: row_data.append(float(data)) except ValueError: print "Non-floatable value!" ds.addSample(tuple(row_data[2:])) # drop the Qid and Aid print "Dataset created with size", len(ds), "and", ds.dim, "features." return ds
def get_nn_dom_prediction(train_data, train_truth, test_data, test_truth, hidden=(5,), weight_decay=0.0):
# Convert data to capture dominance.
train_data, test_data = tuple(map(_convert_to_individual_alleles, [train_data, test_data]))
mean = np.mean(train_truth)
sd = np.std(train_truth)
# Supervised training dataset.
ds = SupervisedDataSet(train_data.shape[1], 1)
ds.setField('input', train_data)
ds.setField('target', (train_truth[:, np.newaxis] - mean) / sd)
net = _get_nn(train_data.shape[1], hidden)
_train_nn(net, ds, weight_decay)
# Unsupervised (test) dataset.
test_ds = UnsupervisedDataSet(test_data.shape[1])
test_ds.setField('sample', test_data)
predicted = net.activateOnDataset(test_ds) * sd + mean
return predicted.ravel()
def test_net(self, input_table, daily=None, label=None):
if self.net_num == 1:
for date, value in input_table.iterrows():
ts = UnsupervisedDataSet(input_table.shape[1], )
ts.addSample(value)
pred = self.prediction_net[0].activateOnDataset(ts)[0]
self.predict_plot.append(pred)
self.result[date] = pred
actual = np.array(daily.loc[date])
self.cal_error_for_list(pred, actual)
else:
for date, classNo in label.iterrows():
classNo_int = int(classNo[0])
# add test sample
ts = UnsupervisedDataSet(input_table.shape[1], )
ts.addSample(input_table.loc[date])
# create prediction result
pred = self.prediction_net[classNo_int].activateOnDataset(
ts)[0]
self.predict_plot.append(pred)
self.result[date] = pred
if isinstance(daily, pd.DataFrame):
actual = np.array(daily.loc[date])
self.cal_error_for_list(pred, actual)
else:
pass
if isinstance(daily, pd.DataFrame):
print "MAPE = ", self.cal_error_sum()
from pybrain.structure import LinearLayer, SigmoidLayer, TanhLayer, SoftmaxLayer
from pybrain.structure import FullConnection
from pybrain.datasets import ClassificationDataSet, SupervisedDataSet, UnsupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.unsupervised.trainers.deepbelief import DeepBeliefTrainer
from pybrain.supervised.trainers import Trainer
from pybrain.structure.networks.rbm import Rbm
from pybrain.unsupervised.trainers.rbm import (RbmGibbsTrainerConfig,
RbmBernoulliTrainer)
import csv
import numpy
# set up a basic feed forward network
net = FeedForwardNetwork()
ds = ClassificationDataSet(9, 1, nb_classes=2, class_labels=['FRAUD', 'N'])
temp_ds = UnsupervisedDataSet(9)
# define 3 layers
inLayer = LinearLayer(9, "visible")
hiddenLayer = SigmoidLayer(16)
outLayer = LinearLayer(1)
# add layers to network
net.addInputModule(inLayer)
net.addModule(hiddenLayer)
net.addOutputModule(outLayer)
# define connections between layers
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
from pybrain.tools.shortcuts import buildNetwork from pybrain.supervised.trainers import BackpropTrainer from pybrain.datasets import SupervisedDataSet,UnsupervisedDataSet from pybrain.structure import LinearLayer ds = SupervisedDataSet(21, 21) ds.addSample(map(int,'1 2 4 6 2 3 4 5 1 3 5 6 7 1 4 7 1 2 3 5 6'.split()),map(int,'1 2 5 6 2 4 4 5 1 2 5 6 7 1 4 6 1 2 3 3 6'.split())) ds.addSample(map(int,'1 2 5 6 2 4 4 5 1 2 5 6 7 1 4 6 1 2 3 3 6'.split()),map(int,'1 3 5 7 2 4 6 7 1 3 5 6 7 1 4 6 1 2 2 3 7'.split())) net = buildNetwork(21, 20, 21, outclass=LinearLayer,bias=True, recurrent=True) trainer = BackpropTrainer(net, ds) trainer.trainEpochs(100) ts = UnsupervisedDataSet(21,) ts.addSample(map(int,'1 3 5 7 2 4 6 7 1 3 5 6 7 1 4 6 1 2 2 3 7'.split())) x = [ int(round(i)) for i in net.activateOnDataset(ts)[0]] print x
from pybrain.tools.shortcuts import buildNetwork
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.datasets import SupervisedDataSet,UnsupervisedDataSet
from pybrain.structure import LinearLayer
ds = SupervisedDataSet(10, 11)
z = map(int,'1 2 4 6 2 3 4 5 1 3 5 6 7 1 4 7 1 2 3 5 6 1 2 5 6 2 4 4 5 1 2 5 6 7 1 4 6 1 2 3 3 6 1 3 5 7 2 4 6 7 1 3 5 6 7 1 4 6 1 2 2 3 7'.split())
obsLen = 10
predLen = 11
for i in xrange(len(z)):
if i+(obsLen-1)+predLen < len(z):
ds.addSample([z[d] for d in range(i,i+obsLen)],[z[d] for d in range(i+1,i+1+predLen)])
net = buildNetwork(10, 20, 11, outclass=LinearLayer,bias=True, recurrent=True)
trainer = BackpropTrainer(net, ds)
trainer.trainEpochs(100)
ts = UnsupervisedDataSet(10,)
ts.addSample(map(int,'1 3 5 7 2 4 6 7 1 3'.split()))
print [ int(round(i)) for i in net.activateOnDataset(ts)[0]]
net.addConnection(FullConnection(bias, h1))
net.addConnection(FullConnection(bias, h2))
net.addConnection(FullConnection(bias, out))
net.sortModules()
return net
if __name__ == "__main__":
import GwData
data = GwData.GwData()
xs = get_binary_data(data)
ys = data.labels_for("50")
sdataset = SupervisedDataSet(xs.shape[1], 1)
udataset = UnsupervisedDataSet(xs.shape[1])
for i, x in enumerate(xs):
sdataset.addSample(x, ys[i])
udataset.addSample(x)
epochs = 100
layerDims = [xs.shape[1], 300, 100, 2]
#net = buildNetwork(*layerDims)
net = custom_build_network(layerDims)
trainer = DeepBeliefTrainer(net, dataset=udataset)
#trainer = DeepBeliefTrainer(net, dataset=sdataset)
trainer.trainEpochs(epochs)
from pybrain.tools.xml import NetworkReader
print 'read dataset'
text_file = open('doc/recog.txt')
lines = text_file.read().split('\n')
text_file.close()
text_file = open('doc/labels.txt')
labels = text_file.read().split('\n')
text_file.close()
network = NetworkReader.readFrom('NN.xml')
for line in lines:
if not line:
continue
line = line.split(' ')
datas = line[:-1]
x = []
for data in datas:
x.append(float(data))
data_set = UnsupervisedDataSet(13)
data_set.addSample(x)
out = network.activateOnDataset(data_set)
print labels[np.argmax(out)]
n = input("Enter number of process:")
print "Enter the burst time of first five process:"
bt = []
p = []
for i in range(0, 5):
bt.append(int(input("p%(x)d :" % {"x": i + 1})))
for i in range(0, n):
p.append(i + 1)
for l in range(5, n):
a = str(bt[l - 5])
b = str(bt[l - 4])
c = str(bt[l - 3])
d = str(bt[l - 2])
e = str(bt[l - 1])
ts = UnsupervisedDataSet(5, )
ts.addSample(map(int, [a, b, c, d, e]))
x = net.activateOnDataset(ts)
bt.append(int(x))
print "----------------------------------------------------------------"
print " FCFS "
print "----------------------------------------------------------------"
wt = [0]
total = 0
for i in range(1, n):
wt.append(0)
for j in range(0, i):
wt[i] += bt[j]
total += wt[i]
avg_wt1 = float(total) / n
def test_network(self, network, data):
dataset = UnsupervisedDataSet(2)
dataset.addSample(data)
return network.activateOnDataset(dataset)[0]
def __init__(self, in_dims, out_dims): self.dataset = UnsupervisedDataSet(in_dims) cfg = RbmGibbsTrainerConfig() cfg.maxIter = 5 self.model = Rbm.fromDims(in_dims, out_dims) self.trainer = RbmBernoulliTrainer(self.model, self.dataset, cfg)
net.addConnection(FullConnection(bias, h1))
net.addConnection(FullConnection(bias, h2))
net.addConnection(FullConnection(bias, out))
net.sortModules()
return net
if __name__ == "__main__":
import GwData
data = GwData.GwData()
xs = get_binary_data(data)
ys = data.labels_for("50")
sdataset = SupervisedDataSet(xs.shape[1], 1)
udataset = UnsupervisedDataSet(xs.shape[1])
for i,x in enumerate(xs):
sdataset.addSample(x, ys[i])
udataset.addSample(x)
epochs = 100
layerDims = [xs.shape[1], 300, 100, 2]
#net = buildNetwork(*layerDims)
net = custom_build_network(layerDims)
trainer = DeepBeliefTrainer(net, dataset=udataset)
#trainer = DeepBeliefTrainer(net, dataset=sdataset)
trainer.trainEpochs(epochs)
def do_GET(self):
print self.path
if self.path == "/":
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.send_header("Access-Control-Allow-Origin", "*")
self.end_headers()
with open(os.getcwd() + '/index.html') as f: self.wfile.write(f.read())
elif self.path.endswith(".png"):
self.send_response(200)
self.send_header('Content-type', 'image/png')
self.send_header("Access-Control-Allow-Origin", "*")
self.end_headers()
with open(os.getcwd() + self.path) as f: self.wfile.write(f.read())
elif self.path.startswith("/train:on"):
print "training..."
count = 0
cap = cv2.VideoCapture(0)
cap.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, 80)
cap.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, 50)
cap.set(cv2.cv.CV_CAP_PROP_FPS, 15)
time.sleep(1.0)
HTTPHandler.train = True
while cap.isOpened() and HTTPHandler.train:
time.sleep(0.1)
if HTTPHandler.left > 40 and HTTPHandler.right > 40:
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
print "frame: ", count, HTTPHandler.left, HTTPHandler.right
cv2.imwrite("frame_{count:04d}_{left:03d}_{right:03d}.png".format(count=count, left=HTTPHandler.left, right=HTTPHandler.right), gray)
count = count + 1
cap.release()
elif self.path.startswith("/train:off"):
HTTPHandler.train = False
elif self.path.startswith("/debug:on"):
HTTPHandler.debug = True
elif self.path.startswith("/debug:off"):
HTTPHandler.debug = False
elif self.path.startswith("/debug:step"):
HTTPHandler.debug_step = True
elif self.path.startswith("/auto:on"):
self.send_response(200)
self.send_header('Content-type','multipart/x-mixed-replace; boundary=--jpgboundary')
self.end_headers()
print "run"
file = "net.obj"
fileObject = open(file, 'r')
network = pickle.load(fileObject)
error = 0.02;
fileObject.close()
print "..."
cap = cv2.VideoCapture(0)
cap.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, 80)
cap.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, 50)
cap.set(cv2.cv.CV_CAP_PROP_FPS, 15)
time.sleep(1.0)
HTTPHandler.auto = True
while cap.isOpened() and HTTPHandler.auto:
while HTTPHandler.debug and not HTTPHandler.debug_step:
time.sleep(0.1)
HTTPHandler.debug_step = False
ret, frame = cap.read()
gray = cv2.cvtColor(frame, cv2.COLOR_BGR2GRAY)
crop = gray[25:,]
inverted = (255 - crop)
bw = cv2.threshold(inverted, 128, 255, cv2.THRESH_BINARY | cv2.THRESH_OTSU)[1]
array = bw.reshape(1, SIZE/2).astype(np.float32)
dataset = UnsupervisedDataSet(SIZE/2)
dataset.addSample(array)
active = network.activateOnDataset(dataset)[0]
if HTTPHandler.distance >= 10: #cm
HTTPHandler.left = 85 if active[1] > 0.9 else 0
HTTPHandler.right = 85 if active[0] > 0.9 else 0
else:
HTTPHandler.left = 0
HTTPHandler.right = 0
print "auto: " + str(HTTPHandler.left) + ":" + str(HTTPHandler.right)
#engine left
GPIO.output(Motor1A, GPIO.LOW)
GPIO.output(Motor1B, GPIO.HIGH)
e1.ChangeDutyCycle(HTTPHandler.left)
#engine right
GPIO.output(Motor2A, GPIO.LOW)
GPIO.output(Motor2B, GPIO.HIGH)
e2.ChangeDutyCycle(HTTPHandler.right)
steps_image = np.zeros((360, 640), np.uint8)
steps_image.fill(255)
steps_image[25+50:50+50+25, 50+25+25:80+25+25+50] = gray
steps_image[25+50+25:50+25+50, 50+25+85+25:25+80+80+5+25+50] = crop
steps_image[25+50+25:50+25+50, 50+25+25+160+5+5:80+80+80+5+5+25+25+50] = inverted
steps_image[25+50+25:50+25+50, 50+25+25+240+5+5+5:80+80+80+80+5+5+5+25+25+50] = bw
cv2.putText(steps_image, "net: '" + file + "', error: " + str(error), (100, 75), cv2.FONT_HERSHEY_PLAIN, 1.0, 0, 1)
cv2.putText(steps_image, "activate: " + str(active), (100, 200), cv2.FONT_HERSHEY_PLAIN, 1.0, 0, 1)
cv2.putText(steps_image, "obstacle: " + str(HTTPHandler.distance) + " cm", (100, 225), cv2.FONT_HERSHEY_PLAIN, 1.0, 0, 1)
cv2.putText(steps_image, "auto: " + str(HTTPHandler.left) + ", " + str(HTTPHandler.right), (100, 250), cv2.FONT_HERSHEY_PLAIN, 1.0, 0, 1)
result, buf = cv2.imencode('.jpg', steps_image, [int(cv2.IMWRITE_JPEG_QUALITY), 90])
assert result
self.wfile.write("--jpgboundary")
self.send_header('Content-type','image/jpeg')
self.send_header('Content-length', str(len(buf)))
self.end_headers()
self.wfile.write(bytearray(buf))
self.wfile.write('\r\n')
cap.release()
elif self.path.startswith("/auto:off"):
HTTPHandler.auto = False
elif self.path.startswith("/ping"):
if HTTPHandler.can_measure:
HTTPHandler.can_measure = False
distance = sonar_distance()
if distance >= 2.0 and distance <= 400.0:
HTTPHandler.distance = int(distance)
GPIO.output(LED, GPIO.HIGH if HTTPHandler.led else GPIO.LOW)
HTTPHandler.led ^= True
_, qual, _, _ = wifi.getStatistics()
self.send_response(200)
self.send_header('Content-type', 'text/html')
self.send_header("Access-Control-Allow-Origin", "*")
self.end_headers()
self.wfile.write(', '.join(str(x) for x in [qual.quality, qual.signallevel, qual.noiselevel, HTTPHandler.distance]))
self.wfile.close()
HTTPHandler.can_measure = True
elif self.path.startswith("/forward"):
HTTPHandler.left = max(0, int(self.path.split(':')[1]))
HTTPHandler.right = max(0, int(self.path.split(':')[2]))
print "forward: " + str(HTTPHandler.left) + ":" + str(HTTPHandler.right)
#engine left
GPIO.output(Motor1A, GPIO.LOW)
GPIO.output(Motor1B, GPIO.HIGH)
e1.ChangeDutyCycle(HTTPHandler.left)
#engine right
GPIO.output(Motor2A, GPIO.LOW)
GPIO.output(Motor2B, GPIO.HIGH)
e2.ChangeDutyCycle(HTTPHandler.right)
elif self.path.startswith("/reverse"):
HTTPHandler.left = max(0, int(self.path.split(':')[1]))
HTTPHandler.right = max(0, int(self.path.split(':')[2]))
print "reverse: " + str(HTTPHandler.left) + ":" + str(HTTPHandler.right)
#engine left
GPIO.output(Motor1A, GPIO.HIGH)
GPIO.output(Motor1B, GPIO.LOW)
e1.ChangeDutyCycle(HTTPHandler.left)
#engine right
GPIO.output(Motor2A, GPIO.HIGH)
GPIO.output(Motor2B, GPIO.LOW)
e2.ChangeDutyCycle(HTTPHandler.right)
elif self.path.startswith("/camera:on"):
status = self.path.split(':')[1]
HTTPHandler.camera = True
self.send_response(200)
self.send_header('Content-type','multipart/x-mixed-replace; boundary=--jpgboundary')
self.end_headers()
cap = cv2.VideoCapture(0)
cap.set(cv2.cv.CV_CAP_PROP_FRAME_WIDTH, 640)
cap.set(cv2.cv.CV_CAP_PROP_FRAME_HEIGHT, 360)
cap.set(cv2.cv.CV_CAP_PROP_FPS, 30)
time.sleep(1.0)
while cap.isOpened() and HTTPHandler.camera:
ret, frame = cap.read()
assert ret
result, buf = cv2.imencode('.jpg', frame, [int(cv2.IMWRITE_JPEG_QUALITY), 60])
assert result
self.wfile.write("--jpgboundary")
self.send_header('Content-type','image/jpeg')
self.send_header('Content-length', str(len(buf)))
self.end_headers()
self.wfile.write(bytearray(buf))
self.wfile.write('\r\n')
cap.release()
elif self.path.startswith("/camera:off"):
HTTPHandler.camera = False
elif self.path.startswith("/off"):
call("halt", shell=True)
from __future__ import print_function #!/usr/bin/env python """ Miniscule restricted Boltzmann machine usage example """ __author__ = 'Justin S Bayer, [email protected]' from pybrain.structure.networks.rbm import Rbm from pybrain.unsupervised.trainers.rbm import (RbmGibbsTrainerConfig, RbmBernoulliTrainer) from pybrain.datasets import UnsupervisedDataSet ds = UnsupervisedDataSet(6) ds.addSample([0, 1] * 3) ds.addSample([1, 0] * 3) cfg = RbmGibbsTrainerConfig() cfg.maxIter = 3 rbm = Rbm.fromDims(6, 1) trainer = RbmBernoulliTrainer(rbm, ds, cfg) print(rbm.params, rbm.biasParams) for _ in range(50): trainer.train() print(rbm.params, rbm.biasParams)
from __future__ import print_function #!/usr/bin/env python """ Miniscule restricted Boltzmann machine usage example """ __author__ = 'Justin S Bayer, [email protected]' from pybrain.structure.networks.rbm import Rbm from pybrain.unsupervised.trainers.rbm import (RbmGibbsTrainerConfig, RbmBernoulliTrainer) from pybrain.datasets import UnsupervisedDataSet ds = UnsupervisedDataSet(6) ds.addSample([0, 1] * 3) ds.addSample([1, 0] * 3) cfg = RbmGibbsTrainerConfig() cfg.maxIter = 3 rbm = Rbm.fromDims(6, 1) trainer = RbmBernoulliTrainer(rbm, ds, cfg) print(rbm.params, rbm.biasParams) for _ in range(50): trainer.train() print(rbm.params, rbm.biasParams)
while not results.empty():
finalTrainingSet.append(results.get())
for i in range(size - 1):
ds.addSample(finalTrainingSet[i], finalTrainingSet[i + 1])
net = buildNetwork(window,
window - 1,
window,
outclass=LinearLayer,
bias=True,
recurrent=True)
trainer = BackpropTrainer(net, ds)
trainer.trainEpochs(100)
ts = UnsupervisedDataSet(window, )
ts.addSample(finalTrainingSet[size - 1])
finalResult = net.activateOnDataset(ts)
t1 = time.time()
time_list.append(t1 - t0)
result_list.append(finalResult[0])
#for elem in finalResult[0]:
# print elem
print "time average: ", numpy.mean(time_list)
print "time std deviation", numpy.std(time_list)
arr = numpy.array(result_list)
maxepochs = 50
for i in range(0, maxepochs):
sys.stdout.write('\r' + str(i) + " / " + str(maxepochs))
aux = trainer.train()
fileObject = open('trainingData', 'w')
pickle.dump(net, fileObject)
fileObject.close()
else:
print "> Using a model from file"
fileObject = open('trainingData', 'r')
net = pickle.load(fileObject)
print "CLASSIFY"
ts = UnsupervisedDataSet(100, )
#input = map(int,'13 14 15 16 17 18 19 20 21 22 23 24 25 26 27 28 29 30 31 32 33'.split())
df = pd.read_csv('lastDay.csv', delimiter=',', index_col=None)
input = [int(x) for x in df.values]
print "Last day values: %s" % input
minimumLevel = min(input)
maximumLevel = max(input) - minimumLevel
input = [element - minimumLevel for element in input]
input = [element / float(maximumLevel * 2) for element in input]
# ts.addSample(input)
# verID = 175
# input = verificationSamples[verID][0]
from pybrain.structure import LinearLayer, SigmoidLayer, TanhLayer, SoftmaxLayer
from pybrain.structure import FullConnection
from pybrain.datasets import ClassificationDataSet, SupervisedDataSet, UnsupervisedDataSet
from pybrain.supervised.trainers import BackpropTrainer
from pybrain.unsupervised.trainers.deepbelief import DeepBeliefTrainer
from pybrain.supervised.trainers import Trainer
from pybrain.structure.networks.rbm import Rbm
from pybrain.unsupervised.trainers.rbm import (RbmGibbsTrainerConfig,
RbmBernoulliTrainer)
import csv
import numpy
# set up a basic feed forward network
net = FeedForwardNetwork()
ds = ClassificationDataSet(9,1,nb_classes=2, class_labels=['FRAUD', 'N'])
temp_ds = UnsupervisedDataSet(9)
# define 3 layers
inLayer = LinearLayer(9, "visible")
hiddenLayer = SigmoidLayer(16)
outLayer = LinearLayer(1)
# add layers to network
net.addInputModule(inLayer)
net.addModule(hiddenLayer)
net.addOutputModule(outLayer)
# define connections between layers
in_to_hidden = FullConnection(inLayer, hiddenLayer)
hidden_to_out = FullConnection(hiddenLayer, outLayer)
def _createUnsupervisedDataSet(X):
alldata = UnsupervisedDataSet(X.shape[1])
for i in X:
alldata.addSample(i)
return alldata
def _createUnsupervisedDataSet(X):
alldata = UnsupervisedDataSet(X.shape[1])
for i in X:
alldata.addSample(i)
return alldata