Example #1
0
    def run(self):
        count = 0
        previous = {} # Used to keep track of previous predictions
        self.parent.sendPacket.value = True
        q = multiQueue()
        last = bciComms.discardTill(self.parent.pipeReceive, self.parent.endPacketRegex, self.parent.headerRegex)
        last = int(last)

        collecting = True

        while True:
            count += 1
            last = bciComms.collectData(self.parent.pipeReceive, self.period, self.parent.headerRegex,
                    self.parent.endPacketRegex, q, last)
            data = q.get()

            # Takes the raw data and decomposes it into a dict of the corresponding terms
            processed = bciComms.rawToDict(data)
            classWith = self.parent.trainingDataFormater.formatFrequencies(processed["Raw FFT"])

            prediction = None
            accuracy = None

            try:
                prediction, accuracy = self.classifier.predict(classWith)
            except Exception:
                continue

            # Changed what predict returns
            accuracy = accuracy[prediction]

            if count * self.period < self.timeout and collecting:
                if not previous.has_key(prediction):
                    previous[prediction] = 0.0

                previous[prediction] += accuracy

            elif collecting:
                likely = sorted(previous, key=previous.get, reverse=True)[0]

                if previous[likely] < count * self.threshold:
                    self.coms.txt.emit("None")
                else:
                    self.coms.txt.emit(likely)

                previous = {}
                count = 0
                collecting = False
            elif count * self.period < self.timeout and not collecting:
                self.coms.txt.emit("Robot Moving")
            elif not collecting:
                collecting = True
                count = 0
                self.coms.txt.emit("")
Example #2
0
    def run(self):
        self.parent.sendPacket.value = True
        q = multiQueue()
        last = bciComms.discardTill(self.parent.pipeReceive, self.parent.endPacketRegex, self.parent.headerRegex)
        last = int(last)

        count = 0
        priors = self.classifier.priors

        while True:
            newQuestion = self.runner.new

            last = bciComms.collectData(self.parent.pipeReceive, self.period, self.parent.headerRegex,
                    self.parent.endPacketRegex, q, last)
            data = q.get()

            # A new question has not arrived
            if not newQuestion:
                continue

            count += 1
            # Want to give the user a second to read the text and ignore the brain signals
            if count * self.period < 1.0: continue

            # Takes the raw data and decomposes it into a dict of the corresponding terms
            processed = bciComms.rawToDict(data)
            classWith = self.parent.trainingDataFormater.formatFrequencies(processed["Raw FFT"])
            logging.info(processed["Raw FFT"])
            

            probs = None
            try:
                _, probs = self.classifier.predict(classWith)
            except Exception:
                continue

            # Updating priors
            for k,v in probs.iteritems():
                priors[k] *= v

            # Renormalizing
            s = sum(priors.values())
            priors = {k: priors[k] / s for k in priors}

            print count
            
            # Emit prediction if time has exceeded 6 seconds or hit threshold
            highest = max(priors, key=lambda k: priors[k])
            if count * self.period >= 6.0 or priors[highest] >= self.threshold:
                self.coms.txt.emit(highest)
                self.runner.new = False
                count = 0
                priors = self.classifier.priors
Example #3
0
    def trainingScreen(self):
        """ Displays a training screen that displays arrows to different frequency lights
        and records the data within each of these periods. Saves this data in a JSON file """
        window = drawWidget(self)

        # Creates a random ordering of the trials
        channels = [str(i) for i in self.settings["channels"].values()
                    if not i == "None"]
        trials = self.settings["numTrials"]
        time = self.settings["trialLength"]
        bciData = {}

        for t in range(trials):
            print (t+1), "/", trials
            random.shuffle(channels)
            bciData[t] = {}

            for c in channels:
                # Setup
                param = self.settings["freqMap"][c]
                q = multiQueue()

                window.drawCrossTimed(0.4, 3, True)

                # Starting storing packets sent through the pipe when a
                # batch arriving from BCI2000 completes. This is signalled
                # by the last Signal(X,Y) received.
                self.sendPacket.value = True
                lastStamp = bciComms.discardTill(self.pipeReceive, self.endPacketRegex, self.headerRegex)
                lastStamp = int(lastStamp)

                collectProc = Process(target=bciComms.collectData,
                        args=(self.pipeReceive, time, self.headerRegex, self.endPacketRegex, q, lastStamp))
                collectProc.start()

                window.drawArrowTimed(param["x"], param["y"], 200, param["theta"], time, True)

                bciData[t][c] = q.get()

                self.writeFile(bciData[t][c], t, c)
                self.sendPacket.value = False

        # Write the training data to a file, and get the formated training data
        fName, _ = QtGui.QFileDialog.getSaveFileName(self, "Save the test data", "", "JSON (*.json)", "JSON (*.json)")

        # User didn't pick a filename, ask them again and if repeated return
        if fName == "":
            self.showMessage("You didn't select a file! Try again otherwise data is lost")
            fName, _ = QtGui.QFileDialog.getSaveFileName(self, "Save the test data", "", "JSON (*.json)", "JSON (*.json)")

            if fName == "":
                window.close()
                return

        formatedJson = None

        # List of frequencies collected on
        freqList = [int(x.split(" ")[0]) for x in channels]
        freqList.sort()

        with open(fName, "w") as f:
            formatedJson = bciComms.processTrainData(bciData, freqList, f)

        # Saves the training data to the instance field, trains the classifier and transitions to run screen
        self.trainingDataFormater = FormatJson(formatedJson, loadDict=True)
        if self.trainClassifier():
            self.transitionToRun()

        window.close()