def create_data(self, inputs, targets): data = SequentialDataSet(inputs, targets) for i in xrange(0, len(self.dataframe) - 1): data.newSequence() ins = self.dataframe.ix[i].values target = self.dataframe.ix[i + 1].values[0] data.appendLinked(ins, target) self.data = data
def create_data(self, inputs, targets): data = SequentialDataSet(inputs, targets) for i in xrange(0, len(self.dataframe) - 1): data.newSequence() ins = self.dataframe.ix[i].values target = self.dataframe.ix[i + 1].values[0] data.appendLinked(ins, target) self.data = data
def create_data(dataframe, inputs, targets): data = SequentialDataSet(inputs, targets) for i in range(0, dataframe.shape[0] - 1): row = dataframe.iloc[i] data.newSequence() ins = row.values target = dataframe.iloc[i + 1].values[0] data.appendLinked(ins, target) return data
def rnnTrain(data): ds = SequentialDataSet(3,3) s = np.size(input) / 9 ds.newSequence() for idx1 in range(s): ds.appendLinked(data[idx1],(1,0,0)) ds.newSequence() for idx2 in range(s): ds.appendLinked(data[idx2+s],(0,1,0)) ds.newSequence() for idx3 in range(s): ds.appendLinked(data[idx3+s+s],(0,0,1)) net = buildNetwork(3, 8, 3, bias=True, recurrent=True, hiddenclass=LSTMLayer) trainer = BackpropTrainer(net,ds) trainer.trainEpochs(1000) return net
consecutive_days_pressure_dropping_by = 0 ds = SequentialDataSet(5, 1) for sample, next_sample in zip(training_features, cycle(training_features[1:])): ds.newSequence() yesterdays_sample = sample yesterdays_pressure = yesterdays_sample[3] todays_pressure = next_sample[3] raining = 0.0 if (todays_pressure > yesterdays_pressure): consecutive_days_pressure_dropping_by += (todays_pressure - yesterdays_pressure) else: raining = 1.0 consecutive_days_pressure_dropping_by = 0 yesterdays_sample.append(float(consecutive_days_pressure_dropping_by)) ds.appendLinked(yesterdays_sample, raining) net = buildNetwork(5, 10, 1, hiddenclass=LSTMLayer, outputbias=False, recurrent=True) #inLayer = LinearLayer(2) #hiddenLayer = LSTMLayer(5) #outLayer = LinearLayer(1) #from pybrain.structure import FullConnection #in_to_hidden = FullConnection(inLayer, hiddenLayer) #hidden_to_out = FullConnection(hiddenLayer, outLayer) trainer = RPropMinusTrainer(net, dataset=ds) train_errors = [] # save errors for plotting later EPOCHS_PER_CYCLE = 5 CYCLES = 50
class LanguageLearner: __OUTPUT = "Sample at {0} epochs (prompt=\"{1}\", length={2}): {3}" def __init__(self, trainingText, hiddenLayers, hiddenNodes): self.__initialized = False with open(trainingText) as f: self.raw = f.read() self.characters = list(self.raw) self.rawData = list(map(ord, self.characters)) print("Creating alphabet mapping...") self.mapping = [] for charCode in self.rawData: if charCode not in self.mapping: self.mapping.append(charCode) print("Mapping of " + str(len(self.mapping)) + " created.") print(str(self.mapping)) print("Converting data to mapping...") self.data = [] for charCode in self.rawData: self.data.append(self.mapping.index(charCode)) print("Done.") self.dataIn = self.data[:-1:] self.dataOut = self.data[1::] self.inputs = 1 self.hiddenLayers = hiddenLayers self.hiddenNodes = hiddenNodes self.outputs = 1 def initialize(self, verbose): print("Initializing language learner...") self.verbose = verbose # Create network and modules self.net = RecurrentNetwork() inp = LinearLayer(self.inputs, name="in") hiddenModules = [] for i in range(0, self.hiddenLayers): hiddenModules.append(LSTMLayer(self.hiddenNodes, name=("hidden-" + str(i + 1)))) outp = LinearLayer(self.outputs, name="out") # Add modules to the network with recurrence self.net.addOutputModule(outp) self.net.addInputModule(inp) for module in hiddenModules: self.net.addModule(module) # Create connections self.net.addConnection(FullConnection(self.net["in"], self.net["hidden-1"])) for i in range(0, len(hiddenModules) - 1): self.net.addConnection(FullConnection(self.net["hidden-" + str(i + 1)], self.net["hidden-" + str(i + 2)])) self.net.addRecurrentConnection(FullConnection(self.net["hidden-" + str(i + 1)], self.net["hidden-" + str(i + 1)])) self.net.addRecurrentConnection(FullConnection(self.net["hidden-" + str(len(hiddenModules))], self.net["hidden-" + str(len(hiddenModules))])) self.net.addConnection(FullConnection(self.net["hidden-" + str(len(hiddenModules))], self.net["out"])) self.net.sortModules() self.trainingSet = SequentialDataSet(self.inputs, self.outputs) for x, y in zip(self.dataIn, self.dataOut): self.trainingSet.newSequence() self.trainingSet.appendLinked([x], [y]) self.net.randomize() print("Neural network initialzed with structure:") print(self.net) self.trainer = BackpropTrainer(self.net, self.trainingSet, verbose=verbose) self.__initialized = True print("Successfully initialized network.") def train(self, epochs, frequency, prompt, length): if not self.__initialized: raise Exception("Attempted to train uninitialized LanguageLearner") print ("Beginning training for " + str(epochs) + " epochs...") if frequency >= 0: print(LanguageLearner.__OUTPUT.format(0, prompt, length, self.sample(prompt, length))) for i in range(1, epochs): print("Error at " + str(i) + " epochs: " + str(self.trainer.train())) if i % frequency == 0: print(LanguageLearner.__OUTPUT.format(i, prompt, length, self.sample(prompt, length))) print("Completed training.") def sample(self, prompt, length): self.net.reset() if prompt == None: prompt = chr(random.choice(self.mapping)) output = prompt charCode = ord(prompt) for i in range(0, length): sampledResult = self.net.activate([charCode]) charCode = int(round(sampledResult[0])) if charCode < 0 or charCode >= len(self.mapping): return output + "#TERMINATED_SAMPLE(reason: learner guessed invalid character)" output += chr(self.mapping[charCode]) return output
files = glob.glob('reel_nopickup/*.csv') #16th notes tunes = [] for filename in files: #tune with open(filename) as f: notes = map(int, map(str.strip, f.readlines()))[::2] #8th ntoes bitmasks = map(to_bitmask, notes) tunes.append(bitmasks) nested_tunes = map(lambda tune: [tune[x:min(len(tune) + 1, x+4)] for x in range(0, len(tune), 4)], tunes) for tune in nested_tunes: for (inp, target) in zip(tune, tune[1:]): chord_ds.newSequence() chord_ds.appendLinked(inp[0], target[0]) for tune in tunes: for beat in tunes: for (inp, target) in zip(beat, beat[1:]): melody_ds.newSequence() melody_ds.appendLinked(inp, target) chord_network.randomize() melody_network.randomize() chord_trainer = BackpropTrainer(chord_network, chord_ds, learningrate=.00001, momentum=.9) melody_trainer = BackpropTrainer(melody_network, melody_ds, learningrate=.00001, momentum=.9) import time print "training chords..." print "\n".join(map(str, chord_trainer.trainUntilConvergence()))
from pybrain.datasets import SequentialDataSet from pybrain.structure import SigmoidLayer from pybrain.structure import LSTMLayer import itertools import numpy as np data = np.loadtxt("datain.txt").T print data datain = data[:-1,:] dataout = data[1:,:] INPUTS = 5 OUTPUTS = 5 HIDDEN = 40 net = buildNetwork(INPUTS, HIDDEN, OUTPUTS, hiddenclass=LSTMLayer, outclass=SigmoidLayer, recurrent=True) ds = SequentialDataSet(INPUTS, OUTPUTS) for x,y in itertools.izip(datain,dataout): ds.newSequence() ds.appendLinked(tuple(x), tuple(y)) net.randomize() trainer = BackpropTrainer(net, ds) for _ in range(1000): print trainer.train()
class smokeDetect(AbstractVisionModule): """example vision class. Detects faces using the openCV face detector""" def __init__(self, host, port, update_frequency, source="webcam", verbose=False): self.logger = logging.getLogger("Borg.Brain.Vision.smokeDetect") super(smokeDetect, self).__init__(host, port) self.update_frequency = update_frequency self.__ticker = Ticker(frequency=update_frequency) self.verbose = verbose self.source = [source] self.vid_mem_reader = util.vidmemreader.VidMemReader(self.source) # set the type of objects that someone can detect self.set_known_objects(['smoke']) self.windowLocations = [] self.labels = [] self.data = [] self.frameAverage = 5 self.svm = None self.load_svm() def __del__(self): cv2.destroyAllWindows() def init_nn(self, datain, dataout): INPUTS = 5 OUTPUTS = 1 HIDDEN = 20 self.net = buildNetwork(INPUTS, HIDDEN, OUTPUTS, hiddenclass=LSTMLayer, outclass=SigmoidLayer, recurrent=True, bias=True) self.ds = SequentialDataSet(INPUTS, OUTPUTS) for x, y in itertools.izip(datain, dataout): self.ds.newSequence() self.ds.appendLinked(tuple(x), tuple(y)) self.net.randomize() trainer = BackpropTrainer(self.net, self.ds) for _ in range(1000): print trainer.train() def train(self): pass def stop(self): cv2.destroyAllWindows() def get_vid(self): if not hasattr(self, 'vid_idx'): self.vid_idx = 0 else: self.vid_idx += 1 if self.vid_idx >= len(vid_files): self.vid_idx = 0 print "NOW LOADING ", vid_files[self.vid_idx] return cv2.VideoCapture(vid_files[self.vid_idx]) def get_image_from_video(self, vid, size=(320, 240)): (result, image) = vid.read() if not result: #vid.release() vid = self.get_vid() (_, image) = vid.read() image = cv2.resize(image, size) return image def run(self): """start loop which gets a new image, then processes it""" #cv2.namedWindow("color_hist", cv2.cv.CV_WINDOW_NORMAL) im = None while im == None: im = self.vid_mem_reader.get_latest_image() if im == None: print "not receiving images yet..." time.sleep(0.2) vid = self.get_vid() idx = -1 while True: histogramList = [] imageList = [] colorList = [] imageOrigList = [] croppedList = [] timeBlock = time.time() heartBeat = time.time() idx = -1 while time.time() - timeBlock < 3: idx += 1 if idx > 300: break #Getting pictures for 5 seconds if time.time() - heartBeat > 2: self._AbstractVisionModule__send_heartbeat() heartBeat = time.time() #temp = self.vid_mem_reader.get_latest_image()[0] #image = np.asarray(temp[:,:]) #image = self.get_image_from_video(vid) (result, image) = vid.read() if not result: #vid.release() vid = self.get_vid() (_, image) = vid.read() image = cv2.resize(image, (320, 240)) if self.vid_idx == 0: w, h, _ = image.shape image = image[100:240, :, :] image = cv2.resize(image, (320, 240)) image_gs = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY) colorList.append(image) imageOrigList.append(image_gs) image_gs = cv2.blur(image_gs, (15, 15)) imageList.append(image_gs) #Calculating Histogram of Gray scale Image and Normalizing it hist = cv2.calcHist(images=[image_gs], channels=[0], mask=None, histSize=[32], ranges=[0, 256]) cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX) histogramList.append(hist) #Calculating Histogram of the Color Image curve = hist_curve(image, 128) if self.verbose: image_gs_rs = cv2.resize(image_gs, (613, 408)) cv2.imshow("Smoothed_Gray_Scale", image_gs_rs) cv2.moveWindow("Smoothed_Gray_Scale", 55, 0) cv2.waitKey(1) self._AbstractVisionModule__send_heartbeat() contourList = [] for i in range(len(imageList) - 1): if time.time() - heartBeat > 4: self._AbstractVisionModule__send_heartbeat() heartBeat = time.time() motion, equalized_motion, denoised_motion, denoised_mask = self.extractMotion( imageList[i], imageList[i + 1]) #Calculating Normalized Histogram of motion image motion_hist = hist_curve(equalized_motion, bin=64, mask=denoised_motion) y = cv2.resize(motion_hist, (320, 240)) #Cropped Grayscale image based on motion final = np.zeros(image_gs.shape, dtype=np.int8) final = cv2.add(final, imageOrigList[i], mask=denoised_mask, dtype=cv2.CV_8UC1) #Getting cropped color image finalColor = self.cropColor(colorList[i], denoised_mask) croppedList.append(finalColor) finalOrigColor = colorList[i] #Calculating Contours contours, hierarchy = cv2.findContours(denoised_mask, cv2.RETR_EXTERNAL, cv2.CHAIN_APPROX_SIMPLE) sanityList = [] #Accept frames having more than one contour if len(contours) > 1: for array in contours: temp_data = [] #Calculate contour structures area = cv2.contourArea(array) if area < 100: continue center, radius = cv2.minEnclosingCircle(array) circleArea = math.pi * math.pow(radius, 2) isConvex = cv2.isContourConvex(array) boundingRect = cv2.boundingRect(array) rectArea = boundingRect[2] * boundingRect[2] ellipseRect = cv2.fitEllipse(array) rectArea = ellipseRect[2] * ellipseRect[2] temp_data.extend([area, circleArea, rectArea]) temp_data.extend([radius, float(isConvex)]) xpos, ypos, w, h = boundingRect contour_hist = cv2.calcHist( images=[ equalized_motion[xpos:xpos + w, ypos:ypos + h] ], channels=[0], mask=denoised_motion[xpos:xpos + w, ypos:ypos + h], histSize=[32], ranges=[0, 256]) cv2.normalize(hist, hist, 0, 255, cv2.NORM_MINMAX) self.logger.debug("contour hist shape : %s", str(contour_hist.shape)) temp_data.extend( np.array(contour_hist).reshape(-1, ).tolist()) #Add deficiency information if not isConvex: temp_data.extend(self.convexDeficiency(array)) else: #Put zero for all the expected values temp_data.extend([0., 0., 0., 0., 0.]) #Ignore big areas and areas which look rectangular if area > 100 and rectArea / area > 2.5: sanityList.append(center) self.data.append(temp_data) #Automatic Labeling based on video if self.vid_idx == 0: self.labels.append(1.0) else: self.labels.append(0.0) test = np.array(temp_data) test = test.astype(np.float32) if self.svm.predict(test) == 1: tempol = np.copy(finalOrigColor) cv2.drawContours(tempol, array, -1, (255, 0, 0)) tempol_rs = cv2.resize(tempol, (614, 408)) cv2.imshow("Finall", tempol_rs) cv2.moveWindow("Finall", 1800 + 45, 460) cv2.waitKey(1) mean = np.mean(np.asarray(sanityList)) std = np.std(np.asarray(sanityList)) contourList.append((mean, std, contours)) if self.verbose: motion_rs = cv2.resize(motion, (613, 408)) cv2.normalize(motion_rs, motion_rs, 0, 255, cv2.NORM_MINMAX) cv2.imshow("motion", motion_rs) cv2.moveWindow("motion", 640 + 45, 0) temp_rs = cv2.resize(denoised_motion, (613, 408)) cv2.imshow("equap", temp_rs) cv2.moveWindow("equap", 1280 + 45, 0) finalColor_rs = cv2.resize(finalColor, (613, 408)) cv2.imshow("cropped-motion", finalColor_rs) cv2.moveWindow("cropped-motion", 0 + 45, 460) y_rs = cv2.resize(y, (613, 408)) cv2.imshow("cropped-motion-hist", y_rs) cv2.moveWindow("cropped-motion-hist", 640 + 45, 460) cv2.waitKey(1) #time.sleep(0.1) ''' DISCRETE FOURIER TRANSFORM dft_im = dft(denoised_motion) pyrdown = dft_im for i in range(4): pyrdown = cv2.pyrDown(pyrdown) w,h = dft_im.shape pyrdown = cv2.resize(pyrdown, (h,w)) cv2.imshow("pyrdown", pyrdown) ''' #Scoring detections in frame sequences Score = 0 minStd = 100 for mean, std, contours in contourList: #print 'Standard deviation of contours', std if std > 0 and std < 50: if std < minStd: minStd = std bestContour = contours minMean = mean Score += 1 elif std > 50: Score -= 30 elif std > 39: Score -= 1 else: #Score -= 1 pass if Score > 0: self.add_property('name', 'smoke') self.add_property('center', minMean) self.add_property('image_path', '/dev/shm/smoke.png') self.store_observation() tempo = np.copy(finalOrigColor) cv2.drawContours(tempo, contours, -1, (255, 0, 0)) cv2.imwrite('/dev/shm/smoke.png', tempo) tempo_rs = cv2.resize(tempo, (614, 408)) cv2.imshow("Final", tempo_rs) cv2.moveWindow("Final", 1280 + 45, 460) cv2.waitKey(1) self.update() self.save(self.data, self.labels) self.update() def save(self, data, labels): data = np.array(data) labels = np.array(labels) self.logger.info("Data size is %s", str(data.shape)) self.logger.info("label size is %s", str(labels.shape)) np.save("/dev/shm/data", data) np.save("/dev/shm/label", labels) np.savetxt("/dev/shm/data.txt", data) np.savetxt("/dev/shm/label.txt", labels) def convexDeficiency(self, contour): ''' Calculates the convex deficiency and returns a list of: 1- mean and standard deviation of deficiency depth, and length of the starting/ending point of the deficiency 2- Number of deficiencies 3- perimiter of each defeciency @contour The contour of the image ''' convex_hull = cv2.convexHull(contour, returnPoints=False) convex_defects = cv2.convexityDefects(contour, convex_hull) self.logger.debug("convex_defects is: %s", str(convex_defects)) defect_number = len(convex_defects) distance_list = [] depth_list = [] premeter_list = [] if defect_number: for defect in convex_defects: self.logger.debug("current defect is: %s", str(defect)) start_idx, end_idx, farthest_pt, pt_depth, = defect[0] self.logger.debug("start/end contour points are %s and %s ", str(contour[start_idx][0]), str(contour[end_idx][0])) distance = math.pow( (contour[start_idx][0][0] - contour[end_idx][0][0]), 2) + math.pow( (contour[start_idx][0][1] - contour[end_idx][0][1]), 2) distance_list.append(distance) depth_list.append(pt_depth) mean_distance = np.mean(np.asarray(distance_list)) std_distance = np.std(np.asarray(distance_list)) mean_depth = np.mean(np.asarray(depth_list)) std_depth = np.std(np.asarray(depth_list)) return [ mean_distance, std_distance, mean_depth, std_depth, defect_number ] def cropColor(self, image, mask): #Crop a color image based on a mask ch1 = np.zeros(mask.shape, dtype=np.int8) ch2 = np.zeros(mask.shape, dtype=np.int8) ch3 = np.zeros(mask.shape, dtype=np.int8) c1 = np.copy(image[:, :, 0]) c2 = np.copy(image[:, :, 1]) c3 = np.copy(image[:, :, 2]) ch1 = cv2.add(ch1, c1, mask=mask, dtype=cv2.CV_8UC1) ch2 = cv2.add(ch2, c2, mask=mask, dtype=cv2.CV_8UC1) ch3 = cv2.add(ch3, c3, mask=mask, dtype=cv2.CV_8UC1) finalColor = cv2.merge((ch1, ch2, ch3)) return finalColor def extractMotion(self, image1, image2): #Background Subtraction motion = cv2.absdiff(image1, image2) #Histogram Equalization of the motion image #TODO: Test without equalization and only normalization #eqaulized_motion = cv2.equalizeHist(motion) #eqaulized_motion = np.zeros(motion.shape) eqaulized_motion = cv2.normalize(src=motion, alpha=0, beta=255, norm_type=cv2.NORM_MINMAX) #Removing Noise by opening and closing the image se = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (8, 8)) temp = cv2.morphologyEx(eqaulized_motion, cv2.MORPH_OPEN, se) se = cv2.getStructuringElement(cv2.MORPH_ELLIPSE, (3, 3)) temp = cv2.morphologyEx(temp, cv2.MORPH_CLOSE, se) denoised_motion = temp #Making a mask from the closed/opened image denoised_mask = np.zeros(image1.shape, dtype=np.uint8) denoised_mask[denoised_motion > 70] = 1 return motion, eqaulized_motion, denoised_motion, denoised_mask def deltaHistogram(self, histogramList, image_gs, hist): ''' This function doesn't work, it should calculate delta histograms ''' for i in range(len(histogramList) - 1): deltaHist = np.absolute( np.subtract(histogramList[i], histogramList[i + 1])) deltaHist /= np.sum(deltaHist) nans = np.isnan(deltaHist) deltaHist[nans] = 0 deltaImage = np.zeros(image_gs.shape) binStep = image_gs.shape[1] / deltaHist.shape[0] print deltaHist for i in range(len(hist) - 1): pt1 = (binStep * i, image_gs.shape[0] - (deltaHist[i] * image_gs.shape[0])) pt2 = (binStep * i + 1, image_gs.shape[0] - (deltaHist[i + 1] * image_gs.shape[0])) color = 255 cv2.line(deltaImage, pt1, pt2, color, 2, 8, 0) if self.verbose: cv2.imshow("delta_hist", deltaImage) cv2.moveWindow("delta_hist", 1600, 0) cv2.waitKey(10) time.sleep(0.1) def archive(self, image): #Adds all types of image conversion to the specified list pass def load_svm(self): self.svm = cv2.SVM() try: self.svm.load("/dev/shm/svm.model") except: self.svm = None
#create the training set #takes word vector -> simple enumerated vector of words from vocab print("Creating the DataSet") dataSet = SequentialDataSet(inputLayerSize,outputLayerSize) dataSet.newSequence() for sample,next in zip(blob[0:sampleSize],cycle(blob[1:sampleSize+1])): try: if sample == ' ': dataSet.newSequence() #print("creating Sample of:",sample,next) actual = [0.0 for x in range(inputLayerSize)] actual[wordToNum[sample]] = 1.0 expected = [0.0 for x in range(inputLayerSize)] expected[wordToNum[next]] = 1.0 dataSet.appendLinked(actual,expected) except KeyError as e: print("Missing: ",str(e)) #print("Something went wrong for:",sample,next) print("Data Set Created: ",dataSet.getNumSequences()) if False: #os.path.exists(networkSaveFile): print("Loading Neural Network") networkSave = codecs.open(networkSaveFile,'r','utf-8') net = pickle.load(networkSave) networkSave.close() else: #create the network print("Creating Network: ",inputLayerSize,"->",hiddenLayerSize,"->",outputLayerSize) net = buildNetwork(inputLayerSize,hiddenLayerSize,outputLayerSize,hiddenclass=LSTMLayer,outputbias=False,recurrent=True)
class NET(): def __init__(self, inputsize, outputsize, hiden=[1]): self.inputsize = inputsize self.outputsize = outputsize self.hiden = hiden self.err = 1 self.old_err = 1 #print type(self.hiden) if type(self.hiden) == str: #print "type str" self.hiden = self.hiden[1:-1] b = self.hiden.split(", ") c = [] for i in b: c.append(int(i)) self.hiden = c[:] b = [] b.append(self.inputsize) b += self.hiden b.append(self.outputsize) #print b#"%s, %s, %s, hiddenclass=TanhLayer"%(self.inputsize, self.hiden, self.outputsize) self.net = FeedForwardNetwork() self.inputlayer = LinearLayer(self.inputsize, "Input") self.net.addInputModule(self.inputlayer) self.outputlayer = LinearLayer(self.outputsize, "Output") self.net.addOutputModule(self.outputlayer) self.hidenlayers = [] for i in xrange(len(self.hiden)): self.hidenlayers.append(SigmoidLayer(self.hiden[i], "hiden%s" % i)) self.net.addModule(self.hidenlayers[-1]) self.net.addConnection( FullConnection(self.inputlayer, self.outputlayer)) for i in xrange(len(self.hidenlayers)): self.net.addConnection( FullConnection(self.inputlayer, self.hidenlayers[i])) self.net.addConnection( FullConnection(self.hidenlayers[i], self.outputlayer)) for i in xrange(len(self.hidenlayers)): for j in xrange(i + 1, len(self.hidenlayers)): self.net.addConnection( FullConnection(self.hidenlayers[i], self.hidenlayers[j])) #self.print_conections(self.net) self.net.sortModules() self.ds = SupervisedDataSet(self.inputsize, self.outputsize) def Update(self, hiden, h): self.net = FeedForwardNetwork() self.inputlayer = LinearLayer(self.inputsize, "Input") self.net.addInputModule(self.inputlayer) self.outputlayer = LinearLayer(self.outputsize, "Output") self.net.addOutputModule(self.outputlayer) self.hidenlayers = [] for i in xrange(len(hiden)): self.hidenlayers.append(SigmoidLayer(hiden[i], "hiden%s" % i)) self.net.addModule(self.hidenlayers[-1]) self.net.addConnection( FullConnection(self.inputlayer, self.outputlayer)) for i in xrange(len(self.hidenlayers)): self.net.addConnection( FullConnection(self.inputlayer, self.hidenlayers[i])) self.net.addConnection( FullConnection(self.hidenlayers[i], self.outputlayer)) for i in xrange(len(self.hidenlayers)): for j in xrange(i + 1, len(self.hidenlayers)): if i < h: self.net.addConnection( FullConnection(self.hidenlayers[i], self.hidenlayers[j])) elif i == h: self.net.addConnection( FullConnection(self.hidenlayers[i], self.hidenlayers[j], inSliceTo=hiden[i] - 1)) else: self.net.addConnection( FullConnection(self.hidenlayers[i], self.hidenlayers[j])) #self.print_conections(self.net) self.net.sortModules() self.hiden = hiden def print_conections(self, n): print("BEGIN") for mod in n.modules: print(mod) for conn in n.connections[mod]: print(conn) for cc in range(len(conn.params)): print(conn.whichBuffers(cc), conn.params[cc]) print("END") def AddData(self, datainput, dataoutput): if len(dataoutput) != len(datainput): print("Not equals data", len(dataoutput), len(datainput)) return 1 self.ds = SupervisedDataSet(self.inputsize, self.outputsize) for i in xrange(len(dataoutput)): self.ds.appendLinked(datainput[i], dataoutput[i]) self.trainer = RPropMinusTrainer(self.net, dataset=self.ds, learningrate=0.1) return 0 def AddDataSequential(self, data): self.ds = SequentialDataSet(self.inputsize, self.outputsize) for i in xrange(len(data) - 1, 0, -1): t = data[i] k = i - 1 while k > -1: self.ds.appendLinked(data[k], t) k -= 1 self.ds.newSequence() """print self.ds.getNumSequences() for i in range(self.ds.getNumSequences()): for input, target in self.ds.getSequenceIterator(i): print i, TransToIntList_45(input), TransToIntList_45(target)""" self.trainer = RPropMinusTrainer(self.net, dataset=self.ds, learningrate=0.1) return 0 def TrainNet(self, epoch, error): if epoch <= 5: epoch = 5 i = 0 count = 0 while i < epoch: if error == self.err: break self.err = self.trainer.train() if self.err == self.old_err: count += 1 else: count = 0 if count == 3: self.err = self.old_err return (self.err, 1) self.old_err = self.err i += 1 #self.SaveNet('%s %s_%s_%s.work'%(self.err, self.inputsize, self.hiden, self.outputsize)) return [self.err, 0] def TrainNetOnce(self): self.err = self.trainer.train() return self.err def SaveNet(self, filename=None): if filename == None: NetworkWriter.writeToFile( self.net, '%s %s_%s_%s.xml' % (self.err, self.inputsize, self.hiden, self.outputsize)) else: NetworkWriter.writeToFile(self.net, filename) def LoadNet(self, fname): self.net = NetworkReader.readFrom(fname) tree = ET.parse(fname) x = tree.getroot() l = [] for modules in x.findall('Network/Modules/SigmoidLayer/dim'): l.append(int(modules.get("val"))) self.hiden = l[:] self.inputsize = self.net.indim self.outputsize = self.net.outdim def TestNet(self, inp): if len(inp) != self.inputsize: return 0 return self.net.activate(inp[:]) def UpdateWeights(self, f1, f2=None): n = NetworkReader.readFrom(f1) if f2 != None: n2 = NetworkReader.readFrom(f2) def DictParams(n): l1 = [] for mod in n.modules: l = [] for conn in n.connections[mod]: if conn.paramdim > 0: l.append([conn.outmod.name, conn.params]) d = dict(l) l1.append([mod.name, d]) d1 = dict(l1) return d1 d1 = DictParams(n) if f2 != None: d2 = DictParams(n2) d3 = DictParams(self.net) params = np.array([]) if f2 != None: for i in d2: for j in d2[i]: b = d3[i][j][:] b[:d2[i][j].size] = d2[i][j][:] d3[i].update({j: b}) for i in d1: for j in d1[i]: b = d3[i][j][:] b[:d1[i][j].size] = d1[i][j][:] d3[i].update({j: b}) for i in d3["Input"]: params = np.hstack((params, d3["Input"][i])) for i in xrange(len(self.hiden)): for j in d3["hiden%s" % i]: params = np.hstack((params, d3["hiden%s" % i][j])) self.net._setParameters(params)
def evalSensor(sensorIndex, featureSpaceIndices): #reset data structure allByTime = {} f = open(fileName, 'r') headers = f.readline().split() for line in f: splited = line.split() timeStamp = int(splited[0]) allByTime[timeStamp] = {} f.close() allByJoint = {} for inputIndices in featureSpaceIndices: allByJoint[inputIndices] = {} clfs = {} grades = {} for inputIndices in featureSpaceIndices: allByTime, allByJoint = angleExtraction.prepareAnglesFromInput(fileName, inputIndices, sensorIndex, True, allByTime, allByJoint) #normalizing allByJoint timeSet = Set([]) for inputIndices in featureSpaceIndices: vec = [] for timeStamp in allByTime.keys(): if(timeStamp in allByJoint[inputIndices].keys()): timeSet.add(timeStamp) x = allByJoint[inputIndices][timeStamp] vec.append(x) if(len(vec) > 0): vec = angleExtraction.normelizeVector(vec) i=0 for timeStamp in allByTime.keys(): if(timeStamp in allByJoint[inputIndices].keys()): allByJoint[inputIndices][timeStamp] = vec[i] i = i + 1 #time set to list, output dict to list time = [] for timeStamp in timeSet: time.append(timeStamp) time.sort() allOutput = [] tmpTime = [] #clean zeros, create time ordered output vector for timeStamp in time: out = allByTime[timeStamp]['output'] if(out != 0 and len(allByTime[timeStamp]) == featureNum + 1): tmpTime.append(timeStamp) allOutput.append(out) time = tmpTime #normalize allOutput allOutput = normalByPercentile(allOutput) #create a net hiddenSize = (featureNum + 2)/2 net = buildNetwork(featureNum, hiddenSize, 1, hiddenclass=LSTMLayer, outclass=SigmoidLayer, recurrent=True, bias=True) #build dataset ds = SequentialDataSet(featureNum, 1) i=0 lastTimeStamp = time[0] for timeStamp in time: if(len(allByTime[timeStamp]) == featureNum+1):#it is a full vector if(timeStamp - lastTimeStamp > 100): ds.newSequence() sample = [] for inputIndices in featureSpaceIndices: sample.append(allByTime[timeStamp][inputIndices]) ds.appendLinked(sample, allOutput[i]) i = i + 1 lastTimeStamp = timeStamp #train net.randomize() tstdata, trndata = ds.splitWithProportion( 0.25 ) trainer = BackpropTrainer(net, trndata) print len(ds) min = 100 trainNum = 100 bestTrainer = None for i in range(trainNum): res = trainer.train() if(res < min): min = res bestTrainer = trainer net.randomize() print min """ res = 100 while(res > min): net.randomize() res = trainer.train() """ trainer = bestTrainer for i in range(trainNum): res = trainer.train() if(i % (trainNum/10) == 0): print res print 'trndata.evaluateModuleMSE ' + str(trndata.evaluateModuleMSE(net)) print 'tstdata.evaluateModuleMSE ' + str(tstdata.evaluateModuleMSE(net)) #print net.activateOnDataset(tstdata) hits = 0.0 total = 0.0 #res = net.activate(tstdata) for i in range(trndata.getNumSequences()): for input, target in trndata.getSequenceIterator(i): res = net.activate(input) total += 1 if(res[0]*target[0] > 0): hits+=1 grade = hits / total print 'grade ' + str(grade) print 'total ' + str(total)
def train_network(options_file_location,training_data_location,output_location): training_file_handle = open(training_data_location,"r") training_reader = csv.reader(training_file_handle) stdout_file = output_location+'training_console_output.txt' stderr_file = output_location+'training_console_errput.txt' sys.stdout = open(stdout_file,"w") sys.stderr = open(stderr_file,"w") options_file_handle = open(options_file_location,'r') options_dictionary = {} for option in options_file_handle.readlines(): key,val = option.split('=') print key print val options_dictionary[key] = val; num_predictors = int(options_dictionary['num_predictors']) num_outputs = int(options_dictionary['num_outputs']) num_training_epochs = int(options_dictionary['num_training_epochs']) num_hidden_neurons = int(options_dictionary['num_hidden_neurons']) compound_prediction = int(options_dictionary['compound_prediction']) #teacher_forced_transient = int(options_dictionary['teacher_forced_transient']) teacher_forced_transient = 0 hidden_neuron_type_str = options_dictionary['hidden_neuron_type'] output_neuron_type_str = options_dictionary['output_neuron_type'] hidden_layer_type,output_layer_type = net_topol.get_layer_types(options_dictionary) training_dataset = SequentialDataSet(num_predictors, num_outputs) print 'reach' previous_sequence_number = 1 #read data into dataset objects print 'reading in training data...' for row in training_reader: #convert list of strings to list of floats list = [float(s) for s in row] #split input line predictors = list[0:num_predictors] outputs = list[num_predictors+1:num_predictors+1+num_outputs] #convert from python list to numpy array predictors = np.array(predictors) outputs = np.array(outputs) sequence_number = math.trunc(list[num_predictors]) if not sequence_number==previous_sequence_number: # print sequence_number # print previous_sequence_number training_dataset.newSequence() previous_sequence_number = sequence_number #add to dataset training_dataset.appendLinked(predictors, outputs) network = shortcuts.buildNetwork(num_predictors, num_hidden_neurons, num_outputs, hiddenclass=LSTMLayer, outclass=LinearLayer) network.sortModules(); trainer = RPropMinusTrainer(module=network, dataset=training_dataset) for i in range(num_training_epochs): print 'Starting training epoch: '+str(i) trainer.trainEpochs(1) sys.stdout.flush() #brittle network_file_path = output_location+'trained_network.xml' NetworkWriter.writeToFile(network, network_file_path) done_file_handle = open(output_location+'training_done.txt',"w") done_file_handle.write('%s' % 'done!') done_file_handle.close()
def network_predict(options_file_location,prediction_data_location,output_location,network_location): prediction_data_file_handle = open(prediction_data_location,"r") prediction_data_reader = csv.reader(prediction_data_file_handle) stdout_file = output_location+'prediction_console_output.txt' stderr_file = output_location+'prediction_console_errput.txt' sys.stdout = open(stdout_file,"w") sys.stderr = open(stderr_file,"w") prediction_results_file_location = output_location+'prediction_results.csv' prediction_results_file_handle = open(prediction_results_file_location,"w") options_file_handle = open(options_file_location,'r') options_dictionary = {} for option in options_file_handle.readlines(): key,val = option.split('=') print key print val options_dictionary[key] = val; num_predictors = int(options_dictionary['num_predictors']) num_outputs = int(options_dictionary['num_outputs']) num_training_epochs = int(options_dictionary['num_training_epochs']) num_hidden_neurons = int(options_dictionary['num_hidden_neurons']) compound_prediction = int(options_dictionary['compound_prediction']) # teacher_forced_transient = int(options_dictionary['teacher_forced_transient']) teacher_forced_transient = 0 prediction_dataset = SequentialDataSet(num_predictors, num_outputs) previous_sequence_number = 1 print 'reading in prediction data...' for row in prediction_data_reader: #convert list of strings to list of floats list = [float(s) for s in row] #split input line predictors = list[0:num_predictors] #+1 is to skip over the sequence column outputs = list[num_predictors+1:num_predictors+1+num_outputs] #convert from python list to numpy array predictors = np.array(predictors) outputs = np.array(outputs) sequence_number = math.trunc(list[num_predictors]) if not sequence_number==previous_sequence_number: # print 'sequence_number '+str(sequence_number) # print 'previous_sequence_number '+str(previous_sequence_number) # frame_number_debug = 0; prediction_dataset.newSequence() previous_sequence_number = sequence_number #add to dataset prediction_dataset.appendLinked(predictors, outputs) network = NetworkReader.readFrom(network_location) if compound_prediction==0: results, targets, mse = evalRNN.evalRNNOnSeqDataset(network,prediction_dataset) elif compound_prediction==1: results, targets, mse = evalRNN.compoundEvalRNNOnSeqDataset(network,prediction_dataset, teacher_forced_transient) results_length, results_width = results.shape np.savetxt(prediction_results_file_location,results,delimiter=" ",fmt='%9.9f') done_file_handle = open(output_location+'predicting_done.txt',"w") done_file_handle.write('%s' % 'done!') done_file_handle.close()