def getphase(fname, driveN, x, Fs): xdat = np.append(x, np.zeros(int(Fs / fdrive))) corr2 = np.correlate(xdat, driveN) maxv = np.armax(corr2) return maxv
def log_ushiriki(self, eval_policy): """ Evaluate on Unshiriki env """ self.best_rews = [] candidates = [] for step in range(self.params['eval_ep_lens']): ob = self.env.reset() policy = {} for i in range(self.env.policyDimension): policy[step + i] = eval_policy.get_action(ob)[0] candidates.append(policy) rew = self.env.evaluatePolicy(candidates) best_idx = np.armax(rew) best_policy = candidates[best_idx] best_rew = rew[best_idx] self.best_rews.append(best_rew)
def ImageProcess(self, image, showLabels=True, showBoundingBox=True, showFPS=False): #Init YOLO if needed if (self.net is None): self.InitYoloV3() (H, W) = image.shape[:2] frame = image.copy() blob = cv2.dnn.blob.blobFromImage(frame, 1 / 255.0, (416, 416), swapRB=True, crop=False) self.net.setInput(blob) if (showFPS == True): starttime = time.time() layerOutputs = self.net.foward(self.ln) if (showFPS == True): stoptime = time.time() print("FPS: {:.4f}".format((stoptime - starttime))) confidences = [] outline = [] class_ids = [] for output in layerOutputs: for detection in output: scores = detection[5:] maxi_class = np.armax(scores) confidence = scores[maxi_class] if confidence > self.confidence: box = detection[0:4] * np.array([W, H, W, H]) (centerX, centerY, width, height) = box.astype("int") x = int(centerX - (width / 2)) y = int(centerY - (height / 2)) outline.append([x, y, int(width), int(height)]) class_ids.append(maxi_class) confidences.append(float(confidence)) box_line = cv2.dnn.NMSBoxes(outline, confidences, 0.5, 0.3) if len(box_line) > 0: flat_box = box_line.flatten() pairs = [] for i in flat_box: (x, y) = (outline[i][0], outline[i][1]) (w, h) = (outline[i][2], outline[i][3]) x_plus_w = round(x + w) y_plus_h = round(y + h) label = str(self.LABELS[class_ids[i]]) color = self.COLORS[class_ids[i]] if (showBoundingBox == True): cv2.rectangle(frame, (x, y), (x_plus_w, y_plus_h), color, 2) if (showLabels == True): cv2.putText(frame, label, (x - 10, y - 10), cv2.FONT_HERSHEY_SIMPLEX, 0.5, color) return frame
def train_neural_network(imput_image): predict_action = convolutional_neural_network(input_image) argmax = tf.placeholder("float", [None, output]) gt = tf.placeholder("float", [None]) action = tf.reduce_sum(tf.multiply(predict_action, argmax), reduction_indices=1) cost = tf.reduce_mean(tf.square(action - gt)) optimizer = tf.train.AdadeltaOptimizer(1e-6).minimize(cost) game = Game() D = deque() _, image = game.run(MOVE_STAY) image = cv2.cvtColor(cv2.resize(image, (100, 80)), cv2.COLOR_BGR2GRAY) ret, image = cv2.threshold(image, 1, 255, cv2.THRESH_BINARY) input_image_data = np.stack((image, image, image, image), axis=2) with tf.Session() as sess: sess.run(tf.initialize_all_variables()) saver = tf.train.Saver() n = 0 epsilon = INIT_ESPTION while True: action_t = predict_action.eval(feed_dict={input_image: [input_image_data]})[0] argmax_t = np.zeros([output], dtype=np.int) if (random.random() <= INIT_ESPTION): maxIndex = random.randrange(output) else: maxIndex = np.armax(action_t) argmax_t[maxIndex] = 1 if epsilon > FINAL_ESPTION: epsilon -= (INIT_ESPTION - FINAL_ESPTION) / EXPLORE reward, image = game.run(list(argmax_t)) image = cv2.cvtColor(cv2.resize(image, (100, 80)), cv2.COLOR_BGR2GRAY) ret, image = cv2.threshold(image, 1, 255, cv2.THRESH_BINARY) image = np.reshape(image, (80, 100, 1)) input_image_datal = np.append(image, input_image_data[:, :, 0:3], axis=2) D.append((input_image_data, argmax_t, reward, input_image_datal)) if len(D) > REPLAY_MEMORY: D.popleft() if n > OBSERVE: minibatch = random.sample(D, BATCH) input_image_data_batch = [d[0] for d in minibatch] argmax_batch = [d[1] for d in minibatch] reward_batch = [d[2] for d in minibatch] input_image_data1_batch = [d[3] for d in minibatch] gt_batch = [] out_batch = predict_action.eval(feed_dict={input_image: input_image_data1_batch}) for i in range(0, len(minibatch)): gt_batch.append(reward_batch[i] + LEARN_RATE * np.max(out_batch[i])) optimizer.run(feed_dict={gt: gt_batch, argmax: argmax_batch, input_image: input_image_data_batch}) input_image_data = input_image_datal n = n + 1 if n % 10000 == 0: # saver.save(sess, 'C:\\Users\\hasee\\game.cpk', global_step=n) print(n, "epsilon:", epsilon, " ", "action:", maxIndex, " ", "reward: ", reward)
def get_decision_indices(self,points): (N,d) = points.shape F = self.fn.evaluate(points) (n,A) = F.shape assert(N == n) return np.armax(F,axis=1)
def inferObjectWithRandomMovements( self, # noqa: C901, N802 objectDescription, # noqa: N803 objectImage, # noqa: N803 all_class_targets, cellsPerColumn, # noqa: N803 trial_iter, fixed_touch_sequence=None, numSensations=None, randomLocation=False): """ Attempt to recognize the specified object with the network. Moves the sensor over the object until the object is recognized. @param objectDescription (dict) For example: {"name": "Object 1", "features": [{"top": 0, "left": 0, "width": 10, "height": 10, "name": "A"}, {"top": 0, "left": 10, "width": 10, "height": 10, "name": "B"}]} @objectImage (Numpy array) The current object's image @all_class_targets (list) Target representations for each class @cellsPerColumn (int) @trial_iter (int) @param numSensations (int or None) Set this to run the network for a fixed number of sensations. Otherwise this method will run until the object is recognized or until maxTraversals is reached. @return inferredStep (int or None), incorrect (dic), prediction_sequence (list), touchSequence (list) """ self.reset() for monitor in self.monitors.values(): monitor.beforeInferObject(objectDescription) currentStep = 0 # noqa: N806 finished = False inferred = False inferredStep = None # noqa: N806 prevTouchSequence = None # noqa: N806 incorrect = { "never_converged": 1, "false_convergence": 0 } # Track if the # non-recognition was due to convergance to an incorrect representation or # never converging for _ in xrange(self.maxTraversals): # noqa: F821 # Choose touch sequence. while True: touchSequence = range(len( objectDescription["features"])) # noqa: N806 if fixed_touch_sequence is None: random.shuffle(touchSequence) print("\nPerforming inference using an arbitrary, unfixed" "sequense of touches:") print(touchSequence) else: print("\nPerforming inference using a fixed random" "sequense of touches:") touchSequence = fixed_touch_sequence # noqa: N806 print(touchSequence) # Make sure the first touch will cause a movement. if (prevTouchSequence is not None and touchSequence[0] == prevTouchSequence[-1]): continue break sense_sequence = [ ] # contains a list of all the previous input SDRs prediction_sequence = [ ] # contains a list of the current SDR prediction, # as well as previously sensed input SDRs up until inference is successful for i_feature in touchSequence: currentStep += 1 feature = objectDescription["features"][i_feature] self._move(feature, randomLocation=randomLocation) pre_touch_location_list = self.column.get_location_copy( ) # Save # representation for later featureSDR = self.features[feature["name"]] # noqa: N806 self._sense(featureSDR, learn=False, waitForSettle=False) predictedColumns = map( int, list( set( np.floor( # noqa: N806 self.column.L4.getBasalPredictedCells() / cellsPerColumn)))) # Note _sense of the feature itself does not change the predicted # columns on this touch iteration (and thus does not invalidate the # prediction), but it does ensure the BasalPredictedCells have been # updated following the movement, and we re-set the location # representation later once in post-inference # Include all previously sensed/predicted representaitons by # over-writing current_sequence current_sequence = sense_sequence[:] current_sequence.append( list(predictedColumns)) # include the newly # predicted columns if currentStep == 1: # On the first step, record the input sensation prediction_sequence.append([featureSDR[:]]) else: prediction_sequence.append(current_sequence) if not inferred: sense_sequence.append(featureSDR[:]) else: # Re-set location representations after inference successful so # that additional sensations don't influence predictions, and we # can use the output predictions to visualize what the network sees # across the rest of the input space module_iter = 0 for module in self.column.L6aModules: module.activeCells = pre_touch_location_list[ module_iter] module_iter += 1 # Once inference has taken place, sense_sequence gathers # predictions sense_sequence.append(list(predictedColumns)) if not inferred: # Use the sensory-activated cells to detect whether the object has # been recognized. If these sensory-activated cells # are correct, it implies that the input layer's representation is # classifiable -- the location layer just correctly classified it. representation = \ self.column.getSensoryAssociatedLocationRepresentation() classification_list = [] if len(set(representation)) > 0: # Check the representation against all possible target classes for target_iter in range(10): target_representations = \ all_class_targets[target_iter][i_feature] if (set(representation) <= target_representations): classification_list.append(target_iter) print("Classified as a " + str(target_iter) + " with ground truth of " + objectDescription["name"]) if len(classification_list) > 1: print( "Classification list : classified as multiple classes!" ) print(classification_list) print( "***Provisional code to handle multiple classes" "implemented, but as never experienced, the reliability" "of the intersection resolution is untested***") exit() intersection_list = [] # Check the amount of overlap between the representations of for ambiguous_class_iter in range( len(classification_list)): intersection_list.append( len( set(representation).intersection( all_class_targets[classification_list[ ambiguous_class_iter]] [i_feature]))) # *** note this does not deal with Numpy's behaviour if two # locations have the same maximum value --> # see https://numpy.org/doc/stable/reference/ # generated/numpy.argmax.html print("Intersection list:") print(intersection_list) classification_list = classification_list[np.armax( intersection_list)] print("After checking intersections, resolved to:") print(classification_list) inferred = (len(classification_list) == 1) if inferred: if classification_list[0] == int( objectDescription["name"][0]): print("Correctly classified") inferredStep = currentStep # noqa: N806 plt.imsave( "correctly_classified/trial_" + str(trial_iter) + "_" + objectDescription["name"] + ".png", objectImage) incorrect = { "never_converged": 0, "false_convergence": 0 } else: print("Incorrectly classified") incorrect = { "never_converged": 0, "false_convergence": 1 } plt.imsave( "misclassified/trial_" + str(trial_iter) + "_example_" + objectDescription["name"] + "_converged_to_" + str(classification_list[0]) + ".png", objectImage) return None, incorrect, prediction_sequence, touchSequence finished = ((((inferred and numSensations is None) or (numSensations is not None and currentStep == numSensations))) and currentStep == 25) # Continuing to step 25 ensures we gather network predictions even after # inference is successful if finished: break prevTouchSequence = touchSequence # noqa: N806 if finished: break if incorrect["never_converged"] == 1: print("\nNever converged!") print("Inferred step when never converged " + str(inferredStep)) return inferredStep, incorrect, prediction_sequence, touchSequence
def predict(self, X): yp = self.model.predict(X) return np.armax(yp)