0:\\n\\t\\t\\t\\tvar.append(p['mepix'])\\n\\t\\tnoise = sum(var) / float(len(var))\\n\\t\\tself.pxdsttresh = (noise, noise)\\n\\t\\t\\t\\t\\n\\t\\t# AFTERMATH\\n\\t\\t# store some variables\\n\\t\\tpixpercm = (self.dispsize[0]/float(self.screensize[0]) + self.dispsize[1]/float(self.screensize[1])) / 2\\n\\t\\tscreendist = settings.SCREENDIST\\n\\t\\t# calculate thresholds based on tracker settings\\n\\t\\tself.accuracy = ((calibresult['Ldeg'],calibresult['Ldeg']), (calibresult['Rdeg'],calibresult['Rdeg'])) \\n\\t\\tself.pxerrdist = deg2pix(screendist, self.errdist, pixpercm)\\n\\t\\tself.pxfixtresh = deg2pix(screendist, self.fixtresh, pixpercm)\\n\\t\\tself.pxaccuracy = ((deg2pix(screendist, self.accuracy[0][0], pixpercm),deg2pix(screendist, self.accuracy[0][1], pixpercm)), (deg2pix(screendist, self.accuracy[1][0], pixpercm),deg2pix(screendist, self.accuracy[1][1], pixpercm)))\\n\\t\\tself.pxspdtresh = deg2pix(screendist, self.spdtresh/1000.0, pixpercm) # in pixels per millisecond\\n\\t\\tself.pxacctresh = deg2pix(screendist, self.accthresh/1000.0, pixpercm) # in pixels per millisecond**2\\n\\n\\t\\t# calibration report\\n\\t\\tself.log(\\\"pygaze calibration report start\\\")\\n\\t\\tself.log(\\\"accuracy (degrees): LX=%s, LY=%s, RX=%s, RY=%s\\\" % (self.accuracy[0][0],self.accuracy[0][1],self.accuracy[1][0],self.accuracy[1][1]))\\n\\t\\tself.log(\\\"accuracy (in pixels): LX=%s, LY=%s, RX=%s, RY=%s\\\" % (self.pxaccuracy[0][0],self.pxaccuracy[0][1],self.pxaccuracy[1][0],self.pxaccuracy[1][1]))\\n\\t\\tself.log(\\\"precision (RMS noise in pixels): X=%s, Y=%s\\\" % (self.pxdsttresh[0],self.pxdsttresh[1]))\\n\\t\\tself.log(\\\"distance between participant and display: %s cm\\\" % screendist)\\n\\t\\tself.log(\\\"fixation threshold: %s pixels\\\" % self.pxfixtresh)\\n\\t\\tself.log(\\\"speed threshold: %s pixels/ms\\\" % self.pxspdtresh)\\n\\t\\tself.log(\\\"acceleration threshold: %s pixels/ms**2\\\" % self.pxacctresh)\\n\\t\\tself.log(\\\"pygaze calibration report end\\\")\\n\\n\\t\\treturn True\",\n \"def _RunCalibration(self, graph_key, gdef, input_data, config):\\n return self._RunGraph(graph_key, gdef, input_data, config, 30)\",\n \"def updateParameters(self):\\r\\n\\r\\n\\t\\tif self.approach.altered:\\r\\n\\t\\t\\tself.transform.enabled = True\\r\\n\\r\\n\\t\\t\\tif self.approach.value == 'Locations in the DEM generated from field observations':\\r\\n\\t\\t\\t\\tself.predefined_pattern.enabled = False\\r\\n\\t\\t\\t\\tself.pattern_workspace.enabled = False\\r\\n\\t\\t\\t\\tself.point_matrix_size.enabled = True\\r\\n\\t\\t\\t\\tself.point_vectors.enabled = True\\r\\n\\t\\t\\t\\tself.mapping_field.enabled = True\\r\\n\\t\\t\\t\\tself.move_to_max.enabled = True\\r\\n\\t\\t\\t\\tself.output_sim_matrix.enabled = True\\r\\n\\t\\t\\t\\tself.mh_dil_val.enabled = False\\r\\n\\r\\n\\t\\t\\t\\tself.mh_iteration.enabled = False\\r\\n\\t\\t\\t\\tself.mh_iteration.value = False\\r\\n\\t\\t\\t\\tself.output_table.enabled = False\\r\\n\\t\\t\\t\\tself.output_raster_workspace.enabled = False\\r\\n\\t\\t\\t\\tself.output_raster_workspace.value = ''\\r\\n\\r\\n\\t\\t\\telif self.approach.value == 'Locations in the DEM versus pre-defined pattern':\\r\\n\\t\\t\\t\\tself.predefined_pattern.enabled = True\\r\\n\\t\\t\\t\\tself.point_matrix_size.enabled = True\\r\\n\\t\\t\\t\\tself.point_vectors.enabled = True\\r\\n\\t\\t\\t\\tself.mapping_field.enabled = True\\r\\n\\t\\t\\t\\tself.move_to_max.enabled = True\\r\\n\\t\\t\\t\\tself.mh_dil_val.enabled = True\\r\\n\\t\\t\\t\\tself.mh_iteration.enabled = True\\r\\n\\t\\t\\t\\tself.output_table.enabled = True\\r\\n\\t\\t\\t\\tself.output_sim_matrix.enabled = False\\r\\n\\t\\t\\t\\tself.output_sim_matrix.value = ''\\r\\n\\t\\t\\t\\tself.output_raster_workspace.enabled = False\\r\\n\\t\\t\\t\\tself.output_raster_workspace.value = ''\\r\\n\\r\\n\\t\\t\\telse: # seek pre-defined pattern in DEM\\r\\n\\t\\t\\t\\tself.predefined_pattern.enabled = True\\r\\n\\t\\t\\t\\tself.point_matrix_size.enabled = True\\r\\n\\t\\t\\t\\tself.mh_iteration.enabled = True\\r\\n\\t\\t\\t\\tself.output_raster_workspace.enabled = True\\r\\n\\t\\t\\t\\tself.point_vectors.enabled = False\\r\\n\\t\\t\\t\\tself.point_vectors.value = ''\\r\\n\\t\\t\\t\\tself.mapping_field.enabled = False\\r\\n\\t\\t\\t\\tself.move_to_max.enabled = False\\r\\n\\t\\t\\t\\tself.move_to_max.value = False\\r\\n\\t\\t\\t\\tself.mh_dil_val.enabled = True\\r\\n\\t\\t\\t\\tself.output_sim_matrix.enabled = False\\r\\n\\t\\t\\t\\tself.output_sim_matrix.value = ''\\r\\n\\t\\t\\t\\tself.output_table.enabled = False\\r\\n\\t\\t\\t\\tself.output_table.value = ''\\r\\n\\r\\n\\t\\tif self.mh_iteration.altered:\\r\\n\\r\\n\\t\\t\\tif self.mh_iteration.value is True:\\r\\n\\t\\t\\t\\tself.mh_dil_start.enabled = True\\r\\n\\t\\t\\t\\tself.mh_dil_stop.enabled = True\\r\\n\\t\\t\\t\\tself.mh_dil_step.enabled = True\\r\\n\\t\\t\\t\\tself.mh_dil_val.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_val.value = 1\\r\\n\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tif self.approach.value == 'Locations in the DEM generated from field observations':\\r\\n\\t\\t\\t\\t\\tself.mh_dil_val.enabled = False\\r\\n\\t\\t\\t\\t\\tself.mh_dil_val.value = 1\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tself.mh_dil_val.enabled = True\\r\\n\\r\\n\\t\\t\\t\\tself.mh_dil_start.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_stop.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_step.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_start.value = 0.01\\r\\n\\t\\t\\t\\tself.mh_dil_stop.value = 1\\r\\n\\t\\t\\t\\tself.mh_dil_step.value = 0.1\\r\\n\\r\\n\\t\\tif self.move_to_max.altered:\\r\\n\\t\\t\\tif self.move_to_max.value is True:\\r\\n\\t\\t\\t\\tself.move_to_max_distance.enabled = True\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tself.move_to_max_distance.enabled = False\\r\\n\\t\\t\\t\\tself.move_to_max_distance.value = 3\\r\\n\\r\\n\\t\\tif self.transform.altered:\\r\\n\\t\\t\\tif self.transform.value == 'Work directly on the elevation matrix':\\r\\n\\t\\t\\t\\tself.size_of_the_cell.enabled = False\\r\\n\\t\\t\\telif self.transform.value == 'Perform a local translation':\\r\\n\\t\\t\\t\\tself.size_of_the_cell.enabled = False\\r\\n\\t\\t\\telif self.transform.value == 'Compute slopes' or self.transform.value == \\\\\\r\\n\\t\\t\\t\\t\\t'Compute slopes and perform local translation':\\r\\n\\t\\t\\t\\tself.size_of_the_cell.enabled = True\\r\\n\\r\\n\\t\\tif self.predefined_pattern.altered:\\r\\n\\t\\t\\tif self.predefined_pattern.value == 'Custom pattern':\\r\\n\\t\\t\\t\\tself.pattern_workspace.enabled = True\\r\\n\\r\\n\\t\\t\\t\\tself.mh_iteration.value = False\\r\\n\\t\\t\\t\\tself.mh_iteration.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_start.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_stop.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_step.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_start.value = 0.01\\r\\n\\t\\t\\t\\tself.mh_dil_stop.value = 1\\r\\n\\t\\t\\t\\tself.mh_dil_step.value = 0.1\\r\\n\\t\\t\\t\\tself.mh_dil_val.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_val.value = 1\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tself.pattern_workspace.enabled = False\",\n \"def calibrate(self):\\n\\t\\twl = BLi.getWavelength()\\n\\t\\tif abs(self.stokes()) <= .5:\\n\\t\\t\\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\\n\\t\\t\\tself.offset2(-xxx)\\n\\t\\t\\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\\n\\t\\t\\tself.offset4(yyy)\\n\\t\\t\\tself.offset9(self.dettrans())\\n\\t\\telif abs(self.stokes()-90.) <= .5:\\n\\t\\t\\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\\n\\t\\t\\tself.offset3(-xxx)\\n\\t\\t\\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\\n\\t\\t\\tself.offset8(yyy)\\n\\t\\t\\tself.offset10(self.dettrans())\\n\\t\\telse:\\n\\t\\t\\tprint \\\"Can't calibrate at stokes=\\\",self.stokes()\\n\\t\\treturn [self.sign(),self.offset2(), self.offset3(),self.offset4(),self.offset5(),self.offset8(),self.offset9(),self.offset10()]\",\n \"def __init__(self):\\n self._read_calibration_data()\\n self.configure_sensor(\\n TemperatureOversamplings.x08,\\n PressureOversamplings.x16,\\n HumidityOversamplings.x08,\\n IIRFilterCoefficients.FC_003,\\n 250,\\n 250)\",\n \"def updateInterface(self):\\n p = self.cxn[self.selectedADR].packet()\\n p.magnetv().pscurrent().psvoltage()\\n p.time()\\n p.temperatures()\\n p.get_state_var('CompressorStatus')\\n p.get_instrument_state()\\n state = yield p.send()\\n # change instrument statuses\\n for name,status in state['get_instrument_state']:\\n if status[0] == False: color = 'red3'\\n elif status[1] == False: color = 'orange3'\\n elif status[1] == True: color = 'green3'\\n else: color = 'gray70'\\n self.instrumentStatuses[name].config(bg=color)\\n # change compressor button\\n if state['get_state_var'] == True:\\n self.compressorButton.configure(text='Stop Compressor',\\n command=self.stopCompressor,\\n state=Tkinter.NORMAL)\\n elif state['get_state_var'] == False:\\n self.compressorButton.configure(text='Start Compressor',\\n command=self.startCompressor,\\n state=Tkinter.NORMAL)\\n else: self.compressorButton.configure(state=Tkinter.DISABLED)\\n # update current, voltage fields\\n temps = {}\\n stages = ('T_60K','T_3K','T_GGG','T_FAA')\\n for i in range(len(stages)):\\n temps[stages[i]] = state['temperatures'][i]\\n #if temps[stages[i]] == 'nan': temps[stages[i]] = numpy.nan\\n if numpy.isnan(state['magnetv']['V']):\\n emf = 'ERR'\\n else:\\n emf = \\\"{0:.3f}\\\".format(state['magnetv']['V'])\\n if numpy.isnan(state['pscurrent']['A']):\\n psI = 'PS OFF'\\n else:\\n psI = \\\"{0:.3f}\\\".format(state['pscurrent']['A'])\\n if numpy.isnan(state['psvoltage']['V']):\\n psV = 'PS OFF'\\n else:\\n psV = \\\"{0:.3f}\\\".format(state['psvoltage']['V'])\\n self.currentBackEMF.set( emf )\\n self.currentI.set( psI )\\n self.currentV.set( psV )\\n # update plot:\\n # change data to plot\\n self.stage60K.set_xdata(numpy.append(self.stage60K.get_xdata(),mpl.dates.date2num(state['time'])))\\n self.stage60K.set_ydata(numpy.append(self.stage60K.get_ydata(),temps['T_60K']['K']))\\n self.stage03K.set_xdata(numpy.append(self.stage03K.get_xdata(),mpl.dates.date2num(state['time'])))\\n self.stage03K.set_ydata(numpy.append(self.stage03K.get_ydata(),temps['T_3K']['K']))\\n self.stageGGG.set_xdata(numpy.append(self.stageGGG.get_xdata(),mpl.dates.date2num(state['time'])))\\n self.stageGGG.set_ydata(numpy.append(self.stageGGG.get_ydata(),temps['T_GGG']['K']))\\n self.stageFAA.set_xdata(numpy.append(self.stageFAA.get_xdata(),mpl.dates.date2num(state['time'])))\\n self.stageFAA.set_ydata(numpy.append(self.stageFAA.get_ydata(),temps['T_FAA']['K']))\\n #update plot\\n self.updatePlot()\\n # update legend\\n labelOrder = ['T_60K','T_3K','T_GGG','T_FAA']\\n lines = [self.stage60K,self.stage03K,self.stageGGG,self.stageFAA]\\n labels = [l.strip('T_')+' ['+\\\"{0:.3f}\\\".format(temps[l]['K'])+'K]' for l in labelOrder]\\n labels = [s.replace('1.#QOK','OoR') for s in labels]\\n # legend on top (if not using this, delete \\\\n in title)\\n self.ax.legend(lines,labels,bbox_to_anchor=(0., 1.02, 1., .102), loc=3,\\n ncol=4, mode=\\\"expand\\\", borderaxespad=0.)\",\n \"def calibrate(self):\\n self.camera.camera_open()\\n while True:\\n img = self.camera.frame\\n if img is not None:\\n img_copy = img.copy()\\n img_h, img_w = img.shape[:2]\\n\\n white_key_width = int(img_w / 10)\\n white_key_bottom = int(img_h / 8)\\n black_key_bottom = img_h - int(img_h / 3)\\n key_top = img_h - white_key_bottom\\n\\n # Draw All Keys\\n for i in self.key_map.values():\\n # TODO: I think key_top and key_bottom are swapped\\n cv2.line(img, (white_key_width*i, key_top),\\n (white_key_width*i, white_key_bottom),\\n (0, 0, 200), 1)\\n\\n cv2.line(img, (0, black_key_bottom),\\n (img_w, black_key_bottom),\\n (0, 0, 200), 1)\\n\\n cv2.imshow('Align Frame', img)\\n key = cv2.waitKey(1)\\n if key == ESCAPE_KEY:\\n break\\n\\n self.img_h = img_h\\n self.img_w = img_w\\n self.white_key_width = white_key_width\\n self.white_key_bottom = white_key_bottom\\n self.black_key_bottom = black_key_bottom\\n self.key_top = key_top\\n self.latest_img = img_copy\\n\\n self.camera.camera_close()\\n cv2.destroyAllWindows()\",\n \"async def test_calibrate_gripper_raises_on_ot2(\\n decoy: Decoy,\\n ot2_hardware_api: OT2API,\\n) -> None:\\n subject = CalibrateGripperImplementation(hardware_api=ot2_hardware_api)\\n\\n params = CalibrateGripperParams(jaw=CalibrateGripperParamsJaw.REAR)\\n\\n with pytest.raises(HardwareNotSupportedError):\\n await subject.execute(params)\",\n \"def refreshSwapRates(self):\\r\\n self.firstPass()\",\n \"def _init_gpf(self):\\n raise NotImplementedError('Abstract Method')\",\n \"def platform_auto_calibrate_accelerometer(self):\\n self._platform_auto_calibrate_check()\\n return self.platform.auto_calibrate_accelerometer()\",\n \"def main():\\n # Instantiate the necessary sensors required for quadcopter control\\n # Pressure Sensor\\n bmp180 = BMP180(bus)\\n bmp180.oversample_sett = 3\\n try:\\n while True:\\n temp = bmp180.temperature\\n p = bmp180.pressure\\n altitude = bmp180.altitude\\n print(temp, p, altitude)\\n time.sleep(.5)\\n except KeyboardInterrupt:\\n print(\\\"Ending Program...\\\")\",\n \"def solvate(self):\\n\\n pass\",\n \"def initialize(self):\\n self.lib.Initialize()\\n\\n self.triggers = {'Internal': 0, 'External': 1, 'External Start': 6,\\n 'External Exposure': 7, 'External FVB EM': 9,\\n 'Software Trigger': 10,\\n 'External Charge Shifting': 12}\\n self.savetypes = {'Signed16bits': 1, 'Signed32bits': 2, 'Float': 3}\\n\\n # Initial values\\n\\n self.readout_packing_state = False\\n self.readout_packing = self.readout_packing_state\\n\\n self.readout_mode_mode = 'Image'\\n self.readout_mode = self.readout_mode_mode\\n\\n self.photon_counting_mode_state = False\\n self.photon_counting_mode = self.photon_counting_mode_state\\n\\n self.frame_transfer_mode_state = False\\n self.frame_transfer_mode = self.frame_transfer_mode_state\\n\\n self.fan_mode_index = 'onfull'\\n self.fan_mode = self.fan_mode_index\\n\\n self.EM_gain_mode_index = 'RealGain'\\n self.EM_gain_mode = self.EM_gain_mode_index\\n\\n self.cooled_on_shutdown_value = False\\n self.cooled_on_shutdown = self.cooled_on_shutdown_value\\n\\n self.baseline_offset_value = 100\\n self.baseline_offset = self.baseline_offset_value\\n\\n self.adv_trigger_mode_state = True\\n self.adv_trigger_mode = self.adv_trigger_mode_state\\n\\n self.acq_mode = 'Single Scan'\\n self.acquisition_mode = self.acq_mode\\n\\n self.amp_typ = 0\\n\\n self.horiz_shift_speed_index = 0\\n self.horiz_shift_speed = self.horiz_shift_speed_index\\n\\n self.vert_shift_speed_index = 0\\n self.vert_shift_speed = self.vert_shift_speed_index\\n\\n self.preamp_index = 0\\n self.preamp = self.preamp_index\\n\\n self.temperature_sp = 0 * degC\\n self.temperature_setpoint = self.temperature_sp\\n\\n self.auxout = np.zeros(4, dtype=bool)\\n for i in np.arange(1, 5):\\n self.out_aux_port[i] = False\\n\\n self.trigger_mode_index = 'Internal'\\n self.trigger_mode = self.trigger_mode_index\",\n \"def platform_auto_calibrate_elevation_servo(self):\\n self._platform_auto_calibrate_check()\\n self.platform.auto_calibrate_elevation_servo()\",\n \"def arm_calibration(self):\\n self.arm_motor.run_forever(speed_sp=900)\\n while not self.touch_sensor.is_pressed:\\n time.sleep(0.01)\\n self.arm_motor.stop(stop_action=\\\"brake\\\")\\n ev3.Sound.beep()\\n self.arm_motor.run_to_rel_pos(\\n speed_sp=900, position_sp=-5100)\\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\\n print('motor is no longer running')\\n ev3.Sound.beep()\\n self.arm_motor.position = 0\",\n \"def teleopInit(self):\\n self.gyro.setSensitivity(\\n self.voltsPerDegreePerSecond\\n ) # calibrates gyro values to equal degrees\",\n \"def degibber(self):\",\n \"async def test_calibrate_gripper_does_not_save_during_error(\\n decoy: Decoy, ot3_hardware_api: OT3API\\n) -> None:\\n subject = CalibrateGripperImplementation(hardware_api=ot3_hardware_api)\\n\\n params = CalibrateGripperParams(\\n jaw=CalibrateGripperParamsJaw.REAR,\\n otherJawOffset=Vec3f(x=4.4, y=5.5, z=6.6),\\n )\\n\\n decoy.when(\\n await ot3_calibration.calibrate_gripper_jaw(\\n ot3_hardware_api, probe=GripperProbe.REAR\\n )\\n ).then_raise(EarlyCapacitiveSenseTrigger(5.0, 3.0))\\n\\n with pytest.raises(EarlyCapacitiveSenseTrigger):\\n await subject.execute(params)\\n\\n decoy.verify(\\n await ot3_hardware_api.save_instrument_offset(\\n mount=OT3Mount.LEFT, delta=Point(x=3, y=4, z=6)\\n ),\\n times=0,\\n )\",\n \"def _init_hardware(self):\\n return\",\n \"def calibrate(self):\\n self.current_state = \\\"calibrate\\\"\\n self.next_state = \\\"idle\\\"\\n self.kinect.loadCameraCalibration()\\n # location_strings = [\\\"lower left corner of board\\\",\\n # \\\"upper left corner of board\\\",\\n # \\\"upper right corner of board\\\",\\n # \\\"lower right corner of board\\\",\\n # \\\"center of shoulder motor\\\"]\\n img = cv2.cvtColor(self.kinect.VideoFrame, cv2.COLOR_RGB2GRAY)\\n img = cv2.resize(img, (640, 480))\\n detector = apriltag(\\\"tagStandard41h12\\\", decimate=1.0)\\n result = detector.detect(img)\\n if len(result) < 4:\\n seen_april = [i['id'] for i in result]\\n occd_april = [str(i) for i in range(4) if i not in seen_april]\\n self.status_message = \\\"April tags Occluded: {}\\\".format(\\n ', '.join(occd_april))\\n print(f\\\"April tags occluded: {', '.join(occd_april)}\\\")\\n time.sleep(2)\\n return\\n for i in range(4):\\n self.kinect.rgb_click_points[i] = result[i]['lb-rb-rt-lt'][(4-i)%4]\\n # print(\\\"Result april:\\\\n\\\", self.kinect.rgb_click_points)\\n # Uncomment below to redo affine\\n # for j in range(5):\\n # self.status_message = \\\"Calibration - Click %s in RGB image\\\" % location_strings[j]\\n # while (self.kinect.new_click == False):\\n # time.sleep(.1)\\n # self.kinect.rgb_click_points[j] = self.kinect.last_click.copy()\\n # self.kinect.new_click = False\\n # print(\\\"Result manual:\\\\n\\\", self.kinect.rgb_click_points)\\n # i = 0\\n # for j in range(5):\\n # self.status_message = \\\"Calibration - Click %s in depth image\\\" % location_strings[j]\\n # while (self.kinect.new_click == False):\\n # time.sleep(.1)\\n # self.kinect.depth_click_points[i] = self.kinect.last_click.copy()\\n # self.kinect.new_click = False\\n # self.kinect.getAffineTransform(\\n # self.kinect.depth_click_points, self.kinect.rgb_click_points)\\n\\n \\\"\\\"\\\"TODO Perform camera calibration here\\\"\\\"\\\"\\n world_coords = np.array([[-0.297, -0.2876, 0], [-0.297, 0.3183, 0],\\n [0.307, 0.3183, 0], [0.3067, -0.2876, 0], [0.0, 0.083, 0.225]])\\n self.status_message = \\\"Calibration - Creating Extrinsic\\\"\\n rgb_click_points_SI = np.float32(self.kinect.rgb_click_points)\\n self.kinect.createExtrinsicCamMat(world_coords, rgb_click_points_SI)\\n self.status_message = \\\"Calibration - Completed Calibration\\\"\\n self.kinect.kinectCalibrated = True\\n cv2.imwrite('depthframergb.jpg', self.kinect.DepthFrameRGB)\\n cv2.imwrite('depthframeraw.jpg', self.kinect.DepthFrameRaw)\\n cv2.imwrite('videoframe.jpg', self.kinect.VideoFrame)\\n time.sleep(1)\",\n \"def recalculate() -> None:\\n NotImplemented\",\n \"def initialise_calibration(self):\\n for i in range(0, self.NUM_SENSORS):\\n self.calibratedMax[i] = 0\\n self.calibratedMin[i] = self.READING_TIMEOUT\",\n \"def safe_calibrate(self):\\n\\n status = -1\\n while status < 3:\\n ifMutexAcquire(self.use_mutex)\\n try:\\n new_status = self.BNO055.get_calibration_status()[3]\\n except:\\n new_status = -1\\n finally:\\n ifMutexRelease(self.use_mutex)\\n if new_status != status:\\n status = new_status\",\n \"def calibrate_power_ADC(self):\\n self.send_packet('\\\\x61')\",\n \"def set_gripper(self, new_gripper_state):\\n self.gripper_servo_handler.set_angle(7, new_gripper_state)\\n self.gripper_servo_handler.move_to_angles()\",\n \"def calibrate(\\n self, acc: np.ndarray, gyr: np.ndarray, acc_unit: Optional[str], gyr_unit: Optional[str]\\n ) -> Tuple[np.ndarray, np.ndarray]:\\n raise NotImplementedError(\\\"This method needs to be implemented by a subclass\\\")\",\n \"def initialize():\\n initialize_gripper()\\n assert right_gripper.is_ready()\\n print(\\\"Initialized gripper\\\")\\n rospy.sleep(2.0)\\n add_constraint('right_wall', 0, right_wall_dist, 0, 4, 0.1, 4) \\n add_constraint('left_wall', 0, left_wall_dist, 0, 4, 0.1, 4)\\n add_constraint('back_wall', back_wall_dist, 0, 0,0.1, 4, 4)\\n #self.add_constraint('table', 0,308, 0, -0.115, 4, 4, 0.1 )\\n mouth_pose = get_mouth_pose()\\n #add_constraint('person',mouth_pose.x, mouth_pose.y, mouth_pose.z, 4,4,4)\",\n \"def Modifier_UserGPS(self):\",\n \"def recalibrate_start(self):\\n self.epoch += 1\\n self.initialize()\\n self.recalibration_i = 0\\n\\n if self.vr_from_epoch is not None and self.epoch >= self.vr_from_epoch:\\n for group in self.param_groups:\\n for p in group['params']:\\n param_state = self.state[p]\\n param_state['gavg'].zero_()\\n param_state['m2'].zero_()\\n\\n # xk is changed to the running_x\\n p.data.zero_().add_(param_state['running_x'])\\n param_state['tilde_x'] = p.data.clone()\",\n \"def _InitializeBase(self):\\n imuen = rospy.get_param(\\\"~imuenable\\\", \\\"True\\\")\\n if imuen:\\n message = 'Startimu\\\\r'\\n else:\\n message = 'Startnoimu\\\\r'\\n\\n rospy.loginfo(\\\"Initializing Base \\\" + message)\\n self._WriteSerial(message)\\n \\n lincorrection = rospy.get_param(\\\"~linear_correction\\\", 1.0)\\n angcorrection = rospy.get_param(\\\"~angular_correction\\\", 0.984)\\n message = 'ascale %d %d\\\\r' % self._GetBaseAndExponent(angcorrection)\\n rospy.loginfo(\\\"Sending correction value: \\\" + message)\\n self._WriteSerial(message)\\n message = 'lscale %d %d\\\\r' % self._GetBaseAndExponent(lincorrection)\\n rospy.loginfo(\\\"Sending correction value: \\\" + message)\\n self._WriteSerial(message)\",\n \"def __init__(self, gpio, clock=CLOCK, data=DATA, mode=DEFAULT_MODE,\\n cal_dir=CALIBRATION_DIR):\\n self._gpio = gpio\\n\\n # Initialize clock and data gpio channels.\\n\\n gpio.set_mode(clock, pigpio.OUTPUT)\\n gpio.set_mode(data, pigpio.INPUT)\\n\\n # Define instance variables for use in the cloak/data gpio callback\\n # methods.\\n\\n self._pulse_num = 0\\n self._total_pulses = 24 + mode\\n self._data_bit = 0\\n self._shift_reg = 0\\n self._raw_data = 0\\n self._data_ready = Event()\\n\\n # Define the clock pulse and the wave chain needed to read a single\\n # 24-bit A/D conversion (25-27 pulses).\\n\\n gpio.wave_clear()\\n clock_mask = 1 << clock\\n clock_pulse = [pigpio.pulse(clock_mask, 0, PULSE_WIDTH),\\n pigpio.pulse(0, clock_mask, PULSE_WIDTH)]\\n gpio.wave_add_generic(clock_pulse)\\n self._wave_id = gpio.wave_create()\\n self._wave_chain = [255, 0, self._wave_id,\\n 255, 1, self._total_pulses, 0]\\n\\n # Initialize calibration constants and mode-dependant variables.\\n\\n self._gain = GAINS[mode]\\n self._offset = 0.0\\n self._cal = DEFAULT_CALIBRATION\\n dir_path = Path(cal_dir)\\n dir_path.mkdir(parents=True, exist_ok=True)\\n self._cal_path = dir_path / Path('calibration')\\n if self._cal_path.is_file():\\n cal_file = open(self._cal_path, 'r')\\n cal_str = cal_file.read()\\n if cal_str.replace('.', '', 1).isdecimal():\\n self._cal = float(cal_str)\\n cal_file.close()\\n\\n # Start the HX711.\\n\\n gpio.write(clock, pigpio.HIGH)\\n sleep(0.001)\\n gpio.write(clock, pigpio.LOW)\\n\\n # Initialize callbacks for activity on the clock and data gpio\\n # channels.\\n\\n self._clock_cb = gpio.callback(clock, pigpio.FALLING_EDGE,\\n self._clock_falling)\\n self._data_cb = gpio.callback(data, pigpio.EITHER_EDGE,\\n self._data_either)\",\n \"def on_run(self):\\n self.set_illumination({'mode': 'breathe'})\",\n \"def change_resolution(self):\",\n \"def set_calibration(self, measured_air_pressure, actual_air_pressure):\\n measured_air_pressure = int(measured_air_pressure)\\n actual_air_pressure = int(actual_air_pressure)\\n\\n self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_SET_CALIBRATION, (measured_air_pressure, actual_air_pressure), 'i i', '')\",\n \"def selfcal_apcal(imc, trial='1'):\\n flagmanager(imc.vislf, mode='restore', versionname='startup')\\n applycal(vis=imc.vislf,\\n spwmap=np.zeros(54),\\n interp='linearPDperobs',\\n gaintable=[imc.path_base+'.pcal'+trial],\\n calwt=False,\\n flagbackup=False)\",\n \"def on_cam_base_adjust_btn_clicked(self):\\n pitch = self.cam_base_pitch_hSlider.value()\\n yaw = self.cam_base_yaw_hSlider.value()\\n len = self.cam_processing_len_edit.text()\\n wid = self.cam_processing_width_edit.text()\\n self.baseCamThread.cam.set_cam_parameters(int(len),float(wid))\\n pitch, yaw = self.control1.device.cmd_cam_adjust(pitch, yaw)\\n status = \\\"goint to angles as, pitch: \\\" + str(pitch) + \\\", yaw: \\\" + str(yaw)\\n self.cam_set_status_txt(status)\",\n \"def platform_auto_calibrate_magnetometer(self):\\n self._platform_auto_calibrate_check()\\n return self.platform.auto_calibrate_magnetometer()\",\n \"def _setup(self) -> None:\\n # Call base implementation\\n super()._setup()\\n\\n # Configure the low-level integrator\\n engine_options = self.simulator.engine.get_options()\\n engine_options[\\\"stepper\\\"][\\\"iterMax\\\"] = 0\\n engine_options[\\\"stepper\\\"][\\\"dtMax\\\"] = min(0.02, self.step_dt)\\n engine_options[\\\"stepper\\\"][\\\"logInternalStepperSteps\\\"] = False\\n\\n # Set maximum computation time for single internal integration steps\\n if self.debug:\\n engine_options[\\\"stepper\\\"][\\\"timeout\\\"] = 0.0\\n else:\\n engine_options[\\\"stepper\\\"][\\\"timeout\\\"] = 2.0\\n\\n # Enable logging of geometries in debug mode\\n if self.debug:\\n engine_options[\\\"telemetry\\\"][\\\"isPersistent\\\"] = True\\n\\n # Update engine options\\n self.simulator.engine.set_options(engine_options)\\n\\n # Set robot in neutral configuration\\n qpos = self._neutral()\\n framesForwardKinematics(\\n self.robot.pinocchio_model, self.robot.pinocchio_data, qpos)\",\n \"def _set_up_acq_opt_direct(self):\\n raise NotImplementedError('Not implemented DiRect yet.')\",\n \"def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:\",\n \"def __init__(self):\\n self.__deviceselected__ = \\\"SR-DMS4AP{LOCALBUMP}DEV:Sel-SP\\\"\\n self.__source__ = \\\"SR-DMS4AP{LOCALBUMP}S-SP\\\"\\n self.__plane__ = \\\"SR-DMS4AP{LOCALBUMP}PLANE-SP\\\"\\n #self.__xshift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT:X-SP\\\"\\n #self.__yshift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT:Y-SP\\\"\\n #self.__xangle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:X-SP\\\"\\n #self.__yangle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:Y-SP\\\"\\n self.__shift__ = \\\"SR-DMS4AP{LOCALBUMP}SHIFT-SP\\\"\\n self.__angle__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE-SP\\\"\\n # with all offsets\\n self.__anglerb__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE-I\\\"\\n self.__positionrb__ = \\\"SR-DMS4AP{LOCALBUMP}POS-I\\\"\\n # with BBA offset only\\n self.__anglerb0__ = \\\"SR-DMS4AP{LOCALBUMP}ANGLE:BBA-I\\\"\\n self.__positionrb0__ = \\\"SR-DMS4AP{LOCALBUMP}POS:BBA-I\\\"\\n\\n self.__bpmposition__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}Pos-I\\\"\\n self.__bpmorbitx__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:X-I\\\"\\n self.__bpmorbity__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y-I\\\"\\n self.__bpmorbitx0__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:X0-I\\\"\\n self.__bpmorbity0__ = \\\"SR-DMS4AP{LOCALBUMP:BPM}ORB:Y0-I\\\"\\n\\n self.__correctorposition__ = \\\"SR-DMS4AP{LOCALBUMP:COR}Pos-I\\\"\\n self.__hcorrectorcurrent__ = \\\"SR-DMS4AP{LOCALBUMP:HCOR}PS-SP\\\"\\n self.__hcorrectordiff__ = \\\"SR-DMS4AP{LOCALBUMP:HCOR}PS:Delta-SP\\\"\\n self.__vcorrectorcurrent__ = \\\"SR-DMS4AP{LOCALBUMP:VCOR}PS-SP\\\"\\n self.__vcorrectordiff__ = \\\"SR-DMS4AP{LOCALBUMP:VCOR}PS:Delta-SP\\\"\\n\\n self.__undo__ = \\\"SR-DMS4AP{LOCALBUMP}Enbl:Undo-Cmd\\\"\\n self.__apply__ = \\\"SR-DMS4AP{LOCALBUMP}Enbl-Cmd\\\"\\n self.__status__ = \\\"SR-DMS4AP{LOCALBUMP}TS-I\\\"\\n self.__idposinfo__ = \\\"SR-DMS4AP{LOCALBUMP}S-I\\\"\\n self.__srcposition__ = \\\"SR-DMS4AP{LOCALBUMP}SRC-SP\\\"\",\n \"def setup(self):\\n\\t\\tself.interface = self.getDriver('light_interface')\\n\\n\\t\\tself.pin = self.config['interface_position']\\n\\t\\tself.blink_rate = self.config['blink_rate'] / 2 or 0.5\\n\\t\\tself.is_on = False\\n\\n\\t\\tself.intensity = 255\\n\\t\\tself.blink = False\\n\\t\\tself.count = None\\n\\t\\tself.current_count = False\\n\\t\\tself.current_count = None\\n\\n\\t\\tself.saved_intensity = None\\n\\t\\tself.saved_blink = False\\n\\t\\tself.saved_count = None\\n\\n\\t\\treturn True\",\n \"def open_gripper(self):\\n if self._control_method == 'p':\\n self.pos_cmd[-self._num_jnt_gripper:] = GRIPPER_MAX[0] * np.ones(self._num_jnt_gripper)\\n elif self._control_method == 'v':\\n self.vel_cmd[-self._num_jnt_gripper:] = -GRIPPER_VEL * (self.jnt_pos[-self._num_jnt_gripper:]\\n - GRIPPER_MAX[0])\",\n \"def pibooth_reset(cfg, hard):\",\n \"def configure(self, mag_calibration=None):\\n\\n self.set_mag_calibration(mag_calibration)\\n\\n ###################################################\\n # - Bit 0 - SW_RESET - software reset for accelerometer and gyro - default 0\\n # - Bit 2 - IF_ADD_INC - automatic register increment for multibyte access - default 1\\n # - Bit 6 - BDU - Block data update . Ensures high and low bytes come from\\n # the same sample. Not necessary if waiting for data ready - default 0\\n self.ag.write_byte(Register.CTRL_REG8, 0x05)\\n # 0x08 - reboot magnetometer, +/- 4 Gauss full scale - fixes occasional magnetometer hang\\n # 0x04 - soft reset magnetometer, +/- 4 Gauss full scale\\n self.mag.write_byte(Register.CTRL_REG2_M, 0x08)\\n time.sleep(0.01) # Wait for reset\\n ###################################################\\n # Confirm that we're connected to the device\\n if self.ag.read_byte(Register.WHO_AM_I) != lsm9ds1.AG_ID:\\n raise RuntimeError('Could not find LSM9DS1 Acceleromter/Gyro. Check wiring and port numbers.')\\n if self.mag.read_byte(Register.WHO_AM_I_M) != lsm9ds1.MAG_ID:\\n raise RuntimeError('Could not find LSM9DS1 Magnetometer. Check wiring and port numbers.')\\n ###################################################\\n # Set up output data rate for Accelerometer and Gyro if using both\\n # Use CTRL_REG2_G and CTRL_REG3_G to control the optional additional filters\\n # 0x6A - 500 dps, 119 Hz ODR, 38Hz cut off (31 Hz Cut off if HP filter is enabled)\\n # 0x8A - 500 dps, 238 Hz ODR, 76Hz cut off (63 Hz Cut off if HP filter is enabled)\\n # 0xAA - 500 dps, 476 Hz ODR, 100Hz cut off (57 Hz Cut off if HP filter is enabled)\\n # 0x00 - disabled\\n self.ag.write_byte(Register.CTRL_REG1_G, 0x8A)\\n # 0x03 - Enable LPF2 - Frequency set by REG1 (2nd Low Pass Filter)\\n # self.ag.write_byte(Register.CTRL_REG2_G, 0x03)\\n # 0x45 - Enable High Pass Filter at (0.2 Hz @ 119 ODR) or (0.5 Hz @ 238 ODR)\\n # self.ag.write_byte(Register.CTRL_REG3_G, 0x45)\\n ###################################################\\n # Set up Accelerometer\\n # 0xC0 - Set to +- 2G, 119 Hz ODR, 50 Hz BW (Frequency is ignored if Gryo is enabled)\\n # 0x87 - Set to +- 2G, 238 Hz ODR, 50 Hz BW (Frequency is ignored if Gryo is enabled)\\n self.ag.write_byte(Register.CTRL_REG6_XL, 0x87)\\n # 0x01 INT1_A/G pin set by accelerometer data ready\\n self.ag.write_byte(Register.INT1_CTRL, 0x01)\\n ###################################################\\n # Set up magnetometer\\n # MSB enables temperature compensation\\n # 0x98 - 40 Hz ODR, Enable Temp Comp\\n # 0x9C - 80 Hz ODR, Enable Temp Comp\\n # 0x18 - 40 Hz ODR, Disable Temp Comp\\n # 0x1C - 80 Hz ODR, Enable Temp Comp\\n # 0xE2 - 155 Hz ODR, Enable Temp Comp, x and y ultra high performance\\n # 0xC2 - 300 Hz ODR, Enable Temp Comp, x and y high performance\\n # 0xA2 - 560 Hz ODR, Enable Temp Comp, x and y medium performance\\n # 0x82 - 1000 Hz ODR, Enable Temp Comp, x and y low performance\\n self.mag.write_byte(Register.CTRL_REG1_M, 0xC2)\\n # 0x00 - Magnetometer continuous operation - I2C enabled\\n # 0x80 - Magnetometer continuous operation - I2C disabled\\n self.mag.write_byte(Register.CTRL_REG3_M, 0x00)\\n # 0x08 - z axi high performance mode - doesn't seem to do anything\\n self.mag.write_byte(Register.CTRL_REG4_M, 0x08)\\n # Enable BDU (block data update) to ensure high and low bytes come from the same sample\\n self.mag.write_byte(Register.CTRL_REG5_M, 0x40)\",\n \"def update(self):\\n\\t\\t# If being controlled by COM\\n\\t\\tif self.controled_by_com :\\n\\t\\t\\t# Substract 1 from the update counter\\n\\t\\t\\tself.update_counter -= 1\\n\\t\\t\\t# If the update counter reaches zero\\n\\t\\t\\tif self.update_counter == 0. :\\n\\t\\t\\t\\t# then ask for an action \\n\\t\\t\\t\\tif self.intermediate_phase is False :\\n\\t\\t\\t\\t\\tself.action_required = True \\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t\\t# if during a change\\n\\t\\t\\t\\t# then make the change\\n\\t\\t\\t\\tif self.intermediate_phase is True : \\n\\t\\t\\t\\t\\tself.action_required = False\\n\\t\\t\\t\\t\\tself._color_changer() #Make the change in the Simulator\\n\\t\\telse :\\n\\t\\t\\tpass\",\n \"def run(self):\\n self.monitorTextBox.setPlainText(\\\"\\\")\\n self.applyChanges()\\n self.toolBox.setCurrentIndex(4)\\n if self.dat.surrogateProblem == None:\\n return\\n tool = self.toolSelectBox.currentText()\\n pg = self.dat.surrogateMethods.plugins[tool].surrogateMethod(self.dat)\\n pg.loadDict(self.dat.surrogateProblem[tool])\\n pg.start()\\n self.pg = pg\\n self.a = True\\n self.timer.start(self.updateDelay)\\n self.timeRunning = time.time()\\n self.runButton.setEnabled(False)\\n self.stopButton.setEnabled(True)\\n self.setStatusBar.emit(\\\"Surrogate Generation Running\\\")\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.75418216","0.7135867","0.67792577","0.6580618","0.65281117","0.6497911","0.6455138","0.63598543","0.6339586","0.6328379","0.62397826","0.6181482","0.6150413","0.6126467","0.61043966","0.6070043","0.6048816","0.6010795","0.59791523","0.59572184","0.5916725","0.5900806","0.5856005","0.58266276","0.57988787","0.57152057","0.5697505","0.5617008","0.56169116","0.5612749","0.55660135","0.5562601","0.5549949","0.5539185","0.5525034","0.5516993","0.55139804","0.55051434","0.54997706","0.549917","0.5494082","0.54835707","0.5479603","0.54741585","0.54677665","0.5467032","0.5460712","0.54524195","0.5444091","0.5434666","0.543352","0.5428342","0.540328","0.5388981","0.5370021","0.53592306","0.5355073","0.5345184","0.53405434","0.53382343","0.5335326","0.53242075","0.5323665","0.5297139","0.5295933","0.52944535","0.5292751","0.52888477","0.5281707","0.5276047","0.5274172","0.5273956","0.5272347","0.5257516","0.5255481","0.5251584","0.5248459","0.5246637","0.52372825","0.52278584","0.5226437","0.5220483","0.52155036","0.52142906","0.51988614","0.519849","0.5195475","0.5194816","0.518704","0.5181081","0.51809984","0.5172403","0.5169121","0.5162822","0.514897","0.5140832","0.5140677","0.513747","0.5136518","0.51323104"],"string":"[\n \"0.75418216\",\n \"0.7135867\",\n \"0.67792577\",\n \"0.6580618\",\n \"0.65281117\",\n \"0.6497911\",\n \"0.6455138\",\n \"0.63598543\",\n \"0.6339586\",\n \"0.6328379\",\n \"0.62397826\",\n \"0.6181482\",\n \"0.6150413\",\n \"0.6126467\",\n \"0.61043966\",\n \"0.6070043\",\n \"0.6048816\",\n \"0.6010795\",\n \"0.59791523\",\n \"0.59572184\",\n \"0.5916725\",\n \"0.5900806\",\n \"0.5856005\",\n \"0.58266276\",\n \"0.57988787\",\n \"0.57152057\",\n \"0.5697505\",\n \"0.5617008\",\n \"0.56169116\",\n \"0.5612749\",\n \"0.55660135\",\n \"0.5562601\",\n \"0.5549949\",\n \"0.5539185\",\n \"0.5525034\",\n \"0.5516993\",\n \"0.55139804\",\n \"0.55051434\",\n \"0.54997706\",\n \"0.549917\",\n \"0.5494082\",\n \"0.54835707\",\n \"0.5479603\",\n \"0.54741585\",\n \"0.54677665\",\n \"0.5467032\",\n \"0.5460712\",\n \"0.54524195\",\n \"0.5444091\",\n \"0.5434666\",\n \"0.543352\",\n \"0.5428342\",\n \"0.540328\",\n \"0.5388981\",\n \"0.5370021\",\n \"0.53592306\",\n \"0.5355073\",\n \"0.5345184\",\n \"0.53405434\",\n \"0.53382343\",\n \"0.5335326\",\n \"0.53242075\",\n \"0.5323665\",\n \"0.5297139\",\n \"0.5295933\",\n \"0.52944535\",\n \"0.5292751\",\n \"0.52888477\",\n \"0.5281707\",\n \"0.5276047\",\n \"0.5274172\",\n \"0.5273956\",\n \"0.5272347\",\n \"0.5257516\",\n \"0.5255481\",\n \"0.5251584\",\n \"0.5248459\",\n \"0.5246637\",\n \"0.52372825\",\n \"0.52278584\",\n \"0.5226437\",\n \"0.5220483\",\n \"0.52155036\",\n \"0.52142906\",\n \"0.51988614\",\n \"0.519849\",\n \"0.5195475\",\n \"0.5194816\",\n \"0.518704\",\n \"0.5181081\",\n \"0.51809984\",\n \"0.5172403\",\n \"0.5169121\",\n \"0.5162822\",\n \"0.514897\",\n \"0.5140832\",\n \"0.5140677\",\n \"0.513747\",\n \"0.5136518\",\n \"0.51323104\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5706692"},"document_rank":{"kind":"string","value":"26"}}},{"rowIdx":21392,"cells":{"query":{"kind":"string","value":"It should delegate to hardware API to calibrate the gripper & save calibration."},"document":{"kind":"string","value":"async def test_calibrate_gripper_saves_calibration(\n decoy: Decoy,\n ot3_hardware_api: OT3API,\n _mock_ot3_calibration: None,\n) -> None:\n subject = CalibrateGripperImplementation(hardware_api=ot3_hardware_api)\n params = CalibrateGripperParams(\n jaw=CalibrateGripperParamsJaw.REAR,\n otherJawOffset=Vec3f(x=4.4, y=5.5, z=6.6),\n )\n expected_calibration_data = GripperCalibrationOffset(\n offset=Point(x=101, y=102, z=103),\n source=CalibrationSourceType.calibration_check,\n status=CalibrationStatus(markedBad=False),\n last_modified=datetime(year=3000, month=1, day=1),\n )\n decoy.when(\n await ot3_calibration.calibrate_gripper_jaw(\n ot3_hardware_api, probe=GripperProbe.REAR\n )\n ).then_return(Point(1.1, 2.2, 3.3))\n decoy.when(\n await ot3_hardware_api.save_instrument_offset(\n mount=OT3Mount.GRIPPER, delta=Point(x=2.75, y=3.85, z=4.95)\n )\n ).then_return(expected_calibration_data)\n result = await subject.execute(params)\n assert result.jawOffset == Vec3f(x=1.1, y=2.2, z=3.3)\n assert result.savedCalibration == expected_calibration_data"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _doCalibration(self):\n self._cmdCalibration(2)","def photometric_calibration():\n pass","def _calibrate(self, Otrain, Ftrain, Feval):\n raise NotImplementedError()","def calibrate_gripper(self):\n self.gripper = Gripper(self.gripper_side)\n self.gripper.calibrate()\n self.gripper.open()\n self.vacuum_sensor = AnalogIO(self.gripper_side + '_vacuum_sensor_analog')\n if rospy.get_param('verbose'):\n rospy.loginfo('Calibrated gripper. (type={})'.format(self.gripper.type()))","def do_calibration(self):\n goal = CalculateParametersGoal()\n self.calibrate_client.send_goal(goal)\n self.calibrate_client.wait_for_result()\n result = self.calibrate_client.get_result()\n rospy.loginfo('Received the calibration results')\n if result.number_of_images is 0:\n rospy.logerr('Failed to calibrate the camera.')\n else:\n rospy.loginfo('Number of pictures: {}, error: {}'.format(result.number_of_images, result.error))\n self.save_calibration_parameters(result.intrinsics, result.error, result.number_of_images)","def calibrate(): \n \n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \n # containing all calibration data. \n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \n\n # Set Beam energy\n CalObj.set_beam_momentum(beamenergy)\n\n # Get gearfile and set air as DUT material\n localgearfile = CalObj.get_filename('gear.xml')\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\n \n # Create list of calibration steps \n calpath = create_calibration_path(CalObj)\n \n # Run the calibration steps \n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)","def calibrate(self):\n if self.iCAL_required:\n logger.info(\"iCAL-sensitive registers were modified, performing calibration...\")\n return self._run_ical()\n else:\n logger.info(\"iCAL-sensitive registers were not modified, skipping calibration...\")\n return 0 # Still success","def calibration(self, cal: int, /) -> None:","def calibrate(self, x, y) -> None:\n pass","def platform_auto_calibrate(self):\n self.platform_auto_calibrate_servos()\n self.platform_auto_calibrate_imu()","def calibrate(self):\n\n self.update_message('Calibrating platform...')\n\n self.calibrate_platform()\n\n self.update_message('Platform Calibrated.')\n\n # calibrate arm x axis\n self.update_message('Calibrating x axis...')\n calibrated = self.calibrate_arm(0)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate x axis.')\n return 0\n else:\n self.update_message('x axis calibrated.')\n\n # calibrate arm y axis\n self.update_message('Calibrating y axis...')\n calibrated = self.calibrate_arm(1)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate y axis.')\n return 0\n else:\n self.update_message('y axis calibrated.')\n\n # calibrate arm z axis\n self.update_message('Calibrating z axis...')\n calibrated = self.calibrate_arm(2)\n\n if not calibrated:\n self.update_message('ERROR: Could not calibrate z axis.')\n return 0\n else:\n self.update_message('z axis calibrated.\\n'\n 'Autocalibration done.\\n'\n 'Accuracy: {}'.format(self.matrix_accuracy()))\n\n # Getting the direction to withdraw pipette along x axis\n self.get_withdraw_sign()\n self.inv_mat = np.linalg.inv(self.mat)\n self.calibrated = 1\n self.cam.click_on_window = True\n self.save_calibration()\n return 1","def calibrate(self):\n self.gripper_io.set_signal_value(\"calibrate\", True)\n success = intera_dataflow.wait_for(\n lambda: self.is_calibrated(),\n timeout=5.0,\n raise_on_error=False\n )\n if not success:\n rospy.logerr(\"({0}) calibration failed.\".format(self.name))\n return success","def run_calib(projector=OPTOMA_HD33()):\n w, h = (0.2160, 0.2794)\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\n [-w/2, 0, 0], [w/2, 0, 0],\n [-w/2, 0, h/2], [w/2, 0, h/2]])\n\n global img_points, going\n img_points = []\n\n try:\n window = Window()\n window.MoveXY(1600,0)\n window.ShowFullScreen(True)\n going = True\n\n @window.eventx\n def EVT_MOUSE_EVENTS(evt):\n global going, img_points\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\n img_points.append(evt.Position)\n print('Picked point %d of 6' % (len(img_points)))\n if len(img_points) == len(obj_points):\n print \"Done\"\n going = False\n\n print(\"\"\"[Extrinsic Calibration] \n\nThere should be 6 points marked on the table and backdrop. \nMoving the mouse over the projected display, click each of the points\nin order:\n (left top, on the backdrop),\n (right top, on the backdrop),\n (left center, on the crease),\n (right center, on the crease),\n (left bottom, on the table),\n (right bottom, on the table)\n\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\n\nClick the six points:\n\"\"\")\n\n while going: cv.WaitKey(10)\n\n finally:\n window.Close()\n\n img_points = np.array(img_points, 'f')\n projector.calibrate_extrinsic(img_points, obj_points)\n\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\n print('OK')","def calibration(self) -> int:","def calibrate(self):\n\t\tLTOGRIGHT = []\n\t\tLTOGUP = []\n\t\tRTOGRIGHT = []\n\t\tRTOGUP = []\n\t\tstart = time.time()\n\t\tcalibration_time = 5.0\n\t\twhile time.time() - start < calibration_time:\n\t\t\tevents = pygame.event.get()\n\t\t\tfor event in events:\n\t\t\t\tif event.type == pygame.JOYAXISMOTION:\n\t\t\t\t\tLTOGRIGHT.append(self.joystick.get_axis(self.LTOGRIGHT))\n\t\t\t\t\tLTOGUP.append(-self.joystick.get_axis(self.LTOGUP))\n\t\t\t\t\tRTOGRIGHT.append(self.joystick.get_axis(self.RTOGRIGHT))\n\t\t\t\t\tRTOGUP.append(-self.joystick.get_axis(self.RTOGUP))\n\n\t\t# calibration sets highest value equal to 1.0\n\t\tself.calibration[0] = 1.0/max(LTOGRIGHT)\n\t\tself.calibration[1] = -1.0/min(LTOGRIGHT)\n\t\tself.calibration[2] = -1.0/min(LTOGUP)\n\t\tself.calibration[3] = 1.0/max(LTOGUP)\n\t\tself.calibration[4] = 1.0/max(RTOGRIGHT)\n\t\tself.calibration[5] = -1.0/min(RTOGRIGHT)\n\t\tself.calibration[6] = -1.0/min(RTOGUP)\n\t\tself.calibration[7] = 1.0/max(RTOGUP)","def calibrate(self):\n import time\n\n CALIBRATE_SLEEP = 0.75\n\n self.change_power(-self._calpow)\n encprev, encnow = 0, None\n while encprev != encnow:\n encprev = encnow\n time.sleep(CALIBRATE_SLEEP)\n encnow = self._bp.get_motor_encoder(self._port)\n self._pmin = encnow\n self.change_power(0)\n\n self.change_power(self._calpow)\n encprev, encnow = 0, None\n while encprev != encnow:\n encprev = encnow\n time.sleep(CALIBRATE_SLEEP)\n encnow = self._bp.get_motor_encoder(self._port)\n self._pmax = encnow\n self.change_power(0)\n\n if self._pmax == self._pmin:\n raise Exception('motor {} does not move'.format(self._port))\n\n self._pinit = (self._pmax + self._pmin) * 0.5\n time.sleep(0.5)\n self.to_init_position()","def calibrate(self):\n self.mode = Mode.calibrating\n yaw_sensor = yaw_button()\n while not yaw_sensor.is_pressed():\n self.move_left()\n for _ in range(75):\n self.move_right()\n\n pitch_sensor = pitch_button()\n while not pitch_sensor.is_pressed():\n self.move_up()\n for _ in range(21):\n self.move_down()\n\n self.pitch = 0.0\n self.yaw = 0.0\n self.mode = Mode.waiting","def set_calibrate(self, calibrate=None, *args, **kwargs):\n calibrate = calibrate or self._calibrate or {}\n calibrate = copy.copy(calibrate)\n calibrate.update(kwargs)\n if calibrate is None: #Use auto\n calibrate = copy.copy(AUTO_CALIBRATE)\n self._calibrate = calibrate\n logging.info(\"Calibration updated! %s\" % self._calibrate)","def calibrate_onc(data, path, model_name):\n \n #split test data (subsets 7-9) into new test (7-8)/train(9) sets\n calibration_train_set = data[((data.subset==7)|(data.subset==8))].copy()\n calibration_test_set = data[data.subset==9].copy()\n\n #define calibration model\n ir = IsotonicRegression(out_of_bounds=\"clip\")\n #fit the model to the probas from the training set\n ir.fit(calibration_train_set.score, calibration_train_set.y )\n \n #evaluate with the test set and save\n calibration_test_set.loc[:,'p_calibrated'] = ir.transform(calibration_test_set.score) \n \n #calibration_test_set.loc[:,'p_calibrated'] = p_calibrated\n \n #save\n with open(path + 'model_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \n pickle.dump(ir,picklefile)\n \n with open(path + 'y_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \n pickle.dump(calibration_test_set, picklefile)\n \n print_calibrated_results(calibration_test_set.y, calibration_test_set.score, calibration_test_set.p_calibrated)\n return calibration_test_set","def calibrate_device(self,event):\n message = \"\"\"Place Microphone as close as possible to speaker.\\n\n Click 'OK' to start system calibration.\"\"\"\n Dlg = wx.MessageDialog(None, message, \"Start System Calibration\",\n wx.OK|wx.CANCEL|wx.ICON_INFORMATION)\n Dlg.SetFont(self.font_std)\n if Dlg.ShowModal() == wx.ID_OK:\n bi = wx.BusyInfo(\"Calibrating System, please wait...\", self)\n time.sleep(5)\n bi2 = wx.BusyInfo(\"Done!\", self)\n time.sleep(2)\n bi.Destroy()\n bi2.Destroy()\n Dlg.Destroy()","def cam_calibration():\n # read all calibration images in a folder with similar names\n images = glob.glob('./camera_cal/calibration*.jpg')\n\n # calibrate camera and read object-points (3D), image points (2D) and image shape\n objpoints, imgpoints, img_shape = calibrate_camera(images)\n print(\"DONE: Camera calibration\")\n # save calibration parameters' pickle file\n save_calib_params(objpoints, imgpoints, img_shape)\n print(\"Calibration parameters pickle file saved \")","def calibrate(self, master):\n if master.polyorder == 'linear':\n self.fitfunction = \"A0 + A1 * D\"\n self.fit_fkt = self.calc_lin\n elif master.polyorder == 'quadratic':\n self.fit_fkt = self.calc_quad\n self.fitfunction = \"A0 + A1 * D + A2 * D**2\"\n elif master.polyorder == \"cubic\":\n self.fitfunction = \"A0 + A1 * D + A2 * D**2 + A3 * D**3\"\n self.fit_fkt = self.calc_cubic\n else:\n print(\"Polynomgrad nicht definiert\")\n \n self.mw = np.asarray(self.mw)\n if master.sensortype == \"Druck\":\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\n else:\n print(\"Sensortyp noch nicht Hinterlegt\")","def platform_auto_calibrate_servos(self):\n self.platform.auto_calibrate_elevation_servo()\n self.platform.auto_calibrate_azimuth_servo()","def calibrate(self, measure_mode):\n self.setMeasurementMode(measure_mode)\n calibrateI1Pro()","def _RunCalibration(self, graph_key, gdef, input_data, config):\n return self._RunGraph(graph_key, gdef, input_data, config, 30)","def _calibrate_measurement(self):\n\n cold_blackbody = bb_radiance(self.cbb.header.cbb_temperature + 273.15,\n self.cbb.data.wavelength)\n warm_blackbody = bb_radiance(self.wbb.header.wbb_temperature + 273.15,\n self.wbb.data.wavelength)\n\n self.wbb.data.average_spectrum[0] = 1\n self.wbb.data.average_spectrum[2047] = 1\n\n calibration_slope = ((warm_blackbody - cold_blackbody) /\n (self.wbb.data.average_spectrum - self.cbb.data.average_spectrum))\n calibration_offset = warm_blackbody - (self.wbb.data.average_spectrum * \n calibration_slope)\n\n self.wbb.calibrate_file(calibration_slope, calibration_offset)\n self.cbb.calibrate_file(calibration_slope, calibration_offset)\n self.sam.calibrate_file(calibration_slope, calibration_offset)\n\n if not self.dwr is None:\n self.dwr.calibrate_file(calibration_slope, calibration_offset)\n\n plate_temperature = self.dwr.header.spare_f[0]\n if (self.plate == -1) :\n plate_emissivity = self.dwr.header.spare_f[1]\n\n plate_blackbody = bb_radiance(plate_temperature + 273.15,\n self.dwr.data.wavelength)\n plate_emission = plate_emissivity * plate_blackbody\n\n self.dwr.data.average_spectrum = ((self.dwr.data.average_spectrum - \n plate_emission) / (1 - plate_emissivity))","def platform_auto_calibrate_imu(self):\n self.imu.reset_calibration()\n self.platform.auto_calibrate_magnetometer()\n self.platform.auto_calibrate_gyroscope()\n self.platform.auto_calibrate_accelerometer()","def calibrate(self, calib_fns, calib_params, analytes=None, drift_correct=False):\n # can have calibration function stored in self and pass *coefs?\n if analytes is None:\n analytes = self.analytes\n\n if 'calibrated' not in self.data.keys():\n self.data['calibrated'] = {}\n\n for a in analytes:\n if drift_correct:\n P = self.drift_params(calib_params, a)\n else:\n P = calib_params[a].values[0]\n\n self.data['calibrated'][a] = \\\n calib_fns[a](P,\n self.data['ratios'][a])\n\n # coefs = calib_params[a]\n # if len(coefs) == 1:\n # self.data['calibrated'][a] = \\\n # self.data['ratios'][a] * coefs\n # else:\n # self.data['calibrated'][a] = \\\n # np.polyval(coefs, self.data['ratios'][a])\n # self.data['ratios'][a] * coefs[0] + coefs[1]\n self.setfocus('calibrated')\n return","def calibrate(self, calibration_dict=None):\n if calibration_dict is not None:\n for i in self.POSITIONS:\n if self.version == \"standard\" and i.startswith(\"save_image__\"):\n continue\n self.POSITIONS[i] = calibration_dict[i]\n else:\n if os.path.isfile(GoogleEarthProCalibration.SETTINGS_FILE):\n print \"Using config file\"\n with open(GoogleEarthProCalibration.SETTINGS_FILE, \"r\") as gf:\n for l in gf:\n cd = l.split(\",\")\n self.POSITIONS[cd[0]] = (int(cd[1]), int(cd[2]))\n else:\n to_offset = [i for i in self.POSITIONS \\\n if i is not \"google_earth_pro_offset\"]\n for i in to_offset:\n self.POSITIONS[i] = self.offset(self.POSITIONS[i])","def save_calibration(filename):\n pass","def finalize(self):\n self._iou_ap.compute_ap_curve()\n self._pixel_ap.compute_ap_curve()\n self._azimuth_ap.compute_ap_curve()\n self._polar_ap.compute_ap_curve()","def calibrate(self):\n super().calibrate()\n dataH1 = self._bus.read_i2c_block_data(self.addr,\n self.CALIBRATION_H1, 1)\n dataHX = self._bus.read_i2c_block_data(self.addr,\n self.CALIBRATION_HX, 7)\n\n self.dig_H1 = float(c_ubyte(dataH1[0]).value)\n self.dig_H2 = float(c_short((dataHX[1] << 8) + dataHX[0]).value)\n self.dig_H3 = float(c_ubyte(dataHX[2]).value)\n self.dig_H4 = float(c_short(\n (dataHX[3] << 4) + (dataHX[4] & 0xf)).value)\n self.dig_H5 = float(c_short(\n (dataHX[5] << 4) + ((dataHX[4] & 0xf0) >> 4)).value)\n self.dig_H6 = float(c_byte(dataHX[6]).value)","def _calibrate(self, t_send, t_recv, server_timestamp):\n pass","def calibrate_meter(self):\r\n print(\"meter calibrated\")","def startAndCalibrateWalabot():\n wlbt.StartCalibration()\n print('- Calibrating...')\n while wlbt.GetStatus()[0] == wlbt.STATUS_CALIBRATING:\n wlbt.Trigger()\n wlbt.Start()\n print('- Calibration ended.\\n- Ready!')","def antenny_calibrate(self):\n if self.antenny_config.get(\"use_bno08x_rvc\"):\n t = .25\n d = .5\n us = 50\n else:\n t = .1\n d = .5\n us = 100\n self.platform.auto_calibrate_elevation_servo(us=us, t=t, d=d)\n self.platform.auto_calibrate_azimuth_servo(us=us, t=t, d=d)\n if self.antenny_config.get(\"use_bno055\"):\n self.platform.auto_calibrate_magnetometer()\n self.platform.auto_calibrate_gyroscope()\n self.platform.auto_calibrate_accelerometer()","def calibrate(self):\n\t\t\n\t\t# CALIBRATION\n\t\t# determine the calibration points\n\t\tcalibpoints = []\n\t\tfor x in [0.1,0.5,0.9]:\n\t\t\tfor y in [0.1,0.5,0.9]:\n\t\t\t\tcalibpoints.append((int(x*self.dispsize[0]),int(y*self.dispsize[1])))\n\t\trandom.shuffle(calibpoints)\n\t\t\n\t\t# show a message\n\t\tself.screen.clear()\n\t\tself.screen.draw_text(\n\t\t\ttext=\"Press Space to calibrate, S to skip, and Q to quit\",\n\t\t\tfontsize=20)\n\t\tself.disp.fill(self.screen)\n\t\tself.disp.show()\n\t\t\n\t\t# wait for keyboard input\n\t\tkey, keytime = self.kb.get_key(keylist=['q', 's', 'space'],\n\t\t\ttimeout=None, flush=True)\n\t\tif key == 's':\n\t\t\treturn True\n\t\tif key == 'q':\n\t\t\tquited = True\n\t\telse:\n\t\t\tquited = False\n\t\t\n\t\t# Pause the processing of samples during the calibration.\n#\t\tself.eyetribe._pause_sample_processing()\n\t\t# run until the user is statisfied, or quits\n\t\tcalibrated = False\n\t\tcalibresult = None\n\t\twhile not quited and not calibrated:\n\n\t\t\t# Clear the existing calibration.\n\t\t\tif self.eyetribe._tracker.get_iscalibrated():\n\t\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\t\tself.eyetribe.calibration.clear()\n\t\t\t\tself.eyetribe._lock.release()\n\t\t\t\n\t\t\t# Wait for a bit.\n\t\t\tclock.pause(1500)\n\n\t\t\t# start a new calibration\n\t\t\tif not self.eyetribe._tracker.get_iscalibrating():\n\t\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\t\tself.eyetribe.calibration.start(pointcount=len(calibpoints))\n\t\t\t\tself.eyetribe._lock.release()\n\t\t\t\n\t\t\t# loop through calibration points\n\t\t\tfor cpos in calibpoints:\n\t\t\t\t# Check whether the calibration is already done.\n\t\t\t\t# (Not sure how or why, but for some reason some data\n\t\t\t\t# can persist between calbrations, and the tracker will\n\t\t\t\t# simply stop allowing further pointstart requests.)\n\t\t\t\tif self.eyetribe._tracker.get_iscalibrated():\n\t\t\t\t\tbreak\n\t\t\t\t\n\t\t\t\t# Draw a calibration target.\n\t\t\t\tself.draw_calibration_target(cpos[0], cpos[1])\n\t\t\t\t# wait for a bit to allow participant to start looking at\n\t\t\t\t# the calibration point (#TODO: space press?)\n\t\t\t\tclock.pause(settings.EYETRIBEPRECALIBDUR)\n\t\t\t\t# start calibration of point\n\t\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\t\tself.eyetribe.calibration.pointstart(cpos[0],cpos[1])\n\t\t\t\tself.eyetribe._lock.release()\n\t\t\t\t# wait for a second\n\t\t\t\tclock.pause(settings.EYETRIBECALIBDUR)\n\t\t\t\t# stop calibration of this point\n\t\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\t\tself.eyetribe.calibration.pointend()\n\t\t\t\tself.eyetribe._lock.release()\n\t\t\t\t# check if the Q key has been pressed\n\t\t\t\tif self.kb.get_key(keylist=['q'],timeout=10,flush=False)[0] == 'q':\n\t\t\t\t\t# abort calibration\n\t\t\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\t\t\tself.eyetribe.calibration.abort()\n\t\t\t\t\tself.eyetribe._lock.release()\n\t\t\t\t\t# set quited variable and break this for loop\n\t\t\t\t\tquited = True\n\t\t\t\t\tbreak\n\t\t\t\n\t\t\t# retry option if the calibration was aborted\t\t\t\n\t\t\tif quited:\n\t\t\t\t# show retry message\n\t\t\t\tself.screen.clear()\n\t\t\t\tself.screen.draw_text(\n\t\t\t\t\t\"Calibration aborted. Press Space to restart or 'Q' to quit\",\n\t\t\t\t\tfontsize=20)\n\t\t\t\tself.disp.fill(self.screen)\n\t\t\t\tself.disp.show()\n\t\t\t\t# get input\n\t\t\t\tkey, keytime = self.kb.get_key(keylist=['q','space'], timeout=None, flush=True)\n\t\t\t\tif key == 'space':\n\t\t\t\t\t# unset quited Boolean\n\t\t\t\t\tquited = False\n\t\t\t\t# skip further processing\n\t\t\t\tcontinue\n\n\t\t\t# empty display\n\t\t\tself.disp.fill()\n\t\t\tself.disp.show()\n\t\t\t# allow for a bit of calculation time\n\t\t\t# (this is waaaaaay too much)\n\t\t\tclock.pause(1000)\n\t\t\t# get the calibration result\n\t\t\tself.eyetribe._lock.acquire(True)\n\t\t\tcalibresult = self.eyetribe._tracker.get_calibresult()\n\t\t\tself.eyetribe._lock.release()\n\n\t\t\t# results\n\t\t\t# clear the screen\n\t\t\tself.screen.clear()\n\t\t\t# draw results for each point\n\t\t\tif type(calibresult) == dict:\n\t\t\t\tfor p in calibresult['calibpoints']:\n\t\t\t\t\t# only draw the point if data was obtained\n\t\t\t\t\tif p['state'] > 0:\n\t\t\t\t\t\t# draw the mean error\n\t\t\t\t\t\t# self.screen.draw_circle(colour=(252,233,79),\n\t\t\t\t\t\t# \tpos=(p['cpx'],p['cpy']), r=p['mepix'], pw=0,\n\t\t\t\t\t\t# \tfill=True)\n\t\t\t\t\t\tself.screen.draw_line(spos=(p['cpx'],p['cpy']),\n\t\t\t\t\t\t\tepos=(p['mecpx'],p['mecpy']), pw=2)\n\t\t\t\t\t\t# draw the point\n\t\t\t\t\t\tself.screen.draw_fixation(fixtype='dot',\n\t\t\t\t\t\t\tcolour=(115,210,22), pos=(p['cpx'],p['cpy']))\n\t\t\t\t\t\t# draw the estimated point\n\t\t\t\t\t\tself.screen.draw_fixation(fixtype='dot',\n\t\t\t\t\t\t\tcolour=(32,74,135), pos=(p['mecpx'],p['mecpy']))\n\t\t\t\t\t\t# annotate accuracy\n\t\t\t\t\t\tself.screen.draw_text(text='%.2f' % p['acd'],\n\t\t\t\t\t\t\tpos=(p['cpx']+10,p['cpy']+10), fontsize=20)\n\t\t\t\t\t# if no data was obtained, draw the point in red\n\t\t\t\t\telse:\n\t\t\t\t\t\tself.screen.draw_fixation(fixtype='dot',\n\t\t\t\t\t\t\tcolour=(204,0,0), pos=(p['cpx'],p['cpy']))\n\t\t\t\t# draw box for averages\n\t\t\t\t# self.screen.draw_rect(colour=(238,238,236), x=int(self.dispsize[0]*0.15), y=int(self.dispsize[1]*0.2), w=400, h=200, pw=0, fill=True)\n\t\t\t\t# draw result\n\t\t\t\tif calibresult['result']:\n\t\t\t\t\tself.screen.draw_text(text=\"Calibration successful\",\n\t\t\t\t\t\tcolour='green',\n\t\t\t\t\t\tpos=(int(self.dispsize[0]*0.5), int(self.dispsize[1]*0.25)), \n\t\t\t\t\t\tfontsize=20)\n\t\t\t\telse:\n\t\t\t\t\tself.screen.draw_text(text=\"Calibration failed\",\n\t\t\t\t\t\tcolour='red',\n\t\t\t\t\t\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25)),\n\t\t\t\t\t\tfontsize=20)\n\t\t\t\t# draw average accuracy\n\t\t\t\tself.screen.draw_text(\n\t\t\t\t\ttext=\"Average error = %.2f degrees\" % (calibresult['deg']),\n\t\t\t\t\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25+30)),\n\t\t\t\t\tfontsize=20)\n\t\t\t\t# draw input options\n\t\t\t\tself.screen.draw_text(\n\t\t\t\t\ttext=\"Press Space to continue or 'R' to restart\",\n\t\t\t\t\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25+60)),\n\t\t\t\t\tfontsize=20)\n\t\t\telse:\n\t\t\t\tself.screen.draw_text(\n\t\t\t\t\ttext=\"Calibration failed. Press 'R' to try again.\",\n\t\t\t\t\tfontsize=20)\n\t\t\t# show the results\n\t\t\tself.disp.fill(self.screen)\n\t\t\tself.disp.show()\n\t\t\t# wait for input\n\t\t\tkey, keytime = self.kb.get_key(keylist=['space','r'], timeout=None,\n\t\t\t\tflush=True)\n\t\t\t# process input\n\t\t\tif key == 'space':\n\t\t\t\tcalibrated = True\n\n\t\t# Continue the processing of samples after the calibration.\n#\t\tself.eyetribe._unpause_sample_processing()\n\n\t\t# calibration failed if the user quited\n\t\tif quited:\n\t\t\treturn False\n\n\t\t# NOISE CALIBRATION\n\t\t# get all error estimates (pixels)\n\t\tvar = []\n\t\tfor p in calibresult['calibpoints']:\n\t\t\t# only draw the point if data was obtained\n\t\t\tif p['state'] > 0:\n\t\t\t\tvar.append(p['mepix'])\n\t\tnoise = sum(var) / float(len(var))\n\t\tself.pxdsttresh = (noise, noise)\n\t\t\t\t\n\t\t# AFTERMATH\n\t\t# store some variables\n\t\tpixpercm = (self.dispsize[0]/float(self.screensize[0]) + self.dispsize[1]/float(self.screensize[1])) / 2\n\t\tscreendist = settings.SCREENDIST\n\t\t# calculate thresholds based on tracker settings\n\t\tself.accuracy = ((calibresult['Ldeg'],calibresult['Ldeg']), (calibresult['Rdeg'],calibresult['Rdeg'])) \n\t\tself.pxerrdist = deg2pix(screendist, self.errdist, pixpercm)\n\t\tself.pxfixtresh = deg2pix(screendist, self.fixtresh, pixpercm)\n\t\tself.pxaccuracy = ((deg2pix(screendist, self.accuracy[0][0], pixpercm),deg2pix(screendist, self.accuracy[0][1], pixpercm)), (deg2pix(screendist, self.accuracy[1][0], pixpercm),deg2pix(screendist, self.accuracy[1][1], pixpercm)))\n\t\tself.pxspdtresh = deg2pix(screendist, self.spdtresh/1000.0, pixpercm) # in pixels per millisecond\n\t\tself.pxacctresh = deg2pix(screendist, self.accthresh/1000.0, pixpercm) # in pixels per millisecond**2\n\n\t\t# calibration report\n\t\tself.log(\"pygaze calibration report start\")\n\t\tself.log(\"accuracy (degrees): LX=%s, LY=%s, RX=%s, RY=%s\" % (self.accuracy[0][0],self.accuracy[0][1],self.accuracy[1][0],self.accuracy[1][1]))\n\t\tself.log(\"accuracy (in pixels): LX=%s, LY=%s, RX=%s, RY=%s\" % (self.pxaccuracy[0][0],self.pxaccuracy[0][1],self.pxaccuracy[1][0],self.pxaccuracy[1][1]))\n\t\tself.log(\"precision (RMS noise in pixels): X=%s, Y=%s\" % (self.pxdsttresh[0],self.pxdsttresh[1]))\n\t\tself.log(\"distance between participant and display: %s cm\" % screendist)\n\t\tself.log(\"fixation threshold: %s pixels\" % self.pxfixtresh)\n\t\tself.log(\"speed threshold: %s pixels/ms\" % self.pxspdtresh)\n\t\tself.log(\"acceleration threshold: %s pixels/ms**2\" % self.pxacctresh)\n\t\tself.log(\"pygaze calibration report end\")\n\n\t\treturn True","def _applyCalibration(self, ws, detPos):\n alg = self.createChildAlgorithm('ApplyCalibration')\n alg.setProperty('Workspace', ws)\n alg.setProperty('PositionTable', detPos)\n alg.execute()","def calibrate(self, eventlog, calibrate=True, validate=False):\n\n\n # # # #calculate thresholds (degrees to pixels)\n self.pxfixtresh = self._deg2pix(self.screendist, self.fixtresh, self.pixpercm)\n # in pixels per millisecons\n self.pxspdtresh = self._deg2pix(self.screendist, self.spdtresh / 1000.0, self.pixpercm)\n # in pixels per millisecond**2\n self.pxacctresh = self._deg2pix(self.screendist, self.accthresh / 1000.0, self.pixpercm)\n\n # calibration image file\n calibImg = c.CALIBIMG\n\n # initialize a sound\n snd = sound.Sound(value=c.CALIBSOUNDFILE)\n snd.setVolume(0.5)\n\n # image scaling range\n bit = 0.02\n scaleRange = ([x / 100.0 for x in range(60, 30, -2)] + [x / 100.0 for x in range(30, 60, 2)])\n\n if calibrate:\n\n if not self.eyetracker:\n print(\"WARNING! libtobii.TobiiProTracker.calibrate: no eye trackers found for the calibration!\")\n self.stop_recording()\n return False\n\n calibration = tr.ScreenBasedCalibration(self.eyetracker)\n\n calibrating = True\n calibration.enter_calibration_mode()\n\n while calibrating:\n\n eventlog.write([\"Calibration started at \", clock.get_time()])\n print \"----------> Starting calibration...\"\n\n # original (normalised) points_to_calibrate = [(0.5, 0.5), (0.9, 0.1), (0.1, 0.1), (0.9, 0.9), (0.1, 0.9)]\n # pixel values are calculated based on the normalised points. With (1920,1200):\n # self.points_to_calibrate calculated values: [(960, 600), (192, 1080), (192, 120), (1728, 1080), (1728, 120)]\n\n # calibration for all calibration points\n for i in range(0,len(self.points_to_calibrate)):\n\n point = self.points_to_calibrate[i]\n\n eventlog.write([\"\\nCalibrating point {0} at: \".format(point), clock.get_time()])\n print \"----------> Calibrating at point \", point\n\n # play the soundfile\n snd.play()\n\n # Shrink from big size to small\n scale = 1\n for frameN in range(20): # 20 frames -> 1/3 sec shrinking (180 to 108)\n\n self.c_screen.clear()\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\n drawCoreImage(self.c_screen, point, i)\n self.disp.fill(self.c_screen)\n self.disp.show()\n scale = scale - bit\n\n # shrink and grow while 'space' is pressed\n s = 0\n for frameN in range(12000): # 108 -> 54, 15 frames (1/4 s) and backwards\n\n s = frameN%30\n scale = scaleRange[s]\n self.c_screen.clear()\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\n drawCoreImage(self.c_screen, point, i)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n if self.kb.get_key(keylist=['space'],timeout=10, flush=False)[0] == 'space':\n break\n\n # collect results for point\n normalized_point = self._px_2_norm(point)\n collect_result = calibration.collect_data(normalized_point[0], normalized_point[1])\n print(\"----------> Collecting results for point \", point)\n eventlog.write([\"Collecting result for point {0} at: \".format(point), clock.get_time()])\n\n if collect_result != tr.CALIBRATION_STATUS_SUCCESS:\n eventlog.write([\"Recollecting result for point {0} at: \".format(point), clock.get_time()])\n # Try again if it didn't go well the first time.\n # Not all eye tracker models will fail at this point, but instead fail on ComputeAndApply.\n calibration.collect_data(normalized_point[0], normalized_point[1])\n\n # Shrink back to big size\n scaleUp = [x / 100.0 for x in range(int(scale*100), 100, 2)]\n for scale in scaleUp:\n self.c_screen.clear()\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\n drawCoreImage(self.c_screen, point, i)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n\n # image rolling to next point\n # pixelised self.points_to_calibrate = [(960, 600), (192, 1080), (192, 120), (1728, 1080), (1728, 120)]\n if (i < len(self.points_to_calibrate)-1):\n\n \"\"\"\n screen ratio: 16/10\n The steps for moving the images should be 16, 10 or 8, 5\n \"\"\"\n # center -> bottom left / (960, 600) -> (192, 1080) - 48 frames\n while point[0] >= self.points_to_calibrate[i+1][0]:\n self.c_screen.clear()\n point = (point[0]-16, point[1]+10)\n self.c_screen.draw_image(calibImg, pos=point)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n # bottom-left -> top-left / (192, 1080) -> (192, 120)\n # AND\n # bottom-right -> top-right / (1728, 1080) -> (1728, 120) - 80 frames\n while point[1] > self.points_to_calibrate[i+1][1]:\n self.c_screen.clear()\n point = (point[0], point[1]-12)\n self.c_screen.draw_image(calibImg, pos=point)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n # top-left -> bottom-right / (192, 120) -> (1728, 1080) - 96 frames\n while point[0] < self.points_to_calibrate[i+1][0] and not point[1] == self.points_to_calibrate[i+1][1]:\n self.c_screen.clear()\n point = (point[0]+16, point[1]+10)\n self.c_screen.draw_image(calibImg, pos=point)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n\n print(\"------------> Calculating calibration result....\")\n\n calibration_result = calibration.compute_and_apply()\n\n eventlog.write([\"\\nCompute and apply returned {0} and collected at {1} points.\\n\".\n format(calibration_result.status, len(calibration_result.calibration_points))])\n print(\"------------> Compute and apply returned {0} and collected at {1} points.\".\n format(calibration_result.status, len(calibration_result.calibration_points)))\n\n\n\n # Show image after calibration\n self.c_screen.clear()\n self.c_screen.draw_image(c.ATT_IMG)\n self.disp.fill(self.c_screen)\n self.disp.show()\n\n if calibration_result.status != tr.CALIBRATION_STATUS_SUCCESS:\n eventlog.write([\"\\n\\nWARNING! libtobii.TobiiProTracker.calibrate: Calibration was unsuccessful!\\n\\n\"])\n print \"Calibration was unsuccessful.\\nPress 'R' to recalibrate all points\\nor 'SPACE' to continue without calibration\"\n key = self.kb.get_key(keylist=['space', 'r'], timeout=None)[0]\n if key == 'r':\n recalibration_points = [0]\n elif key == 'space':\n recalibration_points = []\n\n else:\n # call showCalibrationResults function to present the results on screen 0. The function returns a list\n logfiledir = os.path.dirname(os.path.abspath(self.datafilepath))\n recalibration_points = showCalibrationResults(logfiledir, calibration_result)\n\n # if the list is empty, calibration is finished\n if len(recalibration_points) == 0:\n eventlog.write([\"\\nCalibration finished at \", clock.get_time()])\n calibrating = False\n\n # if the list contains only '0', the calibration was unsuccessful, recalibrate all points\n elif (recalibration_points[0] == 0):\n eventlog.write([\"\\nRecalibrating all points...\"])\n calibrating = True\n # if the list contains only '1', recalibrate all points despite successful calibration\n elif (recalibration_points[0] == 1):\n eventlog.write([\"\\nRecalibrating all points...\"])\n for point in self.points_to_calibrate:\n calibration.discard_data(point[0], point[1])\n calibrating = True\n # recalibrate the returned points\n else:\n eventlog.write([\"\\nRecalibrating {0} points...\".format(len(recalibration_points))])\n self.points_to_calibrate = [self._norm_2_px(p) for p in recalibration_points]\n for point in self.points_to_calibrate:\n calibration.discard_data(point[0], point[1])\n calibrating = True\n\n\n calibration.leave_calibration_mode()\n eventlog.write([\" Leaving calibration mode...\", clock.get_time()])\n self.stop_recording()\n self._write_enabled = True\n self.disp.close()","def imu_calibrate(self):\n self.imu.calibrate_accelerometer()\n self.imu.calibrate_gyroscope()\n self.imu.calibrate_magnetometer()","def set_calibration(self, req):\n\n cmd = req.command\n data = json.loads(req.json)\n if cmd == \"add\":\n if \"x\" in data and \"y\" in data and \"z\" in data:\n x, y, z = float(data[\"x\"]), float(data[\"y\"]), float(data[\"z\"])\n self.add(Point(x, y, z))\n else:\n return False\n elif cmd == \"edit\":\n if \"x\" in data and \"y\" in data and \"z\" in data:\n x, y, z = float(data[\"x\"]), float(data[\"y\"]), float(data[\"z\"])\n self.edit(Point(x, y, z))\n else:\n return False\n elif cmd == \"goto\":\n self.goto(speed=float(data[\"speed\"]) if \"speed\" in data else 1.0)\n elif cmd == \"save\":\n self.save()\n elif cmd == \"cancel\":\n self.load()\n elif cmd == \"safe_goto\":\n self.safe_goto(\n speed=float(\n data[\"speed\"]) if \"speed\" in data else 1.0, distance=float(\n data[\"distance\"]) if \"distance\" in data else SAFETY_DISTANCE)\n elif cmd == \"record\":\n self.record()\n elif cmd == \"remove\":\n self.remove()\n elif cmd == \"set_selected_point\" and \"index\" in data:\n self.set_selected_point(int(data[\"index\"]))\n else:\n RosProxy().notify(\"Invalid calibration input\", STATE.ERROR)\n return False\n\n return True","def save_calibration(self):\n\n path = './{}/'.format(self.controller)\n # Check if path exist, if not, creates it.\n if not os.path.exists(os.path.dirname(path)):\n try:\n os.makedirs(os.path.dirname(path))\n except OSError as exc:\n # Guard against race condition\n if exc.errno != errno.EEXIST:\n raise\n\n # Save Jacobian matrix (self.mat)\n with open(\"./{i}/mat.txt\".format(i=self.controller), 'wt') as f:\n for i in range(3):\n f.write('{a},{b},{c}\\n'.format(a=self.mat[i, 0], b=self.mat[i, 1], c=self.mat[i, 2]))\n\n # Save rotational matrix\n with open(\"./{i}/rotmat.txt\".format(i=self.controller), 'wt') as f:\n for i in range(3):\n f.write('{a},{b},{c}\\n'.format(a=self.rot[i, 0], b=self.rot[i, 1], c=self.rot[i, 2]))\n\n # Save other data\n with open('./{i}/data.txt'.format(i=self.controller), 'wt') as f:\n f.write('{d}\\n'.format(d=self.um_px))\n f.write('{d}\\n'.format(d=self.x_init))\n f.write('{d}\\n'.format(d=self.y_init))\n f.write('{d}\\n'.format(d=self.template_loc[0]))\n f.write('{d}\\n'.format(d=self.template_loc[1]))","def create_calibration_path(Env):\n \n hotpixelkiller = Env.create_path('hotpixelkiller')\n hotpixelkiller.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': rawfile_air }) \n hotpixelkiller.add_processor(name=\"M26HotPixelKiller\")\n\n cluster_calibrator_mc = Env.create_path('cluster_calibrator_mc')\n cluster_calibrator_mc.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': rawfile_air }) \n cluster_calibrator_mc.add_processor(name=\"M26Clusterizer\")\n cluster_calibrator_mc.add_processor(name=\"M26CogHitMaker\")\n cluster_calibrator_mc.add_processor(name=\"M26ClusterCalibrationFromMC\")\n\n clusterizer = Env.create_path('clusterizer')\n clusterizer.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': rawfile_air }) \n clusterizer.add_processor(name=\"M26Clusterizer\")\n clusterizer.add_processor(name=\"LCIOOutput\")\n\n correlator = Env.create_path('correlator')\n correlator.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n correlator.add_processor(name=\"M26CogHitMaker\")\n correlator.add_processor(name=\"RawDQM\") \n correlator.add_processor(name=\"TelCorrelator\")\n \n kalman_aligner_1 = Env.create_path('kalman_aligner_1')\n kalman_aligner_1.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n kalman_aligner_1.add_processor(name=\"M26CogHitMaker\")\n kalman_aligner_1.add_processor(name=\"AlignTF_LC\")\n kalman_aligner_1.add_processor(name=\"PreAligner\")\n \n kalman_aligner_2 = Env.create_path('kalman_aligner_2')\n kalman_aligner_2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n kalman_aligner_2.add_processor(name=\"M26CogHitMaker\")\n kalman_aligner_2.add_processor(name=\"AlignTF_TC\")\n kalman_aligner_2.add_processor(name=\"TelAligner\")\n \n telescope_dqm = Env.create_path('telescope_dqm')\n telescope_dqm.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n telescope_dqm.add_processor(name=\"M26CogHitMaker\")\n telescope_dqm.add_processor(name=\"AlignTF_TC\")\n telescope_dqm.add_processor(name=\"TelescopeDQM\")\n \n cluster_calibration_1 = Env.create_path('cluster_calibration_1')\n cluster_calibration_1.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \"tmp.slcio\" }) \n cluster_calibration_1.add_processor(name=\"M26CogHitMaker\") \n cluster_calibration_1.add_processor(name=\"AlignTF_TC\")\n cluster_calibration_1.add_processor(name=\"M26ClusterCalibrator\")\n \n kalman_aligner_3 = Env.create_path('kalman_aligner_3')\n kalman_aligner_3.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n kalman_aligner_3.add_processor(name=\"M26GoeHitMaker\")\n kalman_aligner_3.add_processor(name=\"AlignTF_TC\")\n kalman_aligner_3.add_processor(name=\"TelAligner\")\n \n cluster_calibration_2 = Env.create_path('cluster_calibration_2')\n cluster_calibration_2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \"tmp.slcio\" }) \n cluster_calibration_2.add_processor(name=\"M26GoeHitMaker\") \n cluster_calibration_2.add_processor(name=\"AlignTF_TC\")\n cluster_calibration_2.add_processor(name=\"M26ClusterCalibrator\")\n\n correlator2 = Env.create_path('correlator2')\n correlator2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" })\n correlator2.add_processor(name=\"M26GoeHitMaker\") \n correlator2.add_processor(name=\"RawDQM\", params={'RootFileName': 'RawDQM2.root'})\n correlator2.add_processor(name=\"TelCorrelator\", params={'OutputRootFileName': 'XCorrelator2.root'})\n \n kalman_aligner_4 = Env.create_path('kalman_aligner_4')\n kalman_aligner_4.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n kalman_aligner_4.add_processor(name=\"M26GoeHitMaker\") \n kalman_aligner_4.add_processor(name=\"AlignTF_LC\")\n kalman_aligner_4.add_processor(name=\"PreAligner\")\n \n kalman_aligner_5 = Env.create_path('kalman_aligner_5')\n kalman_aligner_5.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \"tmp.slcio\" }) \n kalman_aligner_5.add_processor(name=\"M26GoeHitMaker\") \n kalman_aligner_5.add_processor(name=\"AlignTF_TC\")\n kalman_aligner_5.add_processor(name=\"TelAligner\") \n \n telescope_dqm2 = Env.create_path('telescope_dqm2')\n telescope_dqm2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \"tmp.slcio\" }) \n telescope_dqm2.add_processor(name=\"M26GoeHitMaker\") \n telescope_dqm2.add_processor(name=\"AlignTF_TC\")\n telescope_dqm2.add_processor(name=\"TelescopeDQM\", params={'RootFileName' : 'TelescopeDQM2.root'})\n \n \n # create sequence of calibration paths \n calpath= [ hotpixelkiller , \n cluster_calibrator_mc,\n clusterizer,\n correlator, \n kalman_aligner_1, \n kalman_aligner_2, \n kalman_aligner_2, \n kalman_aligner_2, \n telescope_dqm, \n cluster_calibration_1, \n kalman_aligner_3, \n kalman_aligner_3, \n kalman_aligner_3, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2, \n cluster_calibration_2,\n correlator2, \n kalman_aligner_4, \n kalman_aligner_5, \n kalman_aligner_5, \n kalman_aligner_5, \n telescope_dqm2, \n ]\n \n return calpath","def __init__(self, dev, **kw):\n AutomaticCalibrationRoutine.__init__(\n self,\n dev=dev,\n **kw,\n )\n\n self.final_init(**kw)","def calibrate(\n self, acc: np.ndarray, gyr: np.ndarray, acc_unit: Optional[str], gyr_unit: Optional[str]\n ) -> Tuple[np.ndarray, np.ndarray]:\n raise NotImplementedError(\"This method needs to be implemented by a subclass\")","def _calibrate_without_loss(self, calib_dataset, calib_batch_size,\n calib_steps):\n # Create quantize calibration model\n if not self._optimized_model:\n logger.error(\n 'Should call `optimize_model()` before `_calibrate_without_loss`.')\n self._qcb_model, self._layer_metadata = self._quantizer.create_quantize_model(\n self._optimized_model,\n candidate_layers=self._candidate_layers,\n layer_metadata=self._layer_metadata,\n quantize_strategy=self._quantize_strategy,\n mode='QCB',\n target=self._target,\n dataset=calib_dataset,\n batch_size=calib_batch_size,\n steps=calib_steps,\n specific_layers=self._specific_layers)\n\n if calib_dataset is not None:\n logger.info(\"Start Quantize Calibration...\")\n collector = self._run_model_with_collector(self._qcb_model, calib_dataset,\n calib_batch_size, calib_steps)\n\n # Create quantize calibration evaluation model\n self._qcbev_model = model_utils.clone_model_with_weights(self._qcb_model)\n model_utils.set_layer_mode(self._qcbev_model, 'QCBEV')\n\n if type(self._quantize_strategy\n ) == vitis_pof2s_quantize_strategy.VitisPof2SQuantizeStrategy:\n # Freeze the quantize info into the model, now using most_common_quantize_info\n # last_quantize_info = collector.get_last_quantize_info()\n common_quantize_info = collector.get_most_common_quantize_info()\n self._freeze_quantize_info(common_quantize_info)\n elif type(self._quantize_strategy) in [\n vitis_fs_quantize_strategy.VitisFSQuantizeStrategy,\n vitis_fsx_quantize_strategy.VitisFSXQuantizeStrategy,\n vitis_gpu_quantize_strategy.VitisGPUQuantizeStrategy\n ]:\n # Freeze the quantize info into the model, now using most_common_quantize_info\n # last_quantize_info = collector.get_last_quantize_info()\n common_quantize_info = collector.get_entropy_percentile_amax(\n self._qcb_model)\n self._freeze_quantize_info(common_quantize_info)\n\n logger.info(\"Quantize Calibration Done.\")","def go_calib():\n\n ####################\n #\n # Calibration files:\n # everything created under calib/\n #\n ####################\n # Darks - created in subdir darks/\n # - darks needed to make bad pixel mask\n # - store the resulting dark in the file name that indicates the\n # integration time (2.8s) and the coadds (10ca).\n # -- If you use the OSIRIS image, you must include the full filename in the list. \n darkFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(23, 27+1)]\n calib.makedark(darkFiles, 'dark_39.832s_1ca_6rd.fits', instrument=osiris)\n\n darkFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(28, 32+1)]\n calib.makedark(darkFiles, 'dark_5.901s_1ca_4rd.fits', instrument=osiris)\n\n darkFiles = ['i200822_s020{0:03d}_flip'.format(ii) for ii in range(2, 10+1)]\n calib.makedark(darkFiles, 'dark_11.802s_4ca_4rd.fits', instrument=osiris)\n\n darkFiles = ['i200822_s021{0:03d}_flip'.format(ii) for ii in range(2, 10+1)]\n calib.makedark(darkFiles, 'dark_5.901s_8ca_1rd.fits', instrument=osiris)\n\n # Flats - created in subdir flats/\n offFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(3, 21+1, 2)]\n onFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(4, 22+1, 2)]\n calib.makeflat(onFiles, offFiles, 'flat_kp_tdOpen.fits', instrument=osiris)\n\n # Masks (assumes files were created under calib/darks/ and calib/flats/)\n calib.makemask('dark_39.832s_1ca_6rd.fits', 'flat_kp_tdOpen.fits',\n 'supermask.fits', instrument=osiris)","def _read_calibration_data(self):\n #Declare global variables.\n global calT1\n global calT2\n global calT3\n global calP1\n global calP2\n global calP3\n global calP4\n global calP5\n global calP6\n global calP7\n global calP8\n global calP9\n global calP10\n global calH1\n global calH2\n global calH3\n global calH4\n global calH5\n global calH6\n global calH7\n global calGH1\n global calGH2\n global calGH3\n global calResHeatRange\n global calResHeatVal\n global calRangeSwErr\n\n #Temperature calibration.\n calT1 = self._read_2bytes_as_ushort_lsbfirst(self.BME680_T1_LSB_REG)\n calT2 = self._read_2bytes_as_short_lsbfirst(self.BME680_T2_LSB_REG)\n calT3 = self._read_register_1sbyte(self.BME680_T3_REG)\n\n #Pressure calibration.\n calP1 = self._read_2bytes_as_ushort_lsbfirst(self.BME680_P1_LSB_REG)\n calP2 = self._read_2bytes_as_short_lsbfirst(self.BME680_P2_LSB_REG)\n calP3 = self._read_register_1sbyte(self.BME680_P3_REG)\n calP4 = self._read_2bytes_as_short_lsbfirst(self.BME680_P4_LSB_REG)\n calP5 = self._read_2bytes_as_short_lsbfirst(self.BME680_P5_LSB_REG)\n calP6 = self._read_register_1sbyte(self.BME680_P6_REG)\n calP7 = self._read_register_1sbyte(self.BME680_P7_REG)\n calP8 = self._read_2bytes_as_short_lsbfirst(self.BME680_P8_LSB_REG)\n calP9 = self._read_2bytes_as_short_lsbfirst(self.BME680_P9_LSB_REG)\n calP10 = self._read_register_1ubyte(self.BME680_P10_REG)\n\n #Humidity calibration.\n calH1 = self._read_register_1ubyte(self.BME680_H1_MSB_REG) << 4 | (self._read_register_1ubyte(self.BME680_H1_LSB_REG) & 0x0F)\n calH2 = self._read_register_1ubyte(self.BME680_H2_MSB_REG) << 4 | ((self._read_register_1ubyte(self.BME680_H2_LSB_REG)) >> 4)\n calH3 = self._read_register_1sbyte(self.BME680_H3_REG)\n calH4 = self._read_register_1sbyte(self.BME680_H4_REG)\n calH5 = self._read_register_1sbyte(self.BME680_H5_REG)\n calH6 = self._read_register_1ubyte(self.BME680_H6_REG)\n calH7 = self._read_register_1sbyte(self.BME680_H7_REG)\n\n #Gas calibration.\n calGH1 = self._read_register_1sbyte(self.BME680_GH1_REG)\n calGH2 = self._read_2bytes_as_short_lsbfirst(self.BME680_GH2_LSB_REG)\n calGH3 = self._read_register_1sbyte(self.BME680_GH3_REG)\n\n #Heat calibration.\n calResHeatRange = (self._read_register_1ubyte(self.BME680_RES_HEAT_RANGE) & 0x30) / 16\n calResHeatVal = self._read_register_1sbyte(self.BME680_RES_HEAT_VAL)\n calRangeSwErr = (self._read_register_1sbyte(self.BME680_RANGE_SW_ERR) & 0xF0) / 16","def load_cal(self):\n global DEBUG, dtParameterDesc\n if DEBUG:\n print(self.__class__.__name__+'.load_cal(): calibration is loaded')\n if 'refatt' in self.parameters and 'refoutpower' in self.parameters:\n self.parameters['refatt'] = dtParameterDesc['refatt']['default']\n self.parameters['refoutpower'] = dtParameterDesc['refoutpower']['default']","def calibration_wheel(self):\n self.spectrum = self.spectrum","def arm_calibration(self):\n # DONE: 3. Implement the arm calibration movement by fixing the code below (it has many bugs). It should to this:\n # Command the arm_motor to run forever in the positive direction at max speed.\n # Create an infinite while loop that will block code execution until the touch sensor's is_pressed value is True.\n # Within that loop sleep for 0.01 to avoid running code too fast.\n # Once past the loop the touch sensor must be pressed. So stop the arm motor quickly using the brake stop action.\n # Make a beep sound\n # Now move the arm_motor 14.2 revolutions in the negative direction relative to the current location\n # Note the stop action and speed are already set correctly so we don't need to specify them again\n # Block code execution by waiting for the arm to finish running\n # Make a beep sound\n # Set the arm encoder position to 0 (the last line below is correct to do that, it's new so no bug there)\n\n # Code that attempts to do this task but has MANY bugs (nearly 1 on every line). Fix them!\n self.arm_motor.run_forever(speed_sp=900)\n while not self.touch_sensor.is_pressed:\n time.sleep(0.01)\n self.arm_motor.stop(stop_action='brake')\n ev3.Sound.beep().wait()\n # time.sleep(2)\n # arm_motor.stop(stop_action='brake')\n\n arm_revolutions_for_full_range = 14.2 * 360\n self.arm_motor.run_to_rel_pos(position_sp=-arm_revolutions_for_full_range, speed_sp=900)\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\n ev3.Sound.beep()\n self.arm_motor.position = 0 # Calibrate the down position as 0 (this line is correct as is).","def get_calib_data(self):\n\n accel_offset_read = self.con.receive(registers.ACCEL_OFFSET_X_LSB_ADDR, 6)\n accel_offset_read_x = (accel_offset_read[1] << 8) | accel_offset_read[\n 0] # Combine MSB and LSB registers into one decimal\n accel_offset_read_y = (accel_offset_read[3] << 8) | accel_offset_read[\n 2] # Combine MSB and LSB registers into one decimal\n accel_offset_read_z = (accel_offset_read[5] << 8) | accel_offset_read[\n 4] # Combine MSB and LSB registers into one decimal\n\n accel_radius_read = self.con.receive(registers.ACCEL_RADIUS_LSB_ADDR, 2)\n accel_radius_read_value = (accel_radius_read[1] << 8) | accel_radius_read[0]\n\n mag_offset_read = self.con.receive(registers.MAG_OFFSET_X_LSB_ADDR, 6)\n mag_offset_read_x = (mag_offset_read[1] << 8) | mag_offset_read[\n 0] # Combine MSB and LSB registers into one decimal\n mag_offset_read_y = (mag_offset_read[3] << 8) | mag_offset_read[\n 2] # Combine MSB and LSB registers into one decimal\n mag_offset_read_z = (mag_offset_read[5] << 8) | mag_offset_read[\n 4] # Combine MSB and LSB registers into one decimal\n\n mag_radius_read = self.con.receive(registers.MAG_RADIUS_LSB_ADDR, 2)\n mag_radius_read_value = (mag_radius_read[1] << 8) | mag_radius_read[0]\n\n gyro_offset_read = self.con.receive(registers.GYRO_OFFSET_X_LSB_ADDR, 6)\n gyro_offset_read_x = (gyro_offset_read[1] << 8) | gyro_offset_read[\n 0] # Combine MSB and LSB registers into one decimal\n gyro_offset_read_y = (gyro_offset_read[3] << 8) | gyro_offset_read[\n 2] # Combine MSB and LSB registers into one decimal\n gyro_offset_read_z = (gyro_offset_read[5] << 8) | gyro_offset_read[\n 4] # Combine MSB and LSB registers into one decimal\n\n calib_data = {'accel_offset': {'x': accel_offset_read_x, 'y': accel_offset_read_y, 'z': accel_offset_read_z}, 'accel_radius': accel_radius_read_value,\n 'mag_offset': {'x': mag_offset_read_x, 'y': mag_offset_read_y, 'z': mag_offset_read_z}, 'mag_radius': mag_radius_read_value,\n 'gyro_offset': {'x': gyro_offset_read_x, 'y': gyro_offset_read_y, 'z': gyro_offset_read_z}}\n\n return calib_data","def initialise_calibration(self):\n for i in range(0, self.NUM_SENSORS):\n self.calibratedMax[i] = 0\n self.calibratedMin[i] = self.READING_TIMEOUT","def calib_raw(self, calib_func=\"kidsdata.kids_calib.get_calfact\", clean_raw=False, **kwargs):\n\n if getattr(self, \"__calib\", None) is None:\n self.__log.debug(\"calibration using {}\".format(calib_func))\n self.__check_attributes([\"I\", \"Q\"], read_missing=False)\n\n fmod = self.fmod\n mod_mask = self.mod_mask\n\n # Check about the 3rd bit and the fix_masq keyword\n if np.any(mod_mask & (1 << 2)) and kwargs.get(\"fix_masq\") is True:\n self.__log.error(\"fix_masq should not be used when 3rd bit is set\")\n\n self.__log.info(\"Calibrating with fmod={} and {}\".format(fmod, kwargs))\n calib_func = _import_from(calib_func)\n self.__calib = calib_func(self.I, self.Q, mod_mask, fmod=fmod, **kwargs)\n\n else:\n self.__log.error(\"calibrated data already present\")\n\n # Expand keys :\n # Does not double memory, but it will not be possible to\n # partially free memory : All attribute read at the same time\n # must be deleted together\n for ckey in self.__calib.keys():\n self.__dict__[ckey] = self.__calib[ckey]\n\n if clean_raw:\n self._clean_data(\"_KidsRawData__dataSd\")","def test_calibrate(self):\n from astropy.io.fits import Header\n command = '{0} -r {1}'.format(\n os.path.join(self.datadir,\n 'monol_testA_nustar_fpma_ev' + HEN_FILE_EXTENSION),\n os.path.join(self.datadir, 'test.rmf'))\n hen.calibrate.main(command.split())\n new_filename = os.path.join(self.datadir,\n 'monol_testA_nustar_fpma_ev_calib' +\n HEN_FILE_EXTENSION)\n assert os.path.exists(new_filename)\n ev = hen.io.load_events(new_filename)\n assert hasattr(ev, 'header')\n\n Header.fromstring(ev.header)\n assert hasattr(ev, 'gti')\n gti_to_test = hen.io.load_events(self.first_event_file).gti\n assert np.allclose(gti_to_test, ev.gti)","def determine_calibration(func):\r\n calibrate_file = path.abspath(path.join(path.dirname(__file__), \"./cam_param_py2.pickle\"))\r\n # print (calibrate_file,\"--------------------\")\r\n def calibrate_judger(*args, **kwargs):\r\n if path.exists(calibrate_file):\r\n print('Camera has been calibrated, loading parameter file ... ')\r\n with open(calibrate_file) as cal_file:\r\n calibration = pickle.load(cal_file)\r\n else:\r\n print('Computing camera calibration ... ')\r\n calibration = func(*args, **kwargs)\r\n with open(calibrate_file, 'w') as cal_file:\r\n pickle.dump(calibration, cal_file, protocol=2)\r\n print('Camera calibration complete.')\r\n # print(calibration)\r\n return calibration\r\n return calibrate_judger","def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:","def set_calibration(self, measured_air_pressure, actual_air_pressure):\n measured_air_pressure = int(measured_air_pressure)\n actual_air_pressure = int(actual_air_pressure)\n\n self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_SET_CALIBRATION, (measured_air_pressure, actual_air_pressure), 'i i', '')","def calibrate(self):\n self.camera.camera_open()\n while True:\n img = self.camera.frame\n if img is not None:\n img_copy = img.copy()\n img_h, img_w = img.shape[:2]\n\n white_key_width = int(img_w / 10)\n white_key_bottom = int(img_h / 8)\n black_key_bottom = img_h - int(img_h / 3)\n key_top = img_h - white_key_bottom\n\n # Draw All Keys\n for i in self.key_map.values():\n # TODO: I think key_top and key_bottom are swapped\n cv2.line(img, (white_key_width*i, key_top),\n (white_key_width*i, white_key_bottom),\n (0, 0, 200), 1)\n\n cv2.line(img, (0, black_key_bottom),\n (img_w, black_key_bottom),\n (0, 0, 200), 1)\n\n cv2.imshow('Align Frame', img)\n key = cv2.waitKey(1)\n if key == ESCAPE_KEY:\n break\n\n self.img_h = img_h\n self.img_w = img_w\n self.white_key_width = white_key_width\n self.white_key_bottom = white_key_bottom\n self.black_key_bottom = black_key_bottom\n self.key_top = key_top\n self.latest_img = img_copy\n\n self.camera.camera_close()\n cv2.destroyAllWindows()","def calibrate(\n model: onnx.ModelProto, dataset: List[Dict[str, np.ndarray]]\n) -> Dict[str, Tuple[float, float]]:\n augmented_model = ONNXCalibrator(model).build_calibration_model()\n return calibrator.calibrate(augmented_model, dataset)","def proz(): \r\n print(\"processing: \",CURDATA()[0]) \r\n Check_180turn(left_boundary,right_boundary)\r\n EF() #exponential window multiplication + fourier\r\n APK0() #1. Phase correction 0th Ordnung\r\n APK1() #1. Phase correction 1st Ordnung\r\n ABS() #Baseline correction\r\n APK()\r\n ABS() #Baseline correction\r\n Check_180turn(left_boundary,right_boundary)","def calibrate(self, dataset: Iterable[Dict[str, np.ndarray]]) -> Dict[str, Tuple[float, float]]:\n return calibrate(self.model, dataset)","def __call__(self, data):\n cal = self.calc()\n assert data.shape == cal.shape, \\\n \"data shape does not match calibration ({} != {})\".format(data.shape, cal.shape)\n return data * cal","def start_calibration(self):\n self.socket.send_string('C')\n return self.socket.recv_string()","def handle_alive(event):\n\n formation = event.sender\n formation.calibrate()","def calibrate_file(self, filename, custom_file, out_dir, overwrite_rad, overwrite_ref):\n # check for valid rad file\n valid = self.get_rad_file(filename, out_dir, overwrite_rad)\n\n if valid:\n # valid rad file\n print('calibrating' + filename)\n\n out_filename = self.rad_to_ref(out_dir)\n if not overwrite_ref:\n # if we don't want to overwrite existing files, we can skip this file if it already exists\n if os.path.exists(out_filename) and os.path.isfile(out_filename):\n print(out_filename + \" already exists, skipping\")\n return\n\n # now choose values based on exp time\n values = self.choose_values(custom_file)\n if values is None:\n return\n if self.total_files == 1:\n self.update_progress(25)\n # then calibrate by dividing by values\n new_values = self.do_division(values)\n if self.total_files == 1:\n self.update_progress(75)\n # convolve\n final_values = self.do_multiplication(new_values)\n # replace saturated channels that are too large for PDS fixed-width with 0s\n final_values = np.where(abs(final_values) > 10E20, 0, final_values)\n\n # rename rad to ref to get outfile name and then write to file\n write_final(out_filename, self.wavelength, final_values)\n\n # check for original label\n original_label = self.get_original_label(filename)\n if os.path.exists(original_label):\n # write new label based on original\n (path, label_name) = os.path.split(original_label)\n new_label_filename = label_name.replace('PSV', 'REF')\n new_label_filename = new_label_filename.replace('psv', 'ref')\n new_label_filename = new_label_filename.replace('lbl', 'xml')\n (out_path, filename) = os.path.split(out_filename)\n new_label = os.path.join(out_path, new_label_filename)\n write_label(new_label, original_label, False)\n\n if self.total_files == 1:\n self.update_progress(100)\n\n print(filename + ' calibrated and written to ' + out_filename)","def calibrate(self):\n if not self._calibrate:\n raise ValueError(\"calibrate parameter must be set\")\n\n if self.calibration_samples >= self._max_samples:\n return self._camera\n\n frame = self.capture()\n left = frame.images[0]\n right = frame.images[1]\n\n ret_l, corners_l = left.features\n ret_r, corners_r = right.features\n\n if self._last_timestamp is None:\n self._last_timestamp = frame.timestamp\n\n if ret_l is True and ret_r is True and (frame.timestamp - self._last_timestamp).total_seconds() > self._frame_delay:\n self.objpoints.append(self.objp)\n self.imgpoints_l.append(corners_l)\n self.imgpoints_r.append(corners_r)\n\n self.calibration_samples += 1\n self._last_timestamp = frame.timestamp\n\n if self.calibration_samples >= self._max_samples:\n img_shape = left.image.shape[::-1]\n self._camera = self._finish_calibration(self.objpoints, self.imgpoints_l, self.imgpoints_r, img_shape)\n return self._camera","def set_calibration(is_profile):\n\n\n print(\"No calibration could be extracted from the file metadata\\n Please enter calibration paramters\")\n \n pixel_size = validate_calibration(\"Please enter a pixel size (in angstroms) e.g. 14.1\\n\",\"pixel_size\")\n \n wavelength = validate_calibration(\"Please enter beam wavelength (in microns) e.g. .02354\\n\",\"wavelength\") \n\n if not is_profile: \n camera_dist = validate_calibration(\"Please enter camera distance from sample (in millimeters) e.g. 223.1\\n\",\"camera distance\")\n else:\n camera_dist = 0\n\n return { \"pixel_size\": pixel_size,\n \"wavelength\": wavelength,\n \"camera_distance\": camera_dist}","def tune(self, occupation_1, occupation_2, res=1e-3, calibrate_nr=3, plot=False):\n # initialize variables\n self.occupation_1_f = occupation_1\n self.occupation_2_f = occupation_2\n\n # direction variable defines where the next frame is drawn\n # direction == 0: lower right corner (i.e. right)\n # direction == 1: upper right corner (i.e. top-right)\n # direction == 2: upper left corner (i.e. up)\n direction = 1\n found = False\n reverse = False # if charge occupation too high, go back\n counter = 0 # length of path in frames\n\n print('Start tuning Charge States.')\n self.PG1['n_pts'] = self.f + 2 * self.p + 1\n self.PG2['n_pts'] = self.f + 2 * self.p + 1\n\n while not found:\n # define measurement variables\n self.PG1['stop'] = self.trans_path_x[-1] - (self.p + 0.5) * res\n self.PG1['start'] = self.trans_path_x[-1] + (self.f + self.p + 0.5) * res\n self.PG2['stop'] = self.trans_path_y[-1] - (self.p + 0.5) * res\n self.PG2['start'] = self.trans_path_y[-1] + (self.f + self.p + 0.5) * res\n\n # overwrite when necessary\n if reverse:\n if direction == 0:\n self.PG1['stop'] = self.trans_path_x[-1] - (self.f + self.p + 0.5) * res\n self.PG1['start'] = self.trans_path_x[-1] + (self.p + 0.5) * res\n if direction == 2:\n self.PG2['stop'] = self.trans_path_y[-1] - (self.f + self.p + 0.5) * res\n self.PG2['start'] = self.trans_path_y[-1] + (self.p + 0.5) * res\n\n # add starting point for plotting reasons\n self.trans_frame_start.append((self.PG1['start'], self.PG2['start']))\n\n # define mean PG values for QPC calibration\n self.PG2['mean'] = self.PG2['start'] + (self.PG2['stop'] - self.PG2['start']) / 2.\n self.PG1['mean'] = self.PG1['start'] + (self.PG1['stop'] - self.PG1['start']) / 2.\n\n # update charge occupation into list\n self.occupation.append((self.occupation_1, self.occupation_2))\n\n # update path to take\n if direction == 0:\n if not reverse:\n self.trans_path_x.append(self.trans_path_x[-1] + self.f * res)\n self.trans_path_y.append(self.trans_path_y[-1])\n else:\n self.trans_path_x.append(self.trans_path_x[-1] - self.f * res)\n self.trans_path_y.append(self.trans_path_y[-1])\n\n elif direction == 1:\n if not reverse:\n self.trans_path_x.append(self.trans_path_x[-1] + self.f * res)\n self.trans_path_y.append(self.trans_path_y[-1] + self.f * res)\n else: # this is never True - just for completeness\n self.trans_path_x.append(self.trans_path_x[-1] - self.f * res)\n self.trans_path_y.append(self.trans_path_y[-1] - self.f * res)\n\n elif direction == 2:\n if not reverse:\n self.trans_path_x.append(self.trans_path_x[-1])\n self.trans_path_y.append(self.trans_path_y[-1] + self.f * res)\n else:\n self.trans_path_x.append(self.trans_path_x[-1])\n self.trans_path_y.append(self.trans_path_y[-1] - self.f * res)\n\n # Print path number and what points the path links\n print('\\n###################\\n'\n 'Path: {}\\n'\n 'PG1: {} -> {}\\n'\n 'PG2: {} -> {}'.format(counter,\n round(self.trans_path_x[-2], 3), round(self.trans_path_x[-1], 3),\n round(self.trans_path_y[-2], 3), round(self.trans_path_y[-1], 3)))\n\n # define measurement object\n output_path = os.path.join(self.path_out, 'tune_' + str(counter))\n measurement = ScriptTools.MeasurementObject(\n self.path_in,\n output_path\n )\n\n # recalibrate QPC every calibrate_nr frames\n if counter % calibrate_nr == calibrate_nr - 1 or self.sweet_spot is None:\n calibrate = True\n gate_config = None\n\n else:\n calibrate = False\n gate_config = {\n self.gate_names['QPC_G']: self.sweet_spot\n }\n\n # get the measured QPC signal and reshape it\n measurement_signal = self.get_data_(measurement, output_path, DQD_log_channel=self.gate_names['I_DQD'],\n calibrate=calibrate, rescale=True, config=gate_config)\n self.trans_frames.append(measurement_signal['I_QPC'])\n I_DQD = measurement_signal['I_DQD']\n reshaped_signal = self.trans_frames[-1].reshape((1, self.f + 2*self.p, self.f + 2*self.p, 1))\n\n # check whether there is a current through the dot, if so - abort\n # TODO introduce threshold as a variable\n if self.is_current_(I_DQD, 7e-12):\n print('There is too much current through the dot. Tuning stopped.\\n'\n 'Last PG values:\\n'\n 'PG1: {}\\n'\n 'PG2: {}'.format(self.trans_path_x[-1], self.trans_path_y[-1]))\n break\n\n # Make the predictions\n # (QD1 transition, QD2 transition)\n # transition[i] == [1, 0, 0, 0]: (False, False)\n # transition[i] == [0, 1, 0, 0]: (False, True)\n # transition[i] == [0, 0, 1, 0]: (True, False)\n # transition[i] == [0, 0, 0, 1]: (True, True)\n # for i in {0, 1, 2}\n transition = self.trans_rec.predict(reshaped_signal)\n self.trans_classif.append(transition)\n\n # Check whether there is a contradiction. If there is one,\n # measure the same frame again and redo the classifications.\n is_contra = self.is_contradiction_(transition)\n if is_contra:\n print('There is a contradiction.\\n'\n '{}'.format(transition))\n # Remeasure the frame.\n self.trans_frames.append(\n self.get_data_(measurement, output_path, calibrate=calibrate, config=gate_config)['I_QPC'])\n # Redo the classifications\n reshaped_signal = self.trans_frames[-1].reshape((1, self.f + 2 * self.p, self.f + 2 * self.p, 1))\n transition = self.trans_rec.predict(reshaped_signal)\n\n # check again whether there is still a contradiction\n if self.is_contradiction_(transition):\n print('There is still a contradiction. Proceed anyways.')\n else:\n print('There is no contradiction anymore. Proceed as normal.')\n\n # plot the data\n if plot:\n pass\n # grid = plt.GridSpec(20, 20)\n # fig = plt.figure()\n # ax = plt.subplot(grid[:20, :20])\n # axins1 = inset_axes(ax,\n # width=\"3%\",\n # height=\"100%\",\n # loc='lower left',\n # bbox_to_anchor=(1.01, 0., 1, 1),\n # bbox_transform=ax.transAxes,\n # borderpad=0,\n # )\n #\n # im1 = ax.pcolormesh(self.trans_frames[-1][:, :], linewidth=0, rasterized=True)\n # cbar = fig.colorbar(im1, cax=axins1)\n # ax.axhline(y=self.p, color='black', linewidth=2)\n # ax.axhline(y=self.f+self.p, color='black', linewidth=2)\n # ax.axvline(x=self.p, color='black', linewidth=2)\n # ax.axvline(x=self.f+self.p, color='black', linewidth=2)\n # ax.plot(self.trans_path_x[-1], self.trans_path_y[-1])\n # ax.set_ylim(0, self.f+2*self.p)\n # ax.set_xlim(0, self.f+2*self.p)\n # plt.title('Path {}'.format(counter))\n # plt.show()\n\n # Trigger charge transitions\n if np.argmax(transition[direction]) == 0: # no transition at all\n print('No transition.\\n'\n 'Confidence: {}\\n'\n 'Current charge occupation({},{})'.format(np.max(transition[direction]),\n self.occupation_1, self.occupation_2))\n elif np.argmax(transition[direction]) == 1: # transition in QD2\n if not reverse:\n self.occupation_2 += 1\n else:\n self.occupation_2 -= 1\n print('Transition in QD2.\\n'\n 'Confidence: {}\\n'\n 'Current charge occupation({},{})'.format(np.max(transition[direction]),\n self.occupation_1, self.occupation_2))\n elif np.argmax(transition[direction]) == 2: # transision in QD1\n if not reverse:\n self.occupation_1 += 1\n else:\n self.occupation_1 -= 1\n print('Transition in QD1.\\n'\n 'Confidence: {}\\n'\n 'Current charge occupation({},{})'.format(np.max(transition[direction]),\n self.occupation_1, self.occupation_2))\n elif np.argmax(transition[direction]) == 3: # transition in both QDs\n if not reverse:\n self.occupation_2 += 1\n self.occupation_1 += 1\n else:\n self.occupation_2 -= 1\n self.occupation_1 -= 1\n print('Transition in both QDs.\\n'\n 'Confidence: {}\\n'\n 'Current charge occupation({},{})'.format(np.max(transition[direction]),\n self.occupation_1, self.occupation_2))\n\n # define where to go based on current charge occupation\n if self.occupation_1 < self.occupation_1_f and self.occupation_2 < self.occupation_2_f:\n direction = 1\n reverse = False\n print('-> Going up right.')\n\n elif self.occupation_1 == self.occupation_1_f and self.occupation_2 < self.occupation_2_f:\n direction = 2\n reverse = False\n print('-> Going up.')\n\n elif self.occupation_1 < self.occupation_1_f and self.occupation_2 == self.occupation_2_f:\n direction = 0\n reverse = False\n print('-> Going right.')\n\n # go back, if one of the dots has too many electrons\n elif self.occupation_1 > self.occupation_1_f:\n direction = 0\n reverse = True\n print('-> Going left.')\n\n elif self.occupation_2 > self.occupation_2_f:\n direction = 2\n reverse = True\n print('-> Going down.')\n\n # Terminate if desired charge configuration is reached\n elif self.occupation_1 == self.occupation_1_f and self.occupation_2 == self.occupation_2_f:\n print('\\nTuning successful\\n'\n 'PG1: {}V\\n'\n 'PG2: {}V'.format(self.trans_path_x[-1], self.trans_path_y[-1]))\n found = True\n\n if counter >= 15:\n print('Could not find desired charge configuration.\\n'\n 'Program stopped.')\n found = True\n\n counter += 1","def _read_calibration_data(self):\n #Declare global variables.\n global calDig_T1\n global calDig_T2\n global calDig_T3\n global calDig_P1\n global calDig_P2\n global calDig_P3\n global calDig_P4\n global calDig_P5\n global calDig_P6\n global calDig_P7\n global calDig_P8\n global calDig_P9\n global calDig_H1\n global calDig_H2\n global calDig_H3\n global calDig_H4\n global calDig_H5\n global calDig_H6\n\n #Temperature calibration\n calDig_T1 = self._read_2bytes_as_ushort_lsbfirst(self.BME280_DIG_T1)\n calDig_T2 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_T2)\n calDig_T3 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_T3)\n\n #Pressure calibration\n calDig_P1 = self._read_2bytes_as_ushort_lsbfirst(self.BME280_DIG_P1)\n calDig_P2 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P2)\n calDig_P3 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P3)\n calDig_P4 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P4)\n calDig_P5 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P5)\n calDig_P6 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P6)\n calDig_P7 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P7)\n calDig_P8 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P8)\n calDig_P9 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P9)\n\n #Humidity calibration\n calDig_H1 = self._read_register_1sbyte(self.BME280_DIG_H1)\n calDig_H2 = self._read_2bytes_as_ushort_lsbfirst(self.BME280_DIG_H2)\n calDig_H3 = self._read_register_1sbyte(self.BME280_DIG_H3)\n calDig_H4 = (self._read_register_1sbyte(self.BME280_DIG_H4) << 4) | (self._read_register_1sbyte(self.BME280_DIG_H4 + 1) & 0xF)\n calDig_H5 = self._read_register_1sbyte((self.BME280_DIG_H5 + 1) << 4) | (self._read_register_1sbyte(self.BME280_DIG_H5) >> 4)\n calDig_H6 = self._read_register_1sbyte(self.BME280_DIG_H6)","def calibrate(self):\n\t\twl = BLi.getWavelength()\n\t\tif abs(self.stokes()) <= .5:\n\t\t\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\n\t\t\tself.offset2(-xxx)\n\t\t\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\n\t\t\tself.offset4(yyy)\n\t\t\tself.offset9(self.dettrans())\n\t\telif abs(self.stokes()-90.) <= .5:\n\t\t\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\n\t\t\tself.offset3(-xxx)\n\t\t\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\n\t\t\tself.offset8(yyy)\n\t\t\tself.offset10(self.dettrans())\n\t\telse:\n\t\t\tprint \"Can't calibrate at stokes=\",self.stokes()\n\t\treturn [self.sign(),self.offset2(), self.offset3(),self.offset4(),self.offset5(),self.offset8(),self.offset9(),self.offset10()]","def calibration_changed(self):\n\n for marker in self.marker_array.markers:\n marker.action = Marker.DELETE\n\n for idx, pose in enumerate(self.poses):\n marker = Marker()\n marker.id = int(str(int(round(time.time() * 1000)) + idx)[6:])\n marker.header.frame_id = Calibration.marker_workpiece_frame\n marker.type = Marker.SPHERE\n marker.action = Marker.ADD\n marker.scale.x = Calibration.marker_size\n marker.scale.y = Calibration.marker_size\n marker.scale.z = Calibration.marker_size\n marker.color.a = 1.0\n marker.color = ColorRGBA(a=1, r=1, g=0, b=0) if\\\n idx == self.selected_point else ColorRGBA(a=1, r=1, g=1, b=0)\n marker.pose.orientation.w = 1.0\n marker.pose.position = pose.model\n self.marker_array.markers.append(marker)\n\n RosProxy().publish_topic(\n \"calibration_markers\", MarkerArray, self.marker_array, latch=True)\n\n # Keep only the added markers\n self.marker_array.markers = [\n marker for marker in self.marker_array.markers if marker.action == Marker.ADD]\n\n calibration_msg = CalibrationMsg(\n points=self.poses,\n selected_point=-\n 1 if self.selected_point is None else self.selected_point,\n transformation=np.append([], self.transformation_matrix))\n\n RosProxy().publish_topic(\n \"calibration_points\", CalibrationMsg, calibration_msg, latch=True)\n\n RobotControllerHandler().set_transformation(self.transformation_matrix)","def safe_calibrate(self):\n\n status = -1\n while status < 3:\n ifMutexAcquire(self.use_mutex)\n try:\n new_status = self.BNO055.get_calibration_status()[3]\n except:\n new_status = -1\n finally:\n ifMutexRelease(self.use_mutex)\n if new_status != status:\n status = new_status","def __init__(self, poses=None, selected_point=None):\n super(Calibration, self).__init__(\"calibration\")\n\n self.marker_array = MarkerArray()\n if selected_point is None:\n selected_point = 0\n\n if poses is not None:\n self.poses = poses\n else:\n self.load()\n\n self.selected_point = None if len(self.poses) == 0 else selected_point\n self.calibration_changed()\n RosProxy().advertise_service(\"set_calibration\", SetService, self.set_calibration)","def calibrate(self):\n self.current_state = \"calibrate\"\n self.next_state = \"idle\"\n self.kinect.loadCameraCalibration()\n # location_strings = [\"lower left corner of board\",\n # \"upper left corner of board\",\n # \"upper right corner of board\",\n # \"lower right corner of board\",\n # \"center of shoulder motor\"]\n img = cv2.cvtColor(self.kinect.VideoFrame, cv2.COLOR_RGB2GRAY)\n img = cv2.resize(img, (640, 480))\n detector = apriltag(\"tagStandard41h12\", decimate=1.0)\n result = detector.detect(img)\n if len(result) < 4:\n seen_april = [i['id'] for i in result]\n occd_april = [str(i) for i in range(4) if i not in seen_april]\n self.status_message = \"April tags Occluded: {}\".format(\n ', '.join(occd_april))\n print(f\"April tags occluded: {', '.join(occd_april)}\")\n time.sleep(2)\n return\n for i in range(4):\n self.kinect.rgb_click_points[i] = result[i]['lb-rb-rt-lt'][(4-i)%4]\n # print(\"Result april:\\n\", self.kinect.rgb_click_points)\n # Uncomment below to redo affine\n # for j in range(5):\n # self.status_message = \"Calibration - Click %s in RGB image\" % location_strings[j]\n # while (self.kinect.new_click == False):\n # time.sleep(.1)\n # self.kinect.rgb_click_points[j] = self.kinect.last_click.copy()\n # self.kinect.new_click = False\n # print(\"Result manual:\\n\", self.kinect.rgb_click_points)\n # i = 0\n # for j in range(5):\n # self.status_message = \"Calibration - Click %s in depth image\" % location_strings[j]\n # while (self.kinect.new_click == False):\n # time.sleep(.1)\n # self.kinect.depth_click_points[i] = self.kinect.last_click.copy()\n # self.kinect.new_click = False\n # self.kinect.getAffineTransform(\n # self.kinect.depth_click_points, self.kinect.rgb_click_points)\n\n \"\"\"TODO Perform camera calibration here\"\"\"\n world_coords = np.array([[-0.297, -0.2876, 0], [-0.297, 0.3183, 0],\n [0.307, 0.3183, 0], [0.3067, -0.2876, 0], [0.0, 0.083, 0.225]])\n self.status_message = \"Calibration - Creating Extrinsic\"\n rgb_click_points_SI = np.float32(self.kinect.rgb_click_points)\n self.kinect.createExtrinsicCamMat(world_coords, rgb_click_points_SI)\n self.status_message = \"Calibration - Completed Calibration\"\n self.kinect.kinectCalibrated = True\n cv2.imwrite('depthframergb.jpg', self.kinect.DepthFrameRGB)\n cv2.imwrite('depthframeraw.jpg', self.kinect.DepthFrameRaw)\n cv2.imwrite('videoframe.jpg', self.kinect.VideoFrame)\n time.sleep(1)","def arm_calibration(self):\n self.arm_motor.run_forever(speed_sp=self.MAX_SPEED)\n while not self.touch_sensor.is_pressed:\n time.sleep(0.01)\n self.arm_motor.stop()\n ev3.Sound.beep().wait()\n arm_revolutions_for_full_range = 14.2 * 360\n self.arm_motor.run_to_rel_pos(\n position_sp=-arm_revolutions_for_full_range,\n speed_sp=self.MAX_SPEED,\n stop_action=ev3.Motor.STOP_ACTION_BRAKE)\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\n\n self.arm_motor.position = 0 # Calibrate the down position as 0 (this\n # line is correct as is).","def get_calibration(self):\n return GetCalibration(*self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_CALIBRATION, (), '', 'i i'))","def steering_calibration(self):\n\n # Minimum change of rotary encoder per 100 ms to detect stall\n min_difference = 5\n # Calibration motor power in percentage (absolute)\n calibration_power = 30\n\n print('Calibration of steering axis started')\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n last_pos = 99999999 # any super big number\n # Left turn calibration\n while abs(current_pos - last_pos) > min_difference:\n last_pos = current_pos\n self.brick_pi.set_motor_power(self.motor_steer, calibration_power)\n time.sleep(0.1)\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n\n self.brick_pi.set_motor_power(self.motor_steer, 0)\n time.sleep(0.1)\n print('Reset motor encoder after left turn: 0')\n self.brick_pi.reset_motor_encoder(self.motor_steer)\n\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n last_pos = 99999999 # any super big number\n # Right turn calibration\n while abs(current_pos - last_pos) > min_difference:\n last_pos = current_pos\n self.brick_pi.set_motor_power(self.motor_steer, -calibration_power)\n time.sleep(0.1)\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\n\n self.brick_pi.set_motor_power(self.motor_steer, 0)\n time.sleep(0.1)\n self.brick_pi.offset_motor_encoder(self.motor_steer, current_pos / 2)\n self.steering_limit = abs(\n self.brick_pi.get_motor_encoder(self.motor_steer))\n print('Offset motor encoder after right turn: ' +\n str(self.brick_pi.get_motor_encoder(self.motor_steer)))\n\n self.brick_pi.set_motor_position(self.motor_steer, 0)\n print('Calibration of steering axis completed')","def calibration(exp, args):\n show_text(\"Nous allons faire un calibrage\", args).present()\n exp.clock.wait(1500)\n expyriment.stimuli.FixCross(size=(25, 25),\n line_width=3,\n colour=args[\"stimuli_color\"]).present()\n exp.clock.wait(2100)","def apply_calib(fix_dir, tprobs, run, hour, exper=1, smooth=1, wd=''):\n\n # Apply smoothing\n calib_probs = gaussian_filter(tprobs, smooth, mode='constant')\n\n # Apply calibration\n run_str = str(run).zfill(2)\n in_dir = f'{fix_dir}/calib_files/{exper}/{run_str}_{hour}.pkl'\n\n with open(in_dir, 'rb') as f:\n corr_data = pickle.load(f, encoding='latin1')\n\n for index in np.ndindex(calib_probs.shape):\n this_forecast = calib_probs * 100\n if this_forecast[index] < 5:\n bin = 0\n elif this_forecast[index] >= 5 and this_forecast[index] < 15:\n bin = 10\n elif this_forecast[index] >= 15 and this_forecast[index] < 25:\n bin = 20\n elif this_forecast[index] >= 25 and this_forecast[index] < 35:\n bin = 30\n elif this_forecast[index] >= 35 and this_forecast[index] < 45:\n bin = 40\n elif this_forecast[index] >= 45 and this_forecast[index] < 55:\n bin = 50\n elif this_forecast[index] >= 55 and this_forecast[index] < 65:\n bin = 60\n elif this_forecast[index] >= 65 and this_forecast[index] < 75:\n bin = 70\n elif this_forecast[index] >= 75 and this_forecast[index] < 85:\n bin = 80\n elif this_forecast[index] >= 85:\n bin = 90\n\n calib_probs[index] = calib_probs[index] + (corr_data[index][bin] / 100.)\n calib_probs = calib_probs.astype(float)\n \n # Set anything less than 0 after calibration to 0\n calib_probs[calib_probs < 0] = 0\n \n return calib_probs","def selfcal_apcal(imc, trial='1'):\n flagmanager(imc.vislf, mode='restore', versionname='startup')\n applycal(vis=imc.vislf,\n spwmap=np.zeros(54),\n interp='linearPDperobs',\n gaintable=[imc.path_base+'.pcal'+trial],\n calwt=False,\n flagbackup=False)","def preCalibrate(self):\n self._write_enabled = False\n self.start_recording()\n\n origin = (int(self.disp.dispsize[0] / 4), int(self.disp.dispsize[1] / 4))\n size = (int(2 * self.disp.dispsize[0] / 4), int(2 * self.disp.dispsize[1] / 4))\n\n videoFile = os.path.join(c.CALIBVIDEODIR, \"--- cal_movie_1.mov\")\n\n # Initialise a PsychoPy MovieStim\n mov = visual.MovieStim3(self.video_win, videoFile, flipVert=False)\n\n print(\"------------> Pre-calibration process started.\")\n print(\"------------> When correctly positioned press \\'space\\' to start the calibration.\")\n\n while mov.status != visual.FINISHED:\n if not self.gaze:\n continue\n\n self.screen.clear()\n\n # Add the MovieStim to a PyGaze Screen instance.\n self.screen.screen.append(mov)\n\n gaze_sample = copy.copy(self.gaze[-1])\n\n validity_colour = (255, 0, 0)\n\n if gaze_sample['right_gaze_origin_validity'] and gaze_sample['left_gaze_origin_validity']:\n left_validity = 0.15 < gaze_sample['left_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\n right_validity = 0.15 < gaze_sample['right_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\n if left_validity and right_validity:\n validity_colour = (0, 255, 0)\n\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0] + size[0], origin[1]), pw=1)\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0], origin[1] + size[1]), pw=1)\n self.screen.draw_line(colour=validity_colour,\n spos=(origin[0], origin[1] + size[1]),\n epos=(origin[0] + size[0], origin[1] + size[1]),\n pw=1)\n self.screen.draw_line(colour=validity_colour,\n spos=(origin[0] + size[0], origin[1] + size[1]),\n epos=(origin[0] + size[0], origin[1]),\n pw=1)\n\n right_eye, left_eye, distance = None, None, []\n if gaze_sample['right_gaze_origin_validity']:\n distance.append(round(gaze_sample['right_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\n right_pos = gaze_sample['right_gaze_origin_in_trackbox_coordinate_system']\n right_eye = ((1 - right_pos[0]) * size[0] + origin[0], right_pos[1] * size[1] + origin[1])\n self.screen.draw_circle(colour=validity_colour,\n pos=right_eye,\n r=int(self.disp.dispsize[0] / 100),\n pw=5,\n fill=True)\n\n if gaze_sample['left_gaze_origin_validity']:\n distance.append(round(gaze_sample['left_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\n left_pos = gaze_sample['left_gaze_origin_in_trackbox_coordinate_system']\n left_eye = ((1 - left_pos[0]) * size[0] + origin[0], left_pos[1] * size[1] + origin[1])\n self.screen.draw_circle(colour=validity_colour,\n pos=left_eye,\n r=int(self.disp.dispsize[0] / 100),\n pw=5,\n fill=True)\n\n self.screen.draw_text(text=\"Current distance to the eye tracker: {0} cm.\".format(self._mean(distance)),\n pos=(int(self.disp.dispsize[0] / 2), int(self.disp.dispsize[1] * 0.9)),\n colour=(255, 255, 255),\n fontsize=20)\n\n self.disp.fill(self.screen)\n self.disp.show()\n\n key = self._getKeyPress()\n if key == \"space\":\n break\n\n\n\n if mov.status != visual.FINISHED:\n # pause and discard video for the audio to stop as well\n mov.pause()\n self.screen.screen.remove(mov)\n #video_win.close()\n del mov\n self.screen.clear()\n clock.pause(1000)\n return True\n else:\n return False","def calibrer(self):\n self._angle_courant = self._angle_initial\n self.angle(self._angle_initial)","def recalibrate_start(self):\n self.epoch += 1\n self.initialize()\n self.recalibration_i = 0\n\n if self.vr_from_epoch is not None and self.epoch >= self.vr_from_epoch:\n for group in self.param_groups:\n for p in group['params']:\n param_state = self.state[p]\n param_state['gavg'].zero_()\n param_state['m2'].zero_()\n\n # xk is changed to the running_x\n p.data.zero_().add_(param_state['running_x'])\n param_state['tilde_x'] = p.data.clone()","async def test_calibrate_gripper(\n decoy: Decoy,\n ot3_hardware_api: OT3API,\n _mock_ot3_calibration: None,\n params_probe: CalibrateGripperParamsJaw,\n expected_hc_probe: GripperProbe,\n) -> None:\n subject = CalibrateGripperImplementation(hardware_api=ot3_hardware_api)\n\n params = CalibrateGripperParams(jaw=params_probe)\n decoy.when(\n await ot3_calibration.calibrate_gripper_jaw(\n ot3_hardware_api, probe=expected_hc_probe\n )\n ).then_return(Point(1.1, 2.2, 3.3))\n\n result = await subject.execute(params)\n assert result == CalibrateGripperResult(jawOffset=Vec3f(x=1.1, y=2.2, z=3.3))","def calibrate(this, display=False, **kargs): # C'est des maths.\n\t\t# a -> Angle Alpha\n\t\t# b -> Angle Beta\n\t\t\n\t\th = float(kargs.get('h', 1))\n\t\tw = float(kargs.get('w', 1))\n\t\t\n\t\t# Verif de l'espace\n\t\tspace = this._SPACE\n\t\tif not space: return None\n\t\t\n\t\t#try:\n\t\ttry:\n\t\t\n\t\t\t# Calcul d'angles\n\t\t\ta = this._FOV.x * (space.i - space.o)\n\t\t\tb = this._FOV.x * (space.o - space.j)\n\t\t\n\t\t\t# On essaye gentillement\n\t\t\tCa = w - h / math.tan(b)\n\t\t\tCb = h - w / math.tan(a)\n\t\t\tkx = Ca/Cb\n\t\t\t\n\t\t\t# Position finale\n\t\t\tthis._POS.x = x = h * (kx + 1 / math.tan(b)) / (1 + kx**2)\n\t\t\tthis._POS.y = x * kx\n\t\t\n\t\t# Erm\n\t\texcept: this._POS = None\n\t\t\n\t\t# Petit affichage oklm\n\t\tif display: print 'Calibration: %f %f %s' % (math.degrees(a), math.degrees(b), ~this._POS)\n\t\treturn this._POS","def rerun_calibrator(base_dir):\n import infer_sequence\n # base_dir = 'data/batch4'\n collection_dir = 'calib_data'\n calib = Calibrator().init_from_data(os.path.join(base_dir, collection_dir))\n # calib.gen_calib_parameters()\n calib.show_images()","def platform_auto_calibrate_elevation_servo(self):\n self._platform_auto_calibrate_check()\n self.platform.auto_calibrate_elevation_servo()","def calibrate(self):\n with completion_context(\"Estimating sensor offset\", color=\"c\", bright=True):\n # Reset calibration\n self._sens_offset = np.zeros(4) # last two entries are never calibrated but useful for broadcasting\n self._wait_for_pole_at_rest()\n\n # Create parts of the calibration controller\n go_right = QQubeGoToLimCtrl(positive=True, cnt_done=int(1.5 / self._dt))\n go_left = QQubeGoToLimCtrl(positive=False, cnt_done=int(1.5 / self._dt))\n go_center = QQubePDCtrl(self.spec)\n\n # Estimate alpha offset. Go to both limits for theta calibration.\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\n while not go_right.done:\n meas = self._qsoc.snd_rcv(go_right(to.from_numpy(meas)))\n while not go_left.done:\n meas = self._qsoc.snd_rcv(go_left(to.from_numpy(meas)))\n self._sens_offset[0] = (go_right.th_lim + go_left.th_lim) / 2\n\n # Estimate alpha offset\n self._wait_for_pole_at_rest()\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\n self._sens_offset[1] = meas[1]\n\n print_cbt(\n f\"Sensor offset: \"\n f\"theta = {self._sens_offset[0]*180/np.pi:.3f} deg, \"\n f\"alpha = {self._sens_offset[1]*180/np.pi:.3f} deg\",\n \"g\",\n )\n\n with completion_context(\"Centering cube\", color=\"c\", bright=True):\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\n while not go_center.done:\n meas = self._qsoc.snd_rcv(go_center(to.from_numpy(meas - self._sens_offset)))","def __init__(self):\n self._read_calibration_data()\n self.configure_sensor(\n TemperatureOversamplings.x08,\n PressureOversamplings.x16,\n HumidityOversamplings.x08,\n IIRFilterCoefficients.FC_003,\n 250,\n 250)","def calibrate(self, cal=1.0, pol_eff=1.0):\n \n if self.ncomp == 1:\n self.data *= cal\n else:\n self.data[0] *= cal\n self.data[1] *= cal * pol_eff\n self.data[2] *= cal * pol_eff\n\n return self","def updateParameters(self):\r\n\r\n\t\tif self.approach.altered:\r\n\t\t\tself.transform.enabled = True\r\n\r\n\t\t\tif self.approach.value == 'Locations in the DEM generated from field observations':\r\n\t\t\t\tself.predefined_pattern.enabled = False\r\n\t\t\t\tself.pattern_workspace.enabled = False\r\n\t\t\t\tself.point_matrix_size.enabled = True\r\n\t\t\t\tself.point_vectors.enabled = True\r\n\t\t\t\tself.mapping_field.enabled = True\r\n\t\t\t\tself.move_to_max.enabled = True\r\n\t\t\t\tself.output_sim_matrix.enabled = True\r\n\t\t\t\tself.mh_dil_val.enabled = False\r\n\r\n\t\t\t\tself.mh_iteration.enabled = False\r\n\t\t\t\tself.mh_iteration.value = False\r\n\t\t\t\tself.output_table.enabled = False\r\n\t\t\t\tself.output_raster_workspace.enabled = False\r\n\t\t\t\tself.output_raster_workspace.value = ''\r\n\r\n\t\t\telif self.approach.value == 'Locations in the DEM versus pre-defined pattern':\r\n\t\t\t\tself.predefined_pattern.enabled = True\r\n\t\t\t\tself.point_matrix_size.enabled = True\r\n\t\t\t\tself.point_vectors.enabled = True\r\n\t\t\t\tself.mapping_field.enabled = True\r\n\t\t\t\tself.move_to_max.enabled = True\r\n\t\t\t\tself.mh_dil_val.enabled = True\r\n\t\t\t\tself.mh_iteration.enabled = True\r\n\t\t\t\tself.output_table.enabled = True\r\n\t\t\t\tself.output_sim_matrix.enabled = False\r\n\t\t\t\tself.output_sim_matrix.value = ''\r\n\t\t\t\tself.output_raster_workspace.enabled = False\r\n\t\t\t\tself.output_raster_workspace.value = ''\r\n\r\n\t\t\telse: # seek pre-defined pattern in DEM\r\n\t\t\t\tself.predefined_pattern.enabled = True\r\n\t\t\t\tself.point_matrix_size.enabled = True\r\n\t\t\t\tself.mh_iteration.enabled = True\r\n\t\t\t\tself.output_raster_workspace.enabled = True\r\n\t\t\t\tself.point_vectors.enabled = False\r\n\t\t\t\tself.point_vectors.value = ''\r\n\t\t\t\tself.mapping_field.enabled = False\r\n\t\t\t\tself.move_to_max.enabled = False\r\n\t\t\t\tself.move_to_max.value = False\r\n\t\t\t\tself.mh_dil_val.enabled = True\r\n\t\t\t\tself.output_sim_matrix.enabled = False\r\n\t\t\t\tself.output_sim_matrix.value = ''\r\n\t\t\t\tself.output_table.enabled = False\r\n\t\t\t\tself.output_table.value = ''\r\n\r\n\t\tif self.mh_iteration.altered:\r\n\r\n\t\t\tif self.mh_iteration.value is True:\r\n\t\t\t\tself.mh_dil_start.enabled = True\r\n\t\t\t\tself.mh_dil_stop.enabled = True\r\n\t\t\t\tself.mh_dil_step.enabled = True\r\n\t\t\t\tself.mh_dil_val.enabled = False\r\n\t\t\t\tself.mh_dil_val.value = 1\r\n\r\n\t\t\telse:\r\n\t\t\t\tif self.approach.value == 'Locations in the DEM generated from field observations':\r\n\t\t\t\t\tself.mh_dil_val.enabled = False\r\n\t\t\t\t\tself.mh_dil_val.value = 1\r\n\t\t\t\telse:\r\n\t\t\t\t\tself.mh_dil_val.enabled = True\r\n\r\n\t\t\t\tself.mh_dil_start.enabled = False\r\n\t\t\t\tself.mh_dil_stop.enabled = False\r\n\t\t\t\tself.mh_dil_step.enabled = False\r\n\t\t\t\tself.mh_dil_start.value = 0.01\r\n\t\t\t\tself.mh_dil_stop.value = 1\r\n\t\t\t\tself.mh_dil_step.value = 0.1\r\n\r\n\t\tif self.move_to_max.altered:\r\n\t\t\tif self.move_to_max.value is True:\r\n\t\t\t\tself.move_to_max_distance.enabled = True\r\n\t\t\telse:\r\n\t\t\t\tself.move_to_max_distance.enabled = False\r\n\t\t\t\tself.move_to_max_distance.value = 3\r\n\r\n\t\tif self.transform.altered:\r\n\t\t\tif self.transform.value == 'Work directly on the elevation matrix':\r\n\t\t\t\tself.size_of_the_cell.enabled = False\r\n\t\t\telif self.transform.value == 'Perform a local translation':\r\n\t\t\t\tself.size_of_the_cell.enabled = False\r\n\t\t\telif self.transform.value == 'Compute slopes' or self.transform.value == \\\r\n\t\t\t\t\t'Compute slopes and perform local translation':\r\n\t\t\t\tself.size_of_the_cell.enabled = True\r\n\r\n\t\tif self.predefined_pattern.altered:\r\n\t\t\tif self.predefined_pattern.value == 'Custom pattern':\r\n\t\t\t\tself.pattern_workspace.enabled = True\r\n\r\n\t\t\t\tself.mh_iteration.value = False\r\n\t\t\t\tself.mh_iteration.enabled = False\r\n\t\t\t\tself.mh_dil_start.enabled = False\r\n\t\t\t\tself.mh_dil_stop.enabled = False\r\n\t\t\t\tself.mh_dil_step.enabled = False\r\n\t\t\t\tself.mh_dil_start.value = 0.01\r\n\t\t\t\tself.mh_dil_stop.value = 1\r\n\t\t\t\tself.mh_dil_step.value = 0.1\r\n\t\t\t\tself.mh_dil_val.enabled = False\r\n\t\t\t\tself.mh_dil_val.value = 1\r\n\t\t\telse:\r\n\t\t\t\tself.pattern_workspace.enabled = False","def calibrate(raw_data, white_reference, dark_reference):\n # Auto-increment device\n params.device += 1\n\n # Collect the number of wavelengths present\n num_bands = len(white_reference.wavelength_dict)\n den = white_reference.array_data - dark_reference.array_data\n\n # Calibrate using reflectance = (raw data - dark reference) / (white reference - dark reference)\n output_num = []\n for i in range(0, raw_data.lines):\n ans = raw_data.array_data[i,].astype(np.float16) - dark_reference.array_data\n output_num.append(ans)\n num = np.stack(output_num, axis=2)\n output_calibrated = []\n for i in range(0, raw_data.lines):\n ans1 = raw_data.array_data[i,] / den\n output_calibrated.append(ans1)\n\n # Reshape into hyperspectral datacube\n scalibrated = np.stack(output_calibrated, axis=2)\n calibrated_array = np.transpose(scalibrated[0], (1, 0, 2))\n calibrated_array[np.where(calibrated_array < 0)] = 0\n\n # Find array min and max values\n max_pixel = float(np.amax(calibrated_array))\n min_pixel = float(np.amin(calibrated_array))\n\n # Make a new class instance with the calibrated hyperspectral image\n calibrated = Spectral_data(array_data=calibrated_array, max_wavelength=raw_data.max_wavelength,\n min_wavelength=raw_data.min_wavelength, max_value=max_pixel, min_value=min_pixel,\n d_type=raw_data.d_type,\n wavelength_dict=raw_data.wavelength_dict, samples=raw_data.samples,\n lines=raw_data.lines, interleave=raw_data.interleave,\n wavelength_units=raw_data.wavelength_units, array_type=raw_data.array_type,\n pseudo_rgb=None, filename=None, default_bands=raw_data.default_bands)\n\n # Make pseudo-rgb image for the calibrated image\n calibrated.pseudo_rgb = _make_pseudo_rgb(spectral_array=calibrated)\n\n if params.debug == \"plot\":\n # Gamma correct pseudo_rgb image\n plot_image(calibrated.pseudo_rgb)\n elif params.debug == \"print\":\n print_image(calibrated.pseudo_rgb, os.path.join(params.debug_outdir, str(params.device) + \"_calibrated_rgb.png\"))\n\n return calibrated","def calibrateAutoGuider(self, exposureLengthSeconds):\n\n print \"Calibrating autoguider orientation...\"\n self.camera.GuiderCalibrate(exposureLengthSeconds)\n while self.camera.GuiderRunning:\n sys.stdout.write(\".\")\n time.sleep(1)\n print\n print \"Calibration finished\"","def rm_calibration(self):\n\n self.bin_edges_kev = None","def train_calibration(config):\n run_dates = pd.date_range(start=config.start_dates[\"train\"],\n end=config.end_dates[\"train\"],\n freq='1D').strftime(config.run_date_format)\n \n target_calib_models = {}\n print()\n print('Loading Data')\n\n for size_index,size in enumerate(config.size_threshold):\n target_calib_models[size] = {}\n train_files, target_files = [], []\n for date in run_dates: \n train_data_files = glob(config.train_data_path+ \\\n \"20{2}/netcdf/*{0}*unsmoothed*_{1}_*{2}*{3}*{4}.nc\".format(\n config.forecast_model_names,size,date,\n config.start_hour,config.end_hour))\n if len(train_data_files) < 1:\n continue\n if config.sector:\n target_data_files = glob(config.target_data_path+'{0}*{1}*{2}*.nc'.format(\n date,size,config.sector)) \n else:\n target_data_files = glob(config.target_data_path+'{0}*{1}*.nc'.format(\n date,size))\n if len(target_data_files) < 1:\n continue\n train_files.append(train_data_files[0])\n target_files.append(target_data_files[0])\n \n date_indices = [index for index in range(len(train_files))]\n percent_train_indices = int(len(train_files)*0.70)\n t_data = [Dataset(x).variables[\"Data\"][:] for x in train_files] \n tar_data = [Dataset(x).variables[\"24_Hour_All_12z_12z\"][:] for x in target_files] \n print()\n print('Number of files:')\n print('Train (70%): {0}'.format(int(len(t_data)*0.70)))\n print('Validate (30%): {0}'.format(int(len(t_data)*0.30)))\n print()\n for ind,model_name in enumerate(config.calibration_model_names):\n bs = []\n random_models = []\n print('Random Cross-Validation, {0} >{1}mm'.format(model_name,size)) \n random_seed = random.sample(range(1, 100), 10)\n for s,seed in enumerate(random_seed):\n np.random.seed(seed)\n print('Index',s, 'Random Seed', seed)\n train_indices = np.random.choice(date_indices, percent_train_indices, replace=False)\n test_indices = [ind for ind in date_indices if ind not in train_indices]\n \n train_data = np.array(t_data)[train_indices].ravel()\n target_train_data = np.array(tar_data)[train_indices].ravel()\n \n val_data = np.array(t_data)[test_indices].ravel()\n target_val_data = np.array(tar_data)[test_indices].ravel()\n \n model = deepcopy(config.calibration_model_objs[ind])\n model.fit(train_data,target_train_data)\n random_models.append(model)\n \n predict = model.transform(val_data)\n \n #plt.figure(figsize=(9, 6))\n #plt.plot(sorted(val_data),model.transform(sorted(val_data)))\n #plt.xlabel('data')\n #plt.ylabel('calibrated')\n #plt.show()\n #plt.close()\n\n print(brier_score(predict, target_val_data))\n bs.append(brier_score(predict, target_val_data))\n \n best_bs = np.argmin(bs)\n target_calib_models[size][model_name] = np.array(random_models)[best_bs]\n print('Lowest Brier Score: {0}'.format(np.array(bs)[best_bs]))\n print()\n print()\n return target_calib_models","def _calibration_test(self, dataset_name):\n self.setup_flags()\n test_setup = self._get_setup(dataset_name)\n if test_setup[\"error_test\"]:\n self._calibration_error_test(dataset_name, \"Calibration\")\n else:\n self.run_app(\"Calibration\")\n record = parse_calibration_results(\n self.io_args.log_dir, bin_name=\"Calibration\"\n )\n self.check_metrics(record, test_setup)","def Update(self, time, val):\n self['data'] = self.owner['calibrationCurve'](val)\n self['time'] = time\n\n if self.owner.SAVE:\n self.File.write('%f , %f\\n' %(time, self['data'][-1] ))","def handle_calibrate_button(button_state, robot):\n if button_state:\n robot.arm_calibration()","def read_images_gen_cal(self, path: str) -> dict:\n image_files = []\n # read in all image paths (for png and jpgs)\n image_files.extend(glob.glob(os.path.join(path, '*.png')))\n image_files.extend(glob.glob(os.path.join(path, '*.jpg')))\n\n if len(image_files) <= 0:\n raise FileNotFoundError('Could not find any image files for camera calibration (png, jppgs supported!')\n\n # preparation of the 'real world' points like in CarND-Camera-Calibration repository ipynb!\n syn_objp = np.zeros((self._chessboard_shape[1] * self._chessboard_shape[0], 3), np.float32)\n syn_objp[:, :2] = np.mgrid[0:self._chessboard_shape[0], 0:self._chessboard_shape[1]].T.reshape(-1, 2)\n\n # Arrays to store all points pairs from the images. They will be used for calibration computation.\n objpoints = []\n imgpoints = []\n img_size = None\n\n for file_name in image_files:\n img = cv2.imread(file_name)\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\n # remember shape of images\n if img_size is None:\n img_size = (gray.shape[1], gray.shape[0])\n\n # Chessboard detection\n res, chess_pts = cv2.findChessboardCorners(gray, self._chessboard_shape, None)\n # Debug\n # painted = cv2.drawChessboardCorners(img, self._chessboard_shape, chess_pts, res)\n if res:\n objpoints.append(syn_objp)\n imgpoints.append(chess_pts)\n\n if len(objpoints) <= 0:\n raise ValueError('No Chessboard detected on images.')\n\n # Do camera calibration given object points and image points\n ret, mtx, dist, _, _ = cv2.calibrateCamera(objpoints, imgpoints, img_size, None, None)\n if not ret:\n raise ValueError('cv2.calibrateCamera() failed.')\n\n # prepare return value dictionary\n ret = {'mtx': mtx, 'dist': dist}\n return ret"],"string":"[\n \"def _doCalibration(self):\\n self._cmdCalibration(2)\",\n \"def photometric_calibration():\\n pass\",\n \"def _calibrate(self, Otrain, Ftrain, Feval):\\n raise NotImplementedError()\",\n \"def calibrate_gripper(self):\\n self.gripper = Gripper(self.gripper_side)\\n self.gripper.calibrate()\\n self.gripper.open()\\n self.vacuum_sensor = AnalogIO(self.gripper_side + '_vacuum_sensor_analog')\\n if rospy.get_param('verbose'):\\n rospy.loginfo('Calibrated gripper. (type={})'.format(self.gripper.type()))\",\n \"def do_calibration(self):\\n goal = CalculateParametersGoal()\\n self.calibrate_client.send_goal(goal)\\n self.calibrate_client.wait_for_result()\\n result = self.calibrate_client.get_result()\\n rospy.loginfo('Received the calibration results')\\n if result.number_of_images is 0:\\n rospy.logerr('Failed to calibrate the camera.')\\n else:\\n rospy.loginfo('Number of pictures: {}, error: {}'.format(result.number_of_images, result.error))\\n self.save_calibration_parameters(result.intrinsics, result.error, result.number_of_images)\",\n \"def calibrate(): \\n \\n # Calibrate of the run using beam data. Creates a folder cal-files/caltag \\n # containing all calibration data. \\n CalObj = Calibration(steerfiles=steerfiles, name=localcaltag + '-cal') \\n\\n # Set Beam energy\\n CalObj.set_beam_momentum(beamenergy)\\n\\n # Get gearfile and set air as DUT material\\n localgearfile = CalObj.get_filename('gear.xml')\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='thickness', value=0.0001)\\n set_parameter(gearfile=localgearfile, sensorID=11, parametername='radLength', value=304000.0)\\n \\n # Create list of calibration steps \\n calpath = create_calibration_path(CalObj)\\n \\n # Run the calibration steps \\n CalObj.calibrate(path=calpath,ifile=rawfile_air,caltag=localcaltag)\",\n \"def calibrate(self):\\n if self.iCAL_required:\\n logger.info(\\\"iCAL-sensitive registers were modified, performing calibration...\\\")\\n return self._run_ical()\\n else:\\n logger.info(\\\"iCAL-sensitive registers were not modified, skipping calibration...\\\")\\n return 0 # Still success\",\n \"def calibration(self, cal: int, /) -> None:\",\n \"def calibrate(self, x, y) -> None:\\n pass\",\n \"def platform_auto_calibrate(self):\\n self.platform_auto_calibrate_servos()\\n self.platform_auto_calibrate_imu()\",\n \"def calibrate(self):\\n\\n self.update_message('Calibrating platform...')\\n\\n self.calibrate_platform()\\n\\n self.update_message('Platform Calibrated.')\\n\\n # calibrate arm x axis\\n self.update_message('Calibrating x axis...')\\n calibrated = self.calibrate_arm(0)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate x axis.')\\n return 0\\n else:\\n self.update_message('x axis calibrated.')\\n\\n # calibrate arm y axis\\n self.update_message('Calibrating y axis...')\\n calibrated = self.calibrate_arm(1)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate y axis.')\\n return 0\\n else:\\n self.update_message('y axis calibrated.')\\n\\n # calibrate arm z axis\\n self.update_message('Calibrating z axis...')\\n calibrated = self.calibrate_arm(2)\\n\\n if not calibrated:\\n self.update_message('ERROR: Could not calibrate z axis.')\\n return 0\\n else:\\n self.update_message('z axis calibrated.\\\\n'\\n 'Autocalibration done.\\\\n'\\n 'Accuracy: {}'.format(self.matrix_accuracy()))\\n\\n # Getting the direction to withdraw pipette along x axis\\n self.get_withdraw_sign()\\n self.inv_mat = np.linalg.inv(self.mat)\\n self.calibrated = 1\\n self.cam.click_on_window = True\\n self.save_calibration()\\n return 1\",\n \"def calibrate(self):\\n self.gripper_io.set_signal_value(\\\"calibrate\\\", True)\\n success = intera_dataflow.wait_for(\\n lambda: self.is_calibrated(),\\n timeout=5.0,\\n raise_on_error=False\\n )\\n if not success:\\n rospy.logerr(\\\"({0}) calibration failed.\\\".format(self.name))\\n return success\",\n \"def run_calib(projector=OPTOMA_HD33()):\\n w, h = (0.2160, 0.2794)\\n obj_points = np.array([[-w/2, h/2, 0], [w/2, h/2, 0],\\n [-w/2, 0, 0], [w/2, 0, 0],\\n [-w/2, 0, h/2], [w/2, 0, h/2]])\\n\\n global img_points, going\\n img_points = []\\n\\n try:\\n window = Window()\\n window.MoveXY(1600,0)\\n window.ShowFullScreen(True)\\n going = True\\n\\n @window.eventx\\n def EVT_MOUSE_EVENTS(evt):\\n global going, img_points\\n if evt.ButtonUp(wx.MOUSE_BTN_LEFT):\\n img_points.append(evt.Position)\\n print('Picked point %d of 6' % (len(img_points)))\\n if len(img_points) == len(obj_points):\\n print \\\"Done\\\"\\n going = False\\n\\n print(\\\"\\\"\\\"[Extrinsic Calibration] \\n\\nThere should be 6 points marked on the table and backdrop. \\nMoving the mouse over the projected display, click each of the points\\nin order:\\n (left top, on the backdrop),\\n (right top, on the backdrop),\\n (left center, on the crease),\\n (right center, on the crease),\\n (left bottom, on the table),\\n (right bottom, on the table)\\n\\nFollow along with this illustration: http://imgur.com/asfsfd.jpg\\n\\nClick the six points:\\n\\\"\\\"\\\")\\n\\n while going: cv.WaitKey(10)\\n\\n finally:\\n window.Close()\\n\\n img_points = np.array(img_points, 'f')\\n projector.calibrate_extrinsic(img_points, obj_points)\\n\\n np.save('%s/config/projector' % (newest_folder), (projector.KK, projector.RT))\\n print('OK')\",\n \"def calibration(self) -> int:\",\n \"def calibrate(self):\\n\\t\\tLTOGRIGHT = []\\n\\t\\tLTOGUP = []\\n\\t\\tRTOGRIGHT = []\\n\\t\\tRTOGUP = []\\n\\t\\tstart = time.time()\\n\\t\\tcalibration_time = 5.0\\n\\t\\twhile time.time() - start < calibration_time:\\n\\t\\t\\tevents = pygame.event.get()\\n\\t\\t\\tfor event in events:\\n\\t\\t\\t\\tif event.type == pygame.JOYAXISMOTION:\\n\\t\\t\\t\\t\\tLTOGRIGHT.append(self.joystick.get_axis(self.LTOGRIGHT))\\n\\t\\t\\t\\t\\tLTOGUP.append(-self.joystick.get_axis(self.LTOGUP))\\n\\t\\t\\t\\t\\tRTOGRIGHT.append(self.joystick.get_axis(self.RTOGRIGHT))\\n\\t\\t\\t\\t\\tRTOGUP.append(-self.joystick.get_axis(self.RTOGUP))\\n\\n\\t\\t# calibration sets highest value equal to 1.0\\n\\t\\tself.calibration[0] = 1.0/max(LTOGRIGHT)\\n\\t\\tself.calibration[1] = -1.0/min(LTOGRIGHT)\\n\\t\\tself.calibration[2] = -1.0/min(LTOGUP)\\n\\t\\tself.calibration[3] = 1.0/max(LTOGUP)\\n\\t\\tself.calibration[4] = 1.0/max(RTOGRIGHT)\\n\\t\\tself.calibration[5] = -1.0/min(RTOGRIGHT)\\n\\t\\tself.calibration[6] = -1.0/min(RTOGUP)\\n\\t\\tself.calibration[7] = 1.0/max(RTOGUP)\",\n \"def calibrate(self):\\n import time\\n\\n CALIBRATE_SLEEP = 0.75\\n\\n self.change_power(-self._calpow)\\n encprev, encnow = 0, None\\n while encprev != encnow:\\n encprev = encnow\\n time.sleep(CALIBRATE_SLEEP)\\n encnow = self._bp.get_motor_encoder(self._port)\\n self._pmin = encnow\\n self.change_power(0)\\n\\n self.change_power(self._calpow)\\n encprev, encnow = 0, None\\n while encprev != encnow:\\n encprev = encnow\\n time.sleep(CALIBRATE_SLEEP)\\n encnow = self._bp.get_motor_encoder(self._port)\\n self._pmax = encnow\\n self.change_power(0)\\n\\n if self._pmax == self._pmin:\\n raise Exception('motor {} does not move'.format(self._port))\\n\\n self._pinit = (self._pmax + self._pmin) * 0.5\\n time.sleep(0.5)\\n self.to_init_position()\",\n \"def calibrate(self):\\n self.mode = Mode.calibrating\\n yaw_sensor = yaw_button()\\n while not yaw_sensor.is_pressed():\\n self.move_left()\\n for _ in range(75):\\n self.move_right()\\n\\n pitch_sensor = pitch_button()\\n while not pitch_sensor.is_pressed():\\n self.move_up()\\n for _ in range(21):\\n self.move_down()\\n\\n self.pitch = 0.0\\n self.yaw = 0.0\\n self.mode = Mode.waiting\",\n \"def set_calibrate(self, calibrate=None, *args, **kwargs):\\n calibrate = calibrate or self._calibrate or {}\\n calibrate = copy.copy(calibrate)\\n calibrate.update(kwargs)\\n if calibrate is None: #Use auto\\n calibrate = copy.copy(AUTO_CALIBRATE)\\n self._calibrate = calibrate\\n logging.info(\\\"Calibration updated! %s\\\" % self._calibrate)\",\n \"def calibrate_onc(data, path, model_name):\\n \\n #split test data (subsets 7-9) into new test (7-8)/train(9) sets\\n calibration_train_set = data[((data.subset==7)|(data.subset==8))].copy()\\n calibration_test_set = data[data.subset==9].copy()\\n\\n #define calibration model\\n ir = IsotonicRegression(out_of_bounds=\\\"clip\\\")\\n #fit the model to the probas from the training set\\n ir.fit(calibration_train_set.score, calibration_train_set.y )\\n \\n #evaluate with the test set and save\\n calibration_test_set.loc[:,'p_calibrated'] = ir.transform(calibration_test_set.score) \\n \\n #calibration_test_set.loc[:,'p_calibrated'] = p_calibrated\\n \\n #save\\n with open(path + 'model_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \\n pickle.dump(ir,picklefile)\\n \\n with open(path + 'y_calibrated_' + model_name + '.pickle', 'wb') as picklefile: \\n pickle.dump(calibration_test_set, picklefile)\\n \\n print_calibrated_results(calibration_test_set.y, calibration_test_set.score, calibration_test_set.p_calibrated)\\n return calibration_test_set\",\n \"def calibrate_device(self,event):\\n message = \\\"\\\"\\\"Place Microphone as close as possible to speaker.\\\\n\\n Click 'OK' to start system calibration.\\\"\\\"\\\"\\n Dlg = wx.MessageDialog(None, message, \\\"Start System Calibration\\\",\\n wx.OK|wx.CANCEL|wx.ICON_INFORMATION)\\n Dlg.SetFont(self.font_std)\\n if Dlg.ShowModal() == wx.ID_OK:\\n bi = wx.BusyInfo(\\\"Calibrating System, please wait...\\\", self)\\n time.sleep(5)\\n bi2 = wx.BusyInfo(\\\"Done!\\\", self)\\n time.sleep(2)\\n bi.Destroy()\\n bi2.Destroy()\\n Dlg.Destroy()\",\n \"def cam_calibration():\\n # read all calibration images in a folder with similar names\\n images = glob.glob('./camera_cal/calibration*.jpg')\\n\\n # calibrate camera and read object-points (3D), image points (2D) and image shape\\n objpoints, imgpoints, img_shape = calibrate_camera(images)\\n print(\\\"DONE: Camera calibration\\\")\\n # save calibration parameters' pickle file\\n save_calib_params(objpoints, imgpoints, img_shape)\\n print(\\\"Calibration parameters pickle file saved \\\")\",\n \"def calibrate(self, master):\\n if master.polyorder == 'linear':\\n self.fitfunction = \\\"A0 + A1 * D\\\"\\n self.fit_fkt = self.calc_lin\\n elif master.polyorder == 'quadratic':\\n self.fit_fkt = self.calc_quad\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2\\\"\\n elif master.polyorder == \\\"cubic\\\":\\n self.fitfunction = \\\"A0 + A1 * D + A2 * D**2 + A3 * D**3\\\"\\n self.fit_fkt = self.calc_cubic\\n else:\\n print(\\\"Polynomgrad nicht definiert\\\")\\n \\n self.mw = np.asarray(self.mw)\\n if master.sensortype == \\\"Druck\\\":\\n self.best, self.covar = curve_fit(self.fit_fkt, self.mw, master.Referencedata.caldat)\\n else:\\n print(\\\"Sensortyp noch nicht Hinterlegt\\\")\",\n \"def platform_auto_calibrate_servos(self):\\n self.platform.auto_calibrate_elevation_servo()\\n self.platform.auto_calibrate_azimuth_servo()\",\n \"def calibrate(self, measure_mode):\\n self.setMeasurementMode(measure_mode)\\n calibrateI1Pro()\",\n \"def _RunCalibration(self, graph_key, gdef, input_data, config):\\n return self._RunGraph(graph_key, gdef, input_data, config, 30)\",\n \"def _calibrate_measurement(self):\\n\\n cold_blackbody = bb_radiance(self.cbb.header.cbb_temperature + 273.15,\\n self.cbb.data.wavelength)\\n warm_blackbody = bb_radiance(self.wbb.header.wbb_temperature + 273.15,\\n self.wbb.data.wavelength)\\n\\n self.wbb.data.average_spectrum[0] = 1\\n self.wbb.data.average_spectrum[2047] = 1\\n\\n calibration_slope = ((warm_blackbody - cold_blackbody) /\\n (self.wbb.data.average_spectrum - self.cbb.data.average_spectrum))\\n calibration_offset = warm_blackbody - (self.wbb.data.average_spectrum * \\n calibration_slope)\\n\\n self.wbb.calibrate_file(calibration_slope, calibration_offset)\\n self.cbb.calibrate_file(calibration_slope, calibration_offset)\\n self.sam.calibrate_file(calibration_slope, calibration_offset)\\n\\n if not self.dwr is None:\\n self.dwr.calibrate_file(calibration_slope, calibration_offset)\\n\\n plate_temperature = self.dwr.header.spare_f[0]\\n if (self.plate == -1) :\\n plate_emissivity = self.dwr.header.spare_f[1]\\n\\n plate_blackbody = bb_radiance(plate_temperature + 273.15,\\n self.dwr.data.wavelength)\\n plate_emission = plate_emissivity * plate_blackbody\\n\\n self.dwr.data.average_spectrum = ((self.dwr.data.average_spectrum - \\n plate_emission) / (1 - plate_emissivity))\",\n \"def platform_auto_calibrate_imu(self):\\n self.imu.reset_calibration()\\n self.platform.auto_calibrate_magnetometer()\\n self.platform.auto_calibrate_gyroscope()\\n self.platform.auto_calibrate_accelerometer()\",\n \"def calibrate(self, calib_fns, calib_params, analytes=None, drift_correct=False):\\n # can have calibration function stored in self and pass *coefs?\\n if analytes is None:\\n analytes = self.analytes\\n\\n if 'calibrated' not in self.data.keys():\\n self.data['calibrated'] = {}\\n\\n for a in analytes:\\n if drift_correct:\\n P = self.drift_params(calib_params, a)\\n else:\\n P = calib_params[a].values[0]\\n\\n self.data['calibrated'][a] = \\\\\\n calib_fns[a](P,\\n self.data['ratios'][a])\\n\\n # coefs = calib_params[a]\\n # if len(coefs) == 1:\\n # self.data['calibrated'][a] = \\\\\\n # self.data['ratios'][a] * coefs\\n # else:\\n # self.data['calibrated'][a] = \\\\\\n # np.polyval(coefs, self.data['ratios'][a])\\n # self.data['ratios'][a] * coefs[0] + coefs[1]\\n self.setfocus('calibrated')\\n return\",\n \"def calibrate(self, calibration_dict=None):\\n if calibration_dict is not None:\\n for i in self.POSITIONS:\\n if self.version == \\\"standard\\\" and i.startswith(\\\"save_image__\\\"):\\n continue\\n self.POSITIONS[i] = calibration_dict[i]\\n else:\\n if os.path.isfile(GoogleEarthProCalibration.SETTINGS_FILE):\\n print \\\"Using config file\\\"\\n with open(GoogleEarthProCalibration.SETTINGS_FILE, \\\"r\\\") as gf:\\n for l in gf:\\n cd = l.split(\\\",\\\")\\n self.POSITIONS[cd[0]] = (int(cd[1]), int(cd[2]))\\n else:\\n to_offset = [i for i in self.POSITIONS \\\\\\n if i is not \\\"google_earth_pro_offset\\\"]\\n for i in to_offset:\\n self.POSITIONS[i] = self.offset(self.POSITIONS[i])\",\n \"def save_calibration(filename):\\n pass\",\n \"def finalize(self):\\n self._iou_ap.compute_ap_curve()\\n self._pixel_ap.compute_ap_curve()\\n self._azimuth_ap.compute_ap_curve()\\n self._polar_ap.compute_ap_curve()\",\n \"def calibrate(self):\\n super().calibrate()\\n dataH1 = self._bus.read_i2c_block_data(self.addr,\\n self.CALIBRATION_H1, 1)\\n dataHX = self._bus.read_i2c_block_data(self.addr,\\n self.CALIBRATION_HX, 7)\\n\\n self.dig_H1 = float(c_ubyte(dataH1[0]).value)\\n self.dig_H2 = float(c_short((dataHX[1] << 8) + dataHX[0]).value)\\n self.dig_H3 = float(c_ubyte(dataHX[2]).value)\\n self.dig_H4 = float(c_short(\\n (dataHX[3] << 4) + (dataHX[4] & 0xf)).value)\\n self.dig_H5 = float(c_short(\\n (dataHX[5] << 4) + ((dataHX[4] & 0xf0) >> 4)).value)\\n self.dig_H6 = float(c_byte(dataHX[6]).value)\",\n \"def _calibrate(self, t_send, t_recv, server_timestamp):\\n pass\",\n \"def calibrate_meter(self):\\r\\n print(\\\"meter calibrated\\\")\",\n \"def startAndCalibrateWalabot():\\n wlbt.StartCalibration()\\n print('- Calibrating...')\\n while wlbt.GetStatus()[0] == wlbt.STATUS_CALIBRATING:\\n wlbt.Trigger()\\n wlbt.Start()\\n print('- Calibration ended.\\\\n- Ready!')\",\n \"def antenny_calibrate(self):\\n if self.antenny_config.get(\\\"use_bno08x_rvc\\\"):\\n t = .25\\n d = .5\\n us = 50\\n else:\\n t = .1\\n d = .5\\n us = 100\\n self.platform.auto_calibrate_elevation_servo(us=us, t=t, d=d)\\n self.platform.auto_calibrate_azimuth_servo(us=us, t=t, d=d)\\n if self.antenny_config.get(\\\"use_bno055\\\"):\\n self.platform.auto_calibrate_magnetometer()\\n self.platform.auto_calibrate_gyroscope()\\n self.platform.auto_calibrate_accelerometer()\",\n \"def calibrate(self):\\n\\t\\t\\n\\t\\t# CALIBRATION\\n\\t\\t# determine the calibration points\\n\\t\\tcalibpoints = []\\n\\t\\tfor x in [0.1,0.5,0.9]:\\n\\t\\t\\tfor y in [0.1,0.5,0.9]:\\n\\t\\t\\t\\tcalibpoints.append((int(x*self.dispsize[0]),int(y*self.dispsize[1])))\\n\\t\\trandom.shuffle(calibpoints)\\n\\t\\t\\n\\t\\t# show a message\\n\\t\\tself.screen.clear()\\n\\t\\tself.screen.draw_text(\\n\\t\\t\\ttext=\\\"Press Space to calibrate, S to skip, and Q to quit\\\",\\n\\t\\t\\tfontsize=20)\\n\\t\\tself.disp.fill(self.screen)\\n\\t\\tself.disp.show()\\n\\t\\t\\n\\t\\t# wait for keyboard input\\n\\t\\tkey, keytime = self.kb.get_key(keylist=['q', 's', 'space'],\\n\\t\\t\\ttimeout=None, flush=True)\\n\\t\\tif key == 's':\\n\\t\\t\\treturn True\\n\\t\\tif key == 'q':\\n\\t\\t\\tquited = True\\n\\t\\telse:\\n\\t\\t\\tquited = False\\n\\t\\t\\n\\t\\t# Pause the processing of samples during the calibration.\\n#\\t\\tself.eyetribe._pause_sample_processing()\\n\\t\\t# run until the user is statisfied, or quits\\n\\t\\tcalibrated = False\\n\\t\\tcalibresult = None\\n\\t\\twhile not quited and not calibrated:\\n\\n\\t\\t\\t# Clear the existing calibration.\\n\\t\\t\\tif self.eyetribe._tracker.get_iscalibrated():\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.clear()\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\n\\t\\t\\t# Wait for a bit.\\n\\t\\t\\tclock.pause(1500)\\n\\n\\t\\t\\t# start a new calibration\\n\\t\\t\\tif not self.eyetribe._tracker.get_iscalibrating():\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.start(pointcount=len(calibpoints))\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\n\\t\\t\\t# loop through calibration points\\n\\t\\t\\tfor cpos in calibpoints:\\n\\t\\t\\t\\t# Check whether the calibration is already done.\\n\\t\\t\\t\\t# (Not sure how or why, but for some reason some data\\n\\t\\t\\t\\t# can persist between calbrations, and the tracker will\\n\\t\\t\\t\\t# simply stop allowing further pointstart requests.)\\n\\t\\t\\t\\tif self.eyetribe._tracker.get_iscalibrated():\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t# Draw a calibration target.\\n\\t\\t\\t\\tself.draw_calibration_target(cpos[0], cpos[1])\\n\\t\\t\\t\\t# wait for a bit to allow participant to start looking at\\n\\t\\t\\t\\t# the calibration point (#TODO: space press?)\\n\\t\\t\\t\\tclock.pause(settings.EYETRIBEPRECALIBDUR)\\n\\t\\t\\t\\t# start calibration of point\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.pointstart(cpos[0],cpos[1])\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\t# wait for a second\\n\\t\\t\\t\\tclock.pause(settings.EYETRIBECALIBDUR)\\n\\t\\t\\t\\t# stop calibration of this point\\n\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\tself.eyetribe.calibration.pointend()\\n\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\t# check if the Q key has been pressed\\n\\t\\t\\t\\tif self.kb.get_key(keylist=['q'],timeout=10,flush=False)[0] == 'q':\\n\\t\\t\\t\\t\\t# abort calibration\\n\\t\\t\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\t\\t\\tself.eyetribe.calibration.abort()\\n\\t\\t\\t\\t\\tself.eyetribe._lock.release()\\n\\t\\t\\t\\t\\t# set quited variable and break this for loop\\n\\t\\t\\t\\t\\tquited = True\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\n\\t\\t\\t# retry option if the calibration was aborted\\t\\t\\t\\n\\t\\t\\tif quited:\\n\\t\\t\\t\\t# show retry message\\n\\t\\t\\t\\tself.screen.clear()\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\t\\\"Calibration aborted. Press Space to restart or 'Q' to quit\\\",\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\tself.disp.fill(self.screen)\\n\\t\\t\\t\\tself.disp.show()\\n\\t\\t\\t\\t# get input\\n\\t\\t\\t\\tkey, keytime = self.kb.get_key(keylist=['q','space'], timeout=None, flush=True)\\n\\t\\t\\t\\tif key == 'space':\\n\\t\\t\\t\\t\\t# unset quited Boolean\\n\\t\\t\\t\\t\\tquited = False\\n\\t\\t\\t\\t# skip further processing\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t# empty display\\n\\t\\t\\tself.disp.fill()\\n\\t\\t\\tself.disp.show()\\n\\t\\t\\t# allow for a bit of calculation time\\n\\t\\t\\t# (this is waaaaaay too much)\\n\\t\\t\\tclock.pause(1000)\\n\\t\\t\\t# get the calibration result\\n\\t\\t\\tself.eyetribe._lock.acquire(True)\\n\\t\\t\\tcalibresult = self.eyetribe._tracker.get_calibresult()\\n\\t\\t\\tself.eyetribe._lock.release()\\n\\n\\t\\t\\t# results\\n\\t\\t\\t# clear the screen\\n\\t\\t\\tself.screen.clear()\\n\\t\\t\\t# draw results for each point\\n\\t\\t\\tif type(calibresult) == dict:\\n\\t\\t\\t\\tfor p in calibresult['calibpoints']:\\n\\t\\t\\t\\t\\t# only draw the point if data was obtained\\n\\t\\t\\t\\t\\tif p['state'] > 0:\\n\\t\\t\\t\\t\\t\\t# draw the mean error\\n\\t\\t\\t\\t\\t\\t# self.screen.draw_circle(colour=(252,233,79),\\n\\t\\t\\t\\t\\t\\t# \\tpos=(p['cpx'],p['cpy']), r=p['mepix'], pw=0,\\n\\t\\t\\t\\t\\t\\t# \\tfill=True)\\n\\t\\t\\t\\t\\t\\tself.screen.draw_line(spos=(p['cpx'],p['cpy']),\\n\\t\\t\\t\\t\\t\\t\\tepos=(p['mecpx'],p['mecpy']), pw=2)\\n\\t\\t\\t\\t\\t\\t# draw the point\\n\\t\\t\\t\\t\\t\\tself.screen.draw_fixation(fixtype='dot',\\n\\t\\t\\t\\t\\t\\t\\tcolour=(115,210,22), pos=(p['cpx'],p['cpy']))\\n\\t\\t\\t\\t\\t\\t# draw the estimated point\\n\\t\\t\\t\\t\\t\\tself.screen.draw_fixation(fixtype='dot',\\n\\t\\t\\t\\t\\t\\t\\tcolour=(32,74,135), pos=(p['mecpx'],p['mecpy']))\\n\\t\\t\\t\\t\\t\\t# annotate accuracy\\n\\t\\t\\t\\t\\t\\tself.screen.draw_text(text='%.2f' % p['acd'],\\n\\t\\t\\t\\t\\t\\t\\tpos=(p['cpx']+10,p['cpy']+10), fontsize=20)\\n\\t\\t\\t\\t\\t# if no data was obtained, draw the point in red\\n\\t\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\t\\tself.screen.draw_fixation(fixtype='dot',\\n\\t\\t\\t\\t\\t\\t\\tcolour=(204,0,0), pos=(p['cpx'],p['cpy']))\\n\\t\\t\\t\\t# draw box for averages\\n\\t\\t\\t\\t# self.screen.draw_rect(colour=(238,238,236), x=int(self.dispsize[0]*0.15), y=int(self.dispsize[1]*0.2), w=400, h=200, pw=0, fill=True)\\n\\t\\t\\t\\t# draw result\\n\\t\\t\\t\\tif calibresult['result']:\\n\\t\\t\\t\\t\\tself.screen.draw_text(text=\\\"Calibration successful\\\",\\n\\t\\t\\t\\t\\t\\tcolour='green',\\n\\t\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5), int(self.dispsize[1]*0.25)), \\n\\t\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\tself.screen.draw_text(text=\\\"Calibration failed\\\",\\n\\t\\t\\t\\t\\t\\tcolour='red',\\n\\t\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25)),\\n\\t\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\t# draw average accuracy\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\ttext=\\\"Average error = %.2f degrees\\\" % (calibresult['deg']),\\n\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25+30)),\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t\\t# draw input options\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\ttext=\\\"Press Space to continue or 'R' to restart\\\",\\n\\t\\t\\t\\t\\tpos=(int(self.dispsize[0]*0.5),int(self.dispsize[1]*0.25+60)),\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tself.screen.draw_text(\\n\\t\\t\\t\\t\\ttext=\\\"Calibration failed. Press 'R' to try again.\\\",\\n\\t\\t\\t\\t\\tfontsize=20)\\n\\t\\t\\t# show the results\\n\\t\\t\\tself.disp.fill(self.screen)\\n\\t\\t\\tself.disp.show()\\n\\t\\t\\t# wait for input\\n\\t\\t\\tkey, keytime = self.kb.get_key(keylist=['space','r'], timeout=None,\\n\\t\\t\\t\\tflush=True)\\n\\t\\t\\t# process input\\n\\t\\t\\tif key == 'space':\\n\\t\\t\\t\\tcalibrated = True\\n\\n\\t\\t# Continue the processing of samples after the calibration.\\n#\\t\\tself.eyetribe._unpause_sample_processing()\\n\\n\\t\\t# calibration failed if the user quited\\n\\t\\tif quited:\\n\\t\\t\\treturn False\\n\\n\\t\\t# NOISE CALIBRATION\\n\\t\\t# get all error estimates (pixels)\\n\\t\\tvar = []\\n\\t\\tfor p in calibresult['calibpoints']:\\n\\t\\t\\t# only draw the point if data was obtained\\n\\t\\t\\tif p['state'] > 0:\\n\\t\\t\\t\\tvar.append(p['mepix'])\\n\\t\\tnoise = sum(var) / float(len(var))\\n\\t\\tself.pxdsttresh = (noise, noise)\\n\\t\\t\\t\\t\\n\\t\\t# AFTERMATH\\n\\t\\t# store some variables\\n\\t\\tpixpercm = (self.dispsize[0]/float(self.screensize[0]) + self.dispsize[1]/float(self.screensize[1])) / 2\\n\\t\\tscreendist = settings.SCREENDIST\\n\\t\\t# calculate thresholds based on tracker settings\\n\\t\\tself.accuracy = ((calibresult['Ldeg'],calibresult['Ldeg']), (calibresult['Rdeg'],calibresult['Rdeg'])) \\n\\t\\tself.pxerrdist = deg2pix(screendist, self.errdist, pixpercm)\\n\\t\\tself.pxfixtresh = deg2pix(screendist, self.fixtresh, pixpercm)\\n\\t\\tself.pxaccuracy = ((deg2pix(screendist, self.accuracy[0][0], pixpercm),deg2pix(screendist, self.accuracy[0][1], pixpercm)), (deg2pix(screendist, self.accuracy[1][0], pixpercm),deg2pix(screendist, self.accuracy[1][1], pixpercm)))\\n\\t\\tself.pxspdtresh = deg2pix(screendist, self.spdtresh/1000.0, pixpercm) # in pixels per millisecond\\n\\t\\tself.pxacctresh = deg2pix(screendist, self.accthresh/1000.0, pixpercm) # in pixels per millisecond**2\\n\\n\\t\\t# calibration report\\n\\t\\tself.log(\\\"pygaze calibration report start\\\")\\n\\t\\tself.log(\\\"accuracy (degrees): LX=%s, LY=%s, RX=%s, RY=%s\\\" % (self.accuracy[0][0],self.accuracy[0][1],self.accuracy[1][0],self.accuracy[1][1]))\\n\\t\\tself.log(\\\"accuracy (in pixels): LX=%s, LY=%s, RX=%s, RY=%s\\\" % (self.pxaccuracy[0][0],self.pxaccuracy[0][1],self.pxaccuracy[1][0],self.pxaccuracy[1][1]))\\n\\t\\tself.log(\\\"precision (RMS noise in pixels): X=%s, Y=%s\\\" % (self.pxdsttresh[0],self.pxdsttresh[1]))\\n\\t\\tself.log(\\\"distance between participant and display: %s cm\\\" % screendist)\\n\\t\\tself.log(\\\"fixation threshold: %s pixels\\\" % self.pxfixtresh)\\n\\t\\tself.log(\\\"speed threshold: %s pixels/ms\\\" % self.pxspdtresh)\\n\\t\\tself.log(\\\"acceleration threshold: %s pixels/ms**2\\\" % self.pxacctresh)\\n\\t\\tself.log(\\\"pygaze calibration report end\\\")\\n\\n\\t\\treturn True\",\n \"def _applyCalibration(self, ws, detPos):\\n alg = self.createChildAlgorithm('ApplyCalibration')\\n alg.setProperty('Workspace', ws)\\n alg.setProperty('PositionTable', detPos)\\n alg.execute()\",\n \"def calibrate(self, eventlog, calibrate=True, validate=False):\\n\\n\\n # # # #calculate thresholds (degrees to pixels)\\n self.pxfixtresh = self._deg2pix(self.screendist, self.fixtresh, self.pixpercm)\\n # in pixels per millisecons\\n self.pxspdtresh = self._deg2pix(self.screendist, self.spdtresh / 1000.0, self.pixpercm)\\n # in pixels per millisecond**2\\n self.pxacctresh = self._deg2pix(self.screendist, self.accthresh / 1000.0, self.pixpercm)\\n\\n # calibration image file\\n calibImg = c.CALIBIMG\\n\\n # initialize a sound\\n snd = sound.Sound(value=c.CALIBSOUNDFILE)\\n snd.setVolume(0.5)\\n\\n # image scaling range\\n bit = 0.02\\n scaleRange = ([x / 100.0 for x in range(60, 30, -2)] + [x / 100.0 for x in range(30, 60, 2)])\\n\\n if calibrate:\\n\\n if not self.eyetracker:\\n print(\\\"WARNING! libtobii.TobiiProTracker.calibrate: no eye trackers found for the calibration!\\\")\\n self.stop_recording()\\n return False\\n\\n calibration = tr.ScreenBasedCalibration(self.eyetracker)\\n\\n calibrating = True\\n calibration.enter_calibration_mode()\\n\\n while calibrating:\\n\\n eventlog.write([\\\"Calibration started at \\\", clock.get_time()])\\n print \\\"----------> Starting calibration...\\\"\\n\\n # original (normalised) points_to_calibrate = [(0.5, 0.5), (0.9, 0.1), (0.1, 0.1), (0.9, 0.9), (0.1, 0.9)]\\n # pixel values are calculated based on the normalised points. With (1920,1200):\\n # self.points_to_calibrate calculated values: [(960, 600), (192, 1080), (192, 120), (1728, 1080), (1728, 120)]\\n\\n # calibration for all calibration points\\n for i in range(0,len(self.points_to_calibrate)):\\n\\n point = self.points_to_calibrate[i]\\n\\n eventlog.write([\\\"\\\\nCalibrating point {0} at: \\\".format(point), clock.get_time()])\\n print \\\"----------> Calibrating at point \\\", point\\n\\n # play the soundfile\\n snd.play()\\n\\n # Shrink from big size to small\\n scale = 1\\n for frameN in range(20): # 20 frames -> 1/3 sec shrinking (180 to 108)\\n\\n self.c_screen.clear()\\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\\n drawCoreImage(self.c_screen, point, i)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n scale = scale - bit\\n\\n # shrink and grow while 'space' is pressed\\n s = 0\\n for frameN in range(12000): # 108 -> 54, 15 frames (1/4 s) and backwards\\n\\n s = frameN%30\\n scale = scaleRange[s]\\n self.c_screen.clear()\\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\\n drawCoreImage(self.c_screen, point, i)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n if self.kb.get_key(keylist=['space'],timeout=10, flush=False)[0] == 'space':\\n break\\n\\n # collect results for point\\n normalized_point = self._px_2_norm(point)\\n collect_result = calibration.collect_data(normalized_point[0], normalized_point[1])\\n print(\\\"----------> Collecting results for point \\\", point)\\n eventlog.write([\\\"Collecting result for point {0} at: \\\".format(point), clock.get_time()])\\n\\n if collect_result != tr.CALIBRATION_STATUS_SUCCESS:\\n eventlog.write([\\\"Recollecting result for point {0} at: \\\".format(point), clock.get_time()])\\n # Try again if it didn't go well the first time.\\n # Not all eye tracker models will fail at this point, but instead fail on ComputeAndApply.\\n calibration.collect_data(normalized_point[0], normalized_point[1])\\n\\n # Shrink back to big size\\n scaleUp = [x / 100.0 for x in range(int(scale*100), 100, 2)]\\n for scale in scaleUp:\\n self.c_screen.clear()\\n self.c_screen.draw_image(calibImg, pos=point, scale=scale)\\n drawCoreImage(self.c_screen, point, i)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n\\n # image rolling to next point\\n # pixelised self.points_to_calibrate = [(960, 600), (192, 1080), (192, 120), (1728, 1080), (1728, 120)]\\n if (i < len(self.points_to_calibrate)-1):\\n\\n \\\"\\\"\\\"\\n screen ratio: 16/10\\n The steps for moving the images should be 16, 10 or 8, 5\\n \\\"\\\"\\\"\\n # center -> bottom left / (960, 600) -> (192, 1080) - 48 frames\\n while point[0] >= self.points_to_calibrate[i+1][0]:\\n self.c_screen.clear()\\n point = (point[0]-16, point[1]+10)\\n self.c_screen.draw_image(calibImg, pos=point)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n # bottom-left -> top-left / (192, 1080) -> (192, 120)\\n # AND\\n # bottom-right -> top-right / (1728, 1080) -> (1728, 120) - 80 frames\\n while point[1] > self.points_to_calibrate[i+1][1]:\\n self.c_screen.clear()\\n point = (point[0], point[1]-12)\\n self.c_screen.draw_image(calibImg, pos=point)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n # top-left -> bottom-right / (192, 120) -> (1728, 1080) - 96 frames\\n while point[0] < self.points_to_calibrate[i+1][0] and not point[1] == self.points_to_calibrate[i+1][1]:\\n self.c_screen.clear()\\n point = (point[0]+16, point[1]+10)\\n self.c_screen.draw_image(calibImg, pos=point)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n\\n print(\\\"------------> Calculating calibration result....\\\")\\n\\n calibration_result = calibration.compute_and_apply()\\n\\n eventlog.write([\\\"\\\\nCompute and apply returned {0} and collected at {1} points.\\\\n\\\".\\n format(calibration_result.status, len(calibration_result.calibration_points))])\\n print(\\\"------------> Compute and apply returned {0} and collected at {1} points.\\\".\\n format(calibration_result.status, len(calibration_result.calibration_points)))\\n\\n\\n\\n # Show image after calibration\\n self.c_screen.clear()\\n self.c_screen.draw_image(c.ATT_IMG)\\n self.disp.fill(self.c_screen)\\n self.disp.show()\\n\\n if calibration_result.status != tr.CALIBRATION_STATUS_SUCCESS:\\n eventlog.write([\\\"\\\\n\\\\nWARNING! libtobii.TobiiProTracker.calibrate: Calibration was unsuccessful!\\\\n\\\\n\\\"])\\n print \\\"Calibration was unsuccessful.\\\\nPress 'R' to recalibrate all points\\\\nor 'SPACE' to continue without calibration\\\"\\n key = self.kb.get_key(keylist=['space', 'r'], timeout=None)[0]\\n if key == 'r':\\n recalibration_points = [0]\\n elif key == 'space':\\n recalibration_points = []\\n\\n else:\\n # call showCalibrationResults function to present the results on screen 0. The function returns a list\\n logfiledir = os.path.dirname(os.path.abspath(self.datafilepath))\\n recalibration_points = showCalibrationResults(logfiledir, calibration_result)\\n\\n # if the list is empty, calibration is finished\\n if len(recalibration_points) == 0:\\n eventlog.write([\\\"\\\\nCalibration finished at \\\", clock.get_time()])\\n calibrating = False\\n\\n # if the list contains only '0', the calibration was unsuccessful, recalibrate all points\\n elif (recalibration_points[0] == 0):\\n eventlog.write([\\\"\\\\nRecalibrating all points...\\\"])\\n calibrating = True\\n # if the list contains only '1', recalibrate all points despite successful calibration\\n elif (recalibration_points[0] == 1):\\n eventlog.write([\\\"\\\\nRecalibrating all points...\\\"])\\n for point in self.points_to_calibrate:\\n calibration.discard_data(point[0], point[1])\\n calibrating = True\\n # recalibrate the returned points\\n else:\\n eventlog.write([\\\"\\\\nRecalibrating {0} points...\\\".format(len(recalibration_points))])\\n self.points_to_calibrate = [self._norm_2_px(p) for p in recalibration_points]\\n for point in self.points_to_calibrate:\\n calibration.discard_data(point[0], point[1])\\n calibrating = True\\n\\n\\n calibration.leave_calibration_mode()\\n eventlog.write([\\\" Leaving calibration mode...\\\", clock.get_time()])\\n self.stop_recording()\\n self._write_enabled = True\\n self.disp.close()\",\n \"def imu_calibrate(self):\\n self.imu.calibrate_accelerometer()\\n self.imu.calibrate_gyroscope()\\n self.imu.calibrate_magnetometer()\",\n \"def set_calibration(self, req):\\n\\n cmd = req.command\\n data = json.loads(req.json)\\n if cmd == \\\"add\\\":\\n if \\\"x\\\" in data and \\\"y\\\" in data and \\\"z\\\" in data:\\n x, y, z = float(data[\\\"x\\\"]), float(data[\\\"y\\\"]), float(data[\\\"z\\\"])\\n self.add(Point(x, y, z))\\n else:\\n return False\\n elif cmd == \\\"edit\\\":\\n if \\\"x\\\" in data and \\\"y\\\" in data and \\\"z\\\" in data:\\n x, y, z = float(data[\\\"x\\\"]), float(data[\\\"y\\\"]), float(data[\\\"z\\\"])\\n self.edit(Point(x, y, z))\\n else:\\n return False\\n elif cmd == \\\"goto\\\":\\n self.goto(speed=float(data[\\\"speed\\\"]) if \\\"speed\\\" in data else 1.0)\\n elif cmd == \\\"save\\\":\\n self.save()\\n elif cmd == \\\"cancel\\\":\\n self.load()\\n elif cmd == \\\"safe_goto\\\":\\n self.safe_goto(\\n speed=float(\\n data[\\\"speed\\\"]) if \\\"speed\\\" in data else 1.0, distance=float(\\n data[\\\"distance\\\"]) if \\\"distance\\\" in data else SAFETY_DISTANCE)\\n elif cmd == \\\"record\\\":\\n self.record()\\n elif cmd == \\\"remove\\\":\\n self.remove()\\n elif cmd == \\\"set_selected_point\\\" and \\\"index\\\" in data:\\n self.set_selected_point(int(data[\\\"index\\\"]))\\n else:\\n RosProxy().notify(\\\"Invalid calibration input\\\", STATE.ERROR)\\n return False\\n\\n return True\",\n \"def save_calibration(self):\\n\\n path = './{}/'.format(self.controller)\\n # Check if path exist, if not, creates it.\\n if not os.path.exists(os.path.dirname(path)):\\n try:\\n os.makedirs(os.path.dirname(path))\\n except OSError as exc:\\n # Guard against race condition\\n if exc.errno != errno.EEXIST:\\n raise\\n\\n # Save Jacobian matrix (self.mat)\\n with open(\\\"./{i}/mat.txt\\\".format(i=self.controller), 'wt') as f:\\n for i in range(3):\\n f.write('{a},{b},{c}\\\\n'.format(a=self.mat[i, 0], b=self.mat[i, 1], c=self.mat[i, 2]))\\n\\n # Save rotational matrix\\n with open(\\\"./{i}/rotmat.txt\\\".format(i=self.controller), 'wt') as f:\\n for i in range(3):\\n f.write('{a},{b},{c}\\\\n'.format(a=self.rot[i, 0], b=self.rot[i, 1], c=self.rot[i, 2]))\\n\\n # Save other data\\n with open('./{i}/data.txt'.format(i=self.controller), 'wt') as f:\\n f.write('{d}\\\\n'.format(d=self.um_px))\\n f.write('{d}\\\\n'.format(d=self.x_init))\\n f.write('{d}\\\\n'.format(d=self.y_init))\\n f.write('{d}\\\\n'.format(d=self.template_loc[0]))\\n f.write('{d}\\\\n'.format(d=self.template_loc[1]))\",\n \"def create_calibration_path(Env):\\n \\n hotpixelkiller = Env.create_path('hotpixelkiller')\\n hotpixelkiller.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': rawfile_air }) \\n hotpixelkiller.add_processor(name=\\\"M26HotPixelKiller\\\")\\n\\n cluster_calibrator_mc = Env.create_path('cluster_calibrator_mc')\\n cluster_calibrator_mc.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': rawfile_air }) \\n cluster_calibrator_mc.add_processor(name=\\\"M26Clusterizer\\\")\\n cluster_calibrator_mc.add_processor(name=\\\"M26CogHitMaker\\\")\\n cluster_calibrator_mc.add_processor(name=\\\"M26ClusterCalibrationFromMC\\\")\\n\\n clusterizer = Env.create_path('clusterizer')\\n clusterizer.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': rawfile_air }) \\n clusterizer.add_processor(name=\\\"M26Clusterizer\\\")\\n clusterizer.add_processor(name=\\\"LCIOOutput\\\")\\n\\n correlator = Env.create_path('correlator')\\n correlator.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n correlator.add_processor(name=\\\"M26CogHitMaker\\\")\\n correlator.add_processor(name=\\\"RawDQM\\\") \\n correlator.add_processor(name=\\\"TelCorrelator\\\")\\n \\n kalman_aligner_1 = Env.create_path('kalman_aligner_1')\\n kalman_aligner_1.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n kalman_aligner_1.add_processor(name=\\\"M26CogHitMaker\\\")\\n kalman_aligner_1.add_processor(name=\\\"AlignTF_LC\\\")\\n kalman_aligner_1.add_processor(name=\\\"PreAligner\\\")\\n \\n kalman_aligner_2 = Env.create_path('kalman_aligner_2')\\n kalman_aligner_2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n kalman_aligner_2.add_processor(name=\\\"M26CogHitMaker\\\")\\n kalman_aligner_2.add_processor(name=\\\"AlignTF_TC\\\")\\n kalman_aligner_2.add_processor(name=\\\"TelAligner\\\")\\n \\n telescope_dqm = Env.create_path('telescope_dqm')\\n telescope_dqm.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n telescope_dqm.add_processor(name=\\\"M26CogHitMaker\\\")\\n telescope_dqm.add_processor(name=\\\"AlignTF_TC\\\")\\n telescope_dqm.add_processor(name=\\\"TelescopeDQM\\\")\\n \\n cluster_calibration_1 = Env.create_path('cluster_calibration_1')\\n cluster_calibration_1.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n cluster_calibration_1.add_processor(name=\\\"M26CogHitMaker\\\") \\n cluster_calibration_1.add_processor(name=\\\"AlignTF_TC\\\")\\n cluster_calibration_1.add_processor(name=\\\"M26ClusterCalibrator\\\")\\n \\n kalman_aligner_3 = Env.create_path('kalman_aligner_3')\\n kalman_aligner_3.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n kalman_aligner_3.add_processor(name=\\\"M26GoeHitMaker\\\")\\n kalman_aligner_3.add_processor(name=\\\"AlignTF_TC\\\")\\n kalman_aligner_3.add_processor(name=\\\"TelAligner\\\")\\n \\n cluster_calibration_2 = Env.create_path('cluster_calibration_2')\\n cluster_calibration_2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n cluster_calibration_2.add_processor(name=\\\"M26GoeHitMaker\\\") \\n cluster_calibration_2.add_processor(name=\\\"AlignTF_TC\\\")\\n cluster_calibration_2.add_processor(name=\\\"M26ClusterCalibrator\\\")\\n\\n correlator2 = Env.create_path('correlator2')\\n correlator2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" })\\n correlator2.add_processor(name=\\\"M26GoeHitMaker\\\") \\n correlator2.add_processor(name=\\\"RawDQM\\\", params={'RootFileName': 'RawDQM2.root'})\\n correlator2.add_processor(name=\\\"TelCorrelator\\\", params={'OutputRootFileName': 'XCorrelator2.root'})\\n \\n kalman_aligner_4 = Env.create_path('kalman_aligner_4')\\n kalman_aligner_4.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n kalman_aligner_4.add_processor(name=\\\"M26GoeHitMaker\\\") \\n kalman_aligner_4.add_processor(name=\\\"AlignTF_LC\\\")\\n kalman_aligner_4.add_processor(name=\\\"PreAligner\\\")\\n \\n kalman_aligner_5 = Env.create_path('kalman_aligner_5')\\n kalman_aligner_5.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : 100000, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n kalman_aligner_5.add_processor(name=\\\"M26GoeHitMaker\\\") \\n kalman_aligner_5.add_processor(name=\\\"AlignTF_TC\\\")\\n kalman_aligner_5.add_processor(name=\\\"TelAligner\\\") \\n \\n telescope_dqm2 = Env.create_path('telescope_dqm2')\\n telescope_dqm2.set_globals(params={'GearXMLFile': gearfile , 'MaxRecordNumber' : nevents_air, 'LCIOInputFiles': \\\"tmp.slcio\\\" }) \\n telescope_dqm2.add_processor(name=\\\"M26GoeHitMaker\\\") \\n telescope_dqm2.add_processor(name=\\\"AlignTF_TC\\\")\\n telescope_dqm2.add_processor(name=\\\"TelescopeDQM\\\", params={'RootFileName' : 'TelescopeDQM2.root'})\\n \\n \\n # create sequence of calibration paths \\n calpath= [ hotpixelkiller , \\n cluster_calibrator_mc,\\n clusterizer,\\n correlator, \\n kalman_aligner_1, \\n kalman_aligner_2, \\n kalman_aligner_2, \\n kalman_aligner_2, \\n telescope_dqm, \\n cluster_calibration_1, \\n kalman_aligner_3, \\n kalman_aligner_3, \\n kalman_aligner_3, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2, \\n cluster_calibration_2,\\n correlator2, \\n kalman_aligner_4, \\n kalman_aligner_5, \\n kalman_aligner_5, \\n kalman_aligner_5, \\n telescope_dqm2, \\n ]\\n \\n return calpath\",\n \"def __init__(self, dev, **kw):\\n AutomaticCalibrationRoutine.__init__(\\n self,\\n dev=dev,\\n **kw,\\n )\\n\\n self.final_init(**kw)\",\n \"def calibrate(\\n self, acc: np.ndarray, gyr: np.ndarray, acc_unit: Optional[str], gyr_unit: Optional[str]\\n ) -> Tuple[np.ndarray, np.ndarray]:\\n raise NotImplementedError(\\\"This method needs to be implemented by a subclass\\\")\",\n \"def _calibrate_without_loss(self, calib_dataset, calib_batch_size,\\n calib_steps):\\n # Create quantize calibration model\\n if not self._optimized_model:\\n logger.error(\\n 'Should call `optimize_model()` before `_calibrate_without_loss`.')\\n self._qcb_model, self._layer_metadata = self._quantizer.create_quantize_model(\\n self._optimized_model,\\n candidate_layers=self._candidate_layers,\\n layer_metadata=self._layer_metadata,\\n quantize_strategy=self._quantize_strategy,\\n mode='QCB',\\n target=self._target,\\n dataset=calib_dataset,\\n batch_size=calib_batch_size,\\n steps=calib_steps,\\n specific_layers=self._specific_layers)\\n\\n if calib_dataset is not None:\\n logger.info(\\\"Start Quantize Calibration...\\\")\\n collector = self._run_model_with_collector(self._qcb_model, calib_dataset,\\n calib_batch_size, calib_steps)\\n\\n # Create quantize calibration evaluation model\\n self._qcbev_model = model_utils.clone_model_with_weights(self._qcb_model)\\n model_utils.set_layer_mode(self._qcbev_model, 'QCBEV')\\n\\n if type(self._quantize_strategy\\n ) == vitis_pof2s_quantize_strategy.VitisPof2SQuantizeStrategy:\\n # Freeze the quantize info into the model, now using most_common_quantize_info\\n # last_quantize_info = collector.get_last_quantize_info()\\n common_quantize_info = collector.get_most_common_quantize_info()\\n self._freeze_quantize_info(common_quantize_info)\\n elif type(self._quantize_strategy) in [\\n vitis_fs_quantize_strategy.VitisFSQuantizeStrategy,\\n vitis_fsx_quantize_strategy.VitisFSXQuantizeStrategy,\\n vitis_gpu_quantize_strategy.VitisGPUQuantizeStrategy\\n ]:\\n # Freeze the quantize info into the model, now using most_common_quantize_info\\n # last_quantize_info = collector.get_last_quantize_info()\\n common_quantize_info = collector.get_entropy_percentile_amax(\\n self._qcb_model)\\n self._freeze_quantize_info(common_quantize_info)\\n\\n logger.info(\\\"Quantize Calibration Done.\\\")\",\n \"def go_calib():\\n\\n ####################\\n #\\n # Calibration files:\\n # everything created under calib/\\n #\\n ####################\\n # Darks - created in subdir darks/\\n # - darks needed to make bad pixel mask\\n # - store the resulting dark in the file name that indicates the\\n # integration time (2.8s) and the coadds (10ca).\\n # -- If you use the OSIRIS image, you must include the full filename in the list. \\n darkFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(23, 27+1)]\\n calib.makedark(darkFiles, 'dark_39.832s_1ca_6rd.fits', instrument=osiris)\\n\\n darkFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(28, 32+1)]\\n calib.makedark(darkFiles, 'dark_5.901s_1ca_4rd.fits', instrument=osiris)\\n\\n darkFiles = ['i200822_s020{0:03d}_flip'.format(ii) for ii in range(2, 10+1)]\\n calib.makedark(darkFiles, 'dark_11.802s_4ca_4rd.fits', instrument=osiris)\\n\\n darkFiles = ['i200822_s021{0:03d}_flip'.format(ii) for ii in range(2, 10+1)]\\n calib.makedark(darkFiles, 'dark_5.901s_8ca_1rd.fits', instrument=osiris)\\n\\n # Flats - created in subdir flats/\\n offFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(3, 21+1, 2)]\\n onFiles = ['i200822_s003{0:03d}_flip'.format(ii) for ii in range(4, 22+1, 2)]\\n calib.makeflat(onFiles, offFiles, 'flat_kp_tdOpen.fits', instrument=osiris)\\n\\n # Masks (assumes files were created under calib/darks/ and calib/flats/)\\n calib.makemask('dark_39.832s_1ca_6rd.fits', 'flat_kp_tdOpen.fits',\\n 'supermask.fits', instrument=osiris)\",\n \"def _read_calibration_data(self):\\n #Declare global variables.\\n global calT1\\n global calT2\\n global calT3\\n global calP1\\n global calP2\\n global calP3\\n global calP4\\n global calP5\\n global calP6\\n global calP7\\n global calP8\\n global calP9\\n global calP10\\n global calH1\\n global calH2\\n global calH3\\n global calH4\\n global calH5\\n global calH6\\n global calH7\\n global calGH1\\n global calGH2\\n global calGH3\\n global calResHeatRange\\n global calResHeatVal\\n global calRangeSwErr\\n\\n #Temperature calibration.\\n calT1 = self._read_2bytes_as_ushort_lsbfirst(self.BME680_T1_LSB_REG)\\n calT2 = self._read_2bytes_as_short_lsbfirst(self.BME680_T2_LSB_REG)\\n calT3 = self._read_register_1sbyte(self.BME680_T3_REG)\\n\\n #Pressure calibration.\\n calP1 = self._read_2bytes_as_ushort_lsbfirst(self.BME680_P1_LSB_REG)\\n calP2 = self._read_2bytes_as_short_lsbfirst(self.BME680_P2_LSB_REG)\\n calP3 = self._read_register_1sbyte(self.BME680_P3_REG)\\n calP4 = self._read_2bytes_as_short_lsbfirst(self.BME680_P4_LSB_REG)\\n calP5 = self._read_2bytes_as_short_lsbfirst(self.BME680_P5_LSB_REG)\\n calP6 = self._read_register_1sbyte(self.BME680_P6_REG)\\n calP7 = self._read_register_1sbyte(self.BME680_P7_REG)\\n calP8 = self._read_2bytes_as_short_lsbfirst(self.BME680_P8_LSB_REG)\\n calP9 = self._read_2bytes_as_short_lsbfirst(self.BME680_P9_LSB_REG)\\n calP10 = self._read_register_1ubyte(self.BME680_P10_REG)\\n\\n #Humidity calibration.\\n calH1 = self._read_register_1ubyte(self.BME680_H1_MSB_REG) << 4 | (self._read_register_1ubyte(self.BME680_H1_LSB_REG) & 0x0F)\\n calH2 = self._read_register_1ubyte(self.BME680_H2_MSB_REG) << 4 | ((self._read_register_1ubyte(self.BME680_H2_LSB_REG)) >> 4)\\n calH3 = self._read_register_1sbyte(self.BME680_H3_REG)\\n calH4 = self._read_register_1sbyte(self.BME680_H4_REG)\\n calH5 = self._read_register_1sbyte(self.BME680_H5_REG)\\n calH6 = self._read_register_1ubyte(self.BME680_H6_REG)\\n calH7 = self._read_register_1sbyte(self.BME680_H7_REG)\\n\\n #Gas calibration.\\n calGH1 = self._read_register_1sbyte(self.BME680_GH1_REG)\\n calGH2 = self._read_2bytes_as_short_lsbfirst(self.BME680_GH2_LSB_REG)\\n calGH3 = self._read_register_1sbyte(self.BME680_GH3_REG)\\n\\n #Heat calibration.\\n calResHeatRange = (self._read_register_1ubyte(self.BME680_RES_HEAT_RANGE) & 0x30) / 16\\n calResHeatVal = self._read_register_1sbyte(self.BME680_RES_HEAT_VAL)\\n calRangeSwErr = (self._read_register_1sbyte(self.BME680_RANGE_SW_ERR) & 0xF0) / 16\",\n \"def load_cal(self):\\n global DEBUG, dtParameterDesc\\n if DEBUG:\\n print(self.__class__.__name__+'.load_cal(): calibration is loaded')\\n if 'refatt' in self.parameters and 'refoutpower' in self.parameters:\\n self.parameters['refatt'] = dtParameterDesc['refatt']['default']\\n self.parameters['refoutpower'] = dtParameterDesc['refoutpower']['default']\",\n \"def calibration_wheel(self):\\n self.spectrum = self.spectrum\",\n \"def arm_calibration(self):\\n # DONE: 3. Implement the arm calibration movement by fixing the code below (it has many bugs). It should to this:\\n # Command the arm_motor to run forever in the positive direction at max speed.\\n # Create an infinite while loop that will block code execution until the touch sensor's is_pressed value is True.\\n # Within that loop sleep for 0.01 to avoid running code too fast.\\n # Once past the loop the touch sensor must be pressed. So stop the arm motor quickly using the brake stop action.\\n # Make a beep sound\\n # Now move the arm_motor 14.2 revolutions in the negative direction relative to the current location\\n # Note the stop action and speed are already set correctly so we don't need to specify them again\\n # Block code execution by waiting for the arm to finish running\\n # Make a beep sound\\n # Set the arm encoder position to 0 (the last line below is correct to do that, it's new so no bug there)\\n\\n # Code that attempts to do this task but has MANY bugs (nearly 1 on every line). Fix them!\\n self.arm_motor.run_forever(speed_sp=900)\\n while not self.touch_sensor.is_pressed:\\n time.sleep(0.01)\\n self.arm_motor.stop(stop_action='brake')\\n ev3.Sound.beep().wait()\\n # time.sleep(2)\\n # arm_motor.stop(stop_action='brake')\\n\\n arm_revolutions_for_full_range = 14.2 * 360\\n self.arm_motor.run_to_rel_pos(position_sp=-arm_revolutions_for_full_range, speed_sp=900)\\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\\n ev3.Sound.beep()\\n self.arm_motor.position = 0 # Calibrate the down position as 0 (this line is correct as is).\",\n \"def get_calib_data(self):\\n\\n accel_offset_read = self.con.receive(registers.ACCEL_OFFSET_X_LSB_ADDR, 6)\\n accel_offset_read_x = (accel_offset_read[1] << 8) | accel_offset_read[\\n 0] # Combine MSB and LSB registers into one decimal\\n accel_offset_read_y = (accel_offset_read[3] << 8) | accel_offset_read[\\n 2] # Combine MSB and LSB registers into one decimal\\n accel_offset_read_z = (accel_offset_read[5] << 8) | accel_offset_read[\\n 4] # Combine MSB and LSB registers into one decimal\\n\\n accel_radius_read = self.con.receive(registers.ACCEL_RADIUS_LSB_ADDR, 2)\\n accel_radius_read_value = (accel_radius_read[1] << 8) | accel_radius_read[0]\\n\\n mag_offset_read = self.con.receive(registers.MAG_OFFSET_X_LSB_ADDR, 6)\\n mag_offset_read_x = (mag_offset_read[1] << 8) | mag_offset_read[\\n 0] # Combine MSB and LSB registers into one decimal\\n mag_offset_read_y = (mag_offset_read[3] << 8) | mag_offset_read[\\n 2] # Combine MSB and LSB registers into one decimal\\n mag_offset_read_z = (mag_offset_read[5] << 8) | mag_offset_read[\\n 4] # Combine MSB and LSB registers into one decimal\\n\\n mag_radius_read = self.con.receive(registers.MAG_RADIUS_LSB_ADDR, 2)\\n mag_radius_read_value = (mag_radius_read[1] << 8) | mag_radius_read[0]\\n\\n gyro_offset_read = self.con.receive(registers.GYRO_OFFSET_X_LSB_ADDR, 6)\\n gyro_offset_read_x = (gyro_offset_read[1] << 8) | gyro_offset_read[\\n 0] # Combine MSB and LSB registers into one decimal\\n gyro_offset_read_y = (gyro_offset_read[3] << 8) | gyro_offset_read[\\n 2] # Combine MSB and LSB registers into one decimal\\n gyro_offset_read_z = (gyro_offset_read[5] << 8) | gyro_offset_read[\\n 4] # Combine MSB and LSB registers into one decimal\\n\\n calib_data = {'accel_offset': {'x': accel_offset_read_x, 'y': accel_offset_read_y, 'z': accel_offset_read_z}, 'accel_radius': accel_radius_read_value,\\n 'mag_offset': {'x': mag_offset_read_x, 'y': mag_offset_read_y, 'z': mag_offset_read_z}, 'mag_radius': mag_radius_read_value,\\n 'gyro_offset': {'x': gyro_offset_read_x, 'y': gyro_offset_read_y, 'z': gyro_offset_read_z}}\\n\\n return calib_data\",\n \"def initialise_calibration(self):\\n for i in range(0, self.NUM_SENSORS):\\n self.calibratedMax[i] = 0\\n self.calibratedMin[i] = self.READING_TIMEOUT\",\n \"def calib_raw(self, calib_func=\\\"kidsdata.kids_calib.get_calfact\\\", clean_raw=False, **kwargs):\\n\\n if getattr(self, \\\"__calib\\\", None) is None:\\n self.__log.debug(\\\"calibration using {}\\\".format(calib_func))\\n self.__check_attributes([\\\"I\\\", \\\"Q\\\"], read_missing=False)\\n\\n fmod = self.fmod\\n mod_mask = self.mod_mask\\n\\n # Check about the 3rd bit and the fix_masq keyword\\n if np.any(mod_mask & (1 << 2)) and kwargs.get(\\\"fix_masq\\\") is True:\\n self.__log.error(\\\"fix_masq should not be used when 3rd bit is set\\\")\\n\\n self.__log.info(\\\"Calibrating with fmod={} and {}\\\".format(fmod, kwargs))\\n calib_func = _import_from(calib_func)\\n self.__calib = calib_func(self.I, self.Q, mod_mask, fmod=fmod, **kwargs)\\n\\n else:\\n self.__log.error(\\\"calibrated data already present\\\")\\n\\n # Expand keys :\\n # Does not double memory, but it will not be possible to\\n # partially free memory : All attribute read at the same time\\n # must be deleted together\\n for ckey in self.__calib.keys():\\n self.__dict__[ckey] = self.__calib[ckey]\\n\\n if clean_raw:\\n self._clean_data(\\\"_KidsRawData__dataSd\\\")\",\n \"def test_calibrate(self):\\n from astropy.io.fits import Header\\n command = '{0} -r {1}'.format(\\n os.path.join(self.datadir,\\n 'monol_testA_nustar_fpma_ev' + HEN_FILE_EXTENSION),\\n os.path.join(self.datadir, 'test.rmf'))\\n hen.calibrate.main(command.split())\\n new_filename = os.path.join(self.datadir,\\n 'monol_testA_nustar_fpma_ev_calib' +\\n HEN_FILE_EXTENSION)\\n assert os.path.exists(new_filename)\\n ev = hen.io.load_events(new_filename)\\n assert hasattr(ev, 'header')\\n\\n Header.fromstring(ev.header)\\n assert hasattr(ev, 'gti')\\n gti_to_test = hen.io.load_events(self.first_event_file).gti\\n assert np.allclose(gti_to_test, ev.gti)\",\n \"def determine_calibration(func):\\r\\n calibrate_file = path.abspath(path.join(path.dirname(__file__), \\\"./cam_param_py2.pickle\\\"))\\r\\n # print (calibrate_file,\\\"--------------------\\\")\\r\\n def calibrate_judger(*args, **kwargs):\\r\\n if path.exists(calibrate_file):\\r\\n print('Camera has been calibrated, loading parameter file ... ')\\r\\n with open(calibrate_file) as cal_file:\\r\\n calibration = pickle.load(cal_file)\\r\\n else:\\r\\n print('Computing camera calibration ... ')\\r\\n calibration = func(*args, **kwargs)\\r\\n with open(calibrate_file, 'w') as cal_file:\\r\\n pickle.dump(calibration, cal_file, protocol=2)\\r\\n print('Camera calibration complete.')\\r\\n # print(calibration)\\r\\n return calibration\\r\\n return calibrate_judger\",\n \"def calibration(self, pulse_min: int, pulse_max: int, pulse_centre: int, /) -> None:\",\n \"def set_calibration(self, measured_air_pressure, actual_air_pressure):\\n measured_air_pressure = int(measured_air_pressure)\\n actual_air_pressure = int(actual_air_pressure)\\n\\n self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_SET_CALIBRATION, (measured_air_pressure, actual_air_pressure), 'i i', '')\",\n \"def calibrate(self):\\n self.camera.camera_open()\\n while True:\\n img = self.camera.frame\\n if img is not None:\\n img_copy = img.copy()\\n img_h, img_w = img.shape[:2]\\n\\n white_key_width = int(img_w / 10)\\n white_key_bottom = int(img_h / 8)\\n black_key_bottom = img_h - int(img_h / 3)\\n key_top = img_h - white_key_bottom\\n\\n # Draw All Keys\\n for i in self.key_map.values():\\n # TODO: I think key_top and key_bottom are swapped\\n cv2.line(img, (white_key_width*i, key_top),\\n (white_key_width*i, white_key_bottom),\\n (0, 0, 200), 1)\\n\\n cv2.line(img, (0, black_key_bottom),\\n (img_w, black_key_bottom),\\n (0, 0, 200), 1)\\n\\n cv2.imshow('Align Frame', img)\\n key = cv2.waitKey(1)\\n if key == ESCAPE_KEY:\\n break\\n\\n self.img_h = img_h\\n self.img_w = img_w\\n self.white_key_width = white_key_width\\n self.white_key_bottom = white_key_bottom\\n self.black_key_bottom = black_key_bottom\\n self.key_top = key_top\\n self.latest_img = img_copy\\n\\n self.camera.camera_close()\\n cv2.destroyAllWindows()\",\n \"def calibrate(\\n model: onnx.ModelProto, dataset: List[Dict[str, np.ndarray]]\\n) -> Dict[str, Tuple[float, float]]:\\n augmented_model = ONNXCalibrator(model).build_calibration_model()\\n return calibrator.calibrate(augmented_model, dataset)\",\n \"def proz(): \\r\\n print(\\\"processing: \\\",CURDATA()[0]) \\r\\n Check_180turn(left_boundary,right_boundary)\\r\\n EF() #exponential window multiplication + fourier\\r\\n APK0() #1. Phase correction 0th Ordnung\\r\\n APK1() #1. Phase correction 1st Ordnung\\r\\n ABS() #Baseline correction\\r\\n APK()\\r\\n ABS() #Baseline correction\\r\\n Check_180turn(left_boundary,right_boundary)\",\n \"def calibrate(self, dataset: Iterable[Dict[str, np.ndarray]]) -> Dict[str, Tuple[float, float]]:\\n return calibrate(self.model, dataset)\",\n \"def __call__(self, data):\\n cal = self.calc()\\n assert data.shape == cal.shape, \\\\\\n \\\"data shape does not match calibration ({} != {})\\\".format(data.shape, cal.shape)\\n return data * cal\",\n \"def start_calibration(self):\\n self.socket.send_string('C')\\n return self.socket.recv_string()\",\n \"def handle_alive(event):\\n\\n formation = event.sender\\n formation.calibrate()\",\n \"def calibrate_file(self, filename, custom_file, out_dir, overwrite_rad, overwrite_ref):\\n # check for valid rad file\\n valid = self.get_rad_file(filename, out_dir, overwrite_rad)\\n\\n if valid:\\n # valid rad file\\n print('calibrating' + filename)\\n\\n out_filename = self.rad_to_ref(out_dir)\\n if not overwrite_ref:\\n # if we don't want to overwrite existing files, we can skip this file if it already exists\\n if os.path.exists(out_filename) and os.path.isfile(out_filename):\\n print(out_filename + \\\" already exists, skipping\\\")\\n return\\n\\n # now choose values based on exp time\\n values = self.choose_values(custom_file)\\n if values is None:\\n return\\n if self.total_files == 1:\\n self.update_progress(25)\\n # then calibrate by dividing by values\\n new_values = self.do_division(values)\\n if self.total_files == 1:\\n self.update_progress(75)\\n # convolve\\n final_values = self.do_multiplication(new_values)\\n # replace saturated channels that are too large for PDS fixed-width with 0s\\n final_values = np.where(abs(final_values) > 10E20, 0, final_values)\\n\\n # rename rad to ref to get outfile name and then write to file\\n write_final(out_filename, self.wavelength, final_values)\\n\\n # check for original label\\n original_label = self.get_original_label(filename)\\n if os.path.exists(original_label):\\n # write new label based on original\\n (path, label_name) = os.path.split(original_label)\\n new_label_filename = label_name.replace('PSV', 'REF')\\n new_label_filename = new_label_filename.replace('psv', 'ref')\\n new_label_filename = new_label_filename.replace('lbl', 'xml')\\n (out_path, filename) = os.path.split(out_filename)\\n new_label = os.path.join(out_path, new_label_filename)\\n write_label(new_label, original_label, False)\\n\\n if self.total_files == 1:\\n self.update_progress(100)\\n\\n print(filename + ' calibrated and written to ' + out_filename)\",\n \"def calibrate(self):\\n if not self._calibrate:\\n raise ValueError(\\\"calibrate parameter must be set\\\")\\n\\n if self.calibration_samples >= self._max_samples:\\n return self._camera\\n\\n frame = self.capture()\\n left = frame.images[0]\\n right = frame.images[1]\\n\\n ret_l, corners_l = left.features\\n ret_r, corners_r = right.features\\n\\n if self._last_timestamp is None:\\n self._last_timestamp = frame.timestamp\\n\\n if ret_l is True and ret_r is True and (frame.timestamp - self._last_timestamp).total_seconds() > self._frame_delay:\\n self.objpoints.append(self.objp)\\n self.imgpoints_l.append(corners_l)\\n self.imgpoints_r.append(corners_r)\\n\\n self.calibration_samples += 1\\n self._last_timestamp = frame.timestamp\\n\\n if self.calibration_samples >= self._max_samples:\\n img_shape = left.image.shape[::-1]\\n self._camera = self._finish_calibration(self.objpoints, self.imgpoints_l, self.imgpoints_r, img_shape)\\n return self._camera\",\n \"def set_calibration(is_profile):\\n\\n\\n print(\\\"No calibration could be extracted from the file metadata\\\\n Please enter calibration paramters\\\")\\n \\n pixel_size = validate_calibration(\\\"Please enter a pixel size (in angstroms) e.g. 14.1\\\\n\\\",\\\"pixel_size\\\")\\n \\n wavelength = validate_calibration(\\\"Please enter beam wavelength (in microns) e.g. .02354\\\\n\\\",\\\"wavelength\\\") \\n\\n if not is_profile: \\n camera_dist = validate_calibration(\\\"Please enter camera distance from sample (in millimeters) e.g. 223.1\\\\n\\\",\\\"camera distance\\\")\\n else:\\n camera_dist = 0\\n\\n return { \\\"pixel_size\\\": pixel_size,\\n \\\"wavelength\\\": wavelength,\\n \\\"camera_distance\\\": camera_dist}\",\n \"def tune(self, occupation_1, occupation_2, res=1e-3, calibrate_nr=3, plot=False):\\n # initialize variables\\n self.occupation_1_f = occupation_1\\n self.occupation_2_f = occupation_2\\n\\n # direction variable defines where the next frame is drawn\\n # direction == 0: lower right corner (i.e. right)\\n # direction == 1: upper right corner (i.e. top-right)\\n # direction == 2: upper left corner (i.e. up)\\n direction = 1\\n found = False\\n reverse = False # if charge occupation too high, go back\\n counter = 0 # length of path in frames\\n\\n print('Start tuning Charge States.')\\n self.PG1['n_pts'] = self.f + 2 * self.p + 1\\n self.PG2['n_pts'] = self.f + 2 * self.p + 1\\n\\n while not found:\\n # define measurement variables\\n self.PG1['stop'] = self.trans_path_x[-1] - (self.p + 0.5) * res\\n self.PG1['start'] = self.trans_path_x[-1] + (self.f + self.p + 0.5) * res\\n self.PG2['stop'] = self.trans_path_y[-1] - (self.p + 0.5) * res\\n self.PG2['start'] = self.trans_path_y[-1] + (self.f + self.p + 0.5) * res\\n\\n # overwrite when necessary\\n if reverse:\\n if direction == 0:\\n self.PG1['stop'] = self.trans_path_x[-1] - (self.f + self.p + 0.5) * res\\n self.PG1['start'] = self.trans_path_x[-1] + (self.p + 0.5) * res\\n if direction == 2:\\n self.PG2['stop'] = self.trans_path_y[-1] - (self.f + self.p + 0.5) * res\\n self.PG2['start'] = self.trans_path_y[-1] + (self.p + 0.5) * res\\n\\n # add starting point for plotting reasons\\n self.trans_frame_start.append((self.PG1['start'], self.PG2['start']))\\n\\n # define mean PG values for QPC calibration\\n self.PG2['mean'] = self.PG2['start'] + (self.PG2['stop'] - self.PG2['start']) / 2.\\n self.PG1['mean'] = self.PG1['start'] + (self.PG1['stop'] - self.PG1['start']) / 2.\\n\\n # update charge occupation into list\\n self.occupation.append((self.occupation_1, self.occupation_2))\\n\\n # update path to take\\n if direction == 0:\\n if not reverse:\\n self.trans_path_x.append(self.trans_path_x[-1] + self.f * res)\\n self.trans_path_y.append(self.trans_path_y[-1])\\n else:\\n self.trans_path_x.append(self.trans_path_x[-1] - self.f * res)\\n self.trans_path_y.append(self.trans_path_y[-1])\\n\\n elif direction == 1:\\n if not reverse:\\n self.trans_path_x.append(self.trans_path_x[-1] + self.f * res)\\n self.trans_path_y.append(self.trans_path_y[-1] + self.f * res)\\n else: # this is never True - just for completeness\\n self.trans_path_x.append(self.trans_path_x[-1] - self.f * res)\\n self.trans_path_y.append(self.trans_path_y[-1] - self.f * res)\\n\\n elif direction == 2:\\n if not reverse:\\n self.trans_path_x.append(self.trans_path_x[-1])\\n self.trans_path_y.append(self.trans_path_y[-1] + self.f * res)\\n else:\\n self.trans_path_x.append(self.trans_path_x[-1])\\n self.trans_path_y.append(self.trans_path_y[-1] - self.f * res)\\n\\n # Print path number and what points the path links\\n print('\\\\n###################\\\\n'\\n 'Path: {}\\\\n'\\n 'PG1: {} -> {}\\\\n'\\n 'PG2: {} -> {}'.format(counter,\\n round(self.trans_path_x[-2], 3), round(self.trans_path_x[-1], 3),\\n round(self.trans_path_y[-2], 3), round(self.trans_path_y[-1], 3)))\\n\\n # define measurement object\\n output_path = os.path.join(self.path_out, 'tune_' + str(counter))\\n measurement = ScriptTools.MeasurementObject(\\n self.path_in,\\n output_path\\n )\\n\\n # recalibrate QPC every calibrate_nr frames\\n if counter % calibrate_nr == calibrate_nr - 1 or self.sweet_spot is None:\\n calibrate = True\\n gate_config = None\\n\\n else:\\n calibrate = False\\n gate_config = {\\n self.gate_names['QPC_G']: self.sweet_spot\\n }\\n\\n # get the measured QPC signal and reshape it\\n measurement_signal = self.get_data_(measurement, output_path, DQD_log_channel=self.gate_names['I_DQD'],\\n calibrate=calibrate, rescale=True, config=gate_config)\\n self.trans_frames.append(measurement_signal['I_QPC'])\\n I_DQD = measurement_signal['I_DQD']\\n reshaped_signal = self.trans_frames[-1].reshape((1, self.f + 2*self.p, self.f + 2*self.p, 1))\\n\\n # check whether there is a current through the dot, if so - abort\\n # TODO introduce threshold as a variable\\n if self.is_current_(I_DQD, 7e-12):\\n print('There is too much current through the dot. Tuning stopped.\\\\n'\\n 'Last PG values:\\\\n'\\n 'PG1: {}\\\\n'\\n 'PG2: {}'.format(self.trans_path_x[-1], self.trans_path_y[-1]))\\n break\\n\\n # Make the predictions\\n # (QD1 transition, QD2 transition)\\n # transition[i] == [1, 0, 0, 0]: (False, False)\\n # transition[i] == [0, 1, 0, 0]: (False, True)\\n # transition[i] == [0, 0, 1, 0]: (True, False)\\n # transition[i] == [0, 0, 0, 1]: (True, True)\\n # for i in {0, 1, 2}\\n transition = self.trans_rec.predict(reshaped_signal)\\n self.trans_classif.append(transition)\\n\\n # Check whether there is a contradiction. If there is one,\\n # measure the same frame again and redo the classifications.\\n is_contra = self.is_contradiction_(transition)\\n if is_contra:\\n print('There is a contradiction.\\\\n'\\n '{}'.format(transition))\\n # Remeasure the frame.\\n self.trans_frames.append(\\n self.get_data_(measurement, output_path, calibrate=calibrate, config=gate_config)['I_QPC'])\\n # Redo the classifications\\n reshaped_signal = self.trans_frames[-1].reshape((1, self.f + 2 * self.p, self.f + 2 * self.p, 1))\\n transition = self.trans_rec.predict(reshaped_signal)\\n\\n # check again whether there is still a contradiction\\n if self.is_contradiction_(transition):\\n print('There is still a contradiction. Proceed anyways.')\\n else:\\n print('There is no contradiction anymore. Proceed as normal.')\\n\\n # plot the data\\n if plot:\\n pass\\n # grid = plt.GridSpec(20, 20)\\n # fig = plt.figure()\\n # ax = plt.subplot(grid[:20, :20])\\n # axins1 = inset_axes(ax,\\n # width=\\\"3%\\\",\\n # height=\\\"100%\\\",\\n # loc='lower left',\\n # bbox_to_anchor=(1.01, 0., 1, 1),\\n # bbox_transform=ax.transAxes,\\n # borderpad=0,\\n # )\\n #\\n # im1 = ax.pcolormesh(self.trans_frames[-1][:, :], linewidth=0, rasterized=True)\\n # cbar = fig.colorbar(im1, cax=axins1)\\n # ax.axhline(y=self.p, color='black', linewidth=2)\\n # ax.axhline(y=self.f+self.p, color='black', linewidth=2)\\n # ax.axvline(x=self.p, color='black', linewidth=2)\\n # ax.axvline(x=self.f+self.p, color='black', linewidth=2)\\n # ax.plot(self.trans_path_x[-1], self.trans_path_y[-1])\\n # ax.set_ylim(0, self.f+2*self.p)\\n # ax.set_xlim(0, self.f+2*self.p)\\n # plt.title('Path {}'.format(counter))\\n # plt.show()\\n\\n # Trigger charge transitions\\n if np.argmax(transition[direction]) == 0: # no transition at all\\n print('No transition.\\\\n'\\n 'Confidence: {}\\\\n'\\n 'Current charge occupation({},{})'.format(np.max(transition[direction]),\\n self.occupation_1, self.occupation_2))\\n elif np.argmax(transition[direction]) == 1: # transition in QD2\\n if not reverse:\\n self.occupation_2 += 1\\n else:\\n self.occupation_2 -= 1\\n print('Transition in QD2.\\\\n'\\n 'Confidence: {}\\\\n'\\n 'Current charge occupation({},{})'.format(np.max(transition[direction]),\\n self.occupation_1, self.occupation_2))\\n elif np.argmax(transition[direction]) == 2: # transision in QD1\\n if not reverse:\\n self.occupation_1 += 1\\n else:\\n self.occupation_1 -= 1\\n print('Transition in QD1.\\\\n'\\n 'Confidence: {}\\\\n'\\n 'Current charge occupation({},{})'.format(np.max(transition[direction]),\\n self.occupation_1, self.occupation_2))\\n elif np.argmax(transition[direction]) == 3: # transition in both QDs\\n if not reverse:\\n self.occupation_2 += 1\\n self.occupation_1 += 1\\n else:\\n self.occupation_2 -= 1\\n self.occupation_1 -= 1\\n print('Transition in both QDs.\\\\n'\\n 'Confidence: {}\\\\n'\\n 'Current charge occupation({},{})'.format(np.max(transition[direction]),\\n self.occupation_1, self.occupation_2))\\n\\n # define where to go based on current charge occupation\\n if self.occupation_1 < self.occupation_1_f and self.occupation_2 < self.occupation_2_f:\\n direction = 1\\n reverse = False\\n print('-> Going up right.')\\n\\n elif self.occupation_1 == self.occupation_1_f and self.occupation_2 < self.occupation_2_f:\\n direction = 2\\n reverse = False\\n print('-> Going up.')\\n\\n elif self.occupation_1 < self.occupation_1_f and self.occupation_2 == self.occupation_2_f:\\n direction = 0\\n reverse = False\\n print('-> Going right.')\\n\\n # go back, if one of the dots has too many electrons\\n elif self.occupation_1 > self.occupation_1_f:\\n direction = 0\\n reverse = True\\n print('-> Going left.')\\n\\n elif self.occupation_2 > self.occupation_2_f:\\n direction = 2\\n reverse = True\\n print('-> Going down.')\\n\\n # Terminate if desired charge configuration is reached\\n elif self.occupation_1 == self.occupation_1_f and self.occupation_2 == self.occupation_2_f:\\n print('\\\\nTuning successful\\\\n'\\n 'PG1: {}V\\\\n'\\n 'PG2: {}V'.format(self.trans_path_x[-1], self.trans_path_y[-1]))\\n found = True\\n\\n if counter >= 15:\\n print('Could not find desired charge configuration.\\\\n'\\n 'Program stopped.')\\n found = True\\n\\n counter += 1\",\n \"def _read_calibration_data(self):\\n #Declare global variables.\\n global calDig_T1\\n global calDig_T2\\n global calDig_T3\\n global calDig_P1\\n global calDig_P2\\n global calDig_P3\\n global calDig_P4\\n global calDig_P5\\n global calDig_P6\\n global calDig_P7\\n global calDig_P8\\n global calDig_P9\\n global calDig_H1\\n global calDig_H2\\n global calDig_H3\\n global calDig_H4\\n global calDig_H5\\n global calDig_H6\\n\\n #Temperature calibration\\n calDig_T1 = self._read_2bytes_as_ushort_lsbfirst(self.BME280_DIG_T1)\\n calDig_T2 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_T2)\\n calDig_T3 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_T3)\\n\\n #Pressure calibration\\n calDig_P1 = self._read_2bytes_as_ushort_lsbfirst(self.BME280_DIG_P1)\\n calDig_P2 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P2)\\n calDig_P3 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P3)\\n calDig_P4 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P4)\\n calDig_P5 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P5)\\n calDig_P6 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P6)\\n calDig_P7 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P7)\\n calDig_P8 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P8)\\n calDig_P9 = self._read_2bytes_as_short_lsbfirst(self.BME280_DIG_P9)\\n\\n #Humidity calibration\\n calDig_H1 = self._read_register_1sbyte(self.BME280_DIG_H1)\\n calDig_H2 = self._read_2bytes_as_ushort_lsbfirst(self.BME280_DIG_H2)\\n calDig_H3 = self._read_register_1sbyte(self.BME280_DIG_H3)\\n calDig_H4 = (self._read_register_1sbyte(self.BME280_DIG_H4) << 4) | (self._read_register_1sbyte(self.BME280_DIG_H4 + 1) & 0xF)\\n calDig_H5 = self._read_register_1sbyte((self.BME280_DIG_H5 + 1) << 4) | (self._read_register_1sbyte(self.BME280_DIG_H5) >> 4)\\n calDig_H6 = self._read_register_1sbyte(self.BME280_DIG_H6)\",\n \"def calibrate(self):\\n\\t\\twl = BLi.getWavelength()\\n\\t\\tif abs(self.stokes()) <= .5:\\n\\t\\t\\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\\n\\t\\t\\tself.offset2(-xxx)\\n\\t\\t\\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\\n\\t\\t\\tself.offset4(yyy)\\n\\t\\t\\tself.offset9(self.dettrans())\\n\\t\\telif abs(self.stokes()-90.) <= .5:\\n\\t\\t\\txxx=self.sign()*180/pi*asin( wl/(2*self.dspace)) - (self.thp())\\n\\t\\t\\tself.offset3(-xxx)\\n\\t\\t\\tyyy=self.tthp()-self.sign()*2*180/pi*asin(wl/(2*self.dspace))-self.offset5()\\n\\t\\t\\tself.offset8(yyy)\\n\\t\\t\\tself.offset10(self.dettrans())\\n\\t\\telse:\\n\\t\\t\\tprint \\\"Can't calibrate at stokes=\\\",self.stokes()\\n\\t\\treturn [self.sign(),self.offset2(), self.offset3(),self.offset4(),self.offset5(),self.offset8(),self.offset9(),self.offset10()]\",\n \"def calibration_changed(self):\\n\\n for marker in self.marker_array.markers:\\n marker.action = Marker.DELETE\\n\\n for idx, pose in enumerate(self.poses):\\n marker = Marker()\\n marker.id = int(str(int(round(time.time() * 1000)) + idx)[6:])\\n marker.header.frame_id = Calibration.marker_workpiece_frame\\n marker.type = Marker.SPHERE\\n marker.action = Marker.ADD\\n marker.scale.x = Calibration.marker_size\\n marker.scale.y = Calibration.marker_size\\n marker.scale.z = Calibration.marker_size\\n marker.color.a = 1.0\\n marker.color = ColorRGBA(a=1, r=1, g=0, b=0) if\\\\\\n idx == self.selected_point else ColorRGBA(a=1, r=1, g=1, b=0)\\n marker.pose.orientation.w = 1.0\\n marker.pose.position = pose.model\\n self.marker_array.markers.append(marker)\\n\\n RosProxy().publish_topic(\\n \\\"calibration_markers\\\", MarkerArray, self.marker_array, latch=True)\\n\\n # Keep only the added markers\\n self.marker_array.markers = [\\n marker for marker in self.marker_array.markers if marker.action == Marker.ADD]\\n\\n calibration_msg = CalibrationMsg(\\n points=self.poses,\\n selected_point=-\\n 1 if self.selected_point is None else self.selected_point,\\n transformation=np.append([], self.transformation_matrix))\\n\\n RosProxy().publish_topic(\\n \\\"calibration_points\\\", CalibrationMsg, calibration_msg, latch=True)\\n\\n RobotControllerHandler().set_transformation(self.transformation_matrix)\",\n \"def safe_calibrate(self):\\n\\n status = -1\\n while status < 3:\\n ifMutexAcquire(self.use_mutex)\\n try:\\n new_status = self.BNO055.get_calibration_status()[3]\\n except:\\n new_status = -1\\n finally:\\n ifMutexRelease(self.use_mutex)\\n if new_status != status:\\n status = new_status\",\n \"def __init__(self, poses=None, selected_point=None):\\n super(Calibration, self).__init__(\\\"calibration\\\")\\n\\n self.marker_array = MarkerArray()\\n if selected_point is None:\\n selected_point = 0\\n\\n if poses is not None:\\n self.poses = poses\\n else:\\n self.load()\\n\\n self.selected_point = None if len(self.poses) == 0 else selected_point\\n self.calibration_changed()\\n RosProxy().advertise_service(\\\"set_calibration\\\", SetService, self.set_calibration)\",\n \"def calibrate(self):\\n self.current_state = \\\"calibrate\\\"\\n self.next_state = \\\"idle\\\"\\n self.kinect.loadCameraCalibration()\\n # location_strings = [\\\"lower left corner of board\\\",\\n # \\\"upper left corner of board\\\",\\n # \\\"upper right corner of board\\\",\\n # \\\"lower right corner of board\\\",\\n # \\\"center of shoulder motor\\\"]\\n img = cv2.cvtColor(self.kinect.VideoFrame, cv2.COLOR_RGB2GRAY)\\n img = cv2.resize(img, (640, 480))\\n detector = apriltag(\\\"tagStandard41h12\\\", decimate=1.0)\\n result = detector.detect(img)\\n if len(result) < 4:\\n seen_april = [i['id'] for i in result]\\n occd_april = [str(i) for i in range(4) if i not in seen_april]\\n self.status_message = \\\"April tags Occluded: {}\\\".format(\\n ', '.join(occd_april))\\n print(f\\\"April tags occluded: {', '.join(occd_april)}\\\")\\n time.sleep(2)\\n return\\n for i in range(4):\\n self.kinect.rgb_click_points[i] = result[i]['lb-rb-rt-lt'][(4-i)%4]\\n # print(\\\"Result april:\\\\n\\\", self.kinect.rgb_click_points)\\n # Uncomment below to redo affine\\n # for j in range(5):\\n # self.status_message = \\\"Calibration - Click %s in RGB image\\\" % location_strings[j]\\n # while (self.kinect.new_click == False):\\n # time.sleep(.1)\\n # self.kinect.rgb_click_points[j] = self.kinect.last_click.copy()\\n # self.kinect.new_click = False\\n # print(\\\"Result manual:\\\\n\\\", self.kinect.rgb_click_points)\\n # i = 0\\n # for j in range(5):\\n # self.status_message = \\\"Calibration - Click %s in depth image\\\" % location_strings[j]\\n # while (self.kinect.new_click == False):\\n # time.sleep(.1)\\n # self.kinect.depth_click_points[i] = self.kinect.last_click.copy()\\n # self.kinect.new_click = False\\n # self.kinect.getAffineTransform(\\n # self.kinect.depth_click_points, self.kinect.rgb_click_points)\\n\\n \\\"\\\"\\\"TODO Perform camera calibration here\\\"\\\"\\\"\\n world_coords = np.array([[-0.297, -0.2876, 0], [-0.297, 0.3183, 0],\\n [0.307, 0.3183, 0], [0.3067, -0.2876, 0], [0.0, 0.083, 0.225]])\\n self.status_message = \\\"Calibration - Creating Extrinsic\\\"\\n rgb_click_points_SI = np.float32(self.kinect.rgb_click_points)\\n self.kinect.createExtrinsicCamMat(world_coords, rgb_click_points_SI)\\n self.status_message = \\\"Calibration - Completed Calibration\\\"\\n self.kinect.kinectCalibrated = True\\n cv2.imwrite('depthframergb.jpg', self.kinect.DepthFrameRGB)\\n cv2.imwrite('depthframeraw.jpg', self.kinect.DepthFrameRaw)\\n cv2.imwrite('videoframe.jpg', self.kinect.VideoFrame)\\n time.sleep(1)\",\n \"def arm_calibration(self):\\n self.arm_motor.run_forever(speed_sp=self.MAX_SPEED)\\n while not self.touch_sensor.is_pressed:\\n time.sleep(0.01)\\n self.arm_motor.stop()\\n ev3.Sound.beep().wait()\\n arm_revolutions_for_full_range = 14.2 * 360\\n self.arm_motor.run_to_rel_pos(\\n position_sp=-arm_revolutions_for_full_range,\\n speed_sp=self.MAX_SPEED,\\n stop_action=ev3.Motor.STOP_ACTION_BRAKE)\\n self.arm_motor.wait_while(ev3.Motor.STATE_RUNNING)\\n\\n self.arm_motor.position = 0 # Calibrate the down position as 0 (this\\n # line is correct as is).\",\n \"def get_calibration(self):\\n return GetCalibration(*self.ipcon.send_request(self, BrickletBarometerV2.FUNCTION_GET_CALIBRATION, (), '', 'i i'))\",\n \"def steering_calibration(self):\\n\\n # Minimum change of rotary encoder per 100 ms to detect stall\\n min_difference = 5\\n # Calibration motor power in percentage (absolute)\\n calibration_power = 30\\n\\n print('Calibration of steering axis started')\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n last_pos = 99999999 # any super big number\\n # Left turn calibration\\n while abs(current_pos - last_pos) > min_difference:\\n last_pos = current_pos\\n self.brick_pi.set_motor_power(self.motor_steer, calibration_power)\\n time.sleep(0.1)\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n\\n self.brick_pi.set_motor_power(self.motor_steer, 0)\\n time.sleep(0.1)\\n print('Reset motor encoder after left turn: 0')\\n self.brick_pi.reset_motor_encoder(self.motor_steer)\\n\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n last_pos = 99999999 # any super big number\\n # Right turn calibration\\n while abs(current_pos - last_pos) > min_difference:\\n last_pos = current_pos\\n self.brick_pi.set_motor_power(self.motor_steer, -calibration_power)\\n time.sleep(0.1)\\n current_pos = self.brick_pi.get_motor_encoder(self.motor_steer)\\n\\n self.brick_pi.set_motor_power(self.motor_steer, 0)\\n time.sleep(0.1)\\n self.brick_pi.offset_motor_encoder(self.motor_steer, current_pos / 2)\\n self.steering_limit = abs(\\n self.brick_pi.get_motor_encoder(self.motor_steer))\\n print('Offset motor encoder after right turn: ' +\\n str(self.brick_pi.get_motor_encoder(self.motor_steer)))\\n\\n self.brick_pi.set_motor_position(self.motor_steer, 0)\\n print('Calibration of steering axis completed')\",\n \"def calibration(exp, args):\\n show_text(\\\"Nous allons faire un calibrage\\\", args).present()\\n exp.clock.wait(1500)\\n expyriment.stimuli.FixCross(size=(25, 25),\\n line_width=3,\\n colour=args[\\\"stimuli_color\\\"]).present()\\n exp.clock.wait(2100)\",\n \"def apply_calib(fix_dir, tprobs, run, hour, exper=1, smooth=1, wd=''):\\n\\n # Apply smoothing\\n calib_probs = gaussian_filter(tprobs, smooth, mode='constant')\\n\\n # Apply calibration\\n run_str = str(run).zfill(2)\\n in_dir = f'{fix_dir}/calib_files/{exper}/{run_str}_{hour}.pkl'\\n\\n with open(in_dir, 'rb') as f:\\n corr_data = pickle.load(f, encoding='latin1')\\n\\n for index in np.ndindex(calib_probs.shape):\\n this_forecast = calib_probs * 100\\n if this_forecast[index] < 5:\\n bin = 0\\n elif this_forecast[index] >= 5 and this_forecast[index] < 15:\\n bin = 10\\n elif this_forecast[index] >= 15 and this_forecast[index] < 25:\\n bin = 20\\n elif this_forecast[index] >= 25 and this_forecast[index] < 35:\\n bin = 30\\n elif this_forecast[index] >= 35 and this_forecast[index] < 45:\\n bin = 40\\n elif this_forecast[index] >= 45 and this_forecast[index] < 55:\\n bin = 50\\n elif this_forecast[index] >= 55 and this_forecast[index] < 65:\\n bin = 60\\n elif this_forecast[index] >= 65 and this_forecast[index] < 75:\\n bin = 70\\n elif this_forecast[index] >= 75 and this_forecast[index] < 85:\\n bin = 80\\n elif this_forecast[index] >= 85:\\n bin = 90\\n\\n calib_probs[index] = calib_probs[index] + (corr_data[index][bin] / 100.)\\n calib_probs = calib_probs.astype(float)\\n \\n # Set anything less than 0 after calibration to 0\\n calib_probs[calib_probs < 0] = 0\\n \\n return calib_probs\",\n \"def selfcal_apcal(imc, trial='1'):\\n flagmanager(imc.vislf, mode='restore', versionname='startup')\\n applycal(vis=imc.vislf,\\n spwmap=np.zeros(54),\\n interp='linearPDperobs',\\n gaintable=[imc.path_base+'.pcal'+trial],\\n calwt=False,\\n flagbackup=False)\",\n \"def preCalibrate(self):\\n self._write_enabled = False\\n self.start_recording()\\n\\n origin = (int(self.disp.dispsize[0] / 4), int(self.disp.dispsize[1] / 4))\\n size = (int(2 * self.disp.dispsize[0] / 4), int(2 * self.disp.dispsize[1] / 4))\\n\\n videoFile = os.path.join(c.CALIBVIDEODIR, \\\"--- cal_movie_1.mov\\\")\\n\\n # Initialise a PsychoPy MovieStim\\n mov = visual.MovieStim3(self.video_win, videoFile, flipVert=False)\\n\\n print(\\\"------------> Pre-calibration process started.\\\")\\n print(\\\"------------> When correctly positioned press \\\\'space\\\\' to start the calibration.\\\")\\n\\n while mov.status != visual.FINISHED:\\n if not self.gaze:\\n continue\\n\\n self.screen.clear()\\n\\n # Add the MovieStim to a PyGaze Screen instance.\\n self.screen.screen.append(mov)\\n\\n gaze_sample = copy.copy(self.gaze[-1])\\n\\n validity_colour = (255, 0, 0)\\n\\n if gaze_sample['right_gaze_origin_validity'] and gaze_sample['left_gaze_origin_validity']:\\n left_validity = 0.15 < gaze_sample['left_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\\n right_validity = 0.15 < gaze_sample['right_gaze_origin_in_trackbox_coordinate_system'][2] < 0.85\\n if left_validity and right_validity:\\n validity_colour = (0, 255, 0)\\n\\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0] + size[0], origin[1]), pw=1)\\n self.screen.draw_line(colour=validity_colour, spos=origin, epos=(origin[0], origin[1] + size[1]), pw=1)\\n self.screen.draw_line(colour=validity_colour,\\n spos=(origin[0], origin[1] + size[1]),\\n epos=(origin[0] + size[0], origin[1] + size[1]),\\n pw=1)\\n self.screen.draw_line(colour=validity_colour,\\n spos=(origin[0] + size[0], origin[1] + size[1]),\\n epos=(origin[0] + size[0], origin[1]),\\n pw=1)\\n\\n right_eye, left_eye, distance = None, None, []\\n if gaze_sample['right_gaze_origin_validity']:\\n distance.append(round(gaze_sample['right_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\\n right_pos = gaze_sample['right_gaze_origin_in_trackbox_coordinate_system']\\n right_eye = ((1 - right_pos[0]) * size[0] + origin[0], right_pos[1] * size[1] + origin[1])\\n self.screen.draw_circle(colour=validity_colour,\\n pos=right_eye,\\n r=int(self.disp.dispsize[0] / 100),\\n pw=5,\\n fill=True)\\n\\n if gaze_sample['left_gaze_origin_validity']:\\n distance.append(round(gaze_sample['left_gaze_origin_in_user_coordinate_system'][2] / 10, 1))\\n left_pos = gaze_sample['left_gaze_origin_in_trackbox_coordinate_system']\\n left_eye = ((1 - left_pos[0]) * size[0] + origin[0], left_pos[1] * size[1] + origin[1])\\n self.screen.draw_circle(colour=validity_colour,\\n pos=left_eye,\\n r=int(self.disp.dispsize[0] / 100),\\n pw=5,\\n fill=True)\\n\\n self.screen.draw_text(text=\\\"Current distance to the eye tracker: {0} cm.\\\".format(self._mean(distance)),\\n pos=(int(self.disp.dispsize[0] / 2), int(self.disp.dispsize[1] * 0.9)),\\n colour=(255, 255, 255),\\n fontsize=20)\\n\\n self.disp.fill(self.screen)\\n self.disp.show()\\n\\n key = self._getKeyPress()\\n if key == \\\"space\\\":\\n break\\n\\n\\n\\n if mov.status != visual.FINISHED:\\n # pause and discard video for the audio to stop as well\\n mov.pause()\\n self.screen.screen.remove(mov)\\n #video_win.close()\\n del mov\\n self.screen.clear()\\n clock.pause(1000)\\n return True\\n else:\\n return False\",\n \"def calibrer(self):\\n self._angle_courant = self._angle_initial\\n self.angle(self._angle_initial)\",\n \"def recalibrate_start(self):\\n self.epoch += 1\\n self.initialize()\\n self.recalibration_i = 0\\n\\n if self.vr_from_epoch is not None and self.epoch >= self.vr_from_epoch:\\n for group in self.param_groups:\\n for p in group['params']:\\n param_state = self.state[p]\\n param_state['gavg'].zero_()\\n param_state['m2'].zero_()\\n\\n # xk is changed to the running_x\\n p.data.zero_().add_(param_state['running_x'])\\n param_state['tilde_x'] = p.data.clone()\",\n \"async def test_calibrate_gripper(\\n decoy: Decoy,\\n ot3_hardware_api: OT3API,\\n _mock_ot3_calibration: None,\\n params_probe: CalibrateGripperParamsJaw,\\n expected_hc_probe: GripperProbe,\\n) -> None:\\n subject = CalibrateGripperImplementation(hardware_api=ot3_hardware_api)\\n\\n params = CalibrateGripperParams(jaw=params_probe)\\n decoy.when(\\n await ot3_calibration.calibrate_gripper_jaw(\\n ot3_hardware_api, probe=expected_hc_probe\\n )\\n ).then_return(Point(1.1, 2.2, 3.3))\\n\\n result = await subject.execute(params)\\n assert result == CalibrateGripperResult(jawOffset=Vec3f(x=1.1, y=2.2, z=3.3))\",\n \"def calibrate(this, display=False, **kargs): # C'est des maths.\\n\\t\\t# a -> Angle Alpha\\n\\t\\t# b -> Angle Beta\\n\\t\\t\\n\\t\\th = float(kargs.get('h', 1))\\n\\t\\tw = float(kargs.get('w', 1))\\n\\t\\t\\n\\t\\t# Verif de l'espace\\n\\t\\tspace = this._SPACE\\n\\t\\tif not space: return None\\n\\t\\t\\n\\t\\t#try:\\n\\t\\ttry:\\n\\t\\t\\n\\t\\t\\t# Calcul d'angles\\n\\t\\t\\ta = this._FOV.x * (space.i - space.o)\\n\\t\\t\\tb = this._FOV.x * (space.o - space.j)\\n\\t\\t\\n\\t\\t\\t# On essaye gentillement\\n\\t\\t\\tCa = w - h / math.tan(b)\\n\\t\\t\\tCb = h - w / math.tan(a)\\n\\t\\t\\tkx = Ca/Cb\\n\\t\\t\\t\\n\\t\\t\\t# Position finale\\n\\t\\t\\tthis._POS.x = x = h * (kx + 1 / math.tan(b)) / (1 + kx**2)\\n\\t\\t\\tthis._POS.y = x * kx\\n\\t\\t\\n\\t\\t# Erm\\n\\t\\texcept: this._POS = None\\n\\t\\t\\n\\t\\t# Petit affichage oklm\\n\\t\\tif display: print 'Calibration: %f %f %s' % (math.degrees(a), math.degrees(b), ~this._POS)\\n\\t\\treturn this._POS\",\n \"def rerun_calibrator(base_dir):\\n import infer_sequence\\n # base_dir = 'data/batch4'\\n collection_dir = 'calib_data'\\n calib = Calibrator().init_from_data(os.path.join(base_dir, collection_dir))\\n # calib.gen_calib_parameters()\\n calib.show_images()\",\n \"def platform_auto_calibrate_elevation_servo(self):\\n self._platform_auto_calibrate_check()\\n self.platform.auto_calibrate_elevation_servo()\",\n \"def calibrate(self):\\n with completion_context(\\\"Estimating sensor offset\\\", color=\\\"c\\\", bright=True):\\n # Reset calibration\\n self._sens_offset = np.zeros(4) # last two entries are never calibrated but useful for broadcasting\\n self._wait_for_pole_at_rest()\\n\\n # Create parts of the calibration controller\\n go_right = QQubeGoToLimCtrl(positive=True, cnt_done=int(1.5 / self._dt))\\n go_left = QQubeGoToLimCtrl(positive=False, cnt_done=int(1.5 / self._dt))\\n go_center = QQubePDCtrl(self.spec)\\n\\n # Estimate alpha offset. Go to both limits for theta calibration.\\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\\n while not go_right.done:\\n meas = self._qsoc.snd_rcv(go_right(to.from_numpy(meas)))\\n while not go_left.done:\\n meas = self._qsoc.snd_rcv(go_left(to.from_numpy(meas)))\\n self._sens_offset[0] = (go_right.th_lim + go_left.th_lim) / 2\\n\\n # Estimate alpha offset\\n self._wait_for_pole_at_rest()\\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\\n self._sens_offset[1] = meas[1]\\n\\n print_cbt(\\n f\\\"Sensor offset: \\\"\\n f\\\"theta = {self._sens_offset[0]*180/np.pi:.3f} deg, \\\"\\n f\\\"alpha = {self._sens_offset[1]*180/np.pi:.3f} deg\\\",\\n \\\"g\\\",\\n )\\n\\n with completion_context(\\\"Centering cube\\\", color=\\\"c\\\", bright=True):\\n meas = self._qsoc.snd_rcv(np.zeros(self.act_space.shape))\\n while not go_center.done:\\n meas = self._qsoc.snd_rcv(go_center(to.from_numpy(meas - self._sens_offset)))\",\n \"def __init__(self):\\n self._read_calibration_data()\\n self.configure_sensor(\\n TemperatureOversamplings.x08,\\n PressureOversamplings.x16,\\n HumidityOversamplings.x08,\\n IIRFilterCoefficients.FC_003,\\n 250,\\n 250)\",\n \"def calibrate(self, cal=1.0, pol_eff=1.0):\\n \\n if self.ncomp == 1:\\n self.data *= cal\\n else:\\n self.data[0] *= cal\\n self.data[1] *= cal * pol_eff\\n self.data[2] *= cal * pol_eff\\n\\n return self\",\n \"def updateParameters(self):\\r\\n\\r\\n\\t\\tif self.approach.altered:\\r\\n\\t\\t\\tself.transform.enabled = True\\r\\n\\r\\n\\t\\t\\tif self.approach.value == 'Locations in the DEM generated from field observations':\\r\\n\\t\\t\\t\\tself.predefined_pattern.enabled = False\\r\\n\\t\\t\\t\\tself.pattern_workspace.enabled = False\\r\\n\\t\\t\\t\\tself.point_matrix_size.enabled = True\\r\\n\\t\\t\\t\\tself.point_vectors.enabled = True\\r\\n\\t\\t\\t\\tself.mapping_field.enabled = True\\r\\n\\t\\t\\t\\tself.move_to_max.enabled = True\\r\\n\\t\\t\\t\\tself.output_sim_matrix.enabled = True\\r\\n\\t\\t\\t\\tself.mh_dil_val.enabled = False\\r\\n\\r\\n\\t\\t\\t\\tself.mh_iteration.enabled = False\\r\\n\\t\\t\\t\\tself.mh_iteration.value = False\\r\\n\\t\\t\\t\\tself.output_table.enabled = False\\r\\n\\t\\t\\t\\tself.output_raster_workspace.enabled = False\\r\\n\\t\\t\\t\\tself.output_raster_workspace.value = ''\\r\\n\\r\\n\\t\\t\\telif self.approach.value == 'Locations in the DEM versus pre-defined pattern':\\r\\n\\t\\t\\t\\tself.predefined_pattern.enabled = True\\r\\n\\t\\t\\t\\tself.point_matrix_size.enabled = True\\r\\n\\t\\t\\t\\tself.point_vectors.enabled = True\\r\\n\\t\\t\\t\\tself.mapping_field.enabled = True\\r\\n\\t\\t\\t\\tself.move_to_max.enabled = True\\r\\n\\t\\t\\t\\tself.mh_dil_val.enabled = True\\r\\n\\t\\t\\t\\tself.mh_iteration.enabled = True\\r\\n\\t\\t\\t\\tself.output_table.enabled = True\\r\\n\\t\\t\\t\\tself.output_sim_matrix.enabled = False\\r\\n\\t\\t\\t\\tself.output_sim_matrix.value = ''\\r\\n\\t\\t\\t\\tself.output_raster_workspace.enabled = False\\r\\n\\t\\t\\t\\tself.output_raster_workspace.value = ''\\r\\n\\r\\n\\t\\t\\telse: # seek pre-defined pattern in DEM\\r\\n\\t\\t\\t\\tself.predefined_pattern.enabled = True\\r\\n\\t\\t\\t\\tself.point_matrix_size.enabled = True\\r\\n\\t\\t\\t\\tself.mh_iteration.enabled = True\\r\\n\\t\\t\\t\\tself.output_raster_workspace.enabled = True\\r\\n\\t\\t\\t\\tself.point_vectors.enabled = False\\r\\n\\t\\t\\t\\tself.point_vectors.value = ''\\r\\n\\t\\t\\t\\tself.mapping_field.enabled = False\\r\\n\\t\\t\\t\\tself.move_to_max.enabled = False\\r\\n\\t\\t\\t\\tself.move_to_max.value = False\\r\\n\\t\\t\\t\\tself.mh_dil_val.enabled = True\\r\\n\\t\\t\\t\\tself.output_sim_matrix.enabled = False\\r\\n\\t\\t\\t\\tself.output_sim_matrix.value = ''\\r\\n\\t\\t\\t\\tself.output_table.enabled = False\\r\\n\\t\\t\\t\\tself.output_table.value = ''\\r\\n\\r\\n\\t\\tif self.mh_iteration.altered:\\r\\n\\r\\n\\t\\t\\tif self.mh_iteration.value is True:\\r\\n\\t\\t\\t\\tself.mh_dil_start.enabled = True\\r\\n\\t\\t\\t\\tself.mh_dil_stop.enabled = True\\r\\n\\t\\t\\t\\tself.mh_dil_step.enabled = True\\r\\n\\t\\t\\t\\tself.mh_dil_val.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_val.value = 1\\r\\n\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tif self.approach.value == 'Locations in the DEM generated from field observations':\\r\\n\\t\\t\\t\\t\\tself.mh_dil_val.enabled = False\\r\\n\\t\\t\\t\\t\\tself.mh_dil_val.value = 1\\r\\n\\t\\t\\t\\telse:\\r\\n\\t\\t\\t\\t\\tself.mh_dil_val.enabled = True\\r\\n\\r\\n\\t\\t\\t\\tself.mh_dil_start.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_stop.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_step.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_start.value = 0.01\\r\\n\\t\\t\\t\\tself.mh_dil_stop.value = 1\\r\\n\\t\\t\\t\\tself.mh_dil_step.value = 0.1\\r\\n\\r\\n\\t\\tif self.move_to_max.altered:\\r\\n\\t\\t\\tif self.move_to_max.value is True:\\r\\n\\t\\t\\t\\tself.move_to_max_distance.enabled = True\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tself.move_to_max_distance.enabled = False\\r\\n\\t\\t\\t\\tself.move_to_max_distance.value = 3\\r\\n\\r\\n\\t\\tif self.transform.altered:\\r\\n\\t\\t\\tif self.transform.value == 'Work directly on the elevation matrix':\\r\\n\\t\\t\\t\\tself.size_of_the_cell.enabled = False\\r\\n\\t\\t\\telif self.transform.value == 'Perform a local translation':\\r\\n\\t\\t\\t\\tself.size_of_the_cell.enabled = False\\r\\n\\t\\t\\telif self.transform.value == 'Compute slopes' or self.transform.value == \\\\\\r\\n\\t\\t\\t\\t\\t'Compute slopes and perform local translation':\\r\\n\\t\\t\\t\\tself.size_of_the_cell.enabled = True\\r\\n\\r\\n\\t\\tif self.predefined_pattern.altered:\\r\\n\\t\\t\\tif self.predefined_pattern.value == 'Custom pattern':\\r\\n\\t\\t\\t\\tself.pattern_workspace.enabled = True\\r\\n\\r\\n\\t\\t\\t\\tself.mh_iteration.value = False\\r\\n\\t\\t\\t\\tself.mh_iteration.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_start.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_stop.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_step.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_start.value = 0.01\\r\\n\\t\\t\\t\\tself.mh_dil_stop.value = 1\\r\\n\\t\\t\\t\\tself.mh_dil_step.value = 0.1\\r\\n\\t\\t\\t\\tself.mh_dil_val.enabled = False\\r\\n\\t\\t\\t\\tself.mh_dil_val.value = 1\\r\\n\\t\\t\\telse:\\r\\n\\t\\t\\t\\tself.pattern_workspace.enabled = False\",\n \"def calibrate(raw_data, white_reference, dark_reference):\\n # Auto-increment device\\n params.device += 1\\n\\n # Collect the number of wavelengths present\\n num_bands = len(white_reference.wavelength_dict)\\n den = white_reference.array_data - dark_reference.array_data\\n\\n # Calibrate using reflectance = (raw data - dark reference) / (white reference - dark reference)\\n output_num = []\\n for i in range(0, raw_data.lines):\\n ans = raw_data.array_data[i,].astype(np.float16) - dark_reference.array_data\\n output_num.append(ans)\\n num = np.stack(output_num, axis=2)\\n output_calibrated = []\\n for i in range(0, raw_data.lines):\\n ans1 = raw_data.array_data[i,] / den\\n output_calibrated.append(ans1)\\n\\n # Reshape into hyperspectral datacube\\n scalibrated = np.stack(output_calibrated, axis=2)\\n calibrated_array = np.transpose(scalibrated[0], (1, 0, 2))\\n calibrated_array[np.where(calibrated_array < 0)] = 0\\n\\n # Find array min and max values\\n max_pixel = float(np.amax(calibrated_array))\\n min_pixel = float(np.amin(calibrated_array))\\n\\n # Make a new class instance with the calibrated hyperspectral image\\n calibrated = Spectral_data(array_data=calibrated_array, max_wavelength=raw_data.max_wavelength,\\n min_wavelength=raw_data.min_wavelength, max_value=max_pixel, min_value=min_pixel,\\n d_type=raw_data.d_type,\\n wavelength_dict=raw_data.wavelength_dict, samples=raw_data.samples,\\n lines=raw_data.lines, interleave=raw_data.interleave,\\n wavelength_units=raw_data.wavelength_units, array_type=raw_data.array_type,\\n pseudo_rgb=None, filename=None, default_bands=raw_data.default_bands)\\n\\n # Make pseudo-rgb image for the calibrated image\\n calibrated.pseudo_rgb = _make_pseudo_rgb(spectral_array=calibrated)\\n\\n if params.debug == \\\"plot\\\":\\n # Gamma correct pseudo_rgb image\\n plot_image(calibrated.pseudo_rgb)\\n elif params.debug == \\\"print\\\":\\n print_image(calibrated.pseudo_rgb, os.path.join(params.debug_outdir, str(params.device) + \\\"_calibrated_rgb.png\\\"))\\n\\n return calibrated\",\n \"def calibrateAutoGuider(self, exposureLengthSeconds):\\n\\n print \\\"Calibrating autoguider orientation...\\\"\\n self.camera.GuiderCalibrate(exposureLengthSeconds)\\n while self.camera.GuiderRunning:\\n sys.stdout.write(\\\".\\\")\\n time.sleep(1)\\n print\\n print \\\"Calibration finished\\\"\",\n \"def rm_calibration(self):\\n\\n self.bin_edges_kev = None\",\n \"def train_calibration(config):\\n run_dates = pd.date_range(start=config.start_dates[\\\"train\\\"],\\n end=config.end_dates[\\\"train\\\"],\\n freq='1D').strftime(config.run_date_format)\\n \\n target_calib_models = {}\\n print()\\n print('Loading Data')\\n\\n for size_index,size in enumerate(config.size_threshold):\\n target_calib_models[size] = {}\\n train_files, target_files = [], []\\n for date in run_dates: \\n train_data_files = glob(config.train_data_path+ \\\\\\n \\\"20{2}/netcdf/*{0}*unsmoothed*_{1}_*{2}*{3}*{4}.nc\\\".format(\\n config.forecast_model_names,size,date,\\n config.start_hour,config.end_hour))\\n if len(train_data_files) < 1:\\n continue\\n if config.sector:\\n target_data_files = glob(config.target_data_path+'{0}*{1}*{2}*.nc'.format(\\n date,size,config.sector)) \\n else:\\n target_data_files = glob(config.target_data_path+'{0}*{1}*.nc'.format(\\n date,size))\\n if len(target_data_files) < 1:\\n continue\\n train_files.append(train_data_files[0])\\n target_files.append(target_data_files[0])\\n \\n date_indices = [index for index in range(len(train_files))]\\n percent_train_indices = int(len(train_files)*0.70)\\n t_data = [Dataset(x).variables[\\\"Data\\\"][:] for x in train_files] \\n tar_data = [Dataset(x).variables[\\\"24_Hour_All_12z_12z\\\"][:] for x in target_files] \\n print()\\n print('Number of files:')\\n print('Train (70%): {0}'.format(int(len(t_data)*0.70)))\\n print('Validate (30%): {0}'.format(int(len(t_data)*0.30)))\\n print()\\n for ind,model_name in enumerate(config.calibration_model_names):\\n bs = []\\n random_models = []\\n print('Random Cross-Validation, {0} >{1}mm'.format(model_name,size)) \\n random_seed = random.sample(range(1, 100), 10)\\n for s,seed in enumerate(random_seed):\\n np.random.seed(seed)\\n print('Index',s, 'Random Seed', seed)\\n train_indices = np.random.choice(date_indices, percent_train_indices, replace=False)\\n test_indices = [ind for ind in date_indices if ind not in train_indices]\\n \\n train_data = np.array(t_data)[train_indices].ravel()\\n target_train_data = np.array(tar_data)[train_indices].ravel()\\n \\n val_data = np.array(t_data)[test_indices].ravel()\\n target_val_data = np.array(tar_data)[test_indices].ravel()\\n \\n model = deepcopy(config.calibration_model_objs[ind])\\n model.fit(train_data,target_train_data)\\n random_models.append(model)\\n \\n predict = model.transform(val_data)\\n \\n #plt.figure(figsize=(9, 6))\\n #plt.plot(sorted(val_data),model.transform(sorted(val_data)))\\n #plt.xlabel('data')\\n #plt.ylabel('calibrated')\\n #plt.show()\\n #plt.close()\\n\\n print(brier_score(predict, target_val_data))\\n bs.append(brier_score(predict, target_val_data))\\n \\n best_bs = np.argmin(bs)\\n target_calib_models[size][model_name] = np.array(random_models)[best_bs]\\n print('Lowest Brier Score: {0}'.format(np.array(bs)[best_bs]))\\n print()\\n print()\\n return target_calib_models\",\n \"def _calibration_test(self, dataset_name):\\n self.setup_flags()\\n test_setup = self._get_setup(dataset_name)\\n if test_setup[\\\"error_test\\\"]:\\n self._calibration_error_test(dataset_name, \\\"Calibration\\\")\\n else:\\n self.run_app(\\\"Calibration\\\")\\n record = parse_calibration_results(\\n self.io_args.log_dir, bin_name=\\\"Calibration\\\"\\n )\\n self.check_metrics(record, test_setup)\",\n \"def Update(self, time, val):\\n self['data'] = self.owner['calibrationCurve'](val)\\n self['time'] = time\\n\\n if self.owner.SAVE:\\n self.File.write('%f , %f\\\\n' %(time, self['data'][-1] ))\",\n \"def handle_calibrate_button(button_state, robot):\\n if button_state:\\n robot.arm_calibration()\",\n \"def read_images_gen_cal(self, path: str) -> dict:\\n image_files = []\\n # read in all image paths (for png and jpgs)\\n image_files.extend(glob.glob(os.path.join(path, '*.png')))\\n image_files.extend(glob.glob(os.path.join(path, '*.jpg')))\\n\\n if len(image_files) <= 0:\\n raise FileNotFoundError('Could not find any image files for camera calibration (png, jppgs supported!')\\n\\n # preparation of the 'real world' points like in CarND-Camera-Calibration repository ipynb!\\n syn_objp = np.zeros((self._chessboard_shape[1] * self._chessboard_shape[0], 3), np.float32)\\n syn_objp[:, :2] = np.mgrid[0:self._chessboard_shape[0], 0:self._chessboard_shape[1]].T.reshape(-1, 2)\\n\\n # Arrays to store all points pairs from the images. They will be used for calibration computation.\\n objpoints = []\\n imgpoints = []\\n img_size = None\\n\\n for file_name in image_files:\\n img = cv2.imread(file_name)\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\n # remember shape of images\\n if img_size is None:\\n img_size = (gray.shape[1], gray.shape[0])\\n\\n # Chessboard detection\\n res, chess_pts = cv2.findChessboardCorners(gray, self._chessboard_shape, None)\\n # Debug\\n # painted = cv2.drawChessboardCorners(img, self._chessboard_shape, chess_pts, res)\\n if res:\\n objpoints.append(syn_objp)\\n imgpoints.append(chess_pts)\\n\\n if len(objpoints) <= 0:\\n raise ValueError('No Chessboard detected on images.')\\n\\n # Do camera calibration given object points and image points\\n ret, mtx, dist, _, _ = cv2.calibrateCamera(objpoints, imgpoints, img_size, None, None)\\n if not ret:\\n raise ValueError('cv2.calibrateCamera() failed.')\\n\\n # prepare return value dictionary\\n ret = {'mtx': mtx, 'dist': dist}\\n return ret\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7903501","0.72188723","0.715543","0.6955527","0.6883555","0.68081695","0.6804072","0.67732644","0.67554444","0.66887903","0.66198134","0.6617778","0.6552011","0.65246826","0.6487285","0.6455561","0.644588","0.63531816","0.62793285","0.62448484","0.62343943","0.62199223","0.620731","0.6186124","0.6174031","0.61554503","0.6121237","0.6048084","0.60455334","0.6032227","0.6008749","0.5994861","0.59866136","0.5977744","0.59653854","0.5950392","0.5944048","0.59355706","0.5921544","0.5920451","0.5909717","0.58960605","0.5891651","0.58836067","0.5879855","0.5818735","0.58111984","0.57894456","0.57729226","0.57530504","0.57505566","0.5749888","0.5747418","0.5745138","0.571002","0.5706912","0.5701707","0.57001865","0.5668824","0.563402","0.5632326","0.56247884","0.5610126","0.5607568","0.5604812","0.56022763","0.5600366","0.5598483","0.5593244","0.5591816","0.5570536","0.5568128","0.5567337","0.55593896","0.5558522","0.55451983","0.553914","0.5534445","0.5531272","0.55030876","0.5483322","0.54701155","0.54694295","0.5468729","0.5465478","0.54491323","0.5446884","0.54356146","0.5425704","0.5410505","0.5409966","0.54040444","0.53902024","0.5385562","0.53833","0.53716844","0.5367202","0.5361569","0.5357641","0.53562886"],"string":"[\n \"0.7903501\",\n \"0.72188723\",\n \"0.715543\",\n \"0.6955527\",\n \"0.6883555\",\n \"0.68081695\",\n \"0.6804072\",\n \"0.67732644\",\n \"0.67554444\",\n \"0.66887903\",\n \"0.66198134\",\n \"0.6617778\",\n \"0.6552011\",\n \"0.65246826\",\n \"0.6487285\",\n \"0.6455561\",\n \"0.644588\",\n \"0.63531816\",\n \"0.62793285\",\n \"0.62448484\",\n \"0.62343943\",\n \"0.62199223\",\n \"0.620731\",\n \"0.6186124\",\n \"0.6174031\",\n \"0.61554503\",\n \"0.6121237\",\n \"0.6048084\",\n \"0.60455334\",\n \"0.6032227\",\n \"0.6008749\",\n \"0.5994861\",\n \"0.59866136\",\n \"0.5977744\",\n \"0.59653854\",\n \"0.5950392\",\n \"0.5944048\",\n \"0.59355706\",\n \"0.5921544\",\n \"0.5920451\",\n \"0.5909717\",\n \"0.58960605\",\n \"0.5891651\",\n \"0.58836067\",\n \"0.5879855\",\n \"0.5818735\",\n \"0.58111984\",\n \"0.57894456\",\n \"0.57729226\",\n \"0.57530504\",\n \"0.57505566\",\n \"0.5749888\",\n \"0.5747418\",\n \"0.5745138\",\n \"0.571002\",\n \"0.5706912\",\n \"0.5701707\",\n \"0.57001865\",\n \"0.5668824\",\n \"0.563402\",\n \"0.5632326\",\n \"0.56247884\",\n \"0.5610126\",\n \"0.5607568\",\n \"0.5604812\",\n \"0.56022763\",\n \"0.5600366\",\n \"0.5598483\",\n \"0.5593244\",\n \"0.5591816\",\n \"0.5570536\",\n \"0.5568128\",\n \"0.5567337\",\n \"0.55593896\",\n \"0.5558522\",\n \"0.55451983\",\n \"0.553914\",\n \"0.5534445\",\n \"0.5531272\",\n \"0.55030876\",\n \"0.5483322\",\n \"0.54701155\",\n \"0.54694295\",\n \"0.5468729\",\n \"0.5465478\",\n \"0.54491323\",\n \"0.5446884\",\n \"0.54356146\",\n \"0.5425704\",\n \"0.5410505\",\n \"0.5409966\",\n \"0.54040444\",\n \"0.53902024\",\n \"0.5385562\",\n \"0.53833\",\n \"0.53716844\",\n \"0.5367202\",\n \"0.5361569\",\n \"0.5357641\",\n \"0.53562886\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.5947198"},"document_rank":{"kind":"string","value":"36"}}},{"rowIdx":21393,"cells":{"query":{"kind":"string","value":"Data should not be saved when an error is raised."},"document":{"kind":"string","value":"async def test_calibrate_gripper_does_not_save_during_error(\n decoy: Decoy, ot3_hardware_api: OT3API\n) -> None:\n subject = CalibrateGripperImplementation(hardware_api=ot3_hardware_api)\n\n params = CalibrateGripperParams(\n jaw=CalibrateGripperParamsJaw.REAR,\n otherJawOffset=Vec3f(x=4.4, y=5.5, z=6.6),\n )\n\n decoy.when(\n await ot3_calibration.calibrate_gripper_jaw(\n ot3_hardware_api, probe=GripperProbe.REAR\n )\n ).then_raise(EarlyCapacitiveSenseTrigger(5.0, 3.0))\n\n with pytest.raises(EarlyCapacitiveSenseTrigger):\n await subject.execute(params)\n\n decoy.verify(\n await ot3_hardware_api.save_instrument_offset(\n mount=OT3Mount.LEFT, delta=Point(x=3, y=4, z=6)\n ),\n times=0,\n )"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def save_data(self):\n pass","def saveData(self):\n pass","def save(self):\r\n try:\r\n self.process_save()\r\n except InputError as ex:\r\n print(ex)\r\n self.save()\r\n except KeyError:\r\n print(\"No saved data to save/load. Please save some data before loading in data.\")\r\n self.menu_page()","def _load_data(self):\n logging.warning('-> loading EMPTY data...')","def check_for_new_data(self):\n return","def clean_up_data(self):\n pass","def _validate_create_data(self, data):\n return","def _save_data(self):\n super()._save_data()\n if self.data:\n # FIXES [BUG-034].\n WeatherForecastObservation.objects.all().delete()\n self.state['inserted_elements'] = len(WeatherForecastObservation.objects.bulk_create(self.data))\n self.logger.info('Successfully saved %d elements.' % self.state['inserted_elements'])\n else:\n self.logger.info('No elements were saved because no elements were available.')\n self.data = None","def invalid(self):\n pass","def test_State_save_none(self):\n with self.assertRaises(TypeError):\n State.save()","def validate_dataset(self):\n pass","def reset_data(self):\n try:\n self._data = self._schema({})\n except vol.Invalid as ex:\n _LOGGER.error(\"Can't reset %s: %s\",\n self._file, humanize_error(self._data, ex))","def _handle_save(self, error):\n err_id = error.get('id', None)\n if err_id is None:\n return False\n # save each error under its id\n self._storage[err_id] = error\n # notify new error\n event.notify(NotifyTraceback(error))\n return True","def dummy():\n\t\t\tself.save()","def _save_data(self):\n super()._save_data()\n if self.data:\n self.state['inserted_elements'] = len(SeaLevelRiseMeasure.objects.bulk_create(self.data))\n self.logger.info('Successfully saved %d elements.' % self.state['inserted_elements'])\n else:\n self.logger.info('No elements were saved because no elements were available.')\n self.data = None","def save(self):\n raise NotImplementedError()","def save(self, *args, **kwargs):\n raise NotImplementedError('missing data mixin')","def test_basemodel_save_none(self):\n with self.assertRaises(TypeError):\n BaseModel.save()","def test_missing_data(self):\n survey = SurveyFactory.create()\n\n orig_data = {\n 'experiment_version': '1',\n 'response_version': 1,\n 'person_id': 'joemamma',\n 'survey_id': survey.name,\n 'flow_id': '20141113',\n 'question_id': '1',\n 'updated_ts': self.timestamp(),\n 'question_text': 'how was lunch?',\n 'variation_id': '1'\n }\n\n for key in orig_data.keys():\n data = dict(orig_data)\n del data[key]\n\n resp = self.client.post(\n reverse('heartbeat-api'),\n content_type='application/json',\n data=json.dumps(data))\n\n assert resp.status_code == 400\n resp_data = json.loads(resp.content)\n assert key in resp_data['errors']","def data_raise(self, data):\n self.put_nowait(data)","def bad(self):\n raise NotImplementedError","def bad(self):\n raise NotImplementedError","def check_Data(self):\r\n \r\n if self._target_data is None:\r\n self.processData()","def _validate_update_data(self, data):\n return","def save(self):\n return None","def check_is_saved(self):\n raise NotImplementedError()","def _handle_load_unknown(self, data, original):\n for key, val in original.items():\n if key not in self.fields:\n data[key] = val\n return data","def __getstate__(self):\n raise IOError(\"You tried to serialize something that should not\"\n \" be serialized.\")","def test_ensure_data_no_totalseconds(self):\n album = Album(artist='Artist', album='Album', totaltracks=2)\n with self.assertRaises(Exception):\n album.ensure_data()","def test_insert_empty_data(self):\n self.engine.insert_data(self.empty_data)\n self.assertDictEqual(self.ds.store, {})","def validate_data_frame(self):\n try:\n # Verify the data frame\n pandas.verify_data_frame(self.data_frame)\n except OnTaskDataFrameNoKey as exc:\n self.add_error(None, str(exc))\n return\n\n # Store the data frame in the DB.\n try:\n # Get frame info with three lists: names, types and is_key\n self.frame_info = pandas.store_temporary_dataframe(\n self.data_frame,\n self.workflow)\n except Exception as exc:\n self.add_error(\n None,\n _('Unable to process file ({0}).').format(str(exc)))","def save(self):\n raise NotImplementedError","def save(self):\n raise NotImplementedError","def save(self):\n raise NotImplementedError","def error_false(self):\n self.errors = self.errors[0:-1]\n if not self.errors:\n self.update_info()","def _save_update(self):\n try:\n self()\n except SignalValueError:\n pass\n except Exception:\n # Allow post-mortem debugging\n type_, value, tb = sys.exc_info()\n tb = tb.tb_next # Skip *this* frame\n sys.last_type = type_\n sys.last_value = value\n sys.last_traceback = tb\n del tb # Get rid of it in this namespace\n logging.exception(value)","def save(self, data):\n\t\tif self.value:\n\t\t\tdata['value'] = self.value","def save(self, *args, **kwargs):\n if self.name == '':\n raise FieldError\n else:\n return super(CrossRefDB, self).save(*args, **kwargs)","def _restore_data_inputs(self):\n super()._restore_data_inputs()\n self.training_data = (\n self._data.training_data.data if self._data.training_data and self._data.training_data.data else None\n )\n self.validation_data = (\n self._data.validation_data.data if self._data.validation_data and self._data.validation_data.data else None\n )","def save_end(self):\n data = self.savedata\n self.savedata = None\n return data","def save(self, doing_import=False):\n if doing_import:\n super(CombinedTeledata, self).save()\n else:\n raise NotImplementedError(message=\"Saving is not possible on this method unless importing.\")","def pre_save(self):\r\n self.validate()","def save(self) -> None:\n pass","def save(self) -> None:\n pass","def save(self) -> None:\n pass","def test_object_is_not_created_without_required_fields(self):\n data1 = self.data.copy()\n del data1[\"title\"]\n\n serializer = ProductSerializer(data=data1)\n\n self.assertFalse(serializer.is_valid())\n self.assertEqual(serializer.errors.get(\"title\")[0], self.error_message)\n\n data2 = self.data.copy()\n del data2[\"description\"]\n\n serializer = ProductSerializer(data=data2)\n self.assertFalse(serializer.is_valid())\n self.assertEqual(serializer.errors.get(\"description\")[0], self.error_message)\n\n data3 = self.data.copy()\n del data3[\"price\"]\n\n serializer = ProductSerializer(data=data3)\n self.assertFalse(serializer.is_valid())\n self.assertEqual(serializer.errors.get(\"price\")[0], self.error_message)","def test_raise_on_write_when_frozen(self):\n self.test_model.freeze()\n self.assertRaises(errors.PersistenceError, self.test_model.save)","def error(self):\n pass","def test_export_data_none(self) -> None:\n user_data = user_models.ExpUserLastPlaythroughModel.export_data(\n self.NONEXISTENT_USER_ID)\n expected_data: Dict[str, Dict[str, str]] = {}\n self.assertEqual(expected_data, user_data)","def clean_data(self):\n return self.instance.data","def test_storing_missing_data(self):\n data = {\"employer\": \"Trading Ltd\", \"jobTitle\": \"Assistant\", \"jobLocation\": \"5th street\",\n \"fromMonth\": \"january\", \"fromYear\": 2007}\n response = self.client.post(self.url, data=json.dumps(data), content_type='application/json')\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, msg=response.content.decode())","def load_data(self, data):\n self.data = data\n self.validate()","def test_attempting_to_save_abstract_model_fails(self):\r\n with self.assertRaises(CQLEngineException):\r\n AbstractModelWithFullCols.create(pkey=1, data=2)","def insert_data(self):\n\n pass","def required_field_fail(self, field, data):\n self.add_required_field_fail(field, data)\n self.update_required_field_fail(field, data)","def test_ensure_data_no_totaltracks(self):\n album = Album(artist='Artist', album='Album', totalseconds=120)\n with self.assertRaises(Exception):\n album.ensure_data()","def test_save(self):\r\n self.assertRaises(StorageNotSetError, self.config.save)","def save(self, *args, **kwargs):\n if self.survey.published:\n # pylint: disable=no-member\n super(Response, self).save(*args, **kwargs)\n else:\n raise DBError('This survey has not been published')","def test_export_data_on_nonexistent_user(self) -> None:\n user_data = user_models.CollectionProgressModel.export_data(\n self.NONEXISTENT_USER_ID)\n expected_data: Dict[str, str] = {}\n self.assertEqual(expected_data, user_data)","def __init__(self, message=\"\"):\n super(DataError, self).__init__(message)","def test_quest_load_data_fail(testing_quest_page):\n testing_quest_page.save()\n\n # fetch the data\n doc = testing_quest_page.doc_ref.get()\n data = testing_quest_page.storage_model.parse_obj(doc.to_dict())\n\n # mess with the data\n data.serialized_data = json.dumps({\"this\": \"nonesense\"})\n testing_quest_page.doc_ref.set(data.dict())\n\n # try to load with the bad version\n with pytest.raises(QuestLoadError):\n testing_quest_page.load()\n\n # cleanup\n testing_quest_page.delete()","def bad_data_fail(self, good_data, bad_data, message):\n self.add_fail(bad_data, message)\n self.update_fail(good_data, bad_data, message)","def handle(self):\n\n # parse the data\n map_dict_fields(self.data, const.API_FIELDS, const.DB_FIELDS)\n\n self.validate()\n if self.errors:\n raise InvalidDataException(self.errors)\n\n # save data\n self.save()","def _handle_dump_unknown(self, data, original):\n for key, val in original.items():\n if key not in self.fields:\n data[key] = val\n return data","def run_validation(self, data=empty):\n\n if data is not empty:\n unknown = set(data) - set(self.fields)\n if unknown:\n errors = ['Unknown field: {}'.format(f) for f in unknown]\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\n return super().run_validation(data)","def set_data_protected(self): \n pass","def do_exception_save(self):\n Save(self.nodeMgr.nodeList, self.nodeMgr.connections, True)","def error(self):\n raise NotImplementedError(\"subclasses need to override this method\")","def data_loaded_check(self):\n return True","def UNUSED_save_ifdirty(self):\n if (self.get_isdirty()):\n self.save()","def missing_information(self, info, field):\n raise NoData","def before_dataobj_create(self, dataobj):","def setData(self, data):\n return None","def IgnorePersistedDecision(self) -> bool:","def save(self):\n pass","def save(self):\n pass","def save(self):\n pass","def save(self):\n pass","def save(self):\n pass","def save_data(self):\n # Validate\n try:\n self._data = self._schema(self._data)\n except vol.Invalid as ex:\n _LOGGER.error(\"Can't parse data: %s\",\n humanize_error(self._data, ex))\n\n # Load last valid data\n _LOGGER.warning(\"Reset %s to last version\", self._file)\n self.read_data()\n return\n\n # write\n try:\n write_json_file(self._file, self._data)\n except (OSError, json.JSONDecodeError) as err:\n _LOGGER.error(\"Can't store config in %s: %s\", self._file, err)","def is_savable(self, do_raise: bool = True) -> Tuple[bool, List[str]]:\n errors = []\n for k, v in self.properties.items():\n if v is None and self.sample_type.field_type(k).required:\n errors.append(\"FieldValue '{}' is required.\".format(k))\n if do_raise and errors:\n raise AquariumModelError(\n \"Cannot update/save due to the following:\\n\"\n \"Sample: id={} name={} ({})\\n\\t{}\".format(\n self.id, self.name, self.sample_type.name, \"\\n\\t\".join(errors)\n )\n )\n return len(errors) == 0, errors","def test_export_data_on_nonexistent_user(self) -> None:\n user_data = user_models.UserStatsModel.export_data(\n self.NONEXISTENT_USER_ID)\n test_data: Dict[str, str] = {}\n self.assertEqual(user_data, test_data)","def _check_data_valid(self):\n\n is_valid = (sum(~np.isnan(self.data).flatten()) > 0 and self.data.flatten().sum() != 0)\n if not is_valid:\n raise FITSException(f\"No data in {self.survey}\")","def _import(self, data):\n if isinstance(data, dict):\n if len(data):\n for key in data:\n if data.get(key) is not None:\n if not self.set(key, data.get(key)):\n raise Exception('%s %s icin dogru bir veri degil.' % (data.get(key), key))","def save (self):\n pass","def store(self, data: dict) -> tuple:\n item = self.model(**data)\n try:\n item.save()\n items = self.get_all()\n\n return items\n except DataBaseException as e:\n return {'error': {'message': e.message}}, 500","def test_storing_wrong_data(self):\n data = {\"employer\": \"Trading Ltd\", \"jobTitle\": \"Assistant\", \"jobLocation\": \"5th street\",\n \"fromMonth\": \"something\",\n \"fromYear\": 2007, \"toMonth\": \"another\", \"toYear\": 2010, \"stillWorkHere\": False}\n response = self.client.post(self.url, data=json.dumps(data), content_type='application/json')\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, msg=response.content.decode())","def fix_nonerrors(self):\n if not self.only_error:\n return\n self.line = None\n self.filename = None","def test_save_a_pet_with_no_name(self):\n pet = Pet(0, None, \"cat\")\n self.assertRaises(DataValidationError, pet.save)","def save():\n pass","def set_api_data_safely(self, o365_record):\n try:\n self.api_data = o365_record.to_api_data()\n except TypeError as e:\n f = \"Caught error on O365 object to_api_data method:\\n {}\\n {}\"\n print(f.format(e, o365_record))","def test_old_data_format_error(self):\n assert_raises(ValueError, get_data, self.testv1)","def save(self):\n # Makes sure that all required properties are available before persistence.\n for name, prop in fields(self, Property).items():\n if hasattr(prop, 'required') and prop.required:\n value = getattr(self, name)\n if prop.empty(value):\n raise BadValueError(\"Property: %s is required\" % name)\n \n Lisa.save(self)\n self.differ.commit()","def failed(self):\n\t\tpass","def post_load(self, data):\n return data","def save(self, *args, **kwargs):\n return","def test_3_incorrect_value(self):\n d = copy.deepcopy(self.fitness_dict)\n d['WorkoutType'] = 1\n self.assertFalse(self.fitness.insert_in_database(d))\n\n d = copy.deepcopy(self.fitness_dict)\n d['Minutes'] = 'Running'\n self.assertFalse(self.fitness.insert_in_database(d))\n\n d = copy.deepcopy(self.fitness_dict)\n d['CaloriesBurned'] = 1\n self.assertFalse(self.fitness.insert_in_database(d))","def existing_key_fail(self, data, new_data):\n message = 'exists'\n rv = self.add_success(data)\n assert not in_response(rv, message)\n self.add_fail(data, message)\n rv = self.add_success(new_data)\n assert not in_response(rv, message)\n self.update_fail(data, message)\n assert self.verify_object(new_data)","def test_invlaid_data(self):\n # Currently, there are no PowerPlant or Project objects in the database\n self.assertEqual(PowerPlant.objects.count(), 0)\n self.assertEqual(Project.objects.count(), 0)\n\n # Call the command with invalid data.\n # The first row is for a power plant, but it has an invalid latitude.\n # The second row is for a project, but it has an invalid project capacity.\n # The third row is for a project, but it has an invalid project capacity unit.\n # The fourth row is for a power plant, but has an invalid status.\n self.call_command(filename='power_plant_import/tests/data/invalid_data.csv')\n\n # Each of the objects were created, though the invalid data was not saved.\n self.assertEqual(PowerPlant.objects.count(), 3)\n self.assertEqual(Project.objects.count(), 2)","def indicate_error(self):\n pass","def add_required_field_fail(self, field, data):\n message = '{} is required'.format(self.fields[field])\n data = data.copy()\n\n data[field] = ''\n self.add_fail(data, message)\n assert not self.verify_object(data)\n\n del data[field]\n self.add_fail(data, message)\n assert not self.verify_object(data)"],"string":"[\n \"def save_data(self):\\n pass\",\n \"def saveData(self):\\n pass\",\n \"def save(self):\\r\\n try:\\r\\n self.process_save()\\r\\n except InputError as ex:\\r\\n print(ex)\\r\\n self.save()\\r\\n except KeyError:\\r\\n print(\\\"No saved data to save/load. Please save some data before loading in data.\\\")\\r\\n self.menu_page()\",\n \"def _load_data(self):\\n logging.warning('-> loading EMPTY data...')\",\n \"def check_for_new_data(self):\\n return\",\n \"def clean_up_data(self):\\n pass\",\n \"def _validate_create_data(self, data):\\n return\",\n \"def _save_data(self):\\n super()._save_data()\\n if self.data:\\n # FIXES [BUG-034].\\n WeatherForecastObservation.objects.all().delete()\\n self.state['inserted_elements'] = len(WeatherForecastObservation.objects.bulk_create(self.data))\\n self.logger.info('Successfully saved %d elements.' % self.state['inserted_elements'])\\n else:\\n self.logger.info('No elements were saved because no elements were available.')\\n self.data = None\",\n \"def invalid(self):\\n pass\",\n \"def test_State_save_none(self):\\n with self.assertRaises(TypeError):\\n State.save()\",\n \"def validate_dataset(self):\\n pass\",\n \"def reset_data(self):\\n try:\\n self._data = self._schema({})\\n except vol.Invalid as ex:\\n _LOGGER.error(\\\"Can't reset %s: %s\\\",\\n self._file, humanize_error(self._data, ex))\",\n \"def _handle_save(self, error):\\n err_id = error.get('id', None)\\n if err_id is None:\\n return False\\n # save each error under its id\\n self._storage[err_id] = error\\n # notify new error\\n event.notify(NotifyTraceback(error))\\n return True\",\n \"def dummy():\\n\\t\\t\\tself.save()\",\n \"def _save_data(self):\\n super()._save_data()\\n if self.data:\\n self.state['inserted_elements'] = len(SeaLevelRiseMeasure.objects.bulk_create(self.data))\\n self.logger.info('Successfully saved %d elements.' % self.state['inserted_elements'])\\n else:\\n self.logger.info('No elements were saved because no elements were available.')\\n self.data = None\",\n \"def save(self):\\n raise NotImplementedError()\",\n \"def save(self, *args, **kwargs):\\n raise NotImplementedError('missing data mixin')\",\n \"def test_basemodel_save_none(self):\\n with self.assertRaises(TypeError):\\n BaseModel.save()\",\n \"def test_missing_data(self):\\n survey = SurveyFactory.create()\\n\\n orig_data = {\\n 'experiment_version': '1',\\n 'response_version': 1,\\n 'person_id': 'joemamma',\\n 'survey_id': survey.name,\\n 'flow_id': '20141113',\\n 'question_id': '1',\\n 'updated_ts': self.timestamp(),\\n 'question_text': 'how was lunch?',\\n 'variation_id': '1'\\n }\\n\\n for key in orig_data.keys():\\n data = dict(orig_data)\\n del data[key]\\n\\n resp = self.client.post(\\n reverse('heartbeat-api'),\\n content_type='application/json',\\n data=json.dumps(data))\\n\\n assert resp.status_code == 400\\n resp_data = json.loads(resp.content)\\n assert key in resp_data['errors']\",\n \"def data_raise(self, data):\\n self.put_nowait(data)\",\n \"def bad(self):\\n raise NotImplementedError\",\n \"def bad(self):\\n raise NotImplementedError\",\n \"def check_Data(self):\\r\\n \\r\\n if self._target_data is None:\\r\\n self.processData()\",\n \"def _validate_update_data(self, data):\\n return\",\n \"def save(self):\\n return None\",\n \"def check_is_saved(self):\\n raise NotImplementedError()\",\n \"def _handle_load_unknown(self, data, original):\\n for key, val in original.items():\\n if key not in self.fields:\\n data[key] = val\\n return data\",\n \"def __getstate__(self):\\n raise IOError(\\\"You tried to serialize something that should not\\\"\\n \\\" be serialized.\\\")\",\n \"def test_ensure_data_no_totalseconds(self):\\n album = Album(artist='Artist', album='Album', totaltracks=2)\\n with self.assertRaises(Exception):\\n album.ensure_data()\",\n \"def test_insert_empty_data(self):\\n self.engine.insert_data(self.empty_data)\\n self.assertDictEqual(self.ds.store, {})\",\n \"def validate_data_frame(self):\\n try:\\n # Verify the data frame\\n pandas.verify_data_frame(self.data_frame)\\n except OnTaskDataFrameNoKey as exc:\\n self.add_error(None, str(exc))\\n return\\n\\n # Store the data frame in the DB.\\n try:\\n # Get frame info with three lists: names, types and is_key\\n self.frame_info = pandas.store_temporary_dataframe(\\n self.data_frame,\\n self.workflow)\\n except Exception as exc:\\n self.add_error(\\n None,\\n _('Unable to process file ({0}).').format(str(exc)))\",\n \"def save(self):\\n raise NotImplementedError\",\n \"def save(self):\\n raise NotImplementedError\",\n \"def save(self):\\n raise NotImplementedError\",\n \"def error_false(self):\\n self.errors = self.errors[0:-1]\\n if not self.errors:\\n self.update_info()\",\n \"def _save_update(self):\\n try:\\n self()\\n except SignalValueError:\\n pass\\n except Exception:\\n # Allow post-mortem debugging\\n type_, value, tb = sys.exc_info()\\n tb = tb.tb_next # Skip *this* frame\\n sys.last_type = type_\\n sys.last_value = value\\n sys.last_traceback = tb\\n del tb # Get rid of it in this namespace\\n logging.exception(value)\",\n \"def save(self, data):\\n\\t\\tif self.value:\\n\\t\\t\\tdata['value'] = self.value\",\n \"def save(self, *args, **kwargs):\\n if self.name == '':\\n raise FieldError\\n else:\\n return super(CrossRefDB, self).save(*args, **kwargs)\",\n \"def _restore_data_inputs(self):\\n super()._restore_data_inputs()\\n self.training_data = (\\n self._data.training_data.data if self._data.training_data and self._data.training_data.data else None\\n )\\n self.validation_data = (\\n self._data.validation_data.data if self._data.validation_data and self._data.validation_data.data else None\\n )\",\n \"def save_end(self):\\n data = self.savedata\\n self.savedata = None\\n return data\",\n \"def save(self, doing_import=False):\\n if doing_import:\\n super(CombinedTeledata, self).save()\\n else:\\n raise NotImplementedError(message=\\\"Saving is not possible on this method unless importing.\\\")\",\n \"def pre_save(self):\\r\\n self.validate()\",\n \"def save(self) -> None:\\n pass\",\n \"def save(self) -> None:\\n pass\",\n \"def save(self) -> None:\\n pass\",\n \"def test_object_is_not_created_without_required_fields(self):\\n data1 = self.data.copy()\\n del data1[\\\"title\\\"]\\n\\n serializer = ProductSerializer(data=data1)\\n\\n self.assertFalse(serializer.is_valid())\\n self.assertEqual(serializer.errors.get(\\\"title\\\")[0], self.error_message)\\n\\n data2 = self.data.copy()\\n del data2[\\\"description\\\"]\\n\\n serializer = ProductSerializer(data=data2)\\n self.assertFalse(serializer.is_valid())\\n self.assertEqual(serializer.errors.get(\\\"description\\\")[0], self.error_message)\\n\\n data3 = self.data.copy()\\n del data3[\\\"price\\\"]\\n\\n serializer = ProductSerializer(data=data3)\\n self.assertFalse(serializer.is_valid())\\n self.assertEqual(serializer.errors.get(\\\"price\\\")[0], self.error_message)\",\n \"def test_raise_on_write_when_frozen(self):\\n self.test_model.freeze()\\n self.assertRaises(errors.PersistenceError, self.test_model.save)\",\n \"def error(self):\\n pass\",\n \"def test_export_data_none(self) -> None:\\n user_data = user_models.ExpUserLastPlaythroughModel.export_data(\\n self.NONEXISTENT_USER_ID)\\n expected_data: Dict[str, Dict[str, str]] = {}\\n self.assertEqual(expected_data, user_data)\",\n \"def clean_data(self):\\n return self.instance.data\",\n \"def test_storing_missing_data(self):\\n data = {\\\"employer\\\": \\\"Trading Ltd\\\", \\\"jobTitle\\\": \\\"Assistant\\\", \\\"jobLocation\\\": \\\"5th street\\\",\\n \\\"fromMonth\\\": \\\"january\\\", \\\"fromYear\\\": 2007}\\n response = self.client.post(self.url, data=json.dumps(data), content_type='application/json')\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, msg=response.content.decode())\",\n \"def load_data(self, data):\\n self.data = data\\n self.validate()\",\n \"def test_attempting_to_save_abstract_model_fails(self):\\r\\n with self.assertRaises(CQLEngineException):\\r\\n AbstractModelWithFullCols.create(pkey=1, data=2)\",\n \"def insert_data(self):\\n\\n pass\",\n \"def required_field_fail(self, field, data):\\n self.add_required_field_fail(field, data)\\n self.update_required_field_fail(field, data)\",\n \"def test_ensure_data_no_totaltracks(self):\\n album = Album(artist='Artist', album='Album', totalseconds=120)\\n with self.assertRaises(Exception):\\n album.ensure_data()\",\n \"def test_save(self):\\r\\n self.assertRaises(StorageNotSetError, self.config.save)\",\n \"def save(self, *args, **kwargs):\\n if self.survey.published:\\n # pylint: disable=no-member\\n super(Response, self).save(*args, **kwargs)\\n else:\\n raise DBError('This survey has not been published')\",\n \"def test_export_data_on_nonexistent_user(self) -> None:\\n user_data = user_models.CollectionProgressModel.export_data(\\n self.NONEXISTENT_USER_ID)\\n expected_data: Dict[str, str] = {}\\n self.assertEqual(expected_data, user_data)\",\n \"def __init__(self, message=\\\"\\\"):\\n super(DataError, self).__init__(message)\",\n \"def test_quest_load_data_fail(testing_quest_page):\\n testing_quest_page.save()\\n\\n # fetch the data\\n doc = testing_quest_page.doc_ref.get()\\n data = testing_quest_page.storage_model.parse_obj(doc.to_dict())\\n\\n # mess with the data\\n data.serialized_data = json.dumps({\\\"this\\\": \\\"nonesense\\\"})\\n testing_quest_page.doc_ref.set(data.dict())\\n\\n # try to load with the bad version\\n with pytest.raises(QuestLoadError):\\n testing_quest_page.load()\\n\\n # cleanup\\n testing_quest_page.delete()\",\n \"def bad_data_fail(self, good_data, bad_data, message):\\n self.add_fail(bad_data, message)\\n self.update_fail(good_data, bad_data, message)\",\n \"def handle(self):\\n\\n # parse the data\\n map_dict_fields(self.data, const.API_FIELDS, const.DB_FIELDS)\\n\\n self.validate()\\n if self.errors:\\n raise InvalidDataException(self.errors)\\n\\n # save data\\n self.save()\",\n \"def _handle_dump_unknown(self, data, original):\\n for key, val in original.items():\\n if key not in self.fields:\\n data[key] = val\\n return data\",\n \"def run_validation(self, data=empty):\\n\\n if data is not empty:\\n unknown = set(data) - set(self.fields)\\n if unknown:\\n errors = ['Unknown field: {}'.format(f) for f in unknown]\\n raise ValidationError({api_settings.NON_FIELD_ERRORS_KEY: errors})\\n return super().run_validation(data)\",\n \"def set_data_protected(self): \\n pass\",\n \"def do_exception_save(self):\\n Save(self.nodeMgr.nodeList, self.nodeMgr.connections, True)\",\n \"def error(self):\\n raise NotImplementedError(\\\"subclasses need to override this method\\\")\",\n \"def data_loaded_check(self):\\n return True\",\n \"def UNUSED_save_ifdirty(self):\\n if (self.get_isdirty()):\\n self.save()\",\n \"def missing_information(self, info, field):\\n raise NoData\",\n \"def before_dataobj_create(self, dataobj):\",\n \"def setData(self, data):\\n return None\",\n \"def IgnorePersistedDecision(self) -> bool:\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save(self):\\n pass\",\n \"def save_data(self):\\n # Validate\\n try:\\n self._data = self._schema(self._data)\\n except vol.Invalid as ex:\\n _LOGGER.error(\\\"Can't parse data: %s\\\",\\n humanize_error(self._data, ex))\\n\\n # Load last valid data\\n _LOGGER.warning(\\\"Reset %s to last version\\\", self._file)\\n self.read_data()\\n return\\n\\n # write\\n try:\\n write_json_file(self._file, self._data)\\n except (OSError, json.JSONDecodeError) as err:\\n _LOGGER.error(\\\"Can't store config in %s: %s\\\", self._file, err)\",\n \"def is_savable(self, do_raise: bool = True) -> Tuple[bool, List[str]]:\\n errors = []\\n for k, v in self.properties.items():\\n if v is None and self.sample_type.field_type(k).required:\\n errors.append(\\\"FieldValue '{}' is required.\\\".format(k))\\n if do_raise and errors:\\n raise AquariumModelError(\\n \\\"Cannot update/save due to the following:\\\\n\\\"\\n \\\"Sample: id={} name={} ({})\\\\n\\\\t{}\\\".format(\\n self.id, self.name, self.sample_type.name, \\\"\\\\n\\\\t\\\".join(errors)\\n )\\n )\\n return len(errors) == 0, errors\",\n \"def test_export_data_on_nonexistent_user(self) -> None:\\n user_data = user_models.UserStatsModel.export_data(\\n self.NONEXISTENT_USER_ID)\\n test_data: Dict[str, str] = {}\\n self.assertEqual(user_data, test_data)\",\n \"def _check_data_valid(self):\\n\\n is_valid = (sum(~np.isnan(self.data).flatten()) > 0 and self.data.flatten().sum() != 0)\\n if not is_valid:\\n raise FITSException(f\\\"No data in {self.survey}\\\")\",\n \"def _import(self, data):\\n if isinstance(data, dict):\\n if len(data):\\n for key in data:\\n if data.get(key) is not None:\\n if not self.set(key, data.get(key)):\\n raise Exception('%s %s icin dogru bir veri degil.' % (data.get(key), key))\",\n \"def save (self):\\n pass\",\n \"def store(self, data: dict) -> tuple:\\n item = self.model(**data)\\n try:\\n item.save()\\n items = self.get_all()\\n\\n return items\\n except DataBaseException as e:\\n return {'error': {'message': e.message}}, 500\",\n \"def test_storing_wrong_data(self):\\n data = {\\\"employer\\\": \\\"Trading Ltd\\\", \\\"jobTitle\\\": \\\"Assistant\\\", \\\"jobLocation\\\": \\\"5th street\\\",\\n \\\"fromMonth\\\": \\\"something\\\",\\n \\\"fromYear\\\": 2007, \\\"toMonth\\\": \\\"another\\\", \\\"toYear\\\": 2010, \\\"stillWorkHere\\\": False}\\n response = self.client.post(self.url, data=json.dumps(data), content_type='application/json')\\n self.assertEqual(response.status_code, status.HTTP_400_BAD_REQUEST, msg=response.content.decode())\",\n \"def fix_nonerrors(self):\\n if not self.only_error:\\n return\\n self.line = None\\n self.filename = None\",\n \"def test_save_a_pet_with_no_name(self):\\n pet = Pet(0, None, \\\"cat\\\")\\n self.assertRaises(DataValidationError, pet.save)\",\n \"def save():\\n pass\",\n \"def set_api_data_safely(self, o365_record):\\n try:\\n self.api_data = o365_record.to_api_data()\\n except TypeError as e:\\n f = \\\"Caught error on O365 object to_api_data method:\\\\n {}\\\\n {}\\\"\\n print(f.format(e, o365_record))\",\n \"def test_old_data_format_error(self):\\n assert_raises(ValueError, get_data, self.testv1)\",\n \"def save(self):\\n # Makes sure that all required properties are available before persistence.\\n for name, prop in fields(self, Property).items():\\n if hasattr(prop, 'required') and prop.required:\\n value = getattr(self, name)\\n if prop.empty(value):\\n raise BadValueError(\\\"Property: %s is required\\\" % name)\\n \\n Lisa.save(self)\\n self.differ.commit()\",\n \"def failed(self):\\n\\t\\tpass\",\n \"def post_load(self, data):\\n return data\",\n \"def save(self, *args, **kwargs):\\n return\",\n \"def test_3_incorrect_value(self):\\n d = copy.deepcopy(self.fitness_dict)\\n d['WorkoutType'] = 1\\n self.assertFalse(self.fitness.insert_in_database(d))\\n\\n d = copy.deepcopy(self.fitness_dict)\\n d['Minutes'] = 'Running'\\n self.assertFalse(self.fitness.insert_in_database(d))\\n\\n d = copy.deepcopy(self.fitness_dict)\\n d['CaloriesBurned'] = 1\\n self.assertFalse(self.fitness.insert_in_database(d))\",\n \"def existing_key_fail(self, data, new_data):\\n message = 'exists'\\n rv = self.add_success(data)\\n assert not in_response(rv, message)\\n self.add_fail(data, message)\\n rv = self.add_success(new_data)\\n assert not in_response(rv, message)\\n self.update_fail(data, message)\\n assert self.verify_object(new_data)\",\n \"def test_invlaid_data(self):\\n # Currently, there are no PowerPlant or Project objects in the database\\n self.assertEqual(PowerPlant.objects.count(), 0)\\n self.assertEqual(Project.objects.count(), 0)\\n\\n # Call the command with invalid data.\\n # The first row is for a power plant, but it has an invalid latitude.\\n # The second row is for a project, but it has an invalid project capacity.\\n # The third row is for a project, but it has an invalid project capacity unit.\\n # The fourth row is for a power plant, but has an invalid status.\\n self.call_command(filename='power_plant_import/tests/data/invalid_data.csv')\\n\\n # Each of the objects were created, though the invalid data was not saved.\\n self.assertEqual(PowerPlant.objects.count(), 3)\\n self.assertEqual(Project.objects.count(), 2)\",\n \"def indicate_error(self):\\n pass\",\n \"def add_required_field_fail(self, field, data):\\n message = '{} is required'.format(self.fields[field])\\n data = data.copy()\\n\\n data[field] = ''\\n self.add_fail(data, message)\\n assert not self.verify_object(data)\\n\\n del data[field]\\n self.add_fail(data, message)\\n assert not self.verify_object(data)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6786101","0.67231554","0.6600586","0.65661645","0.6451117","0.64248633","0.629678","0.62577516","0.6201316","0.6155443","0.61142343","0.611215","0.6106852","0.6094064","0.6088099","0.5968788","0.596374","0.5948944","0.59184533","0.591446","0.59111434","0.59111434","0.5904791","0.59019655","0.5897539","0.5892862","0.5890111","0.58643913","0.58473426","0.58422536","0.5834579","0.5828854","0.5828854","0.5828854","0.5810204","0.5809126","0.58040863","0.5801886","0.57767093","0.57706195","0.57671684","0.57552624","0.5734942","0.5734942","0.5734942","0.5733013","0.573064","0.5721027","0.57134044","0.57033336","0.57031906","0.57009757","0.5693826","0.56935865","0.56907034","0.56898016","0.5671742","0.5671573","0.56669635","0.5658057","0.56570715","0.56492305","0.56395894","0.5638681","0.5632992","0.56273663","0.5619745","0.56160074","0.56131846","0.561178","0.5609342","0.5606233","0.5602027","0.5593514","0.55848134","0.55848134","0.55848134","0.55848134","0.55848134","0.55772436","0.5572042","0.55622417","0.5560117","0.5557445","0.5557026","0.55530405","0.55481553","0.5537042","0.5536761","0.55271184","0.5520985","0.5499026","0.5498075","0.54953146","0.5494386","0.54918665","0.54875416","0.5486911","0.5482567","0.5482212","0.54791695"],"string":"[\n \"0.6786101\",\n \"0.67231554\",\n \"0.6600586\",\n \"0.65661645\",\n \"0.6451117\",\n \"0.64248633\",\n \"0.629678\",\n \"0.62577516\",\n \"0.6201316\",\n \"0.6155443\",\n \"0.61142343\",\n \"0.611215\",\n \"0.6106852\",\n \"0.6094064\",\n \"0.6088099\",\n \"0.5968788\",\n \"0.596374\",\n \"0.5948944\",\n \"0.59184533\",\n \"0.591446\",\n \"0.59111434\",\n \"0.59111434\",\n \"0.5904791\",\n \"0.59019655\",\n \"0.5897539\",\n \"0.5892862\",\n \"0.5890111\",\n \"0.58643913\",\n \"0.58473426\",\n \"0.58422536\",\n \"0.5834579\",\n \"0.5828854\",\n \"0.5828854\",\n \"0.5828854\",\n \"0.5810204\",\n \"0.5809126\",\n \"0.58040863\",\n \"0.5801886\",\n \"0.57767093\",\n \"0.57706195\",\n \"0.57671684\",\n \"0.57552624\",\n \"0.5734942\",\n \"0.5734942\",\n \"0.5734942\",\n \"0.5733013\",\n \"0.573064\",\n \"0.5721027\",\n \"0.57134044\",\n \"0.57033336\",\n \"0.57031906\",\n \"0.57009757\",\n \"0.5693826\",\n \"0.56935865\",\n \"0.56907034\",\n \"0.56898016\",\n \"0.5671742\",\n \"0.5671573\",\n \"0.56669635\",\n \"0.5658057\",\n \"0.56570715\",\n \"0.56492305\",\n \"0.56395894\",\n \"0.5638681\",\n \"0.5632992\",\n \"0.56273663\",\n \"0.5619745\",\n \"0.56160074\",\n \"0.56131846\",\n \"0.561178\",\n \"0.5609342\",\n \"0.5606233\",\n \"0.5602027\",\n \"0.5593514\",\n \"0.55848134\",\n \"0.55848134\",\n \"0.55848134\",\n \"0.55848134\",\n \"0.55848134\",\n \"0.55772436\",\n \"0.5572042\",\n \"0.55622417\",\n \"0.5560117\",\n \"0.5557445\",\n \"0.5557026\",\n \"0.55530405\",\n \"0.55481553\",\n \"0.5537042\",\n \"0.5536761\",\n \"0.55271184\",\n \"0.5520985\",\n \"0.5499026\",\n \"0.5498075\",\n \"0.54953146\",\n \"0.5494386\",\n \"0.54918665\",\n \"0.54875416\",\n \"0.5486911\",\n \"0.5482567\",\n \"0.5482212\",\n \"0.54791695\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21394,"cells":{"query":{"kind":"string","value":"It should raise with a descriptive error if run on an OT2, instead of OT3."},"document":{"kind":"string","value":"async def test_calibrate_gripper_raises_on_ot2(\n decoy: Decoy,\n ot2_hardware_api: OT2API,\n) -> None:\n subject = CalibrateGripperImplementation(hardware_api=ot2_hardware_api)\n\n params = CalibrateGripperParams(jaw=CalibrateGripperParamsJaw.REAR)\n\n with pytest.raises(HardwareNotSupportedError):\n await subject.execute(params)"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def experiment3():\n raise FAKE_ERROR","def report_unexpected_exception(self, *args, **kwargs):\n pass","def unexpected_error(self, exception):","def test_error3(self):\n try:\n api = self.load_api_description('error3.json')\n self.fail('No error thrown for undefined input segment')\n except APIDescriptionException:\n pass","def test_error1(self):\n try:\n api = self.load_api_description('error1.json')\n self.fail('No error thrown for undefined type')\n except APIDescriptionException:\n pass","def test_error2(self):\n try:\n api = self.load_api_description('error2.json')\n self.fail('No error thrown for undefined binding')\n except APIDescriptionException:\n pass","def unexpectedException(self):","def error(self, message=None, show_help=True):","def test_create_unexpected_problem(self):\n pass","def error(self):\n pass","def test_xfailed_not_mentioned_exception():\n assert False","def error(self):\n ...","def err(reason):\n raise AliasException(reason)","def error():\n return None","def raise_(err):\n raise err","def error(self, msg, *args, **kwargs):\n pass","def error(self, *args, **kwargs):","def indicate_error(self):\n pass","def _assert(ok, detail):\n\n if not ok:\n raise UserException(\"the project file is invalid\", detail)","def test_label(self):\n try:\n t = self.OntTerm(label='diffuse')\n raise AssertionError(f'should fail {t!r}')\n except TypeError:\n pass","def error(self):\n raise NotImplementedError(\"subclasses need to override this method\")","def test_type_error(self):\n self._error_test(TypeError)","def test_omegaconf(self):\n with pytest.raises(OmegaConfBaseException):\n exp_manager(None, {\"unused\": 1})","def raise_error(Err):\n raise Err()","def error(self, error):\n pass","def error_impresion(self):\n self._info(\"error_impresion\")","def serious_error(self, e):\n pass","def test_handle_error_does_not_raise_type_errors():\n formatter = mock.create_autospec(base.BaseFormatter, instance=True)\n guide = style_guide.StyleGuide(\n create_options(select=[\"T111\"], ignore=[]),\n formatter=formatter,\n stats=statistics.Statistics(),\n )\n\n assert 1 == guide.handle_error(\n \"T111\", \"file.py\", 1, 1, \"error found\", \"a = 1\"\n )","def test_new_invalid(self) -> None:\n with pytest.raises(TypeError) as excinfo:\n RunwayTestDefinition({}) # type: ignore\n assert str(excinfo.value).startswith(\"expected data of type\")","def test_base_error_raises():\n with pytest.raises(PypyrAwsError) as err_info:\n raise PypyrAwsError(\"this is error text right here\")\n\n assert str(err_info.value) == \"this is error text right here\"","def error(self, *args, **kwargs):\n if len(args) == 3:\n print(f\"ERROR: {args[1]}\")\n else:\n print(f\"ERROR: {args[0]}\")","def error():\r\n raise RuntimeError('admin ticket generator at your service')","def test_mothur_error_2(self):\n\n m = Mothur(**self.init_vars)\n self.set_current_dirs(m)\n with self.assertRaises(RuntimeError):\n m.summary.seqs()\n\n return","def test_no_specification_error():\n try:\n bad_arm = survey.get_spiral_slice()\n except SyntaxError:\n assert True\n else:\n assert False","def error_message(self):\n return u'Something wrong with {}, ' \\\n u'try switch to another series provider'\\\n .format(type(self).__name__)","def error(self, msg):\n fullmsg = \"Subcommand '%s': %s\\n%s\" % (self.tool.get_command(), msg,\n self.get_usage_command())\n raise SBToolError(fullmsg, True)","def test_trestle_not_found_error() -> None:\n msg = 'Custom not found error'\n try:\n raise TrestleNotFoundError(msg)\n except TrestleNotFoundError as err:\n assert str(err) == msg\n assert err.msg == msg","def error_check(self, options):\n if not options[\"type\"] in ['dot', 'raw']:\n sys.stderr.write('\\nUnknown file type \"%s\". Type may be either \"dot\" or \"raw\"\\n' %str(options[\"type\"]))\n self.print_usage()","def check_errors(self) -> None:","def test_invalid_menu_print():\n with pt.raises(Exception):\n sc.print_specific('testing')","def test_traffic_analysis_command_for_invalid_arguments(\n args, err_msg, err_type, mock_client\n):\n from IllumioCore import traffic_analysis_command\n\n with pytest.raises(err_type) as err:\n traffic_analysis_command(mock_client, args)\n assert str(err.value) == err_msg","def throw(self):\n pass","def _check(error: int) -> None:\n if error < 0:\n raise RuntimeError(ffi.string(lib.TCOD_get_error()).decode())","def test_that_test_can_fail():\n try:\n verify_atomic_weight_for_substance(\"O2\", 1.0)\n except AssertionError as e:\n return\n\n raise AssertionError(\"test_that_test_can_fail() didn't fail\")","def sanity_check(self):\n pass","def test_type_errors():\n\n\ttry:\n\t\ttransmissions = compute_transmissions(cal_directory, lines = 3.0)\n\texcept TypeError:\n\t\ttry:\n\t\t\ttransmissions = compute_transmissions(cal_directory, calibrator = 300.0)\n\t\texcept TypeError:\n\t\t\tassert True\n\t\telse:\n\t\t\tassert False\n\telse:\n\t\tassert False","def test_fails(self):\n raise FoolishError(\"I am a broken test\")","def testBadTrackType(self):\n\n self.assertRaises(\n ValueError,\n tools._trackInfo,\n 'Track ID 5: telepathic (junk for the rest'\n )","def handle_err(self):\n pass","async def help_error(self, ctx, error):\n await self.log_error_and_apologize(ctx, error)","def testBadOptionsRaisesErrors(self):\n with self.assertRaises(ValueError):\n self.tree_external2 = CoalescenceTree(os.path.join(\"output\", \"data_3_44_2.db\"))\n self.tree_external2.set_speciation_parameters(\n 0.0001,\n metacommunity_size=10000,\n metacommunity_speciation_rate=self.speciation_rates[0],\n metacommunity_option=os.path.join(\"sample\", \"nse_reference.db\"),\n metacommunity_reference=0,\n )\n self.tree_external2.apply()","def test_option_unhandled(self):\n cmd, output = runCmdOutput(['--__unhandled__'])\n self.assertEqual(cmd.returncode, os.EX_USAGE)","def error(*args, noContext: bool=True, showLineNumber: bool=True, **kwargs)->None:\n pass","def test_error(doctest):","def error(self, e):\n return \"{}: {} ({})\".format(e.__class__.__name__, e.__doc__, e.message)","def test_get_other_typeerror_2(self):\n v = versions.Version(name='foo', version='1.2.3')\n self.assertRaises(TypeError, v._get_other, '1')","def fail(self, msg=None):\n raise Exception, msg","def _syntax_error(self, msg, thing):\n raise TempliteSyntaxError(f\"{msg}: {thing!r}\")","def error_throw(self,stage):\n if self.is_table_info == False:\n print(\"please enter table info by table_info()\")\n sys.exit(0)\n if stage == 'rank':\n if self.import_method == 'none':\n self.error_output_import()\n elif stage == 'output':\n if self.import_method == 'none':\n self.error_output_import()\n else: \n if self.rank_method == 'none':\n self.error_output_rank()","def test_info_fail(self):\n path = \"non_existing_audio.wav\"\n with self.assertRaisesRegex(RuntimeError, path):\n self._info(path)","def errFunc(runType):\n logger.error('Execution type not recognized! {}'.format(runType))\n raise InvalidExecutionType('{} is not a valid command'.format(runType))","def _fail(raise_):\n if raise_:\n raise _UnexpectedForm()\n return None","def test_wrongsyn():\n assert _socli.wrongsyn(\"sdf\") == None","def test_invalidValues(self):\n argV = \"--fooint egg\".split()\n self.assertRaises(usage.UsageError, self.usage.parseOptions, argV)","def test_raise_if_err_ok(self) -> None:\n assert Ok(2).raise_if_err(\"err\") == 2","def test_expect_err_err(self) -> None:\n assert Err(2).expect_err(\"err\") == 2","def error_check(command):\r\n\r\n # TODO\r","def test_lint_fail_short(self, style):\n with ExpectedException(LinterFailure):\n run_linter_throw(\"path/to/file\",\n \"{s}{e}\\n\",\n style,\n whitelist=[\"headerblock/desc_space\"])","def test_unsupported_pair(self):\n with pytest.raises(StateError, match=\"The pair of input\"):\n State(\"water\", T=Q_(100.0, \"degC\"), u=Q_(1e6, \"J/kg\"))","def test_TSE_common(self):\n\n regexpr = re.compile(r'^Error [0-9]{4}: [\\w :-]+$')\n for code in TwitterSearchException._error_codes:\n self.assertTrue( regexpr.match( str(TwitterSearchException(code)) ), \"Odd string patterns detected\")\n\n foo = \"someString\"\n tse = \"%s\" % TwitterSearchException(2000,foo)\n self.assertTrue( regexpr.match(tse) and tse[len(foo)*-1:] == foo )","def test_150(self):\n self.assertRaises(\n exceptions.DataONEExceptionException, exceptions.deserialize,\n INVALID_ERROR_DOC[0]\n )","def test_get_other_typeerror(self):\n v = versions.Version(name='foo', version='1.2.3')\n self.assertRaises(TypeError, v._get_other, 3.4)","def test_prevent_wrong_type(self):\n self.assertRaises(cinv.host.Error, self.wrong_host_type)","def test_episodenotfound(self):\n self.assertRaises(tvdb_episodenotfound, lambda:self.t['Scrubs'][1][30])","def test_bad_command2(self):\n with self.assertRaises(KeyError):\n command = Command['Fake Command2']","def test_friendly_exception_formatting_exc_with_str_overload():\n ex = InsufficientSignatures(1, 3)\n\n formatted_exception = friendlyEx(ex)\n\n assert formatted_exception == '{}'.format(ex.reason)","def error_exit(self, msg):\n wrappedmsg = textwrap.fill(msg, 78)\n fullmsg = \"%s\\n%s\" % (wrappedmsg, self.get_usage_command())\n raise SBToolError(fullmsg, True)","def ErrorString(self): # real signature unknown; restored from __doc__\n pass","def test_known_common_stable_isotopes_error(func):\n with pytest.raises(InvalidElementError):\n func(\"n\")\n pytest.fail(f\"{func} is not raising a ElementError for neutrons.\")","def test_explainer_class_errors(self):\n feature_importance = 'Feature importance not implemented.'\n model_explanation = 'Model explanation (global) not implemented.'\n instance_explanation = ('Data point explanation (local) not '\n 'implemented.')\n\n with pytest.raises(NotImplementedError) as exinf:\n self.explainer.feature_importance()\n assert str(exinf.value) == feature_importance\n with pytest.raises(NotImplementedError) as exinf:\n self.explainer.explain_model()\n assert str(exinf.value) == model_explanation\n with pytest.raises(NotImplementedError) as exinf:\n self.explainer.explain_instance()\n assert str(exinf.value) == instance_explanation","def error(self, msg):\n raise TraitError(\n \"%s at column %d of '%s'\" % (msg, self.index, self.text)\n )","def _raise_performing_request_error(self, *args, **kwargs):","def test_make_compatible_taxa_summaries_incompatible(self):\r\n self.assertRaises(ValueError, _make_compatible_taxa_summaries,\r\n self.taxa_summary3, self.taxa_summary4)\r\n self.assertRaises(ValueError, _make_compatible_taxa_summaries,\r\n self.taxa_summary1, self.taxa_summary2)","def ERR(self):","def test_not_supported_requirement(self, space_each_type):\n with pytest.raises(TypeError) as exc:\n build_required_space(space_each_type, type_requirement=\"fasdfasf\")\n assert \"Unsupported\" in str(exc.value)","def throw(self, type, value=None, traceback=None):\n pass","def test_py2(self):\n if sys.version_info >= self.MIN_SUPPORTED_VERSION:\n return\n try:\n import miflora # noqa: F401 # pylint: disable=unused-import,import-outside-toplevel\n\n self.fail(\"Should have thrown an exception\")\n except ValueError as val_err:\n self.assertIn(\"version\", str(val_err))","def test_init(self):\n with self.assertRaises(IncompetentQiitaDeveloperError):\n MetadataTemplate(1)","def _Assert(self, t):\n self.RaiseError(t, \"Assert not supported\")","def test_fail_main_coord_def_mismatch(self):\n args = self.args.copy()\n args[\"def_file\"] = str(PATH_DATA / \"op_wrong1.def\")\n with pytest.raises(BuildHError) as err:\n UI.main(**args)\n assert f\"Atoms defined in {args['def_file']} are missing in the structure\" in str(err.value)","def test_init_unknown_error(self):\n with self.assertRaises(QiitaDBUnknownIDError):\n SampleTemplate(2)","def test_unsupported_options_handled_nicely(self):\r\n self.params['beta_diversity'] = {'blah': \"something-broken\"}\r\n self.assertRaises(WorkflowError,\r\n run_beta_diversity_through_plots,\r\n self.test_data['biom'][0],\r\n self.test_data['map'][0],\r\n self.test_out,\r\n call_commands_serially,\r\n self.params,\r\n self.qiime_config,\r\n tree_fp=self.test_data['tree'][0],\r\n parallel=False,\r\n status_update_callback=no_status_updates)\r\n\r\n # Check that the log file is created and has size > 0\r\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\r\n self.assertTrue(getsize(log_fp) > 0)","def test_handle_flag_error(self):\n pass","def _TypeMismatch(a, b):\n return 'Types do not match, %s v. %s' % (str(a), str(b))","async def cog_command_error(self, ctx:utils.Context, error:commands.CheckFailure):\n\n # Throw errors properly for me\n if ctx.author.id in self.bot.config['owners']:\n text = f'```py\\n{error}```'\n await ctx.send(text)\n raise error\n\n elif isinstance(error, commands.NotOwner):\n await ctx.send(\"You need to be registered as an owner to run this command.\")\n return","def _error(msg):\n\n error(None, msg)","def manifest_with_many_types_of_errors_helper(error_log):\n assert '\"invalid_authz\"' in error_log\n assert '\"invalid_int\"' in error_log\n assert '\"invalid_md5\"' in error_log\n assert '\"invalid_url\"' in error_log","def test_wrong_type(self):\n msg = 'Widget type is not valid. Valid widget types are: ' + \\\n 'basic, default, formula, histogram, category, animation, time-series.'\n\n with pytest.raises(ValueError) as e:\n Widget({'type': 'xxx'}).get_info()\n assert str(e.value) == msg","def testInvalidDescriptions(self):\n self.assertFalse(self.app._ignore_jobs(\"telecommuting is not an option\"))\n self.assertFalse(self.app._ignore_jobs(\"No telecommuting\"))\n self.assertFalse(self.app._ignore_jobs(\"No telecommute\"))\n self.assertFalse(self.app._ignore_jobs(\"TELECOMMUTE IS NOT AN OPTION\"))","def test04(self):\n self.assertRaises(TypeError, robustApply, oneArgument, \"this\", blah=\"that\")","def _error(self, *args, **kwargs):\n print(\"[{}]\".format(self.type), *args, file=sys.stderr, **kwargs)\n sys.exit(1)"],"string":"[\n \"def experiment3():\\n raise FAKE_ERROR\",\n \"def report_unexpected_exception(self, *args, **kwargs):\\n pass\",\n \"def unexpected_error(self, exception):\",\n \"def test_error3(self):\\n try:\\n api = self.load_api_description('error3.json')\\n self.fail('No error thrown for undefined input segment')\\n except APIDescriptionException:\\n pass\",\n \"def test_error1(self):\\n try:\\n api = self.load_api_description('error1.json')\\n self.fail('No error thrown for undefined type')\\n except APIDescriptionException:\\n pass\",\n \"def test_error2(self):\\n try:\\n api = self.load_api_description('error2.json')\\n self.fail('No error thrown for undefined binding')\\n except APIDescriptionException:\\n pass\",\n \"def unexpectedException(self):\",\n \"def error(self, message=None, show_help=True):\",\n \"def test_create_unexpected_problem(self):\\n pass\",\n \"def error(self):\\n pass\",\n \"def test_xfailed_not_mentioned_exception():\\n assert False\",\n \"def error(self):\\n ...\",\n \"def err(reason):\\n raise AliasException(reason)\",\n \"def error():\\n return None\",\n \"def raise_(err):\\n raise err\",\n \"def error(self, msg, *args, **kwargs):\\n pass\",\n \"def error(self, *args, **kwargs):\",\n \"def indicate_error(self):\\n pass\",\n \"def _assert(ok, detail):\\n\\n if not ok:\\n raise UserException(\\\"the project file is invalid\\\", detail)\",\n \"def test_label(self):\\n try:\\n t = self.OntTerm(label='diffuse')\\n raise AssertionError(f'should fail {t!r}')\\n except TypeError:\\n pass\",\n \"def error(self):\\n raise NotImplementedError(\\\"subclasses need to override this method\\\")\",\n \"def test_type_error(self):\\n self._error_test(TypeError)\",\n \"def test_omegaconf(self):\\n with pytest.raises(OmegaConfBaseException):\\n exp_manager(None, {\\\"unused\\\": 1})\",\n \"def raise_error(Err):\\n raise Err()\",\n \"def error(self, error):\\n pass\",\n \"def error_impresion(self):\\n self._info(\\\"error_impresion\\\")\",\n \"def serious_error(self, e):\\n pass\",\n \"def test_handle_error_does_not_raise_type_errors():\\n formatter = mock.create_autospec(base.BaseFormatter, instance=True)\\n guide = style_guide.StyleGuide(\\n create_options(select=[\\\"T111\\\"], ignore=[]),\\n formatter=formatter,\\n stats=statistics.Statistics(),\\n )\\n\\n assert 1 == guide.handle_error(\\n \\\"T111\\\", \\\"file.py\\\", 1, 1, \\\"error found\\\", \\\"a = 1\\\"\\n )\",\n \"def test_new_invalid(self) -> None:\\n with pytest.raises(TypeError) as excinfo:\\n RunwayTestDefinition({}) # type: ignore\\n assert str(excinfo.value).startswith(\\\"expected data of type\\\")\",\n \"def test_base_error_raises():\\n with pytest.raises(PypyrAwsError) as err_info:\\n raise PypyrAwsError(\\\"this is error text right here\\\")\\n\\n assert str(err_info.value) == \\\"this is error text right here\\\"\",\n \"def error(self, *args, **kwargs):\\n if len(args) == 3:\\n print(f\\\"ERROR: {args[1]}\\\")\\n else:\\n print(f\\\"ERROR: {args[0]}\\\")\",\n \"def error():\\r\\n raise RuntimeError('admin ticket generator at your service')\",\n \"def test_mothur_error_2(self):\\n\\n m = Mothur(**self.init_vars)\\n self.set_current_dirs(m)\\n with self.assertRaises(RuntimeError):\\n m.summary.seqs()\\n\\n return\",\n \"def test_no_specification_error():\\n try:\\n bad_arm = survey.get_spiral_slice()\\n except SyntaxError:\\n assert True\\n else:\\n assert False\",\n \"def error_message(self):\\n return u'Something wrong with {}, ' \\\\\\n u'try switch to another series provider'\\\\\\n .format(type(self).__name__)\",\n \"def error(self, msg):\\n fullmsg = \\\"Subcommand '%s': %s\\\\n%s\\\" % (self.tool.get_command(), msg,\\n self.get_usage_command())\\n raise SBToolError(fullmsg, True)\",\n \"def test_trestle_not_found_error() -> None:\\n msg = 'Custom not found error'\\n try:\\n raise TrestleNotFoundError(msg)\\n except TrestleNotFoundError as err:\\n assert str(err) == msg\\n assert err.msg == msg\",\n \"def error_check(self, options):\\n if not options[\\\"type\\\"] in ['dot', 'raw']:\\n sys.stderr.write('\\\\nUnknown file type \\\"%s\\\". Type may be either \\\"dot\\\" or \\\"raw\\\"\\\\n' %str(options[\\\"type\\\"]))\\n self.print_usage()\",\n \"def check_errors(self) -> None:\",\n \"def test_invalid_menu_print():\\n with pt.raises(Exception):\\n sc.print_specific('testing')\",\n \"def test_traffic_analysis_command_for_invalid_arguments(\\n args, err_msg, err_type, mock_client\\n):\\n from IllumioCore import traffic_analysis_command\\n\\n with pytest.raises(err_type) as err:\\n traffic_analysis_command(mock_client, args)\\n assert str(err.value) == err_msg\",\n \"def throw(self):\\n pass\",\n \"def _check(error: int) -> None:\\n if error < 0:\\n raise RuntimeError(ffi.string(lib.TCOD_get_error()).decode())\",\n \"def test_that_test_can_fail():\\n try:\\n verify_atomic_weight_for_substance(\\\"O2\\\", 1.0)\\n except AssertionError as e:\\n return\\n\\n raise AssertionError(\\\"test_that_test_can_fail() didn't fail\\\")\",\n \"def sanity_check(self):\\n pass\",\n \"def test_type_errors():\\n\\n\\ttry:\\n\\t\\ttransmissions = compute_transmissions(cal_directory, lines = 3.0)\\n\\texcept TypeError:\\n\\t\\ttry:\\n\\t\\t\\ttransmissions = compute_transmissions(cal_directory, calibrator = 300.0)\\n\\t\\texcept TypeError:\\n\\t\\t\\tassert True\\n\\t\\telse:\\n\\t\\t\\tassert False\\n\\telse:\\n\\t\\tassert False\",\n \"def test_fails(self):\\n raise FoolishError(\\\"I am a broken test\\\")\",\n \"def testBadTrackType(self):\\n\\n self.assertRaises(\\n ValueError,\\n tools._trackInfo,\\n 'Track ID 5: telepathic (junk for the rest'\\n )\",\n \"def handle_err(self):\\n pass\",\n \"async def help_error(self, ctx, error):\\n await self.log_error_and_apologize(ctx, error)\",\n \"def testBadOptionsRaisesErrors(self):\\n with self.assertRaises(ValueError):\\n self.tree_external2 = CoalescenceTree(os.path.join(\\\"output\\\", \\\"data_3_44_2.db\\\"))\\n self.tree_external2.set_speciation_parameters(\\n 0.0001,\\n metacommunity_size=10000,\\n metacommunity_speciation_rate=self.speciation_rates[0],\\n metacommunity_option=os.path.join(\\\"sample\\\", \\\"nse_reference.db\\\"),\\n metacommunity_reference=0,\\n )\\n self.tree_external2.apply()\",\n \"def test_option_unhandled(self):\\n cmd, output = runCmdOutput(['--__unhandled__'])\\n self.assertEqual(cmd.returncode, os.EX_USAGE)\",\n \"def error(*args, noContext: bool=True, showLineNumber: bool=True, **kwargs)->None:\\n pass\",\n \"def test_error(doctest):\",\n \"def error(self, e):\\n return \\\"{}: {} ({})\\\".format(e.__class__.__name__, e.__doc__, e.message)\",\n \"def test_get_other_typeerror_2(self):\\n v = versions.Version(name='foo', version='1.2.3')\\n self.assertRaises(TypeError, v._get_other, '1')\",\n \"def fail(self, msg=None):\\n raise Exception, msg\",\n \"def _syntax_error(self, msg, thing):\\n raise TempliteSyntaxError(f\\\"{msg}: {thing!r}\\\")\",\n \"def error_throw(self,stage):\\n if self.is_table_info == False:\\n print(\\\"please enter table info by table_info()\\\")\\n sys.exit(0)\\n if stage == 'rank':\\n if self.import_method == 'none':\\n self.error_output_import()\\n elif stage == 'output':\\n if self.import_method == 'none':\\n self.error_output_import()\\n else: \\n if self.rank_method == 'none':\\n self.error_output_rank()\",\n \"def test_info_fail(self):\\n path = \\\"non_existing_audio.wav\\\"\\n with self.assertRaisesRegex(RuntimeError, path):\\n self._info(path)\",\n \"def errFunc(runType):\\n logger.error('Execution type not recognized! {}'.format(runType))\\n raise InvalidExecutionType('{} is not a valid command'.format(runType))\",\n \"def _fail(raise_):\\n if raise_:\\n raise _UnexpectedForm()\\n return None\",\n \"def test_wrongsyn():\\n assert _socli.wrongsyn(\\\"sdf\\\") == None\",\n \"def test_invalidValues(self):\\n argV = \\\"--fooint egg\\\".split()\\n self.assertRaises(usage.UsageError, self.usage.parseOptions, argV)\",\n \"def test_raise_if_err_ok(self) -> None:\\n assert Ok(2).raise_if_err(\\\"err\\\") == 2\",\n \"def test_expect_err_err(self) -> None:\\n assert Err(2).expect_err(\\\"err\\\") == 2\",\n \"def error_check(command):\\r\\n\\r\\n # TODO\\r\",\n \"def test_lint_fail_short(self, style):\\n with ExpectedException(LinterFailure):\\n run_linter_throw(\\\"path/to/file\\\",\\n \\\"{s}{e}\\\\n\\\",\\n style,\\n whitelist=[\\\"headerblock/desc_space\\\"])\",\n \"def test_unsupported_pair(self):\\n with pytest.raises(StateError, match=\\\"The pair of input\\\"):\\n State(\\\"water\\\", T=Q_(100.0, \\\"degC\\\"), u=Q_(1e6, \\\"J/kg\\\"))\",\n \"def test_TSE_common(self):\\n\\n regexpr = re.compile(r'^Error [0-9]{4}: [\\\\w :-]+$')\\n for code in TwitterSearchException._error_codes:\\n self.assertTrue( regexpr.match( str(TwitterSearchException(code)) ), \\\"Odd string patterns detected\\\")\\n\\n foo = \\\"someString\\\"\\n tse = \\\"%s\\\" % TwitterSearchException(2000,foo)\\n self.assertTrue( regexpr.match(tse) and tse[len(foo)*-1:] == foo )\",\n \"def test_150(self):\\n self.assertRaises(\\n exceptions.DataONEExceptionException, exceptions.deserialize,\\n INVALID_ERROR_DOC[0]\\n )\",\n \"def test_get_other_typeerror(self):\\n v = versions.Version(name='foo', version='1.2.3')\\n self.assertRaises(TypeError, v._get_other, 3.4)\",\n \"def test_prevent_wrong_type(self):\\n self.assertRaises(cinv.host.Error, self.wrong_host_type)\",\n \"def test_episodenotfound(self):\\n self.assertRaises(tvdb_episodenotfound, lambda:self.t['Scrubs'][1][30])\",\n \"def test_bad_command2(self):\\n with self.assertRaises(KeyError):\\n command = Command['Fake Command2']\",\n \"def test_friendly_exception_formatting_exc_with_str_overload():\\n ex = InsufficientSignatures(1, 3)\\n\\n formatted_exception = friendlyEx(ex)\\n\\n assert formatted_exception == '{}'.format(ex.reason)\",\n \"def error_exit(self, msg):\\n wrappedmsg = textwrap.fill(msg, 78)\\n fullmsg = \\\"%s\\\\n%s\\\" % (wrappedmsg, self.get_usage_command())\\n raise SBToolError(fullmsg, True)\",\n \"def ErrorString(self): # real signature unknown; restored from __doc__\\n pass\",\n \"def test_known_common_stable_isotopes_error(func):\\n with pytest.raises(InvalidElementError):\\n func(\\\"n\\\")\\n pytest.fail(f\\\"{func} is not raising a ElementError for neutrons.\\\")\",\n \"def test_explainer_class_errors(self):\\n feature_importance = 'Feature importance not implemented.'\\n model_explanation = 'Model explanation (global) not implemented.'\\n instance_explanation = ('Data point explanation (local) not '\\n 'implemented.')\\n\\n with pytest.raises(NotImplementedError) as exinf:\\n self.explainer.feature_importance()\\n assert str(exinf.value) == feature_importance\\n with pytest.raises(NotImplementedError) as exinf:\\n self.explainer.explain_model()\\n assert str(exinf.value) == model_explanation\\n with pytest.raises(NotImplementedError) as exinf:\\n self.explainer.explain_instance()\\n assert str(exinf.value) == instance_explanation\",\n \"def error(self, msg):\\n raise TraitError(\\n \\\"%s at column %d of '%s'\\\" % (msg, self.index, self.text)\\n )\",\n \"def _raise_performing_request_error(self, *args, **kwargs):\",\n \"def test_make_compatible_taxa_summaries_incompatible(self):\\r\\n self.assertRaises(ValueError, _make_compatible_taxa_summaries,\\r\\n self.taxa_summary3, self.taxa_summary4)\\r\\n self.assertRaises(ValueError, _make_compatible_taxa_summaries,\\r\\n self.taxa_summary1, self.taxa_summary2)\",\n \"def ERR(self):\",\n \"def test_not_supported_requirement(self, space_each_type):\\n with pytest.raises(TypeError) as exc:\\n build_required_space(space_each_type, type_requirement=\\\"fasdfasf\\\")\\n assert \\\"Unsupported\\\" in str(exc.value)\",\n \"def throw(self, type, value=None, traceback=None):\\n pass\",\n \"def test_py2(self):\\n if sys.version_info >= self.MIN_SUPPORTED_VERSION:\\n return\\n try:\\n import miflora # noqa: F401 # pylint: disable=unused-import,import-outside-toplevel\\n\\n self.fail(\\\"Should have thrown an exception\\\")\\n except ValueError as val_err:\\n self.assertIn(\\\"version\\\", str(val_err))\",\n \"def test_init(self):\\n with self.assertRaises(IncompetentQiitaDeveloperError):\\n MetadataTemplate(1)\",\n \"def _Assert(self, t):\\n self.RaiseError(t, \\\"Assert not supported\\\")\",\n \"def test_fail_main_coord_def_mismatch(self):\\n args = self.args.copy()\\n args[\\\"def_file\\\"] = str(PATH_DATA / \\\"op_wrong1.def\\\")\\n with pytest.raises(BuildHError) as err:\\n UI.main(**args)\\n assert f\\\"Atoms defined in {args['def_file']} are missing in the structure\\\" in str(err.value)\",\n \"def test_init_unknown_error(self):\\n with self.assertRaises(QiitaDBUnknownIDError):\\n SampleTemplate(2)\",\n \"def test_unsupported_options_handled_nicely(self):\\r\\n self.params['beta_diversity'] = {'blah': \\\"something-broken\\\"}\\r\\n self.assertRaises(WorkflowError,\\r\\n run_beta_diversity_through_plots,\\r\\n self.test_data['biom'][0],\\r\\n self.test_data['map'][0],\\r\\n self.test_out,\\r\\n call_commands_serially,\\r\\n self.params,\\r\\n self.qiime_config,\\r\\n tree_fp=self.test_data['tree'][0],\\r\\n parallel=False,\\r\\n status_update_callback=no_status_updates)\\r\\n\\r\\n # Check that the log file is created and has size > 0\\r\\n log_fp = glob(join(self.test_out, 'log*.txt'))[0]\\r\\n self.assertTrue(getsize(log_fp) > 0)\",\n \"def test_handle_flag_error(self):\\n pass\",\n \"def _TypeMismatch(a, b):\\n return 'Types do not match, %s v. %s' % (str(a), str(b))\",\n \"async def cog_command_error(self, ctx:utils.Context, error:commands.CheckFailure):\\n\\n # Throw errors properly for me\\n if ctx.author.id in self.bot.config['owners']:\\n text = f'```py\\\\n{error}```'\\n await ctx.send(text)\\n raise error\\n\\n elif isinstance(error, commands.NotOwner):\\n await ctx.send(\\\"You need to be registered as an owner to run this command.\\\")\\n return\",\n \"def _error(msg):\\n\\n error(None, msg)\",\n \"def manifest_with_many_types_of_errors_helper(error_log):\\n assert '\\\"invalid_authz\\\"' in error_log\\n assert '\\\"invalid_int\\\"' in error_log\\n assert '\\\"invalid_md5\\\"' in error_log\\n assert '\\\"invalid_url\\\"' in error_log\",\n \"def test_wrong_type(self):\\n msg = 'Widget type is not valid. Valid widget types are: ' + \\\\\\n 'basic, default, formula, histogram, category, animation, time-series.'\\n\\n with pytest.raises(ValueError) as e:\\n Widget({'type': 'xxx'}).get_info()\\n assert str(e.value) == msg\",\n \"def testInvalidDescriptions(self):\\n self.assertFalse(self.app._ignore_jobs(\\\"telecommuting is not an option\\\"))\\n self.assertFalse(self.app._ignore_jobs(\\\"No telecommuting\\\"))\\n self.assertFalse(self.app._ignore_jobs(\\\"No telecommute\\\"))\\n self.assertFalse(self.app._ignore_jobs(\\\"TELECOMMUTE IS NOT AN OPTION\\\"))\",\n \"def test04(self):\\n self.assertRaises(TypeError, robustApply, oneArgument, \\\"this\\\", blah=\\\"that\\\")\",\n \"def _error(self, *args, **kwargs):\\n print(\\\"[{}]\\\".format(self.type), *args, file=sys.stderr, **kwargs)\\n sys.exit(1)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6747502","0.6558903","0.6558514","0.653314","0.6455933","0.63935745","0.6391505","0.6379069","0.6378044","0.6333795","0.6234843","0.6221498","0.61709213","0.6087179","0.60803807","0.6072119","0.6054898","0.6038267","0.6025209","0.6005897","0.59995884","0.59585947","0.5931985","0.5914876","0.5899732","0.5884995","0.58749026","0.5865561","0.58582824","0.58575624","0.5835879","0.5833873","0.5832171","0.58258045","0.5821348","0.58191043","0.5817756","0.58112013","0.5810757","0.58063275","0.5801969","0.5794187","0.57881194","0.5787273","0.57786876","0.57777417","0.5774632","0.5762242","0.5745393","0.5745135","0.5744874","0.5744821","0.57375157","0.5735383","0.5734876","0.57313","0.5729259","0.5726768","0.5724598","0.57168216","0.5716759","0.5712711","0.5701892","0.56912225","0.5689502","0.5689305","0.56806976","0.56781286","0.56755483","0.56568027","0.56555223","0.565381","0.565278","0.56488866","0.5647902","0.5639411","0.56263715","0.5614347","0.56128895","0.56086737","0.5603016","0.5598689","0.55965036","0.55922335","0.5591913","0.5591476","0.55796045","0.557916","0.55749774","0.55704874","0.55688894","0.5561397","0.55608755","0.5556576","0.5556119","0.5553269","0.55477977","0.5546237","0.55445397","0.5543795","0.5543494"],"string":"[\n \"0.6747502\",\n \"0.6558903\",\n \"0.6558514\",\n \"0.653314\",\n \"0.6455933\",\n \"0.63935745\",\n \"0.6391505\",\n \"0.6379069\",\n \"0.6378044\",\n \"0.6333795\",\n \"0.6234843\",\n \"0.6221498\",\n \"0.61709213\",\n \"0.6087179\",\n \"0.60803807\",\n \"0.6072119\",\n \"0.6054898\",\n \"0.6038267\",\n \"0.6025209\",\n \"0.6005897\",\n \"0.59995884\",\n \"0.59585947\",\n \"0.5931985\",\n \"0.5914876\",\n \"0.5899732\",\n \"0.5884995\",\n \"0.58749026\",\n \"0.5865561\",\n \"0.58582824\",\n \"0.58575624\",\n \"0.5835879\",\n \"0.5833873\",\n \"0.5832171\",\n \"0.58258045\",\n \"0.5821348\",\n \"0.58191043\",\n \"0.5817756\",\n \"0.58112013\",\n \"0.5810757\",\n \"0.58063275\",\n \"0.5801969\",\n \"0.5794187\",\n \"0.57881194\",\n \"0.5787273\",\n \"0.57786876\",\n \"0.57777417\",\n \"0.5774632\",\n \"0.5762242\",\n \"0.5745393\",\n \"0.5745135\",\n \"0.5744874\",\n \"0.5744821\",\n \"0.57375157\",\n \"0.5735383\",\n \"0.5734876\",\n \"0.57313\",\n \"0.5729259\",\n \"0.5726768\",\n \"0.5724598\",\n \"0.57168216\",\n \"0.5716759\",\n \"0.5712711\",\n \"0.5701892\",\n \"0.56912225\",\n \"0.5689502\",\n \"0.5689305\",\n \"0.56806976\",\n \"0.56781286\",\n \"0.56755483\",\n \"0.56568027\",\n \"0.56555223\",\n \"0.565381\",\n \"0.565278\",\n \"0.56488866\",\n \"0.5647902\",\n \"0.5639411\",\n \"0.56263715\",\n \"0.5614347\",\n \"0.56128895\",\n \"0.56086737\",\n \"0.5603016\",\n \"0.5598689\",\n \"0.55965036\",\n \"0.55922335\",\n \"0.5591913\",\n \"0.5591476\",\n \"0.55796045\",\n \"0.557916\",\n \"0.55749774\",\n \"0.55704874\",\n \"0.55688894\",\n \"0.5561397\",\n \"0.55608755\",\n \"0.5556576\",\n \"0.5556119\",\n \"0.5553269\",\n \"0.55477977\",\n \"0.5546237\",\n \"0.55445397\",\n \"0.5543795\",\n \"0.5543494\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21395,"cells":{"query":{"kind":"string","value":"Gets list of project users from taiga api, authorization token is provided Returns List of users emails"},"document":{"kind":"string","value":"def project_users(): \r\n project_school = api.projects.get_by_slug('ps') \r\n users_list = []\r\n for member in project_school.members:\r\n users_list.append(member.username + '@miem.hse.ru')\r\n \r\n #replaces some users usernames as they are different in taiga than in google groups \r\n for user in range(len(users_list)):\r\n if (users_list[user] == 'DenisPalukha@miem.hse.ru'):\r\n users_list[user] = 'dvpalukha@miem.hse.ru'\r\n if (users_list[user] == 'Affid@miem.hse.ru'):\r\n users_list[user] = 'aafyodorov@miem.hse.ru'\r\n \r\n return users_list"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def fetch_all_users():\n url = \"{}/workspace/{}/users\".format(V1_API_URL, WORKSPACE_ID)\n responses = requests.get(url, headers=HEADERS)\n return [\n {\n \"acronym\": user[\"name\"].lower(),\n \"clockify_id\": user[\"id\"],\n \"email\": user[\"email\"].lower(),\n }\n for user in responses.json()\n ]","def list_users(access_token):\n request_url = OKTA_URL + \"api/v1/users\"\n headers = {\"Authorization\": \"Bearer \" + access_token}\n group_request = requests.get(request_url, headers=headers).json()\n return group_request","def get_emails(self, token):\n user_email_url = get_config('login.github.emails_info_url')\n headers = {\n \"Authorization\": \"token %s\" % token\n }\n email_info_resp = get_remote(user_email_url, headers)\n email_list = json.loads(email_info_resp)\n\n return email_list","def list_users(self):\n _url = \"http://\" + self.host_ip + \":35357/v2.0/users\"\n _body = None\n _headers = {'Content-type': 'application/json',\n 'x-auth-token': self.cloud_admin_info['token_project']}\n\n response = self.request(\"GET\", _url, _headers, _body)\n if response is None:\n LOG_OBJ.error(\" no response from Server\")\n return response\n if response.status not in [200, 201, 202, 203, 204]:\n LOG_OBJ.error(\n \"get user list Failed with status %s \" %\n response.status)\n return response.status\n\n output = json.loads(response.data)\n LOG_OBJ.info(\"users List : %s\")\n return output[\"users\"]","def get_users(self, *args, **kwargs):\n\n users_data = api.get_users(\n *args,\n api_key=self.__creds.api_key_v2, \n **kwargs)\n return [en.User(creds=self.__creds, **user_data) for user_data in users_data]","def build_users_list():\n\n # Cannot query in cronjob (only use case for this func) without app running.\n # Must build separate connection to read file\n # con = sqlite3.connect(f\"{cur_wd}/bigbeta/site.db\")\n # cur = con.cursor()\n # users_list = [u for u in cur.execute(\"SELECT email FROM user;\")]\n\n # Get app context\n\n with bigbeta_app.app_context():\n users = User.query.all()\n user_emails = [user.email for user in users]\n\n return user_emails","def get_all_users():\n token = request.headers.get('token')\n\n # Token Validation\n token_valid, response = is_token_valid(token)\n if not token_valid:\n return response\n token_username = response\n\n # Privilege handling\n if token_username != 'admin':\n return jsonify({'message': \"You aren't allowed to access this\"}), 404\n\n return jsonify(list(Users.values())), 200","def users():\n access_token = session['access_token']\n return \"%s\" % list_users(access_token)","def get_users(self):\n url = \"%s/api/v1/users\" % self.subdomain\n req = request.get(url, headers=self.api_headers)\n if request.ok(req):\n response_json = req.json()\n return response_json[\"users\"]\n else:\n return None","def get_all_users(session, data):\n\n all_users = None\n user_data = []\n\n page = 1\n per_page = 10\n\n email_recipients = []\n\n all_users = session.query(UsersAuthModel).all()\n\n if 'offset' in data.keys() and 'limit' in data.keys():\n page = data.get('offset')\n per_page = data.get('limit')\n\n all_users = session.query(UsersAuthModel).paginate(page=page, per_page=per_page, error_out=False).all()\n\n for user_rs in all_users:\n id_user = user_rs.user_id\n username = user_rs.user_name\n password = user_rs.password\n is_active = user_rs.is_active\n is_staff = user_rs.is_staff\n is_superuser = user_rs.is_superuser\n creation_date = user_rs.creation_date\n last_update_date = user_rs.last_update_date\n\n user_data += [{\n \"AuthUser\": {\n \"Id\": id_user,\n \"Username\": username,\n \"Password\": password,\n \"IsActive\": is_active,\n \"IsStaff\": is_staff,\n \"IsSuperuser\": is_superuser,\n \"CreationDate\": creation_date,\n \"LastUpdateDate\": last_update_date\n }\n }]\n\n if bool(is_active) and bool(is_superuser):\n email_recipients.append(username)\n\n cfg_app.email_recipients = email_recipients\n\n return json.dumps(user_data)","def get_users(self):\r\n\t\tlogger.debug(\"Fetch users\")\r\n\t\t\r\n\t\treturn login.get_users()","def get_all_users():","def get_users(self):\n res = self.conn.cursor().execute('SELECT id,email,username FROM users')\n return res.fetchall()","def get_users():\n return Response(f\"{User.get_all_users()}\", 200, mimetype='text/plain')","def get_users_for(self, email):\r\n # this is a list rather than a generator because we probably want to do a len() on it right away\r\n return [address.user for address in EmailAddress.objects.filter(verified=True, email=email)]","def users_get(self) -> Dict[str, list]:\n self.__logger.debug('Eva.users_get called')\n return self.__http_client.users_get()","def get_users(self):\n users = []\n page = 1\n while not len(users) % 100:\n users += self._get('/users?{0}'.format(urllib.urlencode({'per_page': 100, 'page': page})))\n if not users:\n break\n page += 1\n return users","def get_users_for(self, email):\n # this is a list rather than a generator because we probably want to\n # do a len() on it right away\n return [address.user for address in \\\n self.filter(verified=True, email=email)]","def users(self,org_id=None):\n if org_id is None:\n org_id = self.org_id\n return self.get('{}/orgs/{}/users'.format(ApiVersion.A1.value,org_id))","def get_users_of_project(self, project_id):\n res = self.conn.cursor().execute(\"\"\"SELECT id, username FROM users u JOIN users_projects up \n ON u.id = up.user_id \n WHERE up.project_id=?\"\"\", (project_id,))\n return res.fetchall()","def get_all_users():\n return jsonify(admin.get_all_users(current_app.scoped_session()))","def _get_users(_id, email, user_access_token, admin_access_token):\n admin = Session.query(User).filter_by(id_=ADMIN_USER_ID).one_or_none()\n if admin_access_token != admin.access_token:\n raise ValueError(\"Admin access token invalid.\")\n search_criteria = dict()\n if _id:\n search_criteria[\"id_\"] = _id\n if email:\n search_criteria[\"email\"] = email\n query = Session.query(User).filter_by(**search_criteria)\n if user_access_token:\n query = query.join(User.tokens).filter_by(\n token=user_access_token, type_=UserTokenType.reana\n )\n return query.all()","def get_users(self):\n fields = ['name', ]\n return self.get_data(\"myUsers\", fields)","def get_project_list(token):\n session = requests.Session()\n session.headers.update({'Authorization': f'Token {token}'})\n url = get_project_list_url()\n r = session.get(url=url)\n return r","def get_user_list(self, connection):\n http = get_web_service(connection)\n try:\n req = http.request('GET', connection[\"url\"] + '/users/?_format=json')\n data = json.loads(req.data.decode('utf-8'))\n # print(json.dumps(data, indent=4, sort_keys=True))\n return data\n except urllib3.exceptions.HTTPError as e:\n print(\"Connection error\")\n print(e)","def user_list(ctx):\n data = ctx.obj.get_all_users()\n output_json_data(data)","def fetch_users(self):\n data = self._make_request()\n return data['result']","def get_users():\n users = functions.users()\n return users","def get_list(self, per_page=100):\n url = \"{0}/users\".format(self.base_url)\n url = self._add_token_to_url(url)\n page_current = 0\n users_list = None\n\n self.session.headers.update({\"Content-Type\": \"application/json\"})\n\n while True:\n payload = {\"per_page\": per_page, \"page\": page_current + 1}\n user_list_response = self.session.get(url, params=payload, verify=False).json()\n # user_list_response = self.session.get(url, data=json.dumps(payload), verify=False).json()\n page_total = user_list_response['pagination']['total']\n page_current = user_list_response['pagination']['page']\n if users_list:\n users_list.extend(user_list_response['response'])\n else:\n users_list = user_list_response['response']\n if page_total == page_current:\n break\n return users_list","def get_users(self, query_args={}):\n endpoint = '/v3/educator/users'\n result = self.request(endpoint, query_args)\n\n users = []\n for data in result.response:\n user = User(data)\n users.append(user)\n\n return users","def getUsers(client, req):\n client.sendTarget(req[\"id\"], key=\"get.users\", payload={\"payload\": magic.users})","def get_users():\n current_user = get_jwt_identity()\n\n if not current_user:\n print('uri=/login error=\"Missing user\"', flush=True)\n return jsonify(message=\"Missing user\"), 400\n\n if not Administrator.is_administrator(current_user):\n print('non-admin user error', flush=True)\n return jsonify(message=\"Forbidden\"), 403\n\n try:\n users = User.get_users()\n print(users, flush=True)\n return jsonify(message='{}'.format(json.dumps(users))), 200\n\n except Exception as e:\n print(e, flush=True)\n return jsonify(message='{}'.format(e)), 501","def _get_users(self, context, project, object_list=None):\n by = self.request.GET.get(\"by\", \"\").lower()\n options = [\n (\"Project members\", \"members\"),\n (\"Others (Anonymous users)\", \"anonymous\"),\n ]\n exists = [i for i in options if i[1] == by]\n matches = exists[0][1] if len(exists) == 1 else \"\"\n\n if object_list is not None:\n return self._get_object_list(\n object_list,\n matches != \"\",\n creator__isnull=True if matches == \"anonymous\" else False,\n )\n\n return {\n **context,\n \"by\": by,\n \"by_options\": options,\n }","def get_users(self, email):\n active_users = User.objects.filter(\n email__iexact=email,\n is_active=True\n )\n return (u for u in active_users)","def get_users(filter, api_site_parameter, page = 1, pagesize = 30, sort = 'reputation'):\n path = \"users\"\n results = __fetch_results(path, api_site_parameter, inname= filter, page = page, pagesize = pagesize, sort = sort)\n return results","def users(self, site = None):\r\n uids = self.user_ids()\r\n if uids:\r\n users = Account._byID(uids, True, return_dict = False)\r\n return [self.ajax_user(u) for u in users]\r\n else:\r\n return ()","def list_users():\n if not check_content_type():\n return jsonify(status=CONTENT_TYPE_ERROR)\n reqdata = request.json\n if not check_token(reqdata[\"token\"]):\n return jsonify(status=TOKEN_ERROR)\n users = db.session.query(User).all()\n resdata = []\n for user in users:\n resdata.append({\"id\" : user.id, \"login\" : user.login, \"password\" : user.hash_password})\n return jsonify(data=resdata, status=OK_STATUS)","def get_users():\n users = storage.all('User')\n users_list = []\n for user in users.values():\n users_list.append(user.to_dict())\n return jsonify(users_list), 200","def list_users(self):\n raise NotImplementedError","def list_users(BrokerId=None, MaxResults=None, NextToken=None):\n pass","def get_users():\n return db.fetch_users()","def get_users(session, access_token, request_params={}):\n endpoint = \"https://graph.microsoft.com/v1.0/users\"\n r = session.get(endpoint, headers={\"Authorization\": \"Bearer \" + access_token})\n response = json.loads(r.text)\n return response[\"value\"]","def get(self):\n # TODO this endpoint returns null is instead of respoinse message when token is not in the header, read about error handling to solve this issue\n return get_users()","def get(self):\n return get_all_users()","def get(self):\n return get_all_users()","def get(self):\n return get_all_users()","def get(self):\n return get_all_users()","def get_users(self, email):\n print(\"bu\")\n active_users = UserModel._default_manager.filter(**{\n '%s__iexact' % UserModel.get_username_field_name(): username,\n 'is_active': True,\n })\n print(active_users)\n # active_users = UserModel._default_manager.filter(**{\n # '%s__iexact' % UserModel.get_email_field_name(): email,\n # 'is_active': True,\n # })\n return (u for u in active_users if u.has_usable_password())","def _users_list(self):\n result = self.slack.api_call(\"users.list\", presence=0)\n\n if not result.get(\"ok\"):\n logging.error(result['error'])\n return None\n\n return result['members']","def get_users(email=None, parentemail=None, username=None, include_pw_hash=False):\n db = api.db.get_conn()\n\n match = {}\n projection = {\"_id\": 0}\n if not include_pw_hash:\n projection[\"password_hash\"] = 0\n\n if email is not None:\n match.update({\"email\": re.compile(email, re.IGNORECASE)})\n elif parentemail is not None:\n match.update({\"demo.parentemail\": re.compile(parentemail, re.IGNORECASE)})\n elif username is not None:\n match.update({\"username\": re.compile(username, re.IGNORECASE)})\n else:\n raise PicoException(\"Could not retrieve user - no argument provided\", 400)\n\n return list(db.users.find(match, projection).limit(50))","def get_users(self, params=None):\n url = 'users'\n if params:\n url += '?%s' % urllib.urlencode(params)\n resp, body = self.get(url)\n self.expected_success(200, resp.status)\n body = json.loads(body)\n return service_client.ResponseBodyList(resp, body['users'])","def get_users():\n return jsonify([\n users.to_dict()\n for users in models.storage.all('User').values()\n ])","def users(self, team, params={}, **options):\n path = \"/teams/%s/users\" % (team)\n return self.client.get_collection(path, params, **options)","def get_users():\n username = request.args.get('username')\n netAdminToolDB = app.config['DATABASE']\n if username != None:\n users = []\n users.append(netAdminToolDB.get_user_name(username))\n else:\n users = netAdminToolDB.get_user()\n\n userList = []\n for user in users:\n uri = url_for('get_user', user_id=user.id,_external=True)\n #role = netAdminToolDB.get_role(user.role_id)\n userList.append({\n 'id': user.id,\n 'uri': uri,\n 'username': user.username,\n 'display_name': user.display_name,\n 'role': user.role_name\n })\n if userList == []:\n return jsonify({'error': 'No users found'}), 404\n\n return jsonify({'users': userList })","def list_users(ctx, project_name):\n project = ctx.obj.groups.byName[project_name].get().data\n pprint(ctx.obj.groups[project.id].databaseUsers.get().data)","def getInterestedUsers():","def slack_users_by_email(self, emails):\n users = []\n for user in self.all_slack_users:\n if user['profile'].get('email') in emails:\n users.append(user)\n\n return users","def get_users(self):\n return self.execute(TABELLE['users']['select']['all'])","def list_users(self):\n return self.get_admin(\"users\")","def get(self):\n\n offset = 0\n limit = Config.get_page_limit()\n args = request.args\n try:\n offset = request.args['offset']\n except Exception:\n pass\n\n try:\n limit = request.args['limit']\n except Exception:\n pass\n\n return self.get_request_handler(request.headers).get_all_users(offset=offset, limit=limit)","def list_users(self, startIndex=0, pageSize=10):\n uURL = self._url + \"/users/getUsers\"\n params={\n \"f\" : \"json\",\n \"startIndex\" : startIndex,\n \"pageSize\" : pageSize\n }\n return self._con.post(path=uURL,\n postdata=params)","def get_users():\n users = User.query.order_by(User.id).all()\n users = {user.id: user.username for user in users}\n\n response = jsonify({\"success\": True, \"users\": users})\n\n return response","def emails(self):\r\n url = api_base + 'emails/'\r\n return json.loads(self.load_url(url))","def get_every_user():\r\n connect(\"mongodb://vcm-3594.vm.duke.edu:27017/heart_rate_app\")\r\n user_list = get_all_users()\r\n return_dict = {\r\n \"user_emails\": user_list\r\n }\r\n return jsonify(return_dict),200","def _get_users_list(self):\n return self.users['user_id'].tolist()","def check_user_email(self, email):\n useremails = []\n for user in self.__users:\n if user['email'] == email:\n useremails.append(user)\n return useremails","def listUsers(self):\n return self._client.listUsers()","def getContributors(auth):\n users = []\n r = requests.get(url='https://gist.github.com/paulmillr/2657075/',\n auth=auth)\n soup = BeautifulSoup(r.text, 'html.parser')\n users = [tr.select_one('a').text for tr in soup('tbody')[0].select('tr')]\n return users","def users(self):\n return self.get_data(\"users\")","def get_all_users():\n users = []\n for mv in storage.all(\"User\").values():\n users.append(mv.to_dict())\n return jsonify(users)","def retrieve_users(payload):\n selection = User.query.order_by(User.id).all()\n users = []\n for item in selection:\n formatted_user = item.format()\n users.append(formatted_user)\n\n return jsonify({\n 'success': True,\n 'total': len(users),\n 'users': users\n })","def get_user_list(host):\n users = query(\"$.host.'{host}'.user\", host=host)\n if isinstance(users, (str, unicode)):\n users = users.replace(', ', ' ').replace(',', ' ').split(' ')\n return users or []","def get_users(self) -> List[Dict[str, Any]]:\n users = self.user_manager.get_users()\n return [\n {\n 'user_id': user.user_id,\n 'username': user.username,\n 'created_at': user.created_at.isoformat(),\n }\n for user in users\n ]","def users(self, per_page=None, page=None):\r\n params = base.get_params(None, locals())\r\n url = '{0}/{1}'.format(self.get_url(), 'users')\r\n return http.Request('GET', url, params), parsers.parse_json","def get_users():\n selection = []\n try:\n selection = [{'id':usr.id, 'username':usr.username, 'email':usr.email} \n for usr in User.query.all()]\n except:\n selection = {'error':True}\n return json.dumps(selection)","def get_user_profiles(self):\n print 'inside get user profiles'\n print 'self.username :' + self.username\n g = GoogleAnalyticsAPI(self.username)\n if g:\n print 'GA client exists'\n user_accounts = g.get_user_accounts()\n return user_accounts.get('items')\n else:\n print 'GA client does not exist'\n return []","def show_users(self):\n\n u = User(self.settings)\n users_list = u.find_users()\n\n # transform the results in a \"jsonifiable\"-form\n json_results = []\n for user in users_list:\n json_results.append(user.to_json())\n\n # return\n return json_results","def _load_users(self) -> List[Dict]:\n try:\n api_call = self.web_client.api_call('users.list')\n if api_call.get('ok'):\n return api_call.get('members')\n except Exception:\n LOGGER.exception('Cannot get users')\n raise","def get_slack_users(users=[]):\n api_call = slack_client.api_call(\"users.list\")\n if api_call.get('ok'):\n # retrieve all users so we can find our bot\n users = api_call.get('members')\n return users","def getResponsibleUsers():","def get_company_users(self, company_referece, active=True):\n url = 'companies/{0}/users'.format(company_referece)\n if active:\n data = {'status_in_company': 'active'}\n else:\n data = {'status_in_company': 'inactive'}\n result = self.get(url, data)\n return result.get('users', result)","def getUsers(self) -> List[bbUser.bbUser]:\n return list(self.users.values())","def task_get_users(task):\n logger = logging.getLogger(__name__)\n logger.debug('Get JUNOS users info')\n result = list()\n out = task.run(task=netmiko_send_command,\n command_string=\"show configuration system login\")\n if out.failed:\n for host in out.failed_hosts.keys():\n logger.warning('Failed task on device {}'.format(task.inventory.hosts[host].name))\n task.inventory.hosts[host]['error'] = True\n for host, res in out.items():\n if not res.failed:\n logger.debug('Fill JUNOS users properties from device {}'.format(task.inventory.hosts[host].name))\n task.inventory.hosts[host]['error'] = False\n# with open('output/junos_show_conf_system_login.txt','w+') as f:\n# f.write(r.result)\n result.append(parse_users(host, res.result))\n return result","def get_users(self, headers=None, query_params=None):\n uri = self.url + \"/users\"\n uri = uri + build_query_string(query_params)\n return requests.get(uri, headers=headers)","def list_users():\n return json_response(\n status=200,\n response_data={\n \"success\": True,\n \"data\": {\n \"users\": [user.serialize() for user in User.all()]\n }\n }\n )","def getUsersData(self):\n users_data = self.get_api_results(\n \"/api/user/list?fields=id,username,name,phone,email,url,about,role,joined,lastactive,avatar,company,position,location&api_key={0}&format=json\")\n for user in users_data:\n if user[\"name\"] not in self.users:\n self.add_user(user)\n else:\n self.merge_user(user)\n return users_data","def get_users(self, date_start, date_end, project='enwiki'):\n\n # @TODO MOVE DB REFS INTO QUERY MODULE\n\n params = {\n 'date_start': format_mediawiki_timestamp(date_start),\n 'date_end': format_mediawiki_timestamp(date_end),\n }\n conn = Connector(instance=settings.PROJECT_DB_MAP[project])\n query = sub_tokens(self.QUERY_TYPES[self._query_type],\n db=escape_var(project))\n conn._cur_.execute(query, params)\n\n for row in conn._cur_:\n yield row[0]","def user_list(request_dict):\n users = User.query.all()\n users_list = list()\n for user in users:\n users_list.append(user)\n\n return JSONTools.user_list_reply(users_list)","def get_all_users(self) -> tuple:\n users_list: dict_list_type = [user.to_dict() for user in UserModel.query().fetch()]\n message: str = 'successfully retrieved active users'\n return jsonify({'status': True, 'payload': users_list, 'message': message}), 200","def get_users(self):\n query = \"\"\"SELECT firstname,lastname,othernames,email,phonenumber,\\\n username,public_id,isadmin,isactive,registered\\\n from users ORDER BY registered ASC\"\"\"\n conn = self.db\n cursor = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)\n cursor.execute(query)\n rows = cursor.fetchall()\n return rows","def get_users(self, *, Range=None, filter=None, fields=None, **kwargs):\n headers = kwargs.get('headers', {}).update({'Allow-Hidden': True})\n function_endpoint = urljoin(self._baseurl, 'users')\n return self._call('GET', function_endpoint, headers=headers, **kwargs)","def get_user_list():\n response = []\n for user in mongo.db.users.find():\n user[\"_id\"] = str(user[\"_id\"])\n response.append(user)\n return response","def get(self):\n\n users = [marshal(user, user_fields) for user in models.ExerciseUser.select()]\n\n return users","def get_user_info_list(self):\n\t\treturn Job(SDK.PrlSrv_GetUserInfoList(self.handle)[0])","def emails(self):\r\n return UserEmails(self)","def get_projects():\n if current_user.get_id() is None:\n return\n with database.engine.begin() as connection:\n result = connection.execute(select(\n [models.projects.c.project_id, models.projects.c.name, models.projects.c.path, models.projects.c.creation_date, models.projects.c.user_id, func.count(models.objects.c.object_id).label('object_count')])\n .select_from(models.projects.outerjoin(models.objects))\n .where(and_(models.projects.c.active == True, models.projects.c.user_id == current_user.id))\n .group_by(models.projects.c.project_id)\n .order_by(models.projects.c.project_id))\n projects = [dict(row) for row in result]\n for project in projects:\n user = models.User.query.filter_by(\n id=project['user_id']).first()\n if user:\n project['email'] = user.email\n return projects","def fusion_api_get_directory_users(self, body, api=None, headers=None):\n return self.logindomain.users(body, api, headers)","async def list_users(self, ctx):\n \n path = \"Users\"\n headers = {\n 'accept': 'application/json'\n }\n response = send_request(method=\"get\", path=path, headers=headers)\n users = []\n for page in response:\n users.append(f\"**{page['Name']}**: ``{page['Id']}``\")\n log.debug(users)\n\n embed = embeds.make_embed(ctx=ctx, title=\"List Users\", image_url=\"https://emby.media/resources/logowhite_1881.png\")\n\n await LinePaginator.paginate([line for line in users], ctx, embed, restrict_to_user=ctx.author)","def _get_userlist_by_userright(self, userright):\n params = {\n \"action\": \"query\",\n \"list\": \"allusers\",\n \"format\": \"json\",\n \"augroup\": userright,\n \"aulimit\": \"500\",\n }\n r = self.session.get(ENWIKI_API, params=params)\n data = r.json()\n return [u[\"name\"] for u in data[\"query\"][\"allusers\"]]","def list_users():\n\ttry:\n\t\tusers_call = sc.api_call(\"users.list\")\n\t\tusers = []\n\t\tif users_call.get('ok'):\n\t\t\treturn users_call['members']\n\texcept:\n\t\tprint(\"users error\")\n\treturn None"],"string":"[\n \"def fetch_all_users():\\n url = \\\"{}/workspace/{}/users\\\".format(V1_API_URL, WORKSPACE_ID)\\n responses = requests.get(url, headers=HEADERS)\\n return [\\n {\\n \\\"acronym\\\": user[\\\"name\\\"].lower(),\\n \\\"clockify_id\\\": user[\\\"id\\\"],\\n \\\"email\\\": user[\\\"email\\\"].lower(),\\n }\\n for user in responses.json()\\n ]\",\n \"def list_users(access_token):\\n request_url = OKTA_URL + \\\"api/v1/users\\\"\\n headers = {\\\"Authorization\\\": \\\"Bearer \\\" + access_token}\\n group_request = requests.get(request_url, headers=headers).json()\\n return group_request\",\n \"def get_emails(self, token):\\n user_email_url = get_config('login.github.emails_info_url')\\n headers = {\\n \\\"Authorization\\\": \\\"token %s\\\" % token\\n }\\n email_info_resp = get_remote(user_email_url, headers)\\n email_list = json.loads(email_info_resp)\\n\\n return email_list\",\n \"def list_users(self):\\n _url = \\\"http://\\\" + self.host_ip + \\\":35357/v2.0/users\\\"\\n _body = None\\n _headers = {'Content-type': 'application/json',\\n 'x-auth-token': self.cloud_admin_info['token_project']}\\n\\n response = self.request(\\\"GET\\\", _url, _headers, _body)\\n if response is None:\\n LOG_OBJ.error(\\\" no response from Server\\\")\\n return response\\n if response.status not in [200, 201, 202, 203, 204]:\\n LOG_OBJ.error(\\n \\\"get user list Failed with status %s \\\" %\\n response.status)\\n return response.status\\n\\n output = json.loads(response.data)\\n LOG_OBJ.info(\\\"users List : %s\\\")\\n return output[\\\"users\\\"]\",\n \"def get_users(self, *args, **kwargs):\\n\\n users_data = api.get_users(\\n *args,\\n api_key=self.__creds.api_key_v2, \\n **kwargs)\\n return [en.User(creds=self.__creds, **user_data) for user_data in users_data]\",\n \"def build_users_list():\\n\\n # Cannot query in cronjob (only use case for this func) without app running.\\n # Must build separate connection to read file\\n # con = sqlite3.connect(f\\\"{cur_wd}/bigbeta/site.db\\\")\\n # cur = con.cursor()\\n # users_list = [u for u in cur.execute(\\\"SELECT email FROM user;\\\")]\\n\\n # Get app context\\n\\n with bigbeta_app.app_context():\\n users = User.query.all()\\n user_emails = [user.email for user in users]\\n\\n return user_emails\",\n \"def get_all_users():\\n token = request.headers.get('token')\\n\\n # Token Validation\\n token_valid, response = is_token_valid(token)\\n if not token_valid:\\n return response\\n token_username = response\\n\\n # Privilege handling\\n if token_username != 'admin':\\n return jsonify({'message': \\\"You aren't allowed to access this\\\"}), 404\\n\\n return jsonify(list(Users.values())), 200\",\n \"def users():\\n access_token = session['access_token']\\n return \\\"%s\\\" % list_users(access_token)\",\n \"def get_users(self):\\n url = \\\"%s/api/v1/users\\\" % self.subdomain\\n req = request.get(url, headers=self.api_headers)\\n if request.ok(req):\\n response_json = req.json()\\n return response_json[\\\"users\\\"]\\n else:\\n return None\",\n \"def get_all_users(session, data):\\n\\n all_users = None\\n user_data = []\\n\\n page = 1\\n per_page = 10\\n\\n email_recipients = []\\n\\n all_users = session.query(UsersAuthModel).all()\\n\\n if 'offset' in data.keys() and 'limit' in data.keys():\\n page = data.get('offset')\\n per_page = data.get('limit')\\n\\n all_users = session.query(UsersAuthModel).paginate(page=page, per_page=per_page, error_out=False).all()\\n\\n for user_rs in all_users:\\n id_user = user_rs.user_id\\n username = user_rs.user_name\\n password = user_rs.password\\n is_active = user_rs.is_active\\n is_staff = user_rs.is_staff\\n is_superuser = user_rs.is_superuser\\n creation_date = user_rs.creation_date\\n last_update_date = user_rs.last_update_date\\n\\n user_data += [{\\n \\\"AuthUser\\\": {\\n \\\"Id\\\": id_user,\\n \\\"Username\\\": username,\\n \\\"Password\\\": password,\\n \\\"IsActive\\\": is_active,\\n \\\"IsStaff\\\": is_staff,\\n \\\"IsSuperuser\\\": is_superuser,\\n \\\"CreationDate\\\": creation_date,\\n \\\"LastUpdateDate\\\": last_update_date\\n }\\n }]\\n\\n if bool(is_active) and bool(is_superuser):\\n email_recipients.append(username)\\n\\n cfg_app.email_recipients = email_recipients\\n\\n return json.dumps(user_data)\",\n \"def get_users(self):\\r\\n\\t\\tlogger.debug(\\\"Fetch users\\\")\\r\\n\\t\\t\\r\\n\\t\\treturn login.get_users()\",\n \"def get_all_users():\",\n \"def get_users(self):\\n res = self.conn.cursor().execute('SELECT id,email,username FROM users')\\n return res.fetchall()\",\n \"def get_users():\\n return Response(f\\\"{User.get_all_users()}\\\", 200, mimetype='text/plain')\",\n \"def get_users_for(self, email):\\r\\n # this is a list rather than a generator because we probably want to do a len() on it right away\\r\\n return [address.user for address in EmailAddress.objects.filter(verified=True, email=email)]\",\n \"def users_get(self) -> Dict[str, list]:\\n self.__logger.debug('Eva.users_get called')\\n return self.__http_client.users_get()\",\n \"def get_users(self):\\n users = []\\n page = 1\\n while not len(users) % 100:\\n users += self._get('/users?{0}'.format(urllib.urlencode({'per_page': 100, 'page': page})))\\n if not users:\\n break\\n page += 1\\n return users\",\n \"def get_users_for(self, email):\\n # this is a list rather than a generator because we probably want to\\n # do a len() on it right away\\n return [address.user for address in \\\\\\n self.filter(verified=True, email=email)]\",\n \"def users(self,org_id=None):\\n if org_id is None:\\n org_id = self.org_id\\n return self.get('{}/orgs/{}/users'.format(ApiVersion.A1.value,org_id))\",\n \"def get_users_of_project(self, project_id):\\n res = self.conn.cursor().execute(\\\"\\\"\\\"SELECT id, username FROM users u JOIN users_projects up \\n ON u.id = up.user_id \\n WHERE up.project_id=?\\\"\\\"\\\", (project_id,))\\n return res.fetchall()\",\n \"def get_all_users():\\n return jsonify(admin.get_all_users(current_app.scoped_session()))\",\n \"def _get_users(_id, email, user_access_token, admin_access_token):\\n admin = Session.query(User).filter_by(id_=ADMIN_USER_ID).one_or_none()\\n if admin_access_token != admin.access_token:\\n raise ValueError(\\\"Admin access token invalid.\\\")\\n search_criteria = dict()\\n if _id:\\n search_criteria[\\\"id_\\\"] = _id\\n if email:\\n search_criteria[\\\"email\\\"] = email\\n query = Session.query(User).filter_by(**search_criteria)\\n if user_access_token:\\n query = query.join(User.tokens).filter_by(\\n token=user_access_token, type_=UserTokenType.reana\\n )\\n return query.all()\",\n \"def get_users(self):\\n fields = ['name', ]\\n return self.get_data(\\\"myUsers\\\", fields)\",\n \"def get_project_list(token):\\n session = requests.Session()\\n session.headers.update({'Authorization': f'Token {token}'})\\n url = get_project_list_url()\\n r = session.get(url=url)\\n return r\",\n \"def get_user_list(self, connection):\\n http = get_web_service(connection)\\n try:\\n req = http.request('GET', connection[\\\"url\\\"] + '/users/?_format=json')\\n data = json.loads(req.data.decode('utf-8'))\\n # print(json.dumps(data, indent=4, sort_keys=True))\\n return data\\n except urllib3.exceptions.HTTPError as e:\\n print(\\\"Connection error\\\")\\n print(e)\",\n \"def user_list(ctx):\\n data = ctx.obj.get_all_users()\\n output_json_data(data)\",\n \"def fetch_users(self):\\n data = self._make_request()\\n return data['result']\",\n \"def get_users():\\n users = functions.users()\\n return users\",\n \"def get_list(self, per_page=100):\\n url = \\\"{0}/users\\\".format(self.base_url)\\n url = self._add_token_to_url(url)\\n page_current = 0\\n users_list = None\\n\\n self.session.headers.update({\\\"Content-Type\\\": \\\"application/json\\\"})\\n\\n while True:\\n payload = {\\\"per_page\\\": per_page, \\\"page\\\": page_current + 1}\\n user_list_response = self.session.get(url, params=payload, verify=False).json()\\n # user_list_response = self.session.get(url, data=json.dumps(payload), verify=False).json()\\n page_total = user_list_response['pagination']['total']\\n page_current = user_list_response['pagination']['page']\\n if users_list:\\n users_list.extend(user_list_response['response'])\\n else:\\n users_list = user_list_response['response']\\n if page_total == page_current:\\n break\\n return users_list\",\n \"def get_users(self, query_args={}):\\n endpoint = '/v3/educator/users'\\n result = self.request(endpoint, query_args)\\n\\n users = []\\n for data in result.response:\\n user = User(data)\\n users.append(user)\\n\\n return users\",\n \"def getUsers(client, req):\\n client.sendTarget(req[\\\"id\\\"], key=\\\"get.users\\\", payload={\\\"payload\\\": magic.users})\",\n \"def get_users():\\n current_user = get_jwt_identity()\\n\\n if not current_user:\\n print('uri=/login error=\\\"Missing user\\\"', flush=True)\\n return jsonify(message=\\\"Missing user\\\"), 400\\n\\n if not Administrator.is_administrator(current_user):\\n print('non-admin user error', flush=True)\\n return jsonify(message=\\\"Forbidden\\\"), 403\\n\\n try:\\n users = User.get_users()\\n print(users, flush=True)\\n return jsonify(message='{}'.format(json.dumps(users))), 200\\n\\n except Exception as e:\\n print(e, flush=True)\\n return jsonify(message='{}'.format(e)), 501\",\n \"def _get_users(self, context, project, object_list=None):\\n by = self.request.GET.get(\\\"by\\\", \\\"\\\").lower()\\n options = [\\n (\\\"Project members\\\", \\\"members\\\"),\\n (\\\"Others (Anonymous users)\\\", \\\"anonymous\\\"),\\n ]\\n exists = [i for i in options if i[1] == by]\\n matches = exists[0][1] if len(exists) == 1 else \\\"\\\"\\n\\n if object_list is not None:\\n return self._get_object_list(\\n object_list,\\n matches != \\\"\\\",\\n creator__isnull=True if matches == \\\"anonymous\\\" else False,\\n )\\n\\n return {\\n **context,\\n \\\"by\\\": by,\\n \\\"by_options\\\": options,\\n }\",\n \"def get_users(self, email):\\n active_users = User.objects.filter(\\n email__iexact=email,\\n is_active=True\\n )\\n return (u for u in active_users)\",\n \"def get_users(filter, api_site_parameter, page = 1, pagesize = 30, sort = 'reputation'):\\n path = \\\"users\\\"\\n results = __fetch_results(path, api_site_parameter, inname= filter, page = page, pagesize = pagesize, sort = sort)\\n return results\",\n \"def users(self, site = None):\\r\\n uids = self.user_ids()\\r\\n if uids:\\r\\n users = Account._byID(uids, True, return_dict = False)\\r\\n return [self.ajax_user(u) for u in users]\\r\\n else:\\r\\n return ()\",\n \"def list_users():\\n if not check_content_type():\\n return jsonify(status=CONTENT_TYPE_ERROR)\\n reqdata = request.json\\n if not check_token(reqdata[\\\"token\\\"]):\\n return jsonify(status=TOKEN_ERROR)\\n users = db.session.query(User).all()\\n resdata = []\\n for user in users:\\n resdata.append({\\\"id\\\" : user.id, \\\"login\\\" : user.login, \\\"password\\\" : user.hash_password})\\n return jsonify(data=resdata, status=OK_STATUS)\",\n \"def get_users():\\n users = storage.all('User')\\n users_list = []\\n for user in users.values():\\n users_list.append(user.to_dict())\\n return jsonify(users_list), 200\",\n \"def list_users(self):\\n raise NotImplementedError\",\n \"def list_users(BrokerId=None, MaxResults=None, NextToken=None):\\n pass\",\n \"def get_users():\\n return db.fetch_users()\",\n \"def get_users(session, access_token, request_params={}):\\n endpoint = \\\"https://graph.microsoft.com/v1.0/users\\\"\\n r = session.get(endpoint, headers={\\\"Authorization\\\": \\\"Bearer \\\" + access_token})\\n response = json.loads(r.text)\\n return response[\\\"value\\\"]\",\n \"def get(self):\\n # TODO this endpoint returns null is instead of respoinse message when token is not in the header, read about error handling to solve this issue\\n return get_users()\",\n \"def get(self):\\n return get_all_users()\",\n \"def get(self):\\n return get_all_users()\",\n \"def get(self):\\n return get_all_users()\",\n \"def get(self):\\n return get_all_users()\",\n \"def get_users(self, email):\\n print(\\\"bu\\\")\\n active_users = UserModel._default_manager.filter(**{\\n '%s__iexact' % UserModel.get_username_field_name(): username,\\n 'is_active': True,\\n })\\n print(active_users)\\n # active_users = UserModel._default_manager.filter(**{\\n # '%s__iexact' % UserModel.get_email_field_name(): email,\\n # 'is_active': True,\\n # })\\n return (u for u in active_users if u.has_usable_password())\",\n \"def _users_list(self):\\n result = self.slack.api_call(\\\"users.list\\\", presence=0)\\n\\n if not result.get(\\\"ok\\\"):\\n logging.error(result['error'])\\n return None\\n\\n return result['members']\",\n \"def get_users(email=None, parentemail=None, username=None, include_pw_hash=False):\\n db = api.db.get_conn()\\n\\n match = {}\\n projection = {\\\"_id\\\": 0}\\n if not include_pw_hash:\\n projection[\\\"password_hash\\\"] = 0\\n\\n if email is not None:\\n match.update({\\\"email\\\": re.compile(email, re.IGNORECASE)})\\n elif parentemail is not None:\\n match.update({\\\"demo.parentemail\\\": re.compile(parentemail, re.IGNORECASE)})\\n elif username is not None:\\n match.update({\\\"username\\\": re.compile(username, re.IGNORECASE)})\\n else:\\n raise PicoException(\\\"Could not retrieve user - no argument provided\\\", 400)\\n\\n return list(db.users.find(match, projection).limit(50))\",\n \"def get_users(self, params=None):\\n url = 'users'\\n if params:\\n url += '?%s' % urllib.urlencode(params)\\n resp, body = self.get(url)\\n self.expected_success(200, resp.status)\\n body = json.loads(body)\\n return service_client.ResponseBodyList(resp, body['users'])\",\n \"def get_users():\\n return jsonify([\\n users.to_dict()\\n for users in models.storage.all('User').values()\\n ])\",\n \"def users(self, team, params={}, **options):\\n path = \\\"/teams/%s/users\\\" % (team)\\n return self.client.get_collection(path, params, **options)\",\n \"def get_users():\\n username = request.args.get('username')\\n netAdminToolDB = app.config['DATABASE']\\n if username != None:\\n users = []\\n users.append(netAdminToolDB.get_user_name(username))\\n else:\\n users = netAdminToolDB.get_user()\\n\\n userList = []\\n for user in users:\\n uri = url_for('get_user', user_id=user.id,_external=True)\\n #role = netAdminToolDB.get_role(user.role_id)\\n userList.append({\\n 'id': user.id,\\n 'uri': uri,\\n 'username': user.username,\\n 'display_name': user.display_name,\\n 'role': user.role_name\\n })\\n if userList == []:\\n return jsonify({'error': 'No users found'}), 404\\n\\n return jsonify({'users': userList })\",\n \"def list_users(ctx, project_name):\\n project = ctx.obj.groups.byName[project_name].get().data\\n pprint(ctx.obj.groups[project.id].databaseUsers.get().data)\",\n \"def getInterestedUsers():\",\n \"def slack_users_by_email(self, emails):\\n users = []\\n for user in self.all_slack_users:\\n if user['profile'].get('email') in emails:\\n users.append(user)\\n\\n return users\",\n \"def get_users(self):\\n return self.execute(TABELLE['users']['select']['all'])\",\n \"def list_users(self):\\n return self.get_admin(\\\"users\\\")\",\n \"def get(self):\\n\\n offset = 0\\n limit = Config.get_page_limit()\\n args = request.args\\n try:\\n offset = request.args['offset']\\n except Exception:\\n pass\\n\\n try:\\n limit = request.args['limit']\\n except Exception:\\n pass\\n\\n return self.get_request_handler(request.headers).get_all_users(offset=offset, limit=limit)\",\n \"def list_users(self, startIndex=0, pageSize=10):\\n uURL = self._url + \\\"/users/getUsers\\\"\\n params={\\n \\\"f\\\" : \\\"json\\\",\\n \\\"startIndex\\\" : startIndex,\\n \\\"pageSize\\\" : pageSize\\n }\\n return self._con.post(path=uURL,\\n postdata=params)\",\n \"def get_users():\\n users = User.query.order_by(User.id).all()\\n users = {user.id: user.username for user in users}\\n\\n response = jsonify({\\\"success\\\": True, \\\"users\\\": users})\\n\\n return response\",\n \"def emails(self):\\r\\n url = api_base + 'emails/'\\r\\n return json.loads(self.load_url(url))\",\n \"def get_every_user():\\r\\n connect(\\\"mongodb://vcm-3594.vm.duke.edu:27017/heart_rate_app\\\")\\r\\n user_list = get_all_users()\\r\\n return_dict = {\\r\\n \\\"user_emails\\\": user_list\\r\\n }\\r\\n return jsonify(return_dict),200\",\n \"def _get_users_list(self):\\n return self.users['user_id'].tolist()\",\n \"def check_user_email(self, email):\\n useremails = []\\n for user in self.__users:\\n if user['email'] == email:\\n useremails.append(user)\\n return useremails\",\n \"def listUsers(self):\\n return self._client.listUsers()\",\n \"def getContributors(auth):\\n users = []\\n r = requests.get(url='https://gist.github.com/paulmillr/2657075/',\\n auth=auth)\\n soup = BeautifulSoup(r.text, 'html.parser')\\n users = [tr.select_one('a').text for tr in soup('tbody')[0].select('tr')]\\n return users\",\n \"def users(self):\\n return self.get_data(\\\"users\\\")\",\n \"def get_all_users():\\n users = []\\n for mv in storage.all(\\\"User\\\").values():\\n users.append(mv.to_dict())\\n return jsonify(users)\",\n \"def retrieve_users(payload):\\n selection = User.query.order_by(User.id).all()\\n users = []\\n for item in selection:\\n formatted_user = item.format()\\n users.append(formatted_user)\\n\\n return jsonify({\\n 'success': True,\\n 'total': len(users),\\n 'users': users\\n })\",\n \"def get_user_list(host):\\n users = query(\\\"$.host.'{host}'.user\\\", host=host)\\n if isinstance(users, (str, unicode)):\\n users = users.replace(', ', ' ').replace(',', ' ').split(' ')\\n return users or []\",\n \"def get_users(self) -> List[Dict[str, Any]]:\\n users = self.user_manager.get_users()\\n return [\\n {\\n 'user_id': user.user_id,\\n 'username': user.username,\\n 'created_at': user.created_at.isoformat(),\\n }\\n for user in users\\n ]\",\n \"def users(self, per_page=None, page=None):\\r\\n params = base.get_params(None, locals())\\r\\n url = '{0}/{1}'.format(self.get_url(), 'users')\\r\\n return http.Request('GET', url, params), parsers.parse_json\",\n \"def get_users():\\n selection = []\\n try:\\n selection = [{'id':usr.id, 'username':usr.username, 'email':usr.email} \\n for usr in User.query.all()]\\n except:\\n selection = {'error':True}\\n return json.dumps(selection)\",\n \"def get_user_profiles(self):\\n print 'inside get user profiles'\\n print 'self.username :' + self.username\\n g = GoogleAnalyticsAPI(self.username)\\n if g:\\n print 'GA client exists'\\n user_accounts = g.get_user_accounts()\\n return user_accounts.get('items')\\n else:\\n print 'GA client does not exist'\\n return []\",\n \"def show_users(self):\\n\\n u = User(self.settings)\\n users_list = u.find_users()\\n\\n # transform the results in a \\\"jsonifiable\\\"-form\\n json_results = []\\n for user in users_list:\\n json_results.append(user.to_json())\\n\\n # return\\n return json_results\",\n \"def _load_users(self) -> List[Dict]:\\n try:\\n api_call = self.web_client.api_call('users.list')\\n if api_call.get('ok'):\\n return api_call.get('members')\\n except Exception:\\n LOGGER.exception('Cannot get users')\\n raise\",\n \"def get_slack_users(users=[]):\\n api_call = slack_client.api_call(\\\"users.list\\\")\\n if api_call.get('ok'):\\n # retrieve all users so we can find our bot\\n users = api_call.get('members')\\n return users\",\n \"def getResponsibleUsers():\",\n \"def get_company_users(self, company_referece, active=True):\\n url = 'companies/{0}/users'.format(company_referece)\\n if active:\\n data = {'status_in_company': 'active'}\\n else:\\n data = {'status_in_company': 'inactive'}\\n result = self.get(url, data)\\n return result.get('users', result)\",\n \"def getUsers(self) -> List[bbUser.bbUser]:\\n return list(self.users.values())\",\n \"def task_get_users(task):\\n logger = logging.getLogger(__name__)\\n logger.debug('Get JUNOS users info')\\n result = list()\\n out = task.run(task=netmiko_send_command,\\n command_string=\\\"show configuration system login\\\")\\n if out.failed:\\n for host in out.failed_hosts.keys():\\n logger.warning('Failed task on device {}'.format(task.inventory.hosts[host].name))\\n task.inventory.hosts[host]['error'] = True\\n for host, res in out.items():\\n if not res.failed:\\n logger.debug('Fill JUNOS users properties from device {}'.format(task.inventory.hosts[host].name))\\n task.inventory.hosts[host]['error'] = False\\n# with open('output/junos_show_conf_system_login.txt','w+') as f:\\n# f.write(r.result)\\n result.append(parse_users(host, res.result))\\n return result\",\n \"def get_users(self, headers=None, query_params=None):\\n uri = self.url + \\\"/users\\\"\\n uri = uri + build_query_string(query_params)\\n return requests.get(uri, headers=headers)\",\n \"def list_users():\\n return json_response(\\n status=200,\\n response_data={\\n \\\"success\\\": True,\\n \\\"data\\\": {\\n \\\"users\\\": [user.serialize() for user in User.all()]\\n }\\n }\\n )\",\n \"def getUsersData(self):\\n users_data = self.get_api_results(\\n \\\"/api/user/list?fields=id,username,name,phone,email,url,about,role,joined,lastactive,avatar,company,position,location&api_key={0}&format=json\\\")\\n for user in users_data:\\n if user[\\\"name\\\"] not in self.users:\\n self.add_user(user)\\n else:\\n self.merge_user(user)\\n return users_data\",\n \"def get_users(self, date_start, date_end, project='enwiki'):\\n\\n # @TODO MOVE DB REFS INTO QUERY MODULE\\n\\n params = {\\n 'date_start': format_mediawiki_timestamp(date_start),\\n 'date_end': format_mediawiki_timestamp(date_end),\\n }\\n conn = Connector(instance=settings.PROJECT_DB_MAP[project])\\n query = sub_tokens(self.QUERY_TYPES[self._query_type],\\n db=escape_var(project))\\n conn._cur_.execute(query, params)\\n\\n for row in conn._cur_:\\n yield row[0]\",\n \"def user_list(request_dict):\\n users = User.query.all()\\n users_list = list()\\n for user in users:\\n users_list.append(user)\\n\\n return JSONTools.user_list_reply(users_list)\",\n \"def get_all_users(self) -> tuple:\\n users_list: dict_list_type = [user.to_dict() for user in UserModel.query().fetch()]\\n message: str = 'successfully retrieved active users'\\n return jsonify({'status': True, 'payload': users_list, 'message': message}), 200\",\n \"def get_users(self):\\n query = \\\"\\\"\\\"SELECT firstname,lastname,othernames,email,phonenumber,\\\\\\n username,public_id,isadmin,isactive,registered\\\\\\n from users ORDER BY registered ASC\\\"\\\"\\\"\\n conn = self.db\\n cursor = conn.cursor(cursor_factory=psycopg2.extras.RealDictCursor)\\n cursor.execute(query)\\n rows = cursor.fetchall()\\n return rows\",\n \"def get_users(self, *, Range=None, filter=None, fields=None, **kwargs):\\n headers = kwargs.get('headers', {}).update({'Allow-Hidden': True})\\n function_endpoint = urljoin(self._baseurl, 'users')\\n return self._call('GET', function_endpoint, headers=headers, **kwargs)\",\n \"def get_user_list():\\n response = []\\n for user in mongo.db.users.find():\\n user[\\\"_id\\\"] = str(user[\\\"_id\\\"])\\n response.append(user)\\n return response\",\n \"def get(self):\\n\\n users = [marshal(user, user_fields) for user in models.ExerciseUser.select()]\\n\\n return users\",\n \"def get_user_info_list(self):\\n\\t\\treturn Job(SDK.PrlSrv_GetUserInfoList(self.handle)[0])\",\n \"def emails(self):\\r\\n return UserEmails(self)\",\n \"def get_projects():\\n if current_user.get_id() is None:\\n return\\n with database.engine.begin() as connection:\\n result = connection.execute(select(\\n [models.projects.c.project_id, models.projects.c.name, models.projects.c.path, models.projects.c.creation_date, models.projects.c.user_id, func.count(models.objects.c.object_id).label('object_count')])\\n .select_from(models.projects.outerjoin(models.objects))\\n .where(and_(models.projects.c.active == True, models.projects.c.user_id == current_user.id))\\n .group_by(models.projects.c.project_id)\\n .order_by(models.projects.c.project_id))\\n projects = [dict(row) for row in result]\\n for project in projects:\\n user = models.User.query.filter_by(\\n id=project['user_id']).first()\\n if user:\\n project['email'] = user.email\\n return projects\",\n \"def fusion_api_get_directory_users(self, body, api=None, headers=None):\\n return self.logindomain.users(body, api, headers)\",\n \"async def list_users(self, ctx):\\n \\n path = \\\"Users\\\"\\n headers = {\\n 'accept': 'application/json'\\n }\\n response = send_request(method=\\\"get\\\", path=path, headers=headers)\\n users = []\\n for page in response:\\n users.append(f\\\"**{page['Name']}**: ``{page['Id']}``\\\")\\n log.debug(users)\\n\\n embed = embeds.make_embed(ctx=ctx, title=\\\"List Users\\\", image_url=\\\"https://emby.media/resources/logowhite_1881.png\\\")\\n\\n await LinePaginator.paginate([line for line in users], ctx, embed, restrict_to_user=ctx.author)\",\n \"def _get_userlist_by_userright(self, userright):\\n params = {\\n \\\"action\\\": \\\"query\\\",\\n \\\"list\\\": \\\"allusers\\\",\\n \\\"format\\\": \\\"json\\\",\\n \\\"augroup\\\": userright,\\n \\\"aulimit\\\": \\\"500\\\",\\n }\\n r = self.session.get(ENWIKI_API, params=params)\\n data = r.json()\\n return [u[\\\"name\\\"] for u in data[\\\"query\\\"][\\\"allusers\\\"]]\",\n \"def list_users():\\n\\ttry:\\n\\t\\tusers_call = sc.api_call(\\\"users.list\\\")\\n\\t\\tusers = []\\n\\t\\tif users_call.get('ok'):\\n\\t\\t\\treturn users_call['members']\\n\\texcept:\\n\\t\\tprint(\\\"users error\\\")\\n\\treturn None\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73056626","0.72447586","0.70628095","0.6971299","0.69661814","0.6821465","0.68033063","0.67938226","0.674622","0.6712039","0.67060554","0.6679689","0.66765285","0.66745746","0.66613865","0.6642741","0.6589498","0.65809524","0.65250397","0.6493682","0.6489429","0.6479174","0.64764804","0.6473919","0.6417557","0.6375667","0.6360999","0.63153565","0.6312169","0.6311605","0.63114136","0.6303873","0.63023967","0.628564","0.62832403","0.6277157","0.6274245","0.6260697","0.6253201","0.62500197","0.6246047","0.6237853","0.62301874","0.6226573","0.6226573","0.6226573","0.6226573","0.62229943","0.62138903","0.6202107","0.61997783","0.6196763","0.61931264","0.6177193","0.6170241","0.61686265","0.6131816","0.61302555","0.61211187","0.61202425","0.6113432","0.61124635","0.61103934","0.6105982","0.6103714","0.60813355","0.6078123","0.6073089","0.6066902","0.6049568","0.60494876","0.60403186","0.6035178","0.6032125","0.6028012","0.6026268","0.60258824","0.60220534","0.60128224","0.6001871","0.60010344","0.59967494","0.59965587","0.59939224","0.59910095","0.59897053","0.59779006","0.5960845","0.59586316","0.5957496","0.59453833","0.5933289","0.5930493","0.59247005","0.5920774","0.59149736","0.5911342","0.5910208","0.5907137","0.59020764"],"string":"[\n \"0.73056626\",\n \"0.72447586\",\n \"0.70628095\",\n \"0.6971299\",\n \"0.69661814\",\n \"0.6821465\",\n \"0.68033063\",\n \"0.67938226\",\n \"0.674622\",\n \"0.6712039\",\n \"0.67060554\",\n \"0.6679689\",\n \"0.66765285\",\n \"0.66745746\",\n \"0.66613865\",\n \"0.6642741\",\n \"0.6589498\",\n \"0.65809524\",\n \"0.65250397\",\n \"0.6493682\",\n \"0.6489429\",\n \"0.6479174\",\n \"0.64764804\",\n \"0.6473919\",\n \"0.6417557\",\n \"0.6375667\",\n \"0.6360999\",\n \"0.63153565\",\n \"0.6312169\",\n \"0.6311605\",\n \"0.63114136\",\n \"0.6303873\",\n \"0.63023967\",\n \"0.628564\",\n \"0.62832403\",\n \"0.6277157\",\n \"0.6274245\",\n \"0.6260697\",\n \"0.6253201\",\n \"0.62500197\",\n \"0.6246047\",\n \"0.6237853\",\n \"0.62301874\",\n \"0.6226573\",\n \"0.6226573\",\n \"0.6226573\",\n \"0.6226573\",\n \"0.62229943\",\n \"0.62138903\",\n \"0.6202107\",\n \"0.61997783\",\n \"0.6196763\",\n \"0.61931264\",\n \"0.6177193\",\n \"0.6170241\",\n \"0.61686265\",\n \"0.6131816\",\n \"0.61302555\",\n \"0.61211187\",\n \"0.61202425\",\n \"0.6113432\",\n \"0.61124635\",\n \"0.61103934\",\n \"0.6105982\",\n \"0.6103714\",\n \"0.60813355\",\n \"0.6078123\",\n \"0.6073089\",\n \"0.6066902\",\n \"0.6049568\",\n \"0.60494876\",\n \"0.60403186\",\n \"0.6035178\",\n \"0.6032125\",\n \"0.6028012\",\n \"0.6026268\",\n \"0.60258824\",\n \"0.60220534\",\n \"0.60128224\",\n \"0.6001871\",\n \"0.60010344\",\n \"0.59967494\",\n \"0.59965587\",\n \"0.59939224\",\n \"0.59910095\",\n \"0.59897053\",\n \"0.59779006\",\n \"0.5960845\",\n \"0.59586316\",\n \"0.5957496\",\n \"0.59453833\",\n \"0.5933289\",\n \"0.5930493\",\n \"0.59247005\",\n \"0.5920774\",\n \"0.59149736\",\n \"0.5911342\",\n \"0.5910208\",\n \"0.5907137\",\n \"0.59020764\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.70697045"},"document_rank":{"kind":"string","value":"2"}}},{"rowIdx":21396,"cells":{"query":{"kind":"string","value":"Given an array it splits the array in two parts at index i"},"document":{"kind":"string","value":"def split_i(array:list, i:int) -> (list, list):\n if i==len(array)-1:\n return array[i], array[:-1]\n else:\n pre = array[0:i]\n post = array[i+1:]\n l = pre + post\n x = array[i]\n return x, l"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def split_array(a):\n n = len(a)\n if n == 1:\n return a\n index = n // 2\n b = a[:index]\n c = a[index:]\n return b, c","def even_split(a, n):\n n = min(n, len(a)) # if less elements in array than chunks to output, change chunks to array length\n k, m = divmod(len(a), n)\n return (a[i * k + min(i, m):(i + 1) * k + min(i + 1, m)] for i in range(n))","def split(a):\n return a[:len(a)//2],a[len(a)//2:]","def test_integer_split_2D_default(self):\n a = array([arange(10),arange(10)])\n res = array_split(a,3)\n desired = [array([arange(10)]),array([arange(10)]),array([])]\n compare_results(res,desired)","def Split(ar, size):\r\n return [ar[i:i + size] for i in range(0, len(ar), size)]","def split_array(array, size):\n arrays = []\n while len(array) > size:\n pice = array[:size]\n arrays.append(pice)\n array = array[size:]\n arrays.append(array)\n return arrays","def split(array, indexes):\n if isinstance(indexes, int):\n return list(array[0:indexes], array[indexes:])\n\n newarray = []\n offset = 0\n for idx in indexes:\n newarray.append(array[offset:idx])\n offset += idx\n if indexes[-1] < len(array):\n newarray.append(array[indexes[-1]:])\n return newarray","def split(a, n):\n n = min(n, len(a))\n k, m = divmod(len(a), n)\n return [a[i * k + min(i, m) : (i + 1) * k + min(i + 1, m)] for i in range(n)]","def split(array, nrows, ncols):\r\n r, h = array.shape\r\n return (array.reshape(h//nrows, nrows, -1, ncols)\r\n .swapaxes(1, 2)\r\n .reshape(-1, nrows, ncols))","def spliter(temp,split1,split2):\n for x in range(len(temp)):\n if x<len(temp)/2:\n split1.append(temp[x])\n else:\n split2.append(temp[x])","def split(a, n):\n k, m = divmod(len(a), n)\n ret = [a[i*k+min(i, m):(i+1)*k+min(i+1, m)] for i in range(n)]\n return ret","def split(f):\n n = len(f)\n f0 = [f[2 * i + 0] for i in range(n // 2)]\n f1 = [f[2 * i + 1] for i in range(n // 2)]\n return [f0, f1]","def split_array(arr, num_of_splits):\n # TODO Replace this function with gluon.utils.split_data() once targeting MXNet 1.7\n size = arr.shape[0]\n if size < num_of_splits:\n return [arr[i:i + 1] for i in range(size)]\n slice_len, rest = divmod(size, num_of_splits)\n div_points = [0] + [(slice_len * index + min(index, rest) + slice_len + (index < rest))\n for index in range(num_of_splits)]\n slices = [arr[div_points[i]:div_points[i + 1]] for i in range(num_of_splits)]\n return slices","def ArraySplit(array_to_split, bucket_size):\n return [array_to_split[i:i+bucket_size]\n for i in xrange(0, len(array_to_split), bucket_size)]","def greedy_split(arr, n, axis=0):\n length = arr.shape[axis]\n # compute the size of each of the first n-1 blocks\n block_size = int(np.ceil(length / float(n)))\n # the indices at which the splits will occur\n ix = np.arange(block_size, length, block_size)\n return np.array(np.split(arr, ix, axis))","def split(self, array):\n q, r = divmod(self.num_envs, self.num_workers)\n return [\n array[i * q + min(i, r) : (i + 1) * q + min(i + 1, r)]\n for i in range(self.num_workers)\n ]","def split(a):\r\n if len(a) % 2 != 0 or len(a[0]) % 2 != 0:\r\n raise Exception('Odd matrices are not supported!')\r\n \r\n length = len(a)\r\n mid = length // 2\r\n tLeft = [[a[i][j] for j in range(mid)] for i in range(mid)]\r\n bottom_left = [[a[i][j] for j in range(mid)] for i in range(mid, length)]\r\n\r\n tRight = [[a[i][j] for j in range(mid, length)] for i in range(mid)]\r\n bottom_right = [[a[i][j] for j in range(mid, length)] for i in range(mid, length)]\r\n\r\n return tLeft, tRight, bottom_left, bottom_right","def split(data):\n return data[:len(data) // 2], data[len(data) // 2:]","def test_integer_split_2D_default(self):\n a = np.array([np.arange(10), np.arange(10)])\n res = array_split(a, 3)\n tgt = [np.array([np.arange(10)]), np.array([np.arange(10)]),\n np.zeros((0, 10))]\n compare_results(res, tgt)\n assert_(a.dtype.type is res[-1].dtype.type)\n # perhaps should check higher dimensions","def split(data):\n data = sorted(data, key=lambda x: x[0])\n half = len(data)//2\n return (data[half][0]+data[half + 1][0])/2\n print(data)","def split(container, count):\n return [container[_i::count] for _i in range(count)]","def split(a, N):\n\n integ = int(len(a) / N)\n remain = int(len(a) % N)\n\n splitted = [a[i * integ + min(i, remain):(i + 1) * integ +\n min(i + 1, remain)] for i in range(N)]\n\n return splitted","def split(list):\n mid = len(list)//2\n left = list[:mid]\n right= list[mid:]\n\n return left,right","def partition(array, first, last):\n # partition up until final value\n pivot = array[last]\n i = first - 1\n\n for count in range(first, last):\n # split array\n if array[count] < pivot:\n i += 1\n # assign array positions\n array[i],array[count] = array[count],array[i]\n # reassign\n array[i+1],array[last] = array[last],array[i+1]\n return (i+1)","def split(list):\r\n \r\n mid = len(list)//2\r\n left = list[:mid]\r\n right = list[mid:]\r\n \r\n return left, right","def split(base_list):\n list_mid_pointer=len(base_list)//2\n return base_list[:list_mid_pointer],base_list[list_mid_pointer:]","def split(self, X):","def split_list(a_list):\n half = len(a_list)/2\n return a_list[:half], a_list[half:]","def split_array(array: np.ndarray, parts: int):\n\n if parts == -1:\n parts = array.size\n shape = array.shape\n possible_chunk_sizes = []\n # Generate all possible chunk sizes for the given array shape\n for chunk_size in product(*[range(1, shape[i] + 1) for i in range(len(shape))]):\n # Check if the number of chunks generated by the current chunk size is equal to the desired number of parts\n if np.prod(\n [shape[i] // chunk_size[i] + int(shape[i] % chunk_size[i] != 0) for i in range(len(shape))]) == parts:\n possible_chunk_sizes.append(chunk_size)\n # Sort the possible chunk sizes in ascending order of the sum of the squares of their dimensions\n possible_chunk_sizes.sort(key=lambda x: np.sum(np.array(x) ** 2)) # type: ignore\n if not possible_chunk_sizes:\n logging.warning(\"Could not divide the domain in %d parts. Trying with parts=%d.\", parts, parts - 1)\n return split_array(array=array, parts=parts - 1)\n selected_chunk_size = possible_chunk_sizes[0]\n\n chunks = []\n # Get the number of chunks for the first possible chunk size\n num_chunks = [shape[i] // selected_chunk_size[i] + int(shape[i] % selected_chunk_size[i] != 0) for i in\n range(len(shape))]\n indexes = [range(num_chunks[i]) for i in range(len(shape))]\n # Iterate over the chunks and append the corresponding slice of the array to the chunks list\n for indx in product(*indexes):\n current_slice = tuple(\n slice(selected_chunk_size[i] * indx[i], min(selected_chunk_size[i] * (indx[i] + 1), shape[i])) for i in\n range(len(shape)))\n chunks.append(array[current_slice])\n return chunks","def split(list):\n\n\tmid = len(list) // 2\n\tleft = list[:mid]\n\tright = list[mid:]\n\n\treturn left, right","def splitList(arr, size):\n arrs = []\n while len(arr) > size:\n pice = arr[:size]\n arrs.append(pice)\n arr = arr[size:]\n arrs.append(arr)\n return arrs","def split_array(array, max_len=2000):\n new_array_lst = []\n for x in range(0, len(array), max_len):\n split = array[x: x + max_len]\n if len(split) >= max_len:\n new_array_lst.append(split)\n\n return new_array_lst","def splits_array_switcher(trajectory1, trajectory2, index_of_cut):\r\n\r\n trajectory1_a, trajectory2_b = trajectory1[:index_of_cut], trajectory1[index_of_cut:]\r\n trajectory2_a, trajectory1_b = trajectory2[:index_of_cut], trajectory2[index_of_cut:]\r\n\r\n trajectory1 = np.concatenate((trajectory1_a, trajectory1_b), axis=0)\r\n trajectory2 = np.concatenate((trajectory2_a, trajectory2_b), axis=0)\r\n\r\n return trajectory1, trajectory2","def splice(i, j, data):\n n = len(data)\n out = ()\n splice_a = []\n splice_b = []\n i = idx(i, n)\n j = idx(j, n)\n i+=1\n j+=1\n if(i < j):\n splice_a = data[i:j]\n splice_b = data[j:] + data[0:i]\n else:\n splice_a = data[i:] + data[0:j]\n splice_b = data[j:i]\n\n return (splice_a, splice_b)","async def split_list(arr, size=100):\n\n arrs = []\n\n while len(arr) > size:\n pice = arr[:size]\n arrs.append(pice)\n arr = arr[size:]\n\n arrs.append(arr)\n return arrs","def _get_indices_split ( indices, number_of_folds ):\n # Split the indicies by the number of folds\n return np.array_split ( indices, indices_or_sections = number_of_folds )\n # End get_indices_split()","def _get_indices_split ( indices, number_of_folds ):\n # Split the indicies by the number of folds\n return np.array_split ( indices, indices_or_sections = number_of_folds )\n # End get_indices_split()","def split_data(data, squeeze=False):\n vdata = np.atleast_2d(data)\n nr_freqs = int(vdata.shape[1] / 2)\n part1 = vdata[:, 0:nr_freqs]\n part2 = vdata[:, nr_freqs:]\n if(squeeze):\n part1 = part1.squeeze()\n part2 = part2.squeeze()\n return part1, part2","def splitList(l, i1, i2):\n n = len(l)\n L1 = []\n L2 = []\n j = 0\n # Creating list 1\n while (i1 + j) % n != i2:\n L1.append(l[(i1 + j) % n])\n j += 1\n L1.append(l[i2])\n # Creating list 2\n j = 0\n while (i2 + j) % n != i1:\n L2.append(l[(i2 + j) % n])\n j += 1\n L2.append(l[i1])\n return (L1, L2)","def split(ba):\n l = []\n for i in range(len(ba)/9):\n l.append(ba[i*9:(i+1)*9])\n\n return l","def split_image(img):\n xs = [] # positions\n ys = [] # colors\n for row_i in range(img.shape[0]):\n for col_i in range(img.shape[1]):\n xs.append([row_i, col_i])\n ys.append(img[row_i, col_i])\n \n xs = np.array(xs)\n ys = np.array(ys)\n return xs, ys","def split_image(img):\n xs = [] # positions\n ys = [] # colors\n for row_i in range(img.shape[0]):\n for col_i in range(img.shape[1]):\n xs.append([row_i, col_i])\n ys.append(img[row_i, col_i])\n \n xs = np.array(xs)\n ys = np.array(ys)\n return xs, ys","def segment_array(array=[],N=0,value=0):\n \n array = np.concatenate([array,np.ones(N-len(array)%N)*value])\n \n return array.reshape((-1,N))","def split_half(slice):\n slice = set_date(slice)\n slice['Date'] = pd.to_datetime(slice['Date'])\n col_names = ['Date', 'Label', 'Text Extract', 'Processed']\n slice = slice[col_names]\n max_date = slice['Date'].max()\n min_date = slice['Date'].min()\n split_day = min_date + (max_date-min_date) // 2\n slice_b = slice[slice['Date'] > split_day]\n slice = slice[slice['Date'] <= split_day]\n return slice, slice_b","def segmentArray(array, pos = 0):\n\t\n#\tfrom jot.basic.countDistinctValues import countDistinctValues\n\t\n\tfinalarray = []\n\tprovarray = list(countDistinctValues(array, pos).keys())\n\t\n\tfor i in provarray:\n\t\n\t\ttemparray = []\n\t\t\n\t\tfor j in array:\n\t\t\n\t\t\tif i == j[0]:\n\t\t\t\ttemparray.append(j[1:])\n\t\t\t\t\n\t\tfinalarray.append(temparray)\n\t\t\n\treturn finalarray","def partition(data, indecies):\n\tsplitdata = [data[:indecies[0]]]\n\tsplitdata += [data[indecies[i-1]:indecies[i]] for i in range(1,len(indecies))]\n\tsplitdata.append(data[indecies[-1]:])\n\treturn splitdata","def sort_and_distribute(array, splits=2):\n if not isinstance(array, (list,tuple)): raise TypeError(\"array must be a list\")\n if not isinstance(splits, int): raise TypeError(\"splits must be an integer\")\n remaining = sorted(array)\n if sys.version_info < (3, 0):\n myrange = xrange(splits)\n else:\n myrange = range(splits)\n groups = [[] for i in myrange]\n while len(remaining) > 0:\n for i in myrange:\n if len(remaining) > 0: groups[i].append(remaining.pop(0))\n return groups","def chunks(array, size: int):\r\n for i in range(0, len(array), size):\r\n yield array[i:i + size]","def img_split(img):\n\tbands = img.shape[2]\n\tif bands is 1:\n\t\treturn \"Image already is 1D. Why would you split it?\"\n\n\tband1 = img[:, :, 0]\n\tband2 = img[:, :, 1]\n\tband3 = img[:, :, 2]\n\tif bands is 4:\n\t\tband4 = img[:, :, 4]\n\t\treturn(band1, band2, band3, band4)\n\treturn(band1, band2, band3)","def partition_files(list_of_files, number_of_parts):\n return np.array_split(list_of_files, number_of_parts)","def split_list(input_list):\n if len(input_list) % 2 == 0:\n half = len(input_list) // 2\n return input_list[:half], input_list[half:]\n else:\n raise NotImplementedError(\"split_list requires a list of even length\")","def get_splits(ntot, nper):\n beglist = numpy.arange(0,ntot,nper)\n endlist = numpy.arange(0,ntot,nper) + nper - 1\n\n if (ntot % nper) != 0:\n endlist[-1] = ntot-1\n return beglist, endlist","def split_image(image_name):\n #pil_image = Image.fromarray(image_name)\n red, green, blue = img.split()\n\n return red, green, blue","def img_to_slices(img):\n res = []\n\n for i, slice_img in enumerate(img):\n res.append(slice_img)\n return res","def trajectory_splitter(trajectory, split_start, split_length):\r\n mask_array = np.zeros(np.shape(trajectory), dtype=bool)\r\n # print(np.shape(mask_array))\r\n mask_array[:, split_start:split_start+split_length] = 1\r\n # print(np.ma.masked_array(trajectory, mask=mask_array))\r\n return trajectory[:, :split_start],trajectory[:, split_start+split_length:], np.ma.masked_array(trajectory, mask=mask_array)","def split(mylist,size):\r\n\r\n split_list = []\r\n\r\n for index,num in enumerate(mylist):\r\n if index + size <= len(mylist):#checks so we don't go out of list range\r\n position = mylist.index(num,index)\r\n split_list.append(mylist[position:position+size])\r\n return split_list","def alternate_iter(array):\n result = []\n array = sorted(array)\n for n in range(len(array)):\n if n >= len(array):\n break\n result.append(array.pop())\n try:\n result.append(array[n])\n except IndexError:\n break\n\n return result","def partition(self, sep):\n return asarray(partition(self, sep))","def _splitPoints(self, points, split):\n # validate split\n if not split:\n return [points]\n\n # complete split with adding start and end frames\n if split[0] != 0:\n split.insert(0, 0)\n\n if split[-1] != len(points):\n split.append(len(points))\n\n # make sure split is sorted and doesn't contain any duplicates\n split = list(set(split))\n split.sort()\n\n # split range for looping\n splitA = split[:-1]\n splitB = split[1:]\n\n # get lists\n return [points[a:b + 1] for a, b in zip(splitA, splitB)]","def subimage(image_as_array, step):\r\n\tsubimage_2d_array = image_as_array[200-int(step):200+int(step)]\r\n\treturn subimage_2d_array","def split(a, sep=None, maxsplit=None):\n # This will return an array of lists of different sizes, so we\n # leave it as an object array\n return _vec_string(\n a, object_, 'split', [sep] + _clean_args(maxsplit))","def _segments2slices(array_size, grid_segments, patch_segments):\n patch_slices = [slice(start, stop) for start, stop in patch_segments]\n array_slices = []\n\n for start, stop in grid_segments:\n segment_size = max(abs(start), abs(stop))\n k = int(ceil(float(segment_size) / array_size) + (-1 if start >= 0 else 0))\n cell_mirrored = k % 2\n \n step = 1\n if start < 0:\n start = k * array_size + start\n stop = k * array_size + stop\n else:\n start = start - k * array_size\n stop = stop - k * array_size\n\n if cell_mirrored:\n start = array_size - start - 1\n stop = array_size - stop - 1\n step = -1\n\n if stop < 0:\n stop = None\n\n array_slices.append(slice(start, stop, step))\n \n return array_slices, patch_slices","def split_seq(seq, size):\n return [seq[ii:ii + size] for ii in range(0, len(seq), size)]","def chunks(arr, n):\n for i in range(0, len(arr), n):\n yield arr[i:i + n]","def split_bits_bit_array(x, bit_array):\n\n mask = bit_array - 1\n\n lower = x & mask\n upper = x & ~mask\n\n return lower, upper","def chunks(arr, n):\n for i in range(0, len(arr), n):\n yield arr[i:i + n]","def b(i,new_arr,arr):\n new_arr = tf.concat([new_arr,arr[:, i:last_step + i:stride, :]], axis=2)\n return i+1,new_arr,arr","def split_at(words, verb):\n if verb in words:\n i = words.index(verb)\n first_half = words[0:i]\n second_half = words[i+1:]\n return [first_half, second_half]\n else:\n return -1","def buildSegments(array, segLength: int):\n s = math.floor(len(array)/segLength)\n segments = []\n for i in range(s+1):\n segments.append(array[i*segLength:(i+1)*segLength])\n return np.array(segments)","def partition(a, sep):\n return _to_bytes_or_str_array(\n _vec_string(a, object_, 'partition', (sep,)), a)","def split_half(str):\n split_pairs = str[:len(str)//2], str[len(str)//2:]\n return split_pairs","def divide_with_stride(arr: np.ndarray) -> List[np.ndarray]:\n\n result_list: List[np.ndarray] = []\n # slice by z axis\n for z in range(0, z_len := arr.shape[0], 16):\n if z + 31 >= z_len:\n z = z_len - 16\n z_arr: np.ndarray = arr[z:z+16]\n\n # slice by y axis\n for y in range(0, y_len := arr.shape[1], 16):\n y_arr: np.ndarray = z_arr[:, y:y+16]\n\n # slice by x axis\n for x in range(0, x_len := arr.shape[2], 16):\n x_arr: np.ndarray = y_arr[:, :, x:x+16]\n if len(set(x_arr.shape)) == 1 and x_arr.shape[0] == 16:\n result_list.append(x_arr)\n \n return result_list","def split_by_size(array: Iterable[T], size: int) -> Iterable[List[T]]:\n chunk = []\n for e in array:\n chunk.append(e)\n if len(chunk) == size:\n yield chunk\n chunk = []\n if len(chunk) > 0:\n yield chunk","def split(a):\r\n compos = [-1] # compos stores the positions of the relevant commas in the argument string\r\n compos.extend(t[2][1] for t in generate_tokens(StringIO(a).readline) if t[1] == ',')\r\n compos.append(len(a))\r\n return [ a[compos[i]+1:compos[i+1]] for i in xrange(len(compos)-1)]","def partition(alist, indices):\n return [alist[i:j] for i, j in zip([0]+indices, indices+[None])]","def segment_array(a):\n\n l = [array(a.typecode) for chaff in range(16)]\n index = 0\n\n for i in range(0, len(a), 16):\n l[index].extend(a[i:i + 16])\n index = (index + 1) % 16\n\n return l","def num_43():\n \n def block(a, r=3, cs=3, row_order=True):\n \"\"\"Block slice an array using a window of (rs, cs) size\n \"\"\"\n lenr = a.shape[0]//rs\n lenc = a.shape[1]//cs\n if row_order:\n iter = [(i, j) for (i, j) in np.ndindex(lenr, lenc)]\n else:\n iter = [(j, i) for (i, j) in np.ndindex(lenr, lenc)]\n b = np.array([a[i*rs:(i+1)*rs, j*cs:(j+1)*cs] for (i,j) in iter])\n #b = np.array([a[i*rs:(i+1)*rs, j*cs:(j+1)*cs] \n # for (i, j) in np.ndindex(lenr, lenc)])\n return b\n r = 6\n c = 6\n a = np.arange(r*c).reshape(r, c)\n vs = np.array(np.vsplit(a, 2))\n hs = np.array(np.hsplit(a, 2))\n #a.squeeze(axis=(2,3))\n rs = 3\n cs = 4\n #lenr = a.shape[0]//rs\n #lenc = a.shape[1]//cs\n #b = np.array([a[i*rs:(i+1)*rs, j*cs:(j+1)*cs] \n # for (i, j) in np.ndindex(lenr, lenc)])\n #b1 = np.array([a[i*rs:(i+1)*rs, j*cs:(j+1)*cs] \n # for (j, i) in np.ndindex(lenr, lenc)])\n e = block(a, 3, 4, row_first=False)\n b = block(a, rs, cs, True)\n b1 = block(a, rs, cs, False)\n c = np.array([np.vsplit(i, 2) for i in np.hsplit(a, 2)])\n d = np.array([np.hsplit(i, 2) for i in np.vsplit(a, 2)])\n #c = c.reshape(lenr*lenc, rs, cs) \n return a, b, b1, c, d, e","def split(it, sz):\n\n out = []\n last = 0.0\n\n while last < len(it):\n out.append(it[int(last):int(last + sz)])\n last += sz\n\n return out","def iterate_array_in_chunks(arr, size: int):\n for i in range(0, len(arr), size):\n yield arr[i:i+size]","def sliceshape(slicetuple, totshape):\n res = []\n for i,s in enumerate(slicetuple):\n if isinstance(s,int):\n #n = 1\n pass\n else:\n i0,i1,istep = s.indices(totshape[i])\n n = (i1-i0)//istep\n res.append(n)\n return res","def split_cond(f, iterable):\n split_point = [i for i, e in enumerate(iterable) if f(e)]\n split_point += [len(iterable)]\n return [iterable[i:j] for i, j in zip(split_point[:-1], split_point[1:])]","def split_seq(seq,size):\n return [seq[i:i+size] for i in range(0, len(seq), size)]","def divide_array(arr, n):\r\n if n <= 0:\r\n raise ValueError(\"Number of elements value must be greater than 0\")\r\n\r\n if len(arr) % n > 0:\r\n output_size = len(arr) // n + 1 # python 3 integer division\r\n last_output_size = output_size - (len(arr) % n)\r\n else:\r\n output_size = len(arr) // n\r\n last_output_size = output_size\r\n\r\n output_arr = []\r\n slice_start = 0\r\n slice_end = output_size\r\n i = 0\r\n\r\n while i < n:\r\n if i < (n - 1):\r\n output_item = arr[slice_start : slice_end]\r\n output_arr.append(output_item)\r\n slice_start += output_size\r\n slice_end += output_size\r\n else:\r\n slice_end = slice_start + last_output_size\r\n output_item = arr[slice_start : slice_end]\r\n output_arr.append(output_item)\r\n i += 1\r\n\r\n return output_arr","def mid(arr):\n\n \n arr_ln = len(arr)\n mid = arr_ln//2\n val = arr.pop(mid)\n\n return arr, val","def split_sequence(sequence, input_dim, output_dim, first_demand_column=0):\r\n x, y = list(), list()\r\n for i in range(input_dim,len(sequence),1):\r\n \"\"\" gather input and output parts of the pattern \"\"\"\r\n seq_x, seq_y = sequence[i-input_dim:i], sequence[i:i+output_dim,first_demand_column:]\r\n if len(seq_y) < output_dim:\r\n break\r\n x.append(seq_x)\r\n y.append(seq_y)\r\n \r\n return np.array(x), np.array(y)","def slices_using_group_array(group_array):\n unique_elements = np.unique(group_array)\n slices = []\n for unique_element in unique_elements:\n indexes = np.flatnonzero(group_array == unique_element)\n low, high = (indexes[0], indexes[-1] + 1)\n slices.append((unique_element, slice(low, high)))\n return slices","def splitH_unlifted(pixmap):\n h = pixmap.shape[0]\n if h % 2 == 1:\n h = h // 2\n return [pixmap[:h,:], pixmap[h+1:,:]]\n else:\n h = h // 2\n return [pixmap[:h,:], pixmap[h:,:]]","def split_validation_data(*data, divmod=0.5):\n n = round((len(data[0]) - 1) * divmod)\n return [(d[n:], d[:n]) for d in data]","def class_split(x):\r\n return np.split(x, [19,43])","def separa(matrix):\r\n linha, coluna = matrix.shape\r\n linha2, coluna2 = linha//2, coluna//2\r\n return matrix[:linha2, :coluna2], matrix[:linha2, coluna2:], matrix[linha2:, :coluna2], matrix[linha2:, coluna2:]","def split_into_subarrays_of_max_len(arr, max_len=44100):\n return np.split(arr, np.arange(max_len, len(arr), max_len))","def unstacked_index(size, index):\n return index % size, index // size","def split_range(r, n):\n \n step = int(r / n)\n segments = []\n for i in range(n):\n new_segment = [step * i, step * (i + 1)]\n segments.append(new_segment)\n # correct the gap in the missing index due to the truncated step\n segments[-1][-1] = r\n return segments","def splitregions(region_array, window_len, stride):\n region_output = np.empty((0,3), dtype=np.int)\n for region in region_array:\n strand, left, right = region\n region_length = right - left + 1\n if region_length >= window_len:\n new_lefts, new_rights = _splitregion(region_length, window_len, stride)\n new_regions = np.asarray([np.zeros(len(new_lefts))+strand, new_lefts+left, new_rights+left], dtype=np.uint32).T\n region_output = np.r_[region_output, new_regions]\n return region_output","def lap_split_n(img, n):\n levels = []\n\n print(\"inside lap_split_n function \")\n\n for i in range(n):\n img, hi = lap_split(img)\n levels.append(hi)\n levels.append(img)\n return levels[::-1]","def listsplit(value, arg):\n\n print \"listsplit:{0}\".format(arg)\n args = arg.split(\",\")\n if not len(args) == 2:\n return value\n\n i = int(args[0])\n n = int(args[1])\n\n m = len(value)\n\n base = m // n\n rem = m % n\n\n sizes = [base + 1] * rem + [base] * (n - rem)\n\n start = sum(sizes[0:i])\n end = start + sizes[i]\n\n return value[start:end]","def split_segments_vertically(segments, img_shape):\n left, right = [], []\n split = img_shape[1] // 2\n for (p1, p2) in segments:\n if p1[0] < split and p2[0] < split:\n left.append((p1, p2))\n elif p1[0] > split and p1[0] > split:\n right.append((p1, p2))\n\n return left, right","def _partition(array, order, pivot, lower, upper):\n # The pivot element is made the last not to interfere with other swaping \n # operations\n array[pivot], array[upper] = array[upper], array[pivot]\n\n # Last index of smaller/greater (asc/desc) elements\n idx = lower\n\n for j in range(lower, upper):\n if (order == Order.ASC and array[j] < array[upper] or # ASCENDING\n order == Order.DESC and array[j] > array[upper]): # DESCENDING\n # Moves the current element at the end of the sub-array with\n # the smaller/grater (asc/desc) elements\n array[idx], array[j] = array[j], array[idx]\n idx += 1\n\n # Moves pivot as separator between greater and smaller numbers\n array[idx], array[upper] = array[upper], array[idx]\n\n return idx","def smart_split(strokes):\n\n splited = []\n for stroke in strokes:\n splited += stroke.split_non_differentiable_points()\n return splited","def seperate_list(list, division_part):\n avg = len(list) / float(division_part)\n out = []\n last = 0.0\n\n while last < len(list):\n out.append(list[int(last):int(last + avg)])\n last += avg\n return out"],"string":"[\n \"def split_array(a):\\n n = len(a)\\n if n == 1:\\n return a\\n index = n // 2\\n b = a[:index]\\n c = a[index:]\\n return b, c\",\n \"def even_split(a, n):\\n n = min(n, len(a)) # if less elements in array than chunks to output, change chunks to array length\\n k, m = divmod(len(a), n)\\n return (a[i * k + min(i, m):(i + 1) * k + min(i + 1, m)] for i in range(n))\",\n \"def split(a):\\n return a[:len(a)//2],a[len(a)//2:]\",\n \"def test_integer_split_2D_default(self):\\n a = array([arange(10),arange(10)])\\n res = array_split(a,3)\\n desired = [array([arange(10)]),array([arange(10)]),array([])]\\n compare_results(res,desired)\",\n \"def Split(ar, size):\\r\\n return [ar[i:i + size] for i in range(0, len(ar), size)]\",\n \"def split_array(array, size):\\n arrays = []\\n while len(array) > size:\\n pice = array[:size]\\n arrays.append(pice)\\n array = array[size:]\\n arrays.append(array)\\n return arrays\",\n \"def split(array, indexes):\\n if isinstance(indexes, int):\\n return list(array[0:indexes], array[indexes:])\\n\\n newarray = []\\n offset = 0\\n for idx in indexes:\\n newarray.append(array[offset:idx])\\n offset += idx\\n if indexes[-1] < len(array):\\n newarray.append(array[indexes[-1]:])\\n return newarray\",\n \"def split(a, n):\\n n = min(n, len(a))\\n k, m = divmod(len(a), n)\\n return [a[i * k + min(i, m) : (i + 1) * k + min(i + 1, m)] for i in range(n)]\",\n \"def split(array, nrows, ncols):\\r\\n r, h = array.shape\\r\\n return (array.reshape(h//nrows, nrows, -1, ncols)\\r\\n .swapaxes(1, 2)\\r\\n .reshape(-1, nrows, ncols))\",\n \"def spliter(temp,split1,split2):\\n for x in range(len(temp)):\\n if x<len(temp)/2:\\n split1.append(temp[x])\\n else:\\n split2.append(temp[x])\",\n \"def split(a, n):\\n k, m = divmod(len(a), n)\\n ret = [a[i*k+min(i, m):(i+1)*k+min(i+1, m)] for i in range(n)]\\n return ret\",\n \"def split(f):\\n n = len(f)\\n f0 = [f[2 * i + 0] for i in range(n // 2)]\\n f1 = [f[2 * i + 1] for i in range(n // 2)]\\n return [f0, f1]\",\n \"def split_array(arr, num_of_splits):\\n # TODO Replace this function with gluon.utils.split_data() once targeting MXNet 1.7\\n size = arr.shape[0]\\n if size < num_of_splits:\\n return [arr[i:i + 1] for i in range(size)]\\n slice_len, rest = divmod(size, num_of_splits)\\n div_points = [0] + [(slice_len * index + min(index, rest) + slice_len + (index < rest))\\n for index in range(num_of_splits)]\\n slices = [arr[div_points[i]:div_points[i + 1]] for i in range(num_of_splits)]\\n return slices\",\n \"def ArraySplit(array_to_split, bucket_size):\\n return [array_to_split[i:i+bucket_size]\\n for i in xrange(0, len(array_to_split), bucket_size)]\",\n \"def greedy_split(arr, n, axis=0):\\n length = arr.shape[axis]\\n # compute the size of each of the first n-1 blocks\\n block_size = int(np.ceil(length / float(n)))\\n # the indices at which the splits will occur\\n ix = np.arange(block_size, length, block_size)\\n return np.array(np.split(arr, ix, axis))\",\n \"def split(self, array):\\n q, r = divmod(self.num_envs, self.num_workers)\\n return [\\n array[i * q + min(i, r) : (i + 1) * q + min(i + 1, r)]\\n for i in range(self.num_workers)\\n ]\",\n \"def split(a):\\r\\n if len(a) % 2 != 0 or len(a[0]) % 2 != 0:\\r\\n raise Exception('Odd matrices are not supported!')\\r\\n \\r\\n length = len(a)\\r\\n mid = length // 2\\r\\n tLeft = [[a[i][j] for j in range(mid)] for i in range(mid)]\\r\\n bottom_left = [[a[i][j] for j in range(mid)] for i in range(mid, length)]\\r\\n\\r\\n tRight = [[a[i][j] for j in range(mid, length)] for i in range(mid)]\\r\\n bottom_right = [[a[i][j] for j in range(mid, length)] for i in range(mid, length)]\\r\\n\\r\\n return tLeft, tRight, bottom_left, bottom_right\",\n \"def split(data):\\n return data[:len(data) // 2], data[len(data) // 2:]\",\n \"def test_integer_split_2D_default(self):\\n a = np.array([np.arange(10), np.arange(10)])\\n res = array_split(a, 3)\\n tgt = [np.array([np.arange(10)]), np.array([np.arange(10)]),\\n np.zeros((0, 10))]\\n compare_results(res, tgt)\\n assert_(a.dtype.type is res[-1].dtype.type)\\n # perhaps should check higher dimensions\",\n \"def split(data):\\n data = sorted(data, key=lambda x: x[0])\\n half = len(data)//2\\n return (data[half][0]+data[half + 1][0])/2\\n print(data)\",\n \"def split(container, count):\\n return [container[_i::count] for _i in range(count)]\",\n \"def split(a, N):\\n\\n integ = int(len(a) / N)\\n remain = int(len(a) % N)\\n\\n splitted = [a[i * integ + min(i, remain):(i + 1) * integ +\\n min(i + 1, remain)] for i in range(N)]\\n\\n return splitted\",\n \"def split(list):\\n mid = len(list)//2\\n left = list[:mid]\\n right= list[mid:]\\n\\n return left,right\",\n \"def partition(array, first, last):\\n # partition up until final value\\n pivot = array[last]\\n i = first - 1\\n\\n for count in range(first, last):\\n # split array\\n if array[count] < pivot:\\n i += 1\\n # assign array positions\\n array[i],array[count] = array[count],array[i]\\n # reassign\\n array[i+1],array[last] = array[last],array[i+1]\\n return (i+1)\",\n \"def split(list):\\r\\n \\r\\n mid = len(list)//2\\r\\n left = list[:mid]\\r\\n right = list[mid:]\\r\\n \\r\\n return left, right\",\n \"def split(base_list):\\n list_mid_pointer=len(base_list)//2\\n return base_list[:list_mid_pointer],base_list[list_mid_pointer:]\",\n \"def split(self, X):\",\n \"def split_list(a_list):\\n half = len(a_list)/2\\n return a_list[:half], a_list[half:]\",\n \"def split_array(array: np.ndarray, parts: int):\\n\\n if parts == -1:\\n parts = array.size\\n shape = array.shape\\n possible_chunk_sizes = []\\n # Generate all possible chunk sizes for the given array shape\\n for chunk_size in product(*[range(1, shape[i] + 1) for i in range(len(shape))]):\\n # Check if the number of chunks generated by the current chunk size is equal to the desired number of parts\\n if np.prod(\\n [shape[i] // chunk_size[i] + int(shape[i] % chunk_size[i] != 0) for i in range(len(shape))]) == parts:\\n possible_chunk_sizes.append(chunk_size)\\n # Sort the possible chunk sizes in ascending order of the sum of the squares of their dimensions\\n possible_chunk_sizes.sort(key=lambda x: np.sum(np.array(x) ** 2)) # type: ignore\\n if not possible_chunk_sizes:\\n logging.warning(\\\"Could not divide the domain in %d parts. Trying with parts=%d.\\\", parts, parts - 1)\\n return split_array(array=array, parts=parts - 1)\\n selected_chunk_size = possible_chunk_sizes[0]\\n\\n chunks = []\\n # Get the number of chunks for the first possible chunk size\\n num_chunks = [shape[i] // selected_chunk_size[i] + int(shape[i] % selected_chunk_size[i] != 0) for i in\\n range(len(shape))]\\n indexes = [range(num_chunks[i]) for i in range(len(shape))]\\n # Iterate over the chunks and append the corresponding slice of the array to the chunks list\\n for indx in product(*indexes):\\n current_slice = tuple(\\n slice(selected_chunk_size[i] * indx[i], min(selected_chunk_size[i] * (indx[i] + 1), shape[i])) for i in\\n range(len(shape)))\\n chunks.append(array[current_slice])\\n return chunks\",\n \"def split(list):\\n\\n\\tmid = len(list) // 2\\n\\tleft = list[:mid]\\n\\tright = list[mid:]\\n\\n\\treturn left, right\",\n \"def splitList(arr, size):\\n arrs = []\\n while len(arr) > size:\\n pice = arr[:size]\\n arrs.append(pice)\\n arr = arr[size:]\\n arrs.append(arr)\\n return arrs\",\n \"def split_array(array, max_len=2000):\\n new_array_lst = []\\n for x in range(0, len(array), max_len):\\n split = array[x: x + max_len]\\n if len(split) >= max_len:\\n new_array_lst.append(split)\\n\\n return new_array_lst\",\n \"def splits_array_switcher(trajectory1, trajectory2, index_of_cut):\\r\\n\\r\\n trajectory1_a, trajectory2_b = trajectory1[:index_of_cut], trajectory1[index_of_cut:]\\r\\n trajectory2_a, trajectory1_b = trajectory2[:index_of_cut], trajectory2[index_of_cut:]\\r\\n\\r\\n trajectory1 = np.concatenate((trajectory1_a, trajectory1_b), axis=0)\\r\\n trajectory2 = np.concatenate((trajectory2_a, trajectory2_b), axis=0)\\r\\n\\r\\n return trajectory1, trajectory2\",\n \"def splice(i, j, data):\\n n = len(data)\\n out = ()\\n splice_a = []\\n splice_b = []\\n i = idx(i, n)\\n j = idx(j, n)\\n i+=1\\n j+=1\\n if(i < j):\\n splice_a = data[i:j]\\n splice_b = data[j:] + data[0:i]\\n else:\\n splice_a = data[i:] + data[0:j]\\n splice_b = data[j:i]\\n\\n return (splice_a, splice_b)\",\n \"async def split_list(arr, size=100):\\n\\n arrs = []\\n\\n while len(arr) > size:\\n pice = arr[:size]\\n arrs.append(pice)\\n arr = arr[size:]\\n\\n arrs.append(arr)\\n return arrs\",\n \"def _get_indices_split ( indices, number_of_folds ):\\n # Split the indicies by the number of folds\\n return np.array_split ( indices, indices_or_sections = number_of_folds )\\n # End get_indices_split()\",\n \"def _get_indices_split ( indices, number_of_folds ):\\n # Split the indicies by the number of folds\\n return np.array_split ( indices, indices_or_sections = number_of_folds )\\n # End get_indices_split()\",\n \"def split_data(data, squeeze=False):\\n vdata = np.atleast_2d(data)\\n nr_freqs = int(vdata.shape[1] / 2)\\n part1 = vdata[:, 0:nr_freqs]\\n part2 = vdata[:, nr_freqs:]\\n if(squeeze):\\n part1 = part1.squeeze()\\n part2 = part2.squeeze()\\n return part1, part2\",\n \"def splitList(l, i1, i2):\\n n = len(l)\\n L1 = []\\n L2 = []\\n j = 0\\n # Creating list 1\\n while (i1 + j) % n != i2:\\n L1.append(l[(i1 + j) % n])\\n j += 1\\n L1.append(l[i2])\\n # Creating list 2\\n j = 0\\n while (i2 + j) % n != i1:\\n L2.append(l[(i2 + j) % n])\\n j += 1\\n L2.append(l[i1])\\n return (L1, L2)\",\n \"def split(ba):\\n l = []\\n for i in range(len(ba)/9):\\n l.append(ba[i*9:(i+1)*9])\\n\\n return l\",\n \"def split_image(img):\\n xs = [] # positions\\n ys = [] # colors\\n for row_i in range(img.shape[0]):\\n for col_i in range(img.shape[1]):\\n xs.append([row_i, col_i])\\n ys.append(img[row_i, col_i])\\n \\n xs = np.array(xs)\\n ys = np.array(ys)\\n return xs, ys\",\n \"def split_image(img):\\n xs = [] # positions\\n ys = [] # colors\\n for row_i in range(img.shape[0]):\\n for col_i in range(img.shape[1]):\\n xs.append([row_i, col_i])\\n ys.append(img[row_i, col_i])\\n \\n xs = np.array(xs)\\n ys = np.array(ys)\\n return xs, ys\",\n \"def segment_array(array=[],N=0,value=0):\\n \\n array = np.concatenate([array,np.ones(N-len(array)%N)*value])\\n \\n return array.reshape((-1,N))\",\n \"def split_half(slice):\\n slice = set_date(slice)\\n slice['Date'] = pd.to_datetime(slice['Date'])\\n col_names = ['Date', 'Label', 'Text Extract', 'Processed']\\n slice = slice[col_names]\\n max_date = slice['Date'].max()\\n min_date = slice['Date'].min()\\n split_day = min_date + (max_date-min_date) // 2\\n slice_b = slice[slice['Date'] > split_day]\\n slice = slice[slice['Date'] <= split_day]\\n return slice, slice_b\",\n \"def segmentArray(array, pos = 0):\\n\\t\\n#\\tfrom jot.basic.countDistinctValues import countDistinctValues\\n\\t\\n\\tfinalarray = []\\n\\tprovarray = list(countDistinctValues(array, pos).keys())\\n\\t\\n\\tfor i in provarray:\\n\\t\\n\\t\\ttemparray = []\\n\\t\\t\\n\\t\\tfor j in array:\\n\\t\\t\\n\\t\\t\\tif i == j[0]:\\n\\t\\t\\t\\ttemparray.append(j[1:])\\n\\t\\t\\t\\t\\n\\t\\tfinalarray.append(temparray)\\n\\t\\t\\n\\treturn finalarray\",\n \"def partition(data, indecies):\\n\\tsplitdata = [data[:indecies[0]]]\\n\\tsplitdata += [data[indecies[i-1]:indecies[i]] for i in range(1,len(indecies))]\\n\\tsplitdata.append(data[indecies[-1]:])\\n\\treturn splitdata\",\n \"def sort_and_distribute(array, splits=2):\\n if not isinstance(array, (list,tuple)): raise TypeError(\\\"array must be a list\\\")\\n if not isinstance(splits, int): raise TypeError(\\\"splits must be an integer\\\")\\n remaining = sorted(array)\\n if sys.version_info < (3, 0):\\n myrange = xrange(splits)\\n else:\\n myrange = range(splits)\\n groups = [[] for i in myrange]\\n while len(remaining) > 0:\\n for i in myrange:\\n if len(remaining) > 0: groups[i].append(remaining.pop(0))\\n return groups\",\n \"def chunks(array, size: int):\\r\\n for i in range(0, len(array), size):\\r\\n yield array[i:i + size]\",\n \"def img_split(img):\\n\\tbands = img.shape[2]\\n\\tif bands is 1:\\n\\t\\treturn \\\"Image already is 1D. Why would you split it?\\\"\\n\\n\\tband1 = img[:, :, 0]\\n\\tband2 = img[:, :, 1]\\n\\tband3 = img[:, :, 2]\\n\\tif bands is 4:\\n\\t\\tband4 = img[:, :, 4]\\n\\t\\treturn(band1, band2, band3, band4)\\n\\treturn(band1, band2, band3)\",\n \"def partition_files(list_of_files, number_of_parts):\\n return np.array_split(list_of_files, number_of_parts)\",\n \"def split_list(input_list):\\n if len(input_list) % 2 == 0:\\n half = len(input_list) // 2\\n return input_list[:half], input_list[half:]\\n else:\\n raise NotImplementedError(\\\"split_list requires a list of even length\\\")\",\n \"def get_splits(ntot, nper):\\n beglist = numpy.arange(0,ntot,nper)\\n endlist = numpy.arange(0,ntot,nper) + nper - 1\\n\\n if (ntot % nper) != 0:\\n endlist[-1] = ntot-1\\n return beglist, endlist\",\n \"def split_image(image_name):\\n #pil_image = Image.fromarray(image_name)\\n red, green, blue = img.split()\\n\\n return red, green, blue\",\n \"def img_to_slices(img):\\n res = []\\n\\n for i, slice_img in enumerate(img):\\n res.append(slice_img)\\n return res\",\n \"def trajectory_splitter(trajectory, split_start, split_length):\\r\\n mask_array = np.zeros(np.shape(trajectory), dtype=bool)\\r\\n # print(np.shape(mask_array))\\r\\n mask_array[:, split_start:split_start+split_length] = 1\\r\\n # print(np.ma.masked_array(trajectory, mask=mask_array))\\r\\n return trajectory[:, :split_start],trajectory[:, split_start+split_length:], np.ma.masked_array(trajectory, mask=mask_array)\",\n \"def split(mylist,size):\\r\\n\\r\\n split_list = []\\r\\n\\r\\n for index,num in enumerate(mylist):\\r\\n if index + size <= len(mylist):#checks so we don't go out of list range\\r\\n position = mylist.index(num,index)\\r\\n split_list.append(mylist[position:position+size])\\r\\n return split_list\",\n \"def alternate_iter(array):\\n result = []\\n array = sorted(array)\\n for n in range(len(array)):\\n if n >= len(array):\\n break\\n result.append(array.pop())\\n try:\\n result.append(array[n])\\n except IndexError:\\n break\\n\\n return result\",\n \"def partition(self, sep):\\n return asarray(partition(self, sep))\",\n \"def _splitPoints(self, points, split):\\n # validate split\\n if not split:\\n return [points]\\n\\n # complete split with adding start and end frames\\n if split[0] != 0:\\n split.insert(0, 0)\\n\\n if split[-1] != len(points):\\n split.append(len(points))\\n\\n # make sure split is sorted and doesn't contain any duplicates\\n split = list(set(split))\\n split.sort()\\n\\n # split range for looping\\n splitA = split[:-1]\\n splitB = split[1:]\\n\\n # get lists\\n return [points[a:b + 1] for a, b in zip(splitA, splitB)]\",\n \"def subimage(image_as_array, step):\\r\\n\\tsubimage_2d_array = image_as_array[200-int(step):200+int(step)]\\r\\n\\treturn subimage_2d_array\",\n \"def split(a, sep=None, maxsplit=None):\\n # This will return an array of lists of different sizes, so we\\n # leave it as an object array\\n return _vec_string(\\n a, object_, 'split', [sep] + _clean_args(maxsplit))\",\n \"def _segments2slices(array_size, grid_segments, patch_segments):\\n patch_slices = [slice(start, stop) for start, stop in patch_segments]\\n array_slices = []\\n\\n for start, stop in grid_segments:\\n segment_size = max(abs(start), abs(stop))\\n k = int(ceil(float(segment_size) / array_size) + (-1 if start >= 0 else 0))\\n cell_mirrored = k % 2\\n \\n step = 1\\n if start < 0:\\n start = k * array_size + start\\n stop = k * array_size + stop\\n else:\\n start = start - k * array_size\\n stop = stop - k * array_size\\n\\n if cell_mirrored:\\n start = array_size - start - 1\\n stop = array_size - stop - 1\\n step = -1\\n\\n if stop < 0:\\n stop = None\\n\\n array_slices.append(slice(start, stop, step))\\n \\n return array_slices, patch_slices\",\n \"def split_seq(seq, size):\\n return [seq[ii:ii + size] for ii in range(0, len(seq), size)]\",\n \"def chunks(arr, n):\\n for i in range(0, len(arr), n):\\n yield arr[i:i + n]\",\n \"def split_bits_bit_array(x, bit_array):\\n\\n mask = bit_array - 1\\n\\n lower = x & mask\\n upper = x & ~mask\\n\\n return lower, upper\",\n \"def chunks(arr, n):\\n for i in range(0, len(arr), n):\\n yield arr[i:i + n]\",\n \"def b(i,new_arr,arr):\\n new_arr = tf.concat([new_arr,arr[:, i:last_step + i:stride, :]], axis=2)\\n return i+1,new_arr,arr\",\n \"def split_at(words, verb):\\n if verb in words:\\n i = words.index(verb)\\n first_half = words[0:i]\\n second_half = words[i+1:]\\n return [first_half, second_half]\\n else:\\n return -1\",\n \"def buildSegments(array, segLength: int):\\n s = math.floor(len(array)/segLength)\\n segments = []\\n for i in range(s+1):\\n segments.append(array[i*segLength:(i+1)*segLength])\\n return np.array(segments)\",\n \"def partition(a, sep):\\n return _to_bytes_or_str_array(\\n _vec_string(a, object_, 'partition', (sep,)), a)\",\n \"def split_half(str):\\n split_pairs = str[:len(str)//2], str[len(str)//2:]\\n return split_pairs\",\n \"def divide_with_stride(arr: np.ndarray) -> List[np.ndarray]:\\n\\n result_list: List[np.ndarray] = []\\n # slice by z axis\\n for z in range(0, z_len := arr.shape[0], 16):\\n if z + 31 >= z_len:\\n z = z_len - 16\\n z_arr: np.ndarray = arr[z:z+16]\\n\\n # slice by y axis\\n for y in range(0, y_len := arr.shape[1], 16):\\n y_arr: np.ndarray = z_arr[:, y:y+16]\\n\\n # slice by x axis\\n for x in range(0, x_len := arr.shape[2], 16):\\n x_arr: np.ndarray = y_arr[:, :, x:x+16]\\n if len(set(x_arr.shape)) == 1 and x_arr.shape[0] == 16:\\n result_list.append(x_arr)\\n \\n return result_list\",\n \"def split_by_size(array: Iterable[T], size: int) -> Iterable[List[T]]:\\n chunk = []\\n for e in array:\\n chunk.append(e)\\n if len(chunk) == size:\\n yield chunk\\n chunk = []\\n if len(chunk) > 0:\\n yield chunk\",\n \"def split(a):\\r\\n compos = [-1] # compos stores the positions of the relevant commas in the argument string\\r\\n compos.extend(t[2][1] for t in generate_tokens(StringIO(a).readline) if t[1] == ',')\\r\\n compos.append(len(a))\\r\\n return [ a[compos[i]+1:compos[i+1]] for i in xrange(len(compos)-1)]\",\n \"def partition(alist, indices):\\n return [alist[i:j] for i, j in zip([0]+indices, indices+[None])]\",\n \"def segment_array(a):\\n\\n l = [array(a.typecode) for chaff in range(16)]\\n index = 0\\n\\n for i in range(0, len(a), 16):\\n l[index].extend(a[i:i + 16])\\n index = (index + 1) % 16\\n\\n return l\",\n \"def num_43():\\n \\n def block(a, r=3, cs=3, row_order=True):\\n \\\"\\\"\\\"Block slice an array using a window of (rs, cs) size\\n \\\"\\\"\\\"\\n lenr = a.shape[0]//rs\\n lenc = a.shape[1]//cs\\n if row_order:\\n iter = [(i, j) for (i, j) in np.ndindex(lenr, lenc)]\\n else:\\n iter = [(j, i) for (i, j) in np.ndindex(lenr, lenc)]\\n b = np.array([a[i*rs:(i+1)*rs, j*cs:(j+1)*cs] for (i,j) in iter])\\n #b = np.array([a[i*rs:(i+1)*rs, j*cs:(j+1)*cs] \\n # for (i, j) in np.ndindex(lenr, lenc)])\\n return b\\n r = 6\\n c = 6\\n a = np.arange(r*c).reshape(r, c)\\n vs = np.array(np.vsplit(a, 2))\\n hs = np.array(np.hsplit(a, 2))\\n #a.squeeze(axis=(2,3))\\n rs = 3\\n cs = 4\\n #lenr = a.shape[0]//rs\\n #lenc = a.shape[1]//cs\\n #b = np.array([a[i*rs:(i+1)*rs, j*cs:(j+1)*cs] \\n # for (i, j) in np.ndindex(lenr, lenc)])\\n #b1 = np.array([a[i*rs:(i+1)*rs, j*cs:(j+1)*cs] \\n # for (j, i) in np.ndindex(lenr, lenc)])\\n e = block(a, 3, 4, row_first=False)\\n b = block(a, rs, cs, True)\\n b1 = block(a, rs, cs, False)\\n c = np.array([np.vsplit(i, 2) for i in np.hsplit(a, 2)])\\n d = np.array([np.hsplit(i, 2) for i in np.vsplit(a, 2)])\\n #c = c.reshape(lenr*lenc, rs, cs) \\n return a, b, b1, c, d, e\",\n \"def split(it, sz):\\n\\n out = []\\n last = 0.0\\n\\n while last < len(it):\\n out.append(it[int(last):int(last + sz)])\\n last += sz\\n\\n return out\",\n \"def iterate_array_in_chunks(arr, size: int):\\n for i in range(0, len(arr), size):\\n yield arr[i:i+size]\",\n \"def sliceshape(slicetuple, totshape):\\n res = []\\n for i,s in enumerate(slicetuple):\\n if isinstance(s,int):\\n #n = 1\\n pass\\n else:\\n i0,i1,istep = s.indices(totshape[i])\\n n = (i1-i0)//istep\\n res.append(n)\\n return res\",\n \"def split_cond(f, iterable):\\n split_point = [i for i, e in enumerate(iterable) if f(e)]\\n split_point += [len(iterable)]\\n return [iterable[i:j] for i, j in zip(split_point[:-1], split_point[1:])]\",\n \"def split_seq(seq,size):\\n return [seq[i:i+size] for i in range(0, len(seq), size)]\",\n \"def divide_array(arr, n):\\r\\n if n <= 0:\\r\\n raise ValueError(\\\"Number of elements value must be greater than 0\\\")\\r\\n\\r\\n if len(arr) % n > 0:\\r\\n output_size = len(arr) // n + 1 # python 3 integer division\\r\\n last_output_size = output_size - (len(arr) % n)\\r\\n else:\\r\\n output_size = len(arr) // n\\r\\n last_output_size = output_size\\r\\n\\r\\n output_arr = []\\r\\n slice_start = 0\\r\\n slice_end = output_size\\r\\n i = 0\\r\\n\\r\\n while i < n:\\r\\n if i < (n - 1):\\r\\n output_item = arr[slice_start : slice_end]\\r\\n output_arr.append(output_item)\\r\\n slice_start += output_size\\r\\n slice_end += output_size\\r\\n else:\\r\\n slice_end = slice_start + last_output_size\\r\\n output_item = arr[slice_start : slice_end]\\r\\n output_arr.append(output_item)\\r\\n i += 1\\r\\n\\r\\n return output_arr\",\n \"def mid(arr):\\n\\n \\n arr_ln = len(arr)\\n mid = arr_ln//2\\n val = arr.pop(mid)\\n\\n return arr, val\",\n \"def split_sequence(sequence, input_dim, output_dim, first_demand_column=0):\\r\\n x, y = list(), list()\\r\\n for i in range(input_dim,len(sequence),1):\\r\\n \\\"\\\"\\\" gather input and output parts of the pattern \\\"\\\"\\\"\\r\\n seq_x, seq_y = sequence[i-input_dim:i], sequence[i:i+output_dim,first_demand_column:]\\r\\n if len(seq_y) < output_dim:\\r\\n break\\r\\n x.append(seq_x)\\r\\n y.append(seq_y)\\r\\n \\r\\n return np.array(x), np.array(y)\",\n \"def slices_using_group_array(group_array):\\n unique_elements = np.unique(group_array)\\n slices = []\\n for unique_element in unique_elements:\\n indexes = np.flatnonzero(group_array == unique_element)\\n low, high = (indexes[0], indexes[-1] + 1)\\n slices.append((unique_element, slice(low, high)))\\n return slices\",\n \"def splitH_unlifted(pixmap):\\n h = pixmap.shape[0]\\n if h % 2 == 1:\\n h = h // 2\\n return [pixmap[:h,:], pixmap[h+1:,:]]\\n else:\\n h = h // 2\\n return [pixmap[:h,:], pixmap[h:,:]]\",\n \"def split_validation_data(*data, divmod=0.5):\\n n = round((len(data[0]) - 1) * divmod)\\n return [(d[n:], d[:n]) for d in data]\",\n \"def class_split(x):\\r\\n return np.split(x, [19,43])\",\n \"def separa(matrix):\\r\\n linha, coluna = matrix.shape\\r\\n linha2, coluna2 = linha//2, coluna//2\\r\\n return matrix[:linha2, :coluna2], matrix[:linha2, coluna2:], matrix[linha2:, :coluna2], matrix[linha2:, coluna2:]\",\n \"def split_into_subarrays_of_max_len(arr, max_len=44100):\\n return np.split(arr, np.arange(max_len, len(arr), max_len))\",\n \"def unstacked_index(size, index):\\n return index % size, index // size\",\n \"def split_range(r, n):\\n \\n step = int(r / n)\\n segments = []\\n for i in range(n):\\n new_segment = [step * i, step * (i + 1)]\\n segments.append(new_segment)\\n # correct the gap in the missing index due to the truncated step\\n segments[-1][-1] = r\\n return segments\",\n \"def splitregions(region_array, window_len, stride):\\n region_output = np.empty((0,3), dtype=np.int)\\n for region in region_array:\\n strand, left, right = region\\n region_length = right - left + 1\\n if region_length >= window_len:\\n new_lefts, new_rights = _splitregion(region_length, window_len, stride)\\n new_regions = np.asarray([np.zeros(len(new_lefts))+strand, new_lefts+left, new_rights+left], dtype=np.uint32).T\\n region_output = np.r_[region_output, new_regions]\\n return region_output\",\n \"def lap_split_n(img, n):\\n levels = []\\n\\n print(\\\"inside lap_split_n function \\\")\\n\\n for i in range(n):\\n img, hi = lap_split(img)\\n levels.append(hi)\\n levels.append(img)\\n return levels[::-1]\",\n \"def listsplit(value, arg):\\n\\n print \\\"listsplit:{0}\\\".format(arg)\\n args = arg.split(\\\",\\\")\\n if not len(args) == 2:\\n return value\\n\\n i = int(args[0])\\n n = int(args[1])\\n\\n m = len(value)\\n\\n base = m // n\\n rem = m % n\\n\\n sizes = [base + 1] * rem + [base] * (n - rem)\\n\\n start = sum(sizes[0:i])\\n end = start + sizes[i]\\n\\n return value[start:end]\",\n \"def split_segments_vertically(segments, img_shape):\\n left, right = [], []\\n split = img_shape[1] // 2\\n for (p1, p2) in segments:\\n if p1[0] < split and p2[0] < split:\\n left.append((p1, p2))\\n elif p1[0] > split and p1[0] > split:\\n right.append((p1, p2))\\n\\n return left, right\",\n \"def _partition(array, order, pivot, lower, upper):\\n # The pivot element is made the last not to interfere with other swaping \\n # operations\\n array[pivot], array[upper] = array[upper], array[pivot]\\n\\n # Last index of smaller/greater (asc/desc) elements\\n idx = lower\\n\\n for j in range(lower, upper):\\n if (order == Order.ASC and array[j] < array[upper] or # ASCENDING\\n order == Order.DESC and array[j] > array[upper]): # DESCENDING\\n # Moves the current element at the end of the sub-array with\\n # the smaller/grater (asc/desc) elements\\n array[idx], array[j] = array[j], array[idx]\\n idx += 1\\n\\n # Moves pivot as separator between greater and smaller numbers\\n array[idx], array[upper] = array[upper], array[idx]\\n\\n return idx\",\n \"def smart_split(strokes):\\n\\n splited = []\\n for stroke in strokes:\\n splited += stroke.split_non_differentiable_points()\\n return splited\",\n \"def seperate_list(list, division_part):\\n avg = len(list) / float(division_part)\\n out = []\\n last = 0.0\\n\\n while last < len(list):\\n out.append(list[int(last):int(last + avg)])\\n last += avg\\n return out\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7665456","0.7067053","0.68895733","0.6825084","0.6575467","0.6566739","0.656526","0.6551348","0.65445685","0.6517187","0.64508444","0.6435194","0.6357571","0.63475424","0.6298871","0.6265837","0.6259398","0.6205831","0.6199721","0.61938316","0.61762506","0.6161783","0.6144705","0.6133529","0.61235136","0.60693043","0.5963785","0.59274787","0.59078115","0.588165","0.58644557","0.58570385","0.5852731","0.58488595","0.5823932","0.5818147","0.5818147","0.5792617","0.57841367","0.5765161","0.5750497","0.5750497","0.57421297","0.5732653","0.57294184","0.5724351","0.57169235","0.5713945","0.57093096","0.56903124","0.567239","0.56708235","0.5660492","0.56502193","0.56492585","0.5632626","0.5593616","0.5567195","0.55645037","0.5546117","0.554485","0.5538464","0.5515641","0.5505458","0.5497861","0.54964215","0.5488652","0.54880154","0.5481884","0.5481215","0.54768914","0.54661375","0.546101","0.5455504","0.54491407","0.5442793","0.54354036","0.5430553","0.54218674","0.54203403","0.5418247","0.5417685","0.54169106","0.5403081","0.5398596","0.5393608","0.53744316","0.5373276","0.5372071","0.53542817","0.5337685","0.5325034","0.5314986","0.5312647","0.530615","0.5298577","0.529537","0.5284301","0.52812386","0.5271621"],"string":"[\n \"0.7665456\",\n \"0.7067053\",\n \"0.68895733\",\n \"0.6825084\",\n \"0.6575467\",\n \"0.6566739\",\n \"0.656526\",\n \"0.6551348\",\n \"0.65445685\",\n \"0.6517187\",\n \"0.64508444\",\n \"0.6435194\",\n \"0.6357571\",\n \"0.63475424\",\n \"0.6298871\",\n \"0.6265837\",\n \"0.6259398\",\n \"0.6205831\",\n \"0.6199721\",\n \"0.61938316\",\n \"0.61762506\",\n \"0.6161783\",\n \"0.6144705\",\n \"0.6133529\",\n \"0.61235136\",\n \"0.60693043\",\n \"0.5963785\",\n \"0.59274787\",\n \"0.59078115\",\n \"0.588165\",\n \"0.58644557\",\n \"0.58570385\",\n \"0.5852731\",\n \"0.58488595\",\n \"0.5823932\",\n \"0.5818147\",\n \"0.5818147\",\n \"0.5792617\",\n \"0.57841367\",\n \"0.5765161\",\n \"0.5750497\",\n \"0.5750497\",\n \"0.57421297\",\n \"0.5732653\",\n \"0.57294184\",\n \"0.5724351\",\n \"0.57169235\",\n \"0.5713945\",\n \"0.57093096\",\n \"0.56903124\",\n \"0.567239\",\n \"0.56708235\",\n \"0.5660492\",\n \"0.56502193\",\n \"0.56492585\",\n \"0.5632626\",\n \"0.5593616\",\n \"0.5567195\",\n \"0.55645037\",\n \"0.5546117\",\n \"0.554485\",\n \"0.5538464\",\n \"0.5515641\",\n \"0.5505458\",\n \"0.5497861\",\n \"0.54964215\",\n \"0.5488652\",\n \"0.54880154\",\n \"0.5481884\",\n \"0.5481215\",\n \"0.54768914\",\n \"0.54661375\",\n \"0.546101\",\n \"0.5455504\",\n \"0.54491407\",\n \"0.5442793\",\n \"0.54354036\",\n \"0.5430553\",\n \"0.54218674\",\n \"0.54203403\",\n \"0.5418247\",\n \"0.5417685\",\n \"0.54169106\",\n \"0.5403081\",\n \"0.5398596\",\n \"0.5393608\",\n \"0.53744316\",\n \"0.5373276\",\n \"0.5372071\",\n \"0.53542817\",\n \"0.5337685\",\n \"0.5325034\",\n \"0.5314986\",\n \"0.5312647\",\n \"0.530615\",\n \"0.5298577\",\n \"0.529537\",\n \"0.5284301\",\n \"0.52812386\",\n \"0.5271621\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.77543867"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":21397,"cells":{"query":{"kind":"string","value":"Since the architecture uses features computed through the image and its mask we precompute them to speed up the usage at runtime (Equation (13))"},"document":{"kind":"string","value":"def precompute_features(imgs:list, GTs:list, phi:models) -> list:\n G_Ts = [1 - GTn for GTn in GTs]\n IGms = [GTn * In for GTn, In in zip(GTs, imgs)] \n I_Gms = [G_Tn * In for G_Tn, In in zip(G_Ts, imgs)] \n features = [(phi(IGm), phi(I_Gm)) for IGm, I_Gm in zip(IGms, I_Gms)]\n return features"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def feature(input_dir, input_img, mask, output_dir, window_size):\n\t# Get the pixel array of the ROI\n\tws = int(float(window_size))\n\tfilename = os.path.join(input_dir, input_img)\n\tim = nib.load(filename)\n\taffine = im.affine\n\timg = im.get_data() \n\t# img= (img - img.min()) / (np.sort(img,axis=None)[-10] - img.min()) * 255\n\t# img[img<0]=0\n\t# img[img>255]=255\n\t# fea_img = nib.Nifti1Image(img, affine)\n\t# nib.save(fea_img, output_dir + 'Img_255.nii.gz')\t\n\tMask=nib.load(os.path.join(input_dir, mask)).get_data()\n\t# Slices=np.unique(np.where(Mask==1)[2])\n\t# img=img[:,:,tuple(Slices)]\n\t# Mask=Mask[:,:,tuple(Slices)]\n\t\"\"\" Local feature calculation \"\"\"\n\tif len(img.shape)>2:\n\t\tlength, width, height = img.shape\n\telse:\n\t\timg=img.reshape(img.shape[0],img.shape[1],1)\n\t\tMask=Mask.reshape(img.shape[0],img.shape[1],1)\n\t\tlength, width, height = img.shape\n\t# number of the features\n\tn_fea = 99\n\tfea = np.zeros((length, width, height, n_fea))\n\tfor h in range(height):\n\t\tfor l in range(length):\n\t\t\tfor w in range(width):\n\t\t\t\tif Mask[l,w,h]==0:\n\t\t\t\t\tcontinue\n\t\t\t\tpatch0 = img[max((l - ws),0):min(length,(l + ws)), max((w - ws),0):min(width,(w + ws)), h]\n\t\t\t\tl0, w0 = patch0.shape\n\t\t\t\tpatch = np.array(np.reshape(patch0, (1, l0 * w0)))\n\n\t\t\t\t\"\"\"\n\t\t\t\tfirst order statistics based feature\n\t\t\t\tlist {max, min, median, 25percentile, 75percentile, std, skew, kurtosis, entropy}\n\t\t\t\t\"\"\"\n\t\t\t\tfea[l, w, h, 0] = np.max(patch[0])\n\t\t\t\tfea[l, w, h, 1] = np.min(patch[0])\n\t\t\t\tfea[l, w, h, 2] = np.median(patch[0])\n\t\t\t\tfea[l, w, h, 3] = np.percentile(patch[0], 25)\n\t\t\t\tfea[l, w, h, 4] = np.percentile(patch[0], 75)\n\t\t\t\tfea[l, w, h, 5] = np.percentile(patch[0], 75)-np.percentile(patch[0], 25)\n\t\t\t\tfea[l, w, h, 6] = np.std(patch[0])\n\t\t\t\tfea[l, w, h, 7] = stats.skew(patch[0])\n\t\t\t\tfea[l, w, h, 8] = stats.kurtosis(patch[0])\n\t\t\t\thist = stats.histogram(patch[0], numbins=5)\n\t\t\t\tfea[l, w, h, 9] = stats.entropy(hist.count / np.sum(hist.count))\n\n\t\t\t\t\"\"\"\n\t\t\t\tGLCM based feature\n\t\t\t\tlist {angular second moment, contrast, correlation, variance, inverse difference moment,\n\t\t\t\tsum average, sum variance, sum entropy, entropy, difference variance, difference entropy,\n\t\t\t\tinfo. measure. of corr. 1, info. measure. of corr. 2, max. correlation coefficient}\n\t\t\t\t\"\"\"\n\t\t\t\tpatch2 = np.array((patch0 - img.min()) / (img.max() - img.min()) * 256, dtype=np.uint8)\n\t\t\t\tg_matrix = features.haralick(patch2)\n\t\t\t\tfea[l, w, h, 10:23] = np.mean(g_matrix, axis=0)\n\n\t\t\t\t\"\"\"\n\t\t\t\tLocal Binary Patterns based shape descriptors {7 first order statistics on histogram of LBP}\n\t\t\t\t\"\"\"\n\t\t\t\tlbp = local_binary_pattern(patch0, 8, ceil(ws/2), 'default')\n\t\t\t\tfea[l, w, h, 23] = np.max(lbp)\n\t\t\t\tfea[l, w, h, 24] = np.min(lbp)\n\t\t\t\tfea[l, w, h, 25] = np.median(lbp)\n\t\t\t\tfea[l, w, h, 26] = np.percentile(lbp, 25)\n\t\t\t\tfea[l, w, h, 27] = np.percentile(lbp, 75)\n\t\t\t\tfea[l, w, h, 28] = np.percentile(lbp, 75)-np.percentile(lbp, 25)\n\t\t\t\tfea[l, w, h, 29] = np.std(lbp)\n\t\t\t\t\n\t\t\t\t\"\"\"\n\t\t\t\tHu Moment based shape descriptor {7 moments}\n\t\t\t\t\"\"\"\n\t\t\t\tm = moments(np.array(patch0, dtype=np.float))\n\t\t\t\tcr = m[0, 1] / m[0, 0]\n\t\t\t\tcc = m[1, 0] / m[0, 0]\n\t\t\t\tcm = moments_central(np.array(patch0, dtype=np.float), cr, cc)\n\t\t\t\tncm = moments_normalized(cm)\n\t\t\t\thum = moments_hu(ncm)\n\t\t\t\tfea[l, w, h, 30:37] = hum\n\n\t\t\t\t\"\"\"\n\t\t\t\tZernike moment based shape descriptors {first 8 moments}\n\t\t\t\t\"\"\"\n\t\t\t\tzm = features.zernike_moments(patch0, ws)\n\t\t\t\tfea[l, w, h, 37:45] = zm[1:9]\t\t\n\t\t\t\t\n\t\t\t\t\"\"\"\n\t\t\t\tThreshold Adjacency Statistics based shape descriptors {9 statistics} * 6 = 54\n\t\t\t\t\"\"\"\n\t\t\t\ttas = features.tas(patch0)\n\t\t\t\t# lentas = len(tas)\n\t\t\t\tfea[l, w, h, 45:100] = tas[:54]\n\t# Save all the local feature maps in NIFTI format\t\n\tfeaturedir=os.path.join(output_dir,'Size'+str(window_size))\n\tif not os.path.exists(featuredir):\n\t\tos.makedirs(featuredir)\t\n\tfor ii in range(n_fea):\n\t\toutput_filename = featuredir+'/fea_'+str(ii+1)+'.nii.gz'\n\t\tdata = np.reshape(fea[:, :, :, ii], (length, width, height))\n\t\tfea_img = nib.Nifti1Image(data, affine)\n\t\tnib.save(fea_img, output_filename)","def precompute(self, features, mode, params):\n return None","def __call__(self, prediction, fg_mask, image):\n # prediction = self.pooling(prediction)\n # fg_mask = self.pooling(fg_mask)\n N, C, H, W = prediction.size()\n bg = prediction*(1-fg_mask)\n fg = prediction*fg_mask\n\n\n fg_patch = fg.view(N,C,-1).permute(0,2,1)\n bg_patch = bg.view(N,C,-1)\n\n fg_patch_mu = torch.mean(fg_patch, dim=2, keepdim=True)\n bg_patch_mu = torch.mean(bg_patch, dim=1, keepdim=True)\n fg_bg_local_conv = torch.matmul((fg_patch-fg_patch_mu), (bg_patch-bg_patch_mu))/(C-1)\n\n bg_distribution_std = (torch.var(bg_patch, dim=1, keepdim=True) + 1e-8).sqrt()\n fg_distribution_std = (torch.var(fg_patch, dim=2, keepdim=True) + 1e-8).sqrt()\n fg_bg_r = fg_bg_local_conv.div(torch.matmul(fg_distribution_std,bg_distribution_std)+1e-8)\n fg_bg_r = fg_bg_r.abs()\n # fg_bg_r[fg_bg_r<0.7] = 0\n\n pixel_count = H*W\n # # bg_patch_one = bg.unsqueeze(1).repeat(1, pixel_count, 1, 1, 1)\n # # fg_patch_one = fg.view(N,C,-1).permute(0,2,1).unsqueeze(-1).unsqueeze(-1).expand_as(bg_patch_one)\n # bg_patch_one = bg.permute(0,2,1,3).permute(0,1,3,2).unsqueeze(1)\n # fg_patch_one = fg.view(N,C,-1).permute(0,2,1).unsqueeze(-2).unsqueeze(-2)\n # fg_bg_L1 = (fg_patch_one-bg_patch_one).pow(2).mean(dim=-1)\n # fg_bg_L1_drop_fg = fg_bg_L1*(1-fg_mask)\n\n # fg_mask_channel = fg_mask.view(N, -1, 1, 1).expand_as(fg_bg_L1)\n # fg_bg_L1_only_fg = fg_bg_L1_drop_fg*fg_mask_channel\n\n # # fg_bg_local_conv[fg_bg_local_conv<0] = 0\n # # fg_bg_local_conv = torch.softmax(fg_bg_local_conv, dim=2)\n # # local_loss = fg_bg_L1_only_fg.view(N, pixel_count, pixel_count)*fg_bg_local_conv.permute(0,2,1).detach()\n # local_loss = fg_bg_L1_only_fg.view(N, pixel_count, -1)*fg_bg_r\n # fg_mask_sum = fg_mask.view(N, -1).sum(dim=1)\n\n C1 = 0.01**2\n image = self.adaptivepooling(image)\n # image = F.adaptive_avg_pool2d(image, 32)\n # print(image.size())\n image_fg = image*fg_mask\n image_bg = image*(1-fg_mask)\n image_fg_mu = image_fg.mean(dim=1)\n image_bg_mu = image_bg.mean(dim=1)\n image_fg_patch_one = image_fg_mu.view(N, -1,1)\n image_bg_patch_one = image_bg_mu.view(N, -1,1)\n image_fg_patch_one_sq = image_fg_patch_one.pow(2)\n image_bg_patch_one_sq = image_bg_patch_one.pow(2)\n\n luminance = torch.matmul(image_fg_patch_one, image_bg_patch_one.permute(0,2,1)+C1).div(image_fg_patch_one_sq+image_bg_patch_one_sq+C1)\n # image_bg_patch_one = image_bg.permute(0,2,1,3).permute(0,1,3,2).unsqueeze(1)\n # image_fg_patch_one = image_fg.view(N,image_fg.size(1),-1).permute(0,2,1).unsqueeze(-2).unsqueeze(-2)\n # fg_bg_L1 = (image_fg_patch_one-image_bg_patch_one).pow(2).mean(dim=-1)\n fg_bg_loss = luminance\n \n fg_bg_loss_drop_fg = fg_bg_loss*(1-fg_mask.view(N,1, -1))\n fg_mask_channel = fg_mask.view(N, -1, 1).expand_as(fg_bg_loss)\n fg_bg_loss_only_fg = fg_bg_loss_drop_fg*fg_mask_channel\n local_loss = fg_bg_loss_only_fg*fg_bg_r.detach()\n\n local_loss = local_loss.mean()\n loss = local_loss\n # if target_is_real:\n # loss = local_loss # self.relu(1-prediction.mean())\n # else:\n # loss = -local_loss # self.relu(1+prediction.mean())\n return loss","def Get_Predictors_At_XY(Focal_Features, Image_Features, feature_dict, mask_in = None,\n convert_length = 0.2204315, radius = 50, verbose = False):\n \n ## Expand mask into one-hot mask if input is flat\n #print('z')\n ## Define factor by which to convert pixel area to area in square meters\n convert_area = convert_length**2\n #print('y')\n ## create mask and index list that shows which image_features are buildings\n mask_buildings = Image_Features.Type.isin(['mBuild', 'tBuild']) \n ind_buildings = list(mask_buildings[mask_buildings].index) \n nbuildings = len(ind_buildings)\n #print('x')\n ## Create submasks that distinguish modern buildings from huts \n mask_mods = Image_Features.Type[mask_buildings].isin(['mBuild'])\n ind_mods = list(mask_mods[mask_mods].index)\n mask_huts = Image_Features.Type[mask_buildings].isin(['tBuild'])\n ind_huts = list(mask_huts[mask_huts].index)\n #print('w')\n \n ## Calculate distances between Focal features and buildings\n distance_mat = dist(Focal_Features.loc[:,{'x','y'}], \n Image_Features.loc[ind_buildings,{'x','y'}])\n #print('v') \n Focal_Features.loc[:, 'Local_Buildings'] = None\n Focal_Features.loc[:, 'Local_Moderns'] = None\n Focal_Features.loc[:, 'Local_Traditionals'] = None\n Focal_Features.loc[:, 'Local_Focal_Area'] = 3.14159*radius**2\n #print('u') \n nfeatures = Focal_Features.shape[0]\n\n ## Extract features from convolutional mask if provided\n if mask_in is not None:\n for val in feature_dict.keys():\n ival = int(val)\n feature_name = 'Local_' + feature_dict[val] + '_Area'\n Focal_Features.loc[:, feature_name] = mask_in[iy, ix, ival]*convert_area \n \n # Loop through each feature\n for ii in range(nfeatures):\n \n close_buildings = (distance_mat[ii, :] < radius).sum()\n close_mods = (distance_mat[ii, ind_mods] < radius).sum() \n close_huts = (distance_mat[ii, ind_huts] < radius).sum() \n #print('b' + str(ii))\n Focal_Features.loc[ii, 'Local_Buildings'] = close_buildings \n Focal_Features.loc[ii, 'Local_Moderns'] = close_mods \n Focal_Features.loc[ii, 'Local_Traditionals'] = close_huts \n if verbose:\n print(str(ii) + ' / ' + str(nfeatures))\n return Focal_Features","def _precompute_image_features(img, layers, shape, save_dir):\n # type: (np.ndarray, Union[Tuple[str], List[str]], Union[Tuple[int], List[int]]) -> Dict[str, np.ndarray]\n features_dict = {}\n g = tf.Graph()\n # Choose to use cpu here because we only need to compute this once and using cpu would provide us more memory\n # than the gpu and therefore allow us to process larger style images using the extra memory. This will not have\n # an effect on the training speed later since the gram matrix size is not related to the size of the image.\n with g.as_default(), g.device('/cpu:0'), tf.Session() as sess:\n with tf.variable_scope(\"discriminator\", reuse=False):\n image = tf.placeholder(tf.uint8, shape=shape)\n image_float = tf.image.convert_image_dtype(image,dtype=tf.float32) * 2 - 1\n net = vgg.net(image_float, trainable=False)\n style_pre = np.array([img])\n style_pre = style_pre.astype(np.uint8)\n\n if '0.12.0' in tf.__version__:\n all_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)\n else:\n all_vars = tf.get_collection(tf.GraphKeys.VARIABLES)\n\n discrim_tvars = [var for var in all_vars if var.name.startswith(\"discriminator\")]\n saver = tf.train.Saver(discrim_tvars)\n\n ckpt = tf.train.get_checkpoint_state(save_dir)\n if ckpt and ckpt.model_checkpoint_path:\n saver.restore(sess, ckpt.model_checkpoint_path)\n else:\n raise AssertionError(\"Cannot load from save directory.\")\n\n var_not_saved = [item for item in all_vars if item not in discrim_tvars]\n sess.run(tf.initialize_variables(var_not_saved))\n\n\n for layer in layers:\n # Calculate and store gramian.\n features = net[layer].eval(feed_dict={image: style_pre})\n features = np.reshape(features, (-1, features.shape[3]))\n gram = np.matmul(features.T, features) / features.size\n features_dict[layer] = gram\n return features_dict","def Get_Mask_Predictors(mask_in, Image_Features, feature_dict, \n convert_length = 0.2204315, radius = 50, verbose = False): \n \n ## Expand mask into one-hot mask if input is flat\n if len(mask_in.shape)==2:\n mask_in = Expand_Mask(mask_in, num_class = nfeatures)\n \n ## Define factor by which to convert pixel area to area in square meters\n convert_area = convert_length**2\n \n ## create mask and index list that shows which image_features are buildings\n mask_buildings = Image_Features.Type.isin(['mBuild', 'tBuild']) \n ind_buildings = list(mask_buildings[mask_buildings].index) \n nbuildings = len(ind_buildings)\n \n ## Create submasks that distinguish modern buildings from huts \n mask_mods = Image_Features.Type[mask_buildings].isin(['mBuild'])\n ind_mods = list(mask_mods[mask_mods].index)\n mask_huts = Image_Features.Type[mask_buildings].isin(['tBuild'])\n ind_huts = list(mask_huts[mask_huts].index)\n \n ## Calculate distances between all buildings\n distance_mat = dist(Image_Features.loc[ind_buildings,{'x','y'}])\n \n Image_Features.loc[:, 'Local_Buildings'] = None\n Image_Features.loc[:, 'Local_Moderns'] = None\n Image_Features.loc[:, 'Local_Traditionals'] = None\n Image_Features.loc[:, 'Local_Forest_Area'] = None\n Image_Features.loc[:, 'Local_Bare_Area'] = None\n Image_Features.loc[:, 'Local_Modern_Area'] = None\n Image_Features.loc[:, 'Local_Trads_Area'] = None\n Image_Features.loc[:, 'Local_Focal_Area'] = 3.14159*radius**2\n \n # Loop through each building and collect statistics\n for ii in ind_buildings:\n ind = ind_buildings[ii]\n building_type = Image_Features.Type[ind]\n close_buildings = (distance_mat[ii, :] < radius).sum() - 1.0\n close_mods = (distance_mat[ii, ind_mods] < radius).sum() - 1.0*(building_type=='mBuild')\n close_huts = (distance_mat[ii, ind_huts] < radius).sum() - 1.0*(building_type=='tBuild')\n ##print('b' + str(ii))\n Image_Features.loc[ind, 'Local_Buildings'] = close_buildings \n Image_Features.loc[ind, 'Local_Moderns'] = close_mods \n Image_Features.loc[ind, 'Local_Traditionals'] = close_huts \n ##print('c' + str(ii)) \n ## Define mask that will select a circle around the focal building. Note\n ## that 0 and 1 indices of mask / image correspond to rows (y) and cols (x)\n x = np.arange(0, mask_in.shape[1])\n y = np.arange(0, mask_in.shape[0])\n ##print('d' + str(ii))\n ## Convert distances back into pixels\n cx = round(Image_Features.loc[ind, 'x'] / convert_length)\n cy = round(Image_Features.loc[ind, 'y'] / convert_length)\n r = (radius / convert_length)\n ##print('e' + str(ii))\n ## Make indicator mask of all pixels less than distance r from focal building\n mask = (x[np.newaxis,:]-cx)**2 + (y[:,np.newaxis]-cy)**2 < r**2 \n ##print('f' + str(ii)) \n ##print('mask' + str(mask.shape) + 'mask_in' + str(mask_in.shape))\n Image_Features.loc[ind, 'Local_Modern_Area'] = mask_in[mask,0].sum()*convert_area \n ##print('g' + str(ii)) \n Image_Features.loc[ind, 'Local_Trads_Area'] = mask_in[mask,1].sum()*convert_area \n ##print('h' + str(ii)) \n Image_Features.loc[ind, 'Local_Forest_Area'] = mask_in[mask,2].sum()*convert_area \n ##print('i' + str(ii)) \n Image_Features.loc[ind, 'Local_Bare_Area'] = mask_in[mask,3].sum()*convert_area \n if verbose:\n print(str(ii) + ' / ' + str(nbuildings))\n return Image_Features","def _preprocess_input(self, dataset):\n masker = self.masker or dataset.masker\n\n mask_img = masker.mask_img or masker.labels_img\n if isinstance(mask_img, str):\n mask_img = nib.load(mask_img)\n\n # Ensure that protected values are not included among _required_inputs\n assert \"aggressive_mask\" not in self._required_inputs.keys(), \"This is a protected name.\"\n\n if \"aggressive_mask\" in self.inputs_.keys():\n LGR.warning(\"Removing existing 'aggressive_mask' from Estimator.\")\n self.inputs_.pop(\"aggressive_mask\")\n\n # A dictionary to collect masked image data, to be further reduced by the aggressive mask.\n temp_image_inputs = {}\n\n for name, (type_, _) in self._required_inputs.items():\n if type_ == \"image\":\n # If no resampling is requested, check if resampling is required\n if not self.resample:\n check_imgs = {img: nib.load(img) for img in self.inputs_[name]}\n _check_same_fov(**check_imgs, reference_masker=mask_img, raise_error=True)\n imgs = list(check_imgs.values())\n else:\n # resampling will only occur if shape/affines are different\n # making this harmless if all img shapes/affines are the same as the reference\n imgs = [\n resample_to_img(nib.load(img), mask_img, **self._resample_kwargs)\n for img in self.inputs_[name]\n ]\n\n # input to NiFtiLabelsMasker must be 4d\n img4d = concat_imgs(imgs, ensure_ndim=4)\n\n # Mask required input images using either the dataset's mask or the estimator's.\n temp_arr = masker.transform(img4d)\n\n # An intermediate step to mask out bad voxels.\n # Can be dropped once PyMARE is able to handle masked arrays or missing data.\n nonzero_voxels_bool = np.all(temp_arr != 0, axis=0)\n nonnan_voxels_bool = np.all(~np.isnan(temp_arr), axis=0)\n good_voxels_bool = np.logical_and(nonzero_voxels_bool, nonnan_voxels_bool)\n\n data = masker.transform(img4d)\n\n temp_image_inputs[name] = data\n if \"aggressive_mask\" not in self.inputs_.keys():\n self.inputs_[\"aggressive_mask\"] = good_voxels_bool\n else:\n # Remove any voxels that are bad in any image-based inputs\n self.inputs_[\"aggressive_mask\"] = np.logical_or(\n self.inputs_[\"aggressive_mask\"],\n good_voxels_bool,\n )\n\n # Further reduce image-based inputs to remove \"bad\" voxels\n # (voxels with zeros or NaNs in any studies)\n if \"aggressive_mask\" in self.inputs_.keys():\n n_bad_voxels = (\n self.inputs_[\"aggressive_mask\"].size - self.inputs_[\"aggressive_mask\"].sum()\n )\n if n_bad_voxels:\n LGR.warning(\n f\"Masking out {n_bad_voxels} additional voxels. \"\n \"The updated masker is available in the Estimator.masker attribute.\"\n )\n\n for name, raw_masked_data in temp_image_inputs.items():\n self.inputs_[name] = raw_masked_data[:, self.inputs_[\"aggressive_mask\"]]","def computeFeatures(self, image, mask, inputImageName, **kwargs):\n featureVector = collections.OrderedDict()\n\n # Calculate feature classes\n for featureClassName, enabledFeatures in six.iteritems(self.enabledFeatures):\n # Handle calculation of shape features separately\n if featureClassName == 'shape':\n continue\n\n if featureClassName in self.getFeatureClassNames():\n self.logger.info('Computing %s', featureClassName)\n\n featureClass = self.featureClasses[featureClassName](image, mask, **kwargs)\n\n if enabledFeatures is None or len(enabledFeatures) == 0:\n featureClass.enableAllFeatures()\n else:\n for feature in enabledFeatures:\n featureClass.enableFeatureByName(feature)\n\n featureClass.calculateFeatures()\n for (featureName, featureValue) in six.iteritems(featureClass.featureValues):\n newFeatureName = '%s_%s_%s' % (inputImageName, featureClassName, featureName)\n featureVector[newFeatureName] = featureValue\n\n return featureVector","def do_classify(img,mask,n_sigmas,multichannel,intensity,edges,texture,sigma_min,sigma_max, downsample_value):\n if np.ndim(img)==3:\n features = extract_features(\n img,\n n_sigmas,\n multichannel=multichannel,\n intensity=intensity,\n edges=edges,\n texture=texture,\n sigma_min=sigma_min,\n sigma_max=sigma_max,\n )\n else:\n features = extract_features(\n np.dstack((img,img,img)),\n n_sigmas,\n multichannel=multichannel,\n intensity=intensity,\n edges=edges,\n texture=texture,\n sigma_min=sigma_min,\n sigma_max=sigma_max,\n )\n\n if mask is None:\n raise ValueError(\"If no classifier clf is passed, you must specify a mask.\")\n training_data = features[:, mask > 0].T\n\n training_data = memmap_feats(training_data)\n\n training_labels = mask[mask > 0].ravel()\n\n training_data = training_data[::downsample_value]\n training_labels = training_labels[::downsample_value]\n\n lim_samples = 100000 #200000\n\n if training_data.shape[0]>lim_samples:\n logging.info('Number of samples exceeds %i'% lim_samples)\n ind = np.round(np.linspace(0,training_data.shape[0]-1,lim_samples)).astype('int')\n training_data = training_data[ind,:]\n training_labels = training_labels[ind]\n logging.info('Samples have been subsampled')\n logging.info('Number of samples in training data: %i' % (training_data.shape[0]))\n print(training_data.shape)\n\n clf = make_pipeline(\n StandardScaler(),\n MLPClassifier(\n solver='adam', alpha=1, random_state=1, max_iter=2000,\n early_stopping=True, hidden_layer_sizes=[100, 60],\n ))\n logging.info(datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\"))\n logging.info('Initializing MLP model')\n\n clf.fit(training_data, training_labels)\n logging.info(datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\"))\n logging.info('MLP model fit to data')\n\n del training_data, training_labels\n\n logging.info('Create and memory map model input data')\n\n data = features[:, mask == 0].T\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\n\n data = memmap_feats(data)\n logging.info('Memory mapped model input data')\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\n\n labels = clf.predict(data)\n logging.info(datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\"))\n logging.info('Model used on data to estimate labels')\n\n if mask is None:\n result = labels.reshape(img.shape[:2])\n result2 = result.copy()\n else:\n result = np.copy(mask)#+1\n result[mask == 0] = labels\n del labels, mask\n result2 = result.copy()\n del result\n\n logging.info(datetime.now().strftime(\"%Y-%m-%d-%H-%M-%S\"))\n logging.info('RF feature extraction and model fitting complete')\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\n\n return result2","def extract(self,image_path):#image_path\r\n\r\n img = caffe.io.load_image(image_path)\r\n \r\n #image1=cv2.imread(caffe_root + 'examples/images/cat.jpg') \r\n #img=cv2.cvtColor(image1,cv2.COLOR_BGR2RGB) \r\n #img=img/255. \r\n \r\n\r\n transformed_image = self.transformer.preprocess('data', img)\r\n self.net.blobs['data'].data[...] = transformed_image\r\n ft = self.net.forward()\r\n ft = np.squeeze(ft['pool5/7x7_s1'])\r\n ft = ft / LA.norm(ft)\r\n return ft","def _convert_to_features(self, img: np.ndarray) -> np.ndarray:","def sweep_image_model():\n for c1 in [4, 8, 16]:\n for c2 in [2, 4]:\n for c3 in [2, 4]:\n for c4 in [1, 2]:\n flags = flag_reader.read_flag()\n print(c1)\n flags.channel_list = c1 * np.array([1, c2, c2*c3, c2*c3*c4])\n print('channel list = ', flags.channel_list)\n flags.last_dim = flags.channel_list[-1]\n flags.model_name = flags.data_set + '_channel_' + str(flags.channel_list).replace('[','').replace(']','').replace(' ','_') + \\\n '_dim_last_' + str(flags.last_dim) + '_ind_' + str(flags.comp_ind) + \\\n '_lr_{}_decay_{}_reg_{}_bs_{}'.format(flags.lr, flags.lr_decay_rate, flags.reg_scale, flags.batch_size)\n print(flags.model_name)\n training_from_flag(flags)","def processImage(fpaths_src, label_map, fnames_src, img_idx):\n global counter\n \n n_imgs = len(fpaths_src)\n print(\"Processing %s -- %s/%s (%s%%)\"%(fnames_src[img_idx],counter,n_imgs,round(100.*counter/n_imgs)))\n \n path = fpaths_src[img_idx]\n src_image_raw = Image.open(path, 'r')\n \n # size normalization of the image\n if not (args.resize == None):\n src_image_raw = src_image_raw.resize(size=(int(args.resize), int(args.resize)), resample=Image.BILINEAR)\n \n # convert to writable numpy array\n src_image = np.asarray(src_image_raw, dtype=np.uint8)\n src_image.setflags(write=True)\n \n # some dummy label\n label = -99.99\n # the labels\n if not (label_map == {}):\n # let the label start at 1, instead of 0\n label = int(label_map[fnames_src[img_idx]])+1\n else:\n # add a dummy label (between 0 and 1)\n label = np.random.rand()\n \n image_features = []\n \n # add the original\n image_features.append(generateFeatures(src_image,label,args.knn))\n \n if args.augment == 1:\n print \"Augmenting dataset...\"\n # data augmentation techniques\n rotation_angles = [i for i in xrange(36,360,36)] # samples are transformed by these rotation angles\n \n flip_x = True # data augmentation by flipping around x axis\n flip_y = True # data augmentation by flipping around y axis\n flip_xy= True # data augmentation by flipping around x AND y axis\n \n for angle in rotation_angles:\n rot_matrix = cv2.getRotationMatrix2D(\n (src_image.shape[1]/2.,src_image.shape[0]/2.),\n angle,\n 1.0)\n rot_sample_crop = np.array([])\n rot_sample_crop = cv2.warpAffine(src_image,\n rot_matrix,\n (src_image.shape[1],src_image.shape[0]),\n rot_sample_crop,\n cv2.INTER_LINEAR,\n cv2.BORDER_REFLECT_101)\n \n # add the sample to the dataset\n image_features.append(generateFeatures(rot_sample_crop,label,args.knn))\n \n # add 3 flipped copies\n if flip_x:\n rot_sample_crop_x = cv2.flip(rot_sample_crop,0)\n image_features.append(generateFeatures(rot_sample_crop_x,label,args.knn))\n if flip_y:\n rot_sample_crop_y = cv2.flip(rot_sample_crop,1)\n image_features.append(generateFeatures(rot_sample_crop_y,label,args.knn))\n if flip_xy:\n rot_sample_crop_xy = cv2.flip(rot_sample_crop,-1)\n image_features.append(generateFeatures(rot_sample_crop_xy,label,args.knn))\n \n counter+=1\n\n # return a nx128 or nxk matrix for the features of all modifications of this image\n feat_matrix = np.asarray(image_features)\n return feat_matrix","def get_features(img1,mask1, depth1):\n colors = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)\n img3 = img1.copy()\n img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)\n img1 = clahe.apply(img1) # Applying Clahe\n kp, des = orb.detectAndCompute(img1, mask=mask1) # Computing ORB features\n kp_pts = np.float32([ kp[m].pt for m in range(len(kp))]).reshape(-1,2)\n # Getting Colors\n col = []\n for i in range(len(kp)):\n col.append(colors[kp_pts[i,1].astype(int), kp_pts[i,0].astype(int)])\n col = np.array(col)\n # Getting 2D points\n kp_2d = []\n for m in range(len(kp)):\n kp_2d.append([int(kp[m].pt[0]), int(kp[m].pt[1])])\n kp_2d = np.array(kp_2d).reshape(-1,2)\n \n # Getting the 3D points\n kp_3d, _, _ = convert_3d(kp_2d, depth1, img3)\n \n # Removing points with Zero depth\n my_ind = np.where(kp_3d[:,2]!=0)[0]\n new_kp_3d = kp_3d[my_ind,:]\n new_kp_2d = kp_2d[my_ind,:]\n new_des = des[my_ind,:]\n new_col = col[my_ind,:]\n \n # Removing the duplicates\n uni_3d = np.unique(new_kp_3d, return_index= True, axis=0)[1]\n new_kp_3d1 = new_kp_3d[uni_3d,:]\n new_kp_2d1 = new_kp_2d[uni_3d,:]\n new_des1 = new_des[uni_3d,:]\n new_col1 = new_col[uni_3d,:]\n return kp_3d, kp_2d, des, col","def forward(self, img):\n device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\n H, W = img.size()[2], img.size()[3]\n #print('x',x)\n #print('x.shape',x.shape) ## 32 x 3 x 96 x 128\n z32 = self.start(img)\n z64 = self.layer1(z32) + self.layer1_ds(z32)\n #print('z1',z64.shape)\n z128 = self.layer2(z64) + self.layer2_ds(z64)\n #print('z2',z128.shape)\n z256 = self.layer3(z128) + self.layer3_ds(z128)\n #print('z3',z256.shape)\n z256d = self.drop_out_layer(z256)\n #print('z_drop',z256d.shape)\n z256u = self.layer4(z256d)\n #print('z4',z256u.shape)\n z128u = self.layer5(torch.cat((z256u, F.interpolate(z256d,size=z256u.size()[2:] )), 1))\n #print('z5',z128u.shape)\n z64u = self.layer6(torch.cat((z128u, F.interpolate(z128,size=z128u.size()[2:] )), 1))\n #print('z6',z64u.shape)\n\n z32u = self.final(torch.cat((z64u, F.interpolate(z64,size=z64u.size()[2:] )), 1))\n #print('z6_plus',z32u.shape)\n\n #print('z7_result',self.classifer(z32u)[:, :, :H, :W].shape)\n result_class = self.classifer(z32u)[:, :, :H, :W]\n\n #print('model result shape',result_class.shape)\n ## 16 x 1 x 300 x 400\n\n # using soft argmax\n spa_argmax = spatial_argmax(torch.squeeze(result_class,1))\n\n #one hot with spatial argmax\n #xy_val = torch.zeros(spa_argmax.shape).float()\n #for idx, pt in enumerate(spa_argmax):\n # x_val = (pt[0]+1.0)*63.5\n # y_val = (pt[1]+1.0)*47.5\n # # for each batch. [0...127][0...95]\n # xy_val[idx][0] = x_val\n # xy_val[idx][1] = y_val\n\n xy_val = (spa_argmax+1.0).to(device)\n #print('spa_argmax',spa_argmax)\n scaling_factor = torch.FloatTensor([[(W-1)/2,0.],[0.,(H-1)/2]]).to(device)\n #scaling_factor = torch.FloatTensor([[63.5,0.],[0.,44.5]]).to(device)\n xy_val = xy_val.mm(scaling_factor)\n\n return xy_val","def forward(self, images):\n # assuming that the precomputed features are not already l2-normalized\n #x = l2norm(images.view( images.size(0), -1))\n #print(images.shape, self.fc )\n resnet_feat=torch.empty(len(images),2048)\n vse_feat=torch.empty(len(images),256)\n\n for idx, feat_concat in enumerate(images):\n #print(\"check\", feat_concat[:2048].shape, feat_concat[2048:].shape)\n resnet_feat[idx,:] = feat_concat[:2048]\n vse_feat[idx,:] = feat_concat[2048:]\n x1 = self.fc1(resnet_feat.cuda())\n\n x2 = self.relu(self.fc2(vse_feat.cuda()))\n x2 = self.relu(self.fc3(x2))\n x2 = self.scale(self.fc4(x2))\n #print(x2.shape, x1.shape, x1[:,:5000].shape)\n x = x1[:,:5000]+x2\n \n\n return x","def _process_feats_batch(self, output_reshaped, mask, scale_factor):\n\n # whole_proc = cutotime('whole processing').start()\n\n anchors = self.anchors_cuda[scale_factor]\n\n # TRY THIS\n\n# # Reshape to N, height, width, num_anchors, box_params:\n# box_wh = torch.exp(output_reshaped[:, ..., 2:4]) * anchors # 2, 3 - w, h\n# loh = torch.sigmoid(output_reshaped)\n# box_xy = loh[:, ..., :2] + self.grids[scale_factor] \n# box_xy /= self.sizes_cuda[scale_factor]\n# box_xy -= (box_wh / self.number_two)\n# boxes = torch.cat((box_xy, box_xy + box_wh), axis=-1)\n# out = boxes, loh[:, ..., 4:5], loh[:, ..., 5:]\n\n\n# FILTER BEFORE SIGMOIDS?\n box_xy = torch.sigmoid(output_reshaped[:, ..., :2]) # 0, 1 - x, y\n box_wh = torch.exp(output_reshaped[:, ..., 2:4]) * anchors # 2, 3 - w, h\n box_confidence = torch.sigmoid(output_reshaped[:, ..., 4:5]).flatten(end_dim=-2) # 4 - objectness\n box_class_probs = torch.sigmoid(output_reshaped[:, ..., 5:]).flatten(end_dim=-2) # 5, ... - classes probs\n box_xy += self.grids[scale_factor] \n box_xy /= self.sizes_cuda[scale_factor]\n box_xy -= (box_wh / self.number_two)\n boxes = torch.cat((box_xy, box_xy + box_wh), axis=-1).flatten(end_dim=-2)\n\n first_filter = torch.where(box_confidence >= self.object_threshold)\n #box_confidence = box_confidence[first_filter[:-1]]\n #box_class_probs = box_class_probs[first_filter[:-1]]\n #boxes = boxes[first_filter[:-1]]\n\n box_scores = box_confidence[first_filter[:-1]] * box_class_probs[first_filter[:-1]]\n box_class_scores = torch.max(box_scores, axis=-1)\n box_classes = box_class_scores.indices\n box_class_scores = box_class_scores.values\n pos = torch.where(box_class_scores >= self.object_threshold)\n# print(self.batch_inds[scale_factor].shape, boxes.shape)\n# print(self.batch_inds[scale_factor][first_filter[0]][pos[0]])\n# print(first_filter)\n# MAYBE BATCH_INDS SHOULD BE IN CPU????\n# print(pos)\n out = boxes[first_filter[:-1]][pos], box_classes[pos], box_class_scores[pos], self.batch_inds[scale_factor][first_filter[0]][pos[0]]\n #out = boxes[first_filter[:-1]][pos], box_classes[pos], box_class_scores[pos], first_filter[0][pos[0]]\n #out = boxes[pos], box_classes[pos], box_class_scores[pos], pos[0]\n# whole_proc.stop()\n\n# https://github.com/opencv/opencv/issues/17148\n# scale_x_y \n return out","def forward(self, images):\n features = self.resnet(images)\n features = Variable(features.data)\n features = self.pooling(features)\n # print(features)\n features = features.view(features.size(0),-1)\n # print(features)\n # print(resnet.fc.in_features)\n features = self.bn(self.linear(features))\n return features\n # with torch.no_grad():\n # features = self.resnet(images)\n # features = features.reshape(features.size(0), -1)\n # features = self.bn(self.linear(features))\n # return features","def extract_features(self, preprocessed_inputs, init_extraction=False):\n if init_extraction:\n preprocessed_inputs.get_shape().assert_has_rank(4)\n shape_assert = tf.Assert(\n tf.logical_and(tf.greater_equal(tf.shape(preprocessed_inputs)[1], 33),\n tf.greater_equal(tf.shape(preprocessed_inputs)[2], 33)),\n ['image size must at least be 33 in both height and width.'])\n with tf.control_dependencies([shape_assert]):\n with slim.arg_scope(self._conv_hyperparams):\n with tf.variable_scope('MobilenetV1',\n reuse=self._reuse_weights) as scope:\n _, image_features = mobilenet_v1.mobilenet_v1_base(\n preprocessed_inputs,\n final_endpoint='Conv2d_13_pointwise',\n min_depth=self._min_depth,\n depth_multiplier=self._depth_multiplier,\n scope=scope)\n feature_head = image_features['Conv2d_13_pointwise']\n feature_head = slim.conv2d(\n feature_head,\n 512, [3,3],\n stride=1,\n padding='SAME',\n scope='Conv2d_Append_1x1_256'\n )\n feature_head = tf.nn.avg_pool(feature_head, strides=[1,1,1,1], ksize=[1,4,4,1],\n padding='VALID', )\n return feature_head\n else:\n preprocessed_inputs.get_shape().assert_has_rank(4)\n shape_assert = tf.Assert(\n tf.logical_and(tf.greater_equal(tf.shape(preprocessed_inputs)[1], 33),\n tf.greater_equal(tf.shape(preprocessed_inputs)[2], 33)),\n ['image size must at least be 33 in both height and width.'])\n\n\n bottomup_features_names = [ 'Conv2d_11_pointwise', 'Conv2d_13_pointwise']\n num_appended_layers = 0\n #appended_channel_num = [512, 256, 256, 256]\n appended_channel_num = [512]\n\n with tf.control_dependencies([shape_assert]):\n with slim.arg_scope(self._conv_hyperparams):\n with tf.variable_scope('MobilenetV1',\n reuse=self._reuse_weights) as scope:\n _, image_features = mobilenet_v1.mobilenet_v1_base(\n preprocessed_inputs,\n final_endpoint='Conv2d_13_pointwise',\n min_depth=self._min_depth,\n depth_multiplier=self._depth_multiplier,\n scope=scope)\n\n topdown_features = self._topdown_feature_maps(\n image_features,\n bottomup_features_names=bottomup_features_names,\n num_appended_layers = num_appended_layers,\n appended_channel_num = appended_channel_num)\n return topdown_features.values()","def compute(\n self,\n image,\n exclude_center_feature: bool = False,\n exclude_center_value: bool = False,\n features: ndarray = None,\n feature_last_dim: bool = True,\n passthrough_channels: Optional[Tuple[bool]] = None,\n num_reserved_features: int = 0,\n excluded_voxels: Optional[List[Tuple[int]]] = None,\n spatial_feature_offset: Optional[Tuple[float, ...]] = None,\n spatial_feature_scale: Optional[Tuple[float, ...]] = None,\n ):\n\n with lsection('Computing features'):\n\n # some important numbers:\n num_dims = len(image.shape)\n num_spatiotemp_dim = num_dims - 2\n num_batches = image.shape[0]\n num_channels = image.shape[1]\n num_features = self.get_num_features(num_spatiotemp_dim)\n\n # exclude_center_value can be a tuple, in that case each entry corresponds to a channel:\n if type(exclude_center_value) is not tuple:\n exclude_center_value = (exclude_center_value,) * num_channels\n\n # Fills in the default values for passthrough channels: False ==> by default channels are not passthrough.\n if passthrough_channels is None:\n passthrough_channels = (False,) * num_channels\n\n # Computes the number of features, taking into account: passthrough_channels, channels, and reserved_features:\n num_passthrough_channels = sum(1 if p else 0 for p in passthrough_channels)\n num_normal_features = num_features * (\n num_channels - num_passthrough_channels\n )\n num_total_features = (\n num_normal_features + num_passthrough_channels + num_reserved_features\n )\n\n # Creates feature array that will hold the final result:\n features = self.create_feature_array(image, num_total_features)\n\n # We iterate over batches:\n for batch_index in range(num_batches):\n\n with lsection(\n f'Computing features for batch: {batch_index + 1}/{num_batches}'\n ):\n feature_pointer = 0\n\n # We iterate over channels:\n for channel_index in range(num_channels):\n\n with lsection(\n f'Computing features for channel: {channel_index + 1}/{num_channels}'\n ):\n # We collect the 'exclude_center_value' for the current channel:\n exclude_center_value_for_channel = exclude_center_value[\n channel_index\n ]\n\n lprint(\n f'Excluding center value for channel: {exclude_center_value_for_channel}'\n )\n\n # Image batch slice:\n image_slice = (\n batch_index,\n channel_index,\n *(slice(None),) * num_spatiotemp_dim,\n )\n\n lprint(f'Image slice: {image_slice}')\n\n if passthrough_channels[channel_index]:\n # A passthrough channel is simply fed directly as a feature:\n lprint(\n f'Adding passthrough channel feature for channel index: {channel_index}'\n )\n batch_feature_slice = (\n slice(feature_pointer, feature_pointer + 1, 1),\n batch_index,\n *(slice(None),) * num_spatiotemp_dim,\n )\n features[batch_feature_slice] = image[\n image_slice\n ].astype(self.dtype, copy=False)\n feature_pointer += 1\n\n else:\n single_image = image[image_slice]\n\n # Usefull code snippet for debugging features:\n # with napari.gui_qt():\n # viewer = Viewer()\n # viewer.add_image(image_batch_gpu.get(), name='image')\n # viewer.add_image(rescale_intensity(image_integral_gpu.get(), in_range='image', out_range=(0, 1)), name='integral')\n\n # Feature batch slice:\n batch_feature_slice = (\n slice(None),\n batch_index,\n *(slice(None),) * num_spatiotemp_dim,\n )\n lprint(\n f'Feature slice for batch and channel: {batch_feature_slice}'\n )\n\n batch_channel_features = features[batch_feature_slice]\n\n for feature_group in self.features_group_list:\n lprint(\n f'Computing feature {feature_group}, ' # , and kwargs={kwargs}'\n )\n\n # number of features in group:\n num_group_features = feature_group.num_features(\n num_spatiotemp_dim\n )\n\n # Excluded voxels:\n if excluded_voxels is None:\n excluded_voxels = []\n excluded_voxels_for_feature_group = []\n\n if exclude_center_value_for_channel:\n excluded_voxels_for_feature_group.extend(\n excluded_voxels\n )\n if (\n not (0,) * num_spatiotemp_dim\n in excluded_voxels_for_feature_group\n ):\n excluded_voxels_for_feature_group.append(\n (0,) * num_spatiotemp_dim\n )\n\n # We prepare feature generation for the group by setting the image,\n # any computation that can be factored should happen now:\n feature_group.prepare(\n single_image,\n excluded_voxels=excluded_voxels_for_feature_group,\n offset=spatial_feature_offset,\n scale=spatial_feature_scale,\n )\n\n for index in range(num_group_features):\n # feature array\n feature = batch_channel_features[\n feature_pointer\n ]\n\n # Computing the feature:\n feature_group.compute_feature(index, feature)\n\n # Increments feature index:\n feature_pointer += 1\n\n feature_group.finish()\n\n # # Usefull code snippet for debugging features:\n # import napari\n #\n # with napari.gui_qt():\n # from napari import Viewer\n #\n # viewer = Viewer()\n # viewer.add_image(features, name='features')\n\n # 'collect_features_nD' puts the feature vector in axis 0.\n # The following line creates a view of the array\n # in which the features are indexed by the last dimension instead:\n if feature_last_dim:\n lprint('Move feature axis to the last axis ...')\n features = numpy.moveaxis(features, 0, -1)\n\n return features","def create_GT_masks(root_dir, background_dir, intrinsic_matrix,classes):\n list_all_images = load_obj(root_dir + \"all_images_adr\")\n training_images_idx = load_obj(root_dir + \"train_images_indices\")\n for i in range(len(training_images_idx)):\n img_adr = list_all_images[training_images_idx[i]]\n label = os.path.split(os.path.split(os.path.dirname(img_adr))[0])[1]\n regex = re.compile(r'\\d+')\n idx = regex.findall(os.path.split(img_adr)[1])[0]\n\n if i % 1000 == 0:\n print(str(i) + \"/\" + str(len(training_images_idx)) + \" finished!\")\n\n image = cv2.imread(img_adr)\n ID_mask = np.zeros((image.shape[0], image.shape[1]))\n U_mask = np.zeros((image.shape[0], image.shape[1]))\n V_mask = np.zeros((image.shape[0], image.shape[1]))\n\n ID_mask_file = root_dir + label + \\\n \"/ground_truth/IDmasks/color\" + str(idx) + \".png\"\n U_mask_file = root_dir + label + \\\n \"/ground_truth/Umasks/color\" + str(idx) + \".png\"\n V_mask_file = root_dir + label + \\\n \"/ground_truth/Vmasks/color\" + str(idx) + \".png\"\n\n tra_adr = root_dir + label + \"/data/tra\" + str(idx) + \".tra\"\n rot_adr = root_dir + label + \"/data/rot\" + str(idx) + \".rot\"\n rigid_transformation = get_rot_tra(rot_adr, tra_adr)\n\n # Read point Point Cloud Data\n ptcld_file = root_dir + label + \"/object.xyz\"\n pt_cld_data = np.loadtxt(ptcld_file, skiprows=1, usecols=(0, 1, 2))\n ones = np.ones((pt_cld_data.shape[0], 1))\n homogenous_coordinate = np.append(pt_cld_data[:, :3], ones, axis=1)\n\n # Perspective Projection to obtain 2D coordinates for masks\n homogenous_2D = intrinsic_matrix @ (rigid_transformation @ homogenous_coordinate.T)\n coord_2D = homogenous_2D[:2, :] / homogenous_2D[2, :]\n coord_2D = ((np.floor(coord_2D)).T).astype(int)\n x_2d = np.clip(coord_2D[:, 0], 0, 639)\n y_2d = np.clip(coord_2D[:, 1], 0, 479)\n ID_mask[y_2d, x_2d] = classes[label]\n\n if i % 100 != 0: # change background for every 99/100 images\n background_img_adr = background_dir + random.choice(os.listdir(background_dir))\n background_img = cv2.imread(background_img_adr)\n background_img = cv2.resize(background_img, (image.shape[1], image.shape[0]), interpolation=cv2.INTER_AREA)\n background_img[y_2d, x_2d, :] = image[y_2d, x_2d, :]\n background_adr = root_dir + label + \"/changed_background/color\" + str(idx) + \".png\"\n mpimg.imsave(background_adr, background_img)\n\n # Generate Ground Truth UV Maps\n centre = np.mean(pt_cld_data, axis=0)\n length = np.sqrt((centre[0]-pt_cld_data[:, 0])**2 + (centre[1] -\n pt_cld_data[:, 1])**2 + (centre[2]-pt_cld_data[:, 2])**2)\n unit_vector = [(pt_cld_data[:, 0]-centre[0])/length, (pt_cld_data[:,\n 1]-centre[1])/length, (pt_cld_data[:, 2]-centre[2])/length]\n U = 0.5 + (np.arctan2(unit_vector[2], unit_vector[0])/(2*np.pi))\n V = 0.5 - (np.arcsin(unit_vector[1])/np.pi)\n U_mask[y_2d, x_2d] = U\n V_mask[y_2d, x_2d] = V\n\n # Saving ID, U and V masks after using the fill holes function\n ID_mask, U_mask, V_mask = fill_holes(ID_mask, U_mask, V_mask)\n cv2.imwrite(ID_mask_file, ID_mask)\n mpimg.imsave(U_mask_file, U_mask, cmap='gray')\n mpimg.imsave(V_mask_file, V_mask, cmap='gray')","def extractFeatures(image, feature_list):\n # for multiple features or color features\n #feat_vec = np.array([])\n \n # sift has 128D\n feat_vec = np.empty((0,128))\n n_channels = (image.shape[2] if len(image.shape)==3 else 1)\n \n #img_f32 = image.astype(np.float32)\n\n for feature in feature_list:\n if (feature.strip().lower() == 'dsift'):\n print \"computing dsift (dense rootSift) features\"\n dense = cv2.FeatureDetector_create(\"Dense\")\n sift = cv2.SIFT()\n if n_channels == 1:\n kp = dense.detect(image[:,:])\n # compute kp descriptors\n _,des = sift.compute(image[:,:],kp)\n \n # normalize the descriptors (L1)\n des /= (des.sum(axis=1, keepdims=True) + 1e-7)\n des = np.sqrt(des)\n \n feat_vec = np.vstack((feat_vec, des))\n else:\n for channel in xrange(n_channels):\n kp = dense.detect(image[:,:,channel])\n _,des = sift.compute(image[:,:,channel],kp)\n \n # normalize the descriptors (L1)\n des /= (des.sum(axis=1, keepdims=True) + 1e-7)\n des = np.sqrt(des)\n\n feat_vec = np.vstack((feat_vec, des))\n \n# if (feature.strip().lower() == 'color'):\n# print \"computing color features\"\n# # scale from 0-255 between 0 and 1\n# if args.scale == 1:\n# img_f32 /= 255.\n# \n# f_tmp = img_f32.flatten()\n# feat_vec = np.append(feat_vec, f_tmp)\n else:\n raise Exception(\"Method '%s' is not implemented!\"%(feature)) \n \n return feat_vec","def _make_features(self):\n self.features = {}\n self.labels = {}\n for key in ['train', 'cv', 'test']:\n if self.radius is not None:\n feat, label = self._sliding_window(self.images[key], self.masks[key], window_radius=self.radius)\n self.features[key] = feat\n self.labels[key] = label\n else:\n self.features[key] = self.images[key].reshape(-1, 3)\n self.labels[key] = self.masks[key].ravel()","def forward(self, images):\n # assuming that the precomputed features are not already l2-normalized\n #x = l2norm(images.view( images.size(0), -1))\n #print(images.shape, self.fc )\n resnet_feat=torch.empty(len(images),2048)\n vse_feat=torch.empty(len(images),256)\n\n for idx, feat_concat in enumerate(images):\n #print(\"check\", feat_concat[:2048].shape, feat_concat[2048:].shape)\n #resnet_feat[idx,:] = feat_concat[:2048]\n vse_feat[idx,:] = feat_concat[2048:]\n x = self.relu(self.fc1(vse_feat.cuda()))\n x = self.relu(self.fc2(x))\n x = self.fc3(x)\n\n return x","def main():\n feature_extraction_model = \"HOG\"\n # feature_extraction_models = [\"CM\", \"HOG\"]\n feature_extraction_model_1 = \"CM\"\n dimension_reduction_model = \"PCA\"\n k_value = 10\n dim_k_value = 40\n # K_value = 20\n # lab_folder = \"Dataset3/Labelled/Set1\"\n # unlab_folder = \"Dataset3/Unlabelled/Set 2\"\n lab_folder = get_input_folder(\"Labelled Folder\")\n unlab_folder = get_input_folder(\"Classify\")\n start = time.time()\n # ================================================================================================================\n # labelled Images\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\n folder_metadata=lab_folder,\n metadata_collection=\"labelled\")\n obj_feat_lab = dim_red.get_object_feature_matrix()\n features_list_lab = np.array(obj_feat_lab['featureVector'].tolist())\n images_list_lab = np.array(obj_feat_lab['imageId'])\n # filtering the labelled set\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\n\n # unlabelled images\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\n folder_metadata=unlab_folder,\n metadata_collection=\"unlabelled\")\n obj_feat_unlab = dim_red.get_object_feature_matrix()\n features_list_unlab = np.array(obj_feat_unlab['featureVector'].tolist())\n images_list_unlab = np.array(obj_feat_unlab['imageId'])\n\n # ================================================================================================================\n # labelled Images\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\n folder_metadata=lab_folder,\n metadata_collection=\"labelled\")\n obj_feat_lab_1 = dim_red.get_object_feature_matrix()\n features_list_lab_1 = np.array(obj_feat_lab_1['featureVector'].tolist())\n # images_list_lab = np.array(obj_feat_lab_1['imageId'])\n # filtering the labelled set\n\n\n # unlabelled images\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\n folder_metadata=unlab_folder,\n metadata_collection=\"unlabelled\")\n obj_feat_unlab_1 = dim_red.get_object_feature_matrix()\n features_list_unlab_1 = np.array(obj_feat_unlab_1['featureVector'].tolist())\n # images_list_unlab = np.array(obj_feat_unlab['imageId'])\n features_list_lab = np.concatenate((features_list_lab, features_list_lab_1), axis=1)\n features_list_unlab = np.concatenate((features_list_unlab, features_list_unlab_1), axis=1)\n\n # ================================================================================================================\n\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\n features_list = np.concatenate((features_list_lab, features_list_unlab))\n images_list = np.concatenate((images_list_lab, images_list_unlab))\n images_list = list(images_list)\n # Finding Similarity Matrix\n cos_sim = cosine_similarity(features_list)\n sim_graph = np.empty((0, len(cos_sim)))\n for row in cos_sim:\n k_largest = np.argsort(-np.array(row))[1:k_value + 1]\n sim_graph_row = [d if i in k_largest else 0 for i, d in enumerate(row)]\n sim_graph = np.append(sim_graph, np.array([sim_graph_row]), axis=0)\n\n row_sums = sim_graph.sum(axis=1)\n sim_graph = sim_graph / row_sums[:, np.newaxis]\n idx = 0\n results_dorsal = ppr(sim_graph, images_list, dorsal_list)\n results_palmar = ppr(sim_graph, images_list, palmar_list)\n final_results = {}\n\n for img in images_list_unlab:\n if results_dorsal[img] < results_palmar[img]:\n final_results[img] = \"dorsal\"\n else:\n final_results[img] = \"palmar\"\n\n actual_labels = fetch_actual_labels(images_list_unlab)\n print(\"Classification\")\n no_correct = 0\n correctly_classified = []\n incorrectly_classified = []\n print(\"| ImageId | Prediction | Actual |\")\n for r in final_results:\n print(\"| {} | {} | {} |\".format(r, final_results[r], actual_labels[r]))\n if final_results[r] == actual_labels[r]:\n correctly_classified.append(r)\n no_correct += 1\n else:\n incorrectly_classified.append(r)\n\n print(\"Correctly classified: {}\\n\".format(correctly_classified))\n print(\"InCorrectly classified: {}\\n\".format(incorrectly_classified))\n\n print(\"Classification Accuracy: {}%\".format(no_correct / len(images_list_unlab) * 100))\n print(\"Execution time: {} seconds\".format(time.time() - start))","def all_feature_extractor(imgpath):\r\n\r\n image = cv2.imread(imgpath)\r\n image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\r\n\r\n # Extracting Gabor Features\r\n feature_dict = gabor_feature_extractor(image)\r\n\r\n feature_dict['Original'] = image\r\n\r\n entropy_img = entropy(image, disk(1))\r\n feature_dict['Entropy'] = entropy_img\r\n\r\n gaussian3_img = nd.gaussian_filter(image, sigma=3)\r\n feature_dict['Gaussian3'] = gaussian3_img\r\n\r\n gaussian7_img = nd.gaussian_filter(image, sigma=7)\r\n feature_dict['Gaussian7'] = gaussian7_img\r\n\r\n sobel_img = sobel(image)\r\n feature_dict['Sobel'] = sobel_img\r\n\r\n canny_edge_img = cv2.Canny(image, 100, 200)\r\n feature_dict['Canny'] = canny_edge_img\r\n\r\n robert_edge_img = roberts(image)\r\n feature_dict['Robert'] = robert_edge_img\r\n\r\n scharr_edge = scharr(image)\r\n feature_dict['Scharr'] = scharr_edge\r\n\r\n prewitt_edge = prewitt(image)\r\n feature_dict['Prewitt'] = prewitt_edge\r\n\r\n median_img = nd.median_filter(image, size=3)\r\n feature_dict['Median'] = median_img\r\n\r\n variance_img = nd.generic_filter(image, np.var, size=3)\r\n feature_dict['Variance'] = variance_img\r\n\r\n return feature_dict","def preprocess_train(im, boxes, classes, inst_masks, mask, input_size, min_size=2,\n use_augment=False, training_scale=[0.3, 0.5, 0.7, 1.0]):\n ori_im = np.copy(im)\n target_h, target_w = input_size\n\n # ---------- old data_augmentation ----------\n if use_augment:\n if np.random.choice([0, 1]) != 0:\n scale = np.random.choice(training_scale) # adding more small objects\n im, inst_masks, mask, boxes, classes = random_scale(im, inst_masks, mask, boxes, classes, scale=scale)\n min_obj_cover = np.random.choice([0.8, 0.9, 1.0])\n # truncted examples may lead to multiple-detections..\n im, inst_masks, mask, boxes, classes = random_aspect_ratio(im, inst_masks, mask, boxes, classes,\n min_aspect_ratio=0.5, max_aspect_ratio=2.0,\n min_obj_cover=min_obj_cover)\n #\n # # r = np.random.randint(0, 3)\n # if np.random.rand() < 0.75:\n # im, inst_masks, mask, boxes, classes = fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w)\n # else:\n # im, inst_masks, mask, boxes, classes = center_crop2fixed_pad(im, inst_masks, mask, boxes, classes, target_w, target_h,\n # min_size=min_size)\n\n # ---------- old data_augmentation ----------\n\n # ---------- none data_augmentation ----------\n im, inst_masks, mask, boxes, classes = fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w)\n im, inst_masks, mask, boxes, classes = random_flip(im, inst_masks, mask, boxes, classes)\n # ---------- none data_augmentation ----------\n\n # ---------- old data_augmentation ----------\n im = distort_color(im)\n # ---------- old data_augmentation ----------\n\n im = imcv2_recolor(im)\n\n # add this because zeros numpy array will cause errors in torch Dataloader\n inst_masks = np.zeros([1, target_h, target_w], dtype=inst_masks.dtype) if inst_masks.size == 0 else inst_masks\n\n boxes = np.asarray(boxes, dtype=np.float32)\n return im, boxes, classes, inst_masks, mask, ori_im","def collect_features(image, features, variables, vertical_flip=True, urban_only=False):\n node2feature = {}\n pos2node = {}\n node_ind = 0\n pq0, a2, a3, a4 = 379.90516, 17.2693882, 273.16, 35.86 # for Relative Humidity calculation\n \n for i in range(image.shape[0]):\n for j in range(image.shape[1]):\n\n tmp_index = image[i,j]\n if tmp_index == 0:\n # 0 index is dummy index.\n continue\n \n if urban_only:\n if tmp_index == 31 or tmp_index == 32 or tmp_index == 33:\n pass\n else:\n continue\n\n tmp_dict = {'LU_INDEX': tmp_index.item(), 'ij_loc': (i,j)}\n\n for f in features:\n if f in {'T2','ALBEDO','RAINNC','PBLH','Q2','PSFC'}: # 3D time varying\n if vertical_flip:\n tmp_dict[f] = np.array(variables[f][:,-i-1,j])\n else:\n tmp_dict[f] = np.array(variables[f][:,i,j])\n elif f in {'U','V','SMOIS'}: # 4D time varying\n if vertical_flip:\n tmp_dict[f] = np.array(variables[f][:,0,-i-1,j])\n else:\n tmp_dict[f] = np.array(variables[f][:,0,i,j])\n elif f in {'XLAT','XLONG','FRC_URB2D','VEGFRA'}: # 3D time invariant\n if vertical_flip:\n tmp_dict[f] = variables[f][0,-i-1,j].item() #\n else:\n tmp_dict[f] = variables[f][0,i,j].item() #\n else:\n pass # RH2 will be calculated later\n\n # manually calculate relative humidity\n q2 = tmp_dict['Q2']\n t2 = tmp_dict['T2']\n psfc = tmp_dict['PSFC']\n tmp_dict['RH2'] = q2 / ( (pq0 / psfc) * np.exp(a2*(t2 - a3) / (t2 - a4)) )\n\n node2feature[node_ind] = tmp_dict\n pos2node[(i,j)] = node_ind\n node_ind += 1\n\n return node2feature, pos2node","def _featurize(self, img):\n self._classifier.predict(img)\n return self._classifier.get_features()","def Adjust_Data(img,mask,feature_dict, normalize):\n ## Normalize image\n if normalize:\n img = Normalize_Image(img)\n\n ## Assume mask shape has 4 dimensions - mask is (batch, x, y, color-channel)\n ## color-channels are redundant, so just choose the first. \n mask = mask[:,:,:,0]\n \n ## Image_datagen performs interpolation when rotating, resulting in non-integer\n ## mask values. Round these back to integers before expanding the mask. \n mask = mask.round() \n mask = Expand_Mask(mask, feature_dict)\n #print(mask.shape, np.unique(mask, axis = 0))\n return (img,mask)","def training_features(orientation=8, pix_per_cell=8, cell_per_block=2,\n spatial_size=16, hist_bins=32, color_space='HLS', sample_window=64,\n channels=[0], debug=False):\n def extract(paths, augment=False): # extract and augment\n features = []\n for file in paths:\n image = utils.imread_scaled_unified(file)\n if color_space != ident_config['default_color_space']:\n image_color_converted = cv2.cvtColor(\n image,\n eval('cv2.COLOR_' + ident_config['default_color_space'] + '2' + color_space))\n else:\n image_color_converted = image\n # End of if color_space\n\n image_resized = cv2.resize(image_color_converted, (sample_window, sample_window))\n if augment:\n brightened = utils.brighten(image_resized, bright=1.2)\n flipped = cv2.flip(utils.brighten(image_resized, bright=1.1), 1) # horizontal flip\n to_process = [brightened, flipped]\n else:\n to_process = [image_resized]\n # End of if augment\n\n for x in to_process: # must use square bracket for single element in list to iterate\n # using tuple, it will iterate the single image's row dimension. \n hog_features = utils.get_hog_features_channels(\n x, orientation, pix_per_cell, cell_per_block, channels)\n spatial_features, hist_features = utils.color_features(\n x, spatial_size=spatial_size, hist_bins=hist_bins, channels=channels)\n image_features = np.hstack(\n (spatial_features, hist_features, hog_features)).reshape(1, -1)\n image_features = np.squeeze(image_features)\n # remove the redundant dimension, StandardScaler does not like it\n features.append(image_features)\n # End of for x ...\n # End of for file\n return features\n cars, noncars, cars_to_be_augmented, num_cars, num_noncars = samples_sorted()\n num_samples = 30000 # limit the number of samples to be selected from each group.\n print('num_cars: ', num_cars, ' num_noncars: ', num_noncars, ' max. samples: ', 3*num_samples)\n\n car_features = extract(cars[:min(num_samples, len(cars))], augment=False)\n car_augmented_features = extract(cars_to_be_augmented[:min(num_samples, len(cars_to_be_augmented))], augment=True)\n noncar_features = extract(noncars[:min(num_samples, len(noncars))], augment=False)\n\n # Create an array stack of feature vectors\n X = np.vstack((car_features, car_augmented_features, noncar_features)).astype(np.float64)\n # Fit a per-column scaler\n X_scaler = StandardScaler().fit(X)\n # Apply the scaler to X\n scaled_X = X_scaler.transform(X)\n del X # X, scaled_X consumes much memory, should be released ASAP.\n # Define the labels vector\n y = np.hstack((np.ones(len(car_features) + len(car_augmented_features)), np.zeros(len(noncar_features))))\n\n # Split up data into randomized training and test sets\n rand_state = np.random.randint(0, 100)\n X_train, X_test, y_train, y_test = train_test_split(\n scaled_X, y, test_size=0.1, random_state=rand_state)\n return X_train, X_test, y_train, y_test, X_scaler","def extract_feat(self, imgs):\n pass","def extract_feat(self, imgs):\n pass","def forward_train(self, imgs, label, token_ids=None, segment_ids=None, input_mask=None, ans_ids=None, ans_mask=None, **kwargs):\n # (batch_size, num_clips*num_crops, channel, num_segments, h, w) -> (batch_size*num_clips*num_crops, channel, num_segments, h, w)\n imgs = imgs.reshape((-1, ) + imgs.shape[2:]) \n if self.from_scratch:\n imgs = imgs / 255.0\n B_text = token_ids.shape[0]\n # text reshape: (batch_size, num_candidates, seq_length) -> (batch_size * num_candidates, seq_length)\n token_ids = token_ids.reshape((-1, ) + token_ids.shape[2:])\n segment_ids = segment_ids.reshape((-1, ) + segment_ids.shape[2:])\n input_mask = input_mask.reshape((-1, ) + input_mask.shape[2:])\n losses = dict()\n visual_token = self.extract_visual_feat(imgs) # b, d, T, h, w\n B, D, T, H, W = visual_token.shape\n if B_text != B:\n visual_token = visual_token.view(B_text, -1, D, T, H, W)\n visual_token = visual_token.mean(dim=1)\n \n # text feature #\n text_out_with_mask = self.text_backbone(token_ids, input_mask)\n text_out_last_hidden_state = text_out_with_mask['last_hidden_state']\n\n # contrastive type finetuning retrieval #\n if self.task == 'retrieval':\n # text_only_out = self.text_backbone(token_ids, input_mask)\n visual_emb, text_emb = self.ssl_head(visual_token, text_out_last_hidden_state, input_mask, token_ids)\n nce_loss = self.loss_func(visual_emb, text_emb)\n losses['retrieval_nce_loss'] = nce_loss \n elif self.task == 'video_qa' or self.task == 'FIB':\n B, D, T, H, W = visual_token.shape\n visual_token = visual_token.view(B, D, T, -1).permute(0, 2, 3, 1)\n if hasattr(self.qa_head, 'num_labels'):\n num_choices = self.qa_head.num_labels\n visual_token_all = visual_token\n else:\n num_choices = int(token_ids.shape[0] / B)\n visual_token_all = visual_token.unsqueeze(1).expand(-1, num_choices, -1, -1, -1).flatten(0,1)\n\n output = self.multimodal_backbone(visual_token=visual_token_all, text_input_mask=input_mask, text_input_embeds=text_out_last_hidden_state)\n \n if self.answer_mask:\n mask_idx = torch.where(token_ids == 103)\n itm_output = output['t_last_hidden_state'][mask_idx]\n elif self.answer_cls:\n if 'cls_last_hidden_state' in output:\n itm_output = output['cls_last_hidden_state'].squeeze()\n else:\n itm_output = output['t_last_hidden_state'][:, 0]\n if self.itm_head is not None:\n itm_output = self.itm_head(itm_output)\n\n else:\n all_cls_emb = output['last_hidden_state'][:, 0]\n itm_output = self.itm_head(all_cls_emb)\n \n if self.qa_head is not None:\n final_output = self.qa_head(itm_output).view(-1, num_choices)\n final_label = label\n else:\n final_output = itm_output[:, 1]\n final_label = label\n\n\n qa_loss = self.loss_func(final_output, final_label.view(-1))\n losses['qa_loss'] = qa_loss\n\n\n\n return losses","def get_local_features(self, img):\n kp, des = self.fe.detectAndCompute(img, None)\n return kp, des","def Get_Label_Features(mask_in, feature_dict, convert_length = 0.2204315, eps_factor = 0.025, area_thresh = 2): \n\n nfeatures = len(feature_dict)\n Image_Features = pd.DataFrame({'Type':[],'Feature_Area':[], 'x':[], 'y':[]})\n Contours_List = []\n\n # Expand mask into one-hot mask if input is flat\n if len(mask_in.shape)==2:\n mask_in = Expand_Mask(mask_in, feature_dict = feature_dict)\n \n # Loop through mask layers (i.e., feature types) and calculate contours \n for i in range(nfeatures):\n Contours_List.append(list()) \n for ii in feature_dict.keys():\n nii = int(ii)\n mask = mask_in[:,:,nii] \n mask = 255*mask.round().astype('uint8')\n mask = np.stack((mask,mask, mask),-1)\n mask = cv2.cvtColor(mask, cv2.COLOR_RGB2GRAY);\n ret, thresh = cv2.threshold(mask, 127.5, 255, cv2.THRESH_BINARY)\n contours,hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\n for cnt in contours:\n # arcLength args: Contours, flag of whether curve is closed or not\n epsilon = eps_factor*cv2.arcLength(cnt,True)\n # approxPolyDP args: Contours, epsilon for wiggliness, closed shape or not\n approx = cv2.approxPolyDP(cnt,epsilon,True)\n # Extract area and convert to square meters \n area = convert_length**2 * cv2.contourArea(approx)\n if area > area_thresh: ## Filter small features / noise\n ## Compute centroid from moments\n M = cv2.moments(cnt)\n cx = int(M['m10']/(1e-5 + M['m00']))*convert_length\n cy = int(M['m01']/(1e-5 + M['m00']))*convert_length\n Image_Features = Image_Features.append({'Type':feature_dict[ii], 'Feature_Area':area, \n 'x':cx, 'y':cy}, ignore_index = True)\n Contours_List[nii].append(cnt)\n return Contours_List, Image_Features.copy()","def data_augmentation_and_vectorization(self,imlist, lb,im_labels, average_image = None):\n\t\tX,Y,X_original = [] ,[], []\n\n\t\ti = 0\n\t\tfor im in imlist:\n\t\t\tim=Image.fromarray(im,mode=self.mode)\n\t\t\t#try:\n\t\t\t#im_ini = im\n\t\t\tim_original = np.asarray(im, dtype=theano.config.floatX) / 256.\n\t\t\t#im = self.substract_average_image(im, average_image)\n\t\t\t#print 'i:{} is a: {}' .format(i,im_labels[i])\n\t\t\t#im.show()\n\t\t\tX_original.append(im_original)\n\n\t\t\t#Rotations \n\t\t\t#im_r = im.rotate(15)\n\t\t\t# im_r_2 = im.rotate(-15)\n\t\t\t# im_r_3 = im.rotate(180)\n\t\t\t#im_r.show()\n\t\t\t#im_r_2.show()\n\n\t\t\t#Filters\n\t\t\t#im_f = im_ini.filter(ImageFilter.DETAIL)\n\t\t\t#im_f = im.filter(ImageFilter.FIND_EDGES)\n\t\t\t\n\t\t\tif self.mode == 'RGB':\n\t\t\t\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\n\t\t\t\t#Uncomment this if you want to use cross-correlate for 2D arrays http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.signal.correlate2d.html\n\t\t\t\t# im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\t# im = sp.inner(im, [299, 587, 114]) / 1000.0\n\t\t\t\t# im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\n\t\t\t\t# im = (im - im.mean()) / im.std()\n\n\t\t\tif self.mode == 'L':\n\t\t\t\t# im = np.asarray(im, dtype='float64')\n\t\t\t\t# im = filters.sobel(im)\n\t\t\t\t#im = filters.roberts(im)\n\t\t\t\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\n\t\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\n\t\t\t#im = np.asarray(im, dtype=np.uint8)\n\t\t\t#print im.shape\n\t\t\t#print im.shape\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t#im = self.flaten_aux(im)\n\t\t\t#print im.shape\n\t\t\t#im = data.coins() # or any NumPy arr\n\t\t\t#print im.shape\n\t\t\t#image = data.coins() # or any NumPy array!\n\t\t\t#print im\n\t\t\t#im = filter.sobel(im)\n\t\t\t#im = filter.roberts(im)\n\n\t\t\t# im_original = sp.inner(im, [299, 587, 114]) / 1000.0\n\t\t\t# im_original = np.asarray(im_original, dtype=theano.config.floatX)\n\t\t\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\n\t\t\t# im = (im_original - im_original.mean()) / im_original.std()\n\t\t\t#print im.shape\n\t\t\t#print edges\n\t\t\t# edges = np.asarray(edges, dtype=np.uint8)\n\t\t\t#Image.fromarray(edges,mode=self.mode).show()\n\n\t\t\t#print edges\n\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX) / 256.\n\n\t\t\t#print edges.shape\n\t\t\t# io.imshow(im)\n\t\t\t# io.show()\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t\n\t\t\t# plt.suptitle(im_labels[i], size=16)\n\t\t\t# plt.imshow(im, cmap=plt.cm.gray, interpolation='nearest')\n\t\t\t# plt.show()\n\t\t\t#im = np.asarray(im, dtype=theano.config.floatX)\n\t\t\t#print im.shape\n\t\t\t#self.reconstructImage(im).show()\n\n\t\t\t#im_r = np.asarray(im_r, dtype=theano.config.floatX) / 256.\n\t\t\t# im_r_2 = np.asarray(im_r_2, dtype=theano.config.floatX) / 256.\n\t\t\t# im_r_3 = np.asarray(im_r_3, dtype=theano.config.floatX) / 256.\n\t\t\t#im_f = np.asarray(im_f, dtype=theano.config.floatX) / 256.\n\t\t\t\n\t\t\t#im = im.transpose(2, 0, 1)\n\t\t\t#X.append(np.array(im, dtype=theano.config.floatX))\n\t\t\t#X.append(np.array(im_raw, dtype=theano.config.floatX))\n\t\t\t#X.append(im)\n\t\t\tX.append(im)\n\t\t\t# if i % 100 == 0:\n\t\t\t# \tX.append(im)\n\t\t\t#X.append(im_r)\n\t\t\t# X.append(im_r_2)\n\t\t\t# X.append(im_r_3)\n\t\t\t#X.append(im_f)\n\t\t\t#X_original.append(im)\n\n\t\t\t# X.append(np.array(im_r, dtype=theano.config.floatX))\n\t\t\t# X.append(np.array(im_r_2, dtype=theano.config.floatX))\n\n\t\t\t#Uncomment this if you want to work with monochrome\n\t\t\t# im = im.convert('L')\n\t\t\t# pixels_monochrome = np.array(list(im.getdata()), dtype=np.float)\n\t\t\t\t\t\t\n\t\t\t# # scale between 0-1 to speed up computations\n\t\t\t# min_max_scaler = preprocessing.MinMaxScaler(feature_range=(0,1), copy=True)\n\t\t\t# pixels_monochrome = min_max_scaler.fit_transform(pixels_monochrome)\n\n\t\t\t# X.append(pixels_monochrome)\n\n\t\t\t#Y.append(lb.transform([im_labels[i]])[0][0])\n\t\t\t#print lb.transform([im_labels[i]])\n\t\t\t\n\t\t\tlabel = lb.transform([im_labels[i]])[0][0]\n\t\t\t#print lb.transform([im_labels[i]])\n\t\t\t# label_vector = lb.transform([im_labels[i]])[0]\n\t\t\t# label = np.where( label_vector == 1 )[0][0]\n\t\t\t# print \"Label: {}\".format(label)\n\t\t\t#print label\n\t\t\t#Y.append(label)\n\t\t\tY.append(label)\n\t\t\t#Y.append(im_labels[i])\t\n\n\t\t\t\n\t\t\t#Y.append(label)\t\n\t\t\t# Y.append(label)\t\n\t\t\t# except Exception, e:\n\t\t\t# \tprint e\n\t\t\t# \t#raise e\n\n\t\t\t# if i == 30:\n\t\t\t# \tbreak\n\n\t\t\ti += 1\n\t\t\tif self.verbose:\n\t\t\t\tsys.stdout.write(\"\\r Process: {0}/{1}\".format(i, len(imlist)))\n\t\t\t\tsys.stdout.flush()\n\t\t\n\t\t# output = open(self.data_path + 'X_original.pkl', 'wb')\n\t\t# cPickle.dump(X_original, output,protocol=-1)\n\t\t# output.close()\n\n\t\treturn X,Y","def data_assemble(self, x,y, r_cut, add_mask=5, pick_choice=False):\n #segmentation components\n obj_masks,center_mask_info, segments_deblend_list = self._seg_image(x, y, r_cut=r_cut)\n data_masks_center, _, xcenter, ycenter, c_index = center_mask_info\n image = self.cut_image(x,y,r_cut)\n self.raw_image = image\n src_mask = np.zeros_like(image)\n lens_mask = np.zeros_like(image)\n plu_mask = np.zeros_like(image)\n lenslight_mask_index = []\n if self.segmap is not None and self.interaction:\n segmap=self.segmap[0].data\n segdata = segmap[x - r_cut:x + r_cut + 1, y - r_cut:y + r_cut + 1]\n plt.imshow(segdata, origin='lower')\n nlabel = np.unique(segdata)\n for i in range(nlabel.shape[0] - 1):\n ax = (int((np.where(segdata == nlabel[i + 1])[0].max() - np.where(segdata == nlabel[i + 1])[0].min()) / 2 +\n np.where(segdata == nlabel[i + 1])[0].min()))\n ay = (int((np.where(segdata == nlabel[i + 1])[1].max() - np.where(segdata == nlabel[i + 1])[1].min()) / 3 +\n np.where(segdata == nlabel[i + 1])[1].min()))\n plt.text(ay, ax, repr(nlabel[i + 1]), color='r', fontsize=15)\n plt.title('Input segmentation map')\n plt.show()\n source_mask_index = [int(sidex) for sidex in input('Selection of data via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\n for i in source_mask_index:\n src_mask = src_mask + segdata*(segdata==i*1)\n # lens light\n lenslightyn = input('Hint: is there lens light? (y/n): ')\n if lenslightyn == 'y':\n lenslight_mask_index = [int(lidex) for lidex in input('Selection of lens-plane light via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\n for i in lenslight_mask_index:\n lens_mask = (lens_mask + segdata*(segdata==i*1))\n elif lenslightyn == 'n':\n lenslight_mask_index = []\n else:\n raise ValueError(\"Please input 'y' or 'n' !\")\n # contamination\n pluyn = input('Hint: is there contamination? (y/n): ')\n if pluyn == 'y':\n plution_mask_index = [int(pidex) for pidex in input('Selection of contamination via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\n for i in plution_mask_index:\n plu_mask = (plu_mask + segdata*(segdata==i*1))\n elif pluyn == 'n':\n plu_mask = np.zeros_like(image)\n else:\n raise ValueError(\"Please input 'y' or 'n' !\")\n\n\n\n if self.segmap is None and self.interaction:\n self.plot_segmentation(image, segments_deblend_list, xcenter, ycenter, c_index)\n #source light\n if pick_choice:\n source_mask_index = [int(sidex) for sidex in input('Selection of data via segmentation index separated by space, e.g., 0 1 :').split()]\n for i in source_mask_index:\n src_mask = src_mask + obj_masks[i]\n #lens light\n lenslightyn = input('Hint: is there lens light? (y/n): ')\n if lenslightyn == 'y':\n lenslight_mask_index = [int(lidex) for lidex in input('Selection of lens-plane light via segmentation index separated by space, e.g., 0 1 :').split()]\n for i in lenslight_mask_index:\n lens_mask = (lens_mask + obj_masks[i])\n elif lenslightyn == 'n':\n lenslight_mask_index = []\n else:\n raise ValueError(\"Please input 'y' or 'n' !\")\n # contamination\n pluyn = input('Hint: is there contamination? (y/n): ')\n if pluyn == 'y':\n plution_mask_index = [int(pidex) for pidex in input('Selection of contamination via segmentation index separated by space, e.g., 0 1 :').split()]\n for i in plution_mask_index:\n plu_mask = (plu_mask + obj_masks[i])\n elif pluyn == 'n':\n plu_mask = np.zeros_like(image)\n else:\n raise ValueError(\"Please input 'y' or 'n' !\")\n else:\n src_mask = data_masks_center\n\n\n #adding pixels around the selected masks\n selem = np.ones((add_mask, add_mask))\n src_mask = ndimage.binary_dilation(src_mask.astype(np.bool), selem)\n plu_mask_out = ndimage.binary_dilation(plu_mask.astype(np.bool), selem)\n plu_mask_out = (plu_mask_out - 1)*-1\n\n #select source region to fit, or to use whole observation to fit\n ##1.select source region to fit\n snr = self.snr\n source_mask = image * src_mask\n #create background image for picked\n if self.background_rms is None:\n _, _, std = sigma_clipped_stats(image, sigma=snr, mask=source_mask)\n tshape = image.shape\n img_bkg = make_noise_image(tshape, distribution='gaussian', mean=0., stddev=std, seed=12)\n else:\n tshape = image.shape\n std=np.mean(self.background_rms)\n img_bkg = make_noise_image(tshape, distribution='gaussian', mean=0., stddev=std, seed=12)\n\n no_source_mask = (src_mask * -1 + 1) * img_bkg\n picked_data = source_mask + no_source_mask\n\n ##2.use whole observation to fit while mask out the contamination\n maskedimg = image * plu_mask_out\n\n ##orginize the output 'kwargs_data'\n kwargs_data = {}\n if pick_choice:\n kwargs_data['image_data'] = picked_data#select source region to fit\n else:\n kwargs_data['image_data'] = maskedimg#use whole observation to fit while mask out the contamination\n\n if self.background_rms is None:\n kwargs_data['background_rms'] = std\n self.background_rms = std\n else:\n kwargs_data['background_rms'] = np.mean(self.background_rms)\n kwargs_data['exposure_time'] = self.exp_time\n kwargs_data['transform_pix2angle'] = np.array([[1, 0], [0, 1]]) * self.deltaPix\n ra_at_xy_0 = (y - r_cut) * self.deltaPix # (ra,dec) is (y_img,x_img)\n dec_at_xy_0 = (x - r_cut) * self.deltaPix\n kwargs_data['ra_at_xy_0'] = ra_at_xy_0\n kwargs_data['dec_at_xy_0'] = dec_at_xy_0\n\n #coordinate of the lens light\n xlenlight, ylenlight = [], []\n if lenslight_mask_index !=[]:\n for i in lenslight_mask_index:\n xlenlight.append(ra_at_xy_0 + int(xcenter[i]) * self.deltaPix )\n ylenlight.append(dec_at_xy_0 + int(ycenter[i])* self.deltaPix )\n\n #for output\n self.data = kwargs_data['image_data']\n self.kwargs_data = kwargs_data\n self.data_mask = src_mask\n self.lens_mask = lens_mask\n self.plu_mask = plu_mask_out\n self.obj_masks = obj_masks\n imageData = ImageData(**kwargs_data)\n self.imageData = imageData\n kwargs_seg = [segments_deblend_list, xcenter, ycenter, c_index]\n\n return kwargs_data, kwargs_seg, [xlenlight, ylenlight]","def im_detect(net, im, boxes):\n blobs, unused_im_scale_factors = _get_blobs(im, boxes)\n # When mapping from image ROIs to feature map ROIs, there's some aliasing\n # (some distinct image ROIs get mapped to the same feature ROI).\n # Here, we identify duplicate feature ROIs, so we only compute features\n # on the unique subset.\n for i in range(len(blobs['data'])):\n if cfg.DEDUP_BOXES > 0:\n v = np.array([1, 1e3, 1e6, 1e9, 1e12])\n hashes = np.round(blobs['rois'][i] * cfg.DEDUP_BOXES).dot(v)\n _, index, inv_index = np.unique(hashes, return_index=True,\n return_inverse=True)\n blobs['rois'][i] = blobs['rois'][i][index, :]\n boxes_tmp = boxes[index, :].copy()\n else:\n boxes_tmp = boxes.copy()\n t_data = blobs['data'][i].astype(np.float32, copy=False)\n #t_data = t_data.reshape((1, t_data.shape[0], t_data.shape[1], t_data.shape[2], t_data.shape[3]))\n data_height, data_width = t_data.shape[1], t_data.shape[2]\n im_data = torch.FloatTensor(t_data).cuda()\n im_data = im_data.permute(0, 3, 1, 2).contiguous() #.view(3, data_height, data_width)\n LIM = 2000 # split ROIs due to memory issue\n if cfg.TEST.USE_FLIPPED :\n blobs['data'][i] = blobs['data'][i][:, :, ::-1, :]\n width = blobs['data'][i].shape[2]\n t_data = blobs['data'][i].astype(np.float32, copy=False)\n data_height, data_width = t_data.shape[1], t_data.shape[2]\n #im_data = torch.FloatTensor(t_data).cuda()\n im_data_flip = torch.from_numpy(t_data.copy()).cuda()\n im_data_flip = im_data_flip.permute(0, 3, 1, 2).contiguous()#.view(3, data_height, data_width)\n #im_data = im_data[...,::-1]\n for j in range (int(np.ceil(blobs['rois'][i].shape[0] / LIM))) :\n t_rois = blobs['rois'][i][j*LIM:(j+1)*LIM].astype(np.float32, copy=False)\n im_rois = torch.FloatTensor(t_rois).cuda()\n ic_prob, ic_prob1, ic_prob2 = net(im_data, im_rois)\n scores_tmp = ic_prob + ic_prob1 + ic_prob2\n pred_boxes_small = np.tile(boxes_tmp[j*LIM : (j+1)*LIM], (1, scores_tmp.shape[2]))\n\n if cfg.TEST.USE_FLIPPED:\n #pdb.set_trace()\n oldx1 = blobs['rois'][i][j*LIM:(j+1)*LIM, 1].copy()\n oldx2 = blobs['rois'][i][j*LIM:(j+1)*LIM, 3].copy()\n blobs['rois'][i][j*LIM:(j+1)*LIM, 1] = width - oldx2 - 1\n blobs['rois'][i][j*LIM:(j+1)*LIM, 3] = width - oldx1 - 1\n assert (blobs['rois'][i][j*LIM:(j+1)*LIM, 3] >= blobs['rois'][i][j*LIM:(j+1)*LIM, 1]).all()\n t_rois = blobs['rois'][i][j*LIM:(j+1)*LIM].astype(np.float32, copy=False)\n im_rois = torch.FloatTensor(t_rois).cuda()\n ic_prob, ic_prob1, ic_prob2 = net(im_data_flip, im_rois)\n scores_tmp += ic_prob + ic_prob1 + ic_prob2\n del im_rois\n\n if j is 0 :\n scores_tmp_real = scores_tmp\n pred_boxes = pred_boxes_small\n else :\n scores_tmp_real = torch.cat((scores_tmp_real, scores_tmp), dim=1)\n pred_boxes = np.vstack((pred_boxes, pred_boxes_small))\n\n\n if cfg.DEDUP_BOXES > 0:\n # Map scores and predictions back to the original set of boxes\n scores_tmp = scores_tmp_real[:,inv_index, :]\n pred_boxes = pred_boxes[inv_index, :]\n \n if i == 0: \n scores = np.copy(scores_tmp.data).squeeze()\n if len(scores.shape) == 1 :\n scores = scores[np.newaxis, :]\n else:\n scores += scores_tmp[0].data\n\n scores /= len(blobs['data']) * (1. + cfg.TEST.USE_FLIPPED)\n return scores[:,1:], pred_boxes[:, 4:]","def preprocessing(train_raw_, test_raw_):\n \n undef = np.float64(-999.0)\n pred_dict = {'s':'1','b':'0', '?':'-1'}\n # drop 1st column (Id) and also 1st row with column names (\"[1:,\") \n train_raw = train_raw_[1:, :]\n test_raw = test_raw_[1:, :] \n \n # Change s(signal) and b(background) for s:1 and b:0, and change '?' for -1\n train_raw[:,1] = np.vectorize(pred_dict.get)(train_raw[:,1].astype(str))\n test_raw[:,1] = np.vectorize(pred_dict.get)(test_raw[:,1].astype(str))\n \n # Divide the dataset in four according to PRI_jet_num feature and cast to float\n train_data_jets = divide_dataset_by_jet(train_raw)\n test_data_jets = divide_dataset_by_jet(test_raw)\n \n # Remove columns with nan values or with standard deviation of 0\n test_data_jets, train_data_jets = clean_features(test_data_jets, train_data_jets, undef)\n \n # Standardize train and test sets to have mean=0 and std=1\n train_data_jets, test_data_jets = standardize(train_data_jets, test_data_jets)\n \n # Replace remaining undefined values by mean, median or zero\n train_data_mean, train_data_median, train_data_null = replace_nan(train_data_jets)\n test_data_mean, test_data_median, test_data_null = replace_nan(test_data_jets)\n \n return train_data_mean, train_data_median, train_data_null, test_data_mean, test_data_median, test_data_null","def _preprocess(self, features, labels):\n with tf.variable_scope('preprocess'):\n with tf.variable_scope('image'):\n features['image_orig'] = features['image']\n image = tf.image.convert_image_dtype(features['image_orig'],\n dtype=tf.float32)\n if self.mode == ModeKeys.TRAIN:\n images = tf.unstack(image)\n images = [augment_image(img) for img in images]\n image = tf.stack(images)\n image = tf.subtract(image, 0.5)\n image = tf.multiply(image, 2.0)\n features['image'] = image\n\n if labels is None:\n return features, None\n\n with tf.variable_scope('label'):\n # TODO(Shancheng): use start token and end token rather constant 0\n # labels for decoder input\n labels['label_input'] = tf.concat([labels['label'][:, -1:],\n labels['label'][:, 0:-1]], axis=1)\n # from text length to training label length\n labels['length'] = tf.reshape(labels['length'], [-1])\n labels['length'] = labels['length'] + 1\n\n return features, labels","def augment(image,masks):\n\n # Random horizontal flipping\n if random.random() > 0.5:\n image = TF.hflip(image)\n masks = TF.hflip(masks)\n\n # Random vertical flipping\n if random.random() > 0.5:\n image = TF.vflip(image)\n masks = TF.vflip(masks)\n return image,masks","def _extract_features(self, all_batches, patch_size, train=True):\n # manually derive basic intensities features\n # takes 20 sec / 1048 images batch on my laptop in 4 cores //\n p = patch_size\n r = 512 // p\n labels = np.empty(0)\n feats = np.empty(0)\n for counter, tmp in enumerate(all_batches):\n # if counter == 2:\n # break\n if train:\n batch_img, batch_label = tmp\n else:\n batch_img = tmp\n batch_label = np.empty(0)\n # just for testing just use 20 batch as training set\n print('processing batch {}'.format(counter))\n t1 = time.time()\n batch_feats = np.asarray(\n parmap.map(\n self._get_features_from_batch_images,\n batch_img,\n r,\n p,\n pm_pbar=True))\n print(time.time() - t1)\n labels = np.concatenate(\n (labels, batch_label)) if labels.size else batch_label\n feats = np.concatenate(\n (feats, batch_feats)) if feats.size else batch_feats\n if train:\n return feats, labels\n else:\n return feats","def _forward_extract_base_features(self, i_frame, pre_boxes=None):\n relu = nn.ReLU(inplace=True)\n\n batch_size = i_frame.size(0)\n self.batch_size = batch_size\n\n if i_frame.size()[1] == 3:\n base_feat_before_relu = self.RCNN_base_i(i_frame)\n else:\n base_feat_before_relu = self.RCNN_base_i(i_frame[:, 0:3, :, :])\n\n # the\n base_feat_out = base_feat_before_relu.clone() # used to output as appearance feature, [bs, c, h, w]\n f_h, f_w = base_feat_out.size()[2], base_feat_out.size()[3]\n im_h, im_w = i_frame.size()[2], i_frame.size()[3]\n h_scale, w_scale = f_h / im_h, f_w / im_w\n f_scale = i_frame.data.new([w_scale, h_scale, w_scale, h_scale]) # [4]\n\n if pre_boxes is None:\n return base_feat_out, f_scale\n else:\n\n base_feat = relu(base_feat_before_relu)\n\n rois = pre_boxes\n\n base_feat = self.RCNN_conv_new(base_feat)\n\n # do roi pooling based predicted rois\n cls_feat = self.RCNN_cls_base(base_feat)\n pooled_feat_cls = self.RCNN_psroi_pool_cls(cls_feat, rois.view(-1, 5))\n cls_score = self.pooling(pooled_feat_cls)\n cls_score = cls_score.view(cls_score.size(0), cls_score.size(1))\n cls_prob = F.softmax(cls_score, dim=1)\n\n bbox_base = self.RCNN_bbox_base(base_feat)\n pooled_feat_loc = self.RCNN_psroi_pool_loc(bbox_base, rois.view(-1, 5))\n bbox_pred = self.pooling(pooled_feat_loc)\n bbox_pred = bbox_pred.squeeze()\n\n cls_prob = cls_prob.view(batch_size, rois.size(1), -1)\n bbox_pred = bbox_pred.view(batch_size, rois.size(1), -1)\n\n return rois, cls_prob, bbox_pred, base_feat_out, f_scale","def extract_features(img, sigmas, n_features): \n dims = img.shape # dimensions of the image\n \n features = np.zeros((dims[0], dims[1], n_features)) # each feature map has the same size as the input image\n \n # the first feature we use is the pixel intensity in the green channel itself\n img_g = img[:,:,1] #I just assume it follows the RGB convention and not GBR or BGR...\n features[:,:,0] = img_g\n features[:,:,1] = np.sum(img,axis=2) \n \n gabors = get_gabors() \n \n # >>> YOUR CODE STARTS HERE <<<\n i = 2\n# for s in sigmas:\n# gfilters = gauss_filter(s)\n# for gf in gfilters:\n# features[:,:,i] = scipy.signal.fftconvolve(img_g, gf, mode='same') ;i+=1\n for s in sigmas:\n gauss = gauss_filter(s)\n for g in gauss:\n features[:,:,i] = scipy.signal.fftconvolve(img_g, g, mode='same') ;i+=1\n \n for gabor in gabors:\n features[:,:,i] = scipy.signal.fftconvolve(img_g, gabor, mode='same') ;i+=1\n \n \n features[:,:,i] = sobel(img_g, axis=0) ;i+=1\n features[:,:,i] = sobel(img_g, axis=1) ;i+=1\n features[:,:,i] = sobel(img_g, axis=0)+sobel(img_g, axis=1) ;i+=1\n features[:,:,i] = feature.canny(img_g, sigma=0.0) ;i+=1\n features[:,:,i] = feature.canny(img_g, sigma=0, low_threshold=13, high_threshold=50);i+=1\n features[:,:,i] = feature.canny(img_g, sigma=1)\n # >>> YOUR CODE ENDS HERE <<< \n \n return features","def _preprocessing(image) -> np.ndarray:\n # TODO: Turn mapping into generic function.\n processed_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)\n processed_image[~mask] = 255\n return processed_image","def create_feature(self):\n\n if not hasattr(self, \"mask\"):\n raise Exception(\"attribute self.mask missing\")\n\n pixels = np.asarray(np.where(self.mask), np.int32).T\n\n self.feature = Feature(pixels)","def extract_features(self, images: List[np.ndarray]) -> List[np.ndarray]:\n pass","def _preprocessing(mask, mapping, image) -> np.ndarray:\n # TODO: Turn mapping into generic function.\n processed_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)\n processed_image = cv.remap(processed_image, *mapping, cv.INTER_LINEAR)\n processed_image[~mask] = 255\n return processed_image","def generatePixelFeaturesForImage(rgbSourceImage):\n totalImagePixels = np.size(rgbSourceImage[:,:,0])\n \n # RGB features\n \n rgbColourValuesFeature = createRGBColourValues(rgbSourceImage)\n \n# rgbColour1DHistogramFeatures, range = create1dRGBColourHistogram(rgbSourceImage)\n# rgbColour1DHistogramFeatures = np.resize(rgbColour1DHistogramFeatures, (totalImagePixels, np.size(rgbColour1DHistogramFeatures[1]) ) )\n \n# rgbColour3DHistogramFeatures, range = create3dRGBColourHistogramFeature(rgbSourceImage)\n# rgbColour3DHistogramFeatures = np.resize(rgbColour3DHistogramFeatures, (totalImagePixels, np.size(rgbColour3DHistogramFeatures[1]) ) )\n range = None\n \n # HSV features\n \n hsvColourValueFeature = createHSVColourValues(rgbSourceImage)\n \n hsvSourceImage = color.rgb2hsv(rgbSourceImage)\n \n# hsvColour1DHistogramFeatures, range = create1dHSVColourHistogram(hsvSourceImage) \n# hsvColour1DHistogramFeatures = np.resize(hsvColour1DHistogramFeatures, (totalImagePixels, np.size(hsvColour1DHistogramFeatures[1]) ) )\n \n hsvColour3DHistogramFeatures, range = create3dHSVColourHistogramFeature(hsvSourceImage)\n hsvColour3DHistogramFeatures = np.resize(hsvColour3DHistogramFeatures, (totalImagePixels, np.size(hsvColour3DHistogramFeatures[1]) ) )\n range = None\n \n # HOG features\n hogFeatureImage = createHistogramOfOrientedGradientFeatures(rgbSourceImage, numGradientBins, (9,9), (3,3), True, True)\n # this is RxCxNbOrients\n hogFeatures = np.reshape( hogFeatureImage, ( rgbSourceImage[:,:,0].size, numGradientBins ) )\n #hog1Darray = None\n #hogFeatures = np.reshape(hogFeatures, (totalImagePixels , np.size(hogFeatures) / totalImagePixels) )\n \n # Local binary pattern features\n lbpFeatures = createLocalBinaryPatternFeatures(rgbSourceImage, 4, 2, \"default\")\n lbpFeatures = np.reshape(lbpFeatures, (totalImagePixels , np.size(lbpFeatures) / totalImagePixels) )\n \n # Testure filter response features\n filterResponseFeatures = createFilterbankResponse(rgbSourceImage, 15)\n filterResponseFeatures = np.reshape(filterResponseFeatures, ( totalImagePixels , np.size(filterResponseFeatures) / totalImagePixels) )\n \n # Test shapes of resized features\n assert (np.shape(rgbColourValuesFeature)[0] == totalImagePixels) , (\"Number of RGB value feature rows not equal to total pixels:: \" +str(np.shape(rgbColourValuesFeature)[0]) + \", \" + str(totalImagePixels))\n# assert (np.shape(rgbColour1DHistogramFeatures)[0] == totalImagePixels) , (\"Number of of RGB 1D histogram features:: \" + str(np.shape(rgbColour1DHistogramFeatures)[0]) + \", \" + str(totalImagePixels))\n# assert (np.shape(rgbColour3DHistogramFeatures)[0] == totalImagePixels) , (\"Number of RGB 3D histogram feature rows not equal to total pixels:: \" , np.shape(rgbColour3DHistogramFeatures)[0] + \", \" + str(totalImagePixels))\n assert (np.shape(hsvColourValueFeature)[0] == totalImagePixels) , (\"Number of HSV value feature rows not equal to total pixels:: \" + str(np.shape(hsvColourValueFeature)[0]) + \", \" + str(totalImagePixels))\n# assert (np.shape(hsvColour1DHistogramFeatures)[0] == totalImagePixels) , (\"Number of HSV 1D histogram feature rows not equal to total pixels:: \" + str(np.shape(hsvColour1DHistogramFeatures)[0]) + \", \" + str(totalImagePixels))\n assert (np.shape(hsvColour3DHistogramFeatures)[0] == totalImagePixels) , (\"Number of HSC 3D histogram feature rows not equal to total pixels:: \" + str(np.shape(hsvColour3DHistogramFeatures)[0]) + \", \" + str(totalImagePixels))\n assert (np.shape(hogFeatures)[0] == totalImagePixels) , (\"Number of HOG features not equal to total pixels:: \" + str(np.shape(hogFeatures)[0]) + \", \" + str(totalImagePixels))\n assert (np.shape(lbpFeatures)[0] == totalImagePixels) , (\"Number of LBP features not equal to total pixels:: \" + str(np.shape(lbpFeatures)[0]) + \", \" + str(totalImagePixels))\n assert (np.shape(filterResponseFeatures)[0] == totalImagePixels) , (\"Number of filter response features not equal to total pixels:: \" + str(np.shape(filterResponseFeatures)[0]) + \", \" + str(totalImagePixels) )\n \n # Consolidate all features for image, per pixel - skip colors and 1d hists for sake of filesize!\n imageFeatures = np.hstack( [ \\\n rgbColourValuesFeature, \\\n# rgbColour1DHistogramFeatures, \\\n# rgbColour3DHistogramFeatures, \\\n# hsvColourValueFeature, \\\n# hsvColour1DHistogramFeatures, \\\n# prob not needed due to crf smoothing hsvColour3DHistogramFeatures, \\\n hogFeatures, \\\n# !!come back to this later lbpFeatures, \\\n filterResponseFeatures \\\n ] )\n # 14/06/13 Reference feature set = rgbColourValuesFeature, hsvColour3DHistogramFeatures, hogFeatures, hogFeatures, lbpFeatures & filterResponseFeatures\n \n assert (np.shape(imageFeatures)[0] == totalImagePixels) , (\"Number of ImageFeatures rows not equal to total pixels:: \" + str(np.shape(imageFeatures)[0]) + \", \" + str(totalImagePixels))\n \n return imageFeatures.astype('float')","def apply(self, mode='lateral'):\n num_lat_slices = self.img3d.shape[0]\n num_cor_slices = self.img3d.shape[2]\n bin_mask = np.zeros(self.mask3d.shape)\n x,y,z = np.where(self.mask3d==self.vertebra_id)\n bin_mask[np.min(x):np.max(x), np.min(y):np.max(y), np.min(z):np.max(z)] = 1\n if mode=='lateral' or mode=='fuse':\n mask_lat = np.zeros((6, self.mask3d.shape[0], self.mask3d.shape[1], self.mask3d.shape[2]))\n img_lat = np.zeros(self.img3d.shape)\n binary_lat = np.zeros(self.mask3d.shape)\n # for each lateral slice\n for idx in range(num_lat_slices):\n img_slice, mask_slice = np.copy(self.img3d[idx, :, :]), np.copy(self.mask3d[idx, :, :])\n xloc, yloc = np.where(mask_slice==self.vertebra_id)\n # check if vertebra is present in image\n if xloc.shape[0]==0:\n # if not keep mask as it is\n mask_lat[:,idx, :, :] = self.get_one_hot(mask_slice)\n img_lat[idx, :, :] = img_slice\n else:\n min_x, max_x = np.min(xloc), np.max(xloc)\n min_y, max_y = np.min(yloc), np.max(yloc)\n inpainted_img, inpainted_mask, binary_mask = self.inpaint(img_slice, mask_slice, min_x, max_x, min_y, max_y)\n mask_lat[:,idx, :, :] = inpainted_mask\n img_lat[idx,:, :] = inpainted_img\n binary_lat[idx,:,:] = binary_mask\n\n\n if mode=='coronal' or mode=='fuse':\n mask_cor = np.zeros((6, self.mask3d.shape[0], self.mask3d.shape[1], self.mask3d.shape[2]))\n img_cor = np.zeros(self.img3d.shape)\n binary_cor = np.zeros(self.mask3d.shape)\n # for each coronal slice\n for idx in range(num_cor_slices):\n img_slice, mask_slice = np.copy(self.img3d[:, :, idx]), np.copy(self.mask3d[:, :, idx])\n xloc, yloc = np.where(mask_slice==self.vertebra_id)\n # check if vertebra is present in image\n if xloc.shape[0]==0:\n # if not keep mask as it is\n mask_cor[:, :, :, idx] = self.get_one_hot(mask_slice)\n img_cor[:, :, idx] = img_slice\n else:\n min_x, max_x = np.min(xloc), np.max(xloc)\n min_y, max_y = np.min(yloc), np.max(yloc)\n # else remove fractured vertebra and inpaint\n inpainted_img, inpainted_mask, binary_mask = self.inpaint(img_slice, mask_slice, min_x, max_x, min_y, max_y, 'coronal')\n mask_cor[:, :, :, idx] = inpainted_mask\n img_cor[:, :, idx] = inpainted_img\n binary_cor[:,:,idx] = binary_mask\n \n # return to a one channel mask and convert labels back\n if mode=='lateral':\n mask_lat = np.argmax(mask_lat, axis=0)\n mask_lat = self.map_class_to_vert(mask_lat)\n self.mask3d = mask_lat\n self.img3d = img_lat\n elif mode=='coronal':\n mask_cor = np.argmax(mask_cor, axis=0)\n mask_cor = self.map_class_to_vert(mask_cor)\n self.mask3d = mask_cor\n self.img3d = img_cor\n elif mode=='fuse':\n mask_fuse = mask_cor*0.5+mask_lat*0.5\n mask_fuse = np.argmax(mask_fuse, axis=0)\n mask_fuse = self.map_class_to_vert(mask_fuse)\n self.mask3d = mask_fuse\n self.img3d = (img_lat+img_cor)/2\n \n # save result\n self.mask3d = self.mask3d.astype(np.uint8)\n self.img3d = self.img3d.astype(np.float32)\n \n # put back if we padded and cropped\n if self.padz and self.padx:\n self.orig_img3d[:,self.ymin:self.ymax, :] = self.img3d[self.xcrop1:-self.xcrop2,:,self.zcrop1:-self.zcrop2]\n self.orig_mask3d[:,self.ymin:self.ymax, :] = self.mask3d[self.xcrop1:-self.xcrop2,:,self.zcrop1:-self.zcrop2]\n elif self.padz and not self.padx:\n self.orig_img3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, :] = self.img3d[:,:,self.zcrop1:-self.zcrop2]\n self.orig_mask3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, :] = self.mask3d[:,:,self.zcrop1:-self.zcrop2]\n elif not self.padz and self.padx:\n self.orig_img3d[:,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.img3d[self.xcrop1:-self.xcrop2,:,:]\n self.orig_mask3d[:,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.mask3d[self.xcrop1:-self.xcrop2,:,:]\n else:\n self.orig_img3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.img3d\n self.orig_mask3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.mask3d\n \n img = return_scan_to_orig(self.orig_img3d, self.mask_affine, self.mask_header, self.zooms)\n nib.save(img, self.inpainted_img_path)\n\n mask_fuse = return_scan_to_orig(self.orig_mask3d, self.mask_affine, self.mask_header, self.zooms, np.uint8)\n nib.save(mask_fuse, self.inpainted_mask_path)\n print('Inpaint mask and image saved at: ', self.inpainted_mask_path, self.inpainted_img_path)","def __init__(self, device=\"cuda:0\", *args, **kwargs):\n source_file_wtsd = \"/g/kreshuk/data/leptin/sourabh_data_v1/Segmentation_results_fused_tp_1_ch_0_Masked_WatershedBoundariesMergeTreeFilter_Out1.tif\"\n source_file_wtsd = \"/g/kreshuk/hilt/projects/data/leptin_fused_tp1_ch_0/Masked_WatershedBoundariesMergeTreeFilter_Out1.h5\"\n # wtsd = torch.from_numpy(np.array(imread(source_file_wtsd).astype(np.long))).to(device)\n wtsd = torch.from_numpy(h5py.File(source_file_wtsd, \"r\")[\"data\"][:].astype(np.long)).to(device)\n slices = [0, 157, 316]\n label_1 = [1359, 886, 1240]\n label_2 = [1172, 748, 807]\n label_3 = [364, 1148, 1447]\n m1, m2, m3, m4, m5 = [], [], [], [], []\n self.outer_cntr_ds, self.inner_cntr_ds, self.celltype_1_ds, self.celltype_2_ds, self.celltype_3_ds = [], [], [], [], []\n for slc, l1, l2, l3 in zip(slices, label_1, label_2, label_3):\n bg = wtsd[:, slc, :] == 1\n bg_cnt = find_contours(bg.cpu().numpy(), level=0)\n cnt1 = bg_cnt[0] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[1]\n cnt2 = bg_cnt[1] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[0]\n for m, cnt in zip([m1, m2], [cnt1, cnt2]):\n mask = torch.zeros_like(wtsd[:, slc, :]).cpu()\n mask[np.round(cnt[:, 0]), np.round(cnt[:, 1])] = 1\n m.append(torch.from_numpy(binary_fill_holes(mask.long().cpu().numpy())).to(device).sum().item())\n\n mask = wtsd[:, slc, :] == l1\n m3.append(mask.long().sum().item())\n cnt3 = find_contours(mask.cpu().numpy(), level=0)[0]\n mask = wtsd[:, slc, :] == l2\n m4.append(mask.long().sum().item())\n cnt4 = find_contours(mask.cpu().numpy(), level=0)[0]\n mask = wtsd[:, slc, :] == l3\n m5.append(mask.long().sum().item())\n cnt5 = find_contours(mask.cpu().numpy(), level=0)[0]\n\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt1[:, 0], cnt1[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt2[:, 0], cnt2[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt3[:, 0], cnt3[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt4[:, 0], cnt4[:, 1]] = 1\n # plt.imshow(img);plt.show()\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\n # img[cnt5[:, 0], cnt5[:, 1]] = 1\n # plt.imshow(img);plt.show()\n\n self.outer_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt1, tolerance=1.2)).to(device)))\n self.inner_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt2, tolerance=1.2)).to(device)))\n self.celltype_1_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt3, tolerance=1.2)).to(device)))\n self.celltype_2_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt4, tolerance=1.2)).to(device)))\n self.celltype_3_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt5, tolerance=1.2)).to(device)))\n\n self.masses = [np.array(m1).mean(), np.array(m2).mean(), np.array(m3 + m4 + m5).mean()]\n self.fg_shape_descriptors = self.celltype_1_ds + self.celltype_2_ds + self.celltype_3_ds","def optimize_fore(self):\n self.u = np.random.uniform(-1, 1, (32, 288, 1, 1))\n \n self.l2 = torch.from_numpy(self.u).float()\n print('self u shape',self.l2.shape)\n self.n = torch.randn(32, 1, 28, 28)\n self.l1 = self.enc(self.input + self.n)\n self.del1=self.dec(self.l1)\n self.del2=self.dec(self.l2)\n self.update_netc()\n self.update_netd()\n\n self.update_l2()\n self.update_netg()\n print('sssssssssssssssssssssss')","def _extract_features(images,\n model_options,\n weight_decay=0.0001,\n reuse=tf.AUTO_REUSE,\n is_training=False,\n fine_tune_batch_norm=False):\n # feature extractor is a backbone factory\n DEBUG_VARS.raw_image = images\n features, end_points = feature_extractor.extract_features(\n images,\n output_stride=model_options.output_stride,\n multi_grid=model_options.multi_grid,\n model_variant=model_options.model_variant,\n weight_decay=weight_decay,\n reuse=reuse,\n is_training=is_training,\n fine_tune_batch_norm=fine_tune_batch_norm)\n\n # TODO:check\n # DEBUG_VARS.xception_feature = end_points['xception_65/entry_flow/conv1_1/Relu:0']\n DEBUG_VARS.xception_feature = features\n if not model_options.aspp_with_batch_norm:\n return features, end_points\n else:\n batch_norm_params = {\n 'is_training': is_training and fine_tune_batch_norm,\n 'decay': 0.9997,\n 'eps': 1e-5,\n 'affine': True,\n }\n regularize_func = regularizer('l2', weight_decay)\n with tf.variable_scope(tf.get_variable_scope(), reuse=reuse):\n with arg_scope([sep_conv2d], activate=tf.nn.relu, activate_middle=tf.nn.relu, batch_norm=True,\n depthwise_weight_reg=None, pointwise_weight_reg=regularize_func,\n padding='SAME', strides=[1, 1]):\n with arg_scope([conv2d], activate=tf.nn.relu, weight_reg=regularize_func,\n batch_norm=True, padding='SAME', strides=[1, 1]):\n # TODO: ASPP IS IMPLEMENTED HERE! Check Out!\n with arg_scope([batch_norm2d], **batch_norm_params):\n depth = 256\n branch_logits = []\n\n # TODO: ADD IMAGE POOLING HERE\n if model_options.add_image_level_feature:\n # this crop size has been updated to the new scaled one outside, which is the exact size\n # of this model's inputs\n pool_height = scale_dimension(model_options.crop_size[0],\n 1. / model_options.output_stride)\n pool_width = scale_dimension(model_options.crop_size[1],\n 1. / model_options.output_stride)\n # global average pooling, check whether the shape here is 1?\n image_feature = avg_pool2d(\n features, [pool_height, pool_width], [pool_height, pool_width],\n padding='VALID')\n # collapse channels to depth after GAP\n image_feature = conv2d(\n inputs=image_feature, outc=depth, ksize=[1, 1], name=_IMAGE_POOLING_SCOPE)\n # TODO:check\n DEBUG_VARS.image_feature = image_feature\n # reshape it to final feature map shape\n image_feature = tf.image.resize_bilinear(\n image_feature, [pool_height, pool_width], align_corners=True)\n image_feature.set_shape([None, pool_height, pool_width, depth])\n # add image level feature to branch_logits\n branch_logits.append(image_feature)\n\n # Employ a 1x1 convolution.\n branch_logits.append(conv2d(features, outc=depth, ksize=[1, 1], name=_ASPP_SCOPE + str(0)))\n\n if model_options.atrous_rates:\n # Employ 3x3 convolutions with different atrous rates.\n DEBUG_VARS.aspp_features = []\n for i, rate in enumerate(model_options.atrous_rates, 1):\n scope = _ASPP_SCOPE + str(i)\n if model_options.aspp_with_separable_conv:\n aspp_features = sep_conv2d(\n features, outc=depth, ksize=[3, 3], ratios=[rate, rate], name=scope)\n DEBUG_VARS.aspp_features.append(aspp_features)\n else:\n aspp_features = conv2d(\n features, outc=depth, ksize=[3, 3], ratios=[rate, rate], name=scope)\n branch_logits.append(aspp_features)\n\n # Merge branch logits.\n concat_logits = tf.concat(branch_logits, 3)\n concat_logits = conv2d(inputs=concat_logits, outc=depth, ksize=[1, 1],\n name=_CONCAT_PROJECTION_SCOPE)\n DEBUG_VARS.aspp_concat_feature = concat_logits\n concat_logits = drop_out(concat_logits, kp_prob=0.9, is_training=is_training,\n name=_CONCAT_PROJECTION_SCOPE + '_dropout')\n\n return concat_logits, end_points","def preprocessing(fish_class):\n\n\t# encode fish_class into integer\n\tfish_label = fish_labels[fish_class]\n\t\n\t# return a list of image directories for each image\n\timg_handles = glob.glob(data_dir + fish_class + '/' + '*.jpg')\n\t\n\t# build an empty list to store each img as np.ndarray\n\timgs = []\n\t\n\t# build an empty list to store the encoded label for each image\n\tlabels = []\n\t\n\t# iterate through all images in the fish_class folder\n\tfor img_handle in img_handles:\n\t\n\t\t# read img as np.ndarray\n\t\timg = cv2.imread(img_handle)\n\t\t\n\t\t# resize it \n\t\tcv2.resize( img, (new_img_width, new_img_height)\n\t\timg = cv2.resize(img, new_img_size, interpolation=cv2.INTER_CUBIC)\n\t\tstore the img in format of np.ndarray into the imgs \n\t\timgs.append(img)\n\t\t\n\t\t# store a label in labels\n\t\tlabels.append(fish_label)\n\t\n\treturn imgs, labels\n\n# time the preprocessing\nt0 = time.time()\n\n# build an empty list to store preprocessed data\npreprocessed_data = []\n\n# build an empty list to store labels\nencoded_labels = []\n\nfor num, fish in enumerate(classes):\n\tprint num\n\tprint 'Preprocessing imgs of fish %s' %(fish)\n\tprint '----------------------------------------------------------------------'\n\tpreprocessed_imgs, labels = preprocessing(fish)\n\tpreprocessed_data.append(preprocessed_imgs)\n\tencoded_labels.append(labels)","def forward(self,images):\n with torch.no_grad(): \n features = self.resnet(images)\n features = features.view(features.size(0),-1)\n features = self.embed(features)\n features = self.bn(features)\n return features","def caffe_preprocess(img):\n out = numpy.copy(img)\n out -= IMAGE_256_MEAN[None, None, :]\n out = out[:, :, [2, 1, 0]] # swap channel from RGB to BGR\n return out","def x_means(image_path):\n\n # List where all the descriptors are stored\n des_list = []\n\n im = cv2.imread(image_path)\n kpts = fea_det.detect(im)\n kpts, des = des_ext.compute(im, kpts)\n\n # rootsift - not boosting performance\n # rs = RootSIFT()\n # des = rs.compute(kpts, des)\n\n des_list.append((image_path, des))\n\n # Stack all the descriptors vertically in a numpy array\n descriptors = des_list[0][1]\n\n # gather features\n test_features = np.zeros((1, numWords), \"float32\")\n words, _ = vq(descriptors, voc)\n for w in words:\n test_features[0][w] += 1\n\n # Perform Tf-Idf vectorization and L2 normalization\n test_features = test_features * idf\n test_features = preprocessing.normalize(test_features, norm='l2')\n\n score = np.dot(test_features, im_features.T)\n # print \"score: \", score\n rank_ID = np.argsort(-score)\n # print \"rank matrix: \", rank_ID[0]\n\n for ID in rank_ID[0]:\n if score[0][ID] <= float(lowcut):\n if ID not in low_union:\n low_union.append(ID)\n\n x_list = []\n for x in score[0]:\n x_list.append([x])\n X = np.array(x_list)\n for n in X:\n n[0] *= 1000000 # increase difference\n # print \"Scores for X-Means: \", X\n\n # compute k range\n # ks = range(1, 21)\n bot_k = 30 * len(image_paths) / (200 + len(image_paths)) - 5\n ks = range(bot_k, bot_k + 10)\n\n # run ks times kmeans and save each result in the KMeans object\n KMeans = [cluster.KMeans(n_clusters=i, init=\"k-means++\").fit(X) for i in ks]\n\n # now run for each cluster the BIC computation\n bic_max = -sys.maxint - 1\n max_idx = 0\n # BIC = [compute_bic(kmeansi,X) for kmeansi in KMeans]\n for i in range(len(KMeans)):\n curr = compute_bic(KMeans[i], X)\n # print \"BIC = \", curr, \" when using %d clusters\\r\" % (i + bot_k)\n if curr > bic_max:\n bic_max = curr\n max_idx = i\n\n best_k = max_idx + bot_k\n # print \"Best K = \", best_k, \"with BIC = %d\\r\" % bic_max\n best_k_labels = KMeans[max_idx].labels_\n # print \"Best K labels\", KMeans[max_idx].labels_\n\n freq = {}\n for cluster_no in best_k_labels:\n if cluster_no in freq:\n freq[cluster_no] = freq[cluster_no] + 1\n else:\n freq[cluster_no] = 1\n max_cluster = 0\n max_size = -1\n for k, v in freq.items():\n if v > max_size:\n max_cluster = k\n max_size = v\n res = []\n for idx in range(len(best_k_labels)):\n if best_k_labels[idx] == max_cluster:\n res.append(idx)\n assert max_size == len(res)\n print \"\\nSize of the largest cluster = \", max_size\n\n # # Archive big clusters for inspection\n # path = os.path.split(pool_path)[0] + \"\\\\\" + \"cluster_\" + os.path.split(image_path)[1]\n # if os.path.exists(path):\n # shutil.rmtree(path)\n # os.mkdir(path)\n # print \"Adding cluster images for pool image \", image_path, \" to path \", path\n # for ID in res:\n # # print \"Adding \", image_paths[ID]\n # shutil.copy(image_paths[ID], path)\n\n return res # biggest_cluster list","def GenerateMapAffinity(img,nb_vertex,pointsInterest,objects_centroid,scale):\n\n # Apply the downscale right now, so the vectors are correct. \n img_affinity = Image.new(img.mode, (int(img.size[0]/scale),int(img.size[1]/scale)), \"black\")\n # Create the empty tensors\n totensor = transforms.Compose([transforms.ToTensor()])\n\n affinities = []\n for i_points in range(nb_vertex):\n affinities.append(torch.zeros(2,int(img.size[1]/scale),int(img.size[0]/scale)))\n \n for i_pointsImage in range(len(pointsInterest)): \n pointsImage = pointsInterest[i_pointsImage]\n center = objects_centroid[i_pointsImage]\n for i_points in range(nb_vertex):\n point = pointsImage[i_points]\n affinity_pair, img_affinity = getAfinityCenter(int(img.size[0]/scale),\n int(img.size[1]/scale),\n tuple((np.array(pointsImage[i_points])/scale).tolist()),\n tuple((np.array(center)/scale).tolist()), \n img_affinity = img_affinity, radius=1)\n\n affinities[i_points] = (affinities[i_points] + affinity_pair)/2\n\n\n # Normalizing\n v = affinities[i_points].numpy() \n \n xvec = v[0]\n yvec = v[1]\n\n norms = np.sqrt(xvec * xvec + yvec * yvec)\n nonzero = norms > 0\n\n xvec[nonzero]/=norms[nonzero]\n yvec[nonzero]/=norms[nonzero]\n\n affinities[i_points] = torch.from_numpy(np.concatenate([[xvec],[yvec]]))\n affinities = torch.cat(affinities,0)\n\n return affinities","def feature_extraction(img, feature):\n\n if feature == 'HoG':\n # HoG parameters\n\n # In the case of the Hog Feature, we already given the base parameters for using hog feature function.\n # TA - You can just use that parameter with each subdivide image (which has image grid size * image grid size)\n # Thank you for the reply. Does it mean to divide the image into 20x20 size sub-images and perform the feature extraction on each image??\n # TA - Yes. In the SIFT, image grid size is different.\n\n win_size = (32, 32)\n block_size = (32, 32)\n block_stride = (16, 16)\n cell_size = (16, 16)\n\n nbins = 9\n deriv_aperture = 1\n win_sigma = 4\n histogram_norm_type = 0\n l2_hys_threshold = 2.0000000000000001e-01\n gamma_correction = 0\n nlevels = 64\n\n # Your code here. You should also change the return value.\n\n # sample visualizing\n # cv2.imshow('img', img)\n\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n\n\n hog = cv2.HOGDescriptor(win_size,\n block_size,\n block_stride,\n cell_size,\n nbins,\n deriv_aperture,\n win_sigma,\n histogram_norm_type,\n l2_hys_threshold,\n gamma_correction,\n nlevels)\n\n # additional parameters\n\n #hist = hog.compute(gray,winStride,padding,locations)\n\n #TODO: Check if this is valid???\n\n hist = hog.compute(gray)\n hist_resized = np.resize(hist, (int(len(hist)/36), 36))\n hist_resized\n return hist_resized\n\n elif feature == 'SIFT':\n\n # Your code here. You should also change the return value.\n\n #input image size 240 * 200 ==> divide H, W by 20 ==> 12 * 10 = 120\n #in case of this input image, the number of feature is 120.\n #So the number of feature is changed according to input image size.\n\n #IF PROBLEMS WITH DEPENDENCIES: pip3 install opencv-contrib-python==3.4.2.16\n\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\n sift = cv2.xfeatures2d.SIFT_create()\n kp, des = sift.detectAndCompute(gray, None)\n\n return des","def preprocess(self, img):\n return img - np.mean(img)","def _get_features_from_batch_images(self, img, r, p):\n tmp_feats = []\n for channel in range(4):\n current_img = img[channel, :, :]\n tmp_feats = np.append(tmp_feats, np.histogram(current_img)[0])\n # extract 8*8 patches of 64*64 px and derive 10 bins histogram\n for j in range(r):\n for k in range(r):\n tmp_feats = np.append(\n tmp_feats,\n np.histogram(current_img[j * p:(j + 1) * (p), k *\n p:(k + 1) * p])[0])\n return tmp_feats","def get_spoof_features(img):\n # Converting default BGR of OpenCV to RGB\n # img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\n\n # Changing dimension from 3*m*n to m*n*3\n h_im = img[:, :, 0]\n s_im = img[:, :, 1]\n v_im = img[:, :, 2]\n\n img = np.array([h_im, s_im, v_im])\n\n return compute_msu_iqa_features(img)","def facial_features_preprocess(img, landmarks, mode):\n centers = compute_centers(landmarks)\n crop_img = crop(img, centers, mode)\n crop_img = crop_img[..., ::-1]\n in_data = resize_image(crop_img, 256, keep_aspect_ratio=False)\n in_data = in_data.astype(np.float32) / 255.\n in_data = np.moveaxis(in_data, -1, 0)[np.newaxis]\n m = np.array([0.485, 0.456, 0.406], dtype=np.float32).reshape((1, 3, 1, 1))\n s = np.array([0.229, 0.224, 0.225], dtype=np.float32).reshape((1, 3, 1, 1))\n in_data = (in_data - m) / s\n return in_data","def compute(\n self,\n image,\n exclude_center_feature: bool = False,\n exclude_center_value: bool = False,\n features: ndarray = None,\n feature_last_dim: bool = True,\n passthrough_channels: Optional[Tuple[bool]] = None,\n num_reserved_features: int = 0,\n excluded_voxels: Optional[List[Tuple[int]]] = None,\n spatial_feature_offset: Optional[Tuple[float, ...]] = None,\n spatial_feature_scale: Optional[Tuple[float, ...]] = None,\n ):\n raise NotImplementedError()","def get_mask(self):\n # use the feature array a to calculate which channels to include etc\n sums = np.sum(self.feature_array, 0)\n feature_mask = np.repeat(np.ones(4, dtype=int), self.n_features)\n # if there are \"missing\" channels use the older version of KK\n zero_sums = sums == 0\n if np.any(zero_sums):\n self.distribution = 1\n feature_mask[zero_sums] = 0\n self.feature_mask = feature_mask\n return feature_mask","def forward(self, images):\n with torch.no_grad():\n features = self.resnet(images) \n features = features.reshape(features.size(0), -1)\n features = self.bn(self.linear(features))\n return features","def forward_train(self, imgs, label, token_ids=None, segment_ids=None, input_mask=None, \n mlm_label=None, dvae_imgs=None, v_token_mask=None, hog_features=None, img_metas=None, **kwargs): \n # (batch_size, num_clips*num_crops, channel, num_segments, h, w) -> (batch_size*num_clips*num_crops, channel, num_segments, h, w)\n imgs = imgs.reshape((-1, ) + imgs.shape[2:]) \n if self.from_scratch:\n imgs = imgs / 255.0\n # text reshape: (batch_size, num_candidates, seq_length) -> (batch_size * num_candidates, seq_length)\n token_ids = token_ids.reshape((-1, ) + token_ids.shape[2:])\n text_input_mask = input_mask.reshape((-1, ) + input_mask.shape[2:])\n if mlm_label is not None:\n mlm_label = mlm_label.reshape((-1, ) + mlm_label.shape[2:])\n\n\n visual_token = self.extract_visual_feat(imgs) # b, d, T, h, w\n\n B, D, T, H, W = visual_token.shape\n losses = dict()\n # -------------- nce loss ------------------- #\n if hasattr(self, 'ssl_head'):\n input_ssl_ids = torch.where(mlm_label == -100, token_ids.clone(), mlm_label.clone())\n input_ssl_mask = text_input_mask.clone()\n text_only_out = self.text_backbone(input_ssl_ids, input_ssl_mask)\n # ------------ complete T -------------- #\n text_out_no_mask = text_only_out['last_hidden_state']\n visual_emb, text_emb = self.ssl_head(visual_token, text_out_no_mask, input_ssl_mask, input_ssl_ids)\n\n\n # ------------ complete V ---------------- #\n visual_token = visual_token.view(B, D, T, -1).permute(0, 2, 3, 1)\n\n\n # ---------- foward mask text input ---------- # \n text_out_with_mask = self.text_backbone(token_ids, text_input_mask)\n text_out_last_hidden_state = text_out_with_mask['last_hidden_state']\n\n # ---------- forward mask v input ------------ #\n visual_token_with_mask, v_mask = self.extract_visual_feat(imgs.clone(), v_token_mask) # b, d, T, h, w\n visual_token_mask = visual_token_with_mask.view(B, D, T, -1).permute(0, 2, 3, 1)\n \n v_fusion_output = self.multimodal_backbone(visual_token=visual_token_mask, text_input_mask=text_input_mask.clone(), text_input_embeds=text_out_no_mask.clone())\n \n t_fusion_output = self.multimodal_backbone(visual_token=visual_token, text_input_mask=text_input_mask, text_input_embeds=text_out_last_hidden_state)\n # for mlm #\n t_last_hidden_state = t_fusion_output['t_last_hidden_state']\n\n\n\n\n\n # ------------ MLM loss ------------ #\n\n if mlm_label is not None and self.mlm_head is not None:\n # we use mask text for MLM\n # because we doubt there will be miss interaction between wrong img-text pair \n # and the model not learn good relationship between vision and language\n # -------- forward masked text ----------- #\n mlm_prediction_score = self.mlm_head(t_last_hidden_state)\n \n if self.mlm_loss_func is not None:\n mlm_label_idx = torch.where(mlm_label.view(-1) != -100)\n mlm_prediction_mask_score = mlm_prediction_score.view(-1, self.text_vocab_size)[mlm_label_idx[0], :]\n mlm_label_mask = mlm_label.view(-1)[mlm_label_idx]\n mlm_loss = self.mlm_loss_func(mlm_prediction_mask_score, mlm_label_mask)\n else:\n mlm_loss = self.loss_func(mlm_prediction_score.view(-1, self.text_vocab_size), mlm_label.view(-1))\n losses['mlm_loss'] = mlm_loss\n\n\n # ------- Tri-modal alignment with mask sample and ranking --------- #\n if self.mlm_ssl_V_head is not None:\n mlm_visual_feat = v_fusion_output['t_last_hidden_state'][:, 0]\n mask_visual_recon_emb = self.mlm_ssl_V_head(mlm_visual_feat)\n mask_word_emb = self.ssl_head.forward_text(text_out_last_hidden_state) if self.use_Cmask else None\n loss_cvt_rank = self.ssl_loss(visual_emb, text_emb, mask_word_emb, mask_visual_recon_emb)\n losses.update(loss_cvt_rank)\n\n\n if self.symmetry_rank:\n mlm_word_feat = t_last_hidden_state[:, 0]\n mask_word_recon_emb = self.mlm_ssl_T_head(mlm_word_feat)\n\n mask_visual_emb = self.ssl_head.forward_vision(visual_token_with_mask) if self.use_Cmask else None\n \n loss_ctv_rank = self.ssl_loss(text_emb, visual_emb, mask_visual_emb, mask_word_recon_emb)\n loss_ctv_rank['v_nce_loss'] = loss_ctv_rank.pop('nce_loss')\n \n if self.ssl_loss.use_rank:\n loss_ctv_rank['rank_v_vm_loss'] = loss_ctv_rank.pop('rank_t_tm_loss')\n\n \n\n losses.update(loss_ctv_rank)\n\n\n\n return losses","def __surface_labelled_segmentation_pipeline(self, features):\n tic = time.perf_counter()\n\n # Collect the data\n ###########################################\n training_data, dev_data, test_data = {}, {}, {}\n dictionaries = (training_data, dev_data, test_data)\n counter = 0\n for file in self.input_files:\n input_file = open(os.path.join(sys.path[0], file), 'r')\n for line in input_file.readlines():\n content = line.rstrip('\\n').split(\" | \")\n labels = '-'.join(get_labels(content[2]))\n segments = removeLabels(content[2])\n\n # dictionaries[counter][content[0]] = [segments, labels] # word:[[segments],[labels]]\n dictionaries[counter][segments] = labels # segments : labels\n input_file.close()\n counter += 1\n\n toc = time.perf_counter()\n print(\"Data Collected in \" + str(tic - toc.__round__(2)))\n\n # Evaluate Model On the Test Set Using Optimised Model\n #######################################################\n\n print(\"Beginning Feature Computation and Model Optimisation\")\n tic = time.perf_counter()\n\n X_training, Y_training, words_training = surface_labelled_data_preparation(training_data)\n X_dev, Y_dev, words_dev = surface_labelled_data_preparation(dev_data)\n X_test, Y_test, words_test = surface_labelled_data_preparation(test_data)\n print(\"Data Processed\")\n\n best_epsilon = 1e-07\n best_max_iteration = 280\n best_algo = 'ap'\n\n # crf = sklearn_crfsuite.CRF(algorithm=best_algo, epsilon=best_epsilon, max_iterations=best_max_iteration)\n '''crf = sklearn_crfsuite.CRF(\n algorithm='lbfgs',\n c1=0.1,\n c2=0.1,\n max_iterations=100,\n all_possible_transitions=True\n )'''\n crf = sklearn_crfsuite.CRF(algorithm='ap', epsilon=best_epsilon, max_iterations=best_max_iteration)\n print(\"CRF Initialized\")\n # crf.fit(X_training, Y_training, X_dev=X_dev, y_dev=Y_dev)\n crf.fit(X_training, Y_training)\n print(\"Data Fitted\")\n Y_predict = crf.predict(features)\n labels = list(crf.classes_)\n sorted_labels = sorted(labels)\n return Y_predict, Y_test","def process_image(img, debug=True):\n global X_scaler, svc, feature, heatmap\n\n global top_left_x, top_left_y, bottom_right_x, bottom_right_y\n global start_win_width, start_win_height, end_win_width, end_win_height\n global overlap_frac_x, overlap_frac_y, layer\n\n out_img = np.copy(img)\n\n # When training the model, the images are loaded by cv2 => BGR (they might be converted later, though)\n # Since moviepy read images as RGB, we need to convert them to BGR first\n img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)\n\n windows = get_windows(img,\n x_start_stop=[top_left_x, bottom_right_x],\n y_start_stop=[top_left_y, bottom_right_y],\n overlap=(overlap_frac_x, overlap_frac_y),\n window_start_size=(start_win_width, start_win_height),\n window_end_size=(end_win_width, end_win_height),\n layers=layer)\n\n car_windows = []\n for window in windows:\n # Extract bounding box image from frame\n cropped_img = get_image_region(img, bbox=window)\n\n # Get feature vector\n feature_vector = feature.extract(cropped_img).astype(np.float64)\n\n # Normalize vector\n scaled_feature_vetor = X_scaler.transform(feature_vector)\n\n # Make prediction\n pred = svc.predict(scaled_feature_vetor)\n\n # If pred[0] == 1. then a car was detected\n if pred[0] == 1.:\n car_windows.append(window)\n\n # Add heat to heatmap where cars were detected\n heatmap.add_heat(car_windows)\n\n # Get labels from heatmap\n l = heatmap.get_labels()\n\n # Create image with all detected labels (post-heatmap)\n label_img = draw_labeled_bboxes(out_img, l)\n\n if debug:\n print('cars found: {}'.format(l[1]))\n\n # Create image with all detected cars (pre-heatmap)\n box_img = draw_boxes(out_img, car_windows)\n\n # Create image that is an average of the last frames heatmap\n last_heatmaps_img = heatmap.last_maps_average()\n\n # Reduce size to 1/3\n small_last_heatmaps_img = cv2.resize(last_heatmaps_img,\n (last_heatmaps_img.shape[1]//3, last_heatmaps_img.shape[0]//3))\n small_current_heatmap_img = cv2.resize(heatmap.current_map, (heatmap.shape[1]//3, heatmap.shape[0]//3))\n small_box_img = cv2.resize(box_img, (box_img.shape[1]//3, box_img.shape[0]//3))\n\n # Create debug view\n right_img = np.vstack((small_last_heatmaps_img, small_current_heatmap_img, small_box_img))\n\n # Add debug view to video\n out_img = np.hstack((label_img,\n right_img))\n else:\n out_img = np.copy(label_img)\n\n # Move current heatmap to archive, create new map for next frame\n heatmap.next_map()\n\n return out_img","def extract_feat(self, img):\r\n _, _, x = self.pre_encoder(img)\r\n x = self.backbone(x)\r\n if self.with_neck:\r\n x = self.neck(x)\r\n return x","def test_stage_0():\n\tra_1 = readImage(TRAIN_RAW_IMAGE_1)\n\tre_1 = readImage(TRAIN_RESULT_IMAGE_1)\n\n\tra_2 = readImage(TRAIN_RAW_IMAGE_2)\n\tre_2 = readImage(TRAIN_RESULT_IMAGE_2)\n\n\t# Uncomment below if more examples are required.\n\t# ra_3 = readImage(TRAIN_RAW_IMAGE_3)\n\t# re_3 = readImage(TRAIN_RESULT_IMAGE_3)\n\n\t# Uncomment below if the additional features are needed.\n\t# ra_1 += (\n\t# \tlaplace_operator(TRAIN_RAW_IMAGE_1),\\\n\t# \t# k_means(TRAIN_RAW_IMAGE_1)[0],\\\n\t# \t)\n\n\t# Uncomment below if the additional features are needed.\n\t# ra_2 += (\n\t# \tlaplace_operator(TRAIN_RAW_IMAGE_2),\\\n\t# \t# k_means(TRAIN_RAW_IMAGE_2)[0],\\\n\t# \t)\n\n\t# The prediction model is obtained and trained.\n\tengine = get_model((ra_1, ra_2,), (re_1, re_2,), model_type=SVM, percentage=0.1)\n\n\ttest_percentage = float(1) # how many tests\n\n\tra_1 = readImage(TEST_RAW_IMAGE_1)\n\n\t# Uncomment below if the additional features are needed.\n\t# ra_1 += (\n\t# \tlaplace_operator(TEST_RAW_IMAGE_1),\\\n\t# \t# k_means(TEST_RAW_IMAGE_1)[0],\\\n\t# \t)\n\n\tre_1 = readImage(TEST_RESULT_IMAGE_1)\n\n\t# ra_2 = readImage(TEST_RAW_IMAGE_2)\n\t# re_2 = readImage(TEST_RESULT_IMAGE_2)\n\n\tinput_vec = []\n\t# The features are extracted.\n\tinput_vec += buildFeatureArray_2(ra_1[0], ra_1[1], ra_1[2],\\\n\t\tRADIUS_ARRAY,\\\n\t\tadditional_feats=([] if len(ra_1) == 3 else ra_1[3:]))\n\n\tex_no = int(test_percentage * len(input_vec)) # actual number of the test sample\n\n\toutput_vec = []\n\toutput_vec += matrixToArray(re_1[0], lambda el: 1 if el == 255 else 0)\n\n\tprint('Will start predicting...')\n\n\tpredicted_vec = engine.predict(input_vec[:ex_no])\n\n\tcounter = float(0)\n\tfor y, p in zip(output_vec[:ex_no], predicted_vec[:ex_no]):\n\t\tif y == p: counter += 1\n\n\tprint('Accuracy: ' + str(counter/ex_no))\n\n\tpredicted_mat = arrayToMatrix( predicted_vec, len(re_1[0]), len(re_1[0][0]),\\\n\t\tlambda el: 255 if el == 1 else 0)\n\n\t# The predicted segmentation is saved.\n\tsave_rgb_img(\\\n\t np.array(predicted_mat).transpose(),\\\n\t np.array(predicted_mat).transpose(),\\\n\t np.array(predicted_mat).transpose(),\\\n\t 'pred.bmp',\\\n\t)","def single_img_features(img, color_space='RGB', spatial_size=(32, 32),\n hist_bins=32, orient=9,\n pix_per_cell=8, cell_per_block=2, hog_channel=0,\n spatial_feat=True, hist_feat=True, hog_feat=True, vis=False):\n # 1) Define an empty list to receive features\n img_features = []\n # 2) Apply colour conversion if other than 'RGB'\n if color_space != 'RGB':\n if color_space == 'HSV':\n feature_image = cv2.cvtColor((img, cv2.COLOR_RGB2HSV))\n elif color_space == 'LUV':\n feature_image = cv2.cvtColor((img, cv2.COLOR_RGB2LUV))\n elif color_space == 'HLS':\n feature_image = cv2.cvtColor((img, cv2.COLOR_RGB2HLS))\n elif color_space == 'YUV':\n feature_image = cv2.cvtColor((img, cv2.COLOR_RGB2YUV))\n elif color_space == 'YCrCb':\n feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb)\n # print('converting to YCrCb')\n else:\n feature_image = np.copy(img)\n\n # 3) Compute spatial features if flag is set\n if spatial_feat == True:\n spatial_features = bin_spatial(feature_image, size=spatial_size)\n # 4) Append features to list\n img_features.append(spatial_features)\n # 5) Compute histogram features if flag is set\n if hist_feat == True:\n # Apply color_hist()\n hist_features = color_hist(feature_image, nbins=hist_bins)\n # 6) Append features to list\n img_features.append(hist_features)\n # 7) Compute HOG features if flag is set\n if hog_feat == True:\n # Call get_hog_features() with vis=False, feature_vec=True\n if hog_channel == 'ALL':\n hog_features = []\n for channel in range(feature_image.shape[2]):\n hog_features.append(get_hog_features(feature_image[:, :, channel],\n orient, pix_per_cell, cell_per_block,\n vis=False, feature_vec=True))\n hog_features = np.concatenate(hog_features)\n # hog_features = np.ravel(hog_features)\n else:\n if vis == True:\n hog_features, hog_image = get_hog_features(feature_image[:, :, hog_channel], orient,\n pix_per_cell, cell_per_block, vis=True,\n feature_vec=True)\n else:\n hog_features = get_hog_features(feature_image[:, :, hog_channel], orient,\n pix_per_cell, cell_per_block, vis=False, feature_vec=True)\n # 8) Append features to list\n img_features.append(hog_features)\n\n # 9) Return concatenated array of features\n if vis == True:\n return np.concatenate(img_features), hog_image\n else:\n return np.concatenate(img_features)","def compute_features(depc, gid_list, config=None):\n logger.info('[ibs] Preprocess Features')\n logger.info('config = {!r}'.format(config))\n # Get controller\n ibs = depc.controller\n ibs.assert_valid_gids(gid_list)\n ######################################################################################\n\n if config['framework'] in ['keras']:\n from keras.preprocessing import image as preprocess_image\n\n thumbnail_config = {\n 'draw_annots': False,\n 'thumbsize': (500, 500),\n }\n thumbpath_list = depc.get(\n 'thumbnails',\n gid_list,\n 'img',\n config=thumbnail_config,\n read_extern=False,\n ensure=True,\n )\n\n target_size = (224, 224)\n if config['model'] in ['vgg', 'vgg16']:\n from keras.applications.vgg16 import VGG16 as MODEL_CLASS\n from keras.applications.vgg16 import preprocess_input\n ######################################################################################\n elif config['model'] in ['vgg19']:\n from keras.applications.vgg19 import VGG19 as MODEL_CLASS\n from keras.applications.vgg19 import preprocess_input\n ######################################################################################\n elif config['model'] in ['resnet']:\n from keras.applications.resnet50 import ResNet50 as MODEL_CLASS # NOQA\n from keras.applications.resnet50 import preprocess_input\n ######################################################################################\n elif config['model'] in ['inception']:\n from keras.applications.inception_v3 import InceptionV3 as MODEL_CLASS # NOQA\n from keras.applications.inception_v3 import preprocess_input\n\n target_size = (299, 299)\n ######################################################################################\n else:\n raise ValueError(\n 'specified feature model is not supported in config = {!r}'.format(config)\n )\n\n # Build model\n model = MODEL_CLASS(include_top=False)\n\n thumbpath_iter = ut.ProgIter(thumbpath_list, lbl='forward inference', bs=True)\n for thumbpath in thumbpath_iter:\n image = preprocess_image.load_img(thumbpath, target_size=target_size)\n image_array = preprocess_image.img_to_array(image)\n image_array = np.expand_dims(image_array, axis=0)\n image_array = preprocess_input(image_array)\n features = model.predict(image_array)\n if config['flatten']:\n features = features.flatten()\n yield (features,)\n elif config['framework'] in ['torch']:\n from wbia.algo.detect import densenet\n\n if config['model'] in ['densenet']:\n config_ = {\n 'draw_annots': False,\n 'thumbsize': (densenet.INPUT_SIZE, densenet.INPUT_SIZE),\n }\n thumbpath_list = ibs.depc_image.get(\n 'thumbnails',\n gid_list,\n 'img',\n config=config_,\n read_extern=False,\n ensure=True,\n )\n feature_list = densenet.features(thumbpath_list)\n else:\n raise ValueError(\n 'specified feature model is not supported in config = {!r}'.format(config)\n )\n\n for feature in feature_list:\n if config['flatten']:\n feature = feature.flatten()\n yield (feature,)\n else:\n raise ValueError(\n 'specified feature framework is not supported in config = {!r}'.format(config)\n )","def _preprocess_image(self, sess, image, is_first_frame):\n features, self.cropped_input_image = sess.run([self.features, self.image_after_crop], feed_dict = {\n self.image_ph: image,\n self.cropbox_ph: self.cropbox,\n })\n #by default should be [8, 8, 512]\n feature_dim = features.shape\n #logging.debug(feature_dim)\n num_features, num_channels = feature_dim\n\n if is_first_frame:\n #pad [num_features, 1]\n pad = np.zeros((num_features, 1))\n features = np.concatenate([features, pad], 1)\n #generate gt\n #gt shape: [num_features, 1]\n gt = np.reshape(preprocess.generate_gt(\n preprocess.apply_transformation(self.normalized_bbox,\n self.transformation),\n FLAGS.cropbox_grid, FLAGS.bbox_grid), [-1, 1])\n features = np.concatenate([features, gt], 1)\n else:\n #this pad contains pad and dummy gt\n pad = np.zeros((num_features, 2))\n features = np.concatenate([features, pad], 1)\n #[...,0,1,0]\n frame_delimiter = np.concatenate([\n np.zeros((1, num_channels)),\n np.ones((1, 1)),\n np.zeros((1, 1))], 1)\n features = np.concatenate([frame_delimiter, features], 0)\n return features","def map_fn(image, label):\n if is_training and train_mode == 'pretrain':\n xs = []\n for _ in range(2): # Two transformations\n xs.append(preprocess_fn_pretrain(image))\n image = tf.concat(xs, -1)\n else:\n image = preprocess_fn_finetune(image)\n label = tf.one_hot(label, num_classes)\n return image, label","def get_mask(self, input_image): \r\n guided_feed_dict = {}\r\n guided_feed_dict[self.imported_x] = input_image \r\n \r\n gradients = self.guided_sess.run(self.guided_grads_node, feed_dict = guided_feed_dict)[0][0]\r\n return gradients","def forward_dummy(self, x, proposal_boxes, proposal_feats, img_metas):\n all_stage_mask_results = []\n num_imgs = len(img_metas)\n num_proposals = proposal_feats.size(1)\n C, H, W = x.shape[-3:]\n mask_preds = proposal_feats.bmm(x.view(num_imgs, C, -1)).view(\n num_imgs, num_proposals, H, W)\n object_feats = proposal_feats\n for stage in range(self.num_stages):\n mask_results = self._mask_forward(stage, x, object_feats,\n mask_preds, img_metas)\n all_stage_mask_results.append(mask_results)\n return all_stage_mask_results","def _forward_mask(self, features: Dict[str, torch.Tensor], instances: List[Instances]):\n if not self.mask_on:\n return {} if self.training else instances\n\n if self.training:\n # head is only trained on positive proposals.\n instances, _ = select_foreground_proposals(instances, self.num_classes)\n\n if self.mask_pooler is not None:\n features = [features[f] for f in self.mask_in_features]\n boxes = [x.proposal_boxes if self.training else x.pred_boxes for x in instances]\n features = self.mask_pooler(features, boxes)\n else:\n features = {f: features[f] for f in self.mask_in_features}\n return self.mask_head(features, instances)","def getSuperPixelFeatures_pixel(image, mask):\n \n # Generate the pixel-level features for the image\n imagePixelFeatures = generatePixelFeaturesForImage(image)\n numFeaturesPerPixel = np.shape(imagePixelFeatures)[1]\n numColumns = np.shape(image)[1]\n numRows = np.shape(image)[0]\n # Get the list of regions in the superpixel mask. np.unique() seems to give consistent sorted ordering\n superPixels = np.unique(mask)\n numSuperPixels = np.size(superPixels)\n \n # Reshape (i*j , f) image feature to (i, j, f) array\n imagePixelFeatures = np.reshape( imagePixelFeatures, (numRows, numColumns, numFeaturesPerPixel) )\n \n # TODO might need a mapper to take superpixel region names and convert to ordered list from 1 to numSuperpixels.\n \n # for each superpixel, create a single feature array i.e. append the feature vectors from each pixel into single array\n # Alternatively, create a list/array of feature vectors for each super pixel\n\n allImgSuperPixelFeatures = []\n \n superPixelCount = 0\n \n for spIdx in range(0 , numSuperPixels ):\n\n superPixel = superPixels[spIdx] \n# print \"t***Processing superpixel region#\" , superPixel\n \n superPixelMask = (mask == superPixel)\n \n superPixelCount = superPixelCount + np.sum(superPixelMask)\n \n # Generate a single array of feature arrays for pixels that match superpixel number \n pixelFeaturesInSuperPixel = imagePixelFeatures[ superPixelMask, : ]\n \n allImgSuperPixelFeatures.append(pixelFeaturesInSuperPixel)\n \n assert numSuperPixels == np.shape(allImgSuperPixelFeatures)[0] , \"The number of superpixels in mask != number of superpixels in result list\"\n \n assert superPixelCount == (numRows * numColumns) , \"The number of pixels assigned to super pixels != number of pixels in image!\"\n \n for idx in range(0 , numSuperPixels ):\n assert np.shape(allImgSuperPixelFeatures[idx])[1] == numFeaturesPerPixel, \"Superpixel result #\" + str(idx) + \" does not have \" + str(numFeaturesPerPixel) + \"; has \" + str(np.shape(allImgSuperPixelFeatures[idx])[1])\n \n return allImgSuperPixelFeatures","def forward(self):\n priors = []\n for k, f in enumerate(self.feature_maps):\n scale = self.image_size / self.strides[k]\n # for i, j in product(range(f), repeat=2):\n for i in range(f[0]):\n for j in range(f[1]):\n # print(i, j)\n # unit center x,y\n cx = (j + 0.5) / scale\n cy = (i + 0.5) / scale\n\n # small sized square box\n size = self.min_sizes[k]\n h = w = size / self.image_size\n priors.append([cx, cy, w, h])\n\n # big sized square box\n size = sqrt(self.min_sizes[k] * self.max_sizes[k])\n h = w = size / self.image_size\n priors.append([cx, cy, w, h])\n\n # change h/w ratio of the small sized box\n size = self.min_sizes[k]\n h = w = size / self.image_size\n for ratio in self.aspect_ratios[k]:\n ratio = sqrt(ratio)\n priors.append([cx, cy, w * ratio, h / ratio])\n priors.append([cx, cy, w / ratio, h * ratio])\n\n priors = torch.Tensor(priors)\n if self.clip:\n priors.clamp_(max=1, min=0)\n return priors","def forward(self, x):\n sources = list()\n new_sources = list()\n\n # apply lds to the initial image\n x_pool = self.lds(x)\n\n # apply vgg up to conv4_3\n for k in range(22):\n x = self.features[k](x)\n conv4_3_bn = self.ibn1(x)\n x_pool1_skip, x_pool1_icn = self.icn1(x_pool)\n s = self.Norm1(conv4_3_bn * x_pool1_icn)\n\n # apply vgg up to fc7\n for k in range(22, 34):\n x = self.features[k](x)\n conv7_bn = self.ibn2(x)\n x_pool2_skip, x_pool2_icn = self.icn2(x_pool1_skip)\n p = self.Norm2(self.dsc1(s) + conv7_bn * x_pool2_icn)\n\n x = self.features[34](x)\n\n # apply extra layers and cache source layer outputs\n for k, v in enumerate(self.extra):\n x = v(x)\n if k == 0:\n x_pool3_skip, x_pool3_icn = self.icn3(x_pool2_skip)\n w = self.Norm3(self.dsc2(p) + x * x_pool3_icn)\n elif k == 2:\n x_pool4_skip, x_pool4_icn = self.icn4(x_pool3_skip)\n q = self.Norm4(self.dsc3(w) + x * x_pool4_icn)\n elif k == 4:\n o = self.Norm5(self.dsc4(q) + x)\n sources.append(o)\n elif k == 7 or k == 9:\n sources.append(x)\n else:\n pass\n\n # project the forward features into lower dimension.\n tmp1 = self.proj1(p)\n tmp2 = self.proj2(w)\n tmp3 = self.proj3(q)\n tmp4 = self.proj4(o)\n\n # The conv4_3 level\n proj1 = F.upsample(tmp1, scale_factor=2, mode='bilinear')\n proj2 = F.upsample(tmp2, scale_factor=4, mode='bilinear')\n proj3 = F.upsample(tmp3, scale_factor=8, mode='bilinear')\n proj4 = F.upsample(tmp4, scale_factor=16, mode='bilinear')\n proj = torch.cat([proj1, proj2, proj3, proj4], dim=1)\n\n agent1 = self.agent1(s)\n\n convert1 = self.convert1(proj)\n pred1 = torch.cat([agent1, convert1], dim=1)\n pred1 = self.merge1(pred1)\n new_sources.append(pred1)\n\n # The fc_7 level\n proj2 = F.upsample(tmp2, scale_factor=2, mode='bilinear')\n proj3 = F.upsample(tmp3, scale_factor=4, mode='bilinear')\n proj4 = F.upsample(tmp4, scale_factor=8, mode='bilinear')\n proj = torch.cat([proj2, proj3, proj4], dim=1)\n\n agent2 = self.agent2(p)\n convert2 = self.convert2(proj)\n pred2 = torch.cat([agent2, convert2], dim=1)\n pred2 = self.merge2(pred2)\n new_sources.append(pred2)\n\n # The conv8 level\n proj3 = F.upsample(tmp3, scale_factor=2, mode='bilinear')\n proj4 = F.upsample(tmp4, scale_factor=4, mode='bilinear')\n proj = torch.cat([proj3, proj4], dim=1)\n\n agent3 = self.agent3(w)\n convert3 = self.convert3(proj)\n pred3 = torch.cat([agent3, convert3], dim=1)\n pred3 = self.merge3(pred3)\n new_sources.append(pred3)\n\n # The conv9 level\n proj4 = F.upsample(tmp4, scale_factor=2, mode='bilinear')\n proj = proj4\n\n agent4 = self.agent4(q)\n convert4 = self.convert4(proj)\n pred4 = torch.cat([agent4, convert4], dim=1)\n pred4 = self.merge4(pred4)\n new_sources.append(pred4)\n\n for prediction in sources:\n new_sources.append(prediction)\n\n return new_sources","def collect_best_features(self):\n bincsp = self.binary_csp # just to make code shorter\n n_folds = len(self.binary_csp.folds)\n n_class_pairs = len(self.binary_csp.class_pairs)\n result_shape = (n_folds, n_class_pairs)\n self.train_feature = np.empty(result_shape, dtype=object)\n self.train_feature_full_fold = np.empty(result_shape, dtype=object)\n self.test_feature = np.empty(result_shape, dtype=object)\n self.test_feature_full_fold = np.empty(result_shape, dtype=object)\n self.selected_filters_per_filterband = np.empty(result_shape, dtype=object)\n for fold_i in range(n_folds):\n for class_pair_i in range(n_class_pairs):\n bin_csp_train_features = deepcopy(bincsp.train_feature[\n self.selected_filter_inds, fold_i, class_pair_i])\n bin_csp_train_features_full_fold = deepcopy(\n bincsp.train_feature_full_fold[\n self.selected_filter_inds,\n fold_i, class_pair_i])\n bin_csp_test_features = deepcopy(bincsp.test_feature[\n self.selected_filter_inds, fold_i, class_pair_i])\n bin_csp_test_features_full_fold = deepcopy(\n bincsp.test_feature_full_fold[\n self.selected_filter_inds,fold_i, class_pair_i])\n selected_filters_per_filt = self.select_best_filters_best_filterbands(\n bin_csp_train_features, max_features=self.n_features,\n forward_steps=self.forward_steps, \n backward_steps=self.backward_steps,\n stop_when_no_improvement=self.stop_when_no_improvement)\n self.train_feature[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_train_features, selected_filters_per_filt)\n self.train_feature_full_fold[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_train_features_full_fold, selected_filters_per_filt)\n \n self.test_feature[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_test_features, selected_filters_per_filt)\n self.test_feature_full_fold[fold_i, class_pair_i] = \\\n self.collect_features_for_filter_selection(\n bin_csp_test_features_full_fold, selected_filters_per_filt)\n \n self.selected_filters_per_filterband[fold_i, class_pair_i] = \\\n selected_filters_per_filt","def preprocessing_fn(inputs):\n outputs = {}\n for key in _DENSE_FLOAT_FEATURE_KEYS:\n # Preserve this feature as a dense float, setting nan's to the mean.\n outputs[_transformed_name(key)] = tft.scale_to_z_score(\n _fill_in_missing(inputs[key]))\n\n for key in _VOCAB_FEATURE_KEYS:\n # Build a vocabulary for this feature.\n outputs[_transformed_name(key)] = tft.compute_and_apply_vocabulary(\n _fill_in_missing(inputs[key]),\n top_k=_VOCAB_SIZE,\n num_oov_buckets=_OOV_SIZE)\n\n for key in _BUCKET_FEATURE_KEYS:\n outputs[_transformed_name(key)] = tft.bucketize(\n _fill_in_missing(inputs[key]), _FEATURE_BUCKET_COUNT,\n always_return_num_quantiles=False)\n\n for key in _CATEGORICAL_FEATURE_KEYS:\n outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])\n\n # Was this passenger a big tipper?\n taxi_fare = _fill_in_missing(inputs[_FARE_KEY])\n tips = _fill_in_missing(inputs[_LABEL_KEY])\n outputs[_transformed_name(_LABEL_KEY)] = tf.where(\n tf.is_nan(taxi_fare),\n tf.cast(tf.zeros_like(taxi_fare), tf.int64),\n # Test if the tip was > 20% of the fare.\n tf.cast(\n tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))\n\n return outputs","def forward(self, im1,im2,im3,im4,im5,im6):\n #edge_index_1 = data[\"edge_index_1\"]\n #edge_index_2 = data[\"edge_index_2\"]\n #features_1 = data[\"features_1\"]\n #features_2 = data[\"features_2\"]\n #print(data.shape)\n im1 = im1.unsqueeze(0)\n im2 = im2.unsqueeze(0)\n im3 = im3.unsqueeze(0)\n im4 = im4.unsqueeze(0)\n im5 = im5.unsqueeze(0)\n im6 = im6.unsqueeze(0)\n f_g_1_1 = self.backbone(im1)\n f_g_1_2 = self.backbone(im2)\n f_g_1_3 = self.backbone(im3)\n f_g_2_1 = self.backbone(im4)\n f_g_2_2 = self.backbone(im5)\n f_g_2_3 = self.backbone(im6)\n edge_index_1 = torch.tensor([[0,0,0,1,1,1,2,2,2],[0,1,2,0,1,2,0,1,2]],dtype=torch.long).cuda()\n #edge_index_1 = edge_index_1.t().contiguous()\n edge_index_2 = edge_index_1\n #print('zz11!', f_g_1_1.shape, f_g_2_3.shape, edge_index_1.shape)\n features_1 = torch.cat([f_g_1_1,f_g_1_2,f_g_1_3],dim=0)\n features_2 = torch.cat([f_g_2_1,f_g_2_2,f_g_2_3],dim=0)\n features_1 = features_1.view(3,-1)\n features_2 = features_1.view(3,-1)\n #features_1 = features_1.permute(2,3,1,0)\n #features_2 = features_2.permute(2,3,1,0)\n #print(features_1.shape, features_2.shape)\n #time.sleep(50)\n abstract_features_1 = self.convolutional_pass(edge_index_1, features_1)\n abstract_features_2 = self.convolutional_pass(edge_index_2, features_2)\n #print('alalala')\n #time.sleep(5)\n if self.args.histogram == True:\n hist = self.calculate_histogram(abstract_features_1,\n torch.t(abstract_features_2))\n\n pooled_features_1 = self.attention(abstract_features_1)\n pooled_features_2 = self.attention(abstract_features_2)\n scores = self.tensor_network(pooled_features_1, pooled_features_2)\n scores = torch.t(scores)\n\n if self.args.histogram == True:\n scores = torch.cat((scores, hist), dim=1).view(1, -1)\n\n scores = torch.nn.functional.relu(self.fully_connected_first(scores))\n score = torch.sigmoid(self.scoring_layer(scores))\n return score","def data_tf(img):\n img = crop.process(img)\n img = random_contrast.process(img)\n img = random_brightness.process(img)\n img = random_color.process(img)\n img = random_sharpness.process(img)\n if img.size[1] >= 32:\n img = compress.process(img)\n img = adjust_resolution.process(img)\n img = blur.process(img)\n img = exposure.process(img)\n # img = rotate.process(img)\n img = salt.process(img)\n img = inverse_color(img)\n img = stretch.process(img)\n return img","def forward(self, x):\n # sources保存特征图，loc与conf保存所有PriorBox的位置与类别预测特征\n sources = list()\n loc = list()\n conf = list()\n\n # 对输入图像卷积到conv4_3，将特征添加到sources中\n for k in range(23):\n x = self.vgg[k](x)\n\n s = self.L2Norm(x)\n sources.append(s)\n\n # 继续卷积到conv7，将特征添加到sources中\n for k in range(23, len(self.vgg)):\n x = self.vgg[k](x)\n sources.append(x)\n\n # 继续利用额外的卷积层计算，并将特征添加到sources中\n for k, v in enumerate(self.extras):\n x = F.relu(v(x), inplace=True)\n if k % 2 == 1: # 间隔一层\n sources.append(x)\n\n # 对sources中的特征图利用类别与位置网络进行卷积计算，并保存到loc与conf中\n for (x, l, c) in zip(sources, self.loc, self.conf):\n loc.append(l(x).permute(0, 2, 3, 1).contiguous())\n conf.append(c(x).permute(0, 2, 3, 1).contiguous())\n\n loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)\n conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)\n\n if self.phase == \"test\":\n output = self.detect(\n loc.view(loc.size(0), -1, 4), # loc preds\n self.softmax(conf.view(conf.size(0), -1, self.num_classes)), # conf preds\n self.priors.type(type(x.data)) # default boxes\n )\n else:\n # 对于训练来说，output包括了loc与conf的预测值以及PriorBox的信息\n output = (\n loc.view(loc.size(0), -1, 4),\n conf.view(conf.size(0), -1, self.num_classes),\n self.priors\n )\n return output","def state_to_features(self, game_state: dict) -> np.array:\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n # This is the dict before the game begins and after it ends\n if game_state is None:\n return None\n\n \n #get global information as a 17x17 channel\n x = game_state['field']\n x = np.swapaxes(x,0,1)\n for i in range(len(game_state['coins'])):\n a = game_state['coins'][i][1]\n b = game_state['coins'][i][0]\n x[a][b] = 4\n for i in range(len(game_state['bombs'])):\n a = game_state['bombs'][i][0][1]\n b = game_state['bombs'][i][0][0]\n x[a][b] = -(5+game_state['bombs'][i][1])\n for i in game_state['others']:\n if i[2]:\n x[i[3][1]][i[3][0]] = -10\n else:\n x[i[3][1]][i[3][0]] = -11\n if game_state['self'][2]:\n x[game_state['self'][3][1]][game_state['self'][3][0]] = 5\n else:\n x[game_state['self'][3][1]][game_state['self'][3][0]] = 6\n expl_List = np.argwhere(game_state['explosion_map'] != 0)\n for i in expl_List:\n x[i[1]][i[0]] = -4\n channel1 = x.copy()\n \n \n #prep local channel\n if self.modelToUse != 0:\n #get simpele direction to and aways from closest coin or crate if no coin on the field\n x_axis,y_axis,coin_creat_encoding = directionToNearestCoin_Crate(game_state['coins'], game_state['self'][3], game_state['field'])\n if x_axis == \"left\":\n if x[game_state['self'][3][1]][game_state['self'][3][0]-1] == 0:\n x[game_state['self'][3][1]][game_state['self'][3][0]-1] = coin_creat_encoding\n if x[game_state['self'][3][1]][game_state['self'][3][0]+1] == 0:\n x[game_state['self'][3][1]][game_state['self'][3][0]+1] = -2\n if x_axis == \"right\":\n if x[game_state['self'][3][1]][game_state['self'][3][0]-1] == 0:\n x[game_state['self'][3][1]][game_state['self'][3][0]-1] = -2\n if x[game_state['self'][3][1]][game_state['self'][3][0]+1] == 0:\n x[game_state['self'][3][1]][game_state['self'][3][0]+1] = coin_creat_encoding\n if y_axis == \"up\":\n if x[game_state['self'][3][1]-1][game_state['self'][3][0]] == 0:\n x[game_state['self'][3][1]-1][game_state['self'][3][0]] = coin_creat_encoding\n if x[game_state['self'][3][1]+1][game_state['self'][3][0]] == 0:\n x[game_state['self'][3][1]+1][game_state['self'][3][0]] = -2\n if y_axis == \"down\":\n if x[game_state['self'][3][1]-1][game_state['self'][3][0]] == 0:\n x[game_state['self'][3][1]-1][game_state['self'][3][0]] = -2\n if x[game_state['self'][3][1]+1][game_state['self'][3][0]] == 0:\n x[game_state['self'][3][1]+1][game_state['self'][3][0]] = coin_creat_encoding\n \n \n \n #get information of bombs: on which position the explotion will be and how far away the bomb is\n bombs = game_state['bombs']\n bombs.sort(key=lambda x: x[1],reverse=True)\n x = np.pad(x, (3,3), 'constant', constant_values=(-1))\n for i in (bombs):\n y_bomb = i[0][1] + 3\n x_bomb = i[0][0] + 3\n for j in range(4):\n if abs(x[y_bomb,x_bomb+j]) != 1 and x[y_bomb,x_bomb+j] != -4:\n blocked = False\n for l in range(j):\n if x[y_bomb,x_bomb+j-l] == -1:\n blocked = True\n if blocked == False:\n x[y_bomb,x_bomb+j] = -(9-j)\n #print(\"test1\")\n if abs(x[y_bomb,x_bomb-j]) != 1 and x[y_bomb,x_bomb-j] != -4:\n blocked = False\n for l in range(j):\n if x[y_bomb,x_bomb-j+l] == -1:\n blocked = True\n if blocked == False:\n x[y_bomb,x_bomb-j] = -(9-j)\n #print(\"test2\")\n if abs(x[y_bomb+j,x_bomb]) != 1 and x[y_bomb+j,x_bomb] != -4:\n blocked = False\n for l in range(j):\n if x[y_bomb+j-l,x_bomb] == -1:\n blocked = True\n if blocked == False:\n x[y_bomb+j,x_bomb] = -(9-j)\n #print(\"test3\")\n if abs(x[y_bomb-j,x_bomb]) != 1 and x[y_bomb-j,x_bomb] != -4:\n blocked = False\n for l in range(j):\n if x[y_bomb-j+l,x_bomb] == -1:\n blocked = True\n if blocked == False:\n x[y_bomb-j,x_bomb] = -(9-j)\n #print(\"test4\")\n x = x[3:-3,3:-3]\n \n \n #get local view and concatenate it with channel 1 (will be sliced apart in the model later)\n z = np.zeros(17)\n y = x[game_state['self'][3][1]-1:game_state['self'][3][1]+2,game_state['self'][3][0]-1:game_state['self'][3][0]+2]\n y = y.flatten()\n z[0:9] = y\n #get correct input for the model used\n if self.modelToUse == 2:\n z = Variable(torch.from_numpy(z)).to(device).to(torch.float)\n z = z.unsqueeze(0).unsqueeze(0).unsqueeze(0)\n channel1 = Variable(torch.from_numpy(channel1)).to(device).to(torch.float)\n channel1 = channel1.unsqueeze(0).unsqueeze(0)\n return torch.cat((channel1,z),2)\n elif self.modelToUse == 1:\n y = Variable(torch.from_numpy(y)).to(device).to(torch.float)\n y = y.unsqueeze(0)\n return y\n else:\n channel1 = Variable(torch.from_numpy(channel1)).to(device).to(torch.float)\n channel1 = channel1.unsqueeze(0).unsqueeze(0)\n return channel1\n return","def basicProcessing(volume, sigma, order, output, mode, truncate):\n\n\n #### Filters ###\n\n result = gaussian_filter(input=volume, sigma=sigma, order=order, output=output, mode=mode, truncate=truncate)\n\n val = threshold_otsu(result)\n print(\"val : {}\".format(val))\n\n mask = np.zeros(volume.shape, dtype=np.int8)\n mask[volume > val] = 1\n #mask = mask.astype(int)\n\n print(\"mask shape: {}\".format(mask.shape))\n print(mask)\n\n\n #### Morphological Operation ###\n\n # Opening removes small objects\n r1 = binary_opening(mask, structure=np.ones((3, 3, 3))).astype(np.int8)\n\n # Closing removes small holes\n r2 = binary_closing(r1, structure=np.ones((3, 3, 3))).astype(np.int8)\n\n\n # 3x3x3 structuring element with connectivity 4 or 8\n struct1 = generate_binary_structure(3, 1) # no diagonal elements\n #struct1 = generate_binary_structure(3, 2) # with diagonal elements\n ############struct1 = struct1.astype(int)\n print (struct1)\n\n\n #r3 = binary_dilation(r2).astype(int)\n r3 = binary_dilation(r2, structure=struct1).astype(int) # using a structure element\n\n # Erosion removes objects smaller than the structure\n r4 = binary_erosion(r3, structure=np.ones((3, 3, 3))).astype(np.int8)\n\n\n #### Measurements ###\n\n struct2 = np.ones((3, 3, 3), dtype=np.int8)\n labeled_array, num_features = label(r4, structure=struct2)\n\n #print(labeled_array)\n print(num_features)\n\n return labeled_array, num_features","def image_detect_and_compute(detector, img_name):\n img_building = cv2.imread(img_name)\n img_building = cv2.cvtColor(img_building, cv2.COLOR_BGR2RGB)\n sift = cv2.xfeatures2d.SIFT_create()\n kp, des = sift.detectAndCompute(img_building, None)\n img_kp = cv2.drawKeypoints(img_building, kp, img_building)\n return img_building, kp, des","def preprocess_fn(img_id, image, box, is_training):\n cv2.setNumThreads(2)\n\n def _infer_data(image, input_shape):\n img_h, img_w, _ = image.shape\n input_h, input_w = input_shape\n\n image = cv2.resize(image, (input_w, input_h))\n\n # When the channels of image is 1\n if len(image.shape) == 2:\n image = np.expand_dims(image, axis=-1)\n image = np.concatenate([image, image, image], axis=-1)\n\n return img_id, image, np.array((img_h, img_w), np.float32)\n\n def _data_aug(image, box, is_training, image_size=(600, 600)):\n \"\"\"Data augmentation function.\"\"\"\n ih, iw, _ = image.shape\n w, h = image_size\n\n if not is_training:\n return _infer_data(image, image_size)\n\n # Random crop\n box = box.astype(np.float32)\n image, box = random_sample_crop(image, box)\n ih, iw, _ = image.shape\n\n # Resize image\n image = cv2.resize(image, (w, h))\n\n # Flip image or not\n flip = _rand() < .5\n if flip:\n image = cv2.flip(image, 1, dst=None)\n\n # When the channels of image is 1\n if len(image.shape) == 2:\n image = np.expand_dims(image, axis=-1)\n image = np.concatenate([image, image, image], axis=-1)\n\n box[:, [0, 2]] = box[:, [0, 2]] / ih\n box[:, [1, 3]] = box[:, [1, 3]] / iw\n\n if flip:\n box[:, [1, 3]] = 1 - box[:, [3, 1]]\n\n box, label, num_match = retinanet_bboxes_encode(box)\n return image, box, label, num_match\n\n return _data_aug(image, box, is_training, image_size=config.img_shape)","def calculate_mAP(det_boxes, det_labels, det_scores, true_boxes, true_labels, true_difficulties, on_dev, data_folder):\n with open(os.path.join(data_folder,'label_map.json'), 'r') as j:\n label_map = json.load(j)\n \n rev_label_map = {v: k for k, v in label_map.items()} \n if on_dev:\n device = det_boxes[0].device # torch.device('cuda:1')\n \n # these are all lists of tensors of the same length, i.e. number of images\n assert len(det_boxes) == len(det_labels) == len(det_scores) == len(true_boxes) == len(true_labels) == len(true_difficulties) \n n_classes = len(label_map)\n \n # Store all (true) objects in a single continuous tensor while keeping track of the image it is from\n true_images = list()\n for i in range(len(true_labels)):\n true_images.extend([i] * true_labels[i].size(0))\n # ==============================================================================================================================\n if on_dev:\n true_images = torch.LongTensor(true_images).to(device)#-(n_objects), n_objects is the total no. of objects across all images\n else:\n true_images = torch.LongTensor(true_images).cuda()#-----(n_objects), n_objects is the total no. of objects across all images\n \n true_boxes = torch.cat(true_boxes, dim=0)#------------------(n_objects, 4)\n true_labels = torch.cat(true_labels, dim=0)#----------------(n_objects)\n true_difficulties = torch.cat(true_difficulties, dim=0)#----(n_objects)\n # ==============================================================================================================================\n assert true_images.size(0) == true_boxes.size(0) == true_labels.size(0)\n\n # Store all detections in a single continuous tensor while keeping track of the image it is from\n det_images = list()\n for i in range(len(det_labels)):\n det_images.extend([i] * det_labels[i].size(0))\n \n if on_dev:\n det_images = torch.LongTensor(det_images).to(device) # (n_detections)\n else:\n det_images = torch.LongTensor(det_images).cuda() # (n_detections)\n \n det_boxes = torch.cat(det_boxes, dim=0) # (n_detections, 4)\n det_labels = torch.cat(det_labels, dim=0) # (n_detections)\n det_scores = torch.cat(det_scores, dim=0) # (n_detections)\n\n assert det_images.size(0) == det_boxes.size(0) == det_labels.size(0) == det_scores.size(0)\n\n # Calculate APs for each class (except background)\n average_precisions = torch.zeros((n_classes - 1), dtype=torch.float) # (n_classes - 1)\n for c in range(1, n_classes):\n # Extract only objects with this class\n true_class_images = true_images[true_labels == c] # (n_class_objects)\n true_class_boxes = true_boxes[true_labels == c] # (n_class_objects, 4)\n true_class_difficulties = true_difficulties[true_labels == c] # (n_class_objects)\n n_easy_class_objects = (1 - true_class_difficulties).sum().item() # ignore difficult objects\n\n # Keep track of which true objects with this class have already been 'detected'\n # So far, none\n if on_dev:\n true_class_boxes_detected = torch.zeros((true_class_difficulties.size(0)), dtype=torch.uint8).to(device)#(n_class_objects)\n else:\n true_class_boxes_detected = torch.zeros((true_class_difficulties.size(0)), dtype=torch.uint8).cuda() # (n_class_objects)\n\n # Extract only detections with this class\n det_class_images = det_images[det_labels == c] # (n_class_detections)\n det_class_boxes = det_boxes[det_labels == c] # (n_class_detections, 4)\n det_class_scores = det_scores[det_labels == c] # (n_class_detections)\n n_class_detections = det_class_boxes.size(0)\n if n_class_detections == 0:\n continue\n\n # Sort detections in decreasing order of confidence/scores\n det_class_scores, sort_ind = torch.sort(det_class_scores, dim=0, descending=True) # (n_class_detections)\n det_class_images = det_class_images[sort_ind] # (n_class_detections)\n det_class_boxes = det_class_boxes[sort_ind] # (n_class_detections, 4)\n\n # In the order of decreasing scores, check if true or false positive\n if on_dev:\n true_positives = torch.zeros((n_class_detections), dtype=torch.float).to(device) # (n_class_detections)\n false_positives = torch.zeros((n_class_detections), dtype=torch.float).to(device) # (n_class_detections)\n else:\n true_positives = torch.zeros((n_class_detections), dtype=torch.float).cuda() # (n_class_detections)\n false_positives = torch.zeros((n_class_detections), dtype=torch.float).cuda() # (n_class_detections)\n \n for d in range(n_class_detections):\n this_detection_box = det_class_boxes[d].unsqueeze(0) # (1, 4)\n this_image = det_class_images[d] # (), scalar\n\n # Find objects in the same image with this class, their difficulties, and whether they have been detected before\n object_boxes = true_class_boxes[true_class_images == this_image] # (n_class_objects_in_img)\n object_difficulties = true_class_difficulties[true_class_images == this_image] # (n_class_objects_in_img)\n # If no such object in this image, then the detection is a false positive\n if object_boxes.size(0) == 0:\n false_positives[d] = 1\n continue\n\n # Find maximum overlap of this detection with objects in this image of this class\n overlaps = find_jaccard_overlap(this_detection_box, object_boxes) # (1, n_class_objects_in_img)\n max_overlap, ind = torch.max(overlaps.squeeze(0), dim=0) # (), () - scalars\n\n # 'ind' is the index of the object in these image-level tensors 'object_boxes', 'object_difficulties'\n # In the original class-level tensors 'true_class_boxes', etc., 'ind' corresponds to object with index...\n original_ind = torch.LongTensor(range(true_class_boxes.size(0)))[true_class_images == this_image][ind]\n # We need 'original_ind' to update 'true_class_boxes_detected'\n\n # If the maximum overlap is greater than the threshold of 0.5, it's a match\n if max_overlap.item() > 0.5:\n # If the object it matched with is 'difficult', ignore it\n if object_difficulties[ind] == 0:\n # If this object has already not been detected, it's a true positive\n if true_class_boxes_detected[original_ind] == 0:\n true_positives[d] = 1\n true_class_boxes_detected[original_ind] = 1 # this object has now been detected/accounted for\n # Otherwise, it's a false positive (since this object is already accounted for)\n else:\n false_positives[d] = 1\n # Otherwise, the detection occurs in a different location than the actual object, and is a false positive\n else:\n false_positives[d] = 1\n\n # Compute cumulative precision and recall at each detection in the order of decreasing scores\n cumul_true_positives = torch.cumsum(true_positives, dim=0) # (n_class_detections)\n cumul_false_positives = torch.cumsum(false_positives, dim=0) # (n_class_detections)\n cumul_precision = cumul_true_positives / (\n cumul_true_positives + cumul_false_positives + 1e-10) # (n_class_detections)\n cumul_recall = cumul_true_positives / n_easy_class_objects # (n_class_detections)\n\n # Find the mean of the maximum of the precisions corresponding to recalls above the threshold 't'\n recall_thresholds = torch.arange(start=0, end=1.1, step=.1).tolist() # (11)\n if on_dev:\n precisions = torch.zeros((len(recall_thresholds)), dtype=torch.float).to(device) # (11)\n else:\n precisions = torch.zeros((len(recall_thresholds)), dtype=torch.float).cuda()\n for i, t in enumerate(recall_thresholds):\n recalls_above_t = cumul_recall >= t\n if recalls_above_t.any():\n precisions[i] = cumul_precision[recalls_above_t].max()\n else:\n precisions[i] = 0.\n average_precisions[c - 1] = precisions.mean() # c is in [1, n_classes - 1]\n\n # Calculate Mean Average Precision (mAP)\n mean_average_precision = average_precisions.mean().item()\n\n # Keep class-wise average precisions in a dictionary\n average_precisions = {rev_label_map[c + 1]: v for c, v in enumerate(average_precisions.tolist())}\n\n return average_precisions, mean_average_precision","def _getFeatures(self, image):\n\n self.model.eval()\n lin_block = 0\n blockwise_features = [image]\n feature = image\n\n for m in self.model.modules():\n # Assume modules are arranged in \"chronological\" fashion\n\n if isinstance(m, nn.ReLU):\n # Get pre-ReLU activations for conv layers\n if len(feature.size()) == 4:\n blockwise_features.append(feature)\n\n if linearity_test(m) is not None:\n if isinstance(m, nn.Linear):\n feature = feature.view(feature.size(0),-1)\n feature = m(feature)\n\n return feature, blockwise_features","def _forward_mask_point(self, features, mask_coarse_logits, instances):\n if not self.mask_point_on:\n return {} if self.training else mask_coarse_logits\n\n mask_features_list = [features[k] for k in self.mask_point_in_features]\n features_scales = [self._feature_scales[k] for k in self.mask_point_in_features]\n\n if self.training:\n proposal_boxes = [x.proposal_boxes for x in instances]\n gt_classes = cat([x.gt_classes for x in instances])\n with torch.no_grad():\n point_coords = get_uncertain_point_coords_with_randomness(\n mask_coarse_logits,\n lambda logits: calculate_uncertainty_ins_seg(logits, gt_classes),\n self.mask_point_train_num_points,\n self.mask_point_oversample_ratio,\n self.mask_point_importance_sample_ratio,\n )\n\n fine_grained_features, point_coords_wrt_image = point_sample_fine_grained_features(\n mask_features_list, features_scales, proposal_boxes, point_coords\n )\n coarse_features = point_sample(mask_coarse_logits, point_coords, align_corners=False)\n point_logits = self.mask_point_head(fine_grained_features, coarse_features)\n return {\n \"loss_mask_point\": roi_mask_point_loss(\n point_logits, instances, point_coords_wrt_image\n )\n }\n else:\n pred_boxes = [x.pred_boxes for x in instances]\n pred_classes = cat([x.pred_classes for x in instances])\n # The subdivision code will fail with the empty list of boxes\n if len(pred_classes) == 0:\n return mask_coarse_logits\n\n mask_logits = mask_coarse_logits.clone()\n for subdivions_step in range(self.mask_point_subdivision_steps):\n mask_logits = interpolate(\n mask_logits, scale_factor=2, mode=\"bilinear\", align_corners=False\n )\n # If `mask_point_subdivision_num_points` is larger or equal to the\n # resolution of the next step, then we can skip this step\n H, W = mask_logits.shape[-2:]\n if (\n self.mask_point_subdivision_num_points >= 4 * H * W\n and subdivions_step < self.mask_point_subdivision_steps - 1\n ):\n continue\n uncertainty_map = calculate_uncertainty_ins_seg(mask_logits, pred_classes)\n point_indices, point_coords = get_uncertain_point_coords_on_grid(\n uncertainty_map, self.mask_point_subdivision_num_points\n )\n fine_grained_features, _ = point_sample_fine_grained_features(\n mask_features_list, features_scales, pred_boxes, point_coords\n )\n coarse_features = point_sample(\n mask_coarse_logits, point_coords, align_corners=False\n )\n point_logits = self.mask_point_head(fine_grained_features, coarse_features)\n\n # put mask point predictions to the right places on the upsampled grid.\n R, C, H, W = mask_logits.shape\n point_indices = point_indices.unsqueeze(1).expand(-1, C, -1)\n mask_logits = (\n mask_logits.reshape(R, C, H * W)\n .scatter_(2, point_indices, point_logits)\n .view(R, C, H, W)\n )\n return mask_logits","def _extract_features(self, ti, tf):\n makedir(self.featdir)\n\n # number of windows in feature request\n Nw = int(np.floor(((tf-ti)/self.dt)/(self.iw-self.io)))\n\n # features to compute\n cfp = ComprehensiveFCParameters()\n if self.compute_only_features:\n cfp = dict([(k, cfp[k]) for k in cfp.keys() if k in self.compute_only_features])\n else:\n # drop features if relevant\n _ = [cfp.pop(df) for df in self.drop_features if df in list(cfp.keys())]\n\n # check if feature matrix already exists and what it contains\n if os.path.isfile(self.featfile):\n t = pd.to_datetime(pd.read_csv(self.featfile, index_col=0, parse_dates=['time'], usecols=['time'], infer_datetime_format=True).index.values)\n ti0,tf0 = t[0],t[-1]\n Nw0 = len(t)\n hds = pd.read_csv(self.featfile, index_col=0, nrows=1)\n hds = list(set([hd.split('__')[1] for hd in hds]))\n\n # option 1, expand rows\n pad_left = int((ti0-ti)/self.dto)# if ti < ti0 else 0\n pad_right = int(((ti+(Nw-1)*self.dto)-tf0)/self.dto)# if tf > tf0 else 0\n i0 = abs(pad_left) if pad_left<0 else 0\n i1 = Nw0 + max([pad_left,0]) + pad_right\n \n # option 2, expand columns\n existing_cols = set(hds) # these features already calculated, in file\n new_cols = set(cfp.keys()) - existing_cols # these features to be added\n more_cols = bool(new_cols)\n all_cols = existing_cols|new_cols\n cfp = ComprehensiveFCParameters()\n cfp = dict([(k, cfp[k]) for k in cfp.keys() if k in all_cols])\n\n # option 3, expand both\n if any([more_cols, pad_left > 0, pad_right > 0]) and self.update_feature_matrix:\n fm = pd.read_csv(self.featfile, index_col=0, parse_dates=['time'], infer_datetime_format=True)\n if more_cols:\n # expand columns now\n df0, wd = self._construct_windows(Nw0, ti0)\n cfp0 = ComprehensiveFCParameters()\n cfp0 = dict([(k, cfp0[k]) for k in cfp0.keys() if k in new_cols])\n fm2 = extract_features(df0, column_id='id', n_jobs=self.n_jobs, default_fc_parameters=cfp0, impute_function=impute)\n fm2.index = pd.Series(wd)\n \n fm = pd.concat([fm,fm2], axis=1, sort=False)\n\n # check if updates required because training period expanded\n # expanded earlier\n if pad_left > 0:\n df, wd = self._construct_windows(Nw, ti, i1=pad_left)\n fm2 = extract_features(df, column_id='id', n_jobs=self.n_jobs, default_fc_parameters=cfp, impute_function=impute)\n fm2.index = pd.Series(wd)\n fm = pd.concat([fm2,fm], sort=False)\n # expanded later\n if pad_right > 0:\n df, wd = self._construct_windows(Nw, ti, i0=Nw - pad_right)\n fm2 = extract_features(df, column_id='id', n_jobs=self.n_jobs, default_fc_parameters=cfp, impute_function=impute)\n fm2.index = pd.Series(wd)\n fm = pd.concat([fm,fm2], sort=False)\n \n # write updated file output\n fm.to_csv(self.featfile, index=True, index_label='time')\n # trim output\n fm = fm.iloc[i0:i1] \n else:\n # read relevant part of matrix\n fm = pd.read_csv(self.featfile, index_col=0, parse_dates=['time'], infer_datetime_format=True, header=0, skiprows=range(1,i0+1), nrows=i1-i0)\n else:\n # create feature matrix from scratch \n df, wd = self._construct_windows(Nw, ti)\n fm = extract_features(df, column_id='id', n_jobs=self.n_jobs, default_fc_parameters=cfp, impute_function=impute)\n fm.index = pd.Series(wd)\n fm.to_csv(self.featfile, index=True, index_label='time')\n \n ys = pd.DataFrame(self._get_label(fm.index.values), columns=['label'], index=fm.index)\n return fm, ys","def deep_features(img_paths, model, func_preprocess_input, target_size=(224, 224, 3),\n crop_amount=None, flip_axis=None, func_postprocess_features=spatial_average_pooling):\n\n features = []\n for img_path in img_paths:\n if crop_amount is None:\n img = image.load_img(img_path, target_size=target_size)\n x = image.img_to_array(img)\n else:\n x = crop_resize_img(img_path, target_size, crop_amount)\n\n if flip_axis is not None:\n x = image.flip_axis(x, flip_axis)\n\n x = np.expand_dims(x, axis=0)\n x = func_preprocess_input(x)\n responses = model.predict(x)\n\n if func_postprocess_features is not None:\n responses = func_postprocess_features(responses)\n\n features.append(responses)\n\n features = np.squeeze(np.asarray(features))\n\n return features","def pre_analyse():\n t = transform()\n model = modified_resnet50()\n model.load_state_dict(\n torch.load(\n \"model.pth.tar\",\n map_location=torch.device(\"cpu\"),\n )[\"state_dict\"]\n )\n model.eval()\n\n def get_preds(img_path):\n \"\"\"\n Gives labelds and probabilities for a single image\n This is were we preprocess the image, using a function defined in the model class\n \"\"\"\n # load image\n img = Image.open(img_path).convert(\"RGB\")\n # process it\n x = t(img)\n # get in in the right format\n x = Variable(x).unsqueeze(0)\n # predictions\n output = model(x)\n # decode\n output = decode(output.cpu().data.numpy()[0])\n\n # filter\n # return pred, proba\n return output\n\n return get_preds(\"image.jpg\")","def __init__(self, img):\n self.origi = imutils.resize(img, width=100)\n self.img = self.origi.copy()\n self.th = np.zeros_like(self.img)\n self.th[:, :, 0] = cv2.adaptiveThreshold(cv2.cvtColor(self.img, cv2.COLOR_BGR2GRAY), 255,\n cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)\n kernel = np.ones((2, 2), np.uint8)\n self.th[:, :, 0] = cv2.morphologyEx(self.th[:, :, 0], cv2.MORPH_CLOSE, kernel)\n self.th[:, :, 1] = self.th[:, :, 2] = self.th[:, :, 0]\n self.kp = None\n self.kpimg = np.zeros_like(img)\n self.segmented = np.zeros_like(img)\n self.fast = cv2.FastFeatureDetector_create()","def forward(self, images):\n with torch.no_grad():\n features = self.resnet(images)\n features = features.reshape(features.size(0), -1)\n features = self.bn(self.linear(features))\n return features","def early_gradient_fusion():\n pass"],"string":"[\n \"def feature(input_dir, input_img, mask, output_dir, window_size):\\n\\t# Get the pixel array of the ROI\\n\\tws = int(float(window_size))\\n\\tfilename = os.path.join(input_dir, input_img)\\n\\tim = nib.load(filename)\\n\\taffine = im.affine\\n\\timg = im.get_data() \\n\\t# img= (img - img.min()) / (np.sort(img,axis=None)[-10] - img.min()) * 255\\n\\t# img[img<0]=0\\n\\t# img[img>255]=255\\n\\t# fea_img = nib.Nifti1Image(img, affine)\\n\\t# nib.save(fea_img, output_dir + 'Img_255.nii.gz')\\t\\n\\tMask=nib.load(os.path.join(input_dir, mask)).get_data()\\n\\t# Slices=np.unique(np.where(Mask==1)[2])\\n\\t# img=img[:,:,tuple(Slices)]\\n\\t# Mask=Mask[:,:,tuple(Slices)]\\n\\t\\\"\\\"\\\" Local feature calculation \\\"\\\"\\\"\\n\\tif len(img.shape)>2:\\n\\t\\tlength, width, height = img.shape\\n\\telse:\\n\\t\\timg=img.reshape(img.shape[0],img.shape[1],1)\\n\\t\\tMask=Mask.reshape(img.shape[0],img.shape[1],1)\\n\\t\\tlength, width, height = img.shape\\n\\t# number of the features\\n\\tn_fea = 99\\n\\tfea = np.zeros((length, width, height, n_fea))\\n\\tfor h in range(height):\\n\\t\\tfor l in range(length):\\n\\t\\t\\tfor w in range(width):\\n\\t\\t\\t\\tif Mask[l,w,h]==0:\\n\\t\\t\\t\\t\\tcontinue\\n\\t\\t\\t\\tpatch0 = img[max((l - ws),0):min(length,(l + ws)), max((w - ws),0):min(width,(w + ws)), h]\\n\\t\\t\\t\\tl0, w0 = patch0.shape\\n\\t\\t\\t\\tpatch = np.array(np.reshape(patch0, (1, l0 * w0)))\\n\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tfirst order statistics based feature\\n\\t\\t\\t\\tlist {max, min, median, 25percentile, 75percentile, std, skew, kurtosis, entropy}\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tfea[l, w, h, 0] = np.max(patch[0])\\n\\t\\t\\t\\tfea[l, w, h, 1] = np.min(patch[0])\\n\\t\\t\\t\\tfea[l, w, h, 2] = np.median(patch[0])\\n\\t\\t\\t\\tfea[l, w, h, 3] = np.percentile(patch[0], 25)\\n\\t\\t\\t\\tfea[l, w, h, 4] = np.percentile(patch[0], 75)\\n\\t\\t\\t\\tfea[l, w, h, 5] = np.percentile(patch[0], 75)-np.percentile(patch[0], 25)\\n\\t\\t\\t\\tfea[l, w, h, 6] = np.std(patch[0])\\n\\t\\t\\t\\tfea[l, w, h, 7] = stats.skew(patch[0])\\n\\t\\t\\t\\tfea[l, w, h, 8] = stats.kurtosis(patch[0])\\n\\t\\t\\t\\thist = stats.histogram(patch[0], numbins=5)\\n\\t\\t\\t\\tfea[l, w, h, 9] = stats.entropy(hist.count / np.sum(hist.count))\\n\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tGLCM based feature\\n\\t\\t\\t\\tlist {angular second moment, contrast, correlation, variance, inverse difference moment,\\n\\t\\t\\t\\tsum average, sum variance, sum entropy, entropy, difference variance, difference entropy,\\n\\t\\t\\t\\tinfo. measure. of corr. 1, info. measure. of corr. 2, max. correlation coefficient}\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tpatch2 = np.array((patch0 - img.min()) / (img.max() - img.min()) * 256, dtype=np.uint8)\\n\\t\\t\\t\\tg_matrix = features.haralick(patch2)\\n\\t\\t\\t\\tfea[l, w, h, 10:23] = np.mean(g_matrix, axis=0)\\n\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tLocal Binary Patterns based shape descriptors {7 first order statistics on histogram of LBP}\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tlbp = local_binary_pattern(patch0, 8, ceil(ws/2), 'default')\\n\\t\\t\\t\\tfea[l, w, h, 23] = np.max(lbp)\\n\\t\\t\\t\\tfea[l, w, h, 24] = np.min(lbp)\\n\\t\\t\\t\\tfea[l, w, h, 25] = np.median(lbp)\\n\\t\\t\\t\\tfea[l, w, h, 26] = np.percentile(lbp, 25)\\n\\t\\t\\t\\tfea[l, w, h, 27] = np.percentile(lbp, 75)\\n\\t\\t\\t\\tfea[l, w, h, 28] = np.percentile(lbp, 75)-np.percentile(lbp, 25)\\n\\t\\t\\t\\tfea[l, w, h, 29] = np.std(lbp)\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tHu Moment based shape descriptor {7 moments}\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tm = moments(np.array(patch0, dtype=np.float))\\n\\t\\t\\t\\tcr = m[0, 1] / m[0, 0]\\n\\t\\t\\t\\tcc = m[1, 0] / m[0, 0]\\n\\t\\t\\t\\tcm = moments_central(np.array(patch0, dtype=np.float), cr, cc)\\n\\t\\t\\t\\tncm = moments_normalized(cm)\\n\\t\\t\\t\\thum = moments_hu(ncm)\\n\\t\\t\\t\\tfea[l, w, h, 30:37] = hum\\n\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tZernike moment based shape descriptors {first 8 moments}\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tzm = features.zernike_moments(patch0, ws)\\n\\t\\t\\t\\tfea[l, w, h, 37:45] = zm[1:9]\\t\\t\\n\\t\\t\\t\\t\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\tThreshold Adjacency Statistics based shape descriptors {9 statistics} * 6 = 54\\n\\t\\t\\t\\t\\\"\\\"\\\"\\n\\t\\t\\t\\ttas = features.tas(patch0)\\n\\t\\t\\t\\t# lentas = len(tas)\\n\\t\\t\\t\\tfea[l, w, h, 45:100] = tas[:54]\\n\\t# Save all the local feature maps in NIFTI format\\t\\n\\tfeaturedir=os.path.join(output_dir,'Size'+str(window_size))\\n\\tif not os.path.exists(featuredir):\\n\\t\\tos.makedirs(featuredir)\\t\\n\\tfor ii in range(n_fea):\\n\\t\\toutput_filename = featuredir+'/fea_'+str(ii+1)+'.nii.gz'\\n\\t\\tdata = np.reshape(fea[:, :, :, ii], (length, width, height))\\n\\t\\tfea_img = nib.Nifti1Image(data, affine)\\n\\t\\tnib.save(fea_img, output_filename)\",\n \"def precompute(self, features, mode, params):\\n return None\",\n \"def __call__(self, prediction, fg_mask, image):\\n # prediction = self.pooling(prediction)\\n # fg_mask = self.pooling(fg_mask)\\n N, C, H, W = prediction.size()\\n bg = prediction*(1-fg_mask)\\n fg = prediction*fg_mask\\n\\n\\n fg_patch = fg.view(N,C,-1).permute(0,2,1)\\n bg_patch = bg.view(N,C,-1)\\n\\n fg_patch_mu = torch.mean(fg_patch, dim=2, keepdim=True)\\n bg_patch_mu = torch.mean(bg_patch, dim=1, keepdim=True)\\n fg_bg_local_conv = torch.matmul((fg_patch-fg_patch_mu), (bg_patch-bg_patch_mu))/(C-1)\\n\\n bg_distribution_std = (torch.var(bg_patch, dim=1, keepdim=True) + 1e-8).sqrt()\\n fg_distribution_std = (torch.var(fg_patch, dim=2, keepdim=True) + 1e-8).sqrt()\\n fg_bg_r = fg_bg_local_conv.div(torch.matmul(fg_distribution_std,bg_distribution_std)+1e-8)\\n fg_bg_r = fg_bg_r.abs()\\n # fg_bg_r[fg_bg_r<0.7] = 0\\n\\n pixel_count = H*W\\n # # bg_patch_one = bg.unsqueeze(1).repeat(1, pixel_count, 1, 1, 1)\\n # # fg_patch_one = fg.view(N,C,-1).permute(0,2,1).unsqueeze(-1).unsqueeze(-1).expand_as(bg_patch_one)\\n # bg_patch_one = bg.permute(0,2,1,3).permute(0,1,3,2).unsqueeze(1)\\n # fg_patch_one = fg.view(N,C,-1).permute(0,2,1).unsqueeze(-2).unsqueeze(-2)\\n # fg_bg_L1 = (fg_patch_one-bg_patch_one).pow(2).mean(dim=-1)\\n # fg_bg_L1_drop_fg = fg_bg_L1*(1-fg_mask)\\n\\n # fg_mask_channel = fg_mask.view(N, -1, 1, 1).expand_as(fg_bg_L1)\\n # fg_bg_L1_only_fg = fg_bg_L1_drop_fg*fg_mask_channel\\n\\n # # fg_bg_local_conv[fg_bg_local_conv<0] = 0\\n # # fg_bg_local_conv = torch.softmax(fg_bg_local_conv, dim=2)\\n # # local_loss = fg_bg_L1_only_fg.view(N, pixel_count, pixel_count)*fg_bg_local_conv.permute(0,2,1).detach()\\n # local_loss = fg_bg_L1_only_fg.view(N, pixel_count, -1)*fg_bg_r\\n # fg_mask_sum = fg_mask.view(N, -1).sum(dim=1)\\n\\n C1 = 0.01**2\\n image = self.adaptivepooling(image)\\n # image = F.adaptive_avg_pool2d(image, 32)\\n # print(image.size())\\n image_fg = image*fg_mask\\n image_bg = image*(1-fg_mask)\\n image_fg_mu = image_fg.mean(dim=1)\\n image_bg_mu = image_bg.mean(dim=1)\\n image_fg_patch_one = image_fg_mu.view(N, -1,1)\\n image_bg_patch_one = image_bg_mu.view(N, -1,1)\\n image_fg_patch_one_sq = image_fg_patch_one.pow(2)\\n image_bg_patch_one_sq = image_bg_patch_one.pow(2)\\n\\n luminance = torch.matmul(image_fg_patch_one, image_bg_patch_one.permute(0,2,1)+C1).div(image_fg_patch_one_sq+image_bg_patch_one_sq+C1)\\n # image_bg_patch_one = image_bg.permute(0,2,1,3).permute(0,1,3,2).unsqueeze(1)\\n # image_fg_patch_one = image_fg.view(N,image_fg.size(1),-1).permute(0,2,1).unsqueeze(-2).unsqueeze(-2)\\n # fg_bg_L1 = (image_fg_patch_one-image_bg_patch_one).pow(2).mean(dim=-1)\\n fg_bg_loss = luminance\\n \\n fg_bg_loss_drop_fg = fg_bg_loss*(1-fg_mask.view(N,1, -1))\\n fg_mask_channel = fg_mask.view(N, -1, 1).expand_as(fg_bg_loss)\\n fg_bg_loss_only_fg = fg_bg_loss_drop_fg*fg_mask_channel\\n local_loss = fg_bg_loss_only_fg*fg_bg_r.detach()\\n\\n local_loss = local_loss.mean()\\n loss = local_loss\\n # if target_is_real:\\n # loss = local_loss # self.relu(1-prediction.mean())\\n # else:\\n # loss = -local_loss # self.relu(1+prediction.mean())\\n return loss\",\n \"def Get_Predictors_At_XY(Focal_Features, Image_Features, feature_dict, mask_in = None,\\n convert_length = 0.2204315, radius = 50, verbose = False):\\n \\n ## Expand mask into one-hot mask if input is flat\\n #print('z')\\n ## Define factor by which to convert pixel area to area in square meters\\n convert_area = convert_length**2\\n #print('y')\\n ## create mask and index list that shows which image_features are buildings\\n mask_buildings = Image_Features.Type.isin(['mBuild', 'tBuild']) \\n ind_buildings = list(mask_buildings[mask_buildings].index) \\n nbuildings = len(ind_buildings)\\n #print('x')\\n ## Create submasks that distinguish modern buildings from huts \\n mask_mods = Image_Features.Type[mask_buildings].isin(['mBuild'])\\n ind_mods = list(mask_mods[mask_mods].index)\\n mask_huts = Image_Features.Type[mask_buildings].isin(['tBuild'])\\n ind_huts = list(mask_huts[mask_huts].index)\\n #print('w')\\n \\n ## Calculate distances between Focal features and buildings\\n distance_mat = dist(Focal_Features.loc[:,{'x','y'}], \\n Image_Features.loc[ind_buildings,{'x','y'}])\\n #print('v') \\n Focal_Features.loc[:, 'Local_Buildings'] = None\\n Focal_Features.loc[:, 'Local_Moderns'] = None\\n Focal_Features.loc[:, 'Local_Traditionals'] = None\\n Focal_Features.loc[:, 'Local_Focal_Area'] = 3.14159*radius**2\\n #print('u') \\n nfeatures = Focal_Features.shape[0]\\n\\n ## Extract features from convolutional mask if provided\\n if mask_in is not None:\\n for val in feature_dict.keys():\\n ival = int(val)\\n feature_name = 'Local_' + feature_dict[val] + '_Area'\\n Focal_Features.loc[:, feature_name] = mask_in[iy, ix, ival]*convert_area \\n \\n # Loop through each feature\\n for ii in range(nfeatures):\\n \\n close_buildings = (distance_mat[ii, :] < radius).sum()\\n close_mods = (distance_mat[ii, ind_mods] < radius).sum() \\n close_huts = (distance_mat[ii, ind_huts] < radius).sum() \\n #print('b' + str(ii))\\n Focal_Features.loc[ii, 'Local_Buildings'] = close_buildings \\n Focal_Features.loc[ii, 'Local_Moderns'] = close_mods \\n Focal_Features.loc[ii, 'Local_Traditionals'] = close_huts \\n if verbose:\\n print(str(ii) + ' / ' + str(nfeatures))\\n return Focal_Features\",\n \"def _precompute_image_features(img, layers, shape, save_dir):\\n # type: (np.ndarray, Union[Tuple[str], List[str]], Union[Tuple[int], List[int]]) -> Dict[str, np.ndarray]\\n features_dict = {}\\n g = tf.Graph()\\n # Choose to use cpu here because we only need to compute this once and using cpu would provide us more memory\\n # than the gpu and therefore allow us to process larger style images using the extra memory. This will not have\\n # an effect on the training speed later since the gram matrix size is not related to the size of the image.\\n with g.as_default(), g.device('/cpu:0'), tf.Session() as sess:\\n with tf.variable_scope(\\\"discriminator\\\", reuse=False):\\n image = tf.placeholder(tf.uint8, shape=shape)\\n image_float = tf.image.convert_image_dtype(image,dtype=tf.float32) * 2 - 1\\n net = vgg.net(image_float, trainable=False)\\n style_pre = np.array([img])\\n style_pre = style_pre.astype(np.uint8)\\n\\n if '0.12.0' in tf.__version__:\\n all_vars = tf.get_collection(tf.GraphKeys.GLOBAL_VARIABLES)\\n else:\\n all_vars = tf.get_collection(tf.GraphKeys.VARIABLES)\\n\\n discrim_tvars = [var for var in all_vars if var.name.startswith(\\\"discriminator\\\")]\\n saver = tf.train.Saver(discrim_tvars)\\n\\n ckpt = tf.train.get_checkpoint_state(save_dir)\\n if ckpt and ckpt.model_checkpoint_path:\\n saver.restore(sess, ckpt.model_checkpoint_path)\\n else:\\n raise AssertionError(\\\"Cannot load from save directory.\\\")\\n\\n var_not_saved = [item for item in all_vars if item not in discrim_tvars]\\n sess.run(tf.initialize_variables(var_not_saved))\\n\\n\\n for layer in layers:\\n # Calculate and store gramian.\\n features = net[layer].eval(feed_dict={image: style_pre})\\n features = np.reshape(features, (-1, features.shape[3]))\\n gram = np.matmul(features.T, features) / features.size\\n features_dict[layer] = gram\\n return features_dict\",\n \"def Get_Mask_Predictors(mask_in, Image_Features, feature_dict, \\n convert_length = 0.2204315, radius = 50, verbose = False): \\n \\n ## Expand mask into one-hot mask if input is flat\\n if len(mask_in.shape)==2:\\n mask_in = Expand_Mask(mask_in, num_class = nfeatures)\\n \\n ## Define factor by which to convert pixel area to area in square meters\\n convert_area = convert_length**2\\n \\n ## create mask and index list that shows which image_features are buildings\\n mask_buildings = Image_Features.Type.isin(['mBuild', 'tBuild']) \\n ind_buildings = list(mask_buildings[mask_buildings].index) \\n nbuildings = len(ind_buildings)\\n \\n ## Create submasks that distinguish modern buildings from huts \\n mask_mods = Image_Features.Type[mask_buildings].isin(['mBuild'])\\n ind_mods = list(mask_mods[mask_mods].index)\\n mask_huts = Image_Features.Type[mask_buildings].isin(['tBuild'])\\n ind_huts = list(mask_huts[mask_huts].index)\\n \\n ## Calculate distances between all buildings\\n distance_mat = dist(Image_Features.loc[ind_buildings,{'x','y'}])\\n \\n Image_Features.loc[:, 'Local_Buildings'] = None\\n Image_Features.loc[:, 'Local_Moderns'] = None\\n Image_Features.loc[:, 'Local_Traditionals'] = None\\n Image_Features.loc[:, 'Local_Forest_Area'] = None\\n Image_Features.loc[:, 'Local_Bare_Area'] = None\\n Image_Features.loc[:, 'Local_Modern_Area'] = None\\n Image_Features.loc[:, 'Local_Trads_Area'] = None\\n Image_Features.loc[:, 'Local_Focal_Area'] = 3.14159*radius**2\\n \\n # Loop through each building and collect statistics\\n for ii in ind_buildings:\\n ind = ind_buildings[ii]\\n building_type = Image_Features.Type[ind]\\n close_buildings = (distance_mat[ii, :] < radius).sum() - 1.0\\n close_mods = (distance_mat[ii, ind_mods] < radius).sum() - 1.0*(building_type=='mBuild')\\n close_huts = (distance_mat[ii, ind_huts] < radius).sum() - 1.0*(building_type=='tBuild')\\n ##print('b' + str(ii))\\n Image_Features.loc[ind, 'Local_Buildings'] = close_buildings \\n Image_Features.loc[ind, 'Local_Moderns'] = close_mods \\n Image_Features.loc[ind, 'Local_Traditionals'] = close_huts \\n ##print('c' + str(ii)) \\n ## Define mask that will select a circle around the focal building. Note\\n ## that 0 and 1 indices of mask / image correspond to rows (y) and cols (x)\\n x = np.arange(0, mask_in.shape[1])\\n y = np.arange(0, mask_in.shape[0])\\n ##print('d' + str(ii))\\n ## Convert distances back into pixels\\n cx = round(Image_Features.loc[ind, 'x'] / convert_length)\\n cy = round(Image_Features.loc[ind, 'y'] / convert_length)\\n r = (radius / convert_length)\\n ##print('e' + str(ii))\\n ## Make indicator mask of all pixels less than distance r from focal building\\n mask = (x[np.newaxis,:]-cx)**2 + (y[:,np.newaxis]-cy)**2 < r**2 \\n ##print('f' + str(ii)) \\n ##print('mask' + str(mask.shape) + 'mask_in' + str(mask_in.shape))\\n Image_Features.loc[ind, 'Local_Modern_Area'] = mask_in[mask,0].sum()*convert_area \\n ##print('g' + str(ii)) \\n Image_Features.loc[ind, 'Local_Trads_Area'] = mask_in[mask,1].sum()*convert_area \\n ##print('h' + str(ii)) \\n Image_Features.loc[ind, 'Local_Forest_Area'] = mask_in[mask,2].sum()*convert_area \\n ##print('i' + str(ii)) \\n Image_Features.loc[ind, 'Local_Bare_Area'] = mask_in[mask,3].sum()*convert_area \\n if verbose:\\n print(str(ii) + ' / ' + str(nbuildings))\\n return Image_Features\",\n \"def _preprocess_input(self, dataset):\\n masker = self.masker or dataset.masker\\n\\n mask_img = masker.mask_img or masker.labels_img\\n if isinstance(mask_img, str):\\n mask_img = nib.load(mask_img)\\n\\n # Ensure that protected values are not included among _required_inputs\\n assert \\\"aggressive_mask\\\" not in self._required_inputs.keys(), \\\"This is a protected name.\\\"\\n\\n if \\\"aggressive_mask\\\" in self.inputs_.keys():\\n LGR.warning(\\\"Removing existing 'aggressive_mask' from Estimator.\\\")\\n self.inputs_.pop(\\\"aggressive_mask\\\")\\n\\n # A dictionary to collect masked image data, to be further reduced by the aggressive mask.\\n temp_image_inputs = {}\\n\\n for name, (type_, _) in self._required_inputs.items():\\n if type_ == \\\"image\\\":\\n # If no resampling is requested, check if resampling is required\\n if not self.resample:\\n check_imgs = {img: nib.load(img) for img in self.inputs_[name]}\\n _check_same_fov(**check_imgs, reference_masker=mask_img, raise_error=True)\\n imgs = list(check_imgs.values())\\n else:\\n # resampling will only occur if shape/affines are different\\n # making this harmless if all img shapes/affines are the same as the reference\\n imgs = [\\n resample_to_img(nib.load(img), mask_img, **self._resample_kwargs)\\n for img in self.inputs_[name]\\n ]\\n\\n # input to NiFtiLabelsMasker must be 4d\\n img4d = concat_imgs(imgs, ensure_ndim=4)\\n\\n # Mask required input images using either the dataset's mask or the estimator's.\\n temp_arr = masker.transform(img4d)\\n\\n # An intermediate step to mask out bad voxels.\\n # Can be dropped once PyMARE is able to handle masked arrays or missing data.\\n nonzero_voxels_bool = np.all(temp_arr != 0, axis=0)\\n nonnan_voxels_bool = np.all(~np.isnan(temp_arr), axis=0)\\n good_voxels_bool = np.logical_and(nonzero_voxels_bool, nonnan_voxels_bool)\\n\\n data = masker.transform(img4d)\\n\\n temp_image_inputs[name] = data\\n if \\\"aggressive_mask\\\" not in self.inputs_.keys():\\n self.inputs_[\\\"aggressive_mask\\\"] = good_voxels_bool\\n else:\\n # Remove any voxels that are bad in any image-based inputs\\n self.inputs_[\\\"aggressive_mask\\\"] = np.logical_or(\\n self.inputs_[\\\"aggressive_mask\\\"],\\n good_voxels_bool,\\n )\\n\\n # Further reduce image-based inputs to remove \\\"bad\\\" voxels\\n # (voxels with zeros or NaNs in any studies)\\n if \\\"aggressive_mask\\\" in self.inputs_.keys():\\n n_bad_voxels = (\\n self.inputs_[\\\"aggressive_mask\\\"].size - self.inputs_[\\\"aggressive_mask\\\"].sum()\\n )\\n if n_bad_voxels:\\n LGR.warning(\\n f\\\"Masking out {n_bad_voxels} additional voxels. \\\"\\n \\\"The updated masker is available in the Estimator.masker attribute.\\\"\\n )\\n\\n for name, raw_masked_data in temp_image_inputs.items():\\n self.inputs_[name] = raw_masked_data[:, self.inputs_[\\\"aggressive_mask\\\"]]\",\n \"def computeFeatures(self, image, mask, inputImageName, **kwargs):\\n featureVector = collections.OrderedDict()\\n\\n # Calculate feature classes\\n for featureClassName, enabledFeatures in six.iteritems(self.enabledFeatures):\\n # Handle calculation of shape features separately\\n if featureClassName == 'shape':\\n continue\\n\\n if featureClassName in self.getFeatureClassNames():\\n self.logger.info('Computing %s', featureClassName)\\n\\n featureClass = self.featureClasses[featureClassName](image, mask, **kwargs)\\n\\n if enabledFeatures is None or len(enabledFeatures) == 0:\\n featureClass.enableAllFeatures()\\n else:\\n for feature in enabledFeatures:\\n featureClass.enableFeatureByName(feature)\\n\\n featureClass.calculateFeatures()\\n for (featureName, featureValue) in six.iteritems(featureClass.featureValues):\\n newFeatureName = '%s_%s_%s' % (inputImageName, featureClassName, featureName)\\n featureVector[newFeatureName] = featureValue\\n\\n return featureVector\",\n \"def do_classify(img,mask,n_sigmas,multichannel,intensity,edges,texture,sigma_min,sigma_max, downsample_value):\\n if np.ndim(img)==3:\\n features = extract_features(\\n img,\\n n_sigmas,\\n multichannel=multichannel,\\n intensity=intensity,\\n edges=edges,\\n texture=texture,\\n sigma_min=sigma_min,\\n sigma_max=sigma_max,\\n )\\n else:\\n features = extract_features(\\n np.dstack((img,img,img)),\\n n_sigmas,\\n multichannel=multichannel,\\n intensity=intensity,\\n edges=edges,\\n texture=texture,\\n sigma_min=sigma_min,\\n sigma_max=sigma_max,\\n )\\n\\n if mask is None:\\n raise ValueError(\\\"If no classifier clf is passed, you must specify a mask.\\\")\\n training_data = features[:, mask > 0].T\\n\\n training_data = memmap_feats(training_data)\\n\\n training_labels = mask[mask > 0].ravel()\\n\\n training_data = training_data[::downsample_value]\\n training_labels = training_labels[::downsample_value]\\n\\n lim_samples = 100000 #200000\\n\\n if training_data.shape[0]>lim_samples:\\n logging.info('Number of samples exceeds %i'% lim_samples)\\n ind = np.round(np.linspace(0,training_data.shape[0]-1,lim_samples)).astype('int')\\n training_data = training_data[ind,:]\\n training_labels = training_labels[ind]\\n logging.info('Samples have been subsampled')\\n logging.info('Number of samples in training data: %i' % (training_data.shape[0]))\\n print(training_data.shape)\\n\\n clf = make_pipeline(\\n StandardScaler(),\\n MLPClassifier(\\n solver='adam', alpha=1, random_state=1, max_iter=2000,\\n early_stopping=True, hidden_layer_sizes=[100, 60],\\n ))\\n logging.info(datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\"))\\n logging.info('Initializing MLP model')\\n\\n clf.fit(training_data, training_labels)\\n logging.info(datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\"))\\n logging.info('MLP model fit to data')\\n\\n del training_data, training_labels\\n\\n logging.info('Create and memory map model input data')\\n\\n data = features[:, mask == 0].T\\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\\n\\n data = memmap_feats(data)\\n logging.info('Memory mapped model input data')\\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\\n\\n labels = clf.predict(data)\\n logging.info(datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\"))\\n logging.info('Model used on data to estimate labels')\\n\\n if mask is None:\\n result = labels.reshape(img.shape[:2])\\n result2 = result.copy()\\n else:\\n result = np.copy(mask)#+1\\n result[mask == 0] = labels\\n del labels, mask\\n result2 = result.copy()\\n del result\\n\\n logging.info(datetime.now().strftime(\\\"%Y-%m-%d-%H-%M-%S\\\"))\\n logging.info('RF feature extraction and model fitting complete')\\n logging.info('percent RAM usage: %f' % (psutil.virtual_memory()[2]))\\n\\n return result2\",\n \"def extract(self,image_path):#image_path\\r\\n\\r\\n img = caffe.io.load_image(image_path)\\r\\n \\r\\n #image1=cv2.imread(caffe_root + 'examples/images/cat.jpg') \\r\\n #img=cv2.cvtColor(image1,cv2.COLOR_BGR2RGB) \\r\\n #img=img/255. \\r\\n \\r\\n\\r\\n transformed_image = self.transformer.preprocess('data', img)\\r\\n self.net.blobs['data'].data[...] = transformed_image\\r\\n ft = self.net.forward()\\r\\n ft = np.squeeze(ft['pool5/7x7_s1'])\\r\\n ft = ft / LA.norm(ft)\\r\\n return ft\",\n \"def _convert_to_features(self, img: np.ndarray) -> np.ndarray:\",\n \"def sweep_image_model():\\n for c1 in [4, 8, 16]:\\n for c2 in [2, 4]:\\n for c3 in [2, 4]:\\n for c4 in [1, 2]:\\n flags = flag_reader.read_flag()\\n print(c1)\\n flags.channel_list = c1 * np.array([1, c2, c2*c3, c2*c3*c4])\\n print('channel list = ', flags.channel_list)\\n flags.last_dim = flags.channel_list[-1]\\n flags.model_name = flags.data_set + '_channel_' + str(flags.channel_list).replace('[','').replace(']','').replace(' ','_') + \\\\\\n '_dim_last_' + str(flags.last_dim) + '_ind_' + str(flags.comp_ind) + \\\\\\n '_lr_{}_decay_{}_reg_{}_bs_{}'.format(flags.lr, flags.lr_decay_rate, flags.reg_scale, flags.batch_size)\\n print(flags.model_name)\\n training_from_flag(flags)\",\n \"def processImage(fpaths_src, label_map, fnames_src, img_idx):\\n global counter\\n \\n n_imgs = len(fpaths_src)\\n print(\\\"Processing %s -- %s/%s (%s%%)\\\"%(fnames_src[img_idx],counter,n_imgs,round(100.*counter/n_imgs)))\\n \\n path = fpaths_src[img_idx]\\n src_image_raw = Image.open(path, 'r')\\n \\n # size normalization of the image\\n if not (args.resize == None):\\n src_image_raw = src_image_raw.resize(size=(int(args.resize), int(args.resize)), resample=Image.BILINEAR)\\n \\n # convert to writable numpy array\\n src_image = np.asarray(src_image_raw, dtype=np.uint8)\\n src_image.setflags(write=True)\\n \\n # some dummy label\\n label = -99.99\\n # the labels\\n if not (label_map == {}):\\n # let the label start at 1, instead of 0\\n label = int(label_map[fnames_src[img_idx]])+1\\n else:\\n # add a dummy label (between 0 and 1)\\n label = np.random.rand()\\n \\n image_features = []\\n \\n # add the original\\n image_features.append(generateFeatures(src_image,label,args.knn))\\n \\n if args.augment == 1:\\n print \\\"Augmenting dataset...\\\"\\n # data augmentation techniques\\n rotation_angles = [i for i in xrange(36,360,36)] # samples are transformed by these rotation angles\\n \\n flip_x = True # data augmentation by flipping around x axis\\n flip_y = True # data augmentation by flipping around y axis\\n flip_xy= True # data augmentation by flipping around x AND y axis\\n \\n for angle in rotation_angles:\\n rot_matrix = cv2.getRotationMatrix2D(\\n (src_image.shape[1]/2.,src_image.shape[0]/2.),\\n angle,\\n 1.0)\\n rot_sample_crop = np.array([])\\n rot_sample_crop = cv2.warpAffine(src_image,\\n rot_matrix,\\n (src_image.shape[1],src_image.shape[0]),\\n rot_sample_crop,\\n cv2.INTER_LINEAR,\\n cv2.BORDER_REFLECT_101)\\n \\n # add the sample to the dataset\\n image_features.append(generateFeatures(rot_sample_crop,label,args.knn))\\n \\n # add 3 flipped copies\\n if flip_x:\\n rot_sample_crop_x = cv2.flip(rot_sample_crop,0)\\n image_features.append(generateFeatures(rot_sample_crop_x,label,args.knn))\\n if flip_y:\\n rot_sample_crop_y = cv2.flip(rot_sample_crop,1)\\n image_features.append(generateFeatures(rot_sample_crop_y,label,args.knn))\\n if flip_xy:\\n rot_sample_crop_xy = cv2.flip(rot_sample_crop,-1)\\n image_features.append(generateFeatures(rot_sample_crop_xy,label,args.knn))\\n \\n counter+=1\\n\\n # return a nx128 or nxk matrix for the features of all modifications of this image\\n feat_matrix = np.asarray(image_features)\\n return feat_matrix\",\n \"def get_features(img1,mask1, depth1):\\n colors = cv2.cvtColor(img1, cv2.COLOR_BGR2RGB)\\n img3 = img1.copy()\\n img1 = cv2.cvtColor(img1, cv2.COLOR_BGR2GRAY)\\n img1 = clahe.apply(img1) # Applying Clahe\\n kp, des = orb.detectAndCompute(img1, mask=mask1) # Computing ORB features\\n kp_pts = np.float32([ kp[m].pt for m in range(len(kp))]).reshape(-1,2)\\n # Getting Colors\\n col = []\\n for i in range(len(kp)):\\n col.append(colors[kp_pts[i,1].astype(int), kp_pts[i,0].astype(int)])\\n col = np.array(col)\\n # Getting 2D points\\n kp_2d = []\\n for m in range(len(kp)):\\n kp_2d.append([int(kp[m].pt[0]), int(kp[m].pt[1])])\\n kp_2d = np.array(kp_2d).reshape(-1,2)\\n \\n # Getting the 3D points\\n kp_3d, _, _ = convert_3d(kp_2d, depth1, img3)\\n \\n # Removing points with Zero depth\\n my_ind = np.where(kp_3d[:,2]!=0)[0]\\n new_kp_3d = kp_3d[my_ind,:]\\n new_kp_2d = kp_2d[my_ind,:]\\n new_des = des[my_ind,:]\\n new_col = col[my_ind,:]\\n \\n # Removing the duplicates\\n uni_3d = np.unique(new_kp_3d, return_index= True, axis=0)[1]\\n new_kp_3d1 = new_kp_3d[uni_3d,:]\\n new_kp_2d1 = new_kp_2d[uni_3d,:]\\n new_des1 = new_des[uni_3d,:]\\n new_col1 = new_col[uni_3d,:]\\n return kp_3d, kp_2d, des, col\",\n \"def forward(self, img):\\n device = torch.device('cuda') if torch.cuda.is_available() else torch.device('cpu')\\n H, W = img.size()[2], img.size()[3]\\n #print('x',x)\\n #print('x.shape',x.shape) ## 32 x 3 x 96 x 128\\n z32 = self.start(img)\\n z64 = self.layer1(z32) + self.layer1_ds(z32)\\n #print('z1',z64.shape)\\n z128 = self.layer2(z64) + self.layer2_ds(z64)\\n #print('z2',z128.shape)\\n z256 = self.layer3(z128) + self.layer3_ds(z128)\\n #print('z3',z256.shape)\\n z256d = self.drop_out_layer(z256)\\n #print('z_drop',z256d.shape)\\n z256u = self.layer4(z256d)\\n #print('z4',z256u.shape)\\n z128u = self.layer5(torch.cat((z256u, F.interpolate(z256d,size=z256u.size()[2:] )), 1))\\n #print('z5',z128u.shape)\\n z64u = self.layer6(torch.cat((z128u, F.interpolate(z128,size=z128u.size()[2:] )), 1))\\n #print('z6',z64u.shape)\\n\\n z32u = self.final(torch.cat((z64u, F.interpolate(z64,size=z64u.size()[2:] )), 1))\\n #print('z6_plus',z32u.shape)\\n\\n #print('z7_result',self.classifer(z32u)[:, :, :H, :W].shape)\\n result_class = self.classifer(z32u)[:, :, :H, :W]\\n\\n #print('model result shape',result_class.shape)\\n ## 16 x 1 x 300 x 400\\n\\n # using soft argmax\\n spa_argmax = spatial_argmax(torch.squeeze(result_class,1))\\n\\n #one hot with spatial argmax\\n #xy_val = torch.zeros(spa_argmax.shape).float()\\n #for idx, pt in enumerate(spa_argmax):\\n # x_val = (pt[0]+1.0)*63.5\\n # y_val = (pt[1]+1.0)*47.5\\n # # for each batch. [0...127][0...95]\\n # xy_val[idx][0] = x_val\\n # xy_val[idx][1] = y_val\\n\\n xy_val = (spa_argmax+1.0).to(device)\\n #print('spa_argmax',spa_argmax)\\n scaling_factor = torch.FloatTensor([[(W-1)/2,0.],[0.,(H-1)/2]]).to(device)\\n #scaling_factor = torch.FloatTensor([[63.5,0.],[0.,44.5]]).to(device)\\n xy_val = xy_val.mm(scaling_factor)\\n\\n return xy_val\",\n \"def forward(self, images):\\n # assuming that the precomputed features are not already l2-normalized\\n #x = l2norm(images.view( images.size(0), -1))\\n #print(images.shape, self.fc )\\n resnet_feat=torch.empty(len(images),2048)\\n vse_feat=torch.empty(len(images),256)\\n\\n for idx, feat_concat in enumerate(images):\\n #print(\\\"check\\\", feat_concat[:2048].shape, feat_concat[2048:].shape)\\n resnet_feat[idx,:] = feat_concat[:2048]\\n vse_feat[idx,:] = feat_concat[2048:]\\n x1 = self.fc1(resnet_feat.cuda())\\n\\n x2 = self.relu(self.fc2(vse_feat.cuda()))\\n x2 = self.relu(self.fc3(x2))\\n x2 = self.scale(self.fc4(x2))\\n #print(x2.shape, x1.shape, x1[:,:5000].shape)\\n x = x1[:,:5000]+x2\\n \\n\\n return x\",\n \"def _process_feats_batch(self, output_reshaped, mask, scale_factor):\\n\\n # whole_proc = cutotime('whole processing').start()\\n\\n anchors = self.anchors_cuda[scale_factor]\\n\\n # TRY THIS\\n\\n# # Reshape to N, height, width, num_anchors, box_params:\\n# box_wh = torch.exp(output_reshaped[:, ..., 2:4]) * anchors # 2, 3 - w, h\\n# loh = torch.sigmoid(output_reshaped)\\n# box_xy = loh[:, ..., :2] + self.grids[scale_factor] \\n# box_xy /= self.sizes_cuda[scale_factor]\\n# box_xy -= (box_wh / self.number_two)\\n# boxes = torch.cat((box_xy, box_xy + box_wh), axis=-1)\\n# out = boxes, loh[:, ..., 4:5], loh[:, ..., 5:]\\n\\n\\n# FILTER BEFORE SIGMOIDS?\\n box_xy = torch.sigmoid(output_reshaped[:, ..., :2]) # 0, 1 - x, y\\n box_wh = torch.exp(output_reshaped[:, ..., 2:4]) * anchors # 2, 3 - w, h\\n box_confidence = torch.sigmoid(output_reshaped[:, ..., 4:5]).flatten(end_dim=-2) # 4 - objectness\\n box_class_probs = torch.sigmoid(output_reshaped[:, ..., 5:]).flatten(end_dim=-2) # 5, ... - classes probs\\n box_xy += self.grids[scale_factor] \\n box_xy /= self.sizes_cuda[scale_factor]\\n box_xy -= (box_wh / self.number_two)\\n boxes = torch.cat((box_xy, box_xy + box_wh), axis=-1).flatten(end_dim=-2)\\n\\n first_filter = torch.where(box_confidence >= self.object_threshold)\\n #box_confidence = box_confidence[first_filter[:-1]]\\n #box_class_probs = box_class_probs[first_filter[:-1]]\\n #boxes = boxes[first_filter[:-1]]\\n\\n box_scores = box_confidence[first_filter[:-1]] * box_class_probs[first_filter[:-1]]\\n box_class_scores = torch.max(box_scores, axis=-1)\\n box_classes = box_class_scores.indices\\n box_class_scores = box_class_scores.values\\n pos = torch.where(box_class_scores >= self.object_threshold)\\n# print(self.batch_inds[scale_factor].shape, boxes.shape)\\n# print(self.batch_inds[scale_factor][first_filter[0]][pos[0]])\\n# print(first_filter)\\n# MAYBE BATCH_INDS SHOULD BE IN CPU????\\n# print(pos)\\n out = boxes[first_filter[:-1]][pos], box_classes[pos], box_class_scores[pos], self.batch_inds[scale_factor][first_filter[0]][pos[0]]\\n #out = boxes[first_filter[:-1]][pos], box_classes[pos], box_class_scores[pos], first_filter[0][pos[0]]\\n #out = boxes[pos], box_classes[pos], box_class_scores[pos], pos[0]\\n# whole_proc.stop()\\n\\n# https://github.com/opencv/opencv/issues/17148\\n# scale_x_y \\n return out\",\n \"def forward(self, images):\\n features = self.resnet(images)\\n features = Variable(features.data)\\n features = self.pooling(features)\\n # print(features)\\n features = features.view(features.size(0),-1)\\n # print(features)\\n # print(resnet.fc.in_features)\\n features = self.bn(self.linear(features))\\n return features\\n # with torch.no_grad():\\n # features = self.resnet(images)\\n # features = features.reshape(features.size(0), -1)\\n # features = self.bn(self.linear(features))\\n # return features\",\n \"def extract_features(self, preprocessed_inputs, init_extraction=False):\\n if init_extraction:\\n preprocessed_inputs.get_shape().assert_has_rank(4)\\n shape_assert = tf.Assert(\\n tf.logical_and(tf.greater_equal(tf.shape(preprocessed_inputs)[1], 33),\\n tf.greater_equal(tf.shape(preprocessed_inputs)[2], 33)),\\n ['image size must at least be 33 in both height and width.'])\\n with tf.control_dependencies([shape_assert]):\\n with slim.arg_scope(self._conv_hyperparams):\\n with tf.variable_scope('MobilenetV1',\\n reuse=self._reuse_weights) as scope:\\n _, image_features = mobilenet_v1.mobilenet_v1_base(\\n preprocessed_inputs,\\n final_endpoint='Conv2d_13_pointwise',\\n min_depth=self._min_depth,\\n depth_multiplier=self._depth_multiplier,\\n scope=scope)\\n feature_head = image_features['Conv2d_13_pointwise']\\n feature_head = slim.conv2d(\\n feature_head,\\n 512, [3,3],\\n stride=1,\\n padding='SAME',\\n scope='Conv2d_Append_1x1_256'\\n )\\n feature_head = tf.nn.avg_pool(feature_head, strides=[1,1,1,1], ksize=[1,4,4,1],\\n padding='VALID', )\\n return feature_head\\n else:\\n preprocessed_inputs.get_shape().assert_has_rank(4)\\n shape_assert = tf.Assert(\\n tf.logical_and(tf.greater_equal(tf.shape(preprocessed_inputs)[1], 33),\\n tf.greater_equal(tf.shape(preprocessed_inputs)[2], 33)),\\n ['image size must at least be 33 in both height and width.'])\\n\\n\\n bottomup_features_names = [ 'Conv2d_11_pointwise', 'Conv2d_13_pointwise']\\n num_appended_layers = 0\\n #appended_channel_num = [512, 256, 256, 256]\\n appended_channel_num = [512]\\n\\n with tf.control_dependencies([shape_assert]):\\n with slim.arg_scope(self._conv_hyperparams):\\n with tf.variable_scope('MobilenetV1',\\n reuse=self._reuse_weights) as scope:\\n _, image_features = mobilenet_v1.mobilenet_v1_base(\\n preprocessed_inputs,\\n final_endpoint='Conv2d_13_pointwise',\\n min_depth=self._min_depth,\\n depth_multiplier=self._depth_multiplier,\\n scope=scope)\\n\\n topdown_features = self._topdown_feature_maps(\\n image_features,\\n bottomup_features_names=bottomup_features_names,\\n num_appended_layers = num_appended_layers,\\n appended_channel_num = appended_channel_num)\\n return topdown_features.values()\",\n \"def compute(\\n self,\\n image,\\n exclude_center_feature: bool = False,\\n exclude_center_value: bool = False,\\n features: ndarray = None,\\n feature_last_dim: bool = True,\\n passthrough_channels: Optional[Tuple[bool]] = None,\\n num_reserved_features: int = 0,\\n excluded_voxels: Optional[List[Tuple[int]]] = None,\\n spatial_feature_offset: Optional[Tuple[float, ...]] = None,\\n spatial_feature_scale: Optional[Tuple[float, ...]] = None,\\n ):\\n\\n with lsection('Computing features'):\\n\\n # some important numbers:\\n num_dims = len(image.shape)\\n num_spatiotemp_dim = num_dims - 2\\n num_batches = image.shape[0]\\n num_channels = image.shape[1]\\n num_features = self.get_num_features(num_spatiotemp_dim)\\n\\n # exclude_center_value can be a tuple, in that case each entry corresponds to a channel:\\n if type(exclude_center_value) is not tuple:\\n exclude_center_value = (exclude_center_value,) * num_channels\\n\\n # Fills in the default values for passthrough channels: False ==> by default channels are not passthrough.\\n if passthrough_channels is None:\\n passthrough_channels = (False,) * num_channels\\n\\n # Computes the number of features, taking into account: passthrough_channels, channels, and reserved_features:\\n num_passthrough_channels = sum(1 if p else 0 for p in passthrough_channels)\\n num_normal_features = num_features * (\\n num_channels - num_passthrough_channels\\n )\\n num_total_features = (\\n num_normal_features + num_passthrough_channels + num_reserved_features\\n )\\n\\n # Creates feature array that will hold the final result:\\n features = self.create_feature_array(image, num_total_features)\\n\\n # We iterate over batches:\\n for batch_index in range(num_batches):\\n\\n with lsection(\\n f'Computing features for batch: {batch_index + 1}/{num_batches}'\\n ):\\n feature_pointer = 0\\n\\n # We iterate over channels:\\n for channel_index in range(num_channels):\\n\\n with lsection(\\n f'Computing features for channel: {channel_index + 1}/{num_channels}'\\n ):\\n # We collect the 'exclude_center_value' for the current channel:\\n exclude_center_value_for_channel = exclude_center_value[\\n channel_index\\n ]\\n\\n lprint(\\n f'Excluding center value for channel: {exclude_center_value_for_channel}'\\n )\\n\\n # Image batch slice:\\n image_slice = (\\n batch_index,\\n channel_index,\\n *(slice(None),) * num_spatiotemp_dim,\\n )\\n\\n lprint(f'Image slice: {image_slice}')\\n\\n if passthrough_channels[channel_index]:\\n # A passthrough channel is simply fed directly as a feature:\\n lprint(\\n f'Adding passthrough channel feature for channel index: {channel_index}'\\n )\\n batch_feature_slice = (\\n slice(feature_pointer, feature_pointer + 1, 1),\\n batch_index,\\n *(slice(None),) * num_spatiotemp_dim,\\n )\\n features[batch_feature_slice] = image[\\n image_slice\\n ].astype(self.dtype, copy=False)\\n feature_pointer += 1\\n\\n else:\\n single_image = image[image_slice]\\n\\n # Usefull code snippet for debugging features:\\n # with napari.gui_qt():\\n # viewer = Viewer()\\n # viewer.add_image(image_batch_gpu.get(), name='image')\\n # viewer.add_image(rescale_intensity(image_integral_gpu.get(), in_range='image', out_range=(0, 1)), name='integral')\\n\\n # Feature batch slice:\\n batch_feature_slice = (\\n slice(None),\\n batch_index,\\n *(slice(None),) * num_spatiotemp_dim,\\n )\\n lprint(\\n f'Feature slice for batch and channel: {batch_feature_slice}'\\n )\\n\\n batch_channel_features = features[batch_feature_slice]\\n\\n for feature_group in self.features_group_list:\\n lprint(\\n f'Computing feature {feature_group}, ' # , and kwargs={kwargs}'\\n )\\n\\n # number of features in group:\\n num_group_features = feature_group.num_features(\\n num_spatiotemp_dim\\n )\\n\\n # Excluded voxels:\\n if excluded_voxels is None:\\n excluded_voxels = []\\n excluded_voxels_for_feature_group = []\\n\\n if exclude_center_value_for_channel:\\n excluded_voxels_for_feature_group.extend(\\n excluded_voxels\\n )\\n if (\\n not (0,) * num_spatiotemp_dim\\n in excluded_voxels_for_feature_group\\n ):\\n excluded_voxels_for_feature_group.append(\\n (0,) * num_spatiotemp_dim\\n )\\n\\n # We prepare feature generation for the group by setting the image,\\n # any computation that can be factored should happen now:\\n feature_group.prepare(\\n single_image,\\n excluded_voxels=excluded_voxels_for_feature_group,\\n offset=spatial_feature_offset,\\n scale=spatial_feature_scale,\\n )\\n\\n for index in range(num_group_features):\\n # feature array\\n feature = batch_channel_features[\\n feature_pointer\\n ]\\n\\n # Computing the feature:\\n feature_group.compute_feature(index, feature)\\n\\n # Increments feature index:\\n feature_pointer += 1\\n\\n feature_group.finish()\\n\\n # # Usefull code snippet for debugging features:\\n # import napari\\n #\\n # with napari.gui_qt():\\n # from napari import Viewer\\n #\\n # viewer = Viewer()\\n # viewer.add_image(features, name='features')\\n\\n # 'collect_features_nD' puts the feature vector in axis 0.\\n # The following line creates a view of the array\\n # in which the features are indexed by the last dimension instead:\\n if feature_last_dim:\\n lprint('Move feature axis to the last axis ...')\\n features = numpy.moveaxis(features, 0, -1)\\n\\n return features\",\n \"def create_GT_masks(root_dir, background_dir, intrinsic_matrix,classes):\\n list_all_images = load_obj(root_dir + \\\"all_images_adr\\\")\\n training_images_idx = load_obj(root_dir + \\\"train_images_indices\\\")\\n for i in range(len(training_images_idx)):\\n img_adr = list_all_images[training_images_idx[i]]\\n label = os.path.split(os.path.split(os.path.dirname(img_adr))[0])[1]\\n regex = re.compile(r'\\\\d+')\\n idx = regex.findall(os.path.split(img_adr)[1])[0]\\n\\n if i % 1000 == 0:\\n print(str(i) + \\\"/\\\" + str(len(training_images_idx)) + \\\" finished!\\\")\\n\\n image = cv2.imread(img_adr)\\n ID_mask = np.zeros((image.shape[0], image.shape[1]))\\n U_mask = np.zeros((image.shape[0], image.shape[1]))\\n V_mask = np.zeros((image.shape[0], image.shape[1]))\\n\\n ID_mask_file = root_dir + label + \\\\\\n \\\"/ground_truth/IDmasks/color\\\" + str(idx) + \\\".png\\\"\\n U_mask_file = root_dir + label + \\\\\\n \\\"/ground_truth/Umasks/color\\\" + str(idx) + \\\".png\\\"\\n V_mask_file = root_dir + label + \\\\\\n \\\"/ground_truth/Vmasks/color\\\" + str(idx) + \\\".png\\\"\\n\\n tra_adr = root_dir + label + \\\"/data/tra\\\" + str(idx) + \\\".tra\\\"\\n rot_adr = root_dir + label + \\\"/data/rot\\\" + str(idx) + \\\".rot\\\"\\n rigid_transformation = get_rot_tra(rot_adr, tra_adr)\\n\\n # Read point Point Cloud Data\\n ptcld_file = root_dir + label + \\\"/object.xyz\\\"\\n pt_cld_data = np.loadtxt(ptcld_file, skiprows=1, usecols=(0, 1, 2))\\n ones = np.ones((pt_cld_data.shape[0], 1))\\n homogenous_coordinate = np.append(pt_cld_data[:, :3], ones, axis=1)\\n\\n # Perspective Projection to obtain 2D coordinates for masks\\n homogenous_2D = intrinsic_matrix @ (rigid_transformation @ homogenous_coordinate.T)\\n coord_2D = homogenous_2D[:2, :] / homogenous_2D[2, :]\\n coord_2D = ((np.floor(coord_2D)).T).astype(int)\\n x_2d = np.clip(coord_2D[:, 0], 0, 639)\\n y_2d = np.clip(coord_2D[:, 1], 0, 479)\\n ID_mask[y_2d, x_2d] = classes[label]\\n\\n if i % 100 != 0: # change background for every 99/100 images\\n background_img_adr = background_dir + random.choice(os.listdir(background_dir))\\n background_img = cv2.imread(background_img_adr)\\n background_img = cv2.resize(background_img, (image.shape[1], image.shape[0]), interpolation=cv2.INTER_AREA)\\n background_img[y_2d, x_2d, :] = image[y_2d, x_2d, :]\\n background_adr = root_dir + label + \\\"/changed_background/color\\\" + str(idx) + \\\".png\\\"\\n mpimg.imsave(background_adr, background_img)\\n\\n # Generate Ground Truth UV Maps\\n centre = np.mean(pt_cld_data, axis=0)\\n length = np.sqrt((centre[0]-pt_cld_data[:, 0])**2 + (centre[1] -\\n pt_cld_data[:, 1])**2 + (centre[2]-pt_cld_data[:, 2])**2)\\n unit_vector = [(pt_cld_data[:, 0]-centre[0])/length, (pt_cld_data[:,\\n 1]-centre[1])/length, (pt_cld_data[:, 2]-centre[2])/length]\\n U = 0.5 + (np.arctan2(unit_vector[2], unit_vector[0])/(2*np.pi))\\n V = 0.5 - (np.arcsin(unit_vector[1])/np.pi)\\n U_mask[y_2d, x_2d] = U\\n V_mask[y_2d, x_2d] = V\\n\\n # Saving ID, U and V masks after using the fill holes function\\n ID_mask, U_mask, V_mask = fill_holes(ID_mask, U_mask, V_mask)\\n cv2.imwrite(ID_mask_file, ID_mask)\\n mpimg.imsave(U_mask_file, U_mask, cmap='gray')\\n mpimg.imsave(V_mask_file, V_mask, cmap='gray')\",\n \"def extractFeatures(image, feature_list):\\n # for multiple features or color features\\n #feat_vec = np.array([])\\n \\n # sift has 128D\\n feat_vec = np.empty((0,128))\\n n_channels = (image.shape[2] if len(image.shape)==3 else 1)\\n \\n #img_f32 = image.astype(np.float32)\\n\\n for feature in feature_list:\\n if (feature.strip().lower() == 'dsift'):\\n print \\\"computing dsift (dense rootSift) features\\\"\\n dense = cv2.FeatureDetector_create(\\\"Dense\\\")\\n sift = cv2.SIFT()\\n if n_channels == 1:\\n kp = dense.detect(image[:,:])\\n # compute kp descriptors\\n _,des = sift.compute(image[:,:],kp)\\n \\n # normalize the descriptors (L1)\\n des /= (des.sum(axis=1, keepdims=True) + 1e-7)\\n des = np.sqrt(des)\\n \\n feat_vec = np.vstack((feat_vec, des))\\n else:\\n for channel in xrange(n_channels):\\n kp = dense.detect(image[:,:,channel])\\n _,des = sift.compute(image[:,:,channel],kp)\\n \\n # normalize the descriptors (L1)\\n des /= (des.sum(axis=1, keepdims=True) + 1e-7)\\n des = np.sqrt(des)\\n\\n feat_vec = np.vstack((feat_vec, des))\\n \\n# if (feature.strip().lower() == 'color'):\\n# print \\\"computing color features\\\"\\n# # scale from 0-255 between 0 and 1\\n# if args.scale == 1:\\n# img_f32 /= 255.\\n# \\n# f_tmp = img_f32.flatten()\\n# feat_vec = np.append(feat_vec, f_tmp)\\n else:\\n raise Exception(\\\"Method '%s' is not implemented!\\\"%(feature)) \\n \\n return feat_vec\",\n \"def _make_features(self):\\n self.features = {}\\n self.labels = {}\\n for key in ['train', 'cv', 'test']:\\n if self.radius is not None:\\n feat, label = self._sliding_window(self.images[key], self.masks[key], window_radius=self.radius)\\n self.features[key] = feat\\n self.labels[key] = label\\n else:\\n self.features[key] = self.images[key].reshape(-1, 3)\\n self.labels[key] = self.masks[key].ravel()\",\n \"def forward(self, images):\\n # assuming that the precomputed features are not already l2-normalized\\n #x = l2norm(images.view( images.size(0), -1))\\n #print(images.shape, self.fc )\\n resnet_feat=torch.empty(len(images),2048)\\n vse_feat=torch.empty(len(images),256)\\n\\n for idx, feat_concat in enumerate(images):\\n #print(\\\"check\\\", feat_concat[:2048].shape, feat_concat[2048:].shape)\\n #resnet_feat[idx,:] = feat_concat[:2048]\\n vse_feat[idx,:] = feat_concat[2048:]\\n x = self.relu(self.fc1(vse_feat.cuda()))\\n x = self.relu(self.fc2(x))\\n x = self.fc3(x)\\n\\n return x\",\n \"def main():\\n feature_extraction_model = \\\"HOG\\\"\\n # feature_extraction_models = [\\\"CM\\\", \\\"HOG\\\"]\\n feature_extraction_model_1 = \\\"CM\\\"\\n dimension_reduction_model = \\\"PCA\\\"\\n k_value = 10\\n dim_k_value = 40\\n # K_value = 20\\n # lab_folder = \\\"Dataset3/Labelled/Set1\\\"\\n # unlab_folder = \\\"Dataset3/Unlabelled/Set 2\\\"\\n lab_folder = get_input_folder(\\\"Labelled Folder\\\")\\n unlab_folder = get_input_folder(\\\"Classify\\\")\\n start = time.time()\\n # ================================================================================================================\\n # labelled Images\\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\\n folder_metadata=lab_folder,\\n metadata_collection=\\\"labelled\\\")\\n obj_feat_lab = dim_red.get_object_feature_matrix()\\n features_list_lab = np.array(obj_feat_lab['featureVector'].tolist())\\n images_list_lab = np.array(obj_feat_lab['imageId'])\\n # filtering the labelled set\\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\\n\\n # unlabelled images\\n dim_red = DimensionReduction(feature_extraction_model, dimension_reduction_model, dim_k_value,\\n folder_metadata=unlab_folder,\\n metadata_collection=\\\"unlabelled\\\")\\n obj_feat_unlab = dim_red.get_object_feature_matrix()\\n features_list_unlab = np.array(obj_feat_unlab['featureVector'].tolist())\\n images_list_unlab = np.array(obj_feat_unlab['imageId'])\\n\\n # ================================================================================================================\\n # labelled Images\\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\\n folder_metadata=lab_folder,\\n metadata_collection=\\\"labelled\\\")\\n obj_feat_lab_1 = dim_red.get_object_feature_matrix()\\n features_list_lab_1 = np.array(obj_feat_lab_1['featureVector'].tolist())\\n # images_list_lab = np.array(obj_feat_lab_1['imageId'])\\n # filtering the labelled set\\n\\n\\n # unlabelled images\\n dim_red = DimensionReduction(feature_extraction_model_1, dimension_reduction_model, dim_k_value,\\n folder_metadata=unlab_folder,\\n metadata_collection=\\\"unlabelled\\\")\\n obj_feat_unlab_1 = dim_red.get_object_feature_matrix()\\n features_list_unlab_1 = np.array(obj_feat_unlab_1['featureVector'].tolist())\\n # images_list_unlab = np.array(obj_feat_unlab['imageId'])\\n features_list_lab = np.concatenate((features_list_lab, features_list_lab_1), axis=1)\\n features_list_unlab = np.concatenate((features_list_unlab, features_list_unlab_1), axis=1)\\n\\n # ================================================================================================================\\n\\n dorsal_list, palmar_list = filter_images_by_label(images_list_lab)\\n features_list = np.concatenate((features_list_lab, features_list_unlab))\\n images_list = np.concatenate((images_list_lab, images_list_unlab))\\n images_list = list(images_list)\\n # Finding Similarity Matrix\\n cos_sim = cosine_similarity(features_list)\\n sim_graph = np.empty((0, len(cos_sim)))\\n for row in cos_sim:\\n k_largest = np.argsort(-np.array(row))[1:k_value + 1]\\n sim_graph_row = [d if i in k_largest else 0 for i, d in enumerate(row)]\\n sim_graph = np.append(sim_graph, np.array([sim_graph_row]), axis=0)\\n\\n row_sums = sim_graph.sum(axis=1)\\n sim_graph = sim_graph / row_sums[:, np.newaxis]\\n idx = 0\\n results_dorsal = ppr(sim_graph, images_list, dorsal_list)\\n results_palmar = ppr(sim_graph, images_list, palmar_list)\\n final_results = {}\\n\\n for img in images_list_unlab:\\n if results_dorsal[img] < results_palmar[img]:\\n final_results[img] = \\\"dorsal\\\"\\n else:\\n final_results[img] = \\\"palmar\\\"\\n\\n actual_labels = fetch_actual_labels(images_list_unlab)\\n print(\\\"Classification\\\")\\n no_correct = 0\\n correctly_classified = []\\n incorrectly_classified = []\\n print(\\\"| ImageId | Prediction | Actual |\\\")\\n for r in final_results:\\n print(\\\"| {} | {} | {} |\\\".format(r, final_results[r], actual_labels[r]))\\n if final_results[r] == actual_labels[r]:\\n correctly_classified.append(r)\\n no_correct += 1\\n else:\\n incorrectly_classified.append(r)\\n\\n print(\\\"Correctly classified: {}\\\\n\\\".format(correctly_classified))\\n print(\\\"InCorrectly classified: {}\\\\n\\\".format(incorrectly_classified))\\n\\n print(\\\"Classification Accuracy: {}%\\\".format(no_correct / len(images_list_unlab) * 100))\\n print(\\\"Execution time: {} seconds\\\".format(time.time() - start))\",\n \"def all_feature_extractor(imgpath):\\r\\n\\r\\n image = cv2.imread(imgpath)\\r\\n image = cv2.cvtColor(image, cv2.COLOR_BGR2GRAY)\\r\\n\\r\\n # Extracting Gabor Features\\r\\n feature_dict = gabor_feature_extractor(image)\\r\\n\\r\\n feature_dict['Original'] = image\\r\\n\\r\\n entropy_img = entropy(image, disk(1))\\r\\n feature_dict['Entropy'] = entropy_img\\r\\n\\r\\n gaussian3_img = nd.gaussian_filter(image, sigma=3)\\r\\n feature_dict['Gaussian3'] = gaussian3_img\\r\\n\\r\\n gaussian7_img = nd.gaussian_filter(image, sigma=7)\\r\\n feature_dict['Gaussian7'] = gaussian7_img\\r\\n\\r\\n sobel_img = sobel(image)\\r\\n feature_dict['Sobel'] = sobel_img\\r\\n\\r\\n canny_edge_img = cv2.Canny(image, 100, 200)\\r\\n feature_dict['Canny'] = canny_edge_img\\r\\n\\r\\n robert_edge_img = roberts(image)\\r\\n feature_dict['Robert'] = robert_edge_img\\r\\n\\r\\n scharr_edge = scharr(image)\\r\\n feature_dict['Scharr'] = scharr_edge\\r\\n\\r\\n prewitt_edge = prewitt(image)\\r\\n feature_dict['Prewitt'] = prewitt_edge\\r\\n\\r\\n median_img = nd.median_filter(image, size=3)\\r\\n feature_dict['Median'] = median_img\\r\\n\\r\\n variance_img = nd.generic_filter(image, np.var, size=3)\\r\\n feature_dict['Variance'] = variance_img\\r\\n\\r\\n return feature_dict\",\n \"def preprocess_train(im, boxes, classes, inst_masks, mask, input_size, min_size=2,\\n use_augment=False, training_scale=[0.3, 0.5, 0.7, 1.0]):\\n ori_im = np.copy(im)\\n target_h, target_w = input_size\\n\\n # ---------- old data_augmentation ----------\\n if use_augment:\\n if np.random.choice([0, 1]) != 0:\\n scale = np.random.choice(training_scale) # adding more small objects\\n im, inst_masks, mask, boxes, classes = random_scale(im, inst_masks, mask, boxes, classes, scale=scale)\\n min_obj_cover = np.random.choice([0.8, 0.9, 1.0])\\n # truncted examples may lead to multiple-detections..\\n im, inst_masks, mask, boxes, classes = random_aspect_ratio(im, inst_masks, mask, boxes, classes,\\n min_aspect_ratio=0.5, max_aspect_ratio=2.0,\\n min_obj_cover=min_obj_cover)\\n #\\n # # r = np.random.randint(0, 3)\\n # if np.random.rand() < 0.75:\\n # im, inst_masks, mask, boxes, classes = fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w)\\n # else:\\n # im, inst_masks, mask, boxes, classes = center_crop2fixed_pad(im, inst_masks, mask, boxes, classes, target_w, target_h,\\n # min_size=min_size)\\n\\n # ---------- old data_augmentation ----------\\n\\n # ---------- none data_augmentation ----------\\n im, inst_masks, mask, boxes, classes = fixed_scale(im, inst_masks, mask, boxes, classes, target_h, target_w)\\n im, inst_masks, mask, boxes, classes = random_flip(im, inst_masks, mask, boxes, classes)\\n # ---------- none data_augmentation ----------\\n\\n # ---------- old data_augmentation ----------\\n im = distort_color(im)\\n # ---------- old data_augmentation ----------\\n\\n im = imcv2_recolor(im)\\n\\n # add this because zeros numpy array will cause errors in torch Dataloader\\n inst_masks = np.zeros([1, target_h, target_w], dtype=inst_masks.dtype) if inst_masks.size == 0 else inst_masks\\n\\n boxes = np.asarray(boxes, dtype=np.float32)\\n return im, boxes, classes, inst_masks, mask, ori_im\",\n \"def collect_features(image, features, variables, vertical_flip=True, urban_only=False):\\n node2feature = {}\\n pos2node = {}\\n node_ind = 0\\n pq0, a2, a3, a4 = 379.90516, 17.2693882, 273.16, 35.86 # for Relative Humidity calculation\\n \\n for i in range(image.shape[0]):\\n for j in range(image.shape[1]):\\n\\n tmp_index = image[i,j]\\n if tmp_index == 0:\\n # 0 index is dummy index.\\n continue\\n \\n if urban_only:\\n if tmp_index == 31 or tmp_index == 32 or tmp_index == 33:\\n pass\\n else:\\n continue\\n\\n tmp_dict = {'LU_INDEX': tmp_index.item(), 'ij_loc': (i,j)}\\n\\n for f in features:\\n if f in {'T2','ALBEDO','RAINNC','PBLH','Q2','PSFC'}: # 3D time varying\\n if vertical_flip:\\n tmp_dict[f] = np.array(variables[f][:,-i-1,j])\\n else:\\n tmp_dict[f] = np.array(variables[f][:,i,j])\\n elif f in {'U','V','SMOIS'}: # 4D time varying\\n if vertical_flip:\\n tmp_dict[f] = np.array(variables[f][:,0,-i-1,j])\\n else:\\n tmp_dict[f] = np.array(variables[f][:,0,i,j])\\n elif f in {'XLAT','XLONG','FRC_URB2D','VEGFRA'}: # 3D time invariant\\n if vertical_flip:\\n tmp_dict[f] = variables[f][0,-i-1,j].item() #\\n else:\\n tmp_dict[f] = variables[f][0,i,j].item() #\\n else:\\n pass # RH2 will be calculated later\\n\\n # manually calculate relative humidity\\n q2 = tmp_dict['Q2']\\n t2 = tmp_dict['T2']\\n psfc = tmp_dict['PSFC']\\n tmp_dict['RH2'] = q2 / ( (pq0 / psfc) * np.exp(a2*(t2 - a3) / (t2 - a4)) )\\n\\n node2feature[node_ind] = tmp_dict\\n pos2node[(i,j)] = node_ind\\n node_ind += 1\\n\\n return node2feature, pos2node\",\n \"def _featurize(self, img):\\n self._classifier.predict(img)\\n return self._classifier.get_features()\",\n \"def Adjust_Data(img,mask,feature_dict, normalize):\\n ## Normalize image\\n if normalize:\\n img = Normalize_Image(img)\\n\\n ## Assume mask shape has 4 dimensions - mask is (batch, x, y, color-channel)\\n ## color-channels are redundant, so just choose the first. \\n mask = mask[:,:,:,0]\\n \\n ## Image_datagen performs interpolation when rotating, resulting in non-integer\\n ## mask values. Round these back to integers before expanding the mask. \\n mask = mask.round() \\n mask = Expand_Mask(mask, feature_dict)\\n #print(mask.shape, np.unique(mask, axis = 0))\\n return (img,mask)\",\n \"def training_features(orientation=8, pix_per_cell=8, cell_per_block=2,\\n spatial_size=16, hist_bins=32, color_space='HLS', sample_window=64,\\n channels=[0], debug=False):\\n def extract(paths, augment=False): # extract and augment\\n features = []\\n for file in paths:\\n image = utils.imread_scaled_unified(file)\\n if color_space != ident_config['default_color_space']:\\n image_color_converted = cv2.cvtColor(\\n image,\\n eval('cv2.COLOR_' + ident_config['default_color_space'] + '2' + color_space))\\n else:\\n image_color_converted = image\\n # End of if color_space\\n\\n image_resized = cv2.resize(image_color_converted, (sample_window, sample_window))\\n if augment:\\n brightened = utils.brighten(image_resized, bright=1.2)\\n flipped = cv2.flip(utils.brighten(image_resized, bright=1.1), 1) # horizontal flip\\n to_process = [brightened, flipped]\\n else:\\n to_process = [image_resized]\\n # End of if augment\\n\\n for x in to_process: # must use square bracket for single element in list to iterate\\n # using tuple, it will iterate the single image's row dimension. \\n hog_features = utils.get_hog_features_channels(\\n x, orientation, pix_per_cell, cell_per_block, channels)\\n spatial_features, hist_features = utils.color_features(\\n x, spatial_size=spatial_size, hist_bins=hist_bins, channels=channels)\\n image_features = np.hstack(\\n (spatial_features, hist_features, hog_features)).reshape(1, -1)\\n image_features = np.squeeze(image_features)\\n # remove the redundant dimension, StandardScaler does not like it\\n features.append(image_features)\\n # End of for x ...\\n # End of for file\\n return features\\n cars, noncars, cars_to_be_augmented, num_cars, num_noncars = samples_sorted()\\n num_samples = 30000 # limit the number of samples to be selected from each group.\\n print('num_cars: ', num_cars, ' num_noncars: ', num_noncars, ' max. samples: ', 3*num_samples)\\n\\n car_features = extract(cars[:min(num_samples, len(cars))], augment=False)\\n car_augmented_features = extract(cars_to_be_augmented[:min(num_samples, len(cars_to_be_augmented))], augment=True)\\n noncar_features = extract(noncars[:min(num_samples, len(noncars))], augment=False)\\n\\n # Create an array stack of feature vectors\\n X = np.vstack((car_features, car_augmented_features, noncar_features)).astype(np.float64)\\n # Fit a per-column scaler\\n X_scaler = StandardScaler().fit(X)\\n # Apply the scaler to X\\n scaled_X = X_scaler.transform(X)\\n del X # X, scaled_X consumes much memory, should be released ASAP.\\n # Define the labels vector\\n y = np.hstack((np.ones(len(car_features) + len(car_augmented_features)), np.zeros(len(noncar_features))))\\n\\n # Split up data into randomized training and test sets\\n rand_state = np.random.randint(0, 100)\\n X_train, X_test, y_train, y_test = train_test_split(\\n scaled_X, y, test_size=0.1, random_state=rand_state)\\n return X_train, X_test, y_train, y_test, X_scaler\",\n \"def extract_feat(self, imgs):\\n pass\",\n \"def extract_feat(self, imgs):\\n pass\",\n \"def forward_train(self, imgs, label, token_ids=None, segment_ids=None, input_mask=None, ans_ids=None, ans_mask=None, **kwargs):\\n # (batch_size, num_clips*num_crops, channel, num_segments, h, w) -> (batch_size*num_clips*num_crops, channel, num_segments, h, w)\\n imgs = imgs.reshape((-1, ) + imgs.shape[2:]) \\n if self.from_scratch:\\n imgs = imgs / 255.0\\n B_text = token_ids.shape[0]\\n # text reshape: (batch_size, num_candidates, seq_length) -> (batch_size * num_candidates, seq_length)\\n token_ids = token_ids.reshape((-1, ) + token_ids.shape[2:])\\n segment_ids = segment_ids.reshape((-1, ) + segment_ids.shape[2:])\\n input_mask = input_mask.reshape((-1, ) + input_mask.shape[2:])\\n losses = dict()\\n visual_token = self.extract_visual_feat(imgs) # b, d, T, h, w\\n B, D, T, H, W = visual_token.shape\\n if B_text != B:\\n visual_token = visual_token.view(B_text, -1, D, T, H, W)\\n visual_token = visual_token.mean(dim=1)\\n \\n # text feature #\\n text_out_with_mask = self.text_backbone(token_ids, input_mask)\\n text_out_last_hidden_state = text_out_with_mask['last_hidden_state']\\n\\n # contrastive type finetuning retrieval #\\n if self.task == 'retrieval':\\n # text_only_out = self.text_backbone(token_ids, input_mask)\\n visual_emb, text_emb = self.ssl_head(visual_token, text_out_last_hidden_state, input_mask, token_ids)\\n nce_loss = self.loss_func(visual_emb, text_emb)\\n losses['retrieval_nce_loss'] = nce_loss \\n elif self.task == 'video_qa' or self.task == 'FIB':\\n B, D, T, H, W = visual_token.shape\\n visual_token = visual_token.view(B, D, T, -1).permute(0, 2, 3, 1)\\n if hasattr(self.qa_head, 'num_labels'):\\n num_choices = self.qa_head.num_labels\\n visual_token_all = visual_token\\n else:\\n num_choices = int(token_ids.shape[0] / B)\\n visual_token_all = visual_token.unsqueeze(1).expand(-1, num_choices, -1, -1, -1).flatten(0,1)\\n\\n output = self.multimodal_backbone(visual_token=visual_token_all, text_input_mask=input_mask, text_input_embeds=text_out_last_hidden_state)\\n \\n if self.answer_mask:\\n mask_idx = torch.where(token_ids == 103)\\n itm_output = output['t_last_hidden_state'][mask_idx]\\n elif self.answer_cls:\\n if 'cls_last_hidden_state' in output:\\n itm_output = output['cls_last_hidden_state'].squeeze()\\n else:\\n itm_output = output['t_last_hidden_state'][:, 0]\\n if self.itm_head is not None:\\n itm_output = self.itm_head(itm_output)\\n\\n else:\\n all_cls_emb = output['last_hidden_state'][:, 0]\\n itm_output = self.itm_head(all_cls_emb)\\n \\n if self.qa_head is not None:\\n final_output = self.qa_head(itm_output).view(-1, num_choices)\\n final_label = label\\n else:\\n final_output = itm_output[:, 1]\\n final_label = label\\n\\n\\n qa_loss = self.loss_func(final_output, final_label.view(-1))\\n losses['qa_loss'] = qa_loss\\n\\n\\n\\n return losses\",\n \"def get_local_features(self, img):\\n kp, des = self.fe.detectAndCompute(img, None)\\n return kp, des\",\n \"def Get_Label_Features(mask_in, feature_dict, convert_length = 0.2204315, eps_factor = 0.025, area_thresh = 2): \\n\\n nfeatures = len(feature_dict)\\n Image_Features = pd.DataFrame({'Type':[],'Feature_Area':[], 'x':[], 'y':[]})\\n Contours_List = []\\n\\n # Expand mask into one-hot mask if input is flat\\n if len(mask_in.shape)==2:\\n mask_in = Expand_Mask(mask_in, feature_dict = feature_dict)\\n \\n # Loop through mask layers (i.e., feature types) and calculate contours \\n for i in range(nfeatures):\\n Contours_List.append(list()) \\n for ii in feature_dict.keys():\\n nii = int(ii)\\n mask = mask_in[:,:,nii] \\n mask = 255*mask.round().astype('uint8')\\n mask = np.stack((mask,mask, mask),-1)\\n mask = cv2.cvtColor(mask, cv2.COLOR_RGB2GRAY);\\n ret, thresh = cv2.threshold(mask, 127.5, 255, cv2.THRESH_BINARY)\\n contours,hierarchy = cv2.findContours(thresh, cv2.RETR_TREE, cv2.CHAIN_APPROX_SIMPLE)\\n for cnt in contours:\\n # arcLength args: Contours, flag of whether curve is closed or not\\n epsilon = eps_factor*cv2.arcLength(cnt,True)\\n # approxPolyDP args: Contours, epsilon for wiggliness, closed shape or not\\n approx = cv2.approxPolyDP(cnt,epsilon,True)\\n # Extract area and convert to square meters \\n area = convert_length**2 * cv2.contourArea(approx)\\n if area > area_thresh: ## Filter small features / noise\\n ## Compute centroid from moments\\n M = cv2.moments(cnt)\\n cx = int(M['m10']/(1e-5 + M['m00']))*convert_length\\n cy = int(M['m01']/(1e-5 + M['m00']))*convert_length\\n Image_Features = Image_Features.append({'Type':feature_dict[ii], 'Feature_Area':area, \\n 'x':cx, 'y':cy}, ignore_index = True)\\n Contours_List[nii].append(cnt)\\n return Contours_List, Image_Features.copy()\",\n \"def data_augmentation_and_vectorization(self,imlist, lb,im_labels, average_image = None):\\n\\t\\tX,Y,X_original = [] ,[], []\\n\\n\\t\\ti = 0\\n\\t\\tfor im in imlist:\\n\\t\\t\\tim=Image.fromarray(im,mode=self.mode)\\n\\t\\t\\t#try:\\n\\t\\t\\t#im_ini = im\\n\\t\\t\\tim_original = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t#im = self.substract_average_image(im, average_image)\\n\\t\\t\\t#print 'i:{} is a: {}' .format(i,im_labels[i])\\n\\t\\t\\t#im.show()\\n\\t\\t\\tX_original.append(im_original)\\n\\n\\t\\t\\t#Rotations \\n\\t\\t\\t#im_r = im.rotate(15)\\n\\t\\t\\t# im_r_2 = im.rotate(-15)\\n\\t\\t\\t# im_r_3 = im.rotate(180)\\n\\t\\t\\t#im_r.show()\\n\\t\\t\\t#im_r_2.show()\\n\\n\\t\\t\\t#Filters\\n\\t\\t\\t#im_f = im_ini.filter(ImageFilter.DETAIL)\\n\\t\\t\\t#im_f = im.filter(ImageFilter.FIND_EDGES)\\n\\t\\t\\t\\n\\t\\t\\tif self.mode == 'RGB':\\n\\t\\t\\t\\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t\\t#Uncomment this if you want to use cross-correlate for 2D arrays http://docs.scipy.org/doc/scipy-0.16.0/reference/generated/scipy.signal.correlate2d.html\\n\\t\\t\\t\\t# im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\t# im = sp.inner(im, [299, 587, 114]) / 1000.0\\n\\t\\t\\t\\t# im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\\n\\t\\t\\t\\t# im = (im - im.mean()) / im.std()\\n\\n\\t\\t\\tif self.mode == 'L':\\n\\t\\t\\t\\t# im = np.asarray(im, dtype='float64')\\n\\t\\t\\t\\t# im = filters.sobel(im)\\n\\t\\t\\t\\t#im = filters.roberts(im)\\n\\t\\t\\t\\tim = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\n\\t\\t\\t#im = np.asarray(im, dtype=np.uint8)\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t#im = self.flaten_aux(im)\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#im = data.coins() # or any NumPy arr\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#image = data.coins() # or any NumPy array!\\n\\t\\t\\t#print im\\n\\t\\t\\t#im = filter.sobel(im)\\n\\t\\t\\t#im = filter.roberts(im)\\n\\n\\t\\t\\t# im_original = sp.inner(im, [299, 587, 114]) / 1000.0\\n\\t\\t\\t# im_original = np.asarray(im_original, dtype=theano.config.floatX)\\n\\t\\t\\t# # normalize per http://en.wikipedia.org/wiki/Cross-correlation\\n\\t\\t\\t# im = (im_original - im_original.mean()) / im_original.std()\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#print edges\\n\\t\\t\\t# edges = np.asarray(edges, dtype=np.uint8)\\n\\t\\t\\t#Image.fromarray(edges,mode=self.mode).show()\\n\\n\\t\\t\\t#print edges\\n\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX) / 256.\\n\\n\\t\\t\\t#print edges.shape\\n\\t\\t\\t# io.imshow(im)\\n\\t\\t\\t# io.show()\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t\\n\\t\\t\\t# plt.suptitle(im_labels[i], size=16)\\n\\t\\t\\t# plt.imshow(im, cmap=plt.cm.gray, interpolation='nearest')\\n\\t\\t\\t# plt.show()\\n\\t\\t\\t#im = np.asarray(im, dtype=theano.config.floatX)\\n\\t\\t\\t#print im.shape\\n\\t\\t\\t#self.reconstructImage(im).show()\\n\\n\\t\\t\\t#im_r = np.asarray(im_r, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t# im_r_2 = np.asarray(im_r_2, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t# im_r_3 = np.asarray(im_r_3, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t#im_f = np.asarray(im_f, dtype=theano.config.floatX) / 256.\\n\\t\\t\\t\\n\\t\\t\\t#im = im.transpose(2, 0, 1)\\n\\t\\t\\t#X.append(np.array(im, dtype=theano.config.floatX))\\n\\t\\t\\t#X.append(np.array(im_raw, dtype=theano.config.floatX))\\n\\t\\t\\t#X.append(im)\\n\\t\\t\\tX.append(im)\\n\\t\\t\\t# if i % 100 == 0:\\n\\t\\t\\t# \\tX.append(im)\\n\\t\\t\\t#X.append(im_r)\\n\\t\\t\\t# X.append(im_r_2)\\n\\t\\t\\t# X.append(im_r_3)\\n\\t\\t\\t#X.append(im_f)\\n\\t\\t\\t#X_original.append(im)\\n\\n\\t\\t\\t# X.append(np.array(im_r, dtype=theano.config.floatX))\\n\\t\\t\\t# X.append(np.array(im_r_2, dtype=theano.config.floatX))\\n\\n\\t\\t\\t#Uncomment this if you want to work with monochrome\\n\\t\\t\\t# im = im.convert('L')\\n\\t\\t\\t# pixels_monochrome = np.array(list(im.getdata()), dtype=np.float)\\n\\t\\t\\t\\t\\t\\t\\n\\t\\t\\t# # scale between 0-1 to speed up computations\\n\\t\\t\\t# min_max_scaler = preprocessing.MinMaxScaler(feature_range=(0,1), copy=True)\\n\\t\\t\\t# pixels_monochrome = min_max_scaler.fit_transform(pixels_monochrome)\\n\\n\\t\\t\\t# X.append(pixels_monochrome)\\n\\n\\t\\t\\t#Y.append(lb.transform([im_labels[i]])[0][0])\\n\\t\\t\\t#print lb.transform([im_labels[i]])\\n\\t\\t\\t\\n\\t\\t\\tlabel = lb.transform([im_labels[i]])[0][0]\\n\\t\\t\\t#print lb.transform([im_labels[i]])\\n\\t\\t\\t# label_vector = lb.transform([im_labels[i]])[0]\\n\\t\\t\\t# label = np.where( label_vector == 1 )[0][0]\\n\\t\\t\\t# print \\\"Label: {}\\\".format(label)\\n\\t\\t\\t#print label\\n\\t\\t\\t#Y.append(label)\\n\\t\\t\\tY.append(label)\\n\\t\\t\\t#Y.append(im_labels[i])\\t\\n\\n\\t\\t\\t\\n\\t\\t\\t#Y.append(label)\\t\\n\\t\\t\\t# Y.append(label)\\t\\n\\t\\t\\t# except Exception, e:\\n\\t\\t\\t# \\tprint e\\n\\t\\t\\t# \\t#raise e\\n\\n\\t\\t\\t# if i == 30:\\n\\t\\t\\t# \\tbreak\\n\\n\\t\\t\\ti += 1\\n\\t\\t\\tif self.verbose:\\n\\t\\t\\t\\tsys.stdout.write(\\\"\\\\r Process: {0}/{1}\\\".format(i, len(imlist)))\\n\\t\\t\\t\\tsys.stdout.flush()\\n\\t\\t\\n\\t\\t# output = open(self.data_path + 'X_original.pkl', 'wb')\\n\\t\\t# cPickle.dump(X_original, output,protocol=-1)\\n\\t\\t# output.close()\\n\\n\\t\\treturn X,Y\",\n \"def data_assemble(self, x,y, r_cut, add_mask=5, pick_choice=False):\\n #segmentation components\\n obj_masks,center_mask_info, segments_deblend_list = self._seg_image(x, y, r_cut=r_cut)\\n data_masks_center, _, xcenter, ycenter, c_index = center_mask_info\\n image = self.cut_image(x,y,r_cut)\\n self.raw_image = image\\n src_mask = np.zeros_like(image)\\n lens_mask = np.zeros_like(image)\\n plu_mask = np.zeros_like(image)\\n lenslight_mask_index = []\\n if self.segmap is not None and self.interaction:\\n segmap=self.segmap[0].data\\n segdata = segmap[x - r_cut:x + r_cut + 1, y - r_cut:y + r_cut + 1]\\n plt.imshow(segdata, origin='lower')\\n nlabel = np.unique(segdata)\\n for i in range(nlabel.shape[0] - 1):\\n ax = (int((np.where(segdata == nlabel[i + 1])[0].max() - np.where(segdata == nlabel[i + 1])[0].min()) / 2 +\\n np.where(segdata == nlabel[i + 1])[0].min()))\\n ay = (int((np.where(segdata == nlabel[i + 1])[1].max() - np.where(segdata == nlabel[i + 1])[1].min()) / 3 +\\n np.where(segdata == nlabel[i + 1])[1].min()))\\n plt.text(ay, ax, repr(nlabel[i + 1]), color='r', fontsize=15)\\n plt.title('Input segmentation map')\\n plt.show()\\n source_mask_index = [int(sidex) for sidex in input('Selection of data via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in source_mask_index:\\n src_mask = src_mask + segdata*(segdata==i*1)\\n # lens light\\n lenslightyn = input('Hint: is there lens light? (y/n): ')\\n if lenslightyn == 'y':\\n lenslight_mask_index = [int(lidex) for lidex in input('Selection of lens-plane light via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in lenslight_mask_index:\\n lens_mask = (lens_mask + segdata*(segdata==i*1))\\n elif lenslightyn == 'n':\\n lenslight_mask_index = []\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n # contamination\\n pluyn = input('Hint: is there contamination? (y/n): ')\\n if pluyn == 'y':\\n plution_mask_index = [int(pidex) for pidex in input('Selection of contamination via (inputed) segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in plution_mask_index:\\n plu_mask = (plu_mask + segdata*(segdata==i*1))\\n elif pluyn == 'n':\\n plu_mask = np.zeros_like(image)\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n\\n\\n\\n if self.segmap is None and self.interaction:\\n self.plot_segmentation(image, segments_deblend_list, xcenter, ycenter, c_index)\\n #source light\\n if pick_choice:\\n source_mask_index = [int(sidex) for sidex in input('Selection of data via segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in source_mask_index:\\n src_mask = src_mask + obj_masks[i]\\n #lens light\\n lenslightyn = input('Hint: is there lens light? (y/n): ')\\n if lenslightyn == 'y':\\n lenslight_mask_index = [int(lidex) for lidex in input('Selection of lens-plane light via segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in lenslight_mask_index:\\n lens_mask = (lens_mask + obj_masks[i])\\n elif lenslightyn == 'n':\\n lenslight_mask_index = []\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n # contamination\\n pluyn = input('Hint: is there contamination? (y/n): ')\\n if pluyn == 'y':\\n plution_mask_index = [int(pidex) for pidex in input('Selection of contamination via segmentation index separated by space, e.g., 0 1 :').split()]\\n for i in plution_mask_index:\\n plu_mask = (plu_mask + obj_masks[i])\\n elif pluyn == 'n':\\n plu_mask = np.zeros_like(image)\\n else:\\n raise ValueError(\\\"Please input 'y' or 'n' !\\\")\\n else:\\n src_mask = data_masks_center\\n\\n\\n #adding pixels around the selected masks\\n selem = np.ones((add_mask, add_mask))\\n src_mask = ndimage.binary_dilation(src_mask.astype(np.bool), selem)\\n plu_mask_out = ndimage.binary_dilation(plu_mask.astype(np.bool), selem)\\n plu_mask_out = (plu_mask_out - 1)*-1\\n\\n #select source region to fit, or to use whole observation to fit\\n ##1.select source region to fit\\n snr = self.snr\\n source_mask = image * src_mask\\n #create background image for picked\\n if self.background_rms is None:\\n _, _, std = sigma_clipped_stats(image, sigma=snr, mask=source_mask)\\n tshape = image.shape\\n img_bkg = make_noise_image(tshape, distribution='gaussian', mean=0., stddev=std, seed=12)\\n else:\\n tshape = image.shape\\n std=np.mean(self.background_rms)\\n img_bkg = make_noise_image(tshape, distribution='gaussian', mean=0., stddev=std, seed=12)\\n\\n no_source_mask = (src_mask * -1 + 1) * img_bkg\\n picked_data = source_mask + no_source_mask\\n\\n ##2.use whole observation to fit while mask out the contamination\\n maskedimg = image * plu_mask_out\\n\\n ##orginize the output 'kwargs_data'\\n kwargs_data = {}\\n if pick_choice:\\n kwargs_data['image_data'] = picked_data#select source region to fit\\n else:\\n kwargs_data['image_data'] = maskedimg#use whole observation to fit while mask out the contamination\\n\\n if self.background_rms is None:\\n kwargs_data['background_rms'] = std\\n self.background_rms = std\\n else:\\n kwargs_data['background_rms'] = np.mean(self.background_rms)\\n kwargs_data['exposure_time'] = self.exp_time\\n kwargs_data['transform_pix2angle'] = np.array([[1, 0], [0, 1]]) * self.deltaPix\\n ra_at_xy_0 = (y - r_cut) * self.deltaPix # (ra,dec) is (y_img,x_img)\\n dec_at_xy_0 = (x - r_cut) * self.deltaPix\\n kwargs_data['ra_at_xy_0'] = ra_at_xy_0\\n kwargs_data['dec_at_xy_0'] = dec_at_xy_0\\n\\n #coordinate of the lens light\\n xlenlight, ylenlight = [], []\\n if lenslight_mask_index !=[]:\\n for i in lenslight_mask_index:\\n xlenlight.append(ra_at_xy_0 + int(xcenter[i]) * self.deltaPix )\\n ylenlight.append(dec_at_xy_0 + int(ycenter[i])* self.deltaPix )\\n\\n #for output\\n self.data = kwargs_data['image_data']\\n self.kwargs_data = kwargs_data\\n self.data_mask = src_mask\\n self.lens_mask = lens_mask\\n self.plu_mask = plu_mask_out\\n self.obj_masks = obj_masks\\n imageData = ImageData(**kwargs_data)\\n self.imageData = imageData\\n kwargs_seg = [segments_deblend_list, xcenter, ycenter, c_index]\\n\\n return kwargs_data, kwargs_seg, [xlenlight, ylenlight]\",\n \"def im_detect(net, im, boxes):\\n blobs, unused_im_scale_factors = _get_blobs(im, boxes)\\n # When mapping from image ROIs to feature map ROIs, there's some aliasing\\n # (some distinct image ROIs get mapped to the same feature ROI).\\n # Here, we identify duplicate feature ROIs, so we only compute features\\n # on the unique subset.\\n for i in range(len(blobs['data'])):\\n if cfg.DEDUP_BOXES > 0:\\n v = np.array([1, 1e3, 1e6, 1e9, 1e12])\\n hashes = np.round(blobs['rois'][i] * cfg.DEDUP_BOXES).dot(v)\\n _, index, inv_index = np.unique(hashes, return_index=True,\\n return_inverse=True)\\n blobs['rois'][i] = blobs['rois'][i][index, :]\\n boxes_tmp = boxes[index, :].copy()\\n else:\\n boxes_tmp = boxes.copy()\\n t_data = blobs['data'][i].astype(np.float32, copy=False)\\n #t_data = t_data.reshape((1, t_data.shape[0], t_data.shape[1], t_data.shape[2], t_data.shape[3]))\\n data_height, data_width = t_data.shape[1], t_data.shape[2]\\n im_data = torch.FloatTensor(t_data).cuda()\\n im_data = im_data.permute(0, 3, 1, 2).contiguous() #.view(3, data_height, data_width)\\n LIM = 2000 # split ROIs due to memory issue\\n if cfg.TEST.USE_FLIPPED :\\n blobs['data'][i] = blobs['data'][i][:, :, ::-1, :]\\n width = blobs['data'][i].shape[2]\\n t_data = blobs['data'][i].astype(np.float32, copy=False)\\n data_height, data_width = t_data.shape[1], t_data.shape[2]\\n #im_data = torch.FloatTensor(t_data).cuda()\\n im_data_flip = torch.from_numpy(t_data.copy()).cuda()\\n im_data_flip = im_data_flip.permute(0, 3, 1, 2).contiguous()#.view(3, data_height, data_width)\\n #im_data = im_data[...,::-1]\\n for j in range (int(np.ceil(blobs['rois'][i].shape[0] / LIM))) :\\n t_rois = blobs['rois'][i][j*LIM:(j+1)*LIM].astype(np.float32, copy=False)\\n im_rois = torch.FloatTensor(t_rois).cuda()\\n ic_prob, ic_prob1, ic_prob2 = net(im_data, im_rois)\\n scores_tmp = ic_prob + ic_prob1 + ic_prob2\\n pred_boxes_small = np.tile(boxes_tmp[j*LIM : (j+1)*LIM], (1, scores_tmp.shape[2]))\\n\\n if cfg.TEST.USE_FLIPPED:\\n #pdb.set_trace()\\n oldx1 = blobs['rois'][i][j*LIM:(j+1)*LIM, 1].copy()\\n oldx2 = blobs['rois'][i][j*LIM:(j+1)*LIM, 3].copy()\\n blobs['rois'][i][j*LIM:(j+1)*LIM, 1] = width - oldx2 - 1\\n blobs['rois'][i][j*LIM:(j+1)*LIM, 3] = width - oldx1 - 1\\n assert (blobs['rois'][i][j*LIM:(j+1)*LIM, 3] >= blobs['rois'][i][j*LIM:(j+1)*LIM, 1]).all()\\n t_rois = blobs['rois'][i][j*LIM:(j+1)*LIM].astype(np.float32, copy=False)\\n im_rois = torch.FloatTensor(t_rois).cuda()\\n ic_prob, ic_prob1, ic_prob2 = net(im_data_flip, im_rois)\\n scores_tmp += ic_prob + ic_prob1 + ic_prob2\\n del im_rois\\n\\n if j is 0 :\\n scores_tmp_real = scores_tmp\\n pred_boxes = pred_boxes_small\\n else :\\n scores_tmp_real = torch.cat((scores_tmp_real, scores_tmp), dim=1)\\n pred_boxes = np.vstack((pred_boxes, pred_boxes_small))\\n\\n\\n if cfg.DEDUP_BOXES > 0:\\n # Map scores and predictions back to the original set of boxes\\n scores_tmp = scores_tmp_real[:,inv_index, :]\\n pred_boxes = pred_boxes[inv_index, :]\\n \\n if i == 0: \\n scores = np.copy(scores_tmp.data).squeeze()\\n if len(scores.shape) == 1 :\\n scores = scores[np.newaxis, :]\\n else:\\n scores += scores_tmp[0].data\\n\\n scores /= len(blobs['data']) * (1. + cfg.TEST.USE_FLIPPED)\\n return scores[:,1:], pred_boxes[:, 4:]\",\n \"def preprocessing(train_raw_, test_raw_):\\n \\n undef = np.float64(-999.0)\\n pred_dict = {'s':'1','b':'0', '?':'-1'}\\n # drop 1st column (Id) and also 1st row with column names (\\\"[1:,\\\") \\n train_raw = train_raw_[1:, :]\\n test_raw = test_raw_[1:, :] \\n \\n # Change s(signal) and b(background) for s:1 and b:0, and change '?' for -1\\n train_raw[:,1] = np.vectorize(pred_dict.get)(train_raw[:,1].astype(str))\\n test_raw[:,1] = np.vectorize(pred_dict.get)(test_raw[:,1].astype(str))\\n \\n # Divide the dataset in four according to PRI_jet_num feature and cast to float\\n train_data_jets = divide_dataset_by_jet(train_raw)\\n test_data_jets = divide_dataset_by_jet(test_raw)\\n \\n # Remove columns with nan values or with standard deviation of 0\\n test_data_jets, train_data_jets = clean_features(test_data_jets, train_data_jets, undef)\\n \\n # Standardize train and test sets to have mean=0 and std=1\\n train_data_jets, test_data_jets = standardize(train_data_jets, test_data_jets)\\n \\n # Replace remaining undefined values by mean, median or zero\\n train_data_mean, train_data_median, train_data_null = replace_nan(train_data_jets)\\n test_data_mean, test_data_median, test_data_null = replace_nan(test_data_jets)\\n \\n return train_data_mean, train_data_median, train_data_null, test_data_mean, test_data_median, test_data_null\",\n \"def _preprocess(self, features, labels):\\n with tf.variable_scope('preprocess'):\\n with tf.variable_scope('image'):\\n features['image_orig'] = features['image']\\n image = tf.image.convert_image_dtype(features['image_orig'],\\n dtype=tf.float32)\\n if self.mode == ModeKeys.TRAIN:\\n images = tf.unstack(image)\\n images = [augment_image(img) for img in images]\\n image = tf.stack(images)\\n image = tf.subtract(image, 0.5)\\n image = tf.multiply(image, 2.0)\\n features['image'] = image\\n\\n if labels is None:\\n return features, None\\n\\n with tf.variable_scope('label'):\\n # TODO(Shancheng): use start token and end token rather constant 0\\n # labels for decoder input\\n labels['label_input'] = tf.concat([labels['label'][:, -1:],\\n labels['label'][:, 0:-1]], axis=1)\\n # from text length to training label length\\n labels['length'] = tf.reshape(labels['length'], [-1])\\n labels['length'] = labels['length'] + 1\\n\\n return features, labels\",\n \"def augment(image,masks):\\n\\n # Random horizontal flipping\\n if random.random() > 0.5:\\n image = TF.hflip(image)\\n masks = TF.hflip(masks)\\n\\n # Random vertical flipping\\n if random.random() > 0.5:\\n image = TF.vflip(image)\\n masks = TF.vflip(masks)\\n return image,masks\",\n \"def _extract_features(self, all_batches, patch_size, train=True):\\n # manually derive basic intensities features\\n # takes 20 sec / 1048 images batch on my laptop in 4 cores //\\n p = patch_size\\n r = 512 // p\\n labels = np.empty(0)\\n feats = np.empty(0)\\n for counter, tmp in enumerate(all_batches):\\n # if counter == 2:\\n # break\\n if train:\\n batch_img, batch_label = tmp\\n else:\\n batch_img = tmp\\n batch_label = np.empty(0)\\n # just for testing just use 20 batch as training set\\n print('processing batch {}'.format(counter))\\n t1 = time.time()\\n batch_feats = np.asarray(\\n parmap.map(\\n self._get_features_from_batch_images,\\n batch_img,\\n r,\\n p,\\n pm_pbar=True))\\n print(time.time() - t1)\\n labels = np.concatenate(\\n (labels, batch_label)) if labels.size else batch_label\\n feats = np.concatenate(\\n (feats, batch_feats)) if feats.size else batch_feats\\n if train:\\n return feats, labels\\n else:\\n return feats\",\n \"def _forward_extract_base_features(self, i_frame, pre_boxes=None):\\n relu = nn.ReLU(inplace=True)\\n\\n batch_size = i_frame.size(0)\\n self.batch_size = batch_size\\n\\n if i_frame.size()[1] == 3:\\n base_feat_before_relu = self.RCNN_base_i(i_frame)\\n else:\\n base_feat_before_relu = self.RCNN_base_i(i_frame[:, 0:3, :, :])\\n\\n # the\\n base_feat_out = base_feat_before_relu.clone() # used to output as appearance feature, [bs, c, h, w]\\n f_h, f_w = base_feat_out.size()[2], base_feat_out.size()[3]\\n im_h, im_w = i_frame.size()[2], i_frame.size()[3]\\n h_scale, w_scale = f_h / im_h, f_w / im_w\\n f_scale = i_frame.data.new([w_scale, h_scale, w_scale, h_scale]) # [4]\\n\\n if pre_boxes is None:\\n return base_feat_out, f_scale\\n else:\\n\\n base_feat = relu(base_feat_before_relu)\\n\\n rois = pre_boxes\\n\\n base_feat = self.RCNN_conv_new(base_feat)\\n\\n # do roi pooling based predicted rois\\n cls_feat = self.RCNN_cls_base(base_feat)\\n pooled_feat_cls = self.RCNN_psroi_pool_cls(cls_feat, rois.view(-1, 5))\\n cls_score = self.pooling(pooled_feat_cls)\\n cls_score = cls_score.view(cls_score.size(0), cls_score.size(1))\\n cls_prob = F.softmax(cls_score, dim=1)\\n\\n bbox_base = self.RCNN_bbox_base(base_feat)\\n pooled_feat_loc = self.RCNN_psroi_pool_loc(bbox_base, rois.view(-1, 5))\\n bbox_pred = self.pooling(pooled_feat_loc)\\n bbox_pred = bbox_pred.squeeze()\\n\\n cls_prob = cls_prob.view(batch_size, rois.size(1), -1)\\n bbox_pred = bbox_pred.view(batch_size, rois.size(1), -1)\\n\\n return rois, cls_prob, bbox_pred, base_feat_out, f_scale\",\n \"def extract_features(img, sigmas, n_features): \\n dims = img.shape # dimensions of the image\\n \\n features = np.zeros((dims[0], dims[1], n_features)) # each feature map has the same size as the input image\\n \\n # the first feature we use is the pixel intensity in the green channel itself\\n img_g = img[:,:,1] #I just assume it follows the RGB convention and not GBR or BGR...\\n features[:,:,0] = img_g\\n features[:,:,1] = np.sum(img,axis=2) \\n \\n gabors = get_gabors() \\n \\n # >>> YOUR CODE STARTS HERE <<<\\n i = 2\\n# for s in sigmas:\\n# gfilters = gauss_filter(s)\\n# for gf in gfilters:\\n# features[:,:,i] = scipy.signal.fftconvolve(img_g, gf, mode='same') ;i+=1\\n for s in sigmas:\\n gauss = gauss_filter(s)\\n for g in gauss:\\n features[:,:,i] = scipy.signal.fftconvolve(img_g, g, mode='same') ;i+=1\\n \\n for gabor in gabors:\\n features[:,:,i] = scipy.signal.fftconvolve(img_g, gabor, mode='same') ;i+=1\\n \\n \\n features[:,:,i] = sobel(img_g, axis=0) ;i+=1\\n features[:,:,i] = sobel(img_g, axis=1) ;i+=1\\n features[:,:,i] = sobel(img_g, axis=0)+sobel(img_g, axis=1) ;i+=1\\n features[:,:,i] = feature.canny(img_g, sigma=0.0) ;i+=1\\n features[:,:,i] = feature.canny(img_g, sigma=0, low_threshold=13, high_threshold=50);i+=1\\n features[:,:,i] = feature.canny(img_g, sigma=1)\\n # >>> YOUR CODE ENDS HERE <<< \\n \\n return features\",\n \"def _preprocessing(image) -> np.ndarray:\\n # TODO: Turn mapping into generic function.\\n processed_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)\\n processed_image[~mask] = 255\\n return processed_image\",\n \"def create_feature(self):\\n\\n if not hasattr(self, \\\"mask\\\"):\\n raise Exception(\\\"attribute self.mask missing\\\")\\n\\n pixels = np.asarray(np.where(self.mask), np.int32).T\\n\\n self.feature = Feature(pixels)\",\n \"def extract_features(self, images: List[np.ndarray]) -> List[np.ndarray]:\\n pass\",\n \"def _preprocessing(mask, mapping, image) -> np.ndarray:\\n # TODO: Turn mapping into generic function.\\n processed_image = cv.cvtColor(image, cv.COLOR_BGR2GRAY)\\n processed_image = cv.remap(processed_image, *mapping, cv.INTER_LINEAR)\\n processed_image[~mask] = 255\\n return processed_image\",\n \"def generatePixelFeaturesForImage(rgbSourceImage):\\n totalImagePixels = np.size(rgbSourceImage[:,:,0])\\n \\n # RGB features\\n \\n rgbColourValuesFeature = createRGBColourValues(rgbSourceImage)\\n \\n# rgbColour1DHistogramFeatures, range = create1dRGBColourHistogram(rgbSourceImage)\\n# rgbColour1DHistogramFeatures = np.resize(rgbColour1DHistogramFeatures, (totalImagePixels, np.size(rgbColour1DHistogramFeatures[1]) ) )\\n \\n# rgbColour3DHistogramFeatures, range = create3dRGBColourHistogramFeature(rgbSourceImage)\\n# rgbColour3DHistogramFeatures = np.resize(rgbColour3DHistogramFeatures, (totalImagePixels, np.size(rgbColour3DHistogramFeatures[1]) ) )\\n range = None\\n \\n # HSV features\\n \\n hsvColourValueFeature = createHSVColourValues(rgbSourceImage)\\n \\n hsvSourceImage = color.rgb2hsv(rgbSourceImage)\\n \\n# hsvColour1DHistogramFeatures, range = create1dHSVColourHistogram(hsvSourceImage) \\n# hsvColour1DHistogramFeatures = np.resize(hsvColour1DHistogramFeatures, (totalImagePixels, np.size(hsvColour1DHistogramFeatures[1]) ) )\\n \\n hsvColour3DHistogramFeatures, range = create3dHSVColourHistogramFeature(hsvSourceImage)\\n hsvColour3DHistogramFeatures = np.resize(hsvColour3DHistogramFeatures, (totalImagePixels, np.size(hsvColour3DHistogramFeatures[1]) ) )\\n range = None\\n \\n # HOG features\\n hogFeatureImage = createHistogramOfOrientedGradientFeatures(rgbSourceImage, numGradientBins, (9,9), (3,3), True, True)\\n # this is RxCxNbOrients\\n hogFeatures = np.reshape( hogFeatureImage, ( rgbSourceImage[:,:,0].size, numGradientBins ) )\\n #hog1Darray = None\\n #hogFeatures = np.reshape(hogFeatures, (totalImagePixels , np.size(hogFeatures) / totalImagePixels) )\\n \\n # Local binary pattern features\\n lbpFeatures = createLocalBinaryPatternFeatures(rgbSourceImage, 4, 2, \\\"default\\\")\\n lbpFeatures = np.reshape(lbpFeatures, (totalImagePixels , np.size(lbpFeatures) / totalImagePixels) )\\n \\n # Testure filter response features\\n filterResponseFeatures = createFilterbankResponse(rgbSourceImage, 15)\\n filterResponseFeatures = np.reshape(filterResponseFeatures, ( totalImagePixels , np.size(filterResponseFeatures) / totalImagePixels) )\\n \\n # Test shapes of resized features\\n assert (np.shape(rgbColourValuesFeature)[0] == totalImagePixels) , (\\\"Number of RGB value feature rows not equal to total pixels:: \\\" +str(np.shape(rgbColourValuesFeature)[0]) + \\\", \\\" + str(totalImagePixels))\\n# assert (np.shape(rgbColour1DHistogramFeatures)[0] == totalImagePixels) , (\\\"Number of of RGB 1D histogram features:: \\\" + str(np.shape(rgbColour1DHistogramFeatures)[0]) + \\\", \\\" + str(totalImagePixels))\\n# assert (np.shape(rgbColour3DHistogramFeatures)[0] == totalImagePixels) , (\\\"Number of RGB 3D histogram feature rows not equal to total pixels:: \\\" , np.shape(rgbColour3DHistogramFeatures)[0] + \\\", \\\" + str(totalImagePixels))\\n assert (np.shape(hsvColourValueFeature)[0] == totalImagePixels) , (\\\"Number of HSV value feature rows not equal to total pixels:: \\\" + str(np.shape(hsvColourValueFeature)[0]) + \\\", \\\" + str(totalImagePixels))\\n# assert (np.shape(hsvColour1DHistogramFeatures)[0] == totalImagePixels) , (\\\"Number of HSV 1D histogram feature rows not equal to total pixels:: \\\" + str(np.shape(hsvColour1DHistogramFeatures)[0]) + \\\", \\\" + str(totalImagePixels))\\n assert (np.shape(hsvColour3DHistogramFeatures)[0] == totalImagePixels) , (\\\"Number of HSC 3D histogram feature rows not equal to total pixels:: \\\" + str(np.shape(hsvColour3DHistogramFeatures)[0]) + \\\", \\\" + str(totalImagePixels))\\n assert (np.shape(hogFeatures)[0] == totalImagePixels) , (\\\"Number of HOG features not equal to total pixels:: \\\" + str(np.shape(hogFeatures)[0]) + \\\", \\\" + str(totalImagePixels))\\n assert (np.shape(lbpFeatures)[0] == totalImagePixels) , (\\\"Number of LBP features not equal to total pixels:: \\\" + str(np.shape(lbpFeatures)[0]) + \\\", \\\" + str(totalImagePixels))\\n assert (np.shape(filterResponseFeatures)[0] == totalImagePixels) , (\\\"Number of filter response features not equal to total pixels:: \\\" + str(np.shape(filterResponseFeatures)[0]) + \\\", \\\" + str(totalImagePixels) )\\n \\n # Consolidate all features for image, per pixel - skip colors and 1d hists for sake of filesize!\\n imageFeatures = np.hstack( [ \\\\\\n rgbColourValuesFeature, \\\\\\n# rgbColour1DHistogramFeatures, \\\\\\n# rgbColour3DHistogramFeatures, \\\\\\n# hsvColourValueFeature, \\\\\\n# hsvColour1DHistogramFeatures, \\\\\\n# prob not needed due to crf smoothing hsvColour3DHistogramFeatures, \\\\\\n hogFeatures, \\\\\\n# !!come back to this later lbpFeatures, \\\\\\n filterResponseFeatures \\\\\\n ] )\\n # 14/06/13 Reference feature set = rgbColourValuesFeature, hsvColour3DHistogramFeatures, hogFeatures, hogFeatures, lbpFeatures & filterResponseFeatures\\n \\n assert (np.shape(imageFeatures)[0] == totalImagePixels) , (\\\"Number of ImageFeatures rows not equal to total pixels:: \\\" + str(np.shape(imageFeatures)[0]) + \\\", \\\" + str(totalImagePixels))\\n \\n return imageFeatures.astype('float')\",\n \"def apply(self, mode='lateral'):\\n num_lat_slices = self.img3d.shape[0]\\n num_cor_slices = self.img3d.shape[2]\\n bin_mask = np.zeros(self.mask3d.shape)\\n x,y,z = np.where(self.mask3d==self.vertebra_id)\\n bin_mask[np.min(x):np.max(x), np.min(y):np.max(y), np.min(z):np.max(z)] = 1\\n if mode=='lateral' or mode=='fuse':\\n mask_lat = np.zeros((6, self.mask3d.shape[0], self.mask3d.shape[1], self.mask3d.shape[2]))\\n img_lat = np.zeros(self.img3d.shape)\\n binary_lat = np.zeros(self.mask3d.shape)\\n # for each lateral slice\\n for idx in range(num_lat_slices):\\n img_slice, mask_slice = np.copy(self.img3d[idx, :, :]), np.copy(self.mask3d[idx, :, :])\\n xloc, yloc = np.where(mask_slice==self.vertebra_id)\\n # check if vertebra is present in image\\n if xloc.shape[0]==0:\\n # if not keep mask as it is\\n mask_lat[:,idx, :, :] = self.get_one_hot(mask_slice)\\n img_lat[idx, :, :] = img_slice\\n else:\\n min_x, max_x = np.min(xloc), np.max(xloc)\\n min_y, max_y = np.min(yloc), np.max(yloc)\\n inpainted_img, inpainted_mask, binary_mask = self.inpaint(img_slice, mask_slice, min_x, max_x, min_y, max_y)\\n mask_lat[:,idx, :, :] = inpainted_mask\\n img_lat[idx,:, :] = inpainted_img\\n binary_lat[idx,:,:] = binary_mask\\n\\n\\n if mode=='coronal' or mode=='fuse':\\n mask_cor = np.zeros((6, self.mask3d.shape[0], self.mask3d.shape[1], self.mask3d.shape[2]))\\n img_cor = np.zeros(self.img3d.shape)\\n binary_cor = np.zeros(self.mask3d.shape)\\n # for each coronal slice\\n for idx in range(num_cor_slices):\\n img_slice, mask_slice = np.copy(self.img3d[:, :, idx]), np.copy(self.mask3d[:, :, idx])\\n xloc, yloc = np.where(mask_slice==self.vertebra_id)\\n # check if vertebra is present in image\\n if xloc.shape[0]==0:\\n # if not keep mask as it is\\n mask_cor[:, :, :, idx] = self.get_one_hot(mask_slice)\\n img_cor[:, :, idx] = img_slice\\n else:\\n min_x, max_x = np.min(xloc), np.max(xloc)\\n min_y, max_y = np.min(yloc), np.max(yloc)\\n # else remove fractured vertebra and inpaint\\n inpainted_img, inpainted_mask, binary_mask = self.inpaint(img_slice, mask_slice, min_x, max_x, min_y, max_y, 'coronal')\\n mask_cor[:, :, :, idx] = inpainted_mask\\n img_cor[:, :, idx] = inpainted_img\\n binary_cor[:,:,idx] = binary_mask\\n \\n # return to a one channel mask and convert labels back\\n if mode=='lateral':\\n mask_lat = np.argmax(mask_lat, axis=0)\\n mask_lat = self.map_class_to_vert(mask_lat)\\n self.mask3d = mask_lat\\n self.img3d = img_lat\\n elif mode=='coronal':\\n mask_cor = np.argmax(mask_cor, axis=0)\\n mask_cor = self.map_class_to_vert(mask_cor)\\n self.mask3d = mask_cor\\n self.img3d = img_cor\\n elif mode=='fuse':\\n mask_fuse = mask_cor*0.5+mask_lat*0.5\\n mask_fuse = np.argmax(mask_fuse, axis=0)\\n mask_fuse = self.map_class_to_vert(mask_fuse)\\n self.mask3d = mask_fuse\\n self.img3d = (img_lat+img_cor)/2\\n \\n # save result\\n self.mask3d = self.mask3d.astype(np.uint8)\\n self.img3d = self.img3d.astype(np.float32)\\n \\n # put back if we padded and cropped\\n if self.padz and self.padx:\\n self.orig_img3d[:,self.ymin:self.ymax, :] = self.img3d[self.xcrop1:-self.xcrop2,:,self.zcrop1:-self.zcrop2]\\n self.orig_mask3d[:,self.ymin:self.ymax, :] = self.mask3d[self.xcrop1:-self.xcrop2,:,self.zcrop1:-self.zcrop2]\\n elif self.padz and not self.padx:\\n self.orig_img3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, :] = self.img3d[:,:,self.zcrop1:-self.zcrop2]\\n self.orig_mask3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, :] = self.mask3d[:,:,self.zcrop1:-self.zcrop2]\\n elif not self.padz and self.padx:\\n self.orig_img3d[:,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.img3d[self.xcrop1:-self.xcrop2,:,:]\\n self.orig_mask3d[:,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.mask3d[self.xcrop1:-self.xcrop2,:,:]\\n else:\\n self.orig_img3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.img3d\\n self.orig_mask3d[self.xcrop1:self.xcrop2,self.ymin:self.ymax, self.zcrop1:self.zcrop2] = self.mask3d\\n \\n img = return_scan_to_orig(self.orig_img3d, self.mask_affine, self.mask_header, self.zooms)\\n nib.save(img, self.inpainted_img_path)\\n\\n mask_fuse = return_scan_to_orig(self.orig_mask3d, self.mask_affine, self.mask_header, self.zooms, np.uint8)\\n nib.save(mask_fuse, self.inpainted_mask_path)\\n print('Inpaint mask and image saved at: ', self.inpainted_mask_path, self.inpainted_img_path)\",\n \"def __init__(self, device=\\\"cuda:0\\\", *args, **kwargs):\\n source_file_wtsd = \\\"/g/kreshuk/data/leptin/sourabh_data_v1/Segmentation_results_fused_tp_1_ch_0_Masked_WatershedBoundariesMergeTreeFilter_Out1.tif\\\"\\n source_file_wtsd = \\\"/g/kreshuk/hilt/projects/data/leptin_fused_tp1_ch_0/Masked_WatershedBoundariesMergeTreeFilter_Out1.h5\\\"\\n # wtsd = torch.from_numpy(np.array(imread(source_file_wtsd).astype(np.long))).to(device)\\n wtsd = torch.from_numpy(h5py.File(source_file_wtsd, \\\"r\\\")[\\\"data\\\"][:].astype(np.long)).to(device)\\n slices = [0, 157, 316]\\n label_1 = [1359, 886, 1240]\\n label_2 = [1172, 748, 807]\\n label_3 = [364, 1148, 1447]\\n m1, m2, m3, m4, m5 = [], [], [], [], []\\n self.outer_cntr_ds, self.inner_cntr_ds, self.celltype_1_ds, self.celltype_2_ds, self.celltype_3_ds = [], [], [], [], []\\n for slc, l1, l2, l3 in zip(slices, label_1, label_2, label_3):\\n bg = wtsd[:, slc, :] == 1\\n bg_cnt = find_contours(bg.cpu().numpy(), level=0)\\n cnt1 = bg_cnt[0] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[1]\\n cnt2 = bg_cnt[1] if bg_cnt[0].shape[0] > bg_cnt[1].shape[0] else bg_cnt[0]\\n for m, cnt in zip([m1, m2], [cnt1, cnt2]):\\n mask = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n mask[np.round(cnt[:, 0]), np.round(cnt[:, 1])] = 1\\n m.append(torch.from_numpy(binary_fill_holes(mask.long().cpu().numpy())).to(device).sum().item())\\n\\n mask = wtsd[:, slc, :] == l1\\n m3.append(mask.long().sum().item())\\n cnt3 = find_contours(mask.cpu().numpy(), level=0)[0]\\n mask = wtsd[:, slc, :] == l2\\n m4.append(mask.long().sum().item())\\n cnt4 = find_contours(mask.cpu().numpy(), level=0)[0]\\n mask = wtsd[:, slc, :] == l3\\n m5.append(mask.long().sum().item())\\n cnt5 = find_contours(mask.cpu().numpy(), level=0)[0]\\n\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt1[:, 0], cnt1[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt2[:, 0], cnt2[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt3[:, 0], cnt3[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt4[:, 0], cnt4[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n # img = torch.zeros_like(wtsd[:, slc, :]).cpu()\\n # img[cnt5[:, 0], cnt5[:, 1]] = 1\\n # plt.imshow(img);plt.show()\\n\\n self.outer_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt1, tolerance=1.2)).to(device)))\\n self.inner_cntr_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt2, tolerance=1.2)).to(device)))\\n self.celltype_1_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt3, tolerance=1.2)).to(device)))\\n self.celltype_2_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt4, tolerance=1.2)).to(device)))\\n self.celltype_3_ds.append(Polygon2d(torch.from_numpy(approximate_polygon(cnt5, tolerance=1.2)).to(device)))\\n\\n self.masses = [np.array(m1).mean(), np.array(m2).mean(), np.array(m3 + m4 + m5).mean()]\\n self.fg_shape_descriptors = self.celltype_1_ds + self.celltype_2_ds + self.celltype_3_ds\",\n \"def optimize_fore(self):\\n self.u = np.random.uniform(-1, 1, (32, 288, 1, 1))\\n \\n self.l2 = torch.from_numpy(self.u).float()\\n print('self u shape',self.l2.shape)\\n self.n = torch.randn(32, 1, 28, 28)\\n self.l1 = self.enc(self.input + self.n)\\n self.del1=self.dec(self.l1)\\n self.del2=self.dec(self.l2)\\n self.update_netc()\\n self.update_netd()\\n\\n self.update_l2()\\n self.update_netg()\\n print('sssssssssssssssssssssss')\",\n \"def _extract_features(images,\\n model_options,\\n weight_decay=0.0001,\\n reuse=tf.AUTO_REUSE,\\n is_training=False,\\n fine_tune_batch_norm=False):\\n # feature extractor is a backbone factory\\n DEBUG_VARS.raw_image = images\\n features, end_points = feature_extractor.extract_features(\\n images,\\n output_stride=model_options.output_stride,\\n multi_grid=model_options.multi_grid,\\n model_variant=model_options.model_variant,\\n weight_decay=weight_decay,\\n reuse=reuse,\\n is_training=is_training,\\n fine_tune_batch_norm=fine_tune_batch_norm)\\n\\n # TODO:check\\n # DEBUG_VARS.xception_feature = end_points['xception_65/entry_flow/conv1_1/Relu:0']\\n DEBUG_VARS.xception_feature = features\\n if not model_options.aspp_with_batch_norm:\\n return features, end_points\\n else:\\n batch_norm_params = {\\n 'is_training': is_training and fine_tune_batch_norm,\\n 'decay': 0.9997,\\n 'eps': 1e-5,\\n 'affine': True,\\n }\\n regularize_func = regularizer('l2', weight_decay)\\n with tf.variable_scope(tf.get_variable_scope(), reuse=reuse):\\n with arg_scope([sep_conv2d], activate=tf.nn.relu, activate_middle=tf.nn.relu, batch_norm=True,\\n depthwise_weight_reg=None, pointwise_weight_reg=regularize_func,\\n padding='SAME', strides=[1, 1]):\\n with arg_scope([conv2d], activate=tf.nn.relu, weight_reg=regularize_func,\\n batch_norm=True, padding='SAME', strides=[1, 1]):\\n # TODO: ASPP IS IMPLEMENTED HERE! Check Out!\\n with arg_scope([batch_norm2d], **batch_norm_params):\\n depth = 256\\n branch_logits = []\\n\\n # TODO: ADD IMAGE POOLING HERE\\n if model_options.add_image_level_feature:\\n # this crop size has been updated to the new scaled one outside, which is the exact size\\n # of this model's inputs\\n pool_height = scale_dimension(model_options.crop_size[0],\\n 1. / model_options.output_stride)\\n pool_width = scale_dimension(model_options.crop_size[1],\\n 1. / model_options.output_stride)\\n # global average pooling, check whether the shape here is 1?\\n image_feature = avg_pool2d(\\n features, [pool_height, pool_width], [pool_height, pool_width],\\n padding='VALID')\\n # collapse channels to depth after GAP\\n image_feature = conv2d(\\n inputs=image_feature, outc=depth, ksize=[1, 1], name=_IMAGE_POOLING_SCOPE)\\n # TODO:check\\n DEBUG_VARS.image_feature = image_feature\\n # reshape it to final feature map shape\\n image_feature = tf.image.resize_bilinear(\\n image_feature, [pool_height, pool_width], align_corners=True)\\n image_feature.set_shape([None, pool_height, pool_width, depth])\\n # add image level feature to branch_logits\\n branch_logits.append(image_feature)\\n\\n # Employ a 1x1 convolution.\\n branch_logits.append(conv2d(features, outc=depth, ksize=[1, 1], name=_ASPP_SCOPE + str(0)))\\n\\n if model_options.atrous_rates:\\n # Employ 3x3 convolutions with different atrous rates.\\n DEBUG_VARS.aspp_features = []\\n for i, rate in enumerate(model_options.atrous_rates, 1):\\n scope = _ASPP_SCOPE + str(i)\\n if model_options.aspp_with_separable_conv:\\n aspp_features = sep_conv2d(\\n features, outc=depth, ksize=[3, 3], ratios=[rate, rate], name=scope)\\n DEBUG_VARS.aspp_features.append(aspp_features)\\n else:\\n aspp_features = conv2d(\\n features, outc=depth, ksize=[3, 3], ratios=[rate, rate], name=scope)\\n branch_logits.append(aspp_features)\\n\\n # Merge branch logits.\\n concat_logits = tf.concat(branch_logits, 3)\\n concat_logits = conv2d(inputs=concat_logits, outc=depth, ksize=[1, 1],\\n name=_CONCAT_PROJECTION_SCOPE)\\n DEBUG_VARS.aspp_concat_feature = concat_logits\\n concat_logits = drop_out(concat_logits, kp_prob=0.9, is_training=is_training,\\n name=_CONCAT_PROJECTION_SCOPE + '_dropout')\\n\\n return concat_logits, end_points\",\n \"def preprocessing(fish_class):\\n\\n\\t# encode fish_class into integer\\n\\tfish_label = fish_labels[fish_class]\\n\\t\\n\\t# return a list of image directories for each image\\n\\timg_handles = glob.glob(data_dir + fish_class + '/' + '*.jpg')\\n\\t\\n\\t# build an empty list to store each img as np.ndarray\\n\\timgs = []\\n\\t\\n\\t# build an empty list to store the encoded label for each image\\n\\tlabels = []\\n\\t\\n\\t# iterate through all images in the fish_class folder\\n\\tfor img_handle in img_handles:\\n\\t\\n\\t\\t# read img as np.ndarray\\n\\t\\timg = cv2.imread(img_handle)\\n\\t\\t\\n\\t\\t# resize it \\n\\t\\tcv2.resize( img, (new_img_width, new_img_height)\\n\\t\\timg = cv2.resize(img, new_img_size, interpolation=cv2.INTER_CUBIC)\\n\\t\\tstore the img in format of np.ndarray into the imgs \\n\\t\\timgs.append(img)\\n\\t\\t\\n\\t\\t# store a label in labels\\n\\t\\tlabels.append(fish_label)\\n\\t\\n\\treturn imgs, labels\\n\\n# time the preprocessing\\nt0 = time.time()\\n\\n# build an empty list to store preprocessed data\\npreprocessed_data = []\\n\\n# build an empty list to store labels\\nencoded_labels = []\\n\\nfor num, fish in enumerate(classes):\\n\\tprint num\\n\\tprint 'Preprocessing imgs of fish %s' %(fish)\\n\\tprint '----------------------------------------------------------------------'\\n\\tpreprocessed_imgs, labels = preprocessing(fish)\\n\\tpreprocessed_data.append(preprocessed_imgs)\\n\\tencoded_labels.append(labels)\",\n \"def forward(self,images):\\n with torch.no_grad(): \\n features = self.resnet(images)\\n features = features.view(features.size(0),-1)\\n features = self.embed(features)\\n features = self.bn(features)\\n return features\",\n \"def caffe_preprocess(img):\\n out = numpy.copy(img)\\n out -= IMAGE_256_MEAN[None, None, :]\\n out = out[:, :, [2, 1, 0]] # swap channel from RGB to BGR\\n return out\",\n \"def x_means(image_path):\\n\\n # List where all the descriptors are stored\\n des_list = []\\n\\n im = cv2.imread(image_path)\\n kpts = fea_det.detect(im)\\n kpts, des = des_ext.compute(im, kpts)\\n\\n # rootsift - not boosting performance\\n # rs = RootSIFT()\\n # des = rs.compute(kpts, des)\\n\\n des_list.append((image_path, des))\\n\\n # Stack all the descriptors vertically in a numpy array\\n descriptors = des_list[0][1]\\n\\n # gather features\\n test_features = np.zeros((1, numWords), \\\"float32\\\")\\n words, _ = vq(descriptors, voc)\\n for w in words:\\n test_features[0][w] += 1\\n\\n # Perform Tf-Idf vectorization and L2 normalization\\n test_features = test_features * idf\\n test_features = preprocessing.normalize(test_features, norm='l2')\\n\\n score = np.dot(test_features, im_features.T)\\n # print \\\"score: \\\", score\\n rank_ID = np.argsort(-score)\\n # print \\\"rank matrix: \\\", rank_ID[0]\\n\\n for ID in rank_ID[0]:\\n if score[0][ID] <= float(lowcut):\\n if ID not in low_union:\\n low_union.append(ID)\\n\\n x_list = []\\n for x in score[0]:\\n x_list.append([x])\\n X = np.array(x_list)\\n for n in X:\\n n[0] *= 1000000 # increase difference\\n # print \\\"Scores for X-Means: \\\", X\\n\\n # compute k range\\n # ks = range(1, 21)\\n bot_k = 30 * len(image_paths) / (200 + len(image_paths)) - 5\\n ks = range(bot_k, bot_k + 10)\\n\\n # run ks times kmeans and save each result in the KMeans object\\n KMeans = [cluster.KMeans(n_clusters=i, init=\\\"k-means++\\\").fit(X) for i in ks]\\n\\n # now run for each cluster the BIC computation\\n bic_max = -sys.maxint - 1\\n max_idx = 0\\n # BIC = [compute_bic(kmeansi,X) for kmeansi in KMeans]\\n for i in range(len(KMeans)):\\n curr = compute_bic(KMeans[i], X)\\n # print \\\"BIC = \\\", curr, \\\" when using %d clusters\\\\r\\\" % (i + bot_k)\\n if curr > bic_max:\\n bic_max = curr\\n max_idx = i\\n\\n best_k = max_idx + bot_k\\n # print \\\"Best K = \\\", best_k, \\\"with BIC = %d\\\\r\\\" % bic_max\\n best_k_labels = KMeans[max_idx].labels_\\n # print \\\"Best K labels\\\", KMeans[max_idx].labels_\\n\\n freq = {}\\n for cluster_no in best_k_labels:\\n if cluster_no in freq:\\n freq[cluster_no] = freq[cluster_no] + 1\\n else:\\n freq[cluster_no] = 1\\n max_cluster = 0\\n max_size = -1\\n for k, v in freq.items():\\n if v > max_size:\\n max_cluster = k\\n max_size = v\\n res = []\\n for idx in range(len(best_k_labels)):\\n if best_k_labels[idx] == max_cluster:\\n res.append(idx)\\n assert max_size == len(res)\\n print \\\"\\\\nSize of the largest cluster = \\\", max_size\\n\\n # # Archive big clusters for inspection\\n # path = os.path.split(pool_path)[0] + \\\"\\\\\\\\\\\" + \\\"cluster_\\\" + os.path.split(image_path)[1]\\n # if os.path.exists(path):\\n # shutil.rmtree(path)\\n # os.mkdir(path)\\n # print \\\"Adding cluster images for pool image \\\", image_path, \\\" to path \\\", path\\n # for ID in res:\\n # # print \\\"Adding \\\", image_paths[ID]\\n # shutil.copy(image_paths[ID], path)\\n\\n return res # biggest_cluster list\",\n \"def GenerateMapAffinity(img,nb_vertex,pointsInterest,objects_centroid,scale):\\n\\n # Apply the downscale right now, so the vectors are correct. \\n img_affinity = Image.new(img.mode, (int(img.size[0]/scale),int(img.size[1]/scale)), \\\"black\\\")\\n # Create the empty tensors\\n totensor = transforms.Compose([transforms.ToTensor()])\\n\\n affinities = []\\n for i_points in range(nb_vertex):\\n affinities.append(torch.zeros(2,int(img.size[1]/scale),int(img.size[0]/scale)))\\n \\n for i_pointsImage in range(len(pointsInterest)): \\n pointsImage = pointsInterest[i_pointsImage]\\n center = objects_centroid[i_pointsImage]\\n for i_points in range(nb_vertex):\\n point = pointsImage[i_points]\\n affinity_pair, img_affinity = getAfinityCenter(int(img.size[0]/scale),\\n int(img.size[1]/scale),\\n tuple((np.array(pointsImage[i_points])/scale).tolist()),\\n tuple((np.array(center)/scale).tolist()), \\n img_affinity = img_affinity, radius=1)\\n\\n affinities[i_points] = (affinities[i_points] + affinity_pair)/2\\n\\n\\n # Normalizing\\n v = affinities[i_points].numpy() \\n \\n xvec = v[0]\\n yvec = v[1]\\n\\n norms = np.sqrt(xvec * xvec + yvec * yvec)\\n nonzero = norms > 0\\n\\n xvec[nonzero]/=norms[nonzero]\\n yvec[nonzero]/=norms[nonzero]\\n\\n affinities[i_points] = torch.from_numpy(np.concatenate([[xvec],[yvec]]))\\n affinities = torch.cat(affinities,0)\\n\\n return affinities\",\n \"def feature_extraction(img, feature):\\n\\n if feature == 'HoG':\\n # HoG parameters\\n\\n # In the case of the Hog Feature, we already given the base parameters for using hog feature function.\\n # TA - You can just use that parameter with each subdivide image (which has image grid size * image grid size)\\n # Thank you for the reply. Does it mean to divide the image into 20x20 size sub-images and perform the feature extraction on each image??\\n # TA - Yes. In the SIFT, image grid size is different.\\n\\n win_size = (32, 32)\\n block_size = (32, 32)\\n block_stride = (16, 16)\\n cell_size = (16, 16)\\n\\n nbins = 9\\n deriv_aperture = 1\\n win_sigma = 4\\n histogram_norm_type = 0\\n l2_hys_threshold = 2.0000000000000001e-01\\n gamma_correction = 0\\n nlevels = 64\\n\\n # Your code here. You should also change the return value.\\n\\n # sample visualizing\\n # cv2.imshow('img', img)\\n\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n\\n\\n hog = cv2.HOGDescriptor(win_size,\\n block_size,\\n block_stride,\\n cell_size,\\n nbins,\\n deriv_aperture,\\n win_sigma,\\n histogram_norm_type,\\n l2_hys_threshold,\\n gamma_correction,\\n nlevels)\\n\\n # additional parameters\\n\\n #hist = hog.compute(gray,winStride,padding,locations)\\n\\n #TODO: Check if this is valid???\\n\\n hist = hog.compute(gray)\\n hist_resized = np.resize(hist, (int(len(hist)/36), 36))\\n hist_resized\\n return hist_resized\\n\\n elif feature == 'SIFT':\\n\\n # Your code here. You should also change the return value.\\n\\n #input image size 240 * 200 ==> divide H, W by 20 ==> 12 * 10 = 120\\n #in case of this input image, the number of feature is 120.\\n #So the number of feature is changed according to input image size.\\n\\n #IF PROBLEMS WITH DEPENDENCIES: pip3 install opencv-contrib-python==3.4.2.16\\n\\n gray = cv2.cvtColor(img, cv2.COLOR_BGR2GRAY)\\n sift = cv2.xfeatures2d.SIFT_create()\\n kp, des = sift.detectAndCompute(gray, None)\\n\\n return des\",\n \"def preprocess(self, img):\\n return img - np.mean(img)\",\n \"def _get_features_from_batch_images(self, img, r, p):\\n tmp_feats = []\\n for channel in range(4):\\n current_img = img[channel, :, :]\\n tmp_feats = np.append(tmp_feats, np.histogram(current_img)[0])\\n # extract 8*8 patches of 64*64 px and derive 10 bins histogram\\n for j in range(r):\\n for k in range(r):\\n tmp_feats = np.append(\\n tmp_feats,\\n np.histogram(current_img[j * p:(j + 1) * (p), k *\\n p:(k + 1) * p])[0])\\n return tmp_feats\",\n \"def get_spoof_features(img):\\n # Converting default BGR of OpenCV to RGB\\n # img = cv2.cvtColor(img, cv2.COLOR_BGR2RGB)\\n\\n # Changing dimension from 3*m*n to m*n*3\\n h_im = img[:, :, 0]\\n s_im = img[:, :, 1]\\n v_im = img[:, :, 2]\\n\\n img = np.array([h_im, s_im, v_im])\\n\\n return compute_msu_iqa_features(img)\",\n \"def facial_features_preprocess(img, landmarks, mode):\\n centers = compute_centers(landmarks)\\n crop_img = crop(img, centers, mode)\\n crop_img = crop_img[..., ::-1]\\n in_data = resize_image(crop_img, 256, keep_aspect_ratio=False)\\n in_data = in_data.astype(np.float32) / 255.\\n in_data = np.moveaxis(in_data, -1, 0)[np.newaxis]\\n m = np.array([0.485, 0.456, 0.406], dtype=np.float32).reshape((1, 3, 1, 1))\\n s = np.array([0.229, 0.224, 0.225], dtype=np.float32).reshape((1, 3, 1, 1))\\n in_data = (in_data - m) / s\\n return in_data\",\n \"def compute(\\n self,\\n image,\\n exclude_center_feature: bool = False,\\n exclude_center_value: bool = False,\\n features: ndarray = None,\\n feature_last_dim: bool = True,\\n passthrough_channels: Optional[Tuple[bool]] = None,\\n num_reserved_features: int = 0,\\n excluded_voxels: Optional[List[Tuple[int]]] = None,\\n spatial_feature_offset: Optional[Tuple[float, ...]] = None,\\n spatial_feature_scale: Optional[Tuple[float, ...]] = None,\\n ):\\n raise NotImplementedError()\",\n \"def get_mask(self):\\n # use the feature array a to calculate which channels to include etc\\n sums = np.sum(self.feature_array, 0)\\n feature_mask = np.repeat(np.ones(4, dtype=int), self.n_features)\\n # if there are \\\"missing\\\" channels use the older version of KK\\n zero_sums = sums == 0\\n if np.any(zero_sums):\\n self.distribution = 1\\n feature_mask[zero_sums] = 0\\n self.feature_mask = feature_mask\\n return feature_mask\",\n \"def forward(self, images):\\n with torch.no_grad():\\n features = self.resnet(images) \\n features = features.reshape(features.size(0), -1)\\n features = self.bn(self.linear(features))\\n return features\",\n \"def forward_train(self, imgs, label, token_ids=None, segment_ids=None, input_mask=None, \\n mlm_label=None, dvae_imgs=None, v_token_mask=None, hog_features=None, img_metas=None, **kwargs): \\n # (batch_size, num_clips*num_crops, channel, num_segments, h, w) -> (batch_size*num_clips*num_crops, channel, num_segments, h, w)\\n imgs = imgs.reshape((-1, ) + imgs.shape[2:]) \\n if self.from_scratch:\\n imgs = imgs / 255.0\\n # text reshape: (batch_size, num_candidates, seq_length) -> (batch_size * num_candidates, seq_length)\\n token_ids = token_ids.reshape((-1, ) + token_ids.shape[2:])\\n text_input_mask = input_mask.reshape((-1, ) + input_mask.shape[2:])\\n if mlm_label is not None:\\n mlm_label = mlm_label.reshape((-1, ) + mlm_label.shape[2:])\\n\\n\\n visual_token = self.extract_visual_feat(imgs) # b, d, T, h, w\\n\\n B, D, T, H, W = visual_token.shape\\n losses = dict()\\n # -------------- nce loss ------------------- #\\n if hasattr(self, 'ssl_head'):\\n input_ssl_ids = torch.where(mlm_label == -100, token_ids.clone(), mlm_label.clone())\\n input_ssl_mask = text_input_mask.clone()\\n text_only_out = self.text_backbone(input_ssl_ids, input_ssl_mask)\\n # ------------ complete T -------------- #\\n text_out_no_mask = text_only_out['last_hidden_state']\\n visual_emb, text_emb = self.ssl_head(visual_token, text_out_no_mask, input_ssl_mask, input_ssl_ids)\\n\\n\\n # ------------ complete V ---------------- #\\n visual_token = visual_token.view(B, D, T, -1).permute(0, 2, 3, 1)\\n\\n\\n # ---------- foward mask text input ---------- # \\n text_out_with_mask = self.text_backbone(token_ids, text_input_mask)\\n text_out_last_hidden_state = text_out_with_mask['last_hidden_state']\\n\\n # ---------- forward mask v input ------------ #\\n visual_token_with_mask, v_mask = self.extract_visual_feat(imgs.clone(), v_token_mask) # b, d, T, h, w\\n visual_token_mask = visual_token_with_mask.view(B, D, T, -1).permute(0, 2, 3, 1)\\n \\n v_fusion_output = self.multimodal_backbone(visual_token=visual_token_mask, text_input_mask=text_input_mask.clone(), text_input_embeds=text_out_no_mask.clone())\\n \\n t_fusion_output = self.multimodal_backbone(visual_token=visual_token, text_input_mask=text_input_mask, text_input_embeds=text_out_last_hidden_state)\\n # for mlm #\\n t_last_hidden_state = t_fusion_output['t_last_hidden_state']\\n\\n\\n\\n\\n\\n # ------------ MLM loss ------------ #\\n\\n if mlm_label is not None and self.mlm_head is not None:\\n # we use mask text for MLM\\n # because we doubt there will be miss interaction between wrong img-text pair \\n # and the model not learn good relationship between vision and language\\n # -------- forward masked text ----------- #\\n mlm_prediction_score = self.mlm_head(t_last_hidden_state)\\n \\n if self.mlm_loss_func is not None:\\n mlm_label_idx = torch.where(mlm_label.view(-1) != -100)\\n mlm_prediction_mask_score = mlm_prediction_score.view(-1, self.text_vocab_size)[mlm_label_idx[0], :]\\n mlm_label_mask = mlm_label.view(-1)[mlm_label_idx]\\n mlm_loss = self.mlm_loss_func(mlm_prediction_mask_score, mlm_label_mask)\\n else:\\n mlm_loss = self.loss_func(mlm_prediction_score.view(-1, self.text_vocab_size), mlm_label.view(-1))\\n losses['mlm_loss'] = mlm_loss\\n\\n\\n # ------- Tri-modal alignment with mask sample and ranking --------- #\\n if self.mlm_ssl_V_head is not None:\\n mlm_visual_feat = v_fusion_output['t_last_hidden_state'][:, 0]\\n mask_visual_recon_emb = self.mlm_ssl_V_head(mlm_visual_feat)\\n mask_word_emb = self.ssl_head.forward_text(text_out_last_hidden_state) if self.use_Cmask else None\\n loss_cvt_rank = self.ssl_loss(visual_emb, text_emb, mask_word_emb, mask_visual_recon_emb)\\n losses.update(loss_cvt_rank)\\n\\n\\n if self.symmetry_rank:\\n mlm_word_feat = t_last_hidden_state[:, 0]\\n mask_word_recon_emb = self.mlm_ssl_T_head(mlm_word_feat)\\n\\n mask_visual_emb = self.ssl_head.forward_vision(visual_token_with_mask) if self.use_Cmask else None\\n \\n loss_ctv_rank = self.ssl_loss(text_emb, visual_emb, mask_visual_emb, mask_word_recon_emb)\\n loss_ctv_rank['v_nce_loss'] = loss_ctv_rank.pop('nce_loss')\\n \\n if self.ssl_loss.use_rank:\\n loss_ctv_rank['rank_v_vm_loss'] = loss_ctv_rank.pop('rank_t_tm_loss')\\n\\n \\n\\n losses.update(loss_ctv_rank)\\n\\n\\n\\n return losses\",\n \"def __surface_labelled_segmentation_pipeline(self, features):\\n tic = time.perf_counter()\\n\\n # Collect the data\\n ###########################################\\n training_data, dev_data, test_data = {}, {}, {}\\n dictionaries = (training_data, dev_data, test_data)\\n counter = 0\\n for file in self.input_files:\\n input_file = open(os.path.join(sys.path[0], file), 'r')\\n for line in input_file.readlines():\\n content = line.rstrip('\\\\n').split(\\\" | \\\")\\n labels = '-'.join(get_labels(content[2]))\\n segments = removeLabels(content[2])\\n\\n # dictionaries[counter][content[0]] = [segments, labels] # word:[[segments],[labels]]\\n dictionaries[counter][segments] = labels # segments : labels\\n input_file.close()\\n counter += 1\\n\\n toc = time.perf_counter()\\n print(\\\"Data Collected in \\\" + str(tic - toc.__round__(2)))\\n\\n # Evaluate Model On the Test Set Using Optimised Model\\n #######################################################\\n\\n print(\\\"Beginning Feature Computation and Model Optimisation\\\")\\n tic = time.perf_counter()\\n\\n X_training, Y_training, words_training = surface_labelled_data_preparation(training_data)\\n X_dev, Y_dev, words_dev = surface_labelled_data_preparation(dev_data)\\n X_test, Y_test, words_test = surface_labelled_data_preparation(test_data)\\n print(\\\"Data Processed\\\")\\n\\n best_epsilon = 1e-07\\n best_max_iteration = 280\\n best_algo = 'ap'\\n\\n # crf = sklearn_crfsuite.CRF(algorithm=best_algo, epsilon=best_epsilon, max_iterations=best_max_iteration)\\n '''crf = sklearn_crfsuite.CRF(\\n algorithm='lbfgs',\\n c1=0.1,\\n c2=0.1,\\n max_iterations=100,\\n all_possible_transitions=True\\n )'''\\n crf = sklearn_crfsuite.CRF(algorithm='ap', epsilon=best_epsilon, max_iterations=best_max_iteration)\\n print(\\\"CRF Initialized\\\")\\n # crf.fit(X_training, Y_training, X_dev=X_dev, y_dev=Y_dev)\\n crf.fit(X_training, Y_training)\\n print(\\\"Data Fitted\\\")\\n Y_predict = crf.predict(features)\\n labels = list(crf.classes_)\\n sorted_labels = sorted(labels)\\n return Y_predict, Y_test\",\n \"def process_image(img, debug=True):\\n global X_scaler, svc, feature, heatmap\\n\\n global top_left_x, top_left_y, bottom_right_x, bottom_right_y\\n global start_win_width, start_win_height, end_win_width, end_win_height\\n global overlap_frac_x, overlap_frac_y, layer\\n\\n out_img = np.copy(img)\\n\\n # When training the model, the images are loaded by cv2 => BGR (they might be converted later, though)\\n # Since moviepy read images as RGB, we need to convert them to BGR first\\n img = cv2.cvtColor(img, cv2.COLOR_RGB2BGR)\\n\\n windows = get_windows(img,\\n x_start_stop=[top_left_x, bottom_right_x],\\n y_start_stop=[top_left_y, bottom_right_y],\\n overlap=(overlap_frac_x, overlap_frac_y),\\n window_start_size=(start_win_width, start_win_height),\\n window_end_size=(end_win_width, end_win_height),\\n layers=layer)\\n\\n car_windows = []\\n for window in windows:\\n # Extract bounding box image from frame\\n cropped_img = get_image_region(img, bbox=window)\\n\\n # Get feature vector\\n feature_vector = feature.extract(cropped_img).astype(np.float64)\\n\\n # Normalize vector\\n scaled_feature_vetor = X_scaler.transform(feature_vector)\\n\\n # Make prediction\\n pred = svc.predict(scaled_feature_vetor)\\n\\n # If pred[0] == 1. then a car was detected\\n if pred[0] == 1.:\\n car_windows.append(window)\\n\\n # Add heat to heatmap where cars were detected\\n heatmap.add_heat(car_windows)\\n\\n # Get labels from heatmap\\n l = heatmap.get_labels()\\n\\n # Create image with all detected labels (post-heatmap)\\n label_img = draw_labeled_bboxes(out_img, l)\\n\\n if debug:\\n print('cars found: {}'.format(l[1]))\\n\\n # Create image with all detected cars (pre-heatmap)\\n box_img = draw_boxes(out_img, car_windows)\\n\\n # Create image that is an average of the last frames heatmap\\n last_heatmaps_img = heatmap.last_maps_average()\\n\\n # Reduce size to 1/3\\n small_last_heatmaps_img = cv2.resize(last_heatmaps_img,\\n (last_heatmaps_img.shape[1]//3, last_heatmaps_img.shape[0]//3))\\n small_current_heatmap_img = cv2.resize(heatmap.current_map, (heatmap.shape[1]//3, heatmap.shape[0]//3))\\n small_box_img = cv2.resize(box_img, (box_img.shape[1]//3, box_img.shape[0]//3))\\n\\n # Create debug view\\n right_img = np.vstack((small_last_heatmaps_img, small_current_heatmap_img, small_box_img))\\n\\n # Add debug view to video\\n out_img = np.hstack((label_img,\\n right_img))\\n else:\\n out_img = np.copy(label_img)\\n\\n # Move current heatmap to archive, create new map for next frame\\n heatmap.next_map()\\n\\n return out_img\",\n \"def extract_feat(self, img):\\r\\n _, _, x = self.pre_encoder(img)\\r\\n x = self.backbone(x)\\r\\n if self.with_neck:\\r\\n x = self.neck(x)\\r\\n return x\",\n \"def test_stage_0():\\n\\tra_1 = readImage(TRAIN_RAW_IMAGE_1)\\n\\tre_1 = readImage(TRAIN_RESULT_IMAGE_1)\\n\\n\\tra_2 = readImage(TRAIN_RAW_IMAGE_2)\\n\\tre_2 = readImage(TRAIN_RESULT_IMAGE_2)\\n\\n\\t# Uncomment below if more examples are required.\\n\\t# ra_3 = readImage(TRAIN_RAW_IMAGE_3)\\n\\t# re_3 = readImage(TRAIN_RESULT_IMAGE_3)\\n\\n\\t# Uncomment below if the additional features are needed.\\n\\t# ra_1 += (\\n\\t# \\tlaplace_operator(TRAIN_RAW_IMAGE_1),\\\\\\n\\t# \\t# k_means(TRAIN_RAW_IMAGE_1)[0],\\\\\\n\\t# \\t)\\n\\n\\t# Uncomment below if the additional features are needed.\\n\\t# ra_2 += (\\n\\t# \\tlaplace_operator(TRAIN_RAW_IMAGE_2),\\\\\\n\\t# \\t# k_means(TRAIN_RAW_IMAGE_2)[0],\\\\\\n\\t# \\t)\\n\\n\\t# The prediction model is obtained and trained.\\n\\tengine = get_model((ra_1, ra_2,), (re_1, re_2,), model_type=SVM, percentage=0.1)\\n\\n\\ttest_percentage = float(1) # how many tests\\n\\n\\tra_1 = readImage(TEST_RAW_IMAGE_1)\\n\\n\\t# Uncomment below if the additional features are needed.\\n\\t# ra_1 += (\\n\\t# \\tlaplace_operator(TEST_RAW_IMAGE_1),\\\\\\n\\t# \\t# k_means(TEST_RAW_IMAGE_1)[0],\\\\\\n\\t# \\t)\\n\\n\\tre_1 = readImage(TEST_RESULT_IMAGE_1)\\n\\n\\t# ra_2 = readImage(TEST_RAW_IMAGE_2)\\n\\t# re_2 = readImage(TEST_RESULT_IMAGE_2)\\n\\n\\tinput_vec = []\\n\\t# The features are extracted.\\n\\tinput_vec += buildFeatureArray_2(ra_1[0], ra_1[1], ra_1[2],\\\\\\n\\t\\tRADIUS_ARRAY,\\\\\\n\\t\\tadditional_feats=([] if len(ra_1) == 3 else ra_1[3:]))\\n\\n\\tex_no = int(test_percentage * len(input_vec)) # actual number of the test sample\\n\\n\\toutput_vec = []\\n\\toutput_vec += matrixToArray(re_1[0], lambda el: 1 if el == 255 else 0)\\n\\n\\tprint('Will start predicting...')\\n\\n\\tpredicted_vec = engine.predict(input_vec[:ex_no])\\n\\n\\tcounter = float(0)\\n\\tfor y, p in zip(output_vec[:ex_no], predicted_vec[:ex_no]):\\n\\t\\tif y == p: counter += 1\\n\\n\\tprint('Accuracy: ' + str(counter/ex_no))\\n\\n\\tpredicted_mat = arrayToMatrix( predicted_vec, len(re_1[0]), len(re_1[0][0]),\\\\\\n\\t\\tlambda el: 255 if el == 1 else 0)\\n\\n\\t# The predicted segmentation is saved.\\n\\tsave_rgb_img(\\\\\\n\\t np.array(predicted_mat).transpose(),\\\\\\n\\t np.array(predicted_mat).transpose(),\\\\\\n\\t np.array(predicted_mat).transpose(),\\\\\\n\\t 'pred.bmp',\\\\\\n\\t)\",\n \"def single_img_features(img, color_space='RGB', spatial_size=(32, 32),\\n hist_bins=32, orient=9,\\n pix_per_cell=8, cell_per_block=2, hog_channel=0,\\n spatial_feat=True, hist_feat=True, hog_feat=True, vis=False):\\n # 1) Define an empty list to receive features\\n img_features = []\\n # 2) Apply colour conversion if other than 'RGB'\\n if color_space != 'RGB':\\n if color_space == 'HSV':\\n feature_image = cv2.cvtColor((img, cv2.COLOR_RGB2HSV))\\n elif color_space == 'LUV':\\n feature_image = cv2.cvtColor((img, cv2.COLOR_RGB2LUV))\\n elif color_space == 'HLS':\\n feature_image = cv2.cvtColor((img, cv2.COLOR_RGB2HLS))\\n elif color_space == 'YUV':\\n feature_image = cv2.cvtColor((img, cv2.COLOR_RGB2YUV))\\n elif color_space == 'YCrCb':\\n feature_image = cv2.cvtColor(img, cv2.COLOR_RGB2YCrCb)\\n # print('converting to YCrCb')\\n else:\\n feature_image = np.copy(img)\\n\\n # 3) Compute spatial features if flag is set\\n if spatial_feat == True:\\n spatial_features = bin_spatial(feature_image, size=spatial_size)\\n # 4) Append features to list\\n img_features.append(spatial_features)\\n # 5) Compute histogram features if flag is set\\n if hist_feat == True:\\n # Apply color_hist()\\n hist_features = color_hist(feature_image, nbins=hist_bins)\\n # 6) Append features to list\\n img_features.append(hist_features)\\n # 7) Compute HOG features if flag is set\\n if hog_feat == True:\\n # Call get_hog_features() with vis=False, feature_vec=True\\n if hog_channel == 'ALL':\\n hog_features = []\\n for channel in range(feature_image.shape[2]):\\n hog_features.append(get_hog_features(feature_image[:, :, channel],\\n orient, pix_per_cell, cell_per_block,\\n vis=False, feature_vec=True))\\n hog_features = np.concatenate(hog_features)\\n # hog_features = np.ravel(hog_features)\\n else:\\n if vis == True:\\n hog_features, hog_image = get_hog_features(feature_image[:, :, hog_channel], orient,\\n pix_per_cell, cell_per_block, vis=True,\\n feature_vec=True)\\n else:\\n hog_features = get_hog_features(feature_image[:, :, hog_channel], orient,\\n pix_per_cell, cell_per_block, vis=False, feature_vec=True)\\n # 8) Append features to list\\n img_features.append(hog_features)\\n\\n # 9) Return concatenated array of features\\n if vis == True:\\n return np.concatenate(img_features), hog_image\\n else:\\n return np.concatenate(img_features)\",\n \"def compute_features(depc, gid_list, config=None):\\n logger.info('[ibs] Preprocess Features')\\n logger.info('config = {!r}'.format(config))\\n # Get controller\\n ibs = depc.controller\\n ibs.assert_valid_gids(gid_list)\\n ######################################################################################\\n\\n if config['framework'] in ['keras']:\\n from keras.preprocessing import image as preprocess_image\\n\\n thumbnail_config = {\\n 'draw_annots': False,\\n 'thumbsize': (500, 500),\\n }\\n thumbpath_list = depc.get(\\n 'thumbnails',\\n gid_list,\\n 'img',\\n config=thumbnail_config,\\n read_extern=False,\\n ensure=True,\\n )\\n\\n target_size = (224, 224)\\n if config['model'] in ['vgg', 'vgg16']:\\n from keras.applications.vgg16 import VGG16 as MODEL_CLASS\\n from keras.applications.vgg16 import preprocess_input\\n ######################################################################################\\n elif config['model'] in ['vgg19']:\\n from keras.applications.vgg19 import VGG19 as MODEL_CLASS\\n from keras.applications.vgg19 import preprocess_input\\n ######################################################################################\\n elif config['model'] in ['resnet']:\\n from keras.applications.resnet50 import ResNet50 as MODEL_CLASS # NOQA\\n from keras.applications.resnet50 import preprocess_input\\n ######################################################################################\\n elif config['model'] in ['inception']:\\n from keras.applications.inception_v3 import InceptionV3 as MODEL_CLASS # NOQA\\n from keras.applications.inception_v3 import preprocess_input\\n\\n target_size = (299, 299)\\n ######################################################################################\\n else:\\n raise ValueError(\\n 'specified feature model is not supported in config = {!r}'.format(config)\\n )\\n\\n # Build model\\n model = MODEL_CLASS(include_top=False)\\n\\n thumbpath_iter = ut.ProgIter(thumbpath_list, lbl='forward inference', bs=True)\\n for thumbpath in thumbpath_iter:\\n image = preprocess_image.load_img(thumbpath, target_size=target_size)\\n image_array = preprocess_image.img_to_array(image)\\n image_array = np.expand_dims(image_array, axis=0)\\n image_array = preprocess_input(image_array)\\n features = model.predict(image_array)\\n if config['flatten']:\\n features = features.flatten()\\n yield (features,)\\n elif config['framework'] in ['torch']:\\n from wbia.algo.detect import densenet\\n\\n if config['model'] in ['densenet']:\\n config_ = {\\n 'draw_annots': False,\\n 'thumbsize': (densenet.INPUT_SIZE, densenet.INPUT_SIZE),\\n }\\n thumbpath_list = ibs.depc_image.get(\\n 'thumbnails',\\n gid_list,\\n 'img',\\n config=config_,\\n read_extern=False,\\n ensure=True,\\n )\\n feature_list = densenet.features(thumbpath_list)\\n else:\\n raise ValueError(\\n 'specified feature model is not supported in config = {!r}'.format(config)\\n )\\n\\n for feature in feature_list:\\n if config['flatten']:\\n feature = feature.flatten()\\n yield (feature,)\\n else:\\n raise ValueError(\\n 'specified feature framework is not supported in config = {!r}'.format(config)\\n )\",\n \"def _preprocess_image(self, sess, image, is_first_frame):\\n features, self.cropped_input_image = sess.run([self.features, self.image_after_crop], feed_dict = {\\n self.image_ph: image,\\n self.cropbox_ph: self.cropbox,\\n })\\n #by default should be [8, 8, 512]\\n feature_dim = features.shape\\n #logging.debug(feature_dim)\\n num_features, num_channels = feature_dim\\n\\n if is_first_frame:\\n #pad [num_features, 1]\\n pad = np.zeros((num_features, 1))\\n features = np.concatenate([features, pad], 1)\\n #generate gt\\n #gt shape: [num_features, 1]\\n gt = np.reshape(preprocess.generate_gt(\\n preprocess.apply_transformation(self.normalized_bbox,\\n self.transformation),\\n FLAGS.cropbox_grid, FLAGS.bbox_grid), [-1, 1])\\n features = np.concatenate([features, gt], 1)\\n else:\\n #this pad contains pad and dummy gt\\n pad = np.zeros((num_features, 2))\\n features = np.concatenate([features, pad], 1)\\n #[...,0,1,0]\\n frame_delimiter = np.concatenate([\\n np.zeros((1, num_channels)),\\n np.ones((1, 1)),\\n np.zeros((1, 1))], 1)\\n features = np.concatenate([frame_delimiter, features], 0)\\n return features\",\n \"def map_fn(image, label):\\n if is_training and train_mode == 'pretrain':\\n xs = []\\n for _ in range(2): # Two transformations\\n xs.append(preprocess_fn_pretrain(image))\\n image = tf.concat(xs, -1)\\n else:\\n image = preprocess_fn_finetune(image)\\n label = tf.one_hot(label, num_classes)\\n return image, label\",\n \"def get_mask(self, input_image): \\r\\n guided_feed_dict = {}\\r\\n guided_feed_dict[self.imported_x] = input_image \\r\\n \\r\\n gradients = self.guided_sess.run(self.guided_grads_node, feed_dict = guided_feed_dict)[0][0]\\r\\n return gradients\",\n \"def forward_dummy(self, x, proposal_boxes, proposal_feats, img_metas):\\n all_stage_mask_results = []\\n num_imgs = len(img_metas)\\n num_proposals = proposal_feats.size(1)\\n C, H, W = x.shape[-3:]\\n mask_preds = proposal_feats.bmm(x.view(num_imgs, C, -1)).view(\\n num_imgs, num_proposals, H, W)\\n object_feats = proposal_feats\\n for stage in range(self.num_stages):\\n mask_results = self._mask_forward(stage, x, object_feats,\\n mask_preds, img_metas)\\n all_stage_mask_results.append(mask_results)\\n return all_stage_mask_results\",\n \"def _forward_mask(self, features: Dict[str, torch.Tensor], instances: List[Instances]):\\n if not self.mask_on:\\n return {} if self.training else instances\\n\\n if self.training:\\n # head is only trained on positive proposals.\\n instances, _ = select_foreground_proposals(instances, self.num_classes)\\n\\n if self.mask_pooler is not None:\\n features = [features[f] for f in self.mask_in_features]\\n boxes = [x.proposal_boxes if self.training else x.pred_boxes for x in instances]\\n features = self.mask_pooler(features, boxes)\\n else:\\n features = {f: features[f] for f in self.mask_in_features}\\n return self.mask_head(features, instances)\",\n \"def getSuperPixelFeatures_pixel(image, mask):\\n \\n # Generate the pixel-level features for the image\\n imagePixelFeatures = generatePixelFeaturesForImage(image)\\n numFeaturesPerPixel = np.shape(imagePixelFeatures)[1]\\n numColumns = np.shape(image)[1]\\n numRows = np.shape(image)[0]\\n # Get the list of regions in the superpixel mask. np.unique() seems to give consistent sorted ordering\\n superPixels = np.unique(mask)\\n numSuperPixels = np.size(superPixels)\\n \\n # Reshape (i*j , f) image feature to (i, j, f) array\\n imagePixelFeatures = np.reshape( imagePixelFeatures, (numRows, numColumns, numFeaturesPerPixel) )\\n \\n # TODO might need a mapper to take superpixel region names and convert to ordered list from 1 to numSuperpixels.\\n \\n # for each superpixel, create a single feature array i.e. append the feature vectors from each pixel into single array\\n # Alternatively, create a list/array of feature vectors for each super pixel\\n\\n allImgSuperPixelFeatures = []\\n \\n superPixelCount = 0\\n \\n for spIdx in range(0 , numSuperPixels ):\\n\\n superPixel = superPixels[spIdx] \\n# print \\\"t***Processing superpixel region#\\\" , superPixel\\n \\n superPixelMask = (mask == superPixel)\\n \\n superPixelCount = superPixelCount + np.sum(superPixelMask)\\n \\n # Generate a single array of feature arrays for pixels that match superpixel number \\n pixelFeaturesInSuperPixel = imagePixelFeatures[ superPixelMask, : ]\\n \\n allImgSuperPixelFeatures.append(pixelFeaturesInSuperPixel)\\n \\n assert numSuperPixels == np.shape(allImgSuperPixelFeatures)[0] , \\\"The number of superpixels in mask != number of superpixels in result list\\\"\\n \\n assert superPixelCount == (numRows * numColumns) , \\\"The number of pixels assigned to super pixels != number of pixels in image!\\\"\\n \\n for idx in range(0 , numSuperPixels ):\\n assert np.shape(allImgSuperPixelFeatures[idx])[1] == numFeaturesPerPixel, \\\"Superpixel result #\\\" + str(idx) + \\\" does not have \\\" + str(numFeaturesPerPixel) + \\\"; has \\\" + str(np.shape(allImgSuperPixelFeatures[idx])[1])\\n \\n return allImgSuperPixelFeatures\",\n \"def forward(self):\\n priors = []\\n for k, f in enumerate(self.feature_maps):\\n scale = self.image_size / self.strides[k]\\n # for i, j in product(range(f), repeat=2):\\n for i in range(f[0]):\\n for j in range(f[1]):\\n # print(i, j)\\n # unit center x,y\\n cx = (j + 0.5) / scale\\n cy = (i + 0.5) / scale\\n\\n # small sized square box\\n size = self.min_sizes[k]\\n h = w = size / self.image_size\\n priors.append([cx, cy, w, h])\\n\\n # big sized square box\\n size = sqrt(self.min_sizes[k] * self.max_sizes[k])\\n h = w = size / self.image_size\\n priors.append([cx, cy, w, h])\\n\\n # change h/w ratio of the small sized box\\n size = self.min_sizes[k]\\n h = w = size / self.image_size\\n for ratio in self.aspect_ratios[k]:\\n ratio = sqrt(ratio)\\n priors.append([cx, cy, w * ratio, h / ratio])\\n priors.append([cx, cy, w / ratio, h * ratio])\\n\\n priors = torch.Tensor(priors)\\n if self.clip:\\n priors.clamp_(max=1, min=0)\\n return priors\",\n \"def forward(self, x):\\n sources = list()\\n new_sources = list()\\n\\n # apply lds to the initial image\\n x_pool = self.lds(x)\\n\\n # apply vgg up to conv4_3\\n for k in range(22):\\n x = self.features[k](x)\\n conv4_3_bn = self.ibn1(x)\\n x_pool1_skip, x_pool1_icn = self.icn1(x_pool)\\n s = self.Norm1(conv4_3_bn * x_pool1_icn)\\n\\n # apply vgg up to fc7\\n for k in range(22, 34):\\n x = self.features[k](x)\\n conv7_bn = self.ibn2(x)\\n x_pool2_skip, x_pool2_icn = self.icn2(x_pool1_skip)\\n p = self.Norm2(self.dsc1(s) + conv7_bn * x_pool2_icn)\\n\\n x = self.features[34](x)\\n\\n # apply extra layers and cache source layer outputs\\n for k, v in enumerate(self.extra):\\n x = v(x)\\n if k == 0:\\n x_pool3_skip, x_pool3_icn = self.icn3(x_pool2_skip)\\n w = self.Norm3(self.dsc2(p) + x * x_pool3_icn)\\n elif k == 2:\\n x_pool4_skip, x_pool4_icn = self.icn4(x_pool3_skip)\\n q = self.Norm4(self.dsc3(w) + x * x_pool4_icn)\\n elif k == 4:\\n o = self.Norm5(self.dsc4(q) + x)\\n sources.append(o)\\n elif k == 7 or k == 9:\\n sources.append(x)\\n else:\\n pass\\n\\n # project the forward features into lower dimension.\\n tmp1 = self.proj1(p)\\n tmp2 = self.proj2(w)\\n tmp3 = self.proj3(q)\\n tmp4 = self.proj4(o)\\n\\n # The conv4_3 level\\n proj1 = F.upsample(tmp1, scale_factor=2, mode='bilinear')\\n proj2 = F.upsample(tmp2, scale_factor=4, mode='bilinear')\\n proj3 = F.upsample(tmp3, scale_factor=8, mode='bilinear')\\n proj4 = F.upsample(tmp4, scale_factor=16, mode='bilinear')\\n proj = torch.cat([proj1, proj2, proj3, proj4], dim=1)\\n\\n agent1 = self.agent1(s)\\n\\n convert1 = self.convert1(proj)\\n pred1 = torch.cat([agent1, convert1], dim=1)\\n pred1 = self.merge1(pred1)\\n new_sources.append(pred1)\\n\\n # The fc_7 level\\n proj2 = F.upsample(tmp2, scale_factor=2, mode='bilinear')\\n proj3 = F.upsample(tmp3, scale_factor=4, mode='bilinear')\\n proj4 = F.upsample(tmp4, scale_factor=8, mode='bilinear')\\n proj = torch.cat([proj2, proj3, proj4], dim=1)\\n\\n agent2 = self.agent2(p)\\n convert2 = self.convert2(proj)\\n pred2 = torch.cat([agent2, convert2], dim=1)\\n pred2 = self.merge2(pred2)\\n new_sources.append(pred2)\\n\\n # The conv8 level\\n proj3 = F.upsample(tmp3, scale_factor=2, mode='bilinear')\\n proj4 = F.upsample(tmp4, scale_factor=4, mode='bilinear')\\n proj = torch.cat([proj3, proj4], dim=1)\\n\\n agent3 = self.agent3(w)\\n convert3 = self.convert3(proj)\\n pred3 = torch.cat([agent3, convert3], dim=1)\\n pred3 = self.merge3(pred3)\\n new_sources.append(pred3)\\n\\n # The conv9 level\\n proj4 = F.upsample(tmp4, scale_factor=2, mode='bilinear')\\n proj = proj4\\n\\n agent4 = self.agent4(q)\\n convert4 = self.convert4(proj)\\n pred4 = torch.cat([agent4, convert4], dim=1)\\n pred4 = self.merge4(pred4)\\n new_sources.append(pred4)\\n\\n for prediction in sources:\\n new_sources.append(prediction)\\n\\n return new_sources\",\n \"def collect_best_features(self):\\n bincsp = self.binary_csp # just to make code shorter\\n n_folds = len(self.binary_csp.folds)\\n n_class_pairs = len(self.binary_csp.class_pairs)\\n result_shape = (n_folds, n_class_pairs)\\n self.train_feature = np.empty(result_shape, dtype=object)\\n self.train_feature_full_fold = np.empty(result_shape, dtype=object)\\n self.test_feature = np.empty(result_shape, dtype=object)\\n self.test_feature_full_fold = np.empty(result_shape, dtype=object)\\n self.selected_filters_per_filterband = np.empty(result_shape, dtype=object)\\n for fold_i in range(n_folds):\\n for class_pair_i in range(n_class_pairs):\\n bin_csp_train_features = deepcopy(bincsp.train_feature[\\n self.selected_filter_inds, fold_i, class_pair_i])\\n bin_csp_train_features_full_fold = deepcopy(\\n bincsp.train_feature_full_fold[\\n self.selected_filter_inds,\\n fold_i, class_pair_i])\\n bin_csp_test_features = deepcopy(bincsp.test_feature[\\n self.selected_filter_inds, fold_i, class_pair_i])\\n bin_csp_test_features_full_fold = deepcopy(\\n bincsp.test_feature_full_fold[\\n self.selected_filter_inds,fold_i, class_pair_i])\\n selected_filters_per_filt = self.select_best_filters_best_filterbands(\\n bin_csp_train_features, max_features=self.n_features,\\n forward_steps=self.forward_steps, \\n backward_steps=self.backward_steps,\\n stop_when_no_improvement=self.stop_when_no_improvement)\\n self.train_feature[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_train_features, selected_filters_per_filt)\\n self.train_feature_full_fold[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_train_features_full_fold, selected_filters_per_filt)\\n \\n self.test_feature[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_test_features, selected_filters_per_filt)\\n self.test_feature_full_fold[fold_i, class_pair_i] = \\\\\\n self.collect_features_for_filter_selection(\\n bin_csp_test_features_full_fold, selected_filters_per_filt)\\n \\n self.selected_filters_per_filterband[fold_i, class_pair_i] = \\\\\\n selected_filters_per_filt\",\n \"def preprocessing_fn(inputs):\\n outputs = {}\\n for key in _DENSE_FLOAT_FEATURE_KEYS:\\n # Preserve this feature as a dense float, setting nan's to the mean.\\n outputs[_transformed_name(key)] = tft.scale_to_z_score(\\n _fill_in_missing(inputs[key]))\\n\\n for key in _VOCAB_FEATURE_KEYS:\\n # Build a vocabulary for this feature.\\n outputs[_transformed_name(key)] = tft.compute_and_apply_vocabulary(\\n _fill_in_missing(inputs[key]),\\n top_k=_VOCAB_SIZE,\\n num_oov_buckets=_OOV_SIZE)\\n\\n for key in _BUCKET_FEATURE_KEYS:\\n outputs[_transformed_name(key)] = tft.bucketize(\\n _fill_in_missing(inputs[key]), _FEATURE_BUCKET_COUNT,\\n always_return_num_quantiles=False)\\n\\n for key in _CATEGORICAL_FEATURE_KEYS:\\n outputs[_transformed_name(key)] = _fill_in_missing(inputs[key])\\n\\n # Was this passenger a big tipper?\\n taxi_fare = _fill_in_missing(inputs[_FARE_KEY])\\n tips = _fill_in_missing(inputs[_LABEL_KEY])\\n outputs[_transformed_name(_LABEL_KEY)] = tf.where(\\n tf.is_nan(taxi_fare),\\n tf.cast(tf.zeros_like(taxi_fare), tf.int64),\\n # Test if the tip was > 20% of the fare.\\n tf.cast(\\n tf.greater(tips, tf.multiply(taxi_fare, tf.constant(0.2))), tf.int64))\\n\\n return outputs\",\n \"def forward(self, im1,im2,im3,im4,im5,im6):\\n #edge_index_1 = data[\\\"edge_index_1\\\"]\\n #edge_index_2 = data[\\\"edge_index_2\\\"]\\n #features_1 = data[\\\"features_1\\\"]\\n #features_2 = data[\\\"features_2\\\"]\\n #print(data.shape)\\n im1 = im1.unsqueeze(0)\\n im2 = im2.unsqueeze(0)\\n im3 = im3.unsqueeze(0)\\n im4 = im4.unsqueeze(0)\\n im5 = im5.unsqueeze(0)\\n im6 = im6.unsqueeze(0)\\n f_g_1_1 = self.backbone(im1)\\n f_g_1_2 = self.backbone(im2)\\n f_g_1_3 = self.backbone(im3)\\n f_g_2_1 = self.backbone(im4)\\n f_g_2_2 = self.backbone(im5)\\n f_g_2_3 = self.backbone(im6)\\n edge_index_1 = torch.tensor([[0,0,0,1,1,1,2,2,2],[0,1,2,0,1,2,0,1,2]],dtype=torch.long).cuda()\\n #edge_index_1 = edge_index_1.t().contiguous()\\n edge_index_2 = edge_index_1\\n #print('zz11!', f_g_1_1.shape, f_g_2_3.shape, edge_index_1.shape)\\n features_1 = torch.cat([f_g_1_1,f_g_1_2,f_g_1_3],dim=0)\\n features_2 = torch.cat([f_g_2_1,f_g_2_2,f_g_2_3],dim=0)\\n features_1 = features_1.view(3,-1)\\n features_2 = features_1.view(3,-1)\\n #features_1 = features_1.permute(2,3,1,0)\\n #features_2 = features_2.permute(2,3,1,0)\\n #print(features_1.shape, features_2.shape)\\n #time.sleep(50)\\n abstract_features_1 = self.convolutional_pass(edge_index_1, features_1)\\n abstract_features_2 = self.convolutional_pass(edge_index_2, features_2)\\n #print('alalala')\\n #time.sleep(5)\\n if self.args.histogram == True:\\n hist = self.calculate_histogram(abstract_features_1,\\n torch.t(abstract_features_2))\\n\\n pooled_features_1 = self.attention(abstract_features_1)\\n pooled_features_2 = self.attention(abstract_features_2)\\n scores = self.tensor_network(pooled_features_1, pooled_features_2)\\n scores = torch.t(scores)\\n\\n if self.args.histogram == True:\\n scores = torch.cat((scores, hist), dim=1).view(1, -1)\\n\\n scores = torch.nn.functional.relu(self.fully_connected_first(scores))\\n score = torch.sigmoid(self.scoring_layer(scores))\\n return score\",\n \"def data_tf(img):\\n img = crop.process(img)\\n img = random_contrast.process(img)\\n img = random_brightness.process(img)\\n img = random_color.process(img)\\n img = random_sharpness.process(img)\\n if img.size[1] >= 32:\\n img = compress.process(img)\\n img = adjust_resolution.process(img)\\n img = blur.process(img)\\n img = exposure.process(img)\\n # img = rotate.process(img)\\n img = salt.process(img)\\n img = inverse_color(img)\\n img = stretch.process(img)\\n return img\",\n \"def forward(self, x):\\n # sources保存特征图，loc与conf保存所有PriorBox的位置与类别预测特征\\n sources = list()\\n loc = list()\\n conf = list()\\n\\n # 对输入图像卷积到conv4_3，将特征添加到sources中\\n for k in range(23):\\n x = self.vgg[k](x)\\n\\n s = self.L2Norm(x)\\n sources.append(s)\\n\\n # 继续卷积到conv7，将特征添加到sources中\\n for k in range(23, len(self.vgg)):\\n x = self.vgg[k](x)\\n sources.append(x)\\n\\n # 继续利用额外的卷积层计算，并将特征添加到sources中\\n for k, v in enumerate(self.extras):\\n x = F.relu(v(x), inplace=True)\\n if k % 2 == 1: # 间隔一层\\n sources.append(x)\\n\\n # 对sources中的特征图利用类别与位置网络进行卷积计算，并保存到loc与conf中\\n for (x, l, c) in zip(sources, self.loc, self.conf):\\n loc.append(l(x).permute(0, 2, 3, 1).contiguous())\\n conf.append(c(x).permute(0, 2, 3, 1).contiguous())\\n\\n loc = torch.cat([o.view(o.size(0), -1) for o in loc], 1)\\n conf = torch.cat([o.view(o.size(0), -1) for o in conf], 1)\\n\\n if self.phase == \\\"test\\\":\\n output = self.detect(\\n loc.view(loc.size(0), -1, 4), # loc preds\\n self.softmax(conf.view(conf.size(0), -1, self.num_classes)), # conf preds\\n self.priors.type(type(x.data)) # default boxes\\n )\\n else:\\n # 对于训练来说，output包括了loc与conf的预测值以及PriorBox的信息\\n output = (\\n loc.view(loc.size(0), -1, 4),\\n conf.view(conf.size(0), -1, self.num_classes),\\n self.priors\\n )\\n return output\",\n \"def state_to_features(self, game_state: dict) -> np.array:\\n device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n # This is the dict before the game begins and after it ends\\n if game_state is None:\\n return None\\n\\n \\n #get global information as a 17x17 channel\\n x = game_state['field']\\n x = np.swapaxes(x,0,1)\\n for i in range(len(game_state['coins'])):\\n a = game_state['coins'][i][1]\\n b = game_state['coins'][i][0]\\n x[a][b] = 4\\n for i in range(len(game_state['bombs'])):\\n a = game_state['bombs'][i][0][1]\\n b = game_state['bombs'][i][0][0]\\n x[a][b] = -(5+game_state['bombs'][i][1])\\n for i in game_state['others']:\\n if i[2]:\\n x[i[3][1]][i[3][0]] = -10\\n else:\\n x[i[3][1]][i[3][0]] = -11\\n if game_state['self'][2]:\\n x[game_state['self'][3][1]][game_state['self'][3][0]] = 5\\n else:\\n x[game_state['self'][3][1]][game_state['self'][3][0]] = 6\\n expl_List = np.argwhere(game_state['explosion_map'] != 0)\\n for i in expl_List:\\n x[i[1]][i[0]] = -4\\n channel1 = x.copy()\\n \\n \\n #prep local channel\\n if self.modelToUse != 0:\\n #get simpele direction to and aways from closest coin or crate if no coin on the field\\n x_axis,y_axis,coin_creat_encoding = directionToNearestCoin_Crate(game_state['coins'], game_state['self'][3], game_state['field'])\\n if x_axis == \\\"left\\\":\\n if x[game_state['self'][3][1]][game_state['self'][3][0]-1] == 0:\\n x[game_state['self'][3][1]][game_state['self'][3][0]-1] = coin_creat_encoding\\n if x[game_state['self'][3][1]][game_state['self'][3][0]+1] == 0:\\n x[game_state['self'][3][1]][game_state['self'][3][0]+1] = -2\\n if x_axis == \\\"right\\\":\\n if x[game_state['self'][3][1]][game_state['self'][3][0]-1] == 0:\\n x[game_state['self'][3][1]][game_state['self'][3][0]-1] = -2\\n if x[game_state['self'][3][1]][game_state['self'][3][0]+1] == 0:\\n x[game_state['self'][3][1]][game_state['self'][3][0]+1] = coin_creat_encoding\\n if y_axis == \\\"up\\\":\\n if x[game_state['self'][3][1]-1][game_state['self'][3][0]] == 0:\\n x[game_state['self'][3][1]-1][game_state['self'][3][0]] = coin_creat_encoding\\n if x[game_state['self'][3][1]+1][game_state['self'][3][0]] == 0:\\n x[game_state['self'][3][1]+1][game_state['self'][3][0]] = -2\\n if y_axis == \\\"down\\\":\\n if x[game_state['self'][3][1]-1][game_state['self'][3][0]] == 0:\\n x[game_state['self'][3][1]-1][game_state['self'][3][0]] = -2\\n if x[game_state['self'][3][1]+1][game_state['self'][3][0]] == 0:\\n x[game_state['self'][3][1]+1][game_state['self'][3][0]] = coin_creat_encoding\\n \\n \\n \\n #get information of bombs: on which position the explotion will be and how far away the bomb is\\n bombs = game_state['bombs']\\n bombs.sort(key=lambda x: x[1],reverse=True)\\n x = np.pad(x, (3,3), 'constant', constant_values=(-1))\\n for i in (bombs):\\n y_bomb = i[0][1] + 3\\n x_bomb = i[0][0] + 3\\n for j in range(4):\\n if abs(x[y_bomb,x_bomb+j]) != 1 and x[y_bomb,x_bomb+j] != -4:\\n blocked = False\\n for l in range(j):\\n if x[y_bomb,x_bomb+j-l] == -1:\\n blocked = True\\n if blocked == False:\\n x[y_bomb,x_bomb+j] = -(9-j)\\n #print(\\\"test1\\\")\\n if abs(x[y_bomb,x_bomb-j]) != 1 and x[y_bomb,x_bomb-j] != -4:\\n blocked = False\\n for l in range(j):\\n if x[y_bomb,x_bomb-j+l] == -1:\\n blocked = True\\n if blocked == False:\\n x[y_bomb,x_bomb-j] = -(9-j)\\n #print(\\\"test2\\\")\\n if abs(x[y_bomb+j,x_bomb]) != 1 and x[y_bomb+j,x_bomb] != -4:\\n blocked = False\\n for l in range(j):\\n if x[y_bomb+j-l,x_bomb] == -1:\\n blocked = True\\n if blocked == False:\\n x[y_bomb+j,x_bomb] = -(9-j)\\n #print(\\\"test3\\\")\\n if abs(x[y_bomb-j,x_bomb]) != 1 and x[y_bomb-j,x_bomb] != -4:\\n blocked = False\\n for l in range(j):\\n if x[y_bomb-j+l,x_bomb] == -1:\\n blocked = True\\n if blocked == False:\\n x[y_bomb-j,x_bomb] = -(9-j)\\n #print(\\\"test4\\\")\\n x = x[3:-3,3:-3]\\n \\n \\n #get local view and concatenate it with channel 1 (will be sliced apart in the model later)\\n z = np.zeros(17)\\n y = x[game_state['self'][3][1]-1:game_state['self'][3][1]+2,game_state['self'][3][0]-1:game_state['self'][3][0]+2]\\n y = y.flatten()\\n z[0:9] = y\\n #get correct input for the model used\\n if self.modelToUse == 2:\\n z = Variable(torch.from_numpy(z)).to(device).to(torch.float)\\n z = z.unsqueeze(0).unsqueeze(0).unsqueeze(0)\\n channel1 = Variable(torch.from_numpy(channel1)).to(device).to(torch.float)\\n channel1 = channel1.unsqueeze(0).unsqueeze(0)\\n return torch.cat((channel1,z),2)\\n elif self.modelToUse == 1:\\n y = Variable(torch.from_numpy(y)).to(device).to(torch.float)\\n y = y.unsqueeze(0)\\n return y\\n else:\\n channel1 = Variable(torch.from_numpy(channel1)).to(device).to(torch.float)\\n channel1 = channel1.unsqueeze(0).unsqueeze(0)\\n return channel1\\n return\",\n \"def basicProcessing(volume, sigma, order, output, mode, truncate):\\n\\n\\n #### Filters ###\\n\\n result = gaussian_filter(input=volume, sigma=sigma, order=order, output=output, mode=mode, truncate=truncate)\\n\\n val = threshold_otsu(result)\\n print(\\\"val : {}\\\".format(val))\\n\\n mask = np.zeros(volume.shape, dtype=np.int8)\\n mask[volume > val] = 1\\n #mask = mask.astype(int)\\n\\n print(\\\"mask shape: {}\\\".format(mask.shape))\\n print(mask)\\n\\n\\n #### Morphological Operation ###\\n\\n # Opening removes small objects\\n r1 = binary_opening(mask, structure=np.ones((3, 3, 3))).astype(np.int8)\\n\\n # Closing removes small holes\\n r2 = binary_closing(r1, structure=np.ones((3, 3, 3))).astype(np.int8)\\n\\n\\n # 3x3x3 structuring element with connectivity 4 or 8\\n struct1 = generate_binary_structure(3, 1) # no diagonal elements\\n #struct1 = generate_binary_structure(3, 2) # with diagonal elements\\n ############struct1 = struct1.astype(int)\\n print (struct1)\\n\\n\\n #r3 = binary_dilation(r2).astype(int)\\n r3 = binary_dilation(r2, structure=struct1).astype(int) # using a structure element\\n\\n # Erosion removes objects smaller than the structure\\n r4 = binary_erosion(r3, structure=np.ones((3, 3, 3))).astype(np.int8)\\n\\n\\n #### Measurements ###\\n\\n struct2 = np.ones((3, 3, 3), dtype=np.int8)\\n labeled_array, num_features = label(r4, structure=struct2)\\n\\n #print(labeled_array)\\n print(num_features)\\n\\n return labeled_array, num_features\",\n \"def image_detect_and_compute(detector, img_name):\\n img_building = cv2.imread(img_name)\\n img_building = cv2.cvtColor(img_building, cv2.COLOR_BGR2RGB)\\n sift = cv2.xfeatures2d.SIFT_create()\\n kp, des = sift.detectAndCompute(img_building, None)\\n img_kp = cv2.drawKeypoints(img_building, kp, img_building)\\n return img_building, kp, des\",\n \"def preprocess_fn(img_id, image, box, is_training):\\n cv2.setNumThreads(2)\\n\\n def _infer_data(image, input_shape):\\n img_h, img_w, _ = image.shape\\n input_h, input_w = input_shape\\n\\n image = cv2.resize(image, (input_w, input_h))\\n\\n # When the channels of image is 1\\n if len(image.shape) == 2:\\n image = np.expand_dims(image, axis=-1)\\n image = np.concatenate([image, image, image], axis=-1)\\n\\n return img_id, image, np.array((img_h, img_w), np.float32)\\n\\n def _data_aug(image, box, is_training, image_size=(600, 600)):\\n \\\"\\\"\\\"Data augmentation function.\\\"\\\"\\\"\\n ih, iw, _ = image.shape\\n w, h = image_size\\n\\n if not is_training:\\n return _infer_data(image, image_size)\\n\\n # Random crop\\n box = box.astype(np.float32)\\n image, box = random_sample_crop(image, box)\\n ih, iw, _ = image.shape\\n\\n # Resize image\\n image = cv2.resize(image, (w, h))\\n\\n # Flip image or not\\n flip = _rand() < .5\\n if flip:\\n image = cv2.flip(image, 1, dst=None)\\n\\n # When the channels of image is 1\\n if len(image.shape) == 2:\\n image = np.expand_dims(image, axis=-1)\\n image = np.concatenate([image, image, image], axis=-1)\\n\\n box[:, [0, 2]] = box[:, [0, 2]] / ih\\n box[:, [1, 3]] = box[:, [1, 3]] / iw\\n\\n if flip:\\n box[:, [1, 3]] = 1 - box[:, [3, 1]]\\n\\n box, label, num_match = retinanet_bboxes_encode(box)\\n return image, box, label, num_match\\n\\n return _data_aug(image, box, is_training, image_size=config.img_shape)\",\n \"def calculate_mAP(det_boxes, det_labels, det_scores, true_boxes, true_labels, true_difficulties, on_dev, data_folder):\\n with open(os.path.join(data_folder,'label_map.json'), 'r') as j:\\n label_map = json.load(j)\\n \\n rev_label_map = {v: k for k, v in label_map.items()} \\n if on_dev:\\n device = det_boxes[0].device # torch.device('cuda:1')\\n \\n # these are all lists of tensors of the same length, i.e. number of images\\n assert len(det_boxes) == len(det_labels) == len(det_scores) == len(true_boxes) == len(true_labels) == len(true_difficulties) \\n n_classes = len(label_map)\\n \\n # Store all (true) objects in a single continuous tensor while keeping track of the image it is from\\n true_images = list()\\n for i in range(len(true_labels)):\\n true_images.extend([i] * true_labels[i].size(0))\\n # ==============================================================================================================================\\n if on_dev:\\n true_images = torch.LongTensor(true_images).to(device)#-(n_objects), n_objects is the total no. of objects across all images\\n else:\\n true_images = torch.LongTensor(true_images).cuda()#-----(n_objects), n_objects is the total no. of objects across all images\\n \\n true_boxes = torch.cat(true_boxes, dim=0)#------------------(n_objects, 4)\\n true_labels = torch.cat(true_labels, dim=0)#----------------(n_objects)\\n true_difficulties = torch.cat(true_difficulties, dim=0)#----(n_objects)\\n # ==============================================================================================================================\\n assert true_images.size(0) == true_boxes.size(0) == true_labels.size(0)\\n\\n # Store all detections in a single continuous tensor while keeping track of the image it is from\\n det_images = list()\\n for i in range(len(det_labels)):\\n det_images.extend([i] * det_labels[i].size(0))\\n \\n if on_dev:\\n det_images = torch.LongTensor(det_images).to(device) # (n_detections)\\n else:\\n det_images = torch.LongTensor(det_images).cuda() # (n_detections)\\n \\n det_boxes = torch.cat(det_boxes, dim=0) # (n_detections, 4)\\n det_labels = torch.cat(det_labels, dim=0) # (n_detections)\\n det_scores = torch.cat(det_scores, dim=0) # (n_detections)\\n\\n assert det_images.size(0) == det_boxes.size(0) == det_labels.size(0) == det_scores.size(0)\\n\\n # Calculate APs for each class (except background)\\n average_precisions = torch.zeros((n_classes - 1), dtype=torch.float) # (n_classes - 1)\\n for c in range(1, n_classes):\\n # Extract only objects with this class\\n true_class_images = true_images[true_labels == c] # (n_class_objects)\\n true_class_boxes = true_boxes[true_labels == c] # (n_class_objects, 4)\\n true_class_difficulties = true_difficulties[true_labels == c] # (n_class_objects)\\n n_easy_class_objects = (1 - true_class_difficulties).sum().item() # ignore difficult objects\\n\\n # Keep track of which true objects with this class have already been 'detected'\\n # So far, none\\n if on_dev:\\n true_class_boxes_detected = torch.zeros((true_class_difficulties.size(0)), dtype=torch.uint8).to(device)#(n_class_objects)\\n else:\\n true_class_boxes_detected = torch.zeros((true_class_difficulties.size(0)), dtype=torch.uint8).cuda() # (n_class_objects)\\n\\n # Extract only detections with this class\\n det_class_images = det_images[det_labels == c] # (n_class_detections)\\n det_class_boxes = det_boxes[det_labels == c] # (n_class_detections, 4)\\n det_class_scores = det_scores[det_labels == c] # (n_class_detections)\\n n_class_detections = det_class_boxes.size(0)\\n if n_class_detections == 0:\\n continue\\n\\n # Sort detections in decreasing order of confidence/scores\\n det_class_scores, sort_ind = torch.sort(det_class_scores, dim=0, descending=True) # (n_class_detections)\\n det_class_images = det_class_images[sort_ind] # (n_class_detections)\\n det_class_boxes = det_class_boxes[sort_ind] # (n_class_detections, 4)\\n\\n # In the order of decreasing scores, check if true or false positive\\n if on_dev:\\n true_positives = torch.zeros((n_class_detections), dtype=torch.float).to(device) # (n_class_detections)\\n false_positives = torch.zeros((n_class_detections), dtype=torch.float).to(device) # (n_class_detections)\\n else:\\n true_positives = torch.zeros((n_class_detections), dtype=torch.float).cuda() # (n_class_detections)\\n false_positives = torch.zeros((n_class_detections), dtype=torch.float).cuda() # (n_class_detections)\\n \\n for d in range(n_class_detections):\\n this_detection_box = det_class_boxes[d].unsqueeze(0) # (1, 4)\\n this_image = det_class_images[d] # (), scalar\\n\\n # Find objects in the same image with this class, their difficulties, and whether they have been detected before\\n object_boxes = true_class_boxes[true_class_images == this_image] # (n_class_objects_in_img)\\n object_difficulties = true_class_difficulties[true_class_images == this_image] # (n_class_objects_in_img)\\n # If no such object in this image, then the detection is a false positive\\n if object_boxes.size(0) == 0:\\n false_positives[d] = 1\\n continue\\n\\n # Find maximum overlap of this detection with objects in this image of this class\\n overlaps = find_jaccard_overlap(this_detection_box, object_boxes) # (1, n_class_objects_in_img)\\n max_overlap, ind = torch.max(overlaps.squeeze(0), dim=0) # (), () - scalars\\n\\n # 'ind' is the index of the object in these image-level tensors 'object_boxes', 'object_difficulties'\\n # In the original class-level tensors 'true_class_boxes', etc., 'ind' corresponds to object with index...\\n original_ind = torch.LongTensor(range(true_class_boxes.size(0)))[true_class_images == this_image][ind]\\n # We need 'original_ind' to update 'true_class_boxes_detected'\\n\\n # If the maximum overlap is greater than the threshold of 0.5, it's a match\\n if max_overlap.item() > 0.5:\\n # If the object it matched with is 'difficult', ignore it\\n if object_difficulties[ind] == 0:\\n # If this object has already not been detected, it's a true positive\\n if true_class_boxes_detected[original_ind] == 0:\\n true_positives[d] = 1\\n true_class_boxes_detected[original_ind] = 1 # this object has now been detected/accounted for\\n # Otherwise, it's a false positive (since this object is already accounted for)\\n else:\\n false_positives[d] = 1\\n # Otherwise, the detection occurs in a different location than the actual object, and is a false positive\\n else:\\n false_positives[d] = 1\\n\\n # Compute cumulative precision and recall at each detection in the order of decreasing scores\\n cumul_true_positives = torch.cumsum(true_positives, dim=0) # (n_class_detections)\\n cumul_false_positives = torch.cumsum(false_positives, dim=0) # (n_class_detections)\\n cumul_precision = cumul_true_positives / (\\n cumul_true_positives + cumul_false_positives + 1e-10) # (n_class_detections)\\n cumul_recall = cumul_true_positives / n_easy_class_objects # (n_class_detections)\\n\\n # Find the mean of the maximum of the precisions corresponding to recalls above the threshold 't'\\n recall_thresholds = torch.arange(start=0, end=1.1, step=.1).tolist() # (11)\\n if on_dev:\\n precisions = torch.zeros((len(recall_thresholds)), dtype=torch.float).to(device) # (11)\\n else:\\n precisions = torch.zeros((len(recall_thresholds)), dtype=torch.float).cuda()\\n for i, t in enumerate(recall_thresholds):\\n recalls_above_t = cumul_recall >= t\\n if recalls_above_t.any():\\n precisions[i] = cumul_precision[recalls_above_t].max()\\n else:\\n precisions[i] = 0.\\n average_precisions[c - 1] = precisions.mean() # c is in [1, n_classes - 1]\\n\\n # Calculate Mean Average Precision (mAP)\\n mean_average_precision = average_precisions.mean().item()\\n\\n # Keep class-wise average precisions in a dictionary\\n average_precisions = {rev_label_map[c + 1]: v for c, v in enumerate(average_precisions.tolist())}\\n\\n return average_precisions, mean_average_precision\",\n \"def _getFeatures(self, image):\\n\\n self.model.eval()\\n lin_block = 0\\n blockwise_features = [image]\\n feature = image\\n\\n for m in self.model.modules():\\n # Assume modules are arranged in \\\"chronological\\\" fashion\\n\\n if isinstance(m, nn.ReLU):\\n # Get pre-ReLU activations for conv layers\\n if len(feature.size()) == 4:\\n blockwise_features.append(feature)\\n\\n if linearity_test(m) is not None:\\n if isinstance(m, nn.Linear):\\n feature = feature.view(feature.size(0),-1)\\n feature = m(feature)\\n\\n return feature, blockwise_features\",\n \"def _forward_mask_point(self, features, mask_coarse_logits, instances):\\n if not self.mask_point_on:\\n return {} if self.training else mask_coarse_logits\\n\\n mask_features_list = [features[k] for k in self.mask_point_in_features]\\n features_scales = [self._feature_scales[k] for k in self.mask_point_in_features]\\n\\n if self.training:\\n proposal_boxes = [x.proposal_boxes for x in instances]\\n gt_classes = cat([x.gt_classes for x in instances])\\n with torch.no_grad():\\n point_coords = get_uncertain_point_coords_with_randomness(\\n mask_coarse_logits,\\n lambda logits: calculate_uncertainty_ins_seg(logits, gt_classes),\\n self.mask_point_train_num_points,\\n self.mask_point_oversample_ratio,\\n self.mask_point_importance_sample_ratio,\\n )\\n\\n fine_grained_features, point_coords_wrt_image = point_sample_fine_grained_features(\\n mask_features_list, features_scales, proposal_boxes, point_coords\\n )\\n coarse_features = point_sample(mask_coarse_logits, point_coords, align_corners=False)\\n point_logits = self.mask_point_head(fine_grained_features, coarse_features)\\n return {\\n \\\"loss_mask_point\\\": roi_mask_point_loss(\\n point_logits, instances, point_coords_wrt_image\\n )\\n }\\n else:\\n pred_boxes = [x.pred_boxes for x in instances]\\n pred_classes = cat([x.pred_classes for x in instances])\\n # The subdivision code will fail with the empty list of boxes\\n if len(pred_classes) == 0:\\n return mask_coarse_logits\\n\\n mask_logits = mask_coarse_logits.clone()\\n for subdivions_step in range(self.mask_point_subdivision_steps):\\n mask_logits = interpolate(\\n mask_logits, scale_factor=2, mode=\\\"bilinear\\\", align_corners=False\\n )\\n # If `mask_point_subdivision_num_points` is larger or equal to the\\n # resolution of the next step, then we can skip this step\\n H, W = mask_logits.shape[-2:]\\n if (\\n self.mask_point_subdivision_num_points >= 4 * H * W\\n and subdivions_step < self.mask_point_subdivision_steps - 1\\n ):\\n continue\\n uncertainty_map = calculate_uncertainty_ins_seg(mask_logits, pred_classes)\\n point_indices, point_coords = get_uncertain_point_coords_on_grid(\\n uncertainty_map, self.mask_point_subdivision_num_points\\n )\\n fine_grained_features, _ = point_sample_fine_grained_features(\\n mask_features_list, features_scales, pred_boxes, point_coords\\n )\\n coarse_features = point_sample(\\n mask_coarse_logits, point_coords, align_corners=False\\n )\\n point_logits = self.mask_point_head(fine_grained_features, coarse_features)\\n\\n # put mask point predictions to the right places on the upsampled grid.\\n R, C, H, W = mask_logits.shape\\n point_indices = point_indices.unsqueeze(1).expand(-1, C, -1)\\n mask_logits = (\\n mask_logits.reshape(R, C, H * W)\\n .scatter_(2, point_indices, point_logits)\\n .view(R, C, H, W)\\n )\\n return mask_logits\",\n \"def _extract_features(self, ti, tf):\\n makedir(self.featdir)\\n\\n # number of windows in feature request\\n Nw = int(np.floor(((tf-ti)/self.dt)/(self.iw-self.io)))\\n\\n # features to compute\\n cfp = ComprehensiveFCParameters()\\n if self.compute_only_features:\\n cfp = dict([(k, cfp[k]) for k in cfp.keys() if k in self.compute_only_features])\\n else:\\n # drop features if relevant\\n _ = [cfp.pop(df) for df in self.drop_features if df in list(cfp.keys())]\\n\\n # check if feature matrix already exists and what it contains\\n if os.path.isfile(self.featfile):\\n t = pd.to_datetime(pd.read_csv(self.featfile, index_col=0, parse_dates=['time'], usecols=['time'], infer_datetime_format=True).index.values)\\n ti0,tf0 = t[0],t[-1]\\n Nw0 = len(t)\\n hds = pd.read_csv(self.featfile, index_col=0, nrows=1)\\n hds = list(set([hd.split('__')[1] for hd in hds]))\\n\\n # option 1, expand rows\\n pad_left = int((ti0-ti)/self.dto)# if ti < ti0 else 0\\n pad_right = int(((ti+(Nw-1)*self.dto)-tf0)/self.dto)# if tf > tf0 else 0\\n i0 = abs(pad_left) if pad_left<0 else 0\\n i1 = Nw0 + max([pad_left,0]) + pad_right\\n \\n # option 2, expand columns\\n existing_cols = set(hds) # these features already calculated, in file\\n new_cols = set(cfp.keys()) - existing_cols # these features to be added\\n more_cols = bool(new_cols)\\n all_cols = existing_cols|new_cols\\n cfp = ComprehensiveFCParameters()\\n cfp = dict([(k, cfp[k]) for k in cfp.keys() if k in all_cols])\\n\\n # option 3, expand both\\n if any([more_cols, pad_left > 0, pad_right > 0]) and self.update_feature_matrix:\\n fm = pd.read_csv(self.featfile, index_col=0, parse_dates=['time'], infer_datetime_format=True)\\n if more_cols:\\n # expand columns now\\n df0, wd = self._construct_windows(Nw0, ti0)\\n cfp0 = ComprehensiveFCParameters()\\n cfp0 = dict([(k, cfp0[k]) for k in cfp0.keys() if k in new_cols])\\n fm2 = extract_features(df0, column_id='id', n_jobs=self.n_jobs, default_fc_parameters=cfp0, impute_function=impute)\\n fm2.index = pd.Series(wd)\\n \\n fm = pd.concat([fm,fm2], axis=1, sort=False)\\n\\n # check if updates required because training period expanded\\n # expanded earlier\\n if pad_left > 0:\\n df, wd = self._construct_windows(Nw, ti, i1=pad_left)\\n fm2 = extract_features(df, column_id='id', n_jobs=self.n_jobs, default_fc_parameters=cfp, impute_function=impute)\\n fm2.index = pd.Series(wd)\\n fm = pd.concat([fm2,fm], sort=False)\\n # expanded later\\n if pad_right > 0:\\n df, wd = self._construct_windows(Nw, ti, i0=Nw - pad_right)\\n fm2 = extract_features(df, column_id='id', n_jobs=self.n_jobs, default_fc_parameters=cfp, impute_function=impute)\\n fm2.index = pd.Series(wd)\\n fm = pd.concat([fm,fm2], sort=False)\\n \\n # write updated file output\\n fm.to_csv(self.featfile, index=True, index_label='time')\\n # trim output\\n fm = fm.iloc[i0:i1] \\n else:\\n # read relevant part of matrix\\n fm = pd.read_csv(self.featfile, index_col=0, parse_dates=['time'], infer_datetime_format=True, header=0, skiprows=range(1,i0+1), nrows=i1-i0)\\n else:\\n # create feature matrix from scratch \\n df, wd = self._construct_windows(Nw, ti)\\n fm = extract_features(df, column_id='id', n_jobs=self.n_jobs, default_fc_parameters=cfp, impute_function=impute)\\n fm.index = pd.Series(wd)\\n fm.to_csv(self.featfile, index=True, index_label='time')\\n \\n ys = pd.DataFrame(self._get_label(fm.index.values), columns=['label'], index=fm.index)\\n return fm, ys\",\n \"def deep_features(img_paths, model, func_preprocess_input, target_size=(224, 224, 3),\\n crop_amount=None, flip_axis=None, func_postprocess_features=spatial_average_pooling):\\n\\n features = []\\n for img_path in img_paths:\\n if crop_amount is None:\\n img = image.load_img(img_path, target_size=target_size)\\n x = image.img_to_array(img)\\n else:\\n x = crop_resize_img(img_path, target_size, crop_amount)\\n\\n if flip_axis is not None:\\n x = image.flip_axis(x, flip_axis)\\n\\n x = np.expand_dims(x, axis=0)\\n x = func_preprocess_input(x)\\n responses = model.predict(x)\\n\\n if func_postprocess_features is not None:\\n responses = func_postprocess_features(responses)\\n\\n features.append(responses)\\n\\n features = np.squeeze(np.asarray(features))\\n\\n return features\",\n \"def pre_analyse():\\n t = transform()\\n model = modified_resnet50()\\n model.load_state_dict(\\n torch.load(\\n \\\"model.pth.tar\\\",\\n map_location=torch.device(\\\"cpu\\\"),\\n )[\\\"state_dict\\\"]\\n )\\n model.eval()\\n\\n def get_preds(img_path):\\n \\\"\\\"\\\"\\n Gives labelds and probabilities for a single image\\n This is were we preprocess the image, using a function defined in the model class\\n \\\"\\\"\\\"\\n # load image\\n img = Image.open(img_path).convert(\\\"RGB\\\")\\n # process it\\n x = t(img)\\n # get in in the right format\\n x = Variable(x).unsqueeze(0)\\n # predictions\\n output = model(x)\\n # decode\\n output = decode(output.cpu().data.numpy()[0])\\n\\n # filter\\n # return pred, proba\\n return output\\n\\n return get_preds(\\\"image.jpg\\\")\",\n \"def __init__(self, img):\\n self.origi = imutils.resize(img, width=100)\\n self.img = self.origi.copy()\\n self.th = np.zeros_like(self.img)\\n self.th[:, :, 0] = cv2.adaptiveThreshold(cv2.cvtColor(self.img, cv2.COLOR_BGR2GRAY), 255,\\n cv2.ADAPTIVE_THRESH_MEAN_C, cv2.THRESH_BINARY, 11, 2)\\n kernel = np.ones((2, 2), np.uint8)\\n self.th[:, :, 0] = cv2.morphologyEx(self.th[:, :, 0], cv2.MORPH_CLOSE, kernel)\\n self.th[:, :, 1] = self.th[:, :, 2] = self.th[:, :, 0]\\n self.kp = None\\n self.kpimg = np.zeros_like(img)\\n self.segmented = np.zeros_like(img)\\n self.fast = cv2.FastFeatureDetector_create()\",\n \"def forward(self, images):\\n with torch.no_grad():\\n features = self.resnet(images)\\n features = features.reshape(features.size(0), -1)\\n features = self.bn(self.linear(features))\\n return features\",\n \"def early_gradient_fusion():\\n pass\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6926122","0.67149717","0.66896415","0.6684665","0.66838753","0.65661734","0.6509679","0.6479813","0.6467656","0.64198256","0.6404838","0.6361878","0.63541794","0.6353836","0.63225704","0.62639576","0.6259601","0.62525296","0.6243414","0.62212324","0.61623716","0.6151733","0.6144423","0.6125647","0.6115585","0.6112267","0.60770047","0.60763156","0.6076065","0.606598","0.6027552","0.6018188","0.6018188","0.60143405","0.60139996","0.6004766","0.599916","0.59955037","0.59939826","0.59871674","0.5982719","0.5977519","0.59626997","0.59505653","0.5943026","0.5931951","0.59279954","0.592485","0.59161234","0.58971083","0.588516","0.5884441","0.588433","0.58796215","0.5848557","0.5846963","0.5845676","0.5844845","0.58432275","0.58400375","0.5835022","0.5833147","0.5832138","0.58215773","0.58196414","0.581625","0.58050627","0.5802203","0.5800841","0.57992744","0.5798995","0.57961035","0.57864267","0.5779666","0.5779608","0.57786894","0.5775395","0.5775104","0.5774094","0.57719034","0.57704496","0.5757156","0.57509255","0.5750081","0.5746576","0.5737643","0.57350427","0.5733918","0.5730302","0.5728243","0.5719249","0.5719168","0.5716155","0.5710487","0.5706649","0.57041115","0.56968766","0.56765085","0.56746083","0.5668554"],"string":"[\n \"0.6926122\",\n \"0.67149717\",\n \"0.66896415\",\n \"0.6684665\",\n \"0.66838753\",\n \"0.65661734\",\n \"0.6509679\",\n \"0.6479813\",\n \"0.6467656\",\n \"0.64198256\",\n \"0.6404838\",\n \"0.6361878\",\n \"0.63541794\",\n \"0.6353836\",\n \"0.63225704\",\n \"0.62639576\",\n \"0.6259601\",\n \"0.62525296\",\n \"0.6243414\",\n \"0.62212324\",\n \"0.61623716\",\n \"0.6151733\",\n \"0.6144423\",\n \"0.6125647\",\n \"0.6115585\",\n \"0.6112267\",\n \"0.60770047\",\n \"0.60763156\",\n \"0.6076065\",\n \"0.606598\",\n \"0.6027552\",\n \"0.6018188\",\n \"0.6018188\",\n \"0.60143405\",\n \"0.60139996\",\n \"0.6004766\",\n \"0.599916\",\n \"0.59955037\",\n \"0.59939826\",\n \"0.59871674\",\n \"0.5982719\",\n \"0.5977519\",\n \"0.59626997\",\n \"0.59505653\",\n \"0.5943026\",\n \"0.5931951\",\n \"0.59279954\",\n \"0.592485\",\n \"0.59161234\",\n \"0.58971083\",\n \"0.588516\",\n \"0.5884441\",\n \"0.588433\",\n \"0.58796215\",\n \"0.5848557\",\n \"0.5846963\",\n \"0.5845676\",\n \"0.5844845\",\n \"0.58432275\",\n \"0.58400375\",\n \"0.5835022\",\n \"0.5833147\",\n \"0.5832138\",\n \"0.58215773\",\n \"0.58196414\",\n \"0.581625\",\n \"0.58050627\",\n \"0.5802203\",\n \"0.5800841\",\n \"0.57992744\",\n \"0.5798995\",\n \"0.57961035\",\n \"0.57864267\",\n \"0.5779666\",\n \"0.5779608\",\n \"0.57786894\",\n \"0.5775395\",\n \"0.5775104\",\n \"0.5774094\",\n \"0.57719034\",\n \"0.57704496\",\n \"0.5757156\",\n \"0.57509255\",\n \"0.5750081\",\n \"0.5746576\",\n \"0.5737643\",\n \"0.57350427\",\n \"0.5733918\",\n \"0.5730302\",\n \"0.5728243\",\n \"0.5719249\",\n \"0.5719168\",\n \"0.5716155\",\n \"0.5710487\",\n \"0.5706649\",\n \"0.57041115\",\n \"0.56968766\",\n \"0.56765085\",\n \"0.56746083\",\n \"0.5668554\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.62619364"},"document_rank":{"kind":"string","value":"16"}}},{"rowIdx":21398,"cells":{"query":{"kind":"string","value":"Cross entropy loss for individual supervision, Equation (12)"},"document":{"kind":"string","value":"def Ls(GTn:torch.tensor, Mn:torch.tensor) -> torch.tensor:\n return (-(GTn * torch.log(Mn+1e-15) + (1- GTn) * torch.log((1- Mn)+1e-15))).sum()"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def cross_entropy_loss():\n return nn.CrossEntropyLoss()","def cross_entropy(y_observed, p):\n\n pass","def cross_entropy_error(self, x, y):\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])","def cross_entropy(self):\n return self._cross_entropy_func","def cross_entropy(y_pred,y):\n \n epsilon = 0.001 # To prevent overflow and ensure numerical stability\n return sum(-y*np.log(y_pred+epsilon))","def _initLoss(self):\n\n return torch.nn.CrossEntropyLoss()","def entropy(y):\n EPS = 0.0005\n\n # YOUR CODE HERE\n if len(y) == 0:\n return 0.\n \n pk = np.mean(y, axis=0)\n \n return - np.sum(pk * np.log(pk + EPS))","def CE():\n def CE_loss(input,target):\n return nn.CrossEntropyLoss()(input.squeeze(), target)\n\n return CE_loss","def compute_loss(self):\n def calc_loss(inputs, outputs):\n reconstruction_loss = tf.metrics.binary_crossentropy(\n tf_flat(inputs), tf_flat(outputs))\n reconstruction_loss *= OUT_SIZE * OUT_SIZE\n kl_loss = -0.5 * tf.reduce_sum(1.0 + self.log_sigma - tf.square(\n self.mu) - tf.exp(self.log_sigma), 1)\n return tf.reduce_mean(reconstruction_loss + kl_loss)\n return calc_loss","def compute_loss(self):\n self.prototypes = self.compute_prototypes()\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.episode.test_labels, logits=self.test_logits)\n cross_entropy_loss = tf.reduce_mean(loss)\n regularization = tf.reduce_sum(\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n loss = cross_entropy_loss + self.weight_decay * regularization\n return loss","def classification_loss(self, logit, target):\n return F.cross_entropy(logit, target)","def _loss(self):\n\n cross_entropy = tf.reduce_mean(-tf.log(self.probability + epsilon) * self.y)\n self.loss = cross_entropy\n\n self.accuracy = tf.reduce_mean(\n tf.cast(tf.equal(tf.argmax(self.y, 1), self.prediction), tf.float32))","def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])","def crossentropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\n return -torch.log2(probability_fn(args))","def cross_entropy(U, V):\n return -np.sum(U * np.log(V))","def cross_entropy(y_pred, y_true, normalize=True, eps=1e-15):\n if type(y_pred) != np.ndarray:\n raise TypeError(\"Require np.ndarray type,{} checked\".format(type(y_pred)))\n if type(y_true) != np.ndarray:\n raise TypeError(\"Require np.ndarray type,{} checked\".format(type(y_true)))\n # clip = np.vectorize(lambda x: max(eps, min(1 - eps, x)))\n # y_pred = clip(y_pred)\n y_pred = np.array(list(map(lambda x: max(eps, min(1 - eps, x)), y_pred)))\n l = np.multiply(y_true, np.log(y_pred)) + np.multiply(1 - y_true, np.log(1 - y_pred))\n loss = -1 * np.sum(l).item()\n if normalize:\n loss = loss / len(y_pred)\n return loss","def cross_entropy(t,y):\r\n #print(-1*t*np.log(y))\r\n #print(np.shape(np.log(y)))\r\n #print(np.shape(t))\r\n return t*np.log(y)*(-1)","def conditional_entropy(self) -> float:\n pass","def loss(params: hk.Params, batch, label) -> jnp.ndarray:\r\n logits = net.apply(params, batch)\r\n labels = jax.nn.one_hot(label, n_classes)\r\n\r\n # Cross Entropy Loss\r\n softmax_xent = -jnp.sum(labels * jax.nn.log_softmax(logits))\r\n softmax_xent /= labels.shape[0]\r\n return softmax_xent","def loss_fn(y_true,y_pred): \n loss = tf.nn.softmax_cross_entropy_with_logits_v2(y_true,\n y_pred,\n axis=-1,\n )\n loss = tf.reduce_mean(loss,name=\"loss\")\n return loss","def compute_loss(self):\n self.test_logits = self.compute_logits()\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\n labels=self.data.test_labels, logits=self.test_logits)\n cross_entropy_loss = tf.reduce_mean(loss)\n regularization = tf.reduce_sum(\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n loss = cross_entropy_loss + self.weight_decay * regularization\n return loss","def setup_loss(self):\n self.loss = nn.CrossEntropyLoss(weight = self.to_device(self.datasetManager.class_weights))\n #self.loss = nn.CrossEntropyLoss()","def cross_entropy(self, sents):\n return (-1) * self.log_prob(sents) / len(self._count)","def genLoss(self, *data):\r\n _, (x_unlab, _) = data\r\n z = self.getInputNoise(self.hypers['ul_BS'])\r\n fake_logits = self.D(self.G(z))\r\n g_losses = -1*logOneMinusSoftmax(fake_logits)[:,self.D.numClasses-1]\r\n return torch.mean(g_losses)","def compute_loss(self):","def test_cross_entropy(self):\n loss = losses.cross_entropy_with_logits(\n logits=self.logits, targets=self.targets)\n kl = loss.mean()\n\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\n\n self.assertAlmostEqual(kl, expected_loss)","def calc_entropy_tuning_loss(self, log_probs):\n with torch.no_grad():\n inner_prod = (log_probs + self.target_entropy).detach()\n alpha_loss = -(self.log_alpha * inner_prod).mean()\n return alpha_loss","def cross_entropy(y_prob,y):\n from numpy import log, sum\n m = y.shape[0]\n p = y_prob\n log_likelihood = -log(p[range(m),y])\n loss = sum(log_likelihood) / m\n return loss","def test_aux_softmax_cross_entropy(self):\n loss_op = listwise_losses.AuxiliarySoftmaxCrossEntropy()\n\n y_pred = loss_op.final_activation_op({\n \"logits\": self.logits,\n \"metadata\": {\n \"mask\": self.mask\n }\n })\n\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\n\n loss = loss_op({\"mask\": self.mask}, self.y_true_aux, y_pred)\n assert np.isclose(loss, 0.88127804, atol=1e-5)","def cross_entropy(X, y):\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\n 1 - y\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)","def loss_sce(y_pred, y_true):\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y_true, logits=y_pred)\n\n return tf.reduce_mean(loss)","def set_loss_function(self):\r\n self.criterion = nn.CrossEntropyLoss().cuda()","def crossEntropyLoss(YPredict, YTrueOneHot):\n if YPredict.shape != YTrueOneHot.shape:\n YTrueOneHot = YTrueOneHot.reshape(YPredict.shape)\n return -np.sum(np.multiply(np.log(YPredict), YTrueOneHot))","def loss_softmax_cross_entropy(self, unet, predict, ground_truth):\n\n loss = -F.mean(F.log(predict+1e-16) * ground_truth)\n\n chainer.report({\"loss\":loss}, unet)#mistery\n return loss","def cross_entropy_loss(self, y, y_hat):\n if y.ndim == 1:\n batch_size = 1\n else:\n batch_size = y.shape[0]\n delta = 1e-7\n return -np.sum(y * np.log(y_hat + delta)) / batch_size","def cross_entropy_loss(self, logits, labels):\n return F.cross_entropy(logits, labels)","def conditional_entropy_hyper(self) -> float:\n pass","def cross_entropy_loss(outputs, labels): \n# works properly\n \n m = labels.shape[0]\n p = outputs\n log_likelihood = -1*torch.log(p[range(m),labels])\n loss = torch.sum(log_likelihood) / m\n return loss.item()","def loss(self, X, y):\n\n # Initialize the loss to zero.\n loss = 0.0\n num_classes = self.W.shape[0] # C = num_classes\n num_train = X.shape[0]\n \n exp_a = np.zeros((num_classes,num_train))\n # ================================================================ #\n # YOUR CODE HERE:\n # Calculate the normalized softmax loss. Store it as the variable loss.\n # (That is, calculate the sum of the losses of all the training \n # set margins, and then normalize the loss by the number of \n # training examples.)\n # ================================================================ #\n \n \n for i in np.arange(num_train):\n \n Loss = 0.0\n\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\n\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\n\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\n \n\n #p[:,i] = exp_a[:,i]/np.sum(exp_a[:,i]) # p now is a valid probability matrix\n #print(p[:,i])\n\n loss += Loss \n #print(Loss,i) \n \n pass\n loss /= num_train\n # ================================================================ #\n # END YOUR CODE HERE\n # ================================================================ #\n\n return loss","def get_cross_entropy(self):\n assert (self.dataset is not None) and (self.labels is not None), 'Logistic Regression requires a dataset and labels.'\n potential = 0.0\n logits = self.dataset @ self.parameters[:self.dataset.shape[1]]\n max_logits = torch.max(torch.zeros(logits.shape[0]),logits)\n potential = (-logits @ self.labels.t() + torch.sum(max_logits) + torch.sum(\n torch.log(torch.exp(-max_logits)+torch.exp(logits - max_logits))))# * n.reciprocal())\n return potential","def calculate_entropy(eval_token_count, training_model):\n sum_of_counts = sum(eval_token_count.values())\n cross_entropy = 0\n mis = []\n for ngram in eval_token_count:\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\n else:\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\n pi = eval_token_count[ngram] / sum_of_counts\n mis.append(mi)\n cross_entropy -= pi * mi\n return cross_entropy","def Weighted_Cross_Entropy(y_true, y_pred, eps = 1e-10):\n y_pred = tf.cast(y_pred, 'float64')\n y_true = tf.cast(y_true, 'float64')\n # deduce weights based on true pixel value\n class_weights = weights * y_true\n # compute your (unweighted) softmax cross entropy loss\n unweighted_losses = y_true*tf.math.log(y_pred + eps)\n ##print(unweighted_losses.dtype, weights.dtype)\n weighted_losses = unweighted_losses * class_weights\n # reduce the result to get your final loss\n loss = -tf.reduce_sum(weighted_losses)\n return loss","def loss_function(recon_x, x, mu, logvar, input_size):\n BCE = F.binary_cross_entropy(recon_x, x.view(-1, input_size), size_average=False)\n\n # see Appendix B from VAE paper:\n # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\n # https://arxiv.org/abs/1312.6114\n # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\n\n return BCE + KLD","def cross_entropy_loss(batch_out, batch_gt):\r\n criterion = torch.nn.CrossEntropyLoss()\r\n target = torch.argmax(batch_gt, 1)\r\n loss = criterion(batch_out, target)\r\n\r\n return loss","def entropy(self):\r\n return 1/2 * (self.dim * (_LOG_2PI + 1) + self._log_det_cov)","def entropy_loss(policy_logits):\n\n softmax = nn.Softmax(dim=-1)\n logsoftmax = nn.LogSoftmax(dim=-1)\n\n policy = softmax(policy_logits.action_type)\n log_policy = logsoftmax(policy_logits.action_type)\n\n return torch.mean(torch.sum(-policy * log_policy, axis=-1))","def entropy(self):\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))","def crossentropy_loss(y_true, y_pred):\n ce = tf.keras.losses.categorical_crossentropy(y_true, y_pred, from_logits=True) \n return ce","def gen_loss_orig(self, noise_samples):\n generator_samples = self.gen_model(noise_samples)\n logits_gen = self.disc_model(generator_samples)\n # loss = -tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.zeros(logits_gen.shape), logits=logits_gen))\n loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones(logits_gen.shape), logits=logits_gen))\n return loss","def cross_entropy(true, pred, axis=-1, epsilon=1e-7):\n pred = ivy.clip(pred, epsilon, 1 - epsilon)\n log_pred = ivy.log(pred)\n # noinspection PyUnresolvedReferences\n return -ivy.reduce_sum(log_pred * true, axis)","def _vae_loss(self, x, x_generated):\n x = K.flatten(x)\n x_generated = K.flatten(x_generated)\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\n binary_crossentropy(x, x_generated)\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\n kl_disc_loss = 0\n return reconstruction_loss + kl_normal_loss + kl_disc_loss","def _vae_loss(self, x, x_generated):\n x = K.flatten(x)\n x_generated = K.flatten(x_generated)\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\n binary_crossentropy(x, x_generated)\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\n kl_disc_loss = 0\n return reconstruction_loss + kl_normal_loss + kl_disc_loss","def _vae_loss(self, x, x_generated):\n x = K.flatten(x)\n x_generated = K.flatten(x_generated)\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\n binary_crossentropy(x, x_generated)\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\n kl_disc_loss = 0\n return reconstruction_loss + kl_normal_loss + kl_disc_loss","def _vae_loss(self, x, x_generated):\n x = K.flatten(x)\n x_generated = K.flatten(x_generated)\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\n binary_crossentropy(x, x_generated)\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\n kl_disc_loss = 0\n return reconstruction_loss + kl_normal_loss + kl_disc_loss","def loss_function(self, x, x_hat_logit, mu, log_sigma):\n rec_loss = nn.functional.binary_cross_entropy_with_logits(x_hat_logit, x, size_average=False)\n kl_loss = -0.5 * torch.sum(1 + log_sigma - mu.pow(2) - log_sigma.exp())\n\n return rec_loss + (kl_loss), rec_loss, kl_loss","def loss(self):\n return la.norm(self.resids) / self.normX","def cross_entropy_loss(predictions, targets, epsilon=1e-12):\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\n N = predictions.shape[0]\n ce = -np.sum(targets*np.log(predictions+1e-9))/N\n return ce","def compute_cross_entropy(probs, target):\n avg_probs_per_sample = probs.mean(\n -1)\n xe = torch.nn.CrossEntropyLoss(reduction='none')\n return xe(avg_probs_per_sample, target).detach().cpu().numpy()","def loss_function(recon_x, x, mu, logvar, cl, target, natural):\n\tglobal decoder_nat_loss, decoder_syn_loss, KLD_syn_loss, KLD_nat_loss, regressor_nat, regressor_syn\n\t#decoder_loss = F.binary_cross_entropy(recon_x, x.view(-1, 1, img_size, img_size), reduction='sum') * decoder_l_factor\n\tdecoder_loss = F.mse_loss(recon_x, x) * decoder_l_factor\n\n\t# see Appendix B from VAE paper: Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\n\t# https://arxiv.org/abs/1312.6114\n\t# 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\n\tbeta = 1 / (batch_size * boundary_dim) # disentanglement factor#extremely small\n\tKLD = -0.5 * beta * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) * KLD_l_factor\n\n\tregressor_loss = F.mse_loss(cl, target.view(-1, 1)) * regressor_l_factor\n\tif epoch < regressor_start:\n\t\tregressor_loss *= 0\n\n\tif natural:\n\t\tdecoder_nat_loss += decoder_loss\n\t\tKLD_nat_loss += KLD\n\t\tregressor_nat += regressor_loss\n\telse:\n\t\tdecoder_syn_loss += decoder_loss\n\t\tKLD_syn_loss += KLD\n\t\tregressor_syn += regressor_loss\n\n\tif KLD > 1e10:\n\t\tplaySound()\n\t\tsys.exit('KLD diverged')\n\n\treturn decoder_loss + KLD + regressor_loss, KLD, regressor_loss","def crossEntropy(p_m1):\n p_m2 = 1 - p_m1\n D = - p_m1*math.log(p_m1) - p_m2*math.log(p_m2)\n return D","def loss_fn(outputs, labels):\n return nn.CrossEntropyLoss()(outputs, labels)","def loss_fn(outputs, labels, wts):\n\n # reshape labels to give a flat vector of length batch_size*seq_len\n loss_noreduce = nn.BCEWithLogitsLoss(reduce=False)\n loss = torch.mean(loss_noreduce(outputs, labels)*wts)\n\t\n # compute cross entropy loss for all tokens\n return loss","def compute_entropy_loss(logits):\n policy = F.softmax(logits, dim=-1)\n log_policy = F.log_softmax(logits, dim=-1)\n return torch.sum(policy * log_policy)","def cEntropy(Y, X):\n return jEntropy(Y, X) - entropy(X)","def entropy(Y):\n\n temp = np.unique(Y, return_counts=True)\n uniq_Y = list(temp[0])\n Y_count = list(temp[1])\n \n total = sum(Y_count)\n\n ent = 0\n for elem in uniq_Y:\n prob = Y_count[uniq_Y.index(elem)] / total\n # print(\"prob:\", prob)\n ent -= (prob * (math.log2(prob)))\n # print(\"ent:\",ent)\n\n return ent","def compute_loss(self, x, gt):\n loss = sum([torch.mean((out - gt)**2) for out in self.forward(x)])\n return loss","def entropy(temp,pres):\n g_t = liq_g(1,0,temp,pres)\n s = -g_t\n return s","def my_loss(y_pred,y_true,n_outputs):\n y_true = tf.one_hot(tf.cast(y_true,tf.int64), n_outputs, dtype=tf.float32)\n return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_true,y_pred))","def compute_test_loss(self, x):\n temp_training = self.training\n self.training = False\n mean, logvar = self.encode(x)\n z = self.reparameterize(mean, logvar)\n x_logit = self.decode(z)\n\n cross_ent = tf.nn.sigmoid_cross_entropy_with_logits(logits=x_logit, labels=x)\n logpx_z = -tf.math.reduce_sum(cross_ent, axis=[1, 2, 3]) # JAH removed 3D axis=[1, 2, 3,4]\n logpz = self.log_normal_pdf(z, 0.0, 0.0)\n logqz_x = self.log_normal_pdf(z, mean, logvar)\n\n\n kl_divergence = logqz_x - logpz\n neg_log_likelihood = -logpx_z\n\n #elbo = tf.math.reduce_mean(-self.kl_weight * kl_divergence - neg_log_likelihood) # shape=()\n neg_elbo = tf.math.reduce_mean(self.kl_weight * kl_divergence + neg_log_likelihood) # shape=()\n self.training = temp_training\n return neg_elbo","def entropy(x):\n nz = np.nonzero(x)[0]\n return -np.sum(x[nz]*np.log2(x[nz]))","def cross_entropy(predictions, targets):\n likelihood = targets * np.log(predictions)\n return -np.sum(likelihood) / predictions.shape[0]","def compute_perplexity(self,loss: float):\n return math.exp(loss)","def _entropy(data):\n hist = np.array(PIL.Image.fromarray(data).histogram())\n hist = hist / hist.sum()\n hist = hist[hist != 0]\n return -np.sum(hist * np.log2(hist))","def entropy(y):\r\n\r\n # INSERT YOUR CODE HERE\r\n value, count = np.unique(y,return_counts = True)\r\n Hy = 0.0\r\n prob = count.astype(float)/len(y)\r\n for p in prob:\r\n Hy += -(p)*(np.log2(p))\r\n return Hy\r\n raise Exception('Function not yet implemented!')","def target_loss(self, inp_hist):\n active_targ = self.get_active_target(inp_hist)\n return torch.mean((inp_hist[:, 1:3] - active_targ) ** 2)","def approximate_loss(self, x, x_recon, v_dist, eps=1e-3):\n log_alpha = v_dist.logits\n bce = F.binary_cross_entropy(x_recon, x.view(-1, 784), reduction='sum')\n num_class = torch.tensor(self.latent_dim).float()\n probs = torch.softmax(log_alpha, dim=-1) # alpha_i / alpha_sum\n kl = torch.sum(probs * (num_class * (probs + eps)).log(), dim=-1).sum()\n return bce, kl","def loss(self, y_pred=None, y_true=None):\n n = y_pred.shape[0]\n ahat = transform(self.ahat)\n bhat = transform(self.bhat)\n return -1 * (-0.5 * n * self.const + 0.5 * n * (torch.digamma(ahat) - torch.log(bhat)) \\\n - 0.5 * (ahat/bhat) * ((y_pred - y_true) ** 2).sum())","def entropy(self, **kwargs) -> TensorType:","def entropy(self, **kwargs) -> TensorType:","def compute_loss(self, obs, returns):","def cross_entropy(x, y):\n\n if len(y.shape) == 1:\n return F.cross_entropy(x, y)\n if y.shape[1] == 1:\n y = y.squeeze(1)\n return F.cross_entropy(x, y)\n\n return torch.mean(\n torch.div(\n F.binary_cross_entropy_with_logits(x, y, reduction=\"none\"),\n torch.sum(y, dim=1),\n )\n )","def test_aux_one_hot_hot_cross_entropy(self):\n loss_op = listwise_losses.AuxiliaryOneHotCrossEntropy()\n\n y_pred = loss_op.final_activation_op({\n \"logits\": self.logits,\n \"metadata\": {\n \"mask\": self.mask\n }\n })\n\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\n\n loss = loss_op({\"mask\": self.mask}, self.y_true_aux, y_pred)\n assert np.isclose(loss, 0.5249801, atol=1e-5)","def __loss(self, h, y):\n return (-y*np.log(h)-(1-y)*np.log(1-h)).mean()","def crossEntropy(obs, actual, offset=1e-7):\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\n # bound by clipping to avoid nan\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\n return -tf.reduce_sum(actual * tf.log(obs_) +\n (1 - actual) * tf.log(1 - obs_), 1)","def compute_loss(self, x, y):\n\n self.batch_size = x.shape[0]\n self.x = x\n self.y = y\n self.soft = self.softmax(x) + 10**(-11)\n out = np.zeros(self.batch_size)\n for i in range(self.batch_size):\n out[i] = -(y[i] @ np.log(self.soft[i]))\n\n return out","def loss(output, y):\n #Computes softmax cross entropy between logits and labels.\n xentropy = tf.nn.softmax_cross_entropy_with_logits(logits=output, labels=y)\n loss = tf.reduce_mean(xentropy)\n\n return loss","def loss_function(self, targets, outputs):\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets, logits=outputs)\n return tf.reduce_mean(cross_entropy)","def cross_entropoy_loss_vectorized(W, X, y, reg): \n loss = 0 \n dW = np.zeros_like(W)\n N, D = X.shape \n \n \n scores = X.dot(W) # [K, N]\n # for numerical stability)\n scores -= np.max(scores)\n scores_exp = np.exp(scores)\n correct_scores_exp = scores_exp[range(N),y] \n scores_exp_sum = np.sum(scores_exp, axis=1) \n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\n loss /= N\n loss += 0.5 * reg * np.sum(W * W)\n\n scores_exp_normalized = scores_exp.T / scores_exp_sum \n scores_exp_normalized[y, range(N)] -= 1 \n dW = np.dot(scores_exp_normalized,X)\n dW = dW.T\n dW /= N \n dW += reg * W\n \n \n ############################################################################\n # TODO: Compute the cross-entropy loss and its gradient without explicit #\n # loops. Store the loss in loss and the gradient in dW. If you are not #\n # careful here, it is easy to run into numeric instability. Don't forget #\n # the regularization! #\n ############################################################################\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, dW","def get_reconstruction_cost(self, nv):\n cross_entropy = T.mean(\n T.sum(\n self.input * T.log(nv) +\n (1 - self.input) * T.log(1 - nv),\n axis=1\n )\n )\n return cross_entropy","def calculate_entropy(prob):\n return -(prob * math.log(prob,2))","def entropy(data):\n e = 0\n\n counter = collections.Counter(data)\n l = len(data)\n for count in counter.values():\n p_x = count / l\n e += - p_x * math.log2(p_x)\n\n return e","def cross_entropy(targets, predictions, epsilon=1e-12):\n\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\n\n N = predictions.shape[0]\n\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\n\n return ce","def gain(Y, X):\n return entropy(Y) - cEntropy(Y,X)","def entropy(out, dim=1, reduce='mean'):\n log_prob = F.log_softmax(out, dim=dim)\n h = -torch.sum(log_prob.exp() * log_prob, dim=dim)\n if reduce == 'none':\n return h\n if reduce == 'mean':\n return h.mean()\n if reduce == 'sum':\n return h.sum()","def loss_fn(self, recons, inputs, mu, log_var, **kwargs):\n# kld_weight = kwargs['M_N'] # Account for the minibatch samples from the dataset\n recons_loss = F.mse_loss(recons, inputs)\n# recons_loss = F.binary_cross_entropy(recons, inputs)\n KLD = torch.mean(-0.5 * torch.sum(1 + log_var - mu**2 - log_var.exp(), dim=1), dim=0)\n loss = recons_loss - KLD\n return loss, recons_loss, KLD","def vae_loss(x, t_decoded):\r\n return K.mean(reconstruction_loss(x, t_decoded))","def loss(y, y_pred):\n # assert_is_binary(y)\n # assert_is_stochastic(y_pred)\n is_binary(y)\n is_stochastic(y_pred)\n\n # prevent taking the log of 0\n eps = np.finfo(float).eps\n\n # each example is associated with a single class; sum the negative log\n # probability of the correct label over all samples in the batch.\n # observe that we are taking advantage of the fact that y is one-hot\n # encoded!\n cross_entropy = -np.sum(y * np.log(y_pred + eps))\n return cross_entropy","def test_softmax_cross_entropy(self):\n loss_op = listwise_losses.SoftmaxCrossEntropy()\n\n y_pred = loss_op.final_activation_op({\n \"logits\": self.logits,\n \"metadata\": {\n \"mask\": self.mask\n }\n })\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\n\n loss = loss_op({\"mask\": self.mask}, self.y_true, y_pred)\n assert np.isclose(loss, 1.306335, atol=1e-5)","def setup_loss(self):\n with vs.variable_scope(\"loss\"):\n self.loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.label_placeholder, logits=self.label_predictions))","def cross_entropoy_loss_naive(W, X, y, reg):\n # pylint: disable=too-many-locals\n # Initialize the loss and gradient to zero.\n loss = 0.0\n dW = np.zeros_like(W)\n \n\n C = W.shape[1]\n# print(\"no. of classes {}\".format(C))\n N,D = X.shape\n# print(\"no. of data {} and dimension {}\".format(N,D))\n for i in range(N):\n xi = X[i,:]\n# print(\"one record shape: {}\".format(xi.shape))\n scores = np.zeros(C)\n for c in range(C):\n w = W[:,c]\n# print(\"weight for one record {}\".format(w.shape))\n scores[c] = xi.dot(w)\n scores -= np.max(scores)\n actual_y = y[i]\n total_score = np.sum(np.exp(scores)) \n loss_i = -scores[actual_y] + np.log(total_score)\n# print('naive score : {}'.format(scores[actual_y]))\n loss += loss_i\n \n #gradient\n probability = np.exp(scores)/total_score\n for j in range(C):\n dW[:,j] += probability[j]*xi\n \n dW[:,actual_y] -= xi\n loss = loss/N\n reg_loss = 0.5*reg*np.sum(W*W)\n loss = loss + reg_loss\n print(\"loss : {}\".format(loss))\n dW = dW/N\n dW += reg*W\n \n \n \n \n\n ############################################################################\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\n # loops. Store the loss in loss and the gradient in dW. If you are not #\n # careful here, it is easy to run into numeric instability. Don't forget #\n # the regularization! #\n ############################################################################\n\n ############################################################################\n # END OF YOUR CODE #\n ############################################################################\n\n return loss, dW","def calc_loss(self, outputs, labels):\n information_loss = self.bottleneck.buffer_capacity.mean() # Taking the mean is equivalent of scaling with 1/K\n cross_entropy = F.cross_entropy(outputs, target=labels)\n total = cross_entropy + self.beta * information_loss\n self.ce_loss.append(cross_entropy.cpu().detach().numpy())\n self.info_loss.append(information_loss.cpu().detach().numpy())\n self.total_loss.append(total.cpu().detach().numpy())\n return total"],"string":"[\n \"def cross_entropy_loss():\\n return nn.CrossEntropyLoss()\",\n \"def cross_entropy(y_observed, p):\\n\\n pass\",\n \"def cross_entropy_error(self, x, y):\\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for i in range(len(y))])\",\n \"def cross_entropy(self):\\n return self._cross_entropy_func\",\n \"def cross_entropy(y_pred,y):\\n \\n epsilon = 0.001 # To prevent overflow and ensure numerical stability\\n return sum(-y*np.log(y_pred+epsilon))\",\n \"def _initLoss(self):\\n\\n return torch.nn.CrossEntropyLoss()\",\n \"def entropy(y):\\n EPS = 0.0005\\n\\n # YOUR CODE HERE\\n if len(y) == 0:\\n return 0.\\n \\n pk = np.mean(y, axis=0)\\n \\n return - np.sum(pk * np.log(pk + EPS))\",\n \"def CE():\\n def CE_loss(input,target):\\n return nn.CrossEntropyLoss()(input.squeeze(), target)\\n\\n return CE_loss\",\n \"def compute_loss(self):\\n def calc_loss(inputs, outputs):\\n reconstruction_loss = tf.metrics.binary_crossentropy(\\n tf_flat(inputs), tf_flat(outputs))\\n reconstruction_loss *= OUT_SIZE * OUT_SIZE\\n kl_loss = -0.5 * tf.reduce_sum(1.0 + self.log_sigma - tf.square(\\n self.mu) - tf.exp(self.log_sigma), 1)\\n return tf.reduce_mean(reconstruction_loss + kl_loss)\\n return calc_loss\",\n \"def compute_loss(self):\\n self.prototypes = self.compute_prototypes()\\n self.test_logits = self.compute_logits()\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.episode.test_labels, logits=self.test_logits)\\n cross_entropy_loss = tf.reduce_mean(loss)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy_loss + self.weight_decay * regularization\\n return loss\",\n \"def classification_loss(self, logit, target):\\n return F.cross_entropy(logit, target)\",\n \"def _loss(self):\\n\\n cross_entropy = tf.reduce_mean(-tf.log(self.probability + epsilon) * self.y)\\n self.loss = cross_entropy\\n\\n self.accuracy = tf.reduce_mean(\\n tf.cast(tf.equal(tf.argmax(self.y, 1), self.prediction), tf.float32))\",\n \"def calculate_cross_entropy(self, output, flat_labels): #completed, expensive, should be compiled\\n return -np.sum(np.log(np.clip(output, a_min=1E-12, a_max=1.0))[np.arange(flat_labels.shape[0]), flat_labels[:,1]])\",\n \"def crossentropy_fn(args: StepFunctionArgs) -> SingleScorePerStepTensor:\\n return -torch.log2(probability_fn(args))\",\n \"def cross_entropy(U, V):\\n return -np.sum(U * np.log(V))\",\n \"def cross_entropy(y_pred, y_true, normalize=True, eps=1e-15):\\n if type(y_pred) != np.ndarray:\\n raise TypeError(\\\"Require np.ndarray type,{} checked\\\".format(type(y_pred)))\\n if type(y_true) != np.ndarray:\\n raise TypeError(\\\"Require np.ndarray type,{} checked\\\".format(type(y_true)))\\n # clip = np.vectorize(lambda x: max(eps, min(1 - eps, x)))\\n # y_pred = clip(y_pred)\\n y_pred = np.array(list(map(lambda x: max(eps, min(1 - eps, x)), y_pred)))\\n l = np.multiply(y_true, np.log(y_pred)) + np.multiply(1 - y_true, np.log(1 - y_pred))\\n loss = -1 * np.sum(l).item()\\n if normalize:\\n loss = loss / len(y_pred)\\n return loss\",\n \"def cross_entropy(t,y):\\r\\n #print(-1*t*np.log(y))\\r\\n #print(np.shape(np.log(y)))\\r\\n #print(np.shape(t))\\r\\n return t*np.log(y)*(-1)\",\n \"def conditional_entropy(self) -> float:\\n pass\",\n \"def loss(params: hk.Params, batch, label) -> jnp.ndarray:\\r\\n logits = net.apply(params, batch)\\r\\n labels = jax.nn.one_hot(label, n_classes)\\r\\n\\r\\n # Cross Entropy Loss\\r\\n softmax_xent = -jnp.sum(labels * jax.nn.log_softmax(logits))\\r\\n softmax_xent /= labels.shape[0]\\r\\n return softmax_xent\",\n \"def loss_fn(y_true,y_pred): \\n loss = tf.nn.softmax_cross_entropy_with_logits_v2(y_true,\\n y_pred,\\n axis=-1,\\n )\\n loss = tf.reduce_mean(loss,name=\\\"loss\\\")\\n return loss\",\n \"def compute_loss(self):\\n self.test_logits = self.compute_logits()\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(\\n labels=self.data.test_labels, logits=self.test_logits)\\n cross_entropy_loss = tf.reduce_mean(loss)\\n regularization = tf.reduce_sum(\\n tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n loss = cross_entropy_loss + self.weight_decay * regularization\\n return loss\",\n \"def setup_loss(self):\\n self.loss = nn.CrossEntropyLoss(weight = self.to_device(self.datasetManager.class_weights))\\n #self.loss = nn.CrossEntropyLoss()\",\n \"def cross_entropy(self, sents):\\n return (-1) * self.log_prob(sents) / len(self._count)\",\n \"def genLoss(self, *data):\\r\\n _, (x_unlab, _) = data\\r\\n z = self.getInputNoise(self.hypers['ul_BS'])\\r\\n fake_logits = self.D(self.G(z))\\r\\n g_losses = -1*logOneMinusSoftmax(fake_logits)[:,self.D.numClasses-1]\\r\\n return torch.mean(g_losses)\",\n \"def compute_loss(self):\",\n \"def test_cross_entropy(self):\\n loss = losses.cross_entropy_with_logits(\\n logits=self.logits, targets=self.targets)\\n kl = loss.mean()\\n\\n expected_loss = -(jnp.log(0.9) + jnp.log(0.1) + jnp.log(0.9)) / 3\\n\\n self.assertAlmostEqual(kl, expected_loss)\",\n \"def calc_entropy_tuning_loss(self, log_probs):\\n with torch.no_grad():\\n inner_prod = (log_probs + self.target_entropy).detach()\\n alpha_loss = -(self.log_alpha * inner_prod).mean()\\n return alpha_loss\",\n \"def cross_entropy(y_prob,y):\\n from numpy import log, sum\\n m = y.shape[0]\\n p = y_prob\\n log_likelihood = -log(p[range(m),y])\\n loss = sum(log_likelihood) / m\\n return loss\",\n \"def test_aux_softmax_cross_entropy(self):\\n loss_op = listwise_losses.AuxiliarySoftmaxCrossEntropy()\\n\\n y_pred = loss_op.final_activation_op({\\n \\\"logits\\\": self.logits,\\n \\\"metadata\\\": {\\n \\\"mask\\\": self.mask\\n }\\n })\\n\\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\\n\\n loss = loss_op({\\\"mask\\\": self.mask}, self.y_true_aux, y_pred)\\n assert np.isclose(loss, 0.88127804, atol=1e-5)\",\n \"def cross_entropy(X, y):\\n return lambda theta: -y * np.log(logistic_hypothesis(theta)(X) + 1e-9) - (\\n 1 - y\\n ) * np.log(1 - logistic_hypothesis(theta)(X) + 1e-9)\",\n \"def loss_sce(y_pred, y_true):\\n loss = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=y_true, logits=y_pred)\\n\\n return tf.reduce_mean(loss)\",\n \"def set_loss_function(self):\\r\\n self.criterion = nn.CrossEntropyLoss().cuda()\",\n \"def crossEntropyLoss(YPredict, YTrueOneHot):\\n if YPredict.shape != YTrueOneHot.shape:\\n YTrueOneHot = YTrueOneHot.reshape(YPredict.shape)\\n return -np.sum(np.multiply(np.log(YPredict), YTrueOneHot))\",\n \"def loss_softmax_cross_entropy(self, unet, predict, ground_truth):\\n\\n loss = -F.mean(F.log(predict+1e-16) * ground_truth)\\n\\n chainer.report({\\\"loss\\\":loss}, unet)#mistery\\n return loss\",\n \"def cross_entropy_loss(self, y, y_hat):\\n if y.ndim == 1:\\n batch_size = 1\\n else:\\n batch_size = y.shape[0]\\n delta = 1e-7\\n return -np.sum(y * np.log(y_hat + delta)) / batch_size\",\n \"def cross_entropy_loss(self, logits, labels):\\n return F.cross_entropy(logits, labels)\",\n \"def conditional_entropy_hyper(self) -> float:\\n pass\",\n \"def cross_entropy_loss(outputs, labels): \\n# works properly\\n \\n m = labels.shape[0]\\n p = outputs\\n log_likelihood = -1*torch.log(p[range(m),labels])\\n loss = torch.sum(log_likelihood) / m\\n return loss.item()\",\n \"def loss(self, X, y):\\n\\n # Initialize the loss to zero.\\n loss = 0.0\\n num_classes = self.W.shape[0] # C = num_classes\\n num_train = X.shape[0]\\n \\n exp_a = np.zeros((num_classes,num_train))\\n # ================================================================ #\\n # YOUR CODE HERE:\\n # Calculate the normalized softmax loss. Store it as the variable loss.\\n # (That is, calculate the sum of the losses of all the training \\n # set margins, and then normalize the loss by the number of \\n # training examples.)\\n # ================================================================ #\\n \\n \\n for i in np.arange(num_train):\\n \\n Loss = 0.0\\n\\n class_scores = np.dot(self.W,X[i,:].T) # calculating class scores (C x 1 vector)\\n class_scores -= np.max(class_scores) # considering the possible issue for numerical instability and account for it\\n\\n exp_a[:,i] = np.exp(class_scores) # turning class scores to probabilities (C x 1 vector), without normalization\\n\\n Loss -= np.log(exp_a[y[i],i]/np.sum(exp_a[:,i]))\\n \\n\\n #p[:,i] = exp_a[:,i]/np.sum(exp_a[:,i]) # p now is a valid probability matrix\\n #print(p[:,i])\\n\\n loss += Loss \\n #print(Loss,i) \\n \\n pass\\n loss /= num_train\\n # ================================================================ #\\n # END YOUR CODE HERE\\n # ================================================================ #\\n\\n return loss\",\n \"def get_cross_entropy(self):\\n assert (self.dataset is not None) and (self.labels is not None), 'Logistic Regression requires a dataset and labels.'\\n potential = 0.0\\n logits = self.dataset @ self.parameters[:self.dataset.shape[1]]\\n max_logits = torch.max(torch.zeros(logits.shape[0]),logits)\\n potential = (-logits @ self.labels.t() + torch.sum(max_logits) + torch.sum(\\n torch.log(torch.exp(-max_logits)+torch.exp(logits - max_logits))))# * n.reciprocal())\\n return potential\",\n \"def calculate_entropy(eval_token_count, training_model):\\n sum_of_counts = sum(eval_token_count.values())\\n cross_entropy = 0\\n mis = []\\n for ngram in eval_token_count:\\n if training_model.score(ngram[-1], list(ngram[0:3])) == 0 or sum_of_counts == 0:\\n mi = np.mean(mis) if len(mis) > 0 else np.log2(0.287)\\n else:\\n mi = training_model.logscore(ngram[-1], list(ngram[0:3]))\\n pi = eval_token_count[ngram] / sum_of_counts\\n mis.append(mi)\\n cross_entropy -= pi * mi\\n return cross_entropy\",\n \"def Weighted_Cross_Entropy(y_true, y_pred, eps = 1e-10):\\n y_pred = tf.cast(y_pred, 'float64')\\n y_true = tf.cast(y_true, 'float64')\\n # deduce weights based on true pixel value\\n class_weights = weights * y_true\\n # compute your (unweighted) softmax cross entropy loss\\n unweighted_losses = y_true*tf.math.log(y_pred + eps)\\n ##print(unweighted_losses.dtype, weights.dtype)\\n weighted_losses = unweighted_losses * class_weights\\n # reduce the result to get your final loss\\n loss = -tf.reduce_sum(weighted_losses)\\n return loss\",\n \"def loss_function(recon_x, x, mu, logvar, input_size):\\n BCE = F.binary_cross_entropy(recon_x, x.view(-1, input_size), size_average=False)\\n\\n # see Appendix B from VAE paper:\\n # Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\\n # https://arxiv.org/abs/1312.6114\\n # 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\\n KLD = -0.5 * torch.sum(1 + logvar - mu.pow(2) - logvar.exp())\\n\\n return BCE + KLD\",\n \"def cross_entropy_loss(batch_out, batch_gt):\\r\\n criterion = torch.nn.CrossEntropyLoss()\\r\\n target = torch.argmax(batch_gt, 1)\\r\\n loss = criterion(batch_out, target)\\r\\n\\r\\n return loss\",\n \"def entropy(self):\\r\\n return 1/2 * (self.dim * (_LOG_2PI + 1) + self._log_det_cov)\",\n \"def entropy_loss(policy_logits):\\n\\n softmax = nn.Softmax(dim=-1)\\n logsoftmax = nn.LogSoftmax(dim=-1)\\n\\n policy = softmax(policy_logits.action_type)\\n log_policy = logsoftmax(policy_logits.action_type)\\n\\n return torch.mean(torch.sum(-policy * log_policy, axis=-1))\",\n \"def entropy(self):\\n return -np.sum(self.log_likelihoods * np.exp(self.log_likelihoods))\",\n \"def crossentropy_loss(y_true, y_pred):\\n ce = tf.keras.losses.categorical_crossentropy(y_true, y_pred, from_logits=True) \\n return ce\",\n \"def gen_loss_orig(self, noise_samples):\\n generator_samples = self.gen_model(noise_samples)\\n logits_gen = self.disc_model(generator_samples)\\n # loss = -tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.zeros(logits_gen.shape), logits=logits_gen))\\n loss = tf.reduce_mean(tf.nn.sigmoid_cross_entropy_with_logits(labels=tf.ones(logits_gen.shape), logits=logits_gen))\\n return loss\",\n \"def cross_entropy(true, pred, axis=-1, epsilon=1e-7):\\n pred = ivy.clip(pred, epsilon, 1 - epsilon)\\n log_pred = ivy.log(pred)\\n # noinspection PyUnresolvedReferences\\n return -ivy.reduce_sum(log_pred * true, axis)\",\n \"def _vae_loss(self, x, x_generated):\\n x = K.flatten(x)\\n x_generated = K.flatten(x_generated)\\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\\\\n binary_crossentropy(x, x_generated)\\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\\n kl_disc_loss = 0\\n return reconstruction_loss + kl_normal_loss + kl_disc_loss\",\n \"def _vae_loss(self, x, x_generated):\\n x = K.flatten(x)\\n x_generated = K.flatten(x_generated)\\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\\\\n binary_crossentropy(x, x_generated)\\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\\n kl_disc_loss = 0\\n return reconstruction_loss + kl_normal_loss + kl_disc_loss\",\n \"def _vae_loss(self, x, x_generated):\\n x = K.flatten(x)\\n x_generated = K.flatten(x_generated)\\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\\\\n binary_crossentropy(x, x_generated)\\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\\n kl_disc_loss = 0\\n return reconstruction_loss + kl_normal_loss + kl_disc_loss\",\n \"def _vae_loss(self, x, x_generated):\\n x = K.flatten(x)\\n x_generated = K.flatten(x_generated)\\n reconstruction_loss = self.input_shape[0] * self.input_shape[1] * \\\\\\n binary_crossentropy(x, x_generated)\\n kl_normal_loss = kl_normal(self.z_mean, self.z_log_var)\\n kl_disc_loss = 0\\n return reconstruction_loss + kl_normal_loss + kl_disc_loss\",\n \"def loss_function(self, x, x_hat_logit, mu, log_sigma):\\n rec_loss = nn.functional.binary_cross_entropy_with_logits(x_hat_logit, x, size_average=False)\\n kl_loss = -0.5 * torch.sum(1 + log_sigma - mu.pow(2) - log_sigma.exp())\\n\\n return rec_loss + (kl_loss), rec_loss, kl_loss\",\n \"def loss(self):\\n return la.norm(self.resids) / self.normX\",\n \"def cross_entropy_loss(predictions, targets, epsilon=1e-12):\\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\\n N = predictions.shape[0]\\n ce = -np.sum(targets*np.log(predictions+1e-9))/N\\n return ce\",\n \"def compute_cross_entropy(probs, target):\\n avg_probs_per_sample = probs.mean(\\n -1)\\n xe = torch.nn.CrossEntropyLoss(reduction='none')\\n return xe(avg_probs_per_sample, target).detach().cpu().numpy()\",\n \"def loss_function(recon_x, x, mu, logvar, cl, target, natural):\\n\\tglobal decoder_nat_loss, decoder_syn_loss, KLD_syn_loss, KLD_nat_loss, regressor_nat, regressor_syn\\n\\t#decoder_loss = F.binary_cross_entropy(recon_x, x.view(-1, 1, img_size, img_size), reduction='sum') * decoder_l_factor\\n\\tdecoder_loss = F.mse_loss(recon_x, x) * decoder_l_factor\\n\\n\\t# see Appendix B from VAE paper: Kingma and Welling. Auto-Encoding Variational Bayes. ICLR, 2014\\n\\t# https://arxiv.org/abs/1312.6114\\n\\t# 0.5 * sum(1 + log(sigma^2) - mu^2 - sigma^2)\\n\\tbeta = 1 / (batch_size * boundary_dim) # disentanglement factor#extremely small\\n\\tKLD = -0.5 * beta * torch.sum(1 + logvar - mu.pow(2) - logvar.exp()) * KLD_l_factor\\n\\n\\tregressor_loss = F.mse_loss(cl, target.view(-1, 1)) * regressor_l_factor\\n\\tif epoch < regressor_start:\\n\\t\\tregressor_loss *= 0\\n\\n\\tif natural:\\n\\t\\tdecoder_nat_loss += decoder_loss\\n\\t\\tKLD_nat_loss += KLD\\n\\t\\tregressor_nat += regressor_loss\\n\\telse:\\n\\t\\tdecoder_syn_loss += decoder_loss\\n\\t\\tKLD_syn_loss += KLD\\n\\t\\tregressor_syn += regressor_loss\\n\\n\\tif KLD > 1e10:\\n\\t\\tplaySound()\\n\\t\\tsys.exit('KLD diverged')\\n\\n\\treturn decoder_loss + KLD + regressor_loss, KLD, regressor_loss\",\n \"def crossEntropy(p_m1):\\n p_m2 = 1 - p_m1\\n D = - p_m1*math.log(p_m1) - p_m2*math.log(p_m2)\\n return D\",\n \"def loss_fn(outputs, labels):\\n return nn.CrossEntropyLoss()(outputs, labels)\",\n \"def loss_fn(outputs, labels, wts):\\n\\n # reshape labels to give a flat vector of length batch_size*seq_len\\n loss_noreduce = nn.BCEWithLogitsLoss(reduce=False)\\n loss = torch.mean(loss_noreduce(outputs, labels)*wts)\\n\\t\\n # compute cross entropy loss for all tokens\\n return loss\",\n \"def compute_entropy_loss(logits):\\n policy = F.softmax(logits, dim=-1)\\n log_policy = F.log_softmax(logits, dim=-1)\\n return torch.sum(policy * log_policy)\",\n \"def cEntropy(Y, X):\\n return jEntropy(Y, X) - entropy(X)\",\n \"def entropy(Y):\\n\\n temp = np.unique(Y, return_counts=True)\\n uniq_Y = list(temp[0])\\n Y_count = list(temp[1])\\n \\n total = sum(Y_count)\\n\\n ent = 0\\n for elem in uniq_Y:\\n prob = Y_count[uniq_Y.index(elem)] / total\\n # print(\\\"prob:\\\", prob)\\n ent -= (prob * (math.log2(prob)))\\n # print(\\\"ent:\\\",ent)\\n\\n return ent\",\n \"def compute_loss(self, x, gt):\\n loss = sum([torch.mean((out - gt)**2) for out in self.forward(x)])\\n return loss\",\n \"def entropy(temp,pres):\\n g_t = liq_g(1,0,temp,pres)\\n s = -g_t\\n return s\",\n \"def my_loss(y_pred,y_true,n_outputs):\\n y_true = tf.one_hot(tf.cast(y_true,tf.int64), n_outputs, dtype=tf.float32)\\n return tf.reduce_mean(tf.nn.softmax_cross_entropy_with_logits(y_true,y_pred))\",\n \"def compute_test_loss(self, x):\\n temp_training = self.training\\n self.training = False\\n mean, logvar = self.encode(x)\\n z = self.reparameterize(mean, logvar)\\n x_logit = self.decode(z)\\n\\n cross_ent = tf.nn.sigmoid_cross_entropy_with_logits(logits=x_logit, labels=x)\\n logpx_z = -tf.math.reduce_sum(cross_ent, axis=[1, 2, 3]) # JAH removed 3D axis=[1, 2, 3,4]\\n logpz = self.log_normal_pdf(z, 0.0, 0.0)\\n logqz_x = self.log_normal_pdf(z, mean, logvar)\\n\\n\\n kl_divergence = logqz_x - logpz\\n neg_log_likelihood = -logpx_z\\n\\n #elbo = tf.math.reduce_mean(-self.kl_weight * kl_divergence - neg_log_likelihood) # shape=()\\n neg_elbo = tf.math.reduce_mean(self.kl_weight * kl_divergence + neg_log_likelihood) # shape=()\\n self.training = temp_training\\n return neg_elbo\",\n \"def entropy(x):\\n nz = np.nonzero(x)[0]\\n return -np.sum(x[nz]*np.log2(x[nz]))\",\n \"def cross_entropy(predictions, targets):\\n likelihood = targets * np.log(predictions)\\n return -np.sum(likelihood) / predictions.shape[0]\",\n \"def compute_perplexity(self,loss: float):\\n return math.exp(loss)\",\n \"def _entropy(data):\\n hist = np.array(PIL.Image.fromarray(data).histogram())\\n hist = hist / hist.sum()\\n hist = hist[hist != 0]\\n return -np.sum(hist * np.log2(hist))\",\n \"def entropy(y):\\r\\n\\r\\n # INSERT YOUR CODE HERE\\r\\n value, count = np.unique(y,return_counts = True)\\r\\n Hy = 0.0\\r\\n prob = count.astype(float)/len(y)\\r\\n for p in prob:\\r\\n Hy += -(p)*(np.log2(p))\\r\\n return Hy\\r\\n raise Exception('Function not yet implemented!')\",\n \"def target_loss(self, inp_hist):\\n active_targ = self.get_active_target(inp_hist)\\n return torch.mean((inp_hist[:, 1:3] - active_targ) ** 2)\",\n \"def approximate_loss(self, x, x_recon, v_dist, eps=1e-3):\\n log_alpha = v_dist.logits\\n bce = F.binary_cross_entropy(x_recon, x.view(-1, 784), reduction='sum')\\n num_class = torch.tensor(self.latent_dim).float()\\n probs = torch.softmax(log_alpha, dim=-1) # alpha_i / alpha_sum\\n kl = torch.sum(probs * (num_class * (probs + eps)).log(), dim=-1).sum()\\n return bce, kl\",\n \"def loss(self, y_pred=None, y_true=None):\\n n = y_pred.shape[0]\\n ahat = transform(self.ahat)\\n bhat = transform(self.bhat)\\n return -1 * (-0.5 * n * self.const + 0.5 * n * (torch.digamma(ahat) - torch.log(bhat)) \\\\\\n - 0.5 * (ahat/bhat) * ((y_pred - y_true) ** 2).sum())\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def entropy(self, **kwargs) -> TensorType:\",\n \"def compute_loss(self, obs, returns):\",\n \"def cross_entropy(x, y):\\n\\n if len(y.shape) == 1:\\n return F.cross_entropy(x, y)\\n if y.shape[1] == 1:\\n y = y.squeeze(1)\\n return F.cross_entropy(x, y)\\n\\n return torch.mean(\\n torch.div(\\n F.binary_cross_entropy_with_logits(x, y, reduction=\\\"none\\\"),\\n torch.sum(y, dim=1),\\n )\\n )\",\n \"def test_aux_one_hot_hot_cross_entropy(self):\\n loss_op = listwise_losses.AuxiliaryOneHotCrossEntropy()\\n\\n y_pred = loss_op.final_activation_op({\\n \\\"logits\\\": self.logits,\\n \\\"metadata\\\": {\\n \\\"mask\\\": self.mask\\n }\\n })\\n\\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\\n\\n loss = loss_op({\\\"mask\\\": self.mask}, self.y_true_aux, y_pred)\\n assert np.isclose(loss, 0.5249801, atol=1e-5)\",\n \"def __loss(self, h, y):\\n return (-y*np.log(h)-(1-y)*np.log(1-h)).mean()\",\n \"def crossEntropy(obs, actual, offset=1e-7):\\n # (tf.Tensor, tf.Tensor, float) -> tf.Tensor\\n # bound by clipping to avoid nan\\n obs_ = tf.clip_by_value(obs, offset, 1 - offset)\\n return -tf.reduce_sum(actual * tf.log(obs_) +\\n (1 - actual) * tf.log(1 - obs_), 1)\",\n \"def compute_loss(self, x, y):\\n\\n self.batch_size = x.shape[0]\\n self.x = x\\n self.y = y\\n self.soft = self.softmax(x) + 10**(-11)\\n out = np.zeros(self.batch_size)\\n for i in range(self.batch_size):\\n out[i] = -(y[i] @ np.log(self.soft[i]))\\n\\n return out\",\n \"def loss(output, y):\\n #Computes softmax cross entropy between logits and labels.\\n xentropy = tf.nn.softmax_cross_entropy_with_logits(logits=output, labels=y)\\n loss = tf.reduce_mean(xentropy)\\n\\n return loss\",\n \"def loss_function(self, targets, outputs):\\n cross_entropy = tf.nn.sparse_softmax_cross_entropy_with_logits(labels=targets, logits=outputs)\\n return tf.reduce_mean(cross_entropy)\",\n \"def cross_entropoy_loss_vectorized(W, X, y, reg): \\n loss = 0 \\n dW = np.zeros_like(W)\\n N, D = X.shape \\n \\n \\n scores = X.dot(W) # [K, N]\\n # for numerical stability)\\n scores -= np.max(scores)\\n scores_exp = np.exp(scores)\\n correct_scores_exp = scores_exp[range(N),y] \\n scores_exp_sum = np.sum(scores_exp, axis=1) \\n loss = -np.sum(np.log(correct_scores_exp / scores_exp_sum))\\n loss /= N\\n loss += 0.5 * reg * np.sum(W * W)\\n\\n scores_exp_normalized = scores_exp.T / scores_exp_sum \\n scores_exp_normalized[y, range(N)] -= 1 \\n dW = np.dot(scores_exp_normalized,X)\\n dW = dW.T\\n dW /= N \\n dW += reg * W\\n \\n \\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient without explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def get_reconstruction_cost(self, nv):\\n cross_entropy = T.mean(\\n T.sum(\\n self.input * T.log(nv) +\\n (1 - self.input) * T.log(1 - nv),\\n axis=1\\n )\\n )\\n return cross_entropy\",\n \"def calculate_entropy(prob):\\n return -(prob * math.log(prob,2))\",\n \"def entropy(data):\\n e = 0\\n\\n counter = collections.Counter(data)\\n l = len(data)\\n for count in counter.values():\\n p_x = count / l\\n e += - p_x * math.log2(p_x)\\n\\n return e\",\n \"def cross_entropy(targets, predictions, epsilon=1e-12):\\n\\n predictions = np.clip(predictions, epsilon, 1. - epsilon)\\n\\n N = predictions.shape[0]\\n\\n ce = -np.sum(np.sum(targets*np.log(predictions+1e-9)))/N\\n\\n return ce\",\n \"def gain(Y, X):\\n return entropy(Y) - cEntropy(Y,X)\",\n \"def entropy(out, dim=1, reduce='mean'):\\n log_prob = F.log_softmax(out, dim=dim)\\n h = -torch.sum(log_prob.exp() * log_prob, dim=dim)\\n if reduce == 'none':\\n return h\\n if reduce == 'mean':\\n return h.mean()\\n if reduce == 'sum':\\n return h.sum()\",\n \"def loss_fn(self, recons, inputs, mu, log_var, **kwargs):\\n# kld_weight = kwargs['M_N'] # Account for the minibatch samples from the dataset\\n recons_loss = F.mse_loss(recons, inputs)\\n# recons_loss = F.binary_cross_entropy(recons, inputs)\\n KLD = torch.mean(-0.5 * torch.sum(1 + log_var - mu**2 - log_var.exp(), dim=1), dim=0)\\n loss = recons_loss - KLD\\n return loss, recons_loss, KLD\",\n \"def vae_loss(x, t_decoded):\\r\\n return K.mean(reconstruction_loss(x, t_decoded))\",\n \"def loss(y, y_pred):\\n # assert_is_binary(y)\\n # assert_is_stochastic(y_pred)\\n is_binary(y)\\n is_stochastic(y_pred)\\n\\n # prevent taking the log of 0\\n eps = np.finfo(float).eps\\n\\n # each example is associated with a single class; sum the negative log\\n # probability of the correct label over all samples in the batch.\\n # observe that we are taking advantage of the fact that y is one-hot\\n # encoded!\\n cross_entropy = -np.sum(y * np.log(y_pred + eps))\\n return cross_entropy\",\n \"def test_softmax_cross_entropy(self):\\n loss_op = listwise_losses.SoftmaxCrossEntropy()\\n\\n y_pred = loss_op.final_activation_op({\\n \\\"logits\\\": self.logits,\\n \\\"metadata\\\": {\\n \\\"mask\\\": self.mask\\n }\\n })\\n assert np.isclose(y_pred[0][0].numpy(), 0.19868991, atol=1e-5)\\n assert np.isclose(y_pred[2][4].numpy(), 0.0, atol=1e-5)\\n\\n loss = loss_op({\\\"mask\\\": self.mask}, self.y_true, y_pred)\\n assert np.isclose(loss, 1.306335, atol=1e-5)\",\n \"def setup_loss(self):\\n with vs.variable_scope(\\\"loss\\\"):\\n self.loss = tf.reduce_mean(tf.nn.sparse_softmax_cross_entropy_with_logits(labels=self.label_placeholder, logits=self.label_predictions))\",\n \"def cross_entropoy_loss_naive(W, X, y, reg):\\n # pylint: disable=too-many-locals\\n # Initialize the loss and gradient to zero.\\n loss = 0.0\\n dW = np.zeros_like(W)\\n \\n\\n C = W.shape[1]\\n# print(\\\"no. of classes {}\\\".format(C))\\n N,D = X.shape\\n# print(\\\"no. of data {} and dimension {}\\\".format(N,D))\\n for i in range(N):\\n xi = X[i,:]\\n# print(\\\"one record shape: {}\\\".format(xi.shape))\\n scores = np.zeros(C)\\n for c in range(C):\\n w = W[:,c]\\n# print(\\\"weight for one record {}\\\".format(w.shape))\\n scores[c] = xi.dot(w)\\n scores -= np.max(scores)\\n actual_y = y[i]\\n total_score = np.sum(np.exp(scores)) \\n loss_i = -scores[actual_y] + np.log(total_score)\\n# print('naive score : {}'.format(scores[actual_y]))\\n loss += loss_i\\n \\n #gradient\\n probability = np.exp(scores)/total_score\\n for j in range(C):\\n dW[:,j] += probability[j]*xi\\n \\n dW[:,actual_y] -= xi\\n loss = loss/N\\n reg_loss = 0.5*reg*np.sum(W*W)\\n loss = loss + reg_loss\\n print(\\\"loss : {}\\\".format(loss))\\n dW = dW/N\\n dW += reg*W\\n \\n \\n \\n \\n\\n ############################################################################\\n # TODO: Compute the cross-entropy loss and its gradient using explicit #\\n # loops. Store the loss in loss and the gradient in dW. If you are not #\\n # careful here, it is easy to run into numeric instability. Don't forget #\\n # the regularization! #\\n ############################################################################\\n\\n ############################################################################\\n # END OF YOUR CODE #\\n ############################################################################\\n\\n return loss, dW\",\n \"def calc_loss(self, outputs, labels):\\n information_loss = self.bottleneck.buffer_capacity.mean() # Taking the mean is equivalent of scaling with 1/K\\n cross_entropy = F.cross_entropy(outputs, target=labels)\\n total = cross_entropy + self.beta * information_loss\\n self.ce_loss.append(cross_entropy.cpu().detach().numpy())\\n self.info_loss.append(information_loss.cpu().detach().numpy())\\n self.total_loss.append(total.cpu().detach().numpy())\\n return total\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.747013","0.7422436","0.7151027","0.7125091","0.68993956","0.6885498","0.68482375","0.68349075","0.6828572","0.6810557","0.6792025","0.6763931","0.6726077","0.6725324","0.6716315","0.6703539","0.6699556","0.66880083","0.6670996","0.66659564","0.66648346","0.6658452","0.66394675","0.6639282","0.6636408","0.6624247","0.6623861","0.66108364","0.66048455","0.6603637","0.6600579","0.6600554","0.65940285","0.65935403","0.65881884","0.6585301","0.65593135","0.6558378","0.6542619","0.6537181","0.65326744","0.65217865","0.6505755","0.6501732","0.6493987","0.64900184","0.648746","0.64740604","0.64704525","0.6426966","0.64228404","0.64228404","0.64228404","0.64228404","0.64209646","0.6418198","0.64169323","0.64114106","0.64062935","0.63929623","0.6392366","0.63890624","0.638792","0.6384262","0.63837785","0.638062","0.63789093","0.6374181","0.6373495","0.63595","0.6357745","0.6337424","0.6336181","0.63350576","0.6334164","0.6332194","0.6330088","0.63277715","0.63277715","0.6316705","0.63034","0.62965417","0.6296372","0.6290532","0.62900734","0.62829787","0.6282418","0.62776655","0.62728524","0.62705714","0.627016","0.6265799","0.6264909","0.6248318","0.6243772","0.6235061","0.6234649","0.62335885","0.6231114","0.62301344","0.6223725"],"string":"[\n \"0.747013\",\n \"0.7422436\",\n \"0.7151027\",\n \"0.7125091\",\n \"0.68993956\",\n \"0.6885498\",\n \"0.68482375\",\n \"0.68349075\",\n \"0.6828572\",\n \"0.6810557\",\n \"0.6792025\",\n \"0.6763931\",\n \"0.6726077\",\n \"0.6725324\",\n \"0.6716315\",\n \"0.6703539\",\n \"0.6699556\",\n \"0.66880083\",\n \"0.6670996\",\n \"0.66659564\",\n \"0.66648346\",\n \"0.6658452\",\n \"0.66394675\",\n \"0.6639282\",\n \"0.6636408\",\n \"0.6624247\",\n \"0.6623861\",\n \"0.66108364\",\n \"0.66048455\",\n \"0.6603637\",\n \"0.6600579\",\n \"0.6600554\",\n \"0.65940285\",\n \"0.65935403\",\n \"0.65881884\",\n \"0.6585301\",\n \"0.65593135\",\n \"0.6558378\",\n \"0.6542619\",\n \"0.6537181\",\n \"0.65326744\",\n \"0.65217865\",\n \"0.6505755\",\n \"0.6501732\",\n \"0.6493987\",\n \"0.64900184\",\n \"0.648746\",\n \"0.64740604\",\n \"0.64704525\",\n \"0.6426966\",\n \"0.64228404\",\n \"0.64228404\",\n \"0.64228404\",\n \"0.64228404\",\n \"0.64209646\",\n \"0.6418198\",\n \"0.64169323\",\n \"0.64114106\",\n \"0.64062935\",\n \"0.63929623\",\n \"0.6392366\",\n \"0.63890624\",\n \"0.638792\",\n \"0.6384262\",\n \"0.63837785\",\n \"0.638062\",\n \"0.63789093\",\n \"0.6374181\",\n \"0.6373495\",\n \"0.63595\",\n \"0.6357745\",\n \"0.6337424\",\n \"0.6336181\",\n \"0.63350576\",\n \"0.6334164\",\n \"0.6332194\",\n \"0.6330088\",\n \"0.63277715\",\n \"0.63277715\",\n \"0.6316705\",\n \"0.63034\",\n \"0.62965417\",\n \"0.6296372\",\n \"0.6290532\",\n \"0.62900734\",\n \"0.62829787\",\n \"0.6282418\",\n \"0.62776655\",\n \"0.62728524\",\n \"0.62705714\",\n \"0.627016\",\n \"0.6265799\",\n \"0.6264909\",\n \"0.6248318\",\n \"0.6243772\",\n \"0.6235061\",\n \"0.6234649\",\n \"0.62335885\",\n \"0.6231114\",\n \"0.62301344\",\n \"0.6223725\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":21399,"cells":{"query":{"kind":"string","value":"Triplet loss group wise constraint Equation (14)"},"document":{"kind":"string","value":"def Lc(i:int, imgs:list, masks:list, features:list, phi:models) -> torch.tensor:\n Ion = phi(masks[i] * imgs[i])\n fi, fts = split_i(features, 1)\n cumsum = 0\n for IGm, I_Gm in fts:\n P = torch.sqrt(((Ion - IGm)**2)+1e-016)\n N = torch.sqrt(((Ion - I_Gm)**2)+1e-016)\n cumsum += softplus(P-N).sum()\n cumsum /= len(fts)\n return cumsum"},"metadata":{"kind":"string","value":"{\n \"objective\": {\n \"self\": [],\n \"paired\": [],\n \"triplet\": [\n [\n \"query\",\n \"document\",\n \"negatives\"\n ]\n ]\n }\n}"},"negatives":{"kind":"list like","value":["def _auxiliary_loss(self, expert_mask, router_prob):\n # density_1's shape: (dp_group, self.expert_dim)\n density_1 = self.reduce_mean(expert_mask, 1)\n # density_1_proxy's shape: (dp_group, self.expert_dim)\n density_1_proxy = self.reduce_mean2(router_prob, 1)\n loss = self.mul(density_1, density_1_proxy)\n loss = self.reduce_mean3(loss)\n loss = self.mul3(self.mul2(loss, self.expert_dim), self.expert_dim)\n return loss","def triplet_loss(y_true,y_pred,alpha=0.2):\n anchor,positive,negative=y_pred[0],y_pred[1],y_pred[2]\n pos_dist=tf.reduce_sum(tf.square(tf.subtract(anchor,positive)),axis=-1)\n neg_dist=tf.reduce_sum(tf.square(tf.subtract(anchor,negative)),axis=-1)\n basic_loss=tf.add(tf.subtract(pos_dist,neg_dist),alpha)\n loss=tf.reduce_sum(tf.maximum(basic_loss,0.0))\n return loss","def rule(model, i, j):\n active = 1-self.task_spread[j]\n den = sum(tril[i, :])\n ind = model.timeslots\n total = sum(tril[i, k] * (\n 1 - model.A[k, j] - model.A2[k, j] - model.A3[k, j] - model.A4[\n k, j]) for k in ind)\n total /= den\n total *= active\n return -1 + EPS, model.CTl[i, j] - total, EPS + self.slack_cont","def triplet_loss(y_true, y_pred):\n [a,p,n] = tf.unstack(y_pred, num=3)\n pos_dist = tf.reduce_sum((a - p)**2, axis=-1)\n neg_dist = tf.reduce_sum((a - n)**2, axis=-1)\n basic_loss = pos_dist - neg_dist + 0.1\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0)) \n return loss","def triplet_loss(self, sim, margin=0.5):\n # sim = sigmoid(5.0 - 5.0*distance)\n pos_sim, neg_sim = tf.slice(sim, [0, 0], [-1, 1]), tf.slice(sim, [0, 1], [-1, -1])\n # pos_sim has larger similarity than neg_sim\n triplet_loss = margin + neg_sim - pos_sim\n triplet_loss = tf.nn.relu(triplet_loss)\n triplet_loss = tf.reduce_sum(triplet_loss, axis=-1)\n triplet_loss = tf.reduce_mean(triplet_loss)\n\n # wmrb_loss = tf.log(1.0 + margin_loss)\n\n return triplet_loss","def loss_perceptual(self, vgg_out, vgg_gt, vgg_comp): \n loss = 0\n for o, c, g in zip(vgg_out, vgg_comp, vgg_gt):\n loss += self.l1(o, g) + self.l1(c, g)\n return loss","def rule(model):\n ind_i = model.timeslots2\n ind_j = model.tasks\n inv = 1-self.valid\n total = sum(\n model.A2[i, j] * inv[i + 1, j] for i in ind_i for j in ind_j)\n total += sum(\n model.A3[i, j] * inv[i + 1, j] for i in ind_i for j in ind_j)\n total += sum(\n model.A4[i, j] * inv[i + 1, j] for i in ind_i for j in ind_j)\n\n ind_i = model.timeslots3\n ind_j = model.tasks\n total += sum(\n model.A3[i, j] * inv[i + 2, j] for i in ind_i for j in ind_j)\n total += sum(\n model.A4[i, j] * inv[i + 2, j] for i in ind_i for j in ind_j)\n\n ind_i = model.timeslots4\n ind_j = model.tasks\n total += sum(\n model.A4[i, j] * inv[i + 3, j] for i in ind_i for j in ind_j)\n\n return None, total, 0","def ObjectiveGLASSO_block(As, bs, Ts, lam, groups, x):\n \n obj = 0\n for j in range(len(As)):\n obj = obj + 0.5*Norm(As[j].dot(x[Ts[j]])-bs[j])**2\n\n obj = obj + lam*np.sum([Norm(x[g]) for g in groups])\n return obj","def step(self):\n loss = None\n for group in self.param_groups:\n for p in group['params']:\n grad = p.grad.data\n state = self.state[p]\n\n if len(state) == 0:\n t = 0\n m = torch.zeros_like(p.data)\n v = torch.zeros_like(p.data)\n # v_hat = torch.zeros_like(p.data)\n else:\n t = state['t']\n m = state['m']\n v = state['v']\n\n b1 = group['beta1']\n b2 = group['beta2']\n t += 1\n\n m = torch.mul(m, b1) + (1-b1) * grad\n v = torch.mul(v, b2) + (1-b2) * grad**2\n\n m_unbias = 1 / (1 - b1**t)\n v_unbias = 1 / (1 - b2**t)\n\n p.data -= (group['lr'] * m_unbias / math.sqrt(v_unbias)) * \\\n m / (math.sqrt(v_unbias) + group['eps'])\n\n # v_hat = torch.max(v_hat, v)\n # p.data -= group['lr'] / m_unbias * m * v_hat / (v_unbias.sqrt() + group['eps'])\n state['t'] = t\n state['m'] = m\n state['v'] = v\n\n return loss","def powerflow_rule(_m, l, y, s, t):\r\n\r\n return (- m.sigma_27[l, y, s, t] + m.sigma_28[l, y, s, t]\r\n + (m.INCIDENCE_MATRIX[l, self.g(l)] * m.lamb[self.g(l), y, s, t])\r\n + (m.INCIDENCE_MATRIX[l, self.h(l)] * m.lamb[self.h(l), y, s, t])\r\n == 0)","def min_error_removed_linear_constraints(self):\n n_e_vars = len(self.removed_linear_constraints) * 2\n\n # Add a pair of (continuous) variables e+ >= 0 and e- >= 0, for each (removed) conflicting constraint\n eplus_vars = self.add_variables(n_variables=n_e_vars / 2, lb=0, var_type=\"continuous\")\n eminus_vars = self.add_variables(n_variables=n_e_vars / 2, lb=0, var_type=\"continuous\")\n\n print self.n_tuple_variables\n print len(eplus_vars)\n print len(eminus_vars)\n assert isinstance(self.problem, cplex.Cplex)\n print \"n binaries\", self.problem.variables.get_num_binary()\n print \"n all\", self.problem.variables.get_num()\n print \"n integers\", self.problem.variables.get_num_integer()\n\n # Set objective coefficients of e variables all to 1 (if minimization, otherwise -1)\n if self.problem.objective.get_sense() == cplex.Cplex.objective.sense.minimize:\n self.problem.objective.set_linear(izip(chain(eplus_vars, eminus_vars), repeat(1, n_e_vars)))\n else:\n self.problem.objective.set_linear(izip(chain(eplus_vars, eminus_vars), repeat(-1, n_e_vars)))\n\n adding_constraints = list()\n\n # For minimizing error in SUM(attr) for each attr in the query package\n for i, lc in enumerate(self.removed_linear_constraints):\n def get_coeff_function(_ugc):\n yield 1\n yield -1\n for coeff in self.get_aggregate_constraint_coefficients(_ugc.aggr, _ugc.attr):\n yield coeff\n\n def get_vars_function(_i):\n yield eplus_vars[_i]\n yield eminus_vars[_i]\n for var in self.tuple_variables:\n yield var\n\n lc = LinearConstraint(\n cid=self.new_constraint_id(),\n vals_func=(get_coeff_function, (lc.ugc,)),\n vars_func=(get_vars_function, (i,)),\n op=operator.eq,\n rhs=lc.rhs)\n\n print \"VALS\", lc.get_coeff_function\n print \"VARS\", lc.get_vars_function\n\n adding_constraints.append(lc)\n\n self.add_linear_constraints(adding_constraints)","def compute_loss(self, x, gt):\n loss = sum([torch.mean((out - gt)**2) for out in self.forward(x)])\n return loss","def rule(model):\n ind_i = model.timeslots\n ind_j = model.tasks\n total = sum(model.A[i, j] * (1-self.valid[i, j]) for i in ind_i\n for j in ind_j)\n total += sum(model.A2[i, j] * (1 - self.valid[i, j]) for i in\n ind_i for j in ind_j)\n total += sum(model.A3[i, j] * (1 - self.valid[i, j]) for i in\n ind_i for j in ind_j)\n\n return None, total, 0","def triplet_loss(anchor, positive, negative, alpha):\n\n with tf.variable_scope('triplet_loss'):\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), 1)\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), 1)\n\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\n loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0)\n\n return loss","def rule(model, i, j):\n active = 1-self.task_spread[j]\n den = sum(triu[i, :])\n ind = model.timeslots\n # FIXME(cathywu) can/should be more precise with A,A2,A3 offsets\n total = sum(triu[i, k] * (\n 1 - model.A[k, j] - model.A2[k, j] - model.A3[k, j] - model.A4[\n k, j]) for k in ind)\n total /= den\n total *= active\n # CTu[i,j] = floor(total)\n return -1 + EPS, model.CTu[i, j] - total, EPS + self.slack_cont","def rule(model, d, j0, j1):\n if self.task_after[j0, j1] == 0:\n return Constraint.Feasible\n total = model.T_end[d, j0] - model.T_end[d, j1]\n return 0, total, None","def constraint_sum(w):\n return sum(w) - 1","def nt_transfer_loss(self, student_net_params, masks, teacher_net_params, x, density_level): \n\n masked_student_net_params = get_sparse_params_filtered_by_masks(student_net_params, masks)\n\n # split inputs into two collections, x1 and x2.\n x1 = x[:int(len(x)/2)]\n x2 = x[int(len(x)/2):]\n \n # student network prediction\n student_prediction = self.apply_fn(masked_student_net_params, x) \n \n # teacher network prediction\n teacher_prediction = self.apply_fn(teacher_net_params, x)\n\n # student network's NTK evaluated on x1 and x2\n student_ntk_mat = self.emp_ntk_fn(x1, x2, masked_student_net_params) \n\n # teacher network's NTK evaluated on x1 and x2\n teacher_ntk_mat = self.emp_ntk_fn(x1, x2, teacher_net_params) \n\n # compute kernel, target, and paramter l2 loss\n ker_dist, target_dist, param_squared_norm = self.kernel_dist_target_dist_l2_loss(student_ntk_mat, student_prediction, teacher_ntk_mat, teacher_prediction, masked_student_net_params)\n\n # weight these losses to get the transfer loss\n transfer_loss = self.LAMBDA_KER_DIST * ker_dist + target_dist + (self.LAMBDA_L2_REG / density_level) * param_squared_norm \n\n return transfer_loss","def rule(model, k):\n ind_i = model.timeslots\n ind_i2 = model.timeslots2\n ind_i3 = model.timeslots3\n ind_i4 = model.timeslots4\n ind_j = model.tasks\n cat_k_total = sum(\n model.A[i, j] * self.task_category[j, k] for i in ind_i for j in\n ind_j)\n cat_k_total += 2 * sum(\n model.A2[i, j] * self.task_category[j, k] for i in ind_i2 for j\n in ind_j)\n cat_k_total += 3 * sum(\n model.A3[i, j] * self.task_category[j, k] for i in ind_i3 for j\n in ind_j)\n cat_k_total += 4 * sum(\n model.A4[i, j] * self.task_category[j, k] for i in ind_i4 for j\n in ind_j)\n return model.C_total[k] == cat_k_total","def constraint_loss(self, output: torch.Tensor, sum_reduction: bool = True, mu: int = 10, class_disjunction=True) -> torch.Tensor:\n device = self.get_device()\n output = output.to(device)\n assert self._formulas != [], \"Explanations not passed yet. set_explanation() method needs to be called first.\"\n constraint_loss1 = torch.zeros(output.shape[0], device=device)\n constraint_loss2 = torch.zeros(output.shape[0], device=device)\n disjunction_loss = torch.zeros(output.shape[0], device=device)\n for i in range(len(self.main_classes)):\n class_loss1 = output[:, i]\n for term in self._formulas[i]:\n term_loss = 1\n for (attribute, negated) in term:\n output_attribute = output[:, attribute]\n if negated:\n output_attribute = 1 - output_attribute\n term_loss *= output_attribute\n term_loss = 1 - term_loss\n class_loss1 = class_loss1 * term_loss\n constraint_loss1 += class_loss1\n class_loss2 = 1\n for term in self._formulas[i]:\n term_loss = 1\n for (attribute, negated) in term:\n output_attribute = output[:, attribute]\n if negated:\n output_attribute = 1 - output_attribute\n term_loss *= output_attribute\n class_loss2 *= (1 - term_loss)\n class_loss2 = (1 - class_loss2) * (1 - output[:, i])\n constraint_loss2 += class_loss2\n if class_disjunction:\n for i in range(len(self.main_classes)):\n single_disjunction_loss = 1\n for j in range(len(self.main_classes)):\n if i != j:\n single_disjunction_loss *= (1 - output[:, j])\n disjunction_loss += output[:, i] * (1 - single_disjunction_loss)\n constraint_loss = constraint_loss1 + constraint_loss2 + disjunction_loss\n if sum_reduction:\n return constraint_loss.sum()\n return constraint_loss","def triplet_loss(anchor, positive, negative, margin=0.2):\n distance_ap = tf.reduce_sum(tf.square(anchor - positive), 1)\n distance_an = tf.reduce_sum(tf.square(anchor - negative), 1)\n loss = tf.maximum(0.0, distance_ap - distance_an + margin)\n loss = tf.reduce_mean(loss)\n return loss","def _constraints_variables(self):\n\n def rule(model, k):\n \"\"\"\n Total slots allocated to category k\n \"\"\"\n ind_i = model.timeslots\n ind_i2 = model.timeslots2\n ind_i3 = model.timeslots3\n ind_i4 = model.timeslots4\n ind_j = model.tasks\n cat_k_total = sum(\n model.A[i, j] * self.task_category[j, k] for i in ind_i for j in\n ind_j)\n cat_k_total += 2 * sum(\n model.A2[i, j] * self.task_category[j, k] for i in ind_i2 for j\n in ind_j)\n cat_k_total += 3 * sum(\n model.A3[i, j] * self.task_category[j, k] for i in ind_i3 for j\n in ind_j)\n cat_k_total += 4 * sum(\n model.A4[i, j] * self.task_category[j, k] for i in ind_i4 for j\n in ind_j)\n return model.C_total[k] == cat_k_total\n\n self.model.constrain_cat_duration0 = Constraint(self.model.categories,\n rule=rule)\n\n def rule(model, s, k):\n \"\"\"\n S_cat[s,k] = whether (any tasks of) category k is assigned on day s\n \"\"\"\n den = sum(self.task_category[:, k])\n ind_j = model.tasks\n total = sum(self.task_category[j, k] * model.S[s, j] for j in\n ind_j) / den\n # Desired: S[i,j] = ceil(total)\n # Desired: S[i,j] = 0 if total <= 0; otherwise, S[i,j] = 1\n return -EPS, model.S_cat[s, k] - total, 1 - EPS\n\n self.model.constrain_cat_days0 = Constraint(self.model.dayslots,\n self.model.categories,\n rule=rule)\n\n def rule(model, k):\n \"\"\"\n S_cat_total[k] = number of unique days in which task from\n category k were assigned\n\n More precisely:\n sum_s S_cat[s,k] == S_cat_total[k]\n \"\"\"\n ind_s = model.dayslots\n total = sum(model.S_cat[s, k] for s in ind_s)\n return model.S_cat_total[k] == total\n\n self.model.constrain_cat_days1 = Constraint(self.model.categories,\n rule=rule)","def triplet_loss(y_true, y_pred, alpha = 0.2):\r\n \r\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\r\n \r\n ### START CODE HERE ### (≈ 4 lines)\r\n # Step 1: Compute the (encoding) distance between the anchor and the positive\r\n pos_dist = tf.reduce_sum(tf.square(anchor - positive))\r\n # Step 2: Compute the (encoding) distance between the anchor and the negative\r\n neg_dist = tf.reduce_sum(tf.square(anchor - negative))\r\n # Step 3: subtract the two previous distances and add alpha.\r\n basic_loss = pos_dist - neg_dist + alpha\r\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\r\n loss = tf.maximum(basic_loss, 0)\r\n ### END CODE HERE ###\r\n \r\n return loss","def triplet_loss(y_true, y_pred, alpha = 0.2):\n \n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\n \n ### START CODE HERE ### (≈ 4 lines)\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,positive)),axis=-1)\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,negative)),axis=-1)\n # Step 3: subtract the two previous distances and add alpha.\n basic_loss = pos_dist-neg_dist+alpha\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0))\n ### END CODE HERE ###\n \n return loss","def _constraints_utility(self):\n\n def rule(model):\n total = summation(self.utilities, model.A)\n return model.A_total == total\n\n self.model.constrain_A_total = Constraint(rule=rule)\n\n def rule(model):\n total = 2 * summation(self.utilities, model.A2)\n return model.A2_total == total\n\n self.model.constrain_A2_total = Constraint(rule=rule)\n\n def rule(model):\n total = 3 * summation(self.utilities, model.A3)\n return model.A3_total == total\n\n self.model.constrain_A3_total = Constraint(rule=rule)\n\n def rule(model):\n total = 4 * summation(self.utilities, model.A4)\n return model.A4_total == total\n\n self.model.constrain_A4_total = Constraint(rule=rule)\n\n def rule(model):\n completion_bonus = self.task_completion_bonus * self.task_duration\n total = summation(completion_bonus, model.T_total)\n return model.Completion_total == total\n\n self.model.constrain_completion_total = Constraint(rule=rule)\n\n def rule(model):\n scaling = 0.2\n affinity = np.outer(c.AFFINITY_COGNITIVE, self.task_cognitive_load)\n\n # TODO(cathywu) replace this code when \"simple slicing\" is clarified\n zeros1 = np.zeros((1, self.num_tasks))\n zeros2 = np.zeros((2, self.num_tasks))\n zeros3 = np.zeros((3, self.num_tasks))\n\n total = summation(affinity, model.A)\n total += summation(affinity, model.A2)\n total += summation(affinity, model.A3)\n total += summation(affinity, model.A4)\n\n total += summation(np.vstack((affinity[1:, :], zeros1)), model.A2)\n total += summation(np.vstack((affinity[1:, :], zeros1)), model.A3)\n total += summation(np.vstack((affinity[1:, :], zeros1)), model.A4)\n\n total += summation(np.vstack((affinity[2:, :], zeros2)), model.A3)\n total += summation(np.vstack((affinity[2:, :], zeros2)), model.A4)\n\n total += summation(np.vstack((affinity[3:, :], zeros3)), model.A4)\n total *= scaling\n\n return model.Affinity_cognitive_total == total\n\n self.model.constrain_affinity_cognitive_total = Constraint(rule=rule)","def dual_equal(s, p, g_x_func, Z_0, k=None, P=None, T=None, \n tol=1e-2):\n from numpy import array, zeros_like, zeros\n from scipy.optimize import minimize\n from tgo import tgo\n \n def x_lim(X): # limiting function used in TGO\n import numpy\n return numpy.sum(X, axis=1) - 1.0 <= 0.0\n \n if k == None:\n k = p.m['Valid phases']\n \n # Initialize\n Z_0 = array(Z_0)\n LBD = - 1e300 # -inf\n s.update_state(s, p, X = Z_0, phase = k, Force_Update=True) \n \n # G_p (Primal problem Z_0_i - x_i = 0 for all i):\n UBD = g_x_func(s, p).m['g_mix']['t'] \n Lambda_d = zeros_like(Z_0)\n\n # X bounds used in UBD optimization\n X_bounds = [zeros(shape=(p.m['n']-1)), # Upper bound\n zeros(shape=(p.m['n']-1)) # Lower bound\n ] \n for i in range(p.m['n']-1): \n Sigma_ind = 0.0 # Sum of independent components excluding i\n # (lever rule) \n for j in range(p.m['n']-1):\n if j != i:\n Sigma_ind += Z_0[j]\n\n X_bounds[0][i] = 1.0 - Sigma_ind \n \n # Construct physical bounds x \\in [0, 1] for all independent components\n # (used in differential_evolution)\n Bounds = []\n for i in range(p.m['n'] - 1):\n #Bounds.append((0, 1))\n Bounds.append((1e-5, 0.99999))\n \n # Construct composition container from X_d for all phases. (REMOVED)\n X_d = Z_0\n\n\n #%% Normal calculation of daul problem if Z_0 is unstable.\n while abs(UBD - LBD) >= tol:\n # Solve UBD\n # Update system to new composition.\n # (Comp. invariant in UBD)\n s.update_state(s, p, X = X_d , phase = k, Force_Update=True) \n Lambda_sol = minimize(ubd, Lambda_d, method='L-BFGS-B', \n args=(g_x_func, X_d, Z_0, s, p, X_bounds,\n k))['x']\n \n Lambda_d = array(Lambda_sol) # If float convert back to 1x1 array\n \n # NOTE: NEGATIVE THE MAX DEFINED PROBLEM:\n UBD = -ubd(Lambda_d, g_x_func, X_d, Z_0, s, p, X_bounds, k)\n\n X_sol = tgo(lbd, Bounds, args=(g_x_func, Lambda_d, Z_0, s, p, k),\n g_func=x_lim,\n n = 100,\n skip=2)\n # Solve LBD \n LBD = lbd(X_sol, g_x_func, Lambda_d, Z_0, s, p, k) \n X_d = X_sol\n # End\n \n\n if False: # Print results optional\n print 'Final UBD = {}'.format(UBD)\n print 'Final LBD = {}'.format(LBD)\n print 'Final UBD - LBD = {}'.format(UBD - LBD)\n print 'Final Z_eq = {}'.format(X_d)\n print 'Final Lambda_d = {}'.format(Lambda_d)\n \n # Returns\n s.m['Z_eq'] = X_d\n s.m['Lambda_d'] = Lambda_d\n return s","def test_penalty_compute(self):\n objective = {'G': numpy.zeros((9)),\n 'H': numpy.diag((1,)*9),\n 'X': 1}\n for penalty in self.penalties:\n result = penalty.compute([1]*self.np, objective)\n assert isinstance(result,tuple)\n # more tests go here","def triplet_loss(y_true, y_pred, alpha = 0.2):\r\n \r\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\r\n \r\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\r\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\r\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\r\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\r\n # Step 3: subtract the two previous distances and add alpha.\r\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\r\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\r\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0))\r\n # END CODE HERE \r\n \r\n return loss","def rule(model, p, k):\n if self.category_daily_caps[k] < 0:\n return Constraint.Feasible\n ind_i = model.timeslots\n ind_j = model.tasks\n total = sum(diag[p, i] * self.task_category[j, k] * (\n model.A[i, j] + 2 * model.A2[i, j] + 3 * model.A3[i, j] + 4 *\n model.A4[i, j]) for i in ind_i for j in ind_j)\n return None, total, self.category_daily_caps[k]","def power_output_candidate_thermal_rule(_m, g, y, s, t):\r\n\r\n if y != m.Y.last() and t != m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\r\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\r\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n elif y != m.Y.last() and t == m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\r\n + m.sigma_20[g, y, s, t]\r\n - m.sigma_23[g, y, s, t]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n elif y == m.Y.last() and t != m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\r\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\r\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n elif y == m.Y.last() and t == m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\r\n + m.sigma_20[g, y, s, t]\r\n - m.sigma_23[g, y, s, t]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n else:\r\n raise Exception(f'Unhandled case: {g, y, s, t}')","def test_tensor_composite_constraints_equal_penalties():\n from pygam.penalties import derivative\n\n def der1(*args, **kwargs):\n kwargs.update({'derivative':1})\n return derivative(*args, **kwargs)\n\n # create a 3D tensor where the penalty should be equal to the constraint\n term = te(0, 1, 2,\n n_splines=[4, 5, 6],\n penalties=der1,\n lam=1,\n constraints='monotonic_inc')\n\n # check all the dimensions\n for i in range(3):\n P = term._build_marginal_penalties(i).A\n C = term._build_marginal_constraints(i,\n -np.arange(term.n_coefs),\n constraint_lam=1,\n constraint_l2=0).A\n\n assert (P == C).all()","def rule(model, j):\n ind_i = model.timeslots\n if self.task_chunk_min[j] == 2:\n total = sum(model.A[i, j] for i in ind_i)\n return None, total, 0\n elif self.task_chunk_min[j] == 3:\n total = sum(model.A[i, j] + model.A2[i, j] for i in ind_i)\n return None, total, 0\n elif self.task_chunk_min[j] >= 4:\n total = sum(\n model.A[i, j] + model.A2[i, j] + model.A3[i, j] for i in\n ind_i)\n return None, total, 0\n return Constraint.Feasible","def structured_loss(predict, frame_mask, label_weight, tp_weight, fp_weight, num_false_neg):\n # tp_weight = torch.autograd.Variable(torch.Tensor(tp_weight), requires_grad=False).cuda()\n # fp_weight = torch.autograd.Variable(torch.Tensor(fp_weight), requires_grad=False).cuda()\n tp_weight = torch.tensor(tp_weight, requires_grad=False).cuda()\n fp_weight = torch.tensor(fp_weight, requires_grad=False).cuda()\n tp_mask = torch.tensor(\n tp_weight > 0, dtype=torch.float32, requires_grad=False).cuda()\n\n # tp_cost = (tp_mask - tp_weight * predict) * label_weight * frame_mask\n tp_cost = tp_weight * -predict * label_weight * frame_mask\n fp_cost = fp_weight * predict * frame_mask\n\n tp_cost = tp_cost.sum(2).sum(0).view(-1)\n fp_cost = fp_cost.sum(2).sum(0).view(-1)\n\n fn_cost = torch.autograd.Variable(\n torch.Tensor(num_false_neg), requires_grad=False).cuda()\n\n return tp_cost, fp_cost, fn_cost","def compute_loss(self):","def loss_tv(self, mask, y_comp):\n\n # Create dilated hole region using a 3x3 kernel of all 1s.\n kernel = K.ones(shape=(3, 3, mask.shape[3], mask.shape[3]))\n dilated_mask = K.conv2d(1-mask, kernel, data_format='channels_last', padding='same')\n\n # Cast values to be [0., 1.], and compute dilated hole region of y_comp\n dilated_mask = K.cast(K.greater(dilated_mask, 0), 'float32')\n P = dilated_mask * y_comp\n\n # Calculate total variation loss\n a = self.l1(P[:,1:,:,:], P[:,:-1,:,:])\n b = self.l1(P[:,:,1:,:], P[:,:,:-1,:]) \n return a+b","def rule(model, i, j):\n return 1, model.T0_end[i, j] + (1-model.A[i, j]), None","def _create_loss(self):\n\n with tf.name_scope(\"loss\"):\n \n # gini=(tf.nn.l2_loss( self.score))/100000\n gini = tf.losses.softmax_cross_entropy(self.score, 0*self.score)\n \n promo_prob=tf.reduce_sum(tf.multiply(self.score, self.cohort_weight),\n axis=1)\n inc_value = tf.reduce_mean(tf.multiply(promo_prob, self.value))- self.control_value\n inc_cost = tf.reduce_mean( tf.multiply(promo_prob, self.cost)) - self.control_cost\n \n\n\n # determine loss function based on self.obj_rule\n if self.obj_rule == 'cpiv':\n self.objective = inc_cost / inc_value\n\n elif self.obj_rule == 'ivc':\n # maximize ivc\n self.objective = - inc_value / inc_cost\n\n elif self.obj_rule == 'lagrangian':\n assert self.shadow is not None, 'Need to pass in shadow value if use lagrangian as obj_rule.'\n self.objective = inc_cost - self.shadow * inc_value\n\n elif self.obj_rule == 'value':\n # maximize delta values\n self.objective = - inc_value\n\n # use only cost as objective\n elif self.obj_rule == 'cost':\n # maximize delta cost\n self.objective = - inc_cost\n\n else:\n raise Exception('Invalid obj_rule!')\n\n # regularization\n reg_loss = tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\n # weights = tf.trainable_variables() # all vars of your graph\n # reg_loss = tf.norm( weights,ord=1)\n\n # final loss\n self.loss = self.objective +reg_loss+.1*gini","def rule(model, d, i, j):\n off = d * 48\n num = np.arange(self.num_timeslots / 7)\n total = model.A[i + off, j] * num[i]\n return 0, model.T_end[d, j] - total, None","def triplet_loss(anchor, positive, negative, alpha = my_alpha):\r\n delta_1 = tf.reduce_sum(tf.square(anchor - positive)) #square of euclidean distance or L2 norm\r\n delta_2 = tf.reduce_sum(tf.square(anchor - negative))\r\n loss = tf.maximum(delta_1 - delta_2 + alpha, tf.constant(0, dtype = tf.float32))\r\n return loss","def rule(model, j):\n ind_i = model.timeslots\n if self.task_chunk_max[j] <= 1:\n total = sum(\n model.A2[i, j] + model.A3[i, j] + model.A4[i, j] for i in\n ind_i)\n return None, total, 0\n elif self.task_chunk_max[j] <= 2:\n total = sum(model.A3[i, j] + model.A4[i, j] for i in ind_i)\n return None, total, 0\n elif self.task_chunk_max[j] <= 3:\n total = sum(model.A4[i, j] for i in ind_i)\n return None, total, 0\n return Constraint.Feasible","def triplet_loss_network(input_shape):\n model = base_model(input_shape)\n\n # input layer for anchor, positive and negative branches\n input_anchor = Input(input_shape)\n input_positive = Input(input_shape)\n input_negative = Input(input_shape)\n\n # init the anchor model, positive model and negative model (three base_model())\n anchor_model = model(input_anchor)\n positive_model = model(input_positive)\n negative_model = model(input_negative)\n\n triplet_loss_model = keras.Model(inputs=[input_anchor, input_positive, input_negative], outputs=[anchor_model, positive_model, negative_model], name=\"triplet_loss_network\")\n\n return triplet_loss_model","def dual_objective_expression_rule(_m):\r\n\r\n # Build limits\r\n t_1 = sum(- (m.mu_2[z, y] * m.SOLAR_BUILD_LIMITS[z]) - (m.mu_3[z, y] * m.WIND_BUILD_LIMITS[z]) - (\r\n m.mu_4[z, y] * m.STORAGE_BUILD_LIMITS[z]) for z in m.Z for y in m.Y)\r\n\r\n # Min power output\r\n t_2 = sum(\r\n m.sigma_1[g, y, s, t] * m.P_MIN[g] for g in m.G.difference(m.G_STORAGE) for y in m.Y for s in m.S for t\r\n in m.T)\r\n\r\n # Max power - existing generators\r\n t_3 = sum(\r\n - m.sigma_2[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_THERM for y in m.Y for s in m.S\r\n for t in m.T)\r\n\r\n # Max power - existing wind\r\n t_4 = sum(\r\n - m.sigma_4[g, y, s, t] * m.Q_W[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_WIND for y in\r\n m.Y for s in m.S for t in m.T)\r\n\r\n # Max power - existing solar\r\n t_5 = sum(\r\n - m.sigma_6[g, y, s, t] * m.Q_S[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_SOLAR for y in\r\n m.Y for s in m.S for t in m.T)\r\n\r\n # Max power - existing hydro\r\n t_6 = sum(\r\n - m.sigma_8[g, y, s, t] * m.P_H[g, y, s, t] * (1 - m.F[g, y]) for g in m.G_E_HYDRO for y in m.Y for s in\r\n m.S for t in m.T)\r\n\r\n # Max charging power - existing storage\r\n t_7 = sum(\r\n - m.sigma_11[g, y, s, t] * m.P_IN_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_STORAGE for y in m.Y for s in\r\n m.S for t in m.T)\r\n\r\n # Max discharging power - existing storage\r\n t_8 = sum(\r\n - m.sigma_13[g, y, s, t] * m.P_OUT_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_STORAGE for y in m.Y for s in\r\n m.S for t in m.T)\r\n\r\n # Max energy - existing storage units\r\n t_9 = sum(\r\n - m.sigma_16[g, y, s, t] * m.Q_MAX[g] for g in m.G_E_STORAGE for y in m.Y for s in m.S for t in m.T)\r\n\r\n # Min energy - interval end\r\n t_10 = sum(m.sigma_18[g, y, s] * m.Q_END_MIN[g] for g in m.G_STORAGE for y in m.Y for s in m.S)\r\n\r\n # Max energy - interval end\r\n t_11 = sum(- m.sigma_19[g, y, s] * m.Q_END_MAX[g] for g in m.G_STORAGE for y in m.Y for s in m.S)\r\n\r\n # Ramp-up constraint - generators\r\n t_12 = sum(\r\n - m.sigma_20[g, y, s, t] * m.RR_UP[g] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for s in m.S\r\n for t in m.T)\r\n\r\n # Ramp-up constraint - initial power output - generators\r\n t_13 = sum(\r\n - m.sigma_20[g, y, s, m.T.first()] * m.P0[g, y, s] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y\r\n for s in m.S)\r\n\r\n # Ramp-down constraint - generators\r\n t_18 = sum(\r\n - m.sigma_23[g, y, s, t] * m.RR_DOWN[g] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for s in m.S\r\n for t in m.T)\r\n\r\n # Ramp-down constraint - initial power output - generators\r\n t_19 = sum(\r\n m.sigma_23[g, y, s, m.T.first()] * m.P0[g, y, s] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for\r\n s in m.S)\r\n\r\n # Min powerflow\r\n t_24 = sum(m.sigma_27[l, y, s, t] * m.POWERFLOW_MIN[l] for l in m.L for y in m.Y for s in m.S for t in m.T)\r\n\r\n # Max powerflow\r\n t_25 = sum(\r\n - m.sigma_28[l, y, s, t] * m.POWERFLOW_MAX[l] for l in m.L for y in m.Y for s in m.S for t in m.T)\r\n\r\n # Demand\r\n t_26 = sum(m.lamb[z, y, s, t] * m.DEMAND[z, y, s, t] for z in m.Z for y in m.Y for s in m.S for t in m.T)\r\n\r\n # Initial storage unit energy\r\n t_27 = sum(m.zeta_1[g, y, s, m.T.first()] * m.Q0[g, y, s] for g in m.G_STORAGE for y in m.Y for s in m.S)\r\n\r\n return (t_1 + t_2 + t_3 + t_4 + t_5 + t_6 + t_7 + t_8 + t_9 + t_10 + t_11 + t_12 + t_13 + t_18 + t_19 + t_24\r\n + t_25 + t_26 + t_27)","def gen1_constraint(model):\n return 10, model.g[1], 50","def bpr_triplet_loss(data):\n positive_item_latent, negative_item_latent, user_latent = data\n\n positive_interactions = tf.math.reduce_sum(tf.math.multiply(user_latent,\n positive_item_latent),\n axis=-1,\n keepdims=True)\n negative_interactions = tf.math.reduce_sum(tf.math.multiply(user_latent,\n negative_item_latent),\n axis=-1,\n keepdims=True)\n\n return tf.math.subtract(tf.constant(1.0),\n tf.sigmoid(tf.math.subtract(positive_interactions,\n negative_interactions)))","def power_output_hydro_rule(_m, g, y, s, t):\r\n\r\n if y != m.Y.last() and t != m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_8[g, y, s, t]\r\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\r\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + (m.DELTA[y] * m.RHO[y, s] * m.C_MC[g, y])\r\n == 0)\r\n\r\n elif y != m.Y.last() and t == m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_8[g, y, s, t]\r\n + m.sigma_20[g, y, s, t]\r\n - m.sigma_23[g, y, s, t]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + (m.DELTA[y] * m.RHO[y, s] * m.C_MC[g, y])\r\n == 0)\r\n\r\n elif y == m.Y.last() and t != m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_8[g, y, s, t]\r\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\r\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + (m.DELTA[y] * m.RHO[y, s] * (1 + (1 / m.INTEREST_RATE)) * m.C_MC[g, y])\r\n == 0)\r\n\r\n elif y == m.Y.last() and t == m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_8[g, y, s, t]\r\n + m.sigma_20[g, y, s, t]\r\n - m.sigma_23[g, y, s, t]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + (m.DELTA[y] * m.RHO[y, s] * (1 + (1 / m.INTEREST_RATE)) * m.C_MC[g, y])\r\n == 0)\r\n\r\n else:\r\n raise Exception(f'Unexpected case: {g, y, s, t}')","def power_output_existing_thermal_rule(_m, g, y, s, t):\r\n\r\n if y != m.Y.last() and t != m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_2[g, y, s, t]\r\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\r\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n elif y != m.Y.last() and t == m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_2[g, y, s, t]\r\n + m.sigma_20[g, y, s, t]\r\n - m.sigma_23[g, y, s, t]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n elif y == m.Y.last() and t != m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_2[g, y, s, t]\r\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\r\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n elif y == m.Y.last() and t == m.T.last():\r\n return (- m.sigma_1[g, y, s, t] + m.sigma_2[g, y, s, t]\r\n + m.sigma_20[g, y, s, t]\r\n - m.sigma_23[g, y, s, t]\r\n - m.lamb[self.k(m, g), y, s, t]\r\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\r\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\r\n == 0)\r\n\r\n else:\r\n raise Exception(f'Unhandled case: {g, y, s, t}')","def triplet_loss(y_true, y_pred, alpha=0.5):\n print('y_pred.shape = ', y_pred)\n\n total_lenght = y_pred.shape.as_list()[-1]\n # print('total_lenght=', total_lenght)\n # total_lenght =12\n\n anchor = y_pred[:, 0:int(total_lenght * 1 / 3)]\n positive = y_pred[:, int(total_lenght * 1 / 3):int(total_lenght * 2 / 3)]\n negative = y_pred[:, int(total_lenght * 2 / 3):int(total_lenght * 3 / 3)]\n\n # distance between the anchor and the positive\n pos_dist = K.sum(K.square(anchor - positive), axis=1)\n\n # distance between the anchor and the negative\n neg_dist = K.sum(K.square(anchor - negative), axis=1)\n\n # compute loss\n basic_loss = pos_dist - neg_dist + alpha\n loss = tf.reduce_mean(K.maximum(basic_loss, 0.0))\n\n return loss","def triplet_loss(y_true, y_pred, alpha=0.2):\n\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\n\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=None, keep_dims=True)\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=None, keep_dims=True)\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0), axis=0)\n\n return loss","def getConstraint(self):\n return self.gk, self.g_mink, self.g_maxk","def solve(num_wizards, num_constraints, wizards, constraints):\n\n # print(num_wizards)\n # print(num_constraints)\n # print(wizards)\n # print(constraints)\n # node_set = set(wizards)\n \n\n\n def cost(sol,num_constraints,constraints):\n constraints_satisfied = 0\n constraints_failed = []\n output_ordering_map = {k: v for v, k in enumerate(sol)}\n for c in constraints:\n\n m = output_ordering_map # Creating an alias for easy reference\n\n wiz_a = m[c[0]]\n wiz_b = m[c[1]]\n wiz_mid = m[c[2]]\n\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\n constraints_failed.append(c)\n else:\n constraints_satisfied += 1\n return num_constraints - constraints_satisfied\n\n def neighbors(sol):\n wiz1 = random.randint(0,num_wizards-1)\n wiz2 = random.randint(0,num_wizards-1)\n\n new_sol = copy.copy(sol)\n temp = new_sol[wiz1]\n new_sol[wiz1] = new_sol[wiz2]\n new_sol[wiz2] = temp\n \n return new_sol\n\n def acceptance_probability(old_cost,new_cost,T):\n exponent = (old_cost - new_cost) / T\n \n try:\n ans = math.exp(exponent)\n except OverflowError:\n ans = float('inf')\n return ans\n\n\n def anneal(solution, num_constraints, constraints):\n old_cost = 0\n new_cost = 0\n old_cost = cost(solution,num_constraints,constraints)\n T = 1.0\n T_min = 0.000001\n alpha = 0.98\n while T > T_min:\n i = 1\n while i <= 1000:\n new_solution = neighbors(solution)\n new_cost = cost(new_solution,num_constraints,constraints)\n if new_cost == 0:\n return new_solution,new_cost\n ap = acceptance_probability(old_cost, new_cost, T)\n if ap > random.random():\n solution = new_solution\n old_cost = new_cost\n i += 1\n T = T*alpha\n return solution, old_cost\n\n s = copy.copy(wizards)\n random.shuffle(s)\n ret = anneal(s,num_constraints,constraints)\n \n for i in range(10):\n if ret[1] == 0:\n break\n random.shuffle(s)\n new_ret = anneal(s,num_constraints,constraints)\n print(i)\n if new_ret[1] < ret[1]:\n ret = new_ret\n print(\"constraints failed: {0}\".format(ret[1]))\n return ret[0]","def regularization_loss(params: hk.Params) -> jnp.ndarray:\r\n\r\n # L1 Loss\r\n sum_in_layer = lambda p: jnp.sum(jnp.abs(p))\r\n sum_p_layers = [sum_in_layer(p) for p in jax.tree_leaves(params)]\r\n l1_loss = sum(sum_p_layers)\r\n\r\n # L2 Loss\r\n l2_loss = 0.5 * sum(jnp.sum(jnp.square(p)) for p in jax.tree_leaves(params))\r\n\r\n return l2_coef * l2_loss + l1_coef * l1_loss","def loss_function(self, prbs, labels, mask):\n\t\t# Using boolean mask\n\t\tloss = tf.keras.losses.sparse_categorical_crossentropy(labels, prbs)\n\t\tsum_loss = tf.reduce_sum(tf.boolean_mask(loss, mask))\n\n\t\treturn sum_loss","def compute_triplet_loss(y_pred, margin=0.2):\n anchor_feature, positive_feature, negative_feature = y_pred\n\n with tf.name_scope(\"triplet_loss\"):\n d_p_squared = tf.square(compute_euclidean_distance(anchor_feature, positive_feature))\n d_n_squared = tf.square(compute_euclidean_distance(anchor_feature, negative_feature))\n\n loss = tf.maximum(0., d_p_squared - d_n_squared + margin)\n #loss = d_p_squared - d_n_squared + margin\n\n return tf.reduce_mean(loss), tf.reduce_mean(d_p_squared), tf.reduce_mean(d_n_squared)","def objective_constraints(self, variables, mask, load, generation, reservations=None):\n constraint_list = []\n constraint_list += [cvx.NonPos(-variables['regu_c'])]\n constraint_list += [cvx.NonPos(-variables['regd_c'])]\n constraint_list += [cvx.NonPos(-variables['regu_d'])]\n constraint_list += [cvx.NonPos(-variables['regd_d'])]\n # p = opt_vars['dis'] - opt_vars['ch']\n # constraint_list += [cvx.NonPos(opt_vars['regd_d'] - cvx.pos(p))]\n # constraint_list += [cvx.NonPos(opt_vars['regu_c'] - cvx.neg(p))]\n if self.combined_market:\n constraint_list += [cvx.Zero(variables['regd_d'] + variables['regd_c'] - variables['regu_d'] - variables['regu_c'])]\n\n return constraint_list","def gen2_constraint(model):\n return 20, model.g[2], 100","def shape_loss(self, pred_vertices, gt_vertices, has_smpl):\n pred_vertices_with_shape = pred_vertices[has_smpl == 1]\n gt_vertices_with_shape = gt_vertices[has_smpl == 1]\n if len(gt_vertices_with_shape) > 0:\n return self.criterion_shape(pred_vertices_with_shape, gt_vertices_with_shape)\n else:\n return torch.FloatTensor(1).fill_(0.).to(self.device)","def rule(model, d, i, j):\n off = d * 48\n num = np.arange(self.num_timeslots / 7)\n total = (model.T_end[d, j] - num[i] + 1) / 48\n return -EPS, model.T0_end[i + off, j] - total, 1 - EPS","def mse_loss(angles_gt, angles_gen):\n loss = (angles_gt - angles_gen)**2\n # loss = torch.sum(loss, dim=-1) # sum loss over dimensions\n loss = torch.mean(loss, dim=-1) # mean loss over images per task\n loss = torch.mean(loss, dim=-1) # mean loss over tasks\n return loss","def main_constraints(self, batch, l_suff_stats):\n\n if self.mode == 'parametric':\n kl = 'i-projection'\n else:\n kl = 'm-projection'\n policy = self.mc.get('policy', target=False)\n t_states = torch.Tensor(batch.states)\n t_policy = self.mc.get('policy', target=True)\n target_suff_stats = t_policy.forward(t_states).detach()\n\n # split constraint if wanted\n if self.split_constraint:\n\n num_dims = target_suff_stats.size()[1]\n constraints = []\n for d in range(num_dims):\n c = (self.v[d] - policy.kl_divergence(batch, l_suff_stats[d+1], kl, 'mean'))\n constraints.append(c)\n\n else:\n constraints = [(self.v[0] - policy.kl_divergence(batch, l_suff_stats[0], kl, 'mean'))]\n\n return constraints","def triplet_loss(y_true, y_pred, alpha = 0.3):\n \n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\n \n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\n # Step 3: subtract the two previous distances and add alpha(learning variable).\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0))\n \n return loss","def get_GNS_cut_reduced(self):\n # we build the optimization around the casted digraph instead of multidigraph\n # for simplicity\n G = self.base_digraph\n s_1 = self.sources[0]\n s_2 = self.sources[1]\n t_1 = self.destinations[0]\n t_2 = self.destinations[1]\n edges = G.edges()\n nodes = G.nodes()\n\n try:\n\n # Great an gurobi instance of the optimization model\n m = Model(\"GNS\")\n m.setParam('OutputFlag', False)\n\n x_v = {}\n # vertex variables for s_1, t_1 cut\n for v in nodes:\n x_v[v] = m.addVar(vtype=GRB.BINARY)\n\n y_v = {}\n # vertex variables for s_2, t_2 cut\n for v in nodes:\n y_v[v] = m.addVar(vtype=GRB.BINARY)\n\n z_v = {}\n # vertex variables for s_2, t_1 cut\n for v in nodes:\n z_v[v] = m.addVar(vtype=GRB.BINARY)\n\n e = {}\n # GNS indicator variable\n for (u,v) in edges:\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\n\n # Done with decision variable creation\n # update model\n m.update()\n\n # Constraints\n # 1. Constraints for s_1 - t_1 cut\n for (u,v) in edges:\n if (u,v) == (s_1, t_1):\n m.addConstr(e[u,v] >= 1)\n elif u == s_1:\n m.addConstr(x_v[v] + e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-x_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(x_v[v] - x_v[u] + e[u,v] >= 0)\n\n if (u,v) == (s_2, t_2):\n m.addConstr(e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(y_v[v] + e[u,v] >= 1)\n elif v == t_2:\n m.addConstr(-y_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(y_v[v] - y_v[u] + e[u,v] >= 0)\n\n if (u,v) == (s_2, t_1):\n m.addConstr(e[u,v] >= 1)\n elif u == s_2:\n m.addConstr(z_v[v] + e[u,v] >= 1)\n elif v == t_1:\n m.addConstr(-z_v[u] + e[u,v] >= 0)\n else:\n m.addConstr(z_v[v] - z_v[u] + e[u,v] >= 0)\n\n m.optimize()\n\n if m.status == GRB.status.OPTIMAL:\n #print \"Min GNS cut value = \" + str(m.objVal)\n #print \"GNS cut edges:\"\n cut_set_edges = []\n for u,v in edges:\n if e[u,v].x != 0:\n #print (u,v), str(G[u][v]['capacity'])\n cut_set_edges.append((u,v, G[u][v]['capacity']))\n return (m.objVal, cut_set_edges)\n else:\n # something went wrong...err...\n print \"Something was wrong\"\n return None, None\n\n except GurobiError:\n print ('Error report from Gurobi')","def loss_total(self, mask):\n\n def loss(y_true, y_pred):\n\n # Compute predicted image with non-hole pixels set to ground truth\n y_comp = mask * y_true + (1-mask) * y_pred\n\n # Compute the vgg features. \n if self.vgg_device:\n with tf.device(self.vgg_device):\n vgg_out = self.vgg(y_pred)\n vgg_gt = self.vgg(y_true)\n vgg_comp = self.vgg(y_comp)\n else:\n vgg_out = self.vgg(y_pred)\n vgg_gt = self.vgg(y_true)\n vgg_comp = self.vgg(y_comp)\n \n # Compute loss components\n l1 = self.loss_valid(mask, y_true, y_pred)\n l2 = self.loss_hole(mask, y_true, y_pred)\n l3 = self.loss_perceptual(vgg_out, vgg_gt, vgg_comp)\n l4 = self.loss_tv(mask, y_comp)\n l5 = - 0.5 * K.sum(1 + self.z_log_var -self.cl - K.square(self.z_mean)/K.exp(self.cl) - K.exp(self.z_log_var)/K.exp(self.cl))\n # Return loss function\n return l1 + 6*l2 + 0.05*l3 + 0.1*l4 +l5 \n return loss","def eta_l(self, children, coef_t, coef_r):\n with tf.compat.v1.name_scope('coef_l'):\n children = tf.cast(children, tf.float32)\n batch_size = tf.shape(input=children)[0]\n max_tree_size = tf.shape(input=children)[1]\n # creates a mask of 1's and 0's where 1 means there is a child there\n # has shape (batch_size x max_tree_size x max_children + 1)\n mask = tf.concat(\n [tf.zeros((batch_size, max_tree_size, 1)),\n tf.minimum(children, tf.ones(tf.shape(input=children)))],\n axis=2,\n name='mask'\n )\n\n # eta_l is shape (batch_size x max_tree_size x max_children + 1)\n return tf.multiply(\n tf.multiply((1.0 - coef_t), (1.0 - coef_r)), mask, name='coef_l'\n )\n\n # def aggregation_layer(self, nodes_representation, w_attention):\n # nodes_representation is (batch_size, max_graph_size, self.node_dim)\n \n # with tf.compat.v1.name_scope(\"global_attention\"):\n # batch_size = tf.shape(input=nodes_representation)[0]\n # max_tree_size = tf.shape(input=nodes_representation)[1]\n\n # (batch_size * max_graph_size, self.node_dim)\n # flat_nodes_representation = tf.reshape(nodes_representation, [-1, self.node_dim])\n # aggregated_vector = tf.matmul(flat_nodes_representation, w_attention)\n\n # attention_score = tf.reshape(aggregated_vector, [-1, max_tree_size, 1])\n\n \"\"\"A note here: softmax will distributed the weights to all of the nodes (sum of node weghts = 1),\n an interesting finding is that for some nodes, the attention score will be very very small, i.e e-12, \n thus making parts of aggregated vector becomes near zero and affect on the learning (very slow nodes_representationergence\n - Better to use sigmoid\"\"\"\n\n \n # attention_weights = tf.nn.softmax(attention_score, axis=1)\n \n # attention_weights = tf.nn.sigmoid(attention_score)\n\n # TODO: reduce_max vs reduce_sum vs reduce_mean\n # if aggregation_type == 1:\n # print(\"Using tf.reduce_sum...........\")\n # weighted_average_nodes = tf.reduce_sum(input_tensor=tf.multiply(nodes_representation, attention_weights), axis=1)\n # if aggregation_type == 2:\n # print(\"Using tf.reduce_max...........\")\n # weighted_average_nodes = tf.reduce_max(tf.multiply(nodes_representation, attention_weights), axis=1)\n # if aggregation_type == 3:\n # print(\"Using tf.reduce_mean...........\")\n # weighted_average_nodes = tf.reduce_mean(tf.multiply(nodes_representation, attention_weights), axis=1)\n\n # return weighted_average_nodes, attention_weights","def triplet_loss(y_true, y_pred, alpha = 0.2):\n \n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\n # Step 3: subtract the two previous distances and add alpha.\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0))\n \n return loss","def __call__(self, box_outputs, labels):\n with tf.name_scope('rpn_loss'):\n levels = sorted(box_outputs.keys())\n\n box_losses = []\n for level in levels:\n box_losses.append(self._rpn_box_loss(box_outputs[level], labels[level]))\n\n # Sum per level losses to total loss.\n return tf.add_n(box_losses)","def loss_fn(self, recons, inputs, mu, log_var, **kwargs):\n# kld_weight = kwargs['M_N'] # Account for the minibatch samples from the dataset\n recons_loss = F.mse_loss(recons, inputs)\n# recons_loss = F.binary_cross_entropy(recons, inputs)\n KLD = torch.mean(-0.5 * torch.sum(1 + log_var - mu**2 - log_var.exp(), dim=1), dim=0)\n loss = recons_loss - KLD\n return loss, recons_loss, KLD","def compute_triplet_loss(anchor_feature, positive_feature, negative_feature, margin):\n\n with tf.variable_scope('triplet_loss'):\n pos_dist = compute_euclidean_distance(anchor_feature, positive_feature, positive=True)\n neg_dist = compute_euclidean_distance(anchor_feature, negative_feature, positive=False)\n\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), margin)\n loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0)\n\n return loss, tf.reduce_mean(pos_dist), tf.reduce_mean(neg_dist)","def gen_gp_loss(gp):\n def loss(_, H):\n dlik_dh_times_H = H * K.gather(gp.dlik_dh, gp.batch_ids[:gp.batch_sz])\n return K.sum(dlik_dh_times_H, axis=1, keepdims=True)\n return loss","def s_penalty(self, triples, nodes):\n\n s_index, p_index, o_index = split_spo(triples)\n\n s, p, o = nodes[s_index, :], self.relations[p_index, :], nodes[o_index, :]\n\n return s.pow(2).mean() + p.pow(2).mean() + o.pow(2).mean()","def loss_fn(self, lbl, y):\n\n binlbl = self._to_device(lbl[:,0]>.5)\n # center = self._to_device(lbl[:,3]) \n offset = 5. * self._to_device(lbl[:,1:]) \n\n loss = self.criterion(y[:,:2], offset) \n loss2 = self.criterion2(y[:,2], binlbl)\n\n # loss3 = self.criterion(y[:,3], center)\n\n loss = loss + loss2\n return loss","def vertex_loss(self, pred_vertices, gt_vertices, has_smpl):\n conf = has_smpl.float()\n loss_vertex = self.criterion_vertex(pred_vertices, gt_vertices)\n loss_vertex = (conf[:, None, None] * loss_vertex).mean()\n return loss_vertex","def constraints(self) -> Tuple[NDArray, NDArray]:","def G(self, (k,t), (j,x), **params):\n d = len(x)/2\n q,dq = x[:d],x[d:]\n J = (j == True)\n _J = np.logical_not(J)\n # number of constraints\n n = len(J) \n # number of active constraints\n m = np.sum(J) # = n - len(a)\n a = self.a( (k,t), (_J,q), **params)\n lambda_ = self.lambda_( (k,t), (J,q,dq), **params)\n # unilateral constraint forces\n lambda_ = lambda_[:m] \n g = np.nan*np.zeros(n)\n g[_J] = a\n g[J] = lambda_\n return g","def triplet_loss(y_true, y_pred, margin = 1):\n\n anchor = y_pred[0]\n positive = y_pred[1]\n negative = y_pred[2]\n\n # squared distance between the anchor and the positive\n pos_dist = tf.math.reduce_sum(tf.math.square(anchor - positive), axis=-1)\n\n # squared distance between the anchor and the negative\n neg_dist = tf.math.reduce_sum(tf.math.square(anchor - negative), axis=-1)\n\n # compute loss\n basic_loss = margin + pos_dist - neg_dist\n loss = tf.math.maximum(basic_loss,0.0)\n loss = tf.math.reduce_mean(loss)\n return loss","def l1_regularization(variables, factor=1e-4, name='l1_regularization', collections=['regularization']):\n l1 = tf.add_n([tf.reduce_sum(tf.abs(var)) for var in variables], name=name) if variables else tf.constant(0.)\n loss = factor * l1\n scalar_summary(loss, name, collections)\n return loss","def ridge_regression(y, tx, lambda_):\n N = tx.shape[0]\n a = tx.T.dot(tx) + 2 * N * lambda_ * np.identity(tx.shape[1])\n b = tx.T.dot(y)\n w = np.linalg.solve(a, b)\n loss = compute_loss_LS(y, tx, w) \n return loss, w","def prediction_aggregation(self, xt_s,mu_s,var_s, method='PoE', weighting='uniform', power=26):\n\n nt = xt_s.shape[0]\n mu = np.zeros([nt, self.C],dtype='float64')\n var = np.zeros([nt, self.C],dtype='float64')\n\n prior_var = self.experts[0].kernel(xt_s[0], xt_s[0])\n\n \n #Process each latent gp individually \n for j in range(self.C):\n \n mu_s_c = mu_s[:, :, j]\n var_s_c = var_s[:, :, j]\n \n weight_matrix = compute_weights(mu_s_c, var_s_c, power, weighting, prior_var)\n \n prec_s= 1/var_s_c\n\n if method == 'PoE':\n \n prec = tf.reduce_sum(prec_s, axis=0)\n \n\n if method == 'gPoE':\n \n weight_matrix = normalize_weights(weight_matrix)\n\n prec = tf.reduce_sum(weight_matrix * prec_s , axis=0)\n \n\n if method == 'BCM':\n \n prec = tf.reduce_sum(prec_s, axis=0) + (1 - self.M) / prior_var \n\n if method == 'rBCM':\n \n \n prec = tf.reduce_sum(weight_matrix * prec_s, axis=0) \\\n + (1 - tf.reduce_sum(weight_matrix, axis=0)) / prior_var\n \n \n \n if method != 'bar':\n \n var[:, j] = 1 / prec\n\n mu[:, j] = var[:, j] * tf.reduce_sum(weight_matrix * prec_s * mu_s_c, axis=0)\n \n else:\n \n weight_matrix = normalize_weights(weight_matrix)\n\n mu[:, j] = tf.reduce_sum(weight_matrix * mu_s_c, axis=0)\n var[:, j] = tf.reduce_sum(weight_matrix * var_s_c, axis=0)\n \n \n return self.lik_aggregation(mu, var)","def scenario_cost_rule(_m, y, s):\r\n\r\n return m.OP_T[y, s] + m.OP_H[y, s] + m.OP_W[y, s] + m.OP_S[y, s] + m.OP_Q[y, s] + m.OP_L[y, s]","def rule(model, k):\n if self.category_days_total[k] <= 0:\n return Constraint.Feasible\n return self.category_days_total[k], model.S_cat_total[k], None","def step(self, closure):\r\n self.state['step'] += 1\r\n for y_ind in range(self.dim_out):\r\n err = closure(y_ind)\r\n for group_ind in range(len(self.param_groups)):\r\n group = self.param_groups[group_ind]\r\n iekf_mat = self.state['iekf_groups'][group_ind]\r\n for ii, w in enumerate(group['params']):\r\n if w.grad is None:\r\n continue\r\n H_n = iekf_mat[ii]['H']\r\n grad = w.grad.data.detach()\r\n if len(w.size()) > 1:\r\n grad = grad.transpose(1, 0)\r\n grad = grad.contiguous().view((1, -1))\r\n if y_ind == 0:\r\n H_n = grad\r\n else:\r\n H_n = torch.cat([H_n, grad], dim=0)\r\n self.state['iekf_groups'][group_ind][ii]['H'] = H_n\r\n\r\n err_T = err.transpose(0, 1)\r\n\r\n for group_ind in range(len(self.param_groups)):\r\n group = self.param_groups[group_ind]\r\n iekf_mat = self.state['iekf_groups'][group_ind]\r\n for ii, w in enumerate(group['params']):\r\n if w.grad is None:\r\n continue\r\n\r\n lbd_n = iekf_mat[ii]['lbd']\r\n P_n = iekf_mat[ii]['P']\r\n EPS = iekf_mat[ii]['EPS']\r\n H_n = iekf_mat[ii]['H']\r\n H_n_T = H_n.transpose(0, 1)\r\n if group['lbd_decay']:\r\n miu = 1.0 / min(self.state['step'], group['lbd_max_step'])\r\n lbd_n = lbd_n + miu * (err_T.mm(err).flatten()[0] / self.dim_out - lbd_n)\r\n self.state['iekf_groups'][group_ind][ii]['lbd'] = lbd_n\r\n R_n = lbd_n * torch.eye(self.dim_out, dtype=torch.float, device=iekf_mat[ii]['device'],\r\n requires_grad=False)\r\n\r\n g_n = R_n + H_n.mm(P_n).mm(H_n_T)\r\n g_n = g_n.inverse()\r\n\r\n K_n = P_n.mm(H_n_T).mm(g_n)\r\n delta_w = K_n.mm(err)\r\n if len(w.size()) > 1:\r\n delta_w = delta_w.view((w.size(1), w.size(0))).transpose(1, 0)\r\n else:\r\n delta_w = delta_w.view(w.size())\r\n\r\n new_P = (group['alpha'] + 1) * (P_n - K_n.mm(H_n).mm(P_n) + EPS)\r\n self.state['iekf_groups'][group_ind][ii]['P'] = new_P\r\n\r\n w.data.add_(delta_w)\r\n\r\n return err","def RHSnet(y,t,a,b0,b1,g,k,w):\n S = y[:N]\n E = y[N:2*N]\n C = y[2*N:3*N]\n b = b0 + b1*(1+np.cos(2*np.pi*t))\n dy = np.zeros(3*N)\n dy[:N]= k*(1-S)-b*C*S+w*np.dot(P,S)-w*S\n dy[N:2*N]= b*C*S-(k+a)*E+w*np.dot(P,E)-w*E\n dy[2*N:3*N]= a*E-(g+k)*C+w*np.dot(P,C)-w*C\n return dy","def loss_criterion(self, result, labels):\n\n w = self.kd_weight\n t = self.temperature\n\n gt_loss = F.cross_entropy(result[\"outs\"], labels)\n\n # Weird way to get 0 tensor\n kd_loss = gt_loss.detach() * 0.0\n\n for v in result[\"teacher_out_list\"]:\n # Multiplying by 100 to keep losses roughly comparable\n kd_loss += nn.KLDivLoss()(\n F.log_softmax(result[\"outs\"] / t, dim=1),\n F.softmax(v / t, dim=1)\n ) * 100.0\n\n kd_loss /= len(result[\"teacher_out_list\"])\n\n # Weigh kd_loss with t^2 to preserve scale of gradients\n final_loss = (kd_loss * w * t * t) + (gt_loss * (1 - w))\n\n return {\n \"loss\": final_loss,\n \"gt_loss\": gt_loss,\n \"kd_loss\": kd_loss\n }","def svm_loss(x, y):\n x = np.squeeze(x)\n N = x.shape[0]\n yt = y\n yt[y==0]=-1\n tmp = 1-yt*x\n mask = np.ones_like(tmp)\n mask[tmp<=0] = 0\n tmp = tmp*mask\n loss = np.sum(tmp)/N\n \n dx = -yt*mask/N\n # dx = np.reshape(dx,[dx.shape[0],1])\n return loss, dx","def get_loss(self, x):\n x = self.normalize(x)\n pernalty_func = 0\n if self.coincide_fun is not None:\n tmp_res = self.coincide_fun(x)\n for i in range(self.cons_num):\n cons = self.constrain[i]\n self.loss_list[i] = cons(x, tmp_res)\n pernalty_tmp = self.pow(self.relu(self.mul_k[i] / self.sigma_k + self.loss_list[i]), self.pow_rate)\\\n - self.pow((self.mul_k[i] / self.sigma_k), self.pow_rate)\n pernalty_func += pernalty_tmp\n objective_val = self.objective_func(x, tmp_res)\n else:\n for i in range(self.cons_num):\n cons = self.constrain[i]\n self.loss_list[i] = cons(x)\n pernalty_tmp = self.pow(self.relu(self.mul_k[i] / self.sigma_k + self.loss_list[i]), self.pow_rate)\\\n - self.pow((self.mul_k[i] / self.sigma_k), self.pow_rate)\n pernalty_func += pernalty_tmp\n objective_val = self.objective_func(x)\n loss1 = self.obj_weight * objective_val\n lagrangian_func = loss1 + self.sigma_k / 2 * pernalty_func\n res = [lagrangian_func, self.loss_list, objective_val, x]\n return res","def get_rhs(self, mol_orbs, task, ops):\n if 'x' in ops or 'y' in ops or 'z' in ops:\n prop = {k: v for k, v in zip('xyz', self.get_dipole(task))}\n den = mol_orbs.get_density(task.molecule)\n da = den.alpha_to_numpy(0)\n db = den.beta_to_numpy(0)\n D = da + db\n S = self.get_overlap(task)\n mo = mol_orbs.alpha_to_numpy()\n\n matrices = tuple([mo.T@(S@D@prop[p].T - prop[p].T@D@S)@mo for p in ops])\n gradients = tuple([self.mat2vec(m, mol_orbs, task) for m in matrices])\n return gradients","def loss_grid(self, output, target):\n pass","def triplet_loss(y_true, y_pred, alpha=0.2):\n\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\n\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\n pos_dist = K.sum(K.square(anchor - positive), axis=-1)\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\n neg_dist = K.sum(K.square(anchor - negative), axis=-1)\n # Step 3: subtract the two previous distances and add alpha.\n basic_loss = pos_dist - neg_dist + alpha\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\n loss = K.sum(K.maximum(basic_loss, 0))\n\n return loss","def model_loss(inp, fake, real_label, fake_label):\n \n \n Dreal,realcls,R1 = gradpen(inp)\n [Dfake,fakecls] = D(fake)\n # 1. Adversarial loss\n \n glabel = tf.ones_like(Dfake)#tf.random.uniform((Dfake.shape), 1-LN, 1)\n dlabelr = tf.ones_like(Dreal)#tf.random.uniform((Dreal.shape), 1-LN, 1)\n dlabelf = tf.zeros_like(Dfake)#tf.random.uniform((Dfake.shape), 0, LN)\n \n \n \n # D has no sigmoid activation: \"from_logits=True\"\n real_loss = tf.keras.losses.binary_crossentropy(\n dlabelr, Dreal, from_logits=True)\n real_loss = tf.reduce_mean(real_loss)\n \n fake_loss = tf.keras.losses.binary_crossentropy(\n dlabelf, Dfake, from_logits=True)\n fake_loss = tf.reduce_mean(fake_loss)\n \n Dadv = 0.5*(real_loss+fake_loss)\n \n Gadv = tf.keras.losses.binary_crossentropy(\n glabel, Dfake, from_logits=True)\n Gadv = tf.reduce_mean(Gadv)\n \n # 2. Classification loss\n \n Dcls = tf.keras.losses.binary_crossentropy(real_label, realcls, from_logits=True)\n Dcls = tf.reduce_mean(Dcls)\n \n Gcls = tf.keras.losses.binary_crossentropy(fake_label, fakecls, from_logits=True)\n Gcls = tf.reduce_mean(Gcls)\n \n # 3. Total loss\n \n Dloss = Dadv + (GAMMA/2)*R1 + LAMBDA_CLS*Dcls\n \n Gloss = Gadv + LAMBDA_CLS*Gcls\n \n return (Dloss, Dadv, Dcls, R1), (Gloss, Gadv, Gcls)","def past_weight_grad_calculator2(xs, es, kp_x, kd_x, kp_e, kd_e, shapes):\n kp_x, kd_x, kp_e, kd_e = [as_floatx(k) for k in (kp_x, kd_x, kp_e, kd_e)]\n n_samples, n_in, n_out = shapes\n rx = kd_x/(kp_x+kd_x)\n re = kd_e/(kp_e+kd_e)\n\n xr = create_shared_variable(np.zeros((n_samples, n_in)))\n er = create_shared_variable(np.zeros((n_samples, n_out)))\n\n\n\n\n # xr_new = xr*rx + xs/(kp_x+kd_x)\n # er_new = er*re + es/(kp_e+kd_e)\n\n arr = rx*re/(1-rx*re)\n\n xr_new = xr*arr + xs/(kp_x+kd_x)\n er_new = er*arr + es/(kp_e+kd_e)\n\n xsum = create_shared_variable(np.zeros((n_samples, n_in)))\n esum = create_shared_variable(np.zeros((n_samples, n_out)))\n\n xsum_new = xsum+xr_new\n esum_new = esum+er_new\n\n x_nospikes = tt.eq(xs, 0)\n e_nospikes = tt.eq(es, 0)\n\n dw = xs.T.dot(esum_new) + xsum_new.T.dot(es)\n\n add_update(xr, xr_new)\n add_update(er, er_new)\n add_update(xsum, xsum_new*x_nospikes)\n add_update(esum, esum_new*e_nospikes)\n\n return xs.T.dot(er) + xr.T.dot(es)\n # return xr.T.dot(er)\n # return dw","def rule(model):\n num = self.num_timeslots\n ind_j = model.tasks\n total = sum(model.A2[num-1, j] for j in ind_j)\n total += sum(model.A3[num-1, j] for j in ind_j)\n total += sum(model.A4[num-1, j] for j in ind_j)\n total += sum(model.A3[num-2, j] for j in ind_j)\n total += sum(model.A4[num-2, j] for j in ind_j)\n total += sum(model.A4[num-3, j] for j in ind_j)\n return None, total, 0","def triplet_loss(y_true, y_pred, alpha=0.2):\n\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\n\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\n # Step 3: subtract the two previous distances and add alpha.\n basic_loss = (pos_dist - neg_dist) + alpha\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0))\n\n return loss","def remaining_constraints(self):\r\n \r\n def iec1(state,decision,nodes):\r\n return decision['E:L']+decision['E:R_1']<=nodes['E'].get_preds_value(state)\r\n def iec2(state,decision,nodes):\r\n return decision['R_1:L']<=nodes['R_1'].get_preds_value(state)\r\n def iec3(state,decision,nodes):\r\n return decision['G:R_1']>=-(nodes['R_1'].get_preds_value(state)) \r\n def iec4(state,decision,nodes):\r\n return decision['G:L']>=0.0\r\n def iec5(state,decision,nodes):\r\n return decision['E:L']>=0.0\r\n def iec6(state,decision,nodes):\r\n return decision['E:R_1']>=0.0\r\n def iec7(state,decision,nodes):\r\n return decision['R_1:L']>=0.0\r\n\r\n Inequality_Constraints=[iec1,iec2,iec3,iec4,iec5,iec6,iec7]\r\n \r\n return Inequality_Constraints","def loss(L, S, A, R, Y, alpha, beta, gamma, delta):\n return alpha*load_imbalance(Y,L,A) + beta*constraints(Y,A) + gamma*transfers(Y,R,S) + delta*choice(Y)","def loss_fn(model):\n with flax.nn.stateful(state) as new_state:\n with flax.nn.stochastic(prng_key):\n logits = model(batch['image'])\n loss = cross_entropy_loss(logits, batch['label'])\n # TODO(britefury): check if applying L2 regularization to weights but\n # *not* biases improves results\n weight_penalty_params = jax.tree_leaves(model.params)\n weight_l2 = sum([jnp.sum(x ** 2)\n for x in weight_penalty_params\n if x.ndim > 1])\n weight_penalty = l2_reg * 0.5 * weight_l2\n loss = loss + weight_penalty\n return loss, (new_state, logits)","def validate(nnet_model, type_nnet, dataset, type_KL, num_samples, latent_dim, covar_module0, covar_module1, likelihoods, \n zt_list, T, weight, train_mu, train_x, id_covariate, loss_function, eps=1e-6):\n\n print(\"Testing the model with a validation set\")\n T=16\n device = torch.device(\"cuda\" if torch.cuda.is_available() else \"cpu\")\n\n batch_size = T\n assert (type_KL == 'GPapprox_closed' or type_KL == 'GPapprox')\n\n # set up Data Loader for training\n dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False, num_workers=4)\n\n Q = len(dataset[0]['label'])\n P = len(dataset) // T\n\n full_mu = torch.zeros(len(dataset), latent_dim, dtype=torch.double, requires_grad=True).to(device)\n full_log_var = torch.zeros(len(dataset), latent_dim, dtype=torch.double, requires_grad=True).to(device)\n full_labels = torch.zeros(len(dataset), Q, dtype=torch.double, requires_grad=False).to(device)\n\n recon_loss_sum = 0\n nll_loss_sum = 0\n for batch_idx, sample_batched in enumerate(dataloader):\n indices = sample_batched['idx']\n data = sample_batched['digit'].double().to(device)\n mask = sample_batched['mask'].double().to(device)\n full_labels[indices] = sample_batched['label'].double().to(device)\n\n covariates = torch.cat((full_labels[indices, :id_covariate], full_labels[indices, id_covariate+1:]), dim=1)\n recon_batch, mu, log_var = nnet_model(data)\n\n full_mu[indices] = mu\n full_log_var[indices] = log_var\n\n [recon_loss, nll] = nnet_model.loss_function(recon_batch, data, mask)\n recon_loss = torch.sum(recon_loss)\n nll = torch.sum(nll)\n\n recon_loss_sum = recon_loss_sum + recon_loss.item()\n nll_loss_sum = nll_loss_sum + nll.item()\n\n gp_losses = 0\n gp_loss_sum = 0\n param_list = []\n\n if isinstance(covar_module0, list):\n if type_KL == 'GPapprox':\n for sample in range(0, num_samples):\n Z = nnet_model.sample_latent(full_mu, full_log_var)\n for i in range(0, latent_dim):\n Z_dim = Z[:, i]\n gp_loss = -elbo(covar_module0[i], covar_module1[i], likelihoods[i], full_labels, Z_dim,\n zt_list[i].to(device), P, T, eps)\n gp_loss_sum = gp_loss.item() + gp_loss_sum\n gp_loss_sum /= num_samples\n\n elif type_KL == 'GPapprox_closed':\n for i in range(0, latent_dim):\n mu_sliced = full_mu[:, i]\n log_var_sliced = full_log_var[:, i]\n gp_loss = deviance_upper_bound(covar_module0[i], covar_module1[i],\n likelihoods[i], full_labels,\n mu_sliced, log_var_sliced,\n zt_list[i].to(device), P,\n T, eps)\n gp_loss_sum = gp_loss.item() + gp_loss_sum\n else:\n if type_KL == 'GPapprox_closed':\n gp_loss = validation_dubo(latent_dim, covar_module0, covar_module1,\n likelihoods, full_labels,\n full_mu, full_log_var,\n zt_list, P, T, eps)\n gp_loss_sum = gp_loss.item()\n\n if loss_function == 'mse':\n gp_loss_sum /= latent_dim\n net_loss_sum = weight*gp_loss_sum + recon_loss_sum\n elif loss_function == 'nll':\n net_loss_sum = gp_loss_sum + nll_loss_sum\n\n #Do logging\n print('Validation set - Loss: %.3f - GP loss: %.3f - NLL loss: %.3f - Recon Loss: %.3f' % (\n net_loss_sum, gp_loss_sum, nll_loss_sum, recon_loss_sum))\n\n return net_loss_sum","def l2_regularization(variables, factor=1e-4, name='l2_regularization', collections=['regularization']):\n l2 = tf.add_n([tf.sqrt(2.*tf.nn.l2_loss(var)) for var in variables], name=name) if variables else tf.constant(0.)\n loss = factor * l2\n scalar_summary(loss, name, collections)\n return loss","def compute_loss(y, tx, w):\n # If a is an N-D array and b is a 1-D array, it is a sum product over the last axis of a and b.\n e = y - np.dot(tx, w)\n loss = 1 / 2 * np.mean(e**2)\n return loss","def max_power_candidate_thermal_rule(_m, g, y, s, t):\r\n\r\n return m.p[g, y, s, t] - sum(m.x_c[g, j] for j in m.Y if j <= y) <= 0","def loss(self, T, mode):\n self.circuit.loss(T, mode)","def __addValueConstraints(self):\n for x in range(self.width):\n for y in range(self.height):\n g = self.grid[(x, y)]\n self.solver.add(\n Or([g == Magnets.EMPTY, g == Magnets.PLUS, g == Magnets.MINUS]))\n if x > 0:\n left = self.grid[(x-1, y)]\n self.solver.add(Or([g != left, g == Magnets.EMPTY]))\n if y > 0:\n up = self.grid[(x, y-1)]\n self.solver.add(Or([g != up, g == Magnets.EMPTY]))","def eval_nt_transfer_loss_on_vali_data(self, masked_student_net_params, vali_teacher_prediction, vali_teacher_ntk_mat, density_level):\n \n # evaluate the student ntk matrix using validation data.\n vali_student_ntk_mat = self.emp_ntk_fn(self.vali_inputs_1, self.vali_inputs_2, masked_student_net_params) \n\n # evaluate the student prediction using validation data. \n vali_student_prediction = self.apply_fn(masked_student_net_params, self.vali_samples) \n\n # calculate the kernel distance, target distance, and parameter l2 loss\n ker_dist, target_dist, param_squared_norm = self.kernel_dist_target_dist_l2_loss(vali_student_ntk_mat, vali_student_prediction, vali_teacher_ntk_mat, vali_teacher_prediction, masked_student_net_params )\n \n # weight these distances and sum them up.\n weighted_ker_dist = self.LAMBDA_KER_DIST * ker_dist\n \n weighted_parameters_squared_norm = (self.LAMBDA_L2_REG / density_level) * param_squared_norm \n\n transfer_loss = weighted_ker_dist + target_dist + weighted_parameters_squared_norm\n\n return transfer_loss, ker_dist, target_dist, param_squared_norm"],"string":"[\n \"def _auxiliary_loss(self, expert_mask, router_prob):\\n # density_1's shape: (dp_group, self.expert_dim)\\n density_1 = self.reduce_mean(expert_mask, 1)\\n # density_1_proxy's shape: (dp_group, self.expert_dim)\\n density_1_proxy = self.reduce_mean2(router_prob, 1)\\n loss = self.mul(density_1, density_1_proxy)\\n loss = self.reduce_mean3(loss)\\n loss = self.mul3(self.mul2(loss, self.expert_dim), self.expert_dim)\\n return loss\",\n \"def triplet_loss(y_true,y_pred,alpha=0.2):\\n anchor,positive,negative=y_pred[0],y_pred[1],y_pred[2]\\n pos_dist=tf.reduce_sum(tf.square(tf.subtract(anchor,positive)),axis=-1)\\n neg_dist=tf.reduce_sum(tf.square(tf.subtract(anchor,negative)),axis=-1)\\n basic_loss=tf.add(tf.subtract(pos_dist,neg_dist),alpha)\\n loss=tf.reduce_sum(tf.maximum(basic_loss,0.0))\\n return loss\",\n \"def rule(model, i, j):\\n active = 1-self.task_spread[j]\\n den = sum(tril[i, :])\\n ind = model.timeslots\\n total = sum(tril[i, k] * (\\n 1 - model.A[k, j] - model.A2[k, j] - model.A3[k, j] - model.A4[\\n k, j]) for k in ind)\\n total /= den\\n total *= active\\n return -1 + EPS, model.CTl[i, j] - total, EPS + self.slack_cont\",\n \"def triplet_loss(y_true, y_pred):\\n [a,p,n] = tf.unstack(y_pred, num=3)\\n pos_dist = tf.reduce_sum((a - p)**2, axis=-1)\\n neg_dist = tf.reduce_sum((a - n)**2, axis=-1)\\n basic_loss = pos_dist - neg_dist + 0.1\\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0)) \\n return loss\",\n \"def triplet_loss(self, sim, margin=0.5):\\n # sim = sigmoid(5.0 - 5.0*distance)\\n pos_sim, neg_sim = tf.slice(sim, [0, 0], [-1, 1]), tf.slice(sim, [0, 1], [-1, -1])\\n # pos_sim has larger similarity than neg_sim\\n triplet_loss = margin + neg_sim - pos_sim\\n triplet_loss = tf.nn.relu(triplet_loss)\\n triplet_loss = tf.reduce_sum(triplet_loss, axis=-1)\\n triplet_loss = tf.reduce_mean(triplet_loss)\\n\\n # wmrb_loss = tf.log(1.0 + margin_loss)\\n\\n return triplet_loss\",\n \"def loss_perceptual(self, vgg_out, vgg_gt, vgg_comp): \\n loss = 0\\n for o, c, g in zip(vgg_out, vgg_comp, vgg_gt):\\n loss += self.l1(o, g) + self.l1(c, g)\\n return loss\",\n \"def rule(model):\\n ind_i = model.timeslots2\\n ind_j = model.tasks\\n inv = 1-self.valid\\n total = sum(\\n model.A2[i, j] * inv[i + 1, j] for i in ind_i for j in ind_j)\\n total += sum(\\n model.A3[i, j] * inv[i + 1, j] for i in ind_i for j in ind_j)\\n total += sum(\\n model.A4[i, j] * inv[i + 1, j] for i in ind_i for j in ind_j)\\n\\n ind_i = model.timeslots3\\n ind_j = model.tasks\\n total += sum(\\n model.A3[i, j] * inv[i + 2, j] for i in ind_i for j in ind_j)\\n total += sum(\\n model.A4[i, j] * inv[i + 2, j] for i in ind_i for j in ind_j)\\n\\n ind_i = model.timeslots4\\n ind_j = model.tasks\\n total += sum(\\n model.A4[i, j] * inv[i + 3, j] for i in ind_i for j in ind_j)\\n\\n return None, total, 0\",\n \"def ObjectiveGLASSO_block(As, bs, Ts, lam, groups, x):\\n \\n obj = 0\\n for j in range(len(As)):\\n obj = obj + 0.5*Norm(As[j].dot(x[Ts[j]])-bs[j])**2\\n\\n obj = obj + lam*np.sum([Norm(x[g]) for g in groups])\\n return obj\",\n \"def step(self):\\n loss = None\\n for group in self.param_groups:\\n for p in group['params']:\\n grad = p.grad.data\\n state = self.state[p]\\n\\n if len(state) == 0:\\n t = 0\\n m = torch.zeros_like(p.data)\\n v = torch.zeros_like(p.data)\\n # v_hat = torch.zeros_like(p.data)\\n else:\\n t = state['t']\\n m = state['m']\\n v = state['v']\\n\\n b1 = group['beta1']\\n b2 = group['beta2']\\n t += 1\\n\\n m = torch.mul(m, b1) + (1-b1) * grad\\n v = torch.mul(v, b2) + (1-b2) * grad**2\\n\\n m_unbias = 1 / (1 - b1**t)\\n v_unbias = 1 / (1 - b2**t)\\n\\n p.data -= (group['lr'] * m_unbias / math.sqrt(v_unbias)) * \\\\\\n m / (math.sqrt(v_unbias) + group['eps'])\\n\\n # v_hat = torch.max(v_hat, v)\\n # p.data -= group['lr'] / m_unbias * m * v_hat / (v_unbias.sqrt() + group['eps'])\\n state['t'] = t\\n state['m'] = m\\n state['v'] = v\\n\\n return loss\",\n \"def powerflow_rule(_m, l, y, s, t):\\r\\n\\r\\n return (- m.sigma_27[l, y, s, t] + m.sigma_28[l, y, s, t]\\r\\n + (m.INCIDENCE_MATRIX[l, self.g(l)] * m.lamb[self.g(l), y, s, t])\\r\\n + (m.INCIDENCE_MATRIX[l, self.h(l)] * m.lamb[self.h(l), y, s, t])\\r\\n == 0)\",\n \"def min_error_removed_linear_constraints(self):\\n n_e_vars = len(self.removed_linear_constraints) * 2\\n\\n # Add a pair of (continuous) variables e+ >= 0 and e- >= 0, for each (removed) conflicting constraint\\n eplus_vars = self.add_variables(n_variables=n_e_vars / 2, lb=0, var_type=\\\"continuous\\\")\\n eminus_vars = self.add_variables(n_variables=n_e_vars / 2, lb=0, var_type=\\\"continuous\\\")\\n\\n print self.n_tuple_variables\\n print len(eplus_vars)\\n print len(eminus_vars)\\n assert isinstance(self.problem, cplex.Cplex)\\n print \\\"n binaries\\\", self.problem.variables.get_num_binary()\\n print \\\"n all\\\", self.problem.variables.get_num()\\n print \\\"n integers\\\", self.problem.variables.get_num_integer()\\n\\n # Set objective coefficients of e variables all to 1 (if minimization, otherwise -1)\\n if self.problem.objective.get_sense() == cplex.Cplex.objective.sense.minimize:\\n self.problem.objective.set_linear(izip(chain(eplus_vars, eminus_vars), repeat(1, n_e_vars)))\\n else:\\n self.problem.objective.set_linear(izip(chain(eplus_vars, eminus_vars), repeat(-1, n_e_vars)))\\n\\n adding_constraints = list()\\n\\n # For minimizing error in SUM(attr) for each attr in the query package\\n for i, lc in enumerate(self.removed_linear_constraints):\\n def get_coeff_function(_ugc):\\n yield 1\\n yield -1\\n for coeff in self.get_aggregate_constraint_coefficients(_ugc.aggr, _ugc.attr):\\n yield coeff\\n\\n def get_vars_function(_i):\\n yield eplus_vars[_i]\\n yield eminus_vars[_i]\\n for var in self.tuple_variables:\\n yield var\\n\\n lc = LinearConstraint(\\n cid=self.new_constraint_id(),\\n vals_func=(get_coeff_function, (lc.ugc,)),\\n vars_func=(get_vars_function, (i,)),\\n op=operator.eq,\\n rhs=lc.rhs)\\n\\n print \\\"VALS\\\", lc.get_coeff_function\\n print \\\"VARS\\\", lc.get_vars_function\\n\\n adding_constraints.append(lc)\\n\\n self.add_linear_constraints(adding_constraints)\",\n \"def compute_loss(self, x, gt):\\n loss = sum([torch.mean((out - gt)**2) for out in self.forward(x)])\\n return loss\",\n \"def rule(model):\\n ind_i = model.timeslots\\n ind_j = model.tasks\\n total = sum(model.A[i, j] * (1-self.valid[i, j]) for i in ind_i\\n for j in ind_j)\\n total += sum(model.A2[i, j] * (1 - self.valid[i, j]) for i in\\n ind_i for j in ind_j)\\n total += sum(model.A3[i, j] * (1 - self.valid[i, j]) for i in\\n ind_i for j in ind_j)\\n\\n return None, total, 0\",\n \"def triplet_loss(anchor, positive, negative, alpha):\\n\\n with tf.variable_scope('triplet_loss'):\\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), 1)\\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), 1)\\n\\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\\n loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0)\\n\\n return loss\",\n \"def rule(model, i, j):\\n active = 1-self.task_spread[j]\\n den = sum(triu[i, :])\\n ind = model.timeslots\\n # FIXME(cathywu) can/should be more precise with A,A2,A3 offsets\\n total = sum(triu[i, k] * (\\n 1 - model.A[k, j] - model.A2[k, j] - model.A3[k, j] - model.A4[\\n k, j]) for k in ind)\\n total /= den\\n total *= active\\n # CTu[i,j] = floor(total)\\n return -1 + EPS, model.CTu[i, j] - total, EPS + self.slack_cont\",\n \"def rule(model, d, j0, j1):\\n if self.task_after[j0, j1] == 0:\\n return Constraint.Feasible\\n total = model.T_end[d, j0] - model.T_end[d, j1]\\n return 0, total, None\",\n \"def constraint_sum(w):\\n return sum(w) - 1\",\n \"def nt_transfer_loss(self, student_net_params, masks, teacher_net_params, x, density_level): \\n\\n masked_student_net_params = get_sparse_params_filtered_by_masks(student_net_params, masks)\\n\\n # split inputs into two collections, x1 and x2.\\n x1 = x[:int(len(x)/2)]\\n x2 = x[int(len(x)/2):]\\n \\n # student network prediction\\n student_prediction = self.apply_fn(masked_student_net_params, x) \\n \\n # teacher network prediction\\n teacher_prediction = self.apply_fn(teacher_net_params, x)\\n\\n # student network's NTK evaluated on x1 and x2\\n student_ntk_mat = self.emp_ntk_fn(x1, x2, masked_student_net_params) \\n\\n # teacher network's NTK evaluated on x1 and x2\\n teacher_ntk_mat = self.emp_ntk_fn(x1, x2, teacher_net_params) \\n\\n # compute kernel, target, and paramter l2 loss\\n ker_dist, target_dist, param_squared_norm = self.kernel_dist_target_dist_l2_loss(student_ntk_mat, student_prediction, teacher_ntk_mat, teacher_prediction, masked_student_net_params)\\n\\n # weight these losses to get the transfer loss\\n transfer_loss = self.LAMBDA_KER_DIST * ker_dist + target_dist + (self.LAMBDA_L2_REG / density_level) * param_squared_norm \\n\\n return transfer_loss\",\n \"def rule(model, k):\\n ind_i = model.timeslots\\n ind_i2 = model.timeslots2\\n ind_i3 = model.timeslots3\\n ind_i4 = model.timeslots4\\n ind_j = model.tasks\\n cat_k_total = sum(\\n model.A[i, j] * self.task_category[j, k] for i in ind_i for j in\\n ind_j)\\n cat_k_total += 2 * sum(\\n model.A2[i, j] * self.task_category[j, k] for i in ind_i2 for j\\n in ind_j)\\n cat_k_total += 3 * sum(\\n model.A3[i, j] * self.task_category[j, k] for i in ind_i3 for j\\n in ind_j)\\n cat_k_total += 4 * sum(\\n model.A4[i, j] * self.task_category[j, k] for i in ind_i4 for j\\n in ind_j)\\n return model.C_total[k] == cat_k_total\",\n \"def constraint_loss(self, output: torch.Tensor, sum_reduction: bool = True, mu: int = 10, class_disjunction=True) -> torch.Tensor:\\n device = self.get_device()\\n output = output.to(device)\\n assert self._formulas != [], \\\"Explanations not passed yet. set_explanation() method needs to be called first.\\\"\\n constraint_loss1 = torch.zeros(output.shape[0], device=device)\\n constraint_loss2 = torch.zeros(output.shape[0], device=device)\\n disjunction_loss = torch.zeros(output.shape[0], device=device)\\n for i in range(len(self.main_classes)):\\n class_loss1 = output[:, i]\\n for term in self._formulas[i]:\\n term_loss = 1\\n for (attribute, negated) in term:\\n output_attribute = output[:, attribute]\\n if negated:\\n output_attribute = 1 - output_attribute\\n term_loss *= output_attribute\\n term_loss = 1 - term_loss\\n class_loss1 = class_loss1 * term_loss\\n constraint_loss1 += class_loss1\\n class_loss2 = 1\\n for term in self._formulas[i]:\\n term_loss = 1\\n for (attribute, negated) in term:\\n output_attribute = output[:, attribute]\\n if negated:\\n output_attribute = 1 - output_attribute\\n term_loss *= output_attribute\\n class_loss2 *= (1 - term_loss)\\n class_loss2 = (1 - class_loss2) * (1 - output[:, i])\\n constraint_loss2 += class_loss2\\n if class_disjunction:\\n for i in range(len(self.main_classes)):\\n single_disjunction_loss = 1\\n for j in range(len(self.main_classes)):\\n if i != j:\\n single_disjunction_loss *= (1 - output[:, j])\\n disjunction_loss += output[:, i] * (1 - single_disjunction_loss)\\n constraint_loss = constraint_loss1 + constraint_loss2 + disjunction_loss\\n if sum_reduction:\\n return constraint_loss.sum()\\n return constraint_loss\",\n \"def triplet_loss(anchor, positive, negative, margin=0.2):\\n distance_ap = tf.reduce_sum(tf.square(anchor - positive), 1)\\n distance_an = tf.reduce_sum(tf.square(anchor - negative), 1)\\n loss = tf.maximum(0.0, distance_ap - distance_an + margin)\\n loss = tf.reduce_mean(loss)\\n return loss\",\n \"def _constraints_variables(self):\\n\\n def rule(model, k):\\n \\\"\\\"\\\"\\n Total slots allocated to category k\\n \\\"\\\"\\\"\\n ind_i = model.timeslots\\n ind_i2 = model.timeslots2\\n ind_i3 = model.timeslots3\\n ind_i4 = model.timeslots4\\n ind_j = model.tasks\\n cat_k_total = sum(\\n model.A[i, j] * self.task_category[j, k] for i in ind_i for j in\\n ind_j)\\n cat_k_total += 2 * sum(\\n model.A2[i, j] * self.task_category[j, k] for i in ind_i2 for j\\n in ind_j)\\n cat_k_total += 3 * sum(\\n model.A3[i, j] * self.task_category[j, k] for i in ind_i3 for j\\n in ind_j)\\n cat_k_total += 4 * sum(\\n model.A4[i, j] * self.task_category[j, k] for i in ind_i4 for j\\n in ind_j)\\n return model.C_total[k] == cat_k_total\\n\\n self.model.constrain_cat_duration0 = Constraint(self.model.categories,\\n rule=rule)\\n\\n def rule(model, s, k):\\n \\\"\\\"\\\"\\n S_cat[s,k] = whether (any tasks of) category k is assigned on day s\\n \\\"\\\"\\\"\\n den = sum(self.task_category[:, k])\\n ind_j = model.tasks\\n total = sum(self.task_category[j, k] * model.S[s, j] for j in\\n ind_j) / den\\n # Desired: S[i,j] = ceil(total)\\n # Desired: S[i,j] = 0 if total <= 0; otherwise, S[i,j] = 1\\n return -EPS, model.S_cat[s, k] - total, 1 - EPS\\n\\n self.model.constrain_cat_days0 = Constraint(self.model.dayslots,\\n self.model.categories,\\n rule=rule)\\n\\n def rule(model, k):\\n \\\"\\\"\\\"\\n S_cat_total[k] = number of unique days in which task from\\n category k were assigned\\n\\n More precisely:\\n sum_s S_cat[s,k] == S_cat_total[k]\\n \\\"\\\"\\\"\\n ind_s = model.dayslots\\n total = sum(model.S_cat[s, k] for s in ind_s)\\n return model.S_cat_total[k] == total\\n\\n self.model.constrain_cat_days1 = Constraint(self.model.categories,\\n rule=rule)\",\n \"def triplet_loss(y_true, y_pred, alpha = 0.2):\\r\\n \\r\\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\\r\\n \\r\\n ### START CODE HERE ### (≈ 4 lines)\\r\\n # Step 1: Compute the (encoding) distance between the anchor and the positive\\r\\n pos_dist = tf.reduce_sum(tf.square(anchor - positive))\\r\\n # Step 2: Compute the (encoding) distance between the anchor and the negative\\r\\n neg_dist = tf.reduce_sum(tf.square(anchor - negative))\\r\\n # Step 3: subtract the two previous distances and add alpha.\\r\\n basic_loss = pos_dist - neg_dist + alpha\\r\\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\\r\\n loss = tf.maximum(basic_loss, 0)\\r\\n ### END CODE HERE ###\\r\\n \\r\\n return loss\",\n \"def triplet_loss(y_true, y_pred, alpha = 0.2):\\n \\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\\n \\n ### START CODE HERE ### (≈ 4 lines)\\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,positive)),axis=-1)\\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor,negative)),axis=-1)\\n # Step 3: subtract the two previous distances and add alpha.\\n basic_loss = pos_dist-neg_dist+alpha\\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0))\\n ### END CODE HERE ###\\n \\n return loss\",\n \"def _constraints_utility(self):\\n\\n def rule(model):\\n total = summation(self.utilities, model.A)\\n return model.A_total == total\\n\\n self.model.constrain_A_total = Constraint(rule=rule)\\n\\n def rule(model):\\n total = 2 * summation(self.utilities, model.A2)\\n return model.A2_total == total\\n\\n self.model.constrain_A2_total = Constraint(rule=rule)\\n\\n def rule(model):\\n total = 3 * summation(self.utilities, model.A3)\\n return model.A3_total == total\\n\\n self.model.constrain_A3_total = Constraint(rule=rule)\\n\\n def rule(model):\\n total = 4 * summation(self.utilities, model.A4)\\n return model.A4_total == total\\n\\n self.model.constrain_A4_total = Constraint(rule=rule)\\n\\n def rule(model):\\n completion_bonus = self.task_completion_bonus * self.task_duration\\n total = summation(completion_bonus, model.T_total)\\n return model.Completion_total == total\\n\\n self.model.constrain_completion_total = Constraint(rule=rule)\\n\\n def rule(model):\\n scaling = 0.2\\n affinity = np.outer(c.AFFINITY_COGNITIVE, self.task_cognitive_load)\\n\\n # TODO(cathywu) replace this code when \\\"simple slicing\\\" is clarified\\n zeros1 = np.zeros((1, self.num_tasks))\\n zeros2 = np.zeros((2, self.num_tasks))\\n zeros3 = np.zeros((3, self.num_tasks))\\n\\n total = summation(affinity, model.A)\\n total += summation(affinity, model.A2)\\n total += summation(affinity, model.A3)\\n total += summation(affinity, model.A4)\\n\\n total += summation(np.vstack((affinity[1:, :], zeros1)), model.A2)\\n total += summation(np.vstack((affinity[1:, :], zeros1)), model.A3)\\n total += summation(np.vstack((affinity[1:, :], zeros1)), model.A4)\\n\\n total += summation(np.vstack((affinity[2:, :], zeros2)), model.A3)\\n total += summation(np.vstack((affinity[2:, :], zeros2)), model.A4)\\n\\n total += summation(np.vstack((affinity[3:, :], zeros3)), model.A4)\\n total *= scaling\\n\\n return model.Affinity_cognitive_total == total\\n\\n self.model.constrain_affinity_cognitive_total = Constraint(rule=rule)\",\n \"def dual_equal(s, p, g_x_func, Z_0, k=None, P=None, T=None, \\n tol=1e-2):\\n from numpy import array, zeros_like, zeros\\n from scipy.optimize import minimize\\n from tgo import tgo\\n \\n def x_lim(X): # limiting function used in TGO\\n import numpy\\n return numpy.sum(X, axis=1) - 1.0 <= 0.0\\n \\n if k == None:\\n k = p.m['Valid phases']\\n \\n # Initialize\\n Z_0 = array(Z_0)\\n LBD = - 1e300 # -inf\\n s.update_state(s, p, X = Z_0, phase = k, Force_Update=True) \\n \\n # G_p (Primal problem Z_0_i - x_i = 0 for all i):\\n UBD = g_x_func(s, p).m['g_mix']['t'] \\n Lambda_d = zeros_like(Z_0)\\n\\n # X bounds used in UBD optimization\\n X_bounds = [zeros(shape=(p.m['n']-1)), # Upper bound\\n zeros(shape=(p.m['n']-1)) # Lower bound\\n ] \\n for i in range(p.m['n']-1): \\n Sigma_ind = 0.0 # Sum of independent components excluding i\\n # (lever rule) \\n for j in range(p.m['n']-1):\\n if j != i:\\n Sigma_ind += Z_0[j]\\n\\n X_bounds[0][i] = 1.0 - Sigma_ind \\n \\n # Construct physical bounds x \\\\in [0, 1] for all independent components\\n # (used in differential_evolution)\\n Bounds = []\\n for i in range(p.m['n'] - 1):\\n #Bounds.append((0, 1))\\n Bounds.append((1e-5, 0.99999))\\n \\n # Construct composition container from X_d for all phases. (REMOVED)\\n X_d = Z_0\\n\\n\\n #%% Normal calculation of daul problem if Z_0 is unstable.\\n while abs(UBD - LBD) >= tol:\\n # Solve UBD\\n # Update system to new composition.\\n # (Comp. invariant in UBD)\\n s.update_state(s, p, X = X_d , phase = k, Force_Update=True) \\n Lambda_sol = minimize(ubd, Lambda_d, method='L-BFGS-B', \\n args=(g_x_func, X_d, Z_0, s, p, X_bounds,\\n k))['x']\\n \\n Lambda_d = array(Lambda_sol) # If float convert back to 1x1 array\\n \\n # NOTE: NEGATIVE THE MAX DEFINED PROBLEM:\\n UBD = -ubd(Lambda_d, g_x_func, X_d, Z_0, s, p, X_bounds, k)\\n\\n X_sol = tgo(lbd, Bounds, args=(g_x_func, Lambda_d, Z_0, s, p, k),\\n g_func=x_lim,\\n n = 100,\\n skip=2)\\n # Solve LBD \\n LBD = lbd(X_sol, g_x_func, Lambda_d, Z_0, s, p, k) \\n X_d = X_sol\\n # End\\n \\n\\n if False: # Print results optional\\n print 'Final UBD = {}'.format(UBD)\\n print 'Final LBD = {}'.format(LBD)\\n print 'Final UBD - LBD = {}'.format(UBD - LBD)\\n print 'Final Z_eq = {}'.format(X_d)\\n print 'Final Lambda_d = {}'.format(Lambda_d)\\n \\n # Returns\\n s.m['Z_eq'] = X_d\\n s.m['Lambda_d'] = Lambda_d\\n return s\",\n \"def test_penalty_compute(self):\\n objective = {'G': numpy.zeros((9)),\\n 'H': numpy.diag((1,)*9),\\n 'X': 1}\\n for penalty in self.penalties:\\n result = penalty.compute([1]*self.np, objective)\\n assert isinstance(result,tuple)\\n # more tests go here\",\n \"def triplet_loss(y_true, y_pred, alpha = 0.2):\\r\\n \\r\\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\\r\\n \\r\\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\\r\\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\\r\\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\\r\\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\\r\\n # Step 3: subtract the two previous distances and add alpha.\\r\\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\\r\\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\\r\\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0))\\r\\n # END CODE HERE \\r\\n \\r\\n return loss\",\n \"def rule(model, p, k):\\n if self.category_daily_caps[k] < 0:\\n return Constraint.Feasible\\n ind_i = model.timeslots\\n ind_j = model.tasks\\n total = sum(diag[p, i] * self.task_category[j, k] * (\\n model.A[i, j] + 2 * model.A2[i, j] + 3 * model.A3[i, j] + 4 *\\n model.A4[i, j]) for i in ind_i for j in ind_j)\\n return None, total, self.category_daily_caps[k]\",\n \"def power_output_candidate_thermal_rule(_m, g, y, s, t):\\r\\n\\r\\n if y != m.Y.last() and t != m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\\r\\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n elif y != m.Y.last() and t == m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t]\\r\\n - m.sigma_23[g, y, s, t]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n elif y == m.Y.last() and t != m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\\r\\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n elif y == m.Y.last() and t == m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_3[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t]\\r\\n - m.sigma_23[g, y, s, t]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n else:\\r\\n raise Exception(f'Unhandled case: {g, y, s, t}')\",\n \"def test_tensor_composite_constraints_equal_penalties():\\n from pygam.penalties import derivative\\n\\n def der1(*args, **kwargs):\\n kwargs.update({'derivative':1})\\n return derivative(*args, **kwargs)\\n\\n # create a 3D tensor where the penalty should be equal to the constraint\\n term = te(0, 1, 2,\\n n_splines=[4, 5, 6],\\n penalties=der1,\\n lam=1,\\n constraints='monotonic_inc')\\n\\n # check all the dimensions\\n for i in range(3):\\n P = term._build_marginal_penalties(i).A\\n C = term._build_marginal_constraints(i,\\n -np.arange(term.n_coefs),\\n constraint_lam=1,\\n constraint_l2=0).A\\n\\n assert (P == C).all()\",\n \"def rule(model, j):\\n ind_i = model.timeslots\\n if self.task_chunk_min[j] == 2:\\n total = sum(model.A[i, j] for i in ind_i)\\n return None, total, 0\\n elif self.task_chunk_min[j] == 3:\\n total = sum(model.A[i, j] + model.A2[i, j] for i in ind_i)\\n return None, total, 0\\n elif self.task_chunk_min[j] >= 4:\\n total = sum(\\n model.A[i, j] + model.A2[i, j] + model.A3[i, j] for i in\\n ind_i)\\n return None, total, 0\\n return Constraint.Feasible\",\n \"def structured_loss(predict, frame_mask, label_weight, tp_weight, fp_weight, num_false_neg):\\n # tp_weight = torch.autograd.Variable(torch.Tensor(tp_weight), requires_grad=False).cuda()\\n # fp_weight = torch.autograd.Variable(torch.Tensor(fp_weight), requires_grad=False).cuda()\\n tp_weight = torch.tensor(tp_weight, requires_grad=False).cuda()\\n fp_weight = torch.tensor(fp_weight, requires_grad=False).cuda()\\n tp_mask = torch.tensor(\\n tp_weight > 0, dtype=torch.float32, requires_grad=False).cuda()\\n\\n # tp_cost = (tp_mask - tp_weight * predict) * label_weight * frame_mask\\n tp_cost = tp_weight * -predict * label_weight * frame_mask\\n fp_cost = fp_weight * predict * frame_mask\\n\\n tp_cost = tp_cost.sum(2).sum(0).view(-1)\\n fp_cost = fp_cost.sum(2).sum(0).view(-1)\\n\\n fn_cost = torch.autograd.Variable(\\n torch.Tensor(num_false_neg), requires_grad=False).cuda()\\n\\n return tp_cost, fp_cost, fn_cost\",\n \"def compute_loss(self):\",\n \"def loss_tv(self, mask, y_comp):\\n\\n # Create dilated hole region using a 3x3 kernel of all 1s.\\n kernel = K.ones(shape=(3, 3, mask.shape[3], mask.shape[3]))\\n dilated_mask = K.conv2d(1-mask, kernel, data_format='channels_last', padding='same')\\n\\n # Cast values to be [0., 1.], and compute dilated hole region of y_comp\\n dilated_mask = K.cast(K.greater(dilated_mask, 0), 'float32')\\n P = dilated_mask * y_comp\\n\\n # Calculate total variation loss\\n a = self.l1(P[:,1:,:,:], P[:,:-1,:,:])\\n b = self.l1(P[:,:,1:,:], P[:,:,:-1,:]) \\n return a+b\",\n \"def rule(model, i, j):\\n return 1, model.T0_end[i, j] + (1-model.A[i, j]), None\",\n \"def _create_loss(self):\\n\\n with tf.name_scope(\\\"loss\\\"):\\n \\n # gini=(tf.nn.l2_loss( self.score))/100000\\n gini = tf.losses.softmax_cross_entropy(self.score, 0*self.score)\\n \\n promo_prob=tf.reduce_sum(tf.multiply(self.score, self.cohort_weight),\\n axis=1)\\n inc_value = tf.reduce_mean(tf.multiply(promo_prob, self.value))- self.control_value\\n inc_cost = tf.reduce_mean( tf.multiply(promo_prob, self.cost)) - self.control_cost\\n \\n\\n\\n # determine loss function based on self.obj_rule\\n if self.obj_rule == 'cpiv':\\n self.objective = inc_cost / inc_value\\n\\n elif self.obj_rule == 'ivc':\\n # maximize ivc\\n self.objective = - inc_value / inc_cost\\n\\n elif self.obj_rule == 'lagrangian':\\n assert self.shadow is not None, 'Need to pass in shadow value if use lagrangian as obj_rule.'\\n self.objective = inc_cost - self.shadow * inc_value\\n\\n elif self.obj_rule == 'value':\\n # maximize delta values\\n self.objective = - inc_value\\n\\n # use only cost as objective\\n elif self.obj_rule == 'cost':\\n # maximize delta cost\\n self.objective = - inc_cost\\n\\n else:\\n raise Exception('Invalid obj_rule!')\\n\\n # regularization\\n reg_loss = tf.reduce_sum(tf.get_collection(tf.GraphKeys.REGULARIZATION_LOSSES))\\n # weights = tf.trainable_variables() # all vars of your graph\\n # reg_loss = tf.norm( weights,ord=1)\\n\\n # final loss\\n self.loss = self.objective +reg_loss+.1*gini\",\n \"def rule(model, d, i, j):\\n off = d * 48\\n num = np.arange(self.num_timeslots / 7)\\n total = model.A[i + off, j] * num[i]\\n return 0, model.T_end[d, j] - total, None\",\n \"def triplet_loss(anchor, positive, negative, alpha = my_alpha):\\r\\n delta_1 = tf.reduce_sum(tf.square(anchor - positive)) #square of euclidean distance or L2 norm\\r\\n delta_2 = tf.reduce_sum(tf.square(anchor - negative))\\r\\n loss = tf.maximum(delta_1 - delta_2 + alpha, tf.constant(0, dtype = tf.float32))\\r\\n return loss\",\n \"def rule(model, j):\\n ind_i = model.timeslots\\n if self.task_chunk_max[j] <= 1:\\n total = sum(\\n model.A2[i, j] + model.A3[i, j] + model.A4[i, j] for i in\\n ind_i)\\n return None, total, 0\\n elif self.task_chunk_max[j] <= 2:\\n total = sum(model.A3[i, j] + model.A4[i, j] for i in ind_i)\\n return None, total, 0\\n elif self.task_chunk_max[j] <= 3:\\n total = sum(model.A4[i, j] for i in ind_i)\\n return None, total, 0\\n return Constraint.Feasible\",\n \"def triplet_loss_network(input_shape):\\n model = base_model(input_shape)\\n\\n # input layer for anchor, positive and negative branches\\n input_anchor = Input(input_shape)\\n input_positive = Input(input_shape)\\n input_negative = Input(input_shape)\\n\\n # init the anchor model, positive model and negative model (three base_model())\\n anchor_model = model(input_anchor)\\n positive_model = model(input_positive)\\n negative_model = model(input_negative)\\n\\n triplet_loss_model = keras.Model(inputs=[input_anchor, input_positive, input_negative], outputs=[anchor_model, positive_model, negative_model], name=\\\"triplet_loss_network\\\")\\n\\n return triplet_loss_model\",\n \"def dual_objective_expression_rule(_m):\\r\\n\\r\\n # Build limits\\r\\n t_1 = sum(- (m.mu_2[z, y] * m.SOLAR_BUILD_LIMITS[z]) - (m.mu_3[z, y] * m.WIND_BUILD_LIMITS[z]) - (\\r\\n m.mu_4[z, y] * m.STORAGE_BUILD_LIMITS[z]) for z in m.Z for y in m.Y)\\r\\n\\r\\n # Min power output\\r\\n t_2 = sum(\\r\\n m.sigma_1[g, y, s, t] * m.P_MIN[g] for g in m.G.difference(m.G_STORAGE) for y in m.Y for s in m.S for t\\r\\n in m.T)\\r\\n\\r\\n # Max power - existing generators\\r\\n t_3 = sum(\\r\\n - m.sigma_2[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_THERM for y in m.Y for s in m.S\\r\\n for t in m.T)\\r\\n\\r\\n # Max power - existing wind\\r\\n t_4 = sum(\\r\\n - m.sigma_4[g, y, s, t] * m.Q_W[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_WIND for y in\\r\\n m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Max power - existing solar\\r\\n t_5 = sum(\\r\\n - m.sigma_6[g, y, s, t] * m.Q_S[g, y, s, t] * m.P_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_SOLAR for y in\\r\\n m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Max power - existing hydro\\r\\n t_6 = sum(\\r\\n - m.sigma_8[g, y, s, t] * m.P_H[g, y, s, t] * (1 - m.F[g, y]) for g in m.G_E_HYDRO for y in m.Y for s in\\r\\n m.S for t in m.T)\\r\\n\\r\\n # Max charging power - existing storage\\r\\n t_7 = sum(\\r\\n - m.sigma_11[g, y, s, t] * m.P_IN_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_STORAGE for y in m.Y for s in\\r\\n m.S for t in m.T)\\r\\n\\r\\n # Max discharging power - existing storage\\r\\n t_8 = sum(\\r\\n - m.sigma_13[g, y, s, t] * m.P_OUT_MAX[g] * (1 - m.F[g, y]) for g in m.G_E_STORAGE for y in m.Y for s in\\r\\n m.S for t in m.T)\\r\\n\\r\\n # Max energy - existing storage units\\r\\n t_9 = sum(\\r\\n - m.sigma_16[g, y, s, t] * m.Q_MAX[g] for g in m.G_E_STORAGE for y in m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Min energy - interval end\\r\\n t_10 = sum(m.sigma_18[g, y, s] * m.Q_END_MIN[g] for g in m.G_STORAGE for y in m.Y for s in m.S)\\r\\n\\r\\n # Max energy - interval end\\r\\n t_11 = sum(- m.sigma_19[g, y, s] * m.Q_END_MAX[g] for g in m.G_STORAGE for y in m.Y for s in m.S)\\r\\n\\r\\n # Ramp-up constraint - generators\\r\\n t_12 = sum(\\r\\n - m.sigma_20[g, y, s, t] * m.RR_UP[g] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for s in m.S\\r\\n for t in m.T)\\r\\n\\r\\n # Ramp-up constraint - initial power output - generators\\r\\n t_13 = sum(\\r\\n - m.sigma_20[g, y, s, m.T.first()] * m.P0[g, y, s] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y\\r\\n for s in m.S)\\r\\n\\r\\n # Ramp-down constraint - generators\\r\\n t_18 = sum(\\r\\n - m.sigma_23[g, y, s, t] * m.RR_DOWN[g] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for s in m.S\\r\\n for t in m.T)\\r\\n\\r\\n # Ramp-down constraint - initial power output - generators\\r\\n t_19 = sum(\\r\\n m.sigma_23[g, y, s, m.T.first()] * m.P0[g, y, s] for g in m.G_THERM.union(m.G_E_HYDRO) for y in m.Y for\\r\\n s in m.S)\\r\\n\\r\\n # Min powerflow\\r\\n t_24 = sum(m.sigma_27[l, y, s, t] * m.POWERFLOW_MIN[l] for l in m.L for y in m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Max powerflow\\r\\n t_25 = sum(\\r\\n - m.sigma_28[l, y, s, t] * m.POWERFLOW_MAX[l] for l in m.L for y in m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Demand\\r\\n t_26 = sum(m.lamb[z, y, s, t] * m.DEMAND[z, y, s, t] for z in m.Z for y in m.Y for s in m.S for t in m.T)\\r\\n\\r\\n # Initial storage unit energy\\r\\n t_27 = sum(m.zeta_1[g, y, s, m.T.first()] * m.Q0[g, y, s] for g in m.G_STORAGE for y in m.Y for s in m.S)\\r\\n\\r\\n return (t_1 + t_2 + t_3 + t_4 + t_5 + t_6 + t_7 + t_8 + t_9 + t_10 + t_11 + t_12 + t_13 + t_18 + t_19 + t_24\\r\\n + t_25 + t_26 + t_27)\",\n \"def gen1_constraint(model):\\n return 10, model.g[1], 50\",\n \"def bpr_triplet_loss(data):\\n positive_item_latent, negative_item_latent, user_latent = data\\n\\n positive_interactions = tf.math.reduce_sum(tf.math.multiply(user_latent,\\n positive_item_latent),\\n axis=-1,\\n keepdims=True)\\n negative_interactions = tf.math.reduce_sum(tf.math.multiply(user_latent,\\n negative_item_latent),\\n axis=-1,\\n keepdims=True)\\n\\n return tf.math.subtract(tf.constant(1.0),\\n tf.sigmoid(tf.math.subtract(positive_interactions,\\n negative_interactions)))\",\n \"def power_output_hydro_rule(_m, g, y, s, t):\\r\\n\\r\\n if y != m.Y.last() and t != m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_8[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\\r\\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + (m.DELTA[y] * m.RHO[y, s] * m.C_MC[g, y])\\r\\n == 0)\\r\\n\\r\\n elif y != m.Y.last() and t == m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_8[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t]\\r\\n - m.sigma_23[g, y, s, t]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + (m.DELTA[y] * m.RHO[y, s] * m.C_MC[g, y])\\r\\n == 0)\\r\\n\\r\\n elif y == m.Y.last() and t != m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_8[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\\r\\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + (m.DELTA[y] * m.RHO[y, s] * (1 + (1 / m.INTEREST_RATE)) * m.C_MC[g, y])\\r\\n == 0)\\r\\n\\r\\n elif y == m.Y.last() and t == m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_8[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t]\\r\\n - m.sigma_23[g, y, s, t]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + (m.DELTA[y] * m.RHO[y, s] * (1 + (1 / m.INTEREST_RATE)) * m.C_MC[g, y])\\r\\n == 0)\\r\\n\\r\\n else:\\r\\n raise Exception(f'Unexpected case: {g, y, s, t}')\",\n \"def power_output_existing_thermal_rule(_m, g, y, s, t):\\r\\n\\r\\n if y != m.Y.last() and t != m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_2[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\\r\\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n elif y != m.Y.last() and t == m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_2[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t]\\r\\n - m.sigma_23[g, y, s, t]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n elif y == m.Y.last() and t != m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_2[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t] - m.sigma_20[g, y, s, t + 1]\\r\\n - m.sigma_23[g, y, s, t] + m.sigma_23[g, y, s, t + 1]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n elif y == m.Y.last() and t == m.T.last():\\r\\n return (- m.sigma_1[g, y, s, t] + m.sigma_2[g, y, s, t]\\r\\n + m.sigma_20[g, y, s, t]\\r\\n - m.sigma_23[g, y, s, t]\\r\\n - m.lamb[self.k(m, g), y, s, t]\\r\\n + ((m.DELTA[y] * m.RHO[y, s]) * (1 + (1 / m.INTEREST_RATE)) * (\\r\\n m.C_MC[g, y] + ((m.EMISSIONS_RATE[g] - m.baseline[y]) * m.permit_price[y])))\\r\\n == 0)\\r\\n\\r\\n else:\\r\\n raise Exception(f'Unhandled case: {g, y, s, t}')\",\n \"def triplet_loss(y_true, y_pred, alpha=0.5):\\n print('y_pred.shape = ', y_pred)\\n\\n total_lenght = y_pred.shape.as_list()[-1]\\n # print('total_lenght=', total_lenght)\\n # total_lenght =12\\n\\n anchor = y_pred[:, 0:int(total_lenght * 1 / 3)]\\n positive = y_pred[:, int(total_lenght * 1 / 3):int(total_lenght * 2 / 3)]\\n negative = y_pred[:, int(total_lenght * 2 / 3):int(total_lenght * 3 / 3)]\\n\\n # distance between the anchor and the positive\\n pos_dist = K.sum(K.square(anchor - positive), axis=1)\\n\\n # distance between the anchor and the negative\\n neg_dist = K.sum(K.square(anchor - negative), axis=1)\\n\\n # compute loss\\n basic_loss = pos_dist - neg_dist + alpha\\n loss = tf.reduce_mean(K.maximum(basic_loss, 0.0))\\n\\n return loss\",\n \"def triplet_loss(y_true, y_pred, alpha=0.2):\\n\\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\\n\\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=None, keep_dims=True)\\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=None, keep_dims=True)\\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0), axis=0)\\n\\n return loss\",\n \"def getConstraint(self):\\n return self.gk, self.g_mink, self.g_maxk\",\n \"def solve(num_wizards, num_constraints, wizards, constraints):\\n\\n # print(num_wizards)\\n # print(num_constraints)\\n # print(wizards)\\n # print(constraints)\\n # node_set = set(wizards)\\n \\n\\n\\n def cost(sol,num_constraints,constraints):\\n constraints_satisfied = 0\\n constraints_failed = []\\n output_ordering_map = {k: v for v, k in enumerate(sol)}\\n for c in constraints:\\n\\n m = output_ordering_map # Creating an alias for easy reference\\n\\n wiz_a = m[c[0]]\\n wiz_b = m[c[1]]\\n wiz_mid = m[c[2]]\\n\\n if (wiz_a < wiz_mid < wiz_b) or (wiz_b < wiz_mid < wiz_a):\\n constraints_failed.append(c)\\n else:\\n constraints_satisfied += 1\\n return num_constraints - constraints_satisfied\\n\\n def neighbors(sol):\\n wiz1 = random.randint(0,num_wizards-1)\\n wiz2 = random.randint(0,num_wizards-1)\\n\\n new_sol = copy.copy(sol)\\n temp = new_sol[wiz1]\\n new_sol[wiz1] = new_sol[wiz2]\\n new_sol[wiz2] = temp\\n \\n return new_sol\\n\\n def acceptance_probability(old_cost,new_cost,T):\\n exponent = (old_cost - new_cost) / T\\n \\n try:\\n ans = math.exp(exponent)\\n except OverflowError:\\n ans = float('inf')\\n return ans\\n\\n\\n def anneal(solution, num_constraints, constraints):\\n old_cost = 0\\n new_cost = 0\\n old_cost = cost(solution,num_constraints,constraints)\\n T = 1.0\\n T_min = 0.000001\\n alpha = 0.98\\n while T > T_min:\\n i = 1\\n while i <= 1000:\\n new_solution = neighbors(solution)\\n new_cost = cost(new_solution,num_constraints,constraints)\\n if new_cost == 0:\\n return new_solution,new_cost\\n ap = acceptance_probability(old_cost, new_cost, T)\\n if ap > random.random():\\n solution = new_solution\\n old_cost = new_cost\\n i += 1\\n T = T*alpha\\n return solution, old_cost\\n\\n s = copy.copy(wizards)\\n random.shuffle(s)\\n ret = anneal(s,num_constraints,constraints)\\n \\n for i in range(10):\\n if ret[1] == 0:\\n break\\n random.shuffle(s)\\n new_ret = anneal(s,num_constraints,constraints)\\n print(i)\\n if new_ret[1] < ret[1]:\\n ret = new_ret\\n print(\\\"constraints failed: {0}\\\".format(ret[1]))\\n return ret[0]\",\n \"def regularization_loss(params: hk.Params) -> jnp.ndarray:\\r\\n\\r\\n # L1 Loss\\r\\n sum_in_layer = lambda p: jnp.sum(jnp.abs(p))\\r\\n sum_p_layers = [sum_in_layer(p) for p in jax.tree_leaves(params)]\\r\\n l1_loss = sum(sum_p_layers)\\r\\n\\r\\n # L2 Loss\\r\\n l2_loss = 0.5 * sum(jnp.sum(jnp.square(p)) for p in jax.tree_leaves(params))\\r\\n\\r\\n return l2_coef * l2_loss + l1_coef * l1_loss\",\n \"def loss_function(self, prbs, labels, mask):\\n\\t\\t# Using boolean mask\\n\\t\\tloss = tf.keras.losses.sparse_categorical_crossentropy(labels, prbs)\\n\\t\\tsum_loss = tf.reduce_sum(tf.boolean_mask(loss, mask))\\n\\n\\t\\treturn sum_loss\",\n \"def compute_triplet_loss(y_pred, margin=0.2):\\n anchor_feature, positive_feature, negative_feature = y_pred\\n\\n with tf.name_scope(\\\"triplet_loss\\\"):\\n d_p_squared = tf.square(compute_euclidean_distance(anchor_feature, positive_feature))\\n d_n_squared = tf.square(compute_euclidean_distance(anchor_feature, negative_feature))\\n\\n loss = tf.maximum(0., d_p_squared - d_n_squared + margin)\\n #loss = d_p_squared - d_n_squared + margin\\n\\n return tf.reduce_mean(loss), tf.reduce_mean(d_p_squared), tf.reduce_mean(d_n_squared)\",\n \"def objective_constraints(self, variables, mask, load, generation, reservations=None):\\n constraint_list = []\\n constraint_list += [cvx.NonPos(-variables['regu_c'])]\\n constraint_list += [cvx.NonPos(-variables['regd_c'])]\\n constraint_list += [cvx.NonPos(-variables['regu_d'])]\\n constraint_list += [cvx.NonPos(-variables['regd_d'])]\\n # p = opt_vars['dis'] - opt_vars['ch']\\n # constraint_list += [cvx.NonPos(opt_vars['regd_d'] - cvx.pos(p))]\\n # constraint_list += [cvx.NonPos(opt_vars['regu_c'] - cvx.neg(p))]\\n if self.combined_market:\\n constraint_list += [cvx.Zero(variables['regd_d'] + variables['regd_c'] - variables['regu_d'] - variables['regu_c'])]\\n\\n return constraint_list\",\n \"def gen2_constraint(model):\\n return 20, model.g[2], 100\",\n \"def shape_loss(self, pred_vertices, gt_vertices, has_smpl):\\n pred_vertices_with_shape = pred_vertices[has_smpl == 1]\\n gt_vertices_with_shape = gt_vertices[has_smpl == 1]\\n if len(gt_vertices_with_shape) > 0:\\n return self.criterion_shape(pred_vertices_with_shape, gt_vertices_with_shape)\\n else:\\n return torch.FloatTensor(1).fill_(0.).to(self.device)\",\n \"def rule(model, d, i, j):\\n off = d * 48\\n num = np.arange(self.num_timeslots / 7)\\n total = (model.T_end[d, j] - num[i] + 1) / 48\\n return -EPS, model.T0_end[i + off, j] - total, 1 - EPS\",\n \"def mse_loss(angles_gt, angles_gen):\\n loss = (angles_gt - angles_gen)**2\\n # loss = torch.sum(loss, dim=-1) # sum loss over dimensions\\n loss = torch.mean(loss, dim=-1) # mean loss over images per task\\n loss = torch.mean(loss, dim=-1) # mean loss over tasks\\n return loss\",\n \"def main_constraints(self, batch, l_suff_stats):\\n\\n if self.mode == 'parametric':\\n kl = 'i-projection'\\n else:\\n kl = 'm-projection'\\n policy = self.mc.get('policy', target=False)\\n t_states = torch.Tensor(batch.states)\\n t_policy = self.mc.get('policy', target=True)\\n target_suff_stats = t_policy.forward(t_states).detach()\\n\\n # split constraint if wanted\\n if self.split_constraint:\\n\\n num_dims = target_suff_stats.size()[1]\\n constraints = []\\n for d in range(num_dims):\\n c = (self.v[d] - policy.kl_divergence(batch, l_suff_stats[d+1], kl, 'mean'))\\n constraints.append(c)\\n\\n else:\\n constraints = [(self.v[0] - policy.kl_divergence(batch, l_suff_stats[0], kl, 'mean'))]\\n\\n return constraints\",\n \"def triplet_loss(y_true, y_pred, alpha = 0.3):\\n \\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\\n \\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\\n # Step 3: subtract the two previous distances and add alpha(learning variable).\\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0.0))\\n \\n return loss\",\n \"def get_GNS_cut_reduced(self):\\n # we build the optimization around the casted digraph instead of multidigraph\\n # for simplicity\\n G = self.base_digraph\\n s_1 = self.sources[0]\\n s_2 = self.sources[1]\\n t_1 = self.destinations[0]\\n t_2 = self.destinations[1]\\n edges = G.edges()\\n nodes = G.nodes()\\n\\n try:\\n\\n # Great an gurobi instance of the optimization model\\n m = Model(\\\"GNS\\\")\\n m.setParam('OutputFlag', False)\\n\\n x_v = {}\\n # vertex variables for s_1, t_1 cut\\n for v in nodes:\\n x_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n y_v = {}\\n # vertex variables for s_2, t_2 cut\\n for v in nodes:\\n y_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n z_v = {}\\n # vertex variables for s_2, t_1 cut\\n for v in nodes:\\n z_v[v] = m.addVar(vtype=GRB.BINARY)\\n\\n e = {}\\n # GNS indicator variable\\n for (u,v) in edges:\\n e[u,v] = m.addVar(vtype=GRB.BINARY, obj=G[u][v]['capacity'])\\n\\n # Done with decision variable creation\\n # update model\\n m.update()\\n\\n # Constraints\\n # 1. Constraints for s_1 - t_1 cut\\n for (u,v) in edges:\\n if (u,v) == (s_1, t_1):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_1:\\n m.addConstr(x_v[v] + e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-x_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(x_v[v] - x_v[u] + e[u,v] >= 0)\\n\\n if (u,v) == (s_2, t_2):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(y_v[v] + e[u,v] >= 1)\\n elif v == t_2:\\n m.addConstr(-y_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(y_v[v] - y_v[u] + e[u,v] >= 0)\\n\\n if (u,v) == (s_2, t_1):\\n m.addConstr(e[u,v] >= 1)\\n elif u == s_2:\\n m.addConstr(z_v[v] + e[u,v] >= 1)\\n elif v == t_1:\\n m.addConstr(-z_v[u] + e[u,v] >= 0)\\n else:\\n m.addConstr(z_v[v] - z_v[u] + e[u,v] >= 0)\\n\\n m.optimize()\\n\\n if m.status == GRB.status.OPTIMAL:\\n #print \\\"Min GNS cut value = \\\" + str(m.objVal)\\n #print \\\"GNS cut edges:\\\"\\n cut_set_edges = []\\n for u,v in edges:\\n if e[u,v].x != 0:\\n #print (u,v), str(G[u][v]['capacity'])\\n cut_set_edges.append((u,v, G[u][v]['capacity']))\\n return (m.objVal, cut_set_edges)\\n else:\\n # something went wrong...err...\\n print \\\"Something was wrong\\\"\\n return None, None\\n\\n except GurobiError:\\n print ('Error report from Gurobi')\",\n \"def loss_total(self, mask):\\n\\n def loss(y_true, y_pred):\\n\\n # Compute predicted image with non-hole pixels set to ground truth\\n y_comp = mask * y_true + (1-mask) * y_pred\\n\\n # Compute the vgg features. \\n if self.vgg_device:\\n with tf.device(self.vgg_device):\\n vgg_out = self.vgg(y_pred)\\n vgg_gt = self.vgg(y_true)\\n vgg_comp = self.vgg(y_comp)\\n else:\\n vgg_out = self.vgg(y_pred)\\n vgg_gt = self.vgg(y_true)\\n vgg_comp = self.vgg(y_comp)\\n \\n # Compute loss components\\n l1 = self.loss_valid(mask, y_true, y_pred)\\n l2 = self.loss_hole(mask, y_true, y_pred)\\n l3 = self.loss_perceptual(vgg_out, vgg_gt, vgg_comp)\\n l4 = self.loss_tv(mask, y_comp)\\n l5 = - 0.5 * K.sum(1 + self.z_log_var -self.cl - K.square(self.z_mean)/K.exp(self.cl) - K.exp(self.z_log_var)/K.exp(self.cl))\\n # Return loss function\\n return l1 + 6*l2 + 0.05*l3 + 0.1*l4 +l5 \\n return loss\",\n \"def eta_l(self, children, coef_t, coef_r):\\n with tf.compat.v1.name_scope('coef_l'):\\n children = tf.cast(children, tf.float32)\\n batch_size = tf.shape(input=children)[0]\\n max_tree_size = tf.shape(input=children)[1]\\n # creates a mask of 1's and 0's where 1 means there is a child there\\n # has shape (batch_size x max_tree_size x max_children + 1)\\n mask = tf.concat(\\n [tf.zeros((batch_size, max_tree_size, 1)),\\n tf.minimum(children, tf.ones(tf.shape(input=children)))],\\n axis=2,\\n name='mask'\\n )\\n\\n # eta_l is shape (batch_size x max_tree_size x max_children + 1)\\n return tf.multiply(\\n tf.multiply((1.0 - coef_t), (1.0 - coef_r)), mask, name='coef_l'\\n )\\n\\n # def aggregation_layer(self, nodes_representation, w_attention):\\n # nodes_representation is (batch_size, max_graph_size, self.node_dim)\\n \\n # with tf.compat.v1.name_scope(\\\"global_attention\\\"):\\n # batch_size = tf.shape(input=nodes_representation)[0]\\n # max_tree_size = tf.shape(input=nodes_representation)[1]\\n\\n # (batch_size * max_graph_size, self.node_dim)\\n # flat_nodes_representation = tf.reshape(nodes_representation, [-1, self.node_dim])\\n # aggregated_vector = tf.matmul(flat_nodes_representation, w_attention)\\n\\n # attention_score = tf.reshape(aggregated_vector, [-1, max_tree_size, 1])\\n\\n \\\"\\\"\\\"A note here: softmax will distributed the weights to all of the nodes (sum of node weghts = 1),\\n an interesting finding is that for some nodes, the attention score will be very very small, i.e e-12, \\n thus making parts of aggregated vector becomes near zero and affect on the learning (very slow nodes_representationergence\\n - Better to use sigmoid\\\"\\\"\\\"\\n\\n \\n # attention_weights = tf.nn.softmax(attention_score, axis=1)\\n \\n # attention_weights = tf.nn.sigmoid(attention_score)\\n\\n # TODO: reduce_max vs reduce_sum vs reduce_mean\\n # if aggregation_type == 1:\\n # print(\\\"Using tf.reduce_sum...........\\\")\\n # weighted_average_nodes = tf.reduce_sum(input_tensor=tf.multiply(nodes_representation, attention_weights), axis=1)\\n # if aggregation_type == 2:\\n # print(\\\"Using tf.reduce_max...........\\\")\\n # weighted_average_nodes = tf.reduce_max(tf.multiply(nodes_representation, attention_weights), axis=1)\\n # if aggregation_type == 3:\\n # print(\\\"Using tf.reduce_mean...........\\\")\\n # weighted_average_nodes = tf.reduce_mean(tf.multiply(nodes_representation, attention_weights), axis=1)\\n\\n # return weighted_average_nodes, attention_weights\",\n \"def triplet_loss(y_true, y_pred, alpha = 0.2):\\n \\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\\n # Step 3: subtract the two previous distances and add alpha.\\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), alpha)\\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0))\\n \\n return loss\",\n \"def __call__(self, box_outputs, labels):\\n with tf.name_scope('rpn_loss'):\\n levels = sorted(box_outputs.keys())\\n\\n box_losses = []\\n for level in levels:\\n box_losses.append(self._rpn_box_loss(box_outputs[level], labels[level]))\\n\\n # Sum per level losses to total loss.\\n return tf.add_n(box_losses)\",\n \"def loss_fn(self, recons, inputs, mu, log_var, **kwargs):\\n# kld_weight = kwargs['M_N'] # Account for the minibatch samples from the dataset\\n recons_loss = F.mse_loss(recons, inputs)\\n# recons_loss = F.binary_cross_entropy(recons, inputs)\\n KLD = torch.mean(-0.5 * torch.sum(1 + log_var - mu**2 - log_var.exp(), dim=1), dim=0)\\n loss = recons_loss - KLD\\n return loss, recons_loss, KLD\",\n \"def compute_triplet_loss(anchor_feature, positive_feature, negative_feature, margin):\\n\\n with tf.variable_scope('triplet_loss'):\\n pos_dist = compute_euclidean_distance(anchor_feature, positive_feature, positive=True)\\n neg_dist = compute_euclidean_distance(anchor_feature, negative_feature, positive=False)\\n\\n basic_loss = tf.add(tf.subtract(pos_dist, neg_dist), margin)\\n loss = tf.reduce_mean(tf.maximum(basic_loss, 0.0), 0)\\n\\n return loss, tf.reduce_mean(pos_dist), tf.reduce_mean(neg_dist)\",\n \"def gen_gp_loss(gp):\\n def loss(_, H):\\n dlik_dh_times_H = H * K.gather(gp.dlik_dh, gp.batch_ids[:gp.batch_sz])\\n return K.sum(dlik_dh_times_H, axis=1, keepdims=True)\\n return loss\",\n \"def s_penalty(self, triples, nodes):\\n\\n s_index, p_index, o_index = split_spo(triples)\\n\\n s, p, o = nodes[s_index, :], self.relations[p_index, :], nodes[o_index, :]\\n\\n return s.pow(2).mean() + p.pow(2).mean() + o.pow(2).mean()\",\n \"def loss_fn(self, lbl, y):\\n\\n binlbl = self._to_device(lbl[:,0]>.5)\\n # center = self._to_device(lbl[:,3]) \\n offset = 5. * self._to_device(lbl[:,1:]) \\n\\n loss = self.criterion(y[:,:2], offset) \\n loss2 = self.criterion2(y[:,2], binlbl)\\n\\n # loss3 = self.criterion(y[:,3], center)\\n\\n loss = loss + loss2\\n return loss\",\n \"def vertex_loss(self, pred_vertices, gt_vertices, has_smpl):\\n conf = has_smpl.float()\\n loss_vertex = self.criterion_vertex(pred_vertices, gt_vertices)\\n loss_vertex = (conf[:, None, None] * loss_vertex).mean()\\n return loss_vertex\",\n \"def constraints(self) -> Tuple[NDArray, NDArray]:\",\n \"def G(self, (k,t), (j,x), **params):\\n d = len(x)/2\\n q,dq = x[:d],x[d:]\\n J = (j == True)\\n _J = np.logical_not(J)\\n # number of constraints\\n n = len(J) \\n # number of active constraints\\n m = np.sum(J) # = n - len(a)\\n a = self.a( (k,t), (_J,q), **params)\\n lambda_ = self.lambda_( (k,t), (J,q,dq), **params)\\n # unilateral constraint forces\\n lambda_ = lambda_[:m] \\n g = np.nan*np.zeros(n)\\n g[_J] = a\\n g[J] = lambda_\\n return g\",\n \"def triplet_loss(y_true, y_pred, margin = 1):\\n\\n anchor = y_pred[0]\\n positive = y_pred[1]\\n negative = y_pred[2]\\n\\n # squared distance between the anchor and the positive\\n pos_dist = tf.math.reduce_sum(tf.math.square(anchor - positive), axis=-1)\\n\\n # squared distance between the anchor and the negative\\n neg_dist = tf.math.reduce_sum(tf.math.square(anchor - negative), axis=-1)\\n\\n # compute loss\\n basic_loss = margin + pos_dist - neg_dist\\n loss = tf.math.maximum(basic_loss,0.0)\\n loss = tf.math.reduce_mean(loss)\\n return loss\",\n \"def l1_regularization(variables, factor=1e-4, name='l1_regularization', collections=['regularization']):\\n l1 = tf.add_n([tf.reduce_sum(tf.abs(var)) for var in variables], name=name) if variables else tf.constant(0.)\\n loss = factor * l1\\n scalar_summary(loss, name, collections)\\n return loss\",\n \"def ridge_regression(y, tx, lambda_):\\n N = tx.shape[0]\\n a = tx.T.dot(tx) + 2 * N * lambda_ * np.identity(tx.shape[1])\\n b = tx.T.dot(y)\\n w = np.linalg.solve(a, b)\\n loss = compute_loss_LS(y, tx, w) \\n return loss, w\",\n \"def prediction_aggregation(self, xt_s,mu_s,var_s, method='PoE', weighting='uniform', power=26):\\n\\n nt = xt_s.shape[0]\\n mu = np.zeros([nt, self.C],dtype='float64')\\n var = np.zeros([nt, self.C],dtype='float64')\\n\\n prior_var = self.experts[0].kernel(xt_s[0], xt_s[0])\\n\\n \\n #Process each latent gp individually \\n for j in range(self.C):\\n \\n mu_s_c = mu_s[:, :, j]\\n var_s_c = var_s[:, :, j]\\n \\n weight_matrix = compute_weights(mu_s_c, var_s_c, power, weighting, prior_var)\\n \\n prec_s= 1/var_s_c\\n\\n if method == 'PoE':\\n \\n prec = tf.reduce_sum(prec_s, axis=0)\\n \\n\\n if method == 'gPoE':\\n \\n weight_matrix = normalize_weights(weight_matrix)\\n\\n prec = tf.reduce_sum(weight_matrix * prec_s , axis=0)\\n \\n\\n if method == 'BCM':\\n \\n prec = tf.reduce_sum(prec_s, axis=0) + (1 - self.M) / prior_var \\n\\n if method == 'rBCM':\\n \\n \\n prec = tf.reduce_sum(weight_matrix * prec_s, axis=0) \\\\\\n + (1 - tf.reduce_sum(weight_matrix, axis=0)) / prior_var\\n \\n \\n \\n if method != 'bar':\\n \\n var[:, j] = 1 / prec\\n\\n mu[:, j] = var[:, j] * tf.reduce_sum(weight_matrix * prec_s * mu_s_c, axis=0)\\n \\n else:\\n \\n weight_matrix = normalize_weights(weight_matrix)\\n\\n mu[:, j] = tf.reduce_sum(weight_matrix * mu_s_c, axis=0)\\n var[:, j] = tf.reduce_sum(weight_matrix * var_s_c, axis=0)\\n \\n \\n return self.lik_aggregation(mu, var)\",\n \"def scenario_cost_rule(_m, y, s):\\r\\n\\r\\n return m.OP_T[y, s] + m.OP_H[y, s] + m.OP_W[y, s] + m.OP_S[y, s] + m.OP_Q[y, s] + m.OP_L[y, s]\",\n \"def rule(model, k):\\n if self.category_days_total[k] <= 0:\\n return Constraint.Feasible\\n return self.category_days_total[k], model.S_cat_total[k], None\",\n \"def step(self, closure):\\r\\n self.state['step'] += 1\\r\\n for y_ind in range(self.dim_out):\\r\\n err = closure(y_ind)\\r\\n for group_ind in range(len(self.param_groups)):\\r\\n group = self.param_groups[group_ind]\\r\\n iekf_mat = self.state['iekf_groups'][group_ind]\\r\\n for ii, w in enumerate(group['params']):\\r\\n if w.grad is None:\\r\\n continue\\r\\n H_n = iekf_mat[ii]['H']\\r\\n grad = w.grad.data.detach()\\r\\n if len(w.size()) > 1:\\r\\n grad = grad.transpose(1, 0)\\r\\n grad = grad.contiguous().view((1, -1))\\r\\n if y_ind == 0:\\r\\n H_n = grad\\r\\n else:\\r\\n H_n = torch.cat([H_n, grad], dim=0)\\r\\n self.state['iekf_groups'][group_ind][ii]['H'] = H_n\\r\\n\\r\\n err_T = err.transpose(0, 1)\\r\\n\\r\\n for group_ind in range(len(self.param_groups)):\\r\\n group = self.param_groups[group_ind]\\r\\n iekf_mat = self.state['iekf_groups'][group_ind]\\r\\n for ii, w in enumerate(group['params']):\\r\\n if w.grad is None:\\r\\n continue\\r\\n\\r\\n lbd_n = iekf_mat[ii]['lbd']\\r\\n P_n = iekf_mat[ii]['P']\\r\\n EPS = iekf_mat[ii]['EPS']\\r\\n H_n = iekf_mat[ii]['H']\\r\\n H_n_T = H_n.transpose(0, 1)\\r\\n if group['lbd_decay']:\\r\\n miu = 1.0 / min(self.state['step'], group['lbd_max_step'])\\r\\n lbd_n = lbd_n + miu * (err_T.mm(err).flatten()[0] / self.dim_out - lbd_n)\\r\\n self.state['iekf_groups'][group_ind][ii]['lbd'] = lbd_n\\r\\n R_n = lbd_n * torch.eye(self.dim_out, dtype=torch.float, device=iekf_mat[ii]['device'],\\r\\n requires_grad=False)\\r\\n\\r\\n g_n = R_n + H_n.mm(P_n).mm(H_n_T)\\r\\n g_n = g_n.inverse()\\r\\n\\r\\n K_n = P_n.mm(H_n_T).mm(g_n)\\r\\n delta_w = K_n.mm(err)\\r\\n if len(w.size()) > 1:\\r\\n delta_w = delta_w.view((w.size(1), w.size(0))).transpose(1, 0)\\r\\n else:\\r\\n delta_w = delta_w.view(w.size())\\r\\n\\r\\n new_P = (group['alpha'] + 1) * (P_n - K_n.mm(H_n).mm(P_n) + EPS)\\r\\n self.state['iekf_groups'][group_ind][ii]['P'] = new_P\\r\\n\\r\\n w.data.add_(delta_w)\\r\\n\\r\\n return err\",\n \"def RHSnet(y,t,a,b0,b1,g,k,w):\\n S = y[:N]\\n E = y[N:2*N]\\n C = y[2*N:3*N]\\n b = b0 + b1*(1+np.cos(2*np.pi*t))\\n dy = np.zeros(3*N)\\n dy[:N]= k*(1-S)-b*C*S+w*np.dot(P,S)-w*S\\n dy[N:2*N]= b*C*S-(k+a)*E+w*np.dot(P,E)-w*E\\n dy[2*N:3*N]= a*E-(g+k)*C+w*np.dot(P,C)-w*C\\n return dy\",\n \"def loss_criterion(self, result, labels):\\n\\n w = self.kd_weight\\n t = self.temperature\\n\\n gt_loss = F.cross_entropy(result[\\\"outs\\\"], labels)\\n\\n # Weird way to get 0 tensor\\n kd_loss = gt_loss.detach() * 0.0\\n\\n for v in result[\\\"teacher_out_list\\\"]:\\n # Multiplying by 100 to keep losses roughly comparable\\n kd_loss += nn.KLDivLoss()(\\n F.log_softmax(result[\\\"outs\\\"] / t, dim=1),\\n F.softmax(v / t, dim=1)\\n ) * 100.0\\n\\n kd_loss /= len(result[\\\"teacher_out_list\\\"])\\n\\n # Weigh kd_loss with t^2 to preserve scale of gradients\\n final_loss = (kd_loss * w * t * t) + (gt_loss * (1 - w))\\n\\n return {\\n \\\"loss\\\": final_loss,\\n \\\"gt_loss\\\": gt_loss,\\n \\\"kd_loss\\\": kd_loss\\n }\",\n \"def svm_loss(x, y):\\n x = np.squeeze(x)\\n N = x.shape[0]\\n yt = y\\n yt[y==0]=-1\\n tmp = 1-yt*x\\n mask = np.ones_like(tmp)\\n mask[tmp<=0] = 0\\n tmp = tmp*mask\\n loss = np.sum(tmp)/N\\n \\n dx = -yt*mask/N\\n # dx = np.reshape(dx,[dx.shape[0],1])\\n return loss, dx\",\n \"def get_loss(self, x):\\n x = self.normalize(x)\\n pernalty_func = 0\\n if self.coincide_fun is not None:\\n tmp_res = self.coincide_fun(x)\\n for i in range(self.cons_num):\\n cons = self.constrain[i]\\n self.loss_list[i] = cons(x, tmp_res)\\n pernalty_tmp = self.pow(self.relu(self.mul_k[i] / self.sigma_k + self.loss_list[i]), self.pow_rate)\\\\\\n - self.pow((self.mul_k[i] / self.sigma_k), self.pow_rate)\\n pernalty_func += pernalty_tmp\\n objective_val = self.objective_func(x, tmp_res)\\n else:\\n for i in range(self.cons_num):\\n cons = self.constrain[i]\\n self.loss_list[i] = cons(x)\\n pernalty_tmp = self.pow(self.relu(self.mul_k[i] / self.sigma_k + self.loss_list[i]), self.pow_rate)\\\\\\n - self.pow((self.mul_k[i] / self.sigma_k), self.pow_rate)\\n pernalty_func += pernalty_tmp\\n objective_val = self.objective_func(x)\\n loss1 = self.obj_weight * objective_val\\n lagrangian_func = loss1 + self.sigma_k / 2 * pernalty_func\\n res = [lagrangian_func, self.loss_list, objective_val, x]\\n return res\",\n \"def get_rhs(self, mol_orbs, task, ops):\\n if 'x' in ops or 'y' in ops or 'z' in ops:\\n prop = {k: v for k, v in zip('xyz', self.get_dipole(task))}\\n den = mol_orbs.get_density(task.molecule)\\n da = den.alpha_to_numpy(0)\\n db = den.beta_to_numpy(0)\\n D = da + db\\n S = self.get_overlap(task)\\n mo = mol_orbs.alpha_to_numpy()\\n\\n matrices = tuple([mo.T@(S@D@prop[p].T - prop[p].T@D@S)@mo for p in ops])\\n gradients = tuple([self.mat2vec(m, mol_orbs, task) for m in matrices])\\n return gradients\",\n \"def loss_grid(self, output, target):\\n pass\",\n \"def triplet_loss(y_true, y_pred, alpha=0.2):\\n\\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\\n\\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\\n pos_dist = K.sum(K.square(anchor - positive), axis=-1)\\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\\n neg_dist = K.sum(K.square(anchor - negative), axis=-1)\\n # Step 3: subtract the two previous distances and add alpha.\\n basic_loss = pos_dist - neg_dist + alpha\\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\\n loss = K.sum(K.maximum(basic_loss, 0))\\n\\n return loss\",\n \"def model_loss(inp, fake, real_label, fake_label):\\n \\n \\n Dreal,realcls,R1 = gradpen(inp)\\n [Dfake,fakecls] = D(fake)\\n # 1. Adversarial loss\\n \\n glabel = tf.ones_like(Dfake)#tf.random.uniform((Dfake.shape), 1-LN, 1)\\n dlabelr = tf.ones_like(Dreal)#tf.random.uniform((Dreal.shape), 1-LN, 1)\\n dlabelf = tf.zeros_like(Dfake)#tf.random.uniform((Dfake.shape), 0, LN)\\n \\n \\n \\n # D has no sigmoid activation: \\\"from_logits=True\\\"\\n real_loss = tf.keras.losses.binary_crossentropy(\\n dlabelr, Dreal, from_logits=True)\\n real_loss = tf.reduce_mean(real_loss)\\n \\n fake_loss = tf.keras.losses.binary_crossentropy(\\n dlabelf, Dfake, from_logits=True)\\n fake_loss = tf.reduce_mean(fake_loss)\\n \\n Dadv = 0.5*(real_loss+fake_loss)\\n \\n Gadv = tf.keras.losses.binary_crossentropy(\\n glabel, Dfake, from_logits=True)\\n Gadv = tf.reduce_mean(Gadv)\\n \\n # 2. Classification loss\\n \\n Dcls = tf.keras.losses.binary_crossentropy(real_label, realcls, from_logits=True)\\n Dcls = tf.reduce_mean(Dcls)\\n \\n Gcls = tf.keras.losses.binary_crossentropy(fake_label, fakecls, from_logits=True)\\n Gcls = tf.reduce_mean(Gcls)\\n \\n # 3. Total loss\\n \\n Dloss = Dadv + (GAMMA/2)*R1 + LAMBDA_CLS*Dcls\\n \\n Gloss = Gadv + LAMBDA_CLS*Gcls\\n \\n return (Dloss, Dadv, Dcls, R1), (Gloss, Gadv, Gcls)\",\n \"def past_weight_grad_calculator2(xs, es, kp_x, kd_x, kp_e, kd_e, shapes):\\n kp_x, kd_x, kp_e, kd_e = [as_floatx(k) for k in (kp_x, kd_x, kp_e, kd_e)]\\n n_samples, n_in, n_out = shapes\\n rx = kd_x/(kp_x+kd_x)\\n re = kd_e/(kp_e+kd_e)\\n\\n xr = create_shared_variable(np.zeros((n_samples, n_in)))\\n er = create_shared_variable(np.zeros((n_samples, n_out)))\\n\\n\\n\\n\\n # xr_new = xr*rx + xs/(kp_x+kd_x)\\n # er_new = er*re + es/(kp_e+kd_e)\\n\\n arr = rx*re/(1-rx*re)\\n\\n xr_new = xr*arr + xs/(kp_x+kd_x)\\n er_new = er*arr + es/(kp_e+kd_e)\\n\\n xsum = create_shared_variable(np.zeros((n_samples, n_in)))\\n esum = create_shared_variable(np.zeros((n_samples, n_out)))\\n\\n xsum_new = xsum+xr_new\\n esum_new = esum+er_new\\n\\n x_nospikes = tt.eq(xs, 0)\\n e_nospikes = tt.eq(es, 0)\\n\\n dw = xs.T.dot(esum_new) + xsum_new.T.dot(es)\\n\\n add_update(xr, xr_new)\\n add_update(er, er_new)\\n add_update(xsum, xsum_new*x_nospikes)\\n add_update(esum, esum_new*e_nospikes)\\n\\n return xs.T.dot(er) + xr.T.dot(es)\\n # return xr.T.dot(er)\\n # return dw\",\n \"def rule(model):\\n num = self.num_timeslots\\n ind_j = model.tasks\\n total = sum(model.A2[num-1, j] for j in ind_j)\\n total += sum(model.A3[num-1, j] for j in ind_j)\\n total += sum(model.A4[num-1, j] for j in ind_j)\\n total += sum(model.A3[num-2, j] for j in ind_j)\\n total += sum(model.A4[num-2, j] for j in ind_j)\\n total += sum(model.A4[num-3, j] for j in ind_j)\\n return None, total, 0\",\n \"def triplet_loss(y_true, y_pred, alpha=0.2):\\n\\n anchor, positive, negative = y_pred[0], y_pred[1], y_pred[2]\\n\\n # Step 1: Compute the (encoding) distance between the anchor and the positive, you will need to sum over axis=-1\\n pos_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, positive)), axis=-1)\\n # Step 2: Compute the (encoding) distance between the anchor and the negative, you will need to sum over axis=-1\\n neg_dist = tf.reduce_sum(tf.square(tf.subtract(anchor, negative)), axis=-1)\\n # Step 3: subtract the two previous distances and add alpha.\\n basic_loss = (pos_dist - neg_dist) + alpha\\n # Step 4: Take the maximum of basic_loss and 0.0. Sum over the training examples.\\n loss = tf.reduce_sum(tf.maximum(basic_loss, 0))\\n\\n return loss\",\n \"def remaining_constraints(self):\\r\\n \\r\\n def iec1(state,decision,nodes):\\r\\n return decision['E:L']+decision['E:R_1']<=nodes['E'].get_preds_value(state)\\r\\n def iec2(state,decision,nodes):\\r\\n return decision['R_1:L']<=nodes['R_1'].get_preds_value(state)\\r\\n def iec3(state,decision,nodes):\\r\\n return decision['G:R_1']>=-(nodes['R_1'].get_preds_value(state)) \\r\\n def iec4(state,decision,nodes):\\r\\n return decision['G:L']>=0.0\\r\\n def iec5(state,decision,nodes):\\r\\n return decision['E:L']>=0.0\\r\\n def iec6(state,decision,nodes):\\r\\n return decision['E:R_1']>=0.0\\r\\n def iec7(state,decision,nodes):\\r\\n return decision['R_1:L']>=0.0\\r\\n\\r\\n Inequality_Constraints=[iec1,iec2,iec3,iec4,iec5,iec6,iec7]\\r\\n \\r\\n return Inequality_Constraints\",\n \"def loss(L, S, A, R, Y, alpha, beta, gamma, delta):\\n return alpha*load_imbalance(Y,L,A) + beta*constraints(Y,A) + gamma*transfers(Y,R,S) + delta*choice(Y)\",\n \"def loss_fn(model):\\n with flax.nn.stateful(state) as new_state:\\n with flax.nn.stochastic(prng_key):\\n logits = model(batch['image'])\\n loss = cross_entropy_loss(logits, batch['label'])\\n # TODO(britefury): check if applying L2 regularization to weights but\\n # *not* biases improves results\\n weight_penalty_params = jax.tree_leaves(model.params)\\n weight_l2 = sum([jnp.sum(x ** 2)\\n for x in weight_penalty_params\\n if x.ndim > 1])\\n weight_penalty = l2_reg * 0.5 * weight_l2\\n loss = loss + weight_penalty\\n return loss, (new_state, logits)\",\n \"def validate(nnet_model, type_nnet, dataset, type_KL, num_samples, latent_dim, covar_module0, covar_module1, likelihoods, \\n zt_list, T, weight, train_mu, train_x, id_covariate, loss_function, eps=1e-6):\\n\\n print(\\\"Testing the model with a validation set\\\")\\n T=16\\n device = torch.device(\\\"cuda\\\" if torch.cuda.is_available() else \\\"cpu\\\")\\n\\n batch_size = T\\n assert (type_KL == 'GPapprox_closed' or type_KL == 'GPapprox')\\n\\n # set up Data Loader for training\\n dataloader = DataLoader(dataset, batch_size=batch_size, shuffle=False, num_workers=4)\\n\\n Q = len(dataset[0]['label'])\\n P = len(dataset) // T\\n\\n full_mu = torch.zeros(len(dataset), latent_dim, dtype=torch.double, requires_grad=True).to(device)\\n full_log_var = torch.zeros(len(dataset), latent_dim, dtype=torch.double, requires_grad=True).to(device)\\n full_labels = torch.zeros(len(dataset), Q, dtype=torch.double, requires_grad=False).to(device)\\n\\n recon_loss_sum = 0\\n nll_loss_sum = 0\\n for batch_idx, sample_batched in enumerate(dataloader):\\n indices = sample_batched['idx']\\n data = sample_batched['digit'].double().to(device)\\n mask = sample_batched['mask'].double().to(device)\\n full_labels[indices] = sample_batched['label'].double().to(device)\\n\\n covariates = torch.cat((full_labels[indices, :id_covariate], full_labels[indices, id_covariate+1:]), dim=1)\\n recon_batch, mu, log_var = nnet_model(data)\\n\\n full_mu[indices] = mu\\n full_log_var[indices] = log_var\\n\\n [recon_loss, nll] = nnet_model.loss_function(recon_batch, data, mask)\\n recon_loss = torch.sum(recon_loss)\\n nll = torch.sum(nll)\\n\\n recon_loss_sum = recon_loss_sum + recon_loss.item()\\n nll_loss_sum = nll_loss_sum + nll.item()\\n\\n gp_losses = 0\\n gp_loss_sum = 0\\n param_list = []\\n\\n if isinstance(covar_module0, list):\\n if type_KL == 'GPapprox':\\n for sample in range(0, num_samples):\\n Z = nnet_model.sample_latent(full_mu, full_log_var)\\n for i in range(0, latent_dim):\\n Z_dim = Z[:, i]\\n gp_loss = -elbo(covar_module0[i], covar_module1[i], likelihoods[i], full_labels, Z_dim,\\n zt_list[i].to(device), P, T, eps)\\n gp_loss_sum = gp_loss.item() + gp_loss_sum\\n gp_loss_sum /= num_samples\\n\\n elif type_KL == 'GPapprox_closed':\\n for i in range(0, latent_dim):\\n mu_sliced = full_mu[:, i]\\n log_var_sliced = full_log_var[:, i]\\n gp_loss = deviance_upper_bound(covar_module0[i], covar_module1[i],\\n likelihoods[i], full_labels,\\n mu_sliced, log_var_sliced,\\n zt_list[i].to(device), P,\\n T, eps)\\n gp_loss_sum = gp_loss.item() + gp_loss_sum\\n else:\\n if type_KL == 'GPapprox_closed':\\n gp_loss = validation_dubo(latent_dim, covar_module0, covar_module1,\\n likelihoods, full_labels,\\n full_mu, full_log_var,\\n zt_list, P, T, eps)\\n gp_loss_sum = gp_loss.item()\\n\\n if loss_function == 'mse':\\n gp_loss_sum /= latent_dim\\n net_loss_sum = weight*gp_loss_sum + recon_loss_sum\\n elif loss_function == 'nll':\\n net_loss_sum = gp_loss_sum + nll_loss_sum\\n\\n #Do logging\\n print('Validation set - Loss: %.3f - GP loss: %.3f - NLL loss: %.3f - Recon Loss: %.3f' % (\\n net_loss_sum, gp_loss_sum, nll_loss_sum, recon_loss_sum))\\n\\n return net_loss_sum\",\n \"def l2_regularization(variables, factor=1e-4, name='l2_regularization', collections=['regularization']):\\n l2 = tf.add_n([tf.sqrt(2.*tf.nn.l2_loss(var)) for var in variables], name=name) if variables else tf.constant(0.)\\n loss = factor * l2\\n scalar_summary(loss, name, collections)\\n return loss\",\n \"def compute_loss(y, tx, w):\\n # If a is an N-D array and b is a 1-D array, it is a sum product over the last axis of a and b.\\n e = y - np.dot(tx, w)\\n loss = 1 / 2 * np.mean(e**2)\\n return loss\",\n \"def max_power_candidate_thermal_rule(_m, g, y, s, t):\\r\\n\\r\\n return m.p[g, y, s, t] - sum(m.x_c[g, j] for j in m.Y if j <= y) <= 0\",\n \"def loss(self, T, mode):\\n self.circuit.loss(T, mode)\",\n \"def __addValueConstraints(self):\\n for x in range(self.width):\\n for y in range(self.height):\\n g = self.grid[(x, y)]\\n self.solver.add(\\n Or([g == Magnets.EMPTY, g == Magnets.PLUS, g == Magnets.MINUS]))\\n if x > 0:\\n left = self.grid[(x-1, y)]\\n self.solver.add(Or([g != left, g == Magnets.EMPTY]))\\n if y > 0:\\n up = self.grid[(x, y-1)]\\n self.solver.add(Or([g != up, g == Magnets.EMPTY]))\",\n \"def eval_nt_transfer_loss_on_vali_data(self, masked_student_net_params, vali_teacher_prediction, vali_teacher_ntk_mat, density_level):\\n \\n # evaluate the student ntk matrix using validation data.\\n vali_student_ntk_mat = self.emp_ntk_fn(self.vali_inputs_1, self.vali_inputs_2, masked_student_net_params) \\n\\n # evaluate the student prediction using validation data. \\n vali_student_prediction = self.apply_fn(masked_student_net_params, self.vali_samples) \\n\\n # calculate the kernel distance, target distance, and parameter l2 loss\\n ker_dist, target_dist, param_squared_norm = self.kernel_dist_target_dist_l2_loss(vali_student_ntk_mat, vali_student_prediction, vali_teacher_ntk_mat, vali_teacher_prediction, masked_student_net_params )\\n \\n # weight these distances and sum them up.\\n weighted_ker_dist = self.LAMBDA_KER_DIST * ker_dist\\n \\n weighted_parameters_squared_norm = (self.LAMBDA_L2_REG / density_level) * param_squared_norm \\n\\n transfer_loss = weighted_ker_dist + target_dist + weighted_parameters_squared_norm\\n\\n return transfer_loss, ker_dist, target_dist, param_squared_norm\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5800624","0.5796773","0.5785705","0.5717265","0.570551","0.56547177","0.5628578","0.5609777","0.56024534","0.557875","0.557706","0.5565382","0.55586576","0.55550206","0.5553454","0.54859525","0.54835945","0.54827017","0.5469203","0.54655266","0.54564786","0.5452441","0.5443862","0.5436205","0.5433676","0.54256934","0.5418711","0.5409091","0.54075235","0.5386163","0.5349976","0.5341229","0.5339751","0.53384316","0.5332976","0.53312284","0.5321857","0.5318495","0.530963","0.5303938","0.5298825","0.52983516","0.5297438","0.5292663","0.5292324","0.52816784","0.5279055","0.5277208","0.5276299","0.52723217","0.52720475","0.52664965","0.52505326","0.52480966","0.524645","0.5244163","0.5240928","0.5238018","0.5237964","0.5234798","0.5232605","0.5221494","0.520693","0.52055246","0.5205347","0.5201373","0.5201164","0.52000254","0.5187054","0.51797944","0.5175502","0.51743054","0.5168197","0.51605666","0.5160241","0.5156691","0.51488125","0.5147776","0.5140953","0.5135375","0.5133596","0.51295537","0.5123258","0.51205826","0.5119349","0.51178414","0.5116831","0.51114994","0.51074356","0.50983757","0.5096643","0.5095889","0.50937706","0.5092379","0.5087933","0.5079351","0.50777215","0.50756633","0.507212","0.50716203","0.5059015"],"string":"[\n \"0.5800624\",\n \"0.5796773\",\n \"0.5785705\",\n \"0.5717265\",\n \"0.570551\",\n \"0.56547177\",\n \"0.5628578\",\n \"0.5609777\",\n \"0.56024534\",\n \"0.557875\",\n \"0.557706\",\n \"0.5565382\",\n \"0.55586576\",\n \"0.55550206\",\n \"0.5553454\",\n \"0.54859525\",\n \"0.54835945\",\n \"0.54827017\",\n \"0.5469203\",\n \"0.54655266\",\n \"0.54564786\",\n \"0.5452441\",\n \"0.5443862\",\n \"0.5436205\",\n \"0.5433676\",\n \"0.54256934\",\n \"0.5418711\",\n \"0.5409091\",\n \"0.54075235\",\n \"0.5386163\",\n \"0.5349976\",\n \"0.5341229\",\n \"0.5339751\",\n \"0.53384316\",\n \"0.5332976\",\n \"0.53312284\",\n \"0.5321857\",\n \"0.5318495\",\n \"0.530963\",\n \"0.5303938\",\n \"0.5298825\",\n \"0.52983516\",\n \"0.5297438\",\n \"0.5292663\",\n \"0.5292324\",\n \"0.52816784\",\n \"0.5279055\",\n \"0.5277208\",\n \"0.5276299\",\n \"0.52723217\",\n \"0.52720475\",\n \"0.52664965\",\n \"0.52505326\",\n \"0.52480966\",\n \"0.524645\",\n \"0.5244163\",\n \"0.5240928\",\n \"0.5238018\",\n \"0.5237964\",\n \"0.5234798\",\n \"0.5232605\",\n \"0.5221494\",\n \"0.520693\",\n \"0.52055246\",\n \"0.5205347\",\n \"0.5201373\",\n \"0.5201164\",\n \"0.52000254\",\n \"0.5187054\",\n \"0.51797944\",\n \"0.5175502\",\n \"0.51743054\",\n \"0.5168197\",\n \"0.51605666\",\n \"0.5160241\",\n \"0.5156691\",\n \"0.51488125\",\n \"0.5147776\",\n \"0.5140953\",\n \"0.5135375\",\n \"0.5133596\",\n \"0.51295537\",\n \"0.5123258\",\n \"0.51205826\",\n \"0.5119349\",\n \"0.51178414\",\n \"0.5116831\",\n \"0.51114994\",\n \"0.51074356\",\n \"0.50983757\",\n \"0.5096643\",\n \"0.5095889\",\n \"0.50937706\",\n \"0.5092379\",\n \"0.5087933\",\n \"0.5079351\",\n \"0.50777215\",\n \"0.50756633\",\n \"0.507212\",\n \"0.50716203\",\n \"0.5059015\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":213,"numItemsPerPage":100,"numTotalItems":95772,"offset":21300,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjQ2NDAzNCwianRpIjoiODFhNDFlODItZmY4NC00NmE3LTg5MmEtYTU1OWZkOTZjZDc3Iiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODY0Njc2MzQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.Td4P9fpwgiVjAHsbMvrNnsSd6WZ4PlMc4EyOwEUKBtRuz3Y78OqyafTxYGQPpUeA8s3htQkZeyVc9a-ocyrTBg","displayUrls":true,"splitSizeSummaries":[{"config":"default","split":"train","numRows":95772,"numBytesParquet":1928375891}]},"discussionsStats":{"closed":1,"open":1,"total":2},"fullWidth":true,"hasGatedAccess":true,"hasFullAccess":true,"isEmbedded":false,"savedQueries":{"community":[],"user":[]}}">
query stringlengths 9 3.4k | document stringlengths 9 87.4k | metadata dict | negatives listlengths 4 101 | negative_scores listlengths 4 101 | document_score stringlengths 3 10 | document_rank stringclasses 102
values |
|---|---|---|---|---|---|---|
Initialize the inference network, stream video to network, and output stats and video. | def infer_on_stream(args, client):
# Initialise the class
infer_network = Network()
# Set Probability threshold for detections
prob_threshold = args.prob_threshold
### TODO: Load the model through `infer_network` ###
infer_network.load_model(args.model,args.cpu_extension,args.device)
input_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def infer_on_stream(args, client):\n # Initialise the class\n infer_network = Network()\n # Set Probability threshold for detections\n prob_threshold = args.prob_threshold\n\n ### TODO: Load the model through `infer_network` ###\n infer_network.load_model(model=args.model,\n ... | [
"0.6657868",
"0.6654198",
"0.6620068",
"0.6584362",
"0.6474501",
"0.62960565",
"0.6276968",
"0.6220246",
"0.6160445",
"0.59733164",
"0.5964964",
"0.59312594",
"0.5894175",
"0.5887097",
"0.58308923",
"0.5786715",
"0.5768193",
"0.57668513",
"0.57543945",
"0.57250965",
"0.570893... | 0.6824545 | 0 |
Load the network and parse the output. | def main():
# Grab command line args
args = build_argparser().parse_args()
#print(args)
#Connect to the MQTT server
client = connect_mqtt()
#Perform inference on the input stream
infer_on_stream(args, client) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_network(self):\t\t\r\n\t\tself.dqn.load_network(self.path)",
"def __load_Model(self):\r\n PrintsForUser.printProcess(\"[INFO] Loading network...\")\r\n \r\n self.__model = load_model(self.__model_path)\r\n self.__lb = pickle.loads(open(self.__labels_path, \"rb\").read())",
... | [
"0.7355958",
"0.6594214",
"0.65300447",
"0.64435625",
"0.6269429",
"0.6132971",
"0.606932",
"0.5980821",
"0.5932085",
"0.5918037",
"0.591396",
"0.59083337",
"0.59021485",
"0.58683854",
"0.585857",
"0.5845249",
"0.5842063",
"0.5813572",
"0.57925004",
"0.5786059",
"0.5769666",
... | 0.0 | -1 |
The set of arguments for constructing a WorkbookTemplate resource. | def __init__(__self__, *,
galleries: pulumi.Input[Sequence[pulumi.Input['WorkbookTemplateGalleryArgs']]],
resource_group_name: pulumi.Input[str],
template_data: Any,
author: Optional[pulumi.Input[str]] = None,
localized: Optional[pulum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(__self__,\n resource_name: str,\n args: WorkbookTemplateArgs,\n opts: Optional[pulumi.ResourceOptions] = None):\n ...",
"def __init__(__self__,\n resource_name: str,\n opts: Optional[pulumi.ResourceOptions] = None... | [
"0.7442528",
"0.69924647",
"0.65530205",
"0.60074925",
"0.5782132",
"0.56032455",
"0.558455",
"0.557802",
"0.5418834",
"0.5376021",
"0.5360666",
"0.5296899",
"0.5247379",
"0.5242798",
"0.51344776",
"0.50795925",
"0.50566286",
"0.5038824",
"0.50251013",
"0.5014964",
"0.5010997... | 0.6734913 | 2 |
Workbook galleries supported by the template. | def galleries(self) -> pulumi.Input[Sequence[pulumi.Input['WorkbookTemplateGalleryArgs']]]:
return pulumi.get(self, "galleries") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def galleries(self) -> pulumi.Output[Sequence['outputs.WorkbookTemplateGalleryResponse']]:\n return pulumi.get(self, \"galleries\")",
"def get_galleries(self):\n data = self._get('get_gallery_list')\n return data['galleries']",
"def Gallery():\n return render_template(\n 'Gallery... | [
"0.8052166",
"0.6197946",
"0.585732",
"0.57718176",
"0.5716009",
"0.5657963",
"0.5653665",
"0.56315845",
"0.5574098",
"0.5572743",
"0.5434536",
"0.5415715",
"0.530429",
"0.5217824",
"0.5189865",
"0.5185198",
"0.5181188",
"0.51711136",
"0.5099473",
"0.5087812",
"0.50609577",
... | 0.82092285 | 0 |
The name of the resource group. The name is case insensitive. | def resource_group_name(self) -> pulumi.Input[str]:
return pulumi.get(self, "resource_group_name") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resource_group_name(self) -> str:\n return pulumi.get(self, \"resource_group_name\")",
"def group_name(self) -> str:\n return pulumi.get(self, \"group_name\")",
"def resource_group_name(self) -> pulumi.Output[str]:\n return pulumi.get(self, \"resource_group_name\")",
"def resource_gr... | [
"0.8591833",
"0.83624226",
"0.8203686",
"0.8203686",
"0.8203686",
"0.8203686",
"0.8203686",
"0.8203686",
"0.8203686",
"0.8203686",
"0.8203686",
"0.8203686",
"0.8203686",
"0.8203686",
"0.81753516",
"0.80862474",
"0.80862474",
"0.80862474",
"0.80862474",
"0.80862474",
"0.808624... | 0.8088815 | 48 |
Valid JSON object containing workbook template payload. | def template_data(self) -> Any:
return pulumi.get(self, "template_data") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_template_valid(template: JSONDict) -> JSONDict:\n\n errors = _rec_is_template_valid(template)\n errors.extend(_check_cyclic_defaults(template))\n\n if errors:\n msg = collate_errors(when=\"checking the template\", errors=errors)\n raise ParselglossyError(msg)\n\n return _reorder_te... | [
"0.62114877",
"0.6071935",
"0.5990931",
"0.59413725",
"0.5856608",
"0.57829463",
"0.5766327",
"0.573466",
"0.57027936",
"0.55965626",
"0.5435958",
"0.54198736",
"0.53931856",
"0.5344035",
"0.5329229",
"0.53008455",
"0.5250856",
"0.5239073",
"0.5200579",
"0.517109",
"0.5154547... | 0.48666596 | 48 |
Information about the author of the workbook template. | def author(self) -> Optional[pulumi.Input[str]]:
return pulumi.get(self, "author") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def author(self):\n\n for item in self.metadata:\n if item.tag.localname == \"creator\":\n if 'file-as' in item.tag:\n return item.tag['file-as']\n else:\n return item.tag.text",
"def author(self) -> str:\n return pulumi... | [
"0.7333974",
"0.7302022",
"0.68595636",
"0.68595636",
"0.6820945",
"0.6795719",
"0.67476195",
"0.67476195",
"0.67476195",
"0.670637",
"0.664949",
"0.65821403",
"0.6567067",
"0.64731705",
"0.64731705",
"0.6378395",
"0.63490343",
"0.634169",
"0.6178657",
"0.6116933",
"0.6079131... | 0.6291452 | 18 |
Key value pair of localized gallery. Each key is the locale code of languages supported by the Azure portal. | def localized(self) -> Optional[pulumi.Input[Mapping[str, pulumi.Input[Sequence[pulumi.Input['WorkbookTemplateLocalizedGalleryArgs']]]]]]:
return pulumi.get(self, "localized") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def localized(self) -> pulumi.Output[Optional[Mapping[str, Sequence['outputs.WorkbookTemplateLocalizedGalleryResponse']]]]:\n return pulumi.get(self, \"localized\")",
"def photo_dict(phrase):\n switcher = {\n '병원 위치': 'https://maps.googleapis.com/maps/api/staticmap?center=37.507144,127.063737&zo... | [
"0.59551746",
"0.579176",
"0.5739075",
"0.5466263",
"0.5320878",
"0.5197395",
"0.515548",
"0.5117539",
"0.5035321",
"0.50232655",
"0.5018956",
"0.49866858",
"0.4972195",
"0.49670196",
"0.49650854",
"0.49545366",
"0.4943",
"0.49376488",
"0.48790962",
"0.48603863",
"0.48575422"... | 0.5682472 | 3 |
Priority of the template. Determines which template to open when a workbook gallery is opened in viewer mode. | def priority(self) -> Optional[pulumi.Input[int]]:
return pulumi.get(self, "priority") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_template_names(self):\n self.object = self.get_object()\n\n tutor = self.request.user.profile.is_tutor()\n # return a different view if they are the owner\n if tutor and tutor == self.object.tutor:\n return self.OWNER_TEMPLATE\n # or if they booked it\n ... | [
"0.58201617",
"0.5730717",
"0.56210905",
"0.5607988",
"0.55770165",
"0.54164374",
"0.5394491",
"0.5394491",
"0.5391942",
"0.5387773",
"0.5371434",
"0.5284352",
"0.52258164",
"0.5222704",
"0.52201176",
"0.51978165",
"0.5177186",
"0.5159384",
"0.5130192",
"0.511712",
"0.5114135... | 0.0 | -1 |
The name of the Application Insights component resource. | def resource_name(self) -> Optional[pulumi.Input[str]]:
return pulumi.get(self, "resource_name") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def name(self):\n return self.raw_resource[\"name\"]",
"def name(self):\n\n return self.resource[\"metadata\"][\"name\"]",
"def name(self) -> str:\n if self._name is None:\n return 'AutoML Metric'\n else:\n return self._name",
"def name(self):\n\n retu... | [
"0.6259344",
"0.62363994",
"0.61032945",
"0.60528404",
"0.6051231",
"0.60437256",
"0.60437256",
"0.60114765",
"0.5920258",
"0.5920258",
"0.58952844",
"0.58867717",
"0.58867717",
"0.5839472",
"0.57963365",
"0.5767712",
"0.57452095",
"0.5737283",
"0.5734956",
"0.5734956",
"0.57... | 0.54356354 | 74 |
An Application Insights workbook template definition. | def __init__(__self__,
resource_name: str,
opts: Optional[pulumi.ResourceOptions] = None,
author: Optional[pulumi.Input[str]] = None,
galleries: Optional[pulumi.Input[Sequence[pulumi.Input[pulumi.InputType['WorkbookTemplateGalleryArgs']]]]] = None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_template(path_string) :\r\n today = datetime.now()\r\n today = today.strftime('%y%y%m%d%H%M%S')\r\n # print(today)\r\n temp_path = os.path.join(path_string, today)\r\n # temp_path = today\r\n # Create a workbook and add a worksheet.\r\n workbook = xlsxwriter.Workbook(f'{temp_path}.x... | [
"0.6370428",
"0.58345425",
"0.5721333",
"0.57181656",
"0.5714411",
"0.55105186",
"0.54626566",
"0.53531194",
"0.5312757",
"0.5260449",
"0.524681",
"0.52356",
"0.5232021",
"0.5198732",
"0.5188773",
"0.5172345",
"0.51696503",
"0.51567936",
"0.5105256",
"0.51019734",
"0.51006556... | 0.5570428 | 5 |
An Application Insights workbook template definition. | def __init__(__self__,
resource_name: str,
args: WorkbookTemplateArgs,
opts: Optional[pulumi.ResourceOptions] = None):
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_template(path_string) :\r\n today = datetime.now()\r\n today = today.strftime('%y%y%m%d%H%M%S')\r\n # print(today)\r\n temp_path = os.path.join(path_string, today)\r\n # temp_path = today\r\n # Create a workbook and add a worksheet.\r\n workbook = xlsxwriter.Workbook(f'{temp_path}.x... | [
"0.6370428",
"0.58345425",
"0.5721333",
"0.57181656",
"0.5570428",
"0.55105186",
"0.54626566",
"0.53531194",
"0.5312757",
"0.5260449",
"0.524681",
"0.52356",
"0.5232021",
"0.5198732",
"0.5188773",
"0.5172345",
"0.51696503",
"0.51567936",
"0.5105256",
"0.51019734",
"0.51006556... | 0.5714411 | 4 |
Get an existing WorkbookTemplate resource's state with the given name, id, and optional extra properties used to qualify the lookup. | def get(resource_name: str,
id: pulumi.Input[str],
opts: Optional[pulumi.ResourceOptions] = None) -> 'WorkbookTemplate':
opts = pulumi.ResourceOptions.merge(opts, pulumi.ResourceOptions(id=id))
__props__ = WorkbookTemplateArgs.__new__(WorkbookTemplateArgs)
__props__.__d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(template_id):\n try:\n template = Template.objects.get(pk=template_id)\n except:\n raise CMException('template_get')\n\n if not template or template.state != template_states['active']:\n raise CMException('template_get')\n\n return template",
"... | [
"0.60059094",
"0.5583698",
"0.5580275",
"0.5527408",
"0.54685605",
"0.5425252",
"0.5421419",
"0.54145896",
"0.5405498",
"0.52019465",
"0.5158618",
"0.5141349",
"0.5131247",
"0.5115271",
"0.50936675",
"0.5086638",
"0.5047412",
"0.5034328",
"0.5018827",
"0.49963653",
"0.4993864... | 0.66030896 | 0 |
Information about the author of the workbook template. | def author(self) -> pulumi.Output[Optional[str]]:
return pulumi.get(self, "author") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def author(self):\n\n for item in self.metadata:\n if item.tag.localname == \"creator\":\n if 'file-as' in item.tag:\n return item.tag['file-as']\n else:\n return item.tag.text",
"def author(self) -> str:\n return pulumi... | [
"0.7333974",
"0.7302022",
"0.68595636",
"0.68595636",
"0.6820945",
"0.6795719",
"0.67476195",
"0.67476195",
"0.67476195",
"0.664949",
"0.65821403",
"0.6567067",
"0.64731705",
"0.64731705",
"0.6378395",
"0.63490343",
"0.634169",
"0.6291452",
"0.6178657",
"0.6116933",
"0.607913... | 0.670637 | 9 |
Workbook galleries supported by the template. | def galleries(self) -> pulumi.Output[Sequence['outputs.WorkbookTemplateGalleryResponse']]:
return pulumi.get(self, "galleries") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def galleries(self) -> pulumi.Input[Sequence[pulumi.Input['WorkbookTemplateGalleryArgs']]]:\n return pulumi.get(self, \"galleries\")",
"def get_galleries(self):\n data = self._get('get_gallery_list')\n return data['galleries']",
"def Gallery():\n return render_template(\n 'Galler... | [
"0.82092285",
"0.6197946",
"0.585732",
"0.57718176",
"0.5716009",
"0.5657963",
"0.5653665",
"0.56315845",
"0.5574098",
"0.5572743",
"0.5434536",
"0.5415715",
"0.530429",
"0.5217824",
"0.5189865",
"0.5185198",
"0.5181188",
"0.51711136",
"0.5099473",
"0.5087812",
"0.50609577",
... | 0.8052166 | 1 |
Key value pair of localized gallery. Each key is the locale code of languages supported by the Azure portal. | def localized(self) -> pulumi.Output[Optional[Mapping[str, Sequence['outputs.WorkbookTemplateLocalizedGalleryResponse']]]]:
return pulumi.get(self, "localized") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def photo_dict(phrase):\n switcher = {\n '병원 위치': 'https://maps.googleapis.com/maps/api/staticmap?center=37.507144,127.063737&zoom=16&size=640x480&markers=color:blue%7Clabel:S%7C37.507144,127.063737&key=AIzaSyCF-XXYf7IW1mkUZFeZF84BCcZdtC-z1M0',\n '병원 운영시간': 'http://gunn.pausd.org/sites/default/fil... | [
"0.579176",
"0.5739075",
"0.5682472",
"0.5466263",
"0.5320878",
"0.5197395",
"0.515548",
"0.5117539",
"0.5035321",
"0.50232655",
"0.5018956",
"0.49866858",
"0.4972195",
"0.49670196",
"0.49650854",
"0.49545366",
"0.4943",
"0.49376488",
"0.48790962",
"0.48603863",
"0.48575422",... | 0.59551746 | 0 |
Priority of the template. Determines which template to open when a workbook gallery is opened in viewer mode. | def priority(self) -> pulumi.Output[Optional[int]]:
return pulumi.get(self, "priority") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_template_names(self):\n self.object = self.get_object()\n\n tutor = self.request.user.profile.is_tutor()\n # return a different view if they are the owner\n if tutor and tutor == self.object.tutor:\n return self.OWNER_TEMPLATE\n # or if they booked it\n ... | [
"0.58201617",
"0.5730717",
"0.56210905",
"0.5607988",
"0.55770165",
"0.54164374",
"0.5394491",
"0.5394491",
"0.5391942",
"0.5387773",
"0.5371434",
"0.5284352",
"0.52258164",
"0.5222704",
"0.52201176",
"0.51978165",
"0.5177186",
"0.5159384",
"0.5130192",
"0.511712",
"0.5114135... | 0.0 | -1 |
Valid JSON object containing workbook template payload. | def template_data(self) -> pulumi.Output[Any]:
return pulumi.get(self, "template_data") | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def is_template_valid(template: JSONDict) -> JSONDict:\n\n errors = _rec_is_template_valid(template)\n errors.extend(_check_cyclic_defaults(template))\n\n if errors:\n msg = collate_errors(when=\"checking the template\", errors=errors)\n raise ParselglossyError(msg)\n\n return _reorder_te... | [
"0.62114877",
"0.6071935",
"0.5990931",
"0.59413725",
"0.5856608",
"0.57829463",
"0.5766327",
"0.573466",
"0.57027936",
"0.55965626",
"0.5435958",
"0.54198736",
"0.53931856",
"0.5344035",
"0.5329229",
"0.53008455",
"0.5250856",
"0.5239073",
"0.5200579",
"0.517109",
"0.5154547... | 0.0 | -1 |
This decorator is to handle the exceptions and print it in log | def handle_exception(function):
def wrapper(*args, **kwargs):
""" The wrapper function """
try:
return function(*args, **kwargs)
except Exception as ex:
exc_type, exc_value, exc_traceback = sys.exc_info()
error("The traceback is ::::\n"+"" \
.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def exception_handler(exctype, val, trace):\n logger.info(\n ''.join(traceback.format_exception(exctype, val, trace)))",
"def log_exceptions(view):\n def decorated(request, *args, **kwargs):\n try:\n return view(request, *args, **kwargs)\n except Exception as... | [
"0.73565656",
"0.7343179",
"0.7290134",
"0.7258473",
"0.7158605",
"0.7137361",
"0.7077733",
"0.70336413",
"0.70336413",
"0.70140934",
"0.69754803",
"0.6966358",
"0.6962238",
"0.6924393",
"0.6924393",
"0.6917137",
"0.6891868",
"0.68603396",
"0.68316257",
"0.68050414",
"0.68050... | 0.0 | -1 |
Test SNMPv3 script utilizing Kirks snmp_helper module | def main():
# Take path argument and list all text files
ip = '10.1.10.100'
a_user = 'cisco'
auth_key = 'cisco123'
encr_key = 'cisco123'
snmp_user = (a_user, auth_key, encr_key)
sw1 = (ip, 161)
sysDescr = '1.3.6.1.2.1.1.1.0'
sysObjectID = '1.3.6.1.2.1.1.2.0'
sysUpTime = '1.3.6.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def quickstart():\n snmp.quickstart()\n return 0",
"def handle_snmpconf():\n return 0",
"def main():\n # CREATE EACH OID STRING USING THE FIRST ARGUMENT PASSED\n cmd_uptime = \"snmpget -v 1 -c public \" + argv[1] + \" 1.3.6.1.2.1.1.3.0\"\n # CREATE LISTS OUT OF EACH COMMAND\n clUptime = cm... | [
"0.63348025",
"0.619772",
"0.6136724",
"0.5980005",
"0.5947892",
"0.58158255",
"0.57572633",
"0.5711977",
"0.5508595",
"0.53740776",
"0.53207225",
"0.5219235",
"0.5182949",
"0.5170424",
"0.5160724",
"0.5152555",
"0.5085134",
"0.50800693",
"0.5075875",
"0.5074044",
"0.50578886... | 0.64426136 | 0 |
Connect to the API and test connection | def connect_api():
print("INFO: Checking API connection and credentials...")
conf = ConfigParser()
conf.read(os.path.join(os.path.abspath(
os.path.dirname(__file__)), '.', 'api.conf'))
client = CBWApi(conf.get('cyberwatch', 'url'), conf.get(
'cyberwatch', 'api_key'), conf.get('cyberwatch... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect():\n return connection.Connection(username=api_user,\n api_key=api_key,\n region=api_region)",
"def test_api_connection(server, username, password, api_key):\n global api_url\n api_url = \"http://\" + server + \"/i-doit/src/jsonrp... | [
"0.75394267",
"0.71746594",
"0.71069753",
"0.70297796",
"0.69757605",
"0.6968587",
"0.6940774",
"0.6929308",
"0.6752766",
"0.67461467",
"0.66849214",
"0.6681502",
"0.6624572",
"0.66045177",
"0.6603074",
"0.6563905",
"0.6545671",
"0.6543918",
"0.650036",
"0.64967084",
"0.64955... | 0.7394636 | 1 |
Setup variables for SMTP | def setup_smtp():
print("INFO: Setting up SMTP variables...")
conf = ConfigParser()
conf.read(os.path.join(os.path.abspath(
os.path.dirname(__file__)), '.', 'smtp.conf'))
smtp = {
"server": conf.get('smtp', 'smtp_server'),
"login": conf.get('smtp', 'smtp_login'),
"passwor... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, smtp_server, smtp_user, smtp_password,\n smtp_port=25, is_with_tls=False):\n self.smtp_server = smtp_server\n self.smtp_port = smtp_port\n self.smtp_user = smtp_user\n self.smtp_password = smtp_password\n self.is_with_tls = is_with_tls",
"def ... | [
"0.65546256",
"0.6469776",
"0.6447924",
"0.64182866",
"0.63860655",
"0.6361841",
"0.62926346",
"0.6200357",
"0.6009188",
"0.5971613",
"0.59700364",
"0.5938338",
"0.58888084",
"0.5881734",
"0.5868435",
"0.5861525",
"0.5846991",
"0.58270794",
"0.57619554",
"0.57489693",
"0.5721... | 0.7708062 | 0 |
Replace server list in file with recent one | def replace_file(servers):
print("INFO: Replacing server list in file with recent one...")
if os.path.exists(os.path.dirname(__file__) + '/communication_failure_list.txt'):
try:
os.remove(os.path.dirname(__file__) +
'/communication_failure_list.txt')
except OSEr... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_server_list(filename):\n if not os.path.isfile(filename):\n return #ignore this error for now\n fo=open(filename,\"r\")\n rd=fo.read()\n fo.close()\n __load_server_list(rd)",
"def update_servers(self, output_file, current_time):\n\n # Check the servers le... | [
"0.6282345",
"0.6164431",
"0.5646351",
"0.5629765",
"0.55825335",
"0.55205137",
"0.54738104",
"0.54054666",
"0.53958476",
"0.53949213",
"0.53838426",
"0.5362909",
"0.53529775",
"0.5349839",
"0.53414625",
"0.53314036",
"0.5330049",
"0.53072166",
"0.5290604",
"0.52862704",
"0.5... | 0.7886564 | 0 |
Find servers with status "Communication failure" and save them to a file | def find_communication_failure_servers(servers):
print('INFO: Finding servers with "Communication failure" status and saving result in file')
with open(os.path.dirname(__file__) + '/communication_failure_list.txt', 'w+') as file:
for server in servers:
if server.status == "server_update_comm... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_recovered_servers(client):\n print(\"INFO: Determining recovered servers by comparing current servers with list in file...\")\n current_servers_list = []\n for server in client.servers():\n if server.status == \"server_update_comm_fail\":\n current_servers_list.append({\"id\": s... | [
"0.64982885",
"0.6221347",
"0.61516804",
"0.5741765",
"0.57228017",
"0.56389916",
"0.56194955",
"0.5510259",
"0.5408489",
"0.5404776",
"0.53996354",
"0.5329651",
"0.5317809",
"0.5298589",
"0.5267512",
"0.52575266",
"0.5253678",
"0.5225752",
"0.5221685",
"0.51375675",
"0.51358... | 0.85111237 | 0 |
Compare list of servers in file with current ones to find recovered servers | def find_recovered_servers(client):
print("INFO: Determining recovered servers by comparing current servers with list in file...")
current_servers_list = []
for server in client.servers():
if server.status == "server_update_comm_fail":
current_servers_list.append({"id": server.id})
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def replace_file(servers):\n print(\"INFO: Replacing server list in file with recent one...\")\n if os.path.exists(os.path.dirname(__file__) + '/communication_failure_list.txt'):\n try:\n os.remove(os.path.dirname(__file__) +\n '/communication_failure_list.txt')\n ... | [
"0.67536014",
"0.6489799",
"0.6314629",
"0.5987139",
"0.5953733",
"0.58189934",
"0.5703676",
"0.55950475",
"0.55163497",
"0.5493828",
"0.54845756",
"0.54702073",
"0.54463625",
"0.5411403",
"0.53845555",
"0.5359683",
"0.5357033",
"0.53492767",
"0.52340114",
"0.52160895",
"0.51... | 0.7713606 | 0 |
Fetch each server that recovered to help build the email report | def build_server_list(client, diff):
print("INFO: Fetching each server not in 'Communication failure' anymore...")
servers = []
for server in diff:
servers.append(client.server(str(server.id)))
return servers | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def grab_server_data(self):\n\n for server, channels in self.servers.items():\n for channel in channels:\n cutoff = self.get_last_scrape_date(server, channel)\n print('grabbing data for {} : {} back to {} ...'.format(server, channel, cutoff.isoformat()))\n ... | [
"0.66062176",
"0.65178025",
"0.6010534",
"0.58261585",
"0.5772471",
"0.57689935",
"0.57268775",
"0.5719524",
"0.5677154",
"0.5617324",
"0.5561407",
"0.55595326",
"0.55461943",
"0.5514094",
"0.5493302",
"0.54723006",
"0.54697764",
"0.54529583",
"0.54460496",
"0.5421955",
"0.54... | 0.6223516 | 2 |
Make an HTML list from server list for email | def create_body_html(client, server_list):
servers_html = ""
for server in server_list:
link = '<a href="{}/servers/{}">{}</a>'.format(
client.api_url, server.id, server.hostname)
html = """{}<br />""".format(link)
servers_html += html
return servers_html | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_list_html(self, items):\n html = \"\"\"\n <html>\n\t\t\t<head>\n\t\t\t\t<title>OpenFDA Cool App</title>\n\t\t\t</head>\n\t\t\t<body>\n <ol>\n \"\"\"\n\n for item in items:\n html += \"<li>\" + item + \"</li>\\n\"\n\n html += \"\"\"\n ... | [
"0.6742271",
"0.61657894",
"0.61091125",
"0.60555714",
"0.60321444",
"0.5965353",
"0.59480834",
"0.5918078",
"0.5883233",
"0.5821413",
"0.5801513",
"0.5782404",
"0.57817954",
"0.57756126",
"0.57365865",
"0.5734727",
"0.57307297",
"0.56886506",
"0.5656043",
"0.5625895",
"0.562... | 0.7079043 | 0 |
Sends an email using smtp configuration specified in the file smtp.conf | def send_email(client, smtp, server_list):
content = create_body_html(client, server_list)
# Email Configuration
message = MIMEMultipart("alternative")
message["Subject"] = '[Cyberwatch] Servers recovered from "Communication failure" report - ' + \
date.today().strftime("%m/%d/%y")
message[... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_email():\n recipients = configs[\"email_to\"].split(\", \")\n email_body = test_email_content()\n if configs[\"smtp_ssl\"] == 1:\n server = smtplib.SMTP_SSL(configs[\"smtp_server\"])\n elif configs[\"smtp_tls\"] == 1:\n server = smtplib.SMTP(configs[\"smtp_server\"])\n ser... | [
"0.7491373",
"0.73841417",
"0.713573",
"0.7031402",
"0.7000115",
"0.68528783",
"0.68497354",
"0.67722887",
"0.67548084",
"0.67065614",
"0.67023444",
"0.66815484",
"0.6659069",
"0.6657875",
"0.6656062",
"0.66539705",
"0.6637547",
"0.6632005",
"0.66252553",
"0.66038924",
"0.659... | 0.0 | -1 |
Create a new managed set s can be any iterable to initialize the set | def __init__(self, s=None):
self._index_map = {}
self._list = []
if s is not None:
for item in s:
self.add(item) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_set(*, ctx: context.ContextLevel, **kwargs) -> irast.Set:\n ir_set = irast.Set(**kwargs)\n ctx.all_sets.append(ir_set)\n return ir_set",
"def __init__(self):\n self.EntireSet = []",
"def __init__(self,s={}) -> None:\n\n self.set=list()",
"def getSet(unique_name):",
"def getSe... | [
"0.7399817",
"0.6877598",
"0.6862654",
"0.66539514",
"0.66539514",
"0.6611376",
"0.65953755",
"0.65797526",
"0.65312886",
"0.64626396",
"0.6415495",
"0.6413129",
"0.6328426",
"0.6302573",
"0.62722033",
"0.6265865",
"0.62559974",
"0.62554675",
"0.61868936",
"0.6185098",
"0.617... | 0.61764705 | 20 |
Returns True if the item is in the set | def __contains__(self, item):
return item in self._index_map | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_item(self, item):\n return item in self.set",
"def has_item(self, item):\n return item in self.set",
"def __contains__(self, item):\n\t\treturn item in self.__dict__.values()",
"def __contains__(self, item):\n return item in self._data",
"def __contains__(self, item):\n ... | [
"0.880693",
"0.880693",
"0.8195229",
"0.8118078",
"0.80649304",
"0.8029175",
"0.80107844",
"0.80002207",
"0.7948576",
"0.79076195",
"0.7889809",
"0.7824471",
"0.7711623",
"0.7678021",
"0.7670866",
"0.76645726",
"0.76564676",
"0.7634171",
"0.762813",
"0.7605421",
"0.7605179",
... | 0.7233767 | 47 |
Add an element to the ManagedSet if it doesn't yet exist | def add(self, item):
if item not in self:
self._index_map[item] = len(self._list)
self._list.append(item) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add(self, item):\n item = self._prepare_item(len(self), item)\n if item not in self._data:\n self._data.append(item)\n self.__log__.append(SetAdd(value=item))",
"def add(self, item):\n if not (item in self.set):\n self.set[item] = True\n heapq.... | [
"0.69828415",
"0.6847343",
"0.65095526",
"0.63862497",
"0.61189485",
"0.6077914",
"0.6077128",
"0.60621035",
"0.60568106",
"0.60124046",
"0.5962723",
"0.58497447",
"0.58171266",
"0.58133477",
"0.57736415",
"0.57612514",
"0.57485837",
"0.5700885",
"0.56979096",
"0.5677765",
"0... | 0.5560599 | 34 |
Remove an item from the ManagedSet if it exists | def remove(self, item):
if item in self:
item_index = self._index_map[item]
last_item = self._list[-1]
# Swap in the item from the end of the list
self._list[item_index] = last_item
self._list.pop()
self._index_map[last_item] = item_inde... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def remove(self, item):\n try:\n entry = self.set.pop(item)\n entry[-1] = self.REMOVED\n except KeyError:\n print(\"Can't remove a non-existing item\")",
"def remove(self, item):\n try:\n self._data.remove(item)\n except ValueError as exc:\n... | [
"0.7588221",
"0.7376286",
"0.68292063",
"0.6777084",
"0.6600415",
"0.6574729",
"0.65593547",
"0.6528472",
"0.6528472",
"0.65188915",
"0.649716",
"0.64792234",
"0.6471408",
"0.64354444",
"0.6390395",
"0.63859606",
"0.6358534",
"0.6353678",
"0.62763745",
"0.6259627",
"0.6246596... | 0.6277959 | 18 |
Remove a random item from the set, and return it | def pop_random(self):
rand_index = randint(0, len(self._list) - 1)
item = self._list[rand_index]
self.remove(item)
return item | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def popitem(self):\n all_items = self.items()\n removed_item = random.choice(all_items)\n self[removed_item[0]] = None\n return removed_item",
"def getRandom(self):\n n = len(self.keys)\n while n > 0:\n index = random.randint(0, n - 1)\n my_key = se... | [
"0.8282262",
"0.7164812",
"0.7115214",
"0.69544333",
"0.68911844",
"0.68830067",
"0.6759804",
"0.67500526",
"0.67464954",
"0.67222595",
"0.6633977",
"0.6544951",
"0.6462838",
"0.6461487",
"0.6363013",
"0.6315286",
"0.6308643",
"0.62988245",
"0.6254927",
"0.6241444",
"0.621253... | 0.79628265 | 1 |
Generate a compressed name from keys wrt config. | def get_compressed_name_from_keys(config: Dict[str, Any],
keys: Tuple[Tuple[str]],
allow_missing: bool = True):
assert not isinstance(config, list), config
name = ''
for pre_keys in keys:
v = config
pre_keys_str = ''
missing = False
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _make_pack_name(names):\n assert names\n tokens_in_names = [name.split('/') for name in names]\n common_prefix_tokens = []\n\n # Find the longest common prefix of tokens.\n while True:\n first_token_in_names = set()\n for tokens in tokens_in_names:\n if not tokens:\n break\n first_t... | [
"0.64022315",
"0.63604325",
"0.6284187",
"0.61198986",
"0.592737",
"0.5915452",
"0.59024495",
"0.5840366",
"0.5840366",
"0.5803846",
"0.57972753",
"0.5789273",
"0.5788882",
"0.57822824",
"0.5780839",
"0.5775445",
"0.57516694",
"0.57482225",
"0.5740038",
"0.5716991",
"0.570401... | 0.7821243 | 0 |
List the keys corresponding to List or callable. | def list_keys_to_expand(config, root=True, pre_keys=()):
if isinstance(config, dict):
keys = ()
for k, v in sorted(config.items()):
keys += list_keys_to_expand(v, root=False, pre_keys=pre_keys + (k,))
return keys
elif (not root and isinstance(config, list)) or callable(config):
assert pre_keys... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_key_list(self) -> list:\n return self.key_functs.keys()",
"def keys(self) -> List:\n pass",
"def keys(self, *args, **kwargs):\n return self._list(*args, **kwargs)",
"def keys(self) -> List[str]:\n raise NotImplementedError",
"def keys(self):\n raise NotImplementedErro... | [
"0.8176447",
"0.7777549",
"0.749392",
"0.7440805",
"0.7102301",
"0.7062519",
"0.7041881",
"0.7037035",
"0.701955",
"0.69905293",
"0.6981548",
"0.6934253",
"0.6925223",
"0.6922672",
"0.69192296",
"0.6856144",
"0.6827365",
"0.6809344",
"0.6800845",
"0.6785259",
"0.67648435",
... | 0.0 | -1 |
Expand configuration distribution specification. | def sample_configuration_dist(config, root=True, num_samples_per_dist=1):
if isinstance(config, dict):
return {
k: sample_configuration_dist(
v, root=False, num_samples_per_dist=num_samples_per_dist)
for k, v in sorted(config.items())
}
elif isinstance(config, list) and root:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _expand_spec(spec, **kwargs):\n fixed_params = {}\n variable_params = {}\n for k, v in spec.items():\n if isinstance(v, list):\n variable_params[k] = v\n elif isinstance(v, dict):\n # Try handling as distribution\n res = sa... | [
"0.57830215",
"0.5412506",
"0.52475715",
"0.5171691",
"0.51531947",
"0.49469507",
"0.48409817",
"0.482933",
"0.4787844",
"0.47850314",
"0.4766017",
"0.47597107",
"0.46887043",
"0.4663835",
"0.46525776",
"0.46523",
"0.4652122",
"0.46401262",
"0.46399802",
"0.4630195",
"0.45890... | 0.45457044 | 25 |
Get a sample of config. | def get_configuration_sample(config, root=True):
if isinstance(config, dict):
return {
k: get_configuration_sample(v, root=False)
for k, v in sorted(config.items())
}
elif isinstance(config, list):
if root:
return get_configuration_sample(
config[np.random.randint(len(con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_sample(config, n_sample=1):\n if config['distribution'] == 'binary':\n data = np.random.choice([0, 1], size=n_sample, replace=True, p=config['pmf'])\n\n elif config['distribution'] == 'discrete':\n data = np.random.choice(config['category'], size=n_sample, replace=True, p=config['pmf'])... | [
"0.66725135",
"0.65855396",
"0.6482443",
"0.64281243",
"0.62920535",
"0.62203",
"0.62141085",
"0.6211423",
"0.61809164",
"0.61482966",
"0.6130489",
"0.60582256",
"0.60312045",
"0.6018113",
"0.6018113",
"0.59389967",
"0.5933204",
"0.5931536",
"0.5909174",
"0.590119",
"0.587822... | 0.7430664 | 0 |
Pass the arguments given by command line. | def __init__(self, args=''):
self._args = args
# Support Logging
self._logger = logging.getLogger(__name__)
log_level = 'DEBUG' if self._args.debug else 'INFO'
self._logger.setLevel(log_level)
logformat = logging.Formatter("%(levelname)s: %(message)s")
stdout = l... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n args = parse_args()\n process_args(args)",
"def parse_arguments(args):",
"def main(args):",
"def main(args):",
"def command_line_args(parser):\n AbyssAssembler.command_line_args(parser)\n SpadesAssembler.command_line_args(parser)\n TrinityAssembler.command_line_args(parser)\n ... | [
"0.7333819",
"0.7315869",
"0.709411",
"0.709411",
"0.7064864",
"0.7001522",
"0.6990702",
"0.6989935",
"0.6989935",
"0.69459844",
"0.6928525",
"0.6928525",
"0.687338",
"0.6740708",
"0.6681569",
"0.6681569",
"0.6681569",
"0.6681569",
"0.6681569",
"0.6681569",
"0.6681569",
"0.... | 0.0 | -1 |
Reads the preflop lookup table preflop_EHSs.txt. | def read_lookup_table(hole_cards, lookup_table):
sorted_hole = sorted(hole_cards)
sorted_hole.reverse()
card_strings = [Card.int_to_str(card) for card in sorted_hole]
if card_strings[0][1] != card_strings[1][1]:
suited = False
else:
suited = True
card_strings[0] = card_strings[0... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_hlas(fasta_fai):\n out = []\n with open(fasta_fai) as in_handle:\n for line in in_handle:\n if line.startswith(\"HLA\"):\n out.append(line.split()[0])\n return out",
"def load_lookup_tables(file_names):\n\n # Check input argument type - - - - - - - - - - - - - ... | [
"0.5214545",
"0.51523465",
"0.50774",
"0.5070679",
"0.50630456",
"0.5054708",
"0.5031981",
"0.50247204",
"0.49250507",
"0.49062192",
"0.4888807",
"0.4881296",
"0.48757115",
"0.48680875",
"0.48369682",
"0.48359004",
"0.48050416",
"0.4792676",
"0.47846827",
"0.47832748",
"0.478... | 0.5086216 | 2 |
Initialization variables and loading data | def __init__(self):
self.running = 1
self.room = 1
self.set_automatic = 1
self.set_thermostat = 0
self.set_humidifier = 0
self.set_sprinklers = 0
self.set_ventilation = 0
self.settings_path = "settings.csv"
self.desired_path = "rooms_desired_value... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data(self):",
"def load_data(self) -> None:",
"def load_data(self):\n if self.debug:\n print(\"Loading data\")",
"def init(self, **kwargs):\n self._d = {}\n self._th = None\n self._run = True\n self.load()",
"def _initialize_data(self):\n self.r... | [
"0.77343583",
"0.7713693",
"0.7421551",
"0.74176455",
"0.7195016",
"0.7080848",
"0.70373166",
"0.7013087",
"0.7001275",
"0.69835466",
"0.69801617",
"0.69212013",
"0.68836963",
"0.68681973",
"0.68602926",
"0.6836477",
"0.6830069",
"0.6815077",
"0.6807112",
"0.67994136",
"0.678... | 0.0 | -1 |
Automatically change devices settings | def auto(self):
self.set_thermostat = 1 if self.desired_values[0] > self.data[0] else 0
self.set_humidifier = 1 if self.desired_values[1] > self.data[1] else 0
self.set_sprinklers = 1 if self.desired_values[2] > self.data[2] else 0
self.set_ventilation = 1 if (self.desired_values[3] > se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set_settings_devices(self):\n self.set_thermostat, self.set_humidifier, self.set_sprinklers, self.set_ventilation = self.settings[3:]",
"def open_settings(self):\n self.android_device_driver.adb.exec_adb_cmd(\n \"shell am start -a android.settings.SETTINGS\").wait()",
"def on(config: dict)... | [
"0.75717664",
"0.6487387",
"0.6348191",
"0.61788106",
"0.61683166",
"0.61518466",
"0.6148382",
"0.61440235",
"0.61389786",
"0.6121356",
"0.6088338",
"0.60738426",
"0.60651356",
"0.60635734",
"0.601406",
"0.60068804",
"0.59988713",
"0.59903884",
"0.59721637",
"0.59567684",
"0.... | 0.0 | -1 |
Function for emulate a launching devices, get value of change and set that | def launch_devices(self):
self.data[0], temp = alghoritm.temperature(self.data[0], self.set_thermostat, 0) # get value
HC35_3S.launch(self.data_path, self.samples_size, temp) # set it via device
self.data[1], humidi = alghoritm.humidity(self.data[1], self.set_humidifier, 0)
humidifier... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_change_brightness_of_the_devicetrue():",
"def change_device(self):\n if self.state.ser:\n UsbHost.close_port(self.state.ser)\n device = self.CBDevices.currentText()\n if device:\n comport = self.devices[int(device)]\n self.state.ser = UsbHost.open_po... | [
"0.63758236",
"0.61740834",
"0.6054749",
"0.60433406",
"0.6002026",
"0.5946447",
"0.5946447",
"0.591832",
"0.5867906",
"0.58041674",
"0.578171",
"0.57716215",
"0.5766558",
"0.5715131",
"0.57112956",
"0.57107544",
"0.5666014",
"0.55885583",
"0.55696195",
"0.5569229",
"0.554301... | 0.5704855 | 16 |
Load data from CSV files | def read_data(self):
temperature_data = RS485.read_temperature(self.data_path)
humidity_data = RS485.read_humidity(self.data_path)
moisture_data = RH_010_GN.read_moisture(self.data_path)
o2_data = LB_856.read_o2(self.data_path)
co2_data = LB_856.read_co2(self.data_path)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def loadCSV(input_file):",
"def load_data_csv():\r\n \r\n # Load lookup table\r\n path = 'data/id_lookup.csv'\r\n lookup_table = pd.read_csv(path, index_col=0)\r\n\r\n # Load song data\r\n path2 = 'data/data_lyrics_features.csv'\r\n data = pd.read_csv(path2, index_col=0)\r\n\r\n return data, lookup_table... | [
"0.7877938",
"0.759222",
"0.75817806",
"0.7457923",
"0.74297255",
"0.7366995",
"0.7305696",
"0.729182",
"0.7266087",
"0.72470284",
"0.7156001",
"0.7114432",
"0.70937014",
"0.70597565",
"0.7055762",
"0.69832",
"0.6959449",
"0.69565874",
"0.6942449",
"0.69329506",
"0.6932639",
... | 0.0 | -1 |
Read actual desired values from CSV file | def read_desired_values(self):
self.desired_values = read_desired_values(self.desired_path, self.room) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv():",
"def read_csv_file(self):\n pass",
"def get_data(self, csv_file):\n pass",
"def loadCSV(input_file):",
"def __obtain_data_from_csv__(self, csvfile):\n data = csvfile.readlines()\n data = self.__parse_string_for_delimiter__(data)\n return data",
"def _r... | [
"0.79397357",
"0.7410742",
"0.7244259",
"0.709767",
"0.68508065",
"0.66784024",
"0.6676786",
"0.65691286",
"0.65635836",
"0.6503509",
"0.6491671",
"0.6421233",
"0.6415983",
"0.6389252",
"0.6364315",
"0.633871",
"0.63328934",
"0.6316609",
"0.62922555",
"0.6290482",
"0.620337",... | 0.0 | -1 |
Read actual settings from CSV file | def read_settings(self):
self.settings = read_settings(self.settings_path) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def read_csv_file(self):\n pass",
"def read_csv():",
"def _read_csv(self):\n with open(self._file_path, 'rb') as f:\n reader = csv.DictReader(f, delimiter=',')\n self._content = [row for row in reader]",
"def loadCSV(input_file):",
"def load_csv(self):\n self.data... | [
"0.7020487",
"0.6802786",
"0.6636211",
"0.6442558",
"0.63362825",
"0.62536347",
"0.6252917",
"0.614084",
"0.611332",
"0.6086529",
"0.6083055",
"0.607521",
"0.6070219",
"0.6068629",
"0.60419023",
"0.60315603",
"0.60211563",
"0.59968203",
"0.5986851",
"0.5957817",
"0.5908996",
... | 0.5869355 | 24 |
Set devices values on/off | def set_settings_devices(self):
self.set_thermostat, self.set_humidifier, self.set_sprinklers, self.set_ventilation = self.settings[3:] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def resetDeviceStates(self):",
"def set_toggle_devices_enabled(self, track, xclip, ident, value = None):\n for device in track.devices:\n if(hasattr(device, 'parameters')):\n self._parent._device_actions.set_device_on_off(device, track, xclip, ident);",
"def Set(self,value):\n ... | [
"0.70645505",
"0.7058006",
"0.6706693",
"0.66463596",
"0.66042775",
"0.64724237",
"0.6445534",
"0.63705325",
"0.63676846",
"0.6358413",
"0.6253338",
"0.6170214",
"0.60686815",
"0.5999802",
"0.59865546",
"0.5983928",
"0.59829843",
"0.5971754",
"0.5971754",
"0.59580594",
"0.593... | 0.6983819 | 2 |
Help function to check the correct operation of the program | def plot(self):
x = np.arange(5)
# labels = ['temp', 'humi', 'mais', 'o2', 'co2']
plt.bar(x - 0.35/2, self.data, 0.35, label='actual')
plt.bar(x + 0.35/2, self.desired_values, 0.35, label='desired')
plt.ylim(-5, 80)
plt.legend()
plt.draw()
plt.pause(0.000... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def usage():",
"def usage():",
"def usage():\n print(\"This program runs with command line arguments.\\n\"\n \"Available parameters:\\n\"\n \"\\t-h --help : help\\n\"\n \"\\t-f : file name or path\\n\"\n \"\\t-k : key file\\n\"\n \"\\t-o : operaion\\n\"\... | [
"0.71139324",
"0.71139324",
"0.70727",
"0.67588127",
"0.67382795",
"0.6703698",
"0.6696139",
"0.66096044",
"0.66091365",
"0.6601356",
"0.65277493",
"0.65181434",
"0.64331025",
"0.64223593",
"0.64211553",
"0.6416539",
"0.6379288",
"0.63616896",
"0.6334443",
"0.63264126",
"0.63... | 0.0 | -1 |
sents is a list of sentences returned by nltk.sent_tokenize | def non_answers(sents):
matches = [{'regex_id': r['regex_id'],
'sentence': s,
'phrase': r['re'].search(s).group() }
for s in sents
for r in regexes
if r['re'].search(s) is not None]
if not matches:
return None
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tokenize_sentences(self, sents):\n token_sentence_list = []\n for sentence in sents:\n token_sentence_list.append(self.tokenizer(sentence))\n return token_sentence_list",
"def tokenize_sents(sents, tokenizer):\n return [tokenizer(sent) for sent in sents]",
"def sentences(... | [
"0.8273085",
"0.79840225",
"0.73435074",
"0.73435074",
"0.728733",
"0.72776616",
"0.71518403",
"0.7131324",
"0.70658165",
"0.70015174",
"0.6960332",
"0.6859285",
"0.6750411",
"0.669615",
"0.6688754",
"0.6679756",
"0.6662568",
"0.6653295",
"0.66051084",
"0.660379",
"0.66018254... | 0.0 | -1 |
See Pelleg's and Moore's for more details. | def loglikelihood(R, R_n, variance, M, K):
if 0 <= variance <= EPS:
res = 0
else:
res = R_n * (np.log(R_n) - np.log(R) - 0.5 * (np.log(2 * np.pi) + M * np.log(variance) + 1)) + 0.5 * K
if res == np.inf:
res = 0
return res | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def regular(self):",
"def _regr_basic():",
"def exo2():",
"def substantiate():",
"def degibber(self):",
"def mezclar_bolsa(self):",
"def sth():",
"def falcon():",
"def exercise_b2_53():\r\n pass",
"def g():",
"def __call__(self) -> None:",
"def support(self):",
"def exercise_b2_106():\r\... | [
"0.66036844",
"0.6600318",
"0.64866984",
"0.6417649",
"0.6405187",
"0.6382748",
"0.63440806",
"0.6330827",
"0.63170177",
"0.6301254",
"0.61618525",
"0.61485845",
"0.61482483",
"0.61257714",
"0.6109756",
"0.6098478",
"0.6098441",
"0.6098441",
"0.6098441",
"0.6098441",
"0.60984... | 0.0 | -1 |
output the indices of a pair of clusters whose distance is the smallest | def detec_mfo_dist(betas):
k = len(betas)
min_dist = np.inf
for i in range(k-1):
for j in range(i+1,k):
distance = np.sum((betas[i,:] - betas[j,:])**2)
if distance < min_dist:
MFO_index = [i,j]
min_dist = distance
return MFO_index | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def smallest_distance(self, clusters):\n i, j = numpy.unravel_index(numpy.argmin(clusters), clusters.shape)\n return clusters[i, j], i, j",
"def slow_closest_pair(cluster_list):\n dist, idx1, idx2 = float(\"inf\"), -1, -1\n for idx_u in range(len(cluster_list)):\n for idx_v in range(le... | [
"0.7430634",
"0.71578205",
"0.7152571",
"0.713903",
"0.7126042",
"0.7021916",
"0.69771445",
"0.6973648",
"0.6949951",
"0.69442433",
"0.6940495",
"0.69324505",
"0.6727459",
"0.6701706",
"0.65744245",
"0.6561031",
"0.6556481",
"0.651129",
"0.65077263",
"0.6481209",
"0.64430726"... | 0.0 | -1 |
Merge the two centers with manyfitone association | def merge(centroids, MFO_index):
fussion_centroid = (centroids[MFO_index[0]] + centroids[MFO_index[1]])/2
centroids = np.delete(centroids, MFO_index, axis=0)
return np.vstack((centroids, fussion_centroid)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_pores(self, n1, n2, setcategory='union', radius=None, center=None, check_throats=True, inner_category='inner', verbose=False):\n\n if not self.graph.has_node(n1) or not self.graph.has_node(n2):\n warn(\"Nodes {} or {} does not exist. Cannot merge them\".format(u, v))\n return... | [
"0.6356105",
"0.6121738",
"0.6055336",
"0.59658766",
"0.59658766",
"0.57911676",
"0.57794744",
"0.5777705",
"0.575305",
"0.5727767",
"0.57131493",
"0.569286",
"0.5615065",
"0.5598778",
"0.55485994",
"0.5525544",
"0.5491827",
"0.5486056",
"0.5469901",
"0.54665923",
"0.54495573... | 0.5773375 | 8 |
output the equivalent classes from pairwise relation [[1,2],[2,3],[4,5]] > [[1,2,3],[4,5]] | def compute_equivalent_class(record):
equivalent_class = {}
class_members=[]
max_class_number = -1
for pair in record:
if (pair[0] in equivalent_class) and (not (pair[1] in equivalent_class)):
equivalent_class[pair[1]] = equivalent_class[pair[0]]
if (not(pair[0] in equivalent... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def equivalence_classes(self):\n\n # Two states `a` and `b` are j-equivalent if and only if there\n # is a bijection `\\varphi` between paths of length <= j\n # starting at `a` and paths starting at `b` with the following\n # properties: Let `p_a` be a path from `a` to `a'` and `p_b` a\... | [
"0.62841934",
"0.5959602",
"0.58290446",
"0.57107425",
"0.57038814",
"0.56956035",
"0.5680738",
"0.562982",
"0.56069076",
"0.5600357",
"0.5521769",
"0.5511383",
"0.55074245",
"0.55074245",
"0.5487679",
"0.5446884",
"0.5439978",
"0.54043436",
"0.54010254",
"0.5384444",
"0.5356... | 0.5683296 | 6 |
merge centers in the same equivalent class | def batch_fussion(betas, class_members):
merge_centers = None
all_merge_indices = []
for c, merge_indices in enumerate(class_members):
all_merge_indices += merge_indices
if isinstance(merge_centers,np.ndarray):
merge_centers = np.vstack((merge_centers,np.mean(betas[merge_indices]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def mergeCenters(nCenters):\r\n\tpath = os.getcwd()\r\n\tos.chdir('Centers/')\r\n\tcenter = np.zeros((0,128))\t\t#: Populator for centers\r\n\r\n\tfor i in os.listdir(os.getcwd()):\r\n\t Center = open(i,\"rb\")\t\t#: File pointer for centers file\r\n\t center = np.vstack((center, pickle.load(Center)))\t#Popu... | [
"0.6535946",
"0.6191329",
"0.6115653",
"0.6022905",
"0.59900016",
"0.59891766",
"0.59014755",
"0.5845771",
"0.57922643",
"0.57680273",
"0.5742475",
"0.573608",
"0.573608",
"0.5734842",
"0.57274073",
"0.57219094",
"0.56922454",
"0.56858224",
"0.5681211",
"0.5643599",
"0.563533... | 0.0 | -1 |
Metodo para calcular los dias entre la fecha de inicio y la fecha final | def _compute_days_tarea(self, cr, uid, ids, field, arg, context=None):
import datetime
result = {}
records = self.browse(cr, uid, ids, context=context)
for r in records:
if r.date_start_tarea:
d = time.strptime(r.date_start_tarea,'%Y-%m-%d %H:%M:%S')
f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def diveDates(self,start,finish):\n start = datetime.strptime(start,\"%Y-%m-%d\")\n finish = datetime.strptime(finish,\"%Y-%m-%d\")\n return start+(finish-start)/2",
"def dias_desde_caso_0(self):\n\n self.covidbr['dias_caso_0'] = self.covidbr['data'] - self.covidbr['data'].iloc[0]\n ... | [
"0.6835163",
"0.65805006",
"0.65312827",
"0.6462369",
"0.6450312",
"0.6374033",
"0.6307957",
"0.6285137",
"0.6246967",
"0.6159689",
"0.5938541",
"0.59264344",
"0.5821794",
"0.58151656",
"0.58118457",
"0.58064634",
"0.57955575",
"0.5751022",
"0.571991",
"0.57169217",
"0.571523... | 0.0 | -1 |
SQL Constraints para validar que La fecha de inicio debe ser menor que la fecha final | def _check_dates_tareas(self, cr, uid, ids, context=None):
for leave in self.read(cr, uid, ids, ['date_start_tarea', 'date_end_tarea'], context=context):
if leave['date_start_tarea'] and leave['date_end_tarea']:
if leave['date_start_tarea'] > leave['date_end_tarea']:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_sequence_for_days(self):\n # delta = (max(self.giorni) - min(self.giorni)).days + 1 # the difference returns a timedelta\n try:\n delta = abs(max(self.giorni).daysTo(min(self.giorni))) + 1\n if delta != len(self.giorni):\n raise ValidationError('dates n... | [
"0.66802496",
"0.64251286",
"0.62597007",
"0.6187541",
"0.61812466",
"0.6089486",
"0.5985262",
"0.5954238",
"0.5907971",
"0.5902994",
"0.5886131",
"0.5882439",
"0.58634484",
"0.58231837",
"0.5763819",
"0.573449",
"0.5717921",
"0.5682444",
"0.56750387",
"0.5667743",
"0.5633855... | 0.0 | -1 |
SQL Constraints para validar que La fecha de inicio debe ser menor que la fecha final | def _check_dates_tarea_start(self, cr, uid, ids, context=None):
for leave in self.read(cr, uid, ids, ['date_start_tarea', 'date_start_proyecto'], context=context):
if leave['date_start_tarea'] and leave['date_start_proyecto']:
if leave['date_start_tarea'] < leave['date_start_proyecto... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_sequence_for_days(self):\n # delta = (max(self.giorni) - min(self.giorni)).days + 1 # the difference returns a timedelta\n try:\n delta = abs(max(self.giorni).daysTo(min(self.giorni))) + 1\n if delta != len(self.giorni):\n raise ValidationError('dates n... | [
"0.6679988",
"0.6426486",
"0.62599313",
"0.6188688",
"0.6182176",
"0.60900605",
"0.5985967",
"0.5954658",
"0.59088355",
"0.5904568",
"0.5887064",
"0.5884011",
"0.58638287",
"0.58248",
"0.5765948",
"0.57343364",
"0.57197255",
"0.5681957",
"0.5675307",
"0.5667842",
"0.5634694",... | 0.5406441 | 47 |
SQL Constraints para validar que La fecha de inicio debe ser menor que la fecha final | def _check_dates_tarea_end(self, cr, uid, ids, context=None):
for leave in self.read(cr, uid, ids, ['date_end_tarea', 'date_end_proyecto'], context=context):
if leave['date_end_tarea'] and leave['date_end_proyecto']:
if leave['date_end_tarea'] > leave['date_end_proyecto']:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_sequence_for_days(self):\n # delta = (max(self.giorni) - min(self.giorni)).days + 1 # the difference returns a timedelta\n try:\n delta = abs(max(self.giorni).daysTo(min(self.giorni))) + 1\n if delta != len(self.giorni):\n raise ValidationError('dates n... | [
"0.6680427",
"0.6425462",
"0.62594205",
"0.6187928",
"0.61815345",
"0.60895884",
"0.59854025",
"0.5954201",
"0.590856",
"0.5903359",
"0.58866584",
"0.588292",
"0.5863781",
"0.5823783",
"0.5765027",
"0.5733856",
"0.57183605",
"0.568202",
"0.56756467",
"0.56681573",
"0.5634456"... | 0.0 | -1 |
Extract the images into a 4D tensor [image index, y, x, channels]. Values are rescaled from [0, 255] down to [0.5, 0.5]. | def extract_data(filename):
print('Extracting', filename)
with gzip.open(filename) as bytestream:
bytestream.read(16)
buf = bytestream.read(28 * 28 * 10000 * 1)
data = numpy.frombuffer(buf, dtype=numpy.uint8).astype(numpy.float32)
data = (data - (255 / 2.0)) / 255
data = data.reshape(10000, 28, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _extract(self, images):\n if (images.ndim != 4 or images.shape[0] <= 0 or\n images.shape[0] > self.batch_size or images.shape[1] not in [1, 3]):\n raise ValueError(f'Input images should be with shape [batch_size, '\n f'channel, height, width], where '\n ... | [
"0.65527594",
"0.6362516",
"0.6347995",
"0.63292974",
"0.625947",
"0.62585825",
"0.62153494",
"0.61934483",
"0.6182799",
"0.6160032",
"0.61571723",
"0.606164",
"0.60403836",
"0.59810907",
"0.5967399",
"0.59663445",
"0.5935928",
"0.5923294",
"0.59225285",
"0.58962965",
"0.5895... | 0.0 | -1 |
Extract the labels into a vector of int64 label IDs. | def extract_labels(filename):
print('Extracting', filename)
with gzip.open(filename) as bytestream:
bytestream.read(8)
buf = bytestream.read(10000)
labels = numpy.frombuffer(buf, dtype=numpy.uint8).astype(numpy.int64)
return labels | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def convert_to_ids(self, terms):\n vec = [self.get_id(label) for label in terms]\n return vec",
"def _label_to_id(self, sequence_labels, dict_map):\n label_id_list = []\n for label in sequence_labels:\n if label not in dict_map:\n self.logger.warn(\"Label not... | [
"0.7547486",
"0.7505124",
"0.7039012",
"0.700775",
"0.6873091",
"0.6785202",
"0.676922",
"0.6675606",
"0.6547229",
"0.65472174",
"0.6520041",
"0.65026706",
"0.65026706",
"0.6430125",
"0.6411952",
"0.63387406",
"0.6327159",
"0.63106453",
"0.6276933",
"0.6254199",
"0.6231591",
... | 0.5816024 | 61 |
Test aperture_photometry when error has units (see 176). | def test_aperture_photometry_with_error_units():
data1 = np.ones((40, 40), dtype=float)
data2 = u.Quantity(data1, unit=u.adu)
error = u.Quantity(data1, unit=u.adu)
radius = 3
true_flux = np.pi * radius * radius
unit = u.adu
position = (20, 20)
table1 = aperture_photometry(data2, Circula... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_aperture_photometry_inputs_with_mask():\n\n data = np.ones((5, 5))\n aperture = CircularAperture((2, 2), 2.0)\n mask = np.zeros_like(data, dtype=bool)\n data[2, 2] = 100.0 # bad pixel\n mask[2, 2] = True\n error = np.sqrt(data)\n data_in = data.copy()\n error_in = error.copy()\n ... | [
"0.69079345",
"0.6512504",
"0.62657374",
"0.6050535",
"0.5927566",
"0.57785326",
"0.5778429",
"0.5767613",
"0.566218",
"0.5603356",
"0.5592774",
"0.55879194",
"0.5550571",
"0.55201626",
"0.5513671",
"0.54968745",
"0.5489606",
"0.5488023",
"0.54835194",
"0.544789",
"0.54413337... | 0.82502395 | 0 |
Test that aperture_photometry does not modify the input data or error array when a mask is input. | def test_aperture_photometry_inputs_with_mask():
data = np.ones((5, 5))
aperture = CircularAperture((2, 2), 2.0)
mask = np.zeros_like(data, dtype=bool)
data[2, 2] = 100.0 # bad pixel
mask[2, 2] = True
error = np.sqrt(data)
data_in = data.copy()
error_in = error.copy()
t1 = aperture... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_aperture_photometry_with_error_units():\n\n data1 = np.ones((40, 40), dtype=float)\n data2 = u.Quantity(data1, unit=u.adu)\n error = u.Quantity(data1, unit=u.adu)\n radius = 3\n true_flux = np.pi * radius * radius\n unit = u.adu\n position = (20, 20)\n table1 = aperture_photometry(... | [
"0.6387848",
"0.62934524",
"0.6213696",
"0.60203755",
"0.60186976",
"0.6006882",
"0.59526944",
"0.58965045",
"0.5882132",
"0.5878645",
"0.58625317",
"0.5860351",
"0.5847825",
"0.58367264",
"0.58344615",
"0.58279014",
"0.5787623",
"0.57459146",
"0.569849",
"0.56977993",
"0.567... | 0.87002504 | 0 |
Test elliptical exact aperture photometry on a grid of pixel positions. | def test_ellipse_exact_grid(x, y, r):
data = np.ones((10, 10))
aperture = EllipticalAperture((x, y), r, r, 0.0)
t = aperture_photometry(data, aperture, method='exact')
actual = t['aperture_sum'][0] / (np.pi * r**2)
assert_allclose(actual, 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def phantom_ellipses(n_points,E):\n \n #Rescaling according to image size \n E[:,0] = E[:,0]*n_points/2 #semiaxis a\n E[:,1] = E[:,1]*n_points/2 #semiaxis b\n E[:,2] = E[:,2]*n_points/2 #x\n E[:,3] = E[:,3]*n_points/2 #y\n E[:,4] = E[:,4]*math.pi/180\n \n x,y = np.meshgrid(np.arange(0,n... | [
"0.66793174",
"0.6369313",
"0.635344",
"0.5881113",
"0.57845265",
"0.5761885",
"0.57279414",
"0.561903",
"0.55827296",
"0.55767804",
"0.55325985",
"0.55246985",
"0.55024266",
"0.5493475",
"0.5487103",
"0.5459197",
"0.54441357",
"0.5431681",
"0.5411385",
"0.5358013",
"0.535433... | 0.7887095 | 0 |
Test that nans and infs are properly masked [267]. | def test_nan_inf_mask(value):
data = np.ones((9, 9))
mask = np.zeros_like(data, dtype=bool)
data[4, 4] = value
mask[4, 4] = True
radius = 2.0
aper = CircularAperture((4, 4), radius)
tbl = aperture_photometry(data, aper, mask=mask)
desired = (np.pi * radius**2) - 1
assert_allclose(tb... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_annular_fpm():\n\n # test some semi-random cases - is the array size as expected? \n assert masks.annular_fpm(3, 2, np.inf).shape == (3*2*2, 3*2*2)\n assert masks.annular_fpm(3, 5, np.inf).shape == (3*5*2, 3*5*2)\n assert masks.annular_fpm(3, 5, 10).shape == (3*10*2, 3*10*2)\n assert masks.... | [
"0.6896983",
"0.65440094",
"0.64346445",
"0.6424667",
"0.6418263",
"0.6261051",
"0.6158754",
"0.6155667",
"0.61021805",
"0.6079935",
"0.59743565",
"0.5958104",
"0.5948614",
"0.59462935",
"0.59143627",
"0.5910886",
"0.59006315",
"0.5854176",
"0.5841831",
"0.5824284",
"0.582298... | 0.65316564 | 2 |
Regression test to check that length1 aperture list appends a "_0" on the column names to be consistent with list inputs. | def test_scalar_aperture():
data = np.ones((20, 20), dtype=float)
ap = CircularAperture((10, 10), r=3.0)
colnames1 = aperture_photometry(data, ap, error=data).colnames
assert (colnames1 == ['id', 'xcenter', 'ycenter', 'aperture_sum',
'aperture_sum_err'])
colnames2 = aper... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_add_list_to_df(self):\n self.assertEqual(self.test_df.shape[1] + 1, em.add_list_to_df(self.test_list, self.test_df).shape[1])",
"def test_list_to_column(self):\n\n good_arg = [13, 14, 15, 16]\n bad_arg = [13, 14, 15, 16, 17]\n ld = Lambdata(self.df)\n\n good_df = ld.li... | [
"0.60576147",
"0.5731071",
"0.5648939",
"0.5648777",
"0.55926967",
"0.5588755",
"0.54673654",
"0.54425526",
"0.54072493",
"0.5385336",
"0.53755796",
"0.5357961",
"0.5279477",
"0.52708286",
"0.5265564",
"0.5232351",
"0.5222445",
"0.52125543",
"0.5208126",
"0.52043056",
"0.5203... | 0.5623747 | 4 |
Regression test that nonfinite data values outside of the aperture mask but within the bounding box do not affect the photometry. | def test_nan_in_bbox():
data1 = np.ones((101, 101))
data2 = data1.copy()
data1[33, 33] = np.nan
data1[67, 67] = np.inf
data1[33, 67] = -np.inf
data1[22, 22] = np.nan
data1[22, 23] = np.inf
error = data1.copy()
aper1 = CircularAperture((50, 50), r=20.0)
aper2 = CircularAperture(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_aperture_photometry_inputs_with_mask():\n\n data = np.ones((5, 5))\n aperture = CircularAperture((2, 2), 2.0)\n mask = np.zeros_like(data, dtype=bool)\n data[2, 2] = 100.0 # bad pixel\n mask[2, 2] = True\n error = np.sqrt(data)\n data_in = data.copy()\n error_in = error.copy()\n ... | [
"0.6720967",
"0.6610739",
"0.6296814",
"0.61645174",
"0.6088839",
"0.60787433",
"0.5982765",
"0.59556407",
"0.5947607",
"0.58739126",
"0.58470315",
"0.58464575",
"0.5712174",
"0.57064",
"0.57048935",
"0.5660747",
"0.5626591",
"0.5626591",
"0.5626591",
"0.5622805",
"0.5616519"... | 0.7124479 | 0 |
Regression test to check that scalar SkyCoords are added to the table as a length1 SkyCoord array. | def test_scalar_skycoord():
data = make_4gaussians_image()
wcs = make_wcs(data.shape)
skycoord = wcs.pixel_to_world(90, 60)
aper = SkyCircularAperture(skycoord, r=0.1 * u.arcsec)
tbl = aperture_photometry(data, aper, wcs=wcs)
assert isinstance(tbl['sky_center'], SkyCoord) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test_xy(self):\n x = np.array([[1,3], [2,8], [1,3]])\n y = np.array([1,1,-1])\n lro = LogisticRegressionOptimiser(x,y)\n expected = np.array([[1,3], [2,8], [-1,-3]])\n for i in 0,1,2:\n for j in 0,1:\n self.assertEqual(lro.xy[i][j], expected[i][j])",
"def test_scalar_index(self):\n... | [
"0.5772283",
"0.5675139",
"0.5644284",
"0.5608696",
"0.5585975",
"0.5573823",
"0.54413795",
"0.5437408",
"0.5400953",
"0.5393124",
"0.5352665",
"0.53412086",
"0.5340118",
"0.53243935",
"0.5320892",
"0.531939",
"0.5305857",
"0.5282068",
"0.52805465",
"0.5274832",
"0.5256645",
... | 0.5873713 | 0 |
Constructor of user class. | def __init__(self, id_user, description, ratings):
self.id_user = id_user
self.description = description
self.ratings = ratings
self.seen = {}
# Store key of the already seen films
for rating in ratings:
self.seen[rating[0]] = True | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, user=None):\n self.user = user",
"def __init__(self, user):\n\n if isinstance(user, dict):\n # Every user must have these values\n self.id = user['id']\n self.name = user['first_name']\n\n # These are optional\n self.username... | [
"0.8175485",
"0.80110633",
"0.79697067",
"0.78595746",
"0.7674515",
"0.75313747",
"0.7475908",
"0.74128264",
"0.7325977",
"0.73237973",
"0.73103154",
"0.73069423",
"0.7303166",
"0.72658205",
"0.7237329",
"0.7215348",
"0.72081065",
"0.718594",
"0.71829504",
"0.7182479",
"0.718... | 0.0 | -1 |
User description formatted as string | def to_string(self):
return "User: {} Description: {} Ratings: {}".format(self.id_user, self.description, self.ratings) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def clean_user_desc(self):\n desc = self.data['user']['description']\n if desc is not None:\n desc = ' '.join(re.sub(\"(RT : )|(@[\\S]+)|(&\\S+)|(http\\S+)\", \" \", desc).split())\n desc = \" \".join(re.sub(\"(#\\S+)\", ' ', desc).split())\n desc = ''.join(list(filte... | [
"0.74948144",
"0.7465629",
"0.7337709",
"0.7337709",
"0.73087656",
"0.70717615",
"0.70207506",
"0.6989267",
"0.6968106",
"0.6956012",
"0.6956012",
"0.69315743",
"0.6842594",
"0.68080837",
"0.68080837",
"0.6773586",
"0.67527544",
"0.67507523",
"0.6748187",
"0.6743495",
"0.6736... | 0.6687835 | 51 |
Getter of the user id. | def get_user_id(self):
return self.id_user | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_id(self):\n return self.user_id",
"def get_id(self) -> int:\n return self.user_id",
"def user_id(self):\n return self._user_id",
"def user_id(self):\n return self._user_id",
"def user_id(self):\n return self._user_id",
"def user_id(self):\n return self._u... | [
"0.8740212",
"0.8674682",
"0.8466421",
"0.8466421",
"0.8466421",
"0.8466421",
"0.8466421",
"0.84438294",
"0.84438294",
"0.8365442",
"0.8362073",
"0.83430153",
"0.8284895",
"0.8284895",
"0.8263458",
"0.8238554",
"0.82361627",
"0.82293457",
"0.8197898",
"0.8093313",
"0.80851257... | 0.8879019 | 0 |
Getter of ratings list for this user. | def get_ratings(self):
return self.ratings | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_user_ratings(self, user_id):\n return self.ratings[self.ratings['user_id'] == user_id]",
"def get_ratings(self):\n return Vote.objects.filter(content_type=self.get_content_type(), object_id=self.instance.pk, key=self.field.key)",
"def user_ratings(user_id):\n return _fetch_records(f\"... | [
"0.7477732",
"0.7453791",
"0.73936325",
"0.72100174",
"0.7001172",
"0.69021744",
"0.68245584",
"0.67234373",
"0.6693334",
"0.66076666",
"0.65877724",
"0.6586307",
"0.6462181",
"0.6363747",
"0.63283545",
"0.61764896",
"0.6175898",
"0.61114925",
"0.61114925",
"0.6096961",
"0.60... | 0.83241516 | 1 |
Method to check if a movie have been already seen for the given user. | def check_movie_seen(self, id_movie):
if id_movie in self.seen:
return True
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def new_watched_movie(username: str, movie_id: int) -> bool:\n with connection:\n all_movies = connection.execute(MOVIES_IDS, (movie_id,)).fetchone()\n all_usernames = connection.execute(USERS_IDS, (username,)).fetchone()\n if all_usernames is not None and all_movies is not None:\n ... | [
"0.62960756",
"0.6231976",
"0.609444",
"0.6070275",
"0.60486317",
"0.6042864",
"0.6039808",
"0.6021467",
"0.5981415",
"0.59635645",
"0.5831276",
"0.58286434",
"0.5827806",
"0.5819191",
"0.579271",
"0.5785383",
"0.57851636",
"0.5760467",
"0.57585835",
"0.57534826",
"0.5748277"... | 0.7359592 | 0 |
Constructor of the movie class | def __init__(self, id_movie, title, tags, ratings):
self.id_movie = id_movie
self.title = title
self.tags = tags
self.ratings = ratings | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, movie_title, movie_storyline, poster_image, trailer_youtube, imdb):",
"def __init__(self, movie_title, poster_image, trailer_youtube, movie_release_data, genre):\n # initialize instance of class Movie\n self.title = movie_title\n self.poster_image_url = poster_image\n ... | [
"0.81332725",
"0.8057832",
"0.80372345",
"0.8007488",
"0.7876238",
"0.7782773",
"0.7781757",
"0.7778634",
"0.7770506",
"0.7763023",
"0.77430177",
"0.7673336",
"0.76395553",
"0.75985646",
"0.7590946",
"0.75906765",
"0.75757456",
"0.7567521",
"0.7497632",
"0.74749136",
"0.74370... | 0.7570345 | 17 |
Getter of movie tags | def get_tags(self):
return self.tags | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def tags():",
"def getTags(self,):\n\t\treturn self.tags;",
"def get_tags(self):\n return self.tags",
"def tags(self):\n return self.get(\"tags\")",
"def tags(self) -> Optional[Any]:\n return pulumi.get(self, \"tags\")",
"def get_tag_object(self) -> Any:\n return self.tags",
... | [
"0.68689597",
"0.6856743",
"0.6677562",
"0.66561365",
"0.65500724",
"0.65472263",
"0.6528084",
"0.64343613",
"0.6412823",
"0.6399436",
"0.6379113",
"0.6379113",
"0.6379113",
"0.6379113",
"0.6375339",
"0.6375339",
"0.6369175",
"0.6369175",
"0.6369175",
"0.6369175",
"0.6369175"... | 0.64078057 | 9 |
Getter of movie id | def get_movie_id(self):
return self.id_movie | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_movie_id(self) -> str:\n return self.movie.id",
"def _get_ID(self):\n raw_data = imdb.search_for_title(self.title)\n if len(raw_data) > 1:\n raw_data = raw_data[0] # Pulls the first value of the title (the closest match)\n # if there is more than one\n s... | [
"0.8985618",
"0.72579557",
"0.7143325",
"0.6941592",
"0.6938852",
"0.68658173",
"0.67975396",
"0.6750645",
"0.67016894",
"0.66771835",
"0.6601591",
"0.6580242",
"0.6561278",
"0.65610945",
"0.6541132",
"0.6535963",
"0.65356594",
"0.65356594",
"0.65356594",
"0.65356594",
"0.653... | 0.8726083 | 1 |
Getter of movie title | def get_title(self):
return self.title | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_title(self, movie_id):\n movie = tmdbsimple.Movies(movie_id)\n request = movie.info()\n\n return movie.title",
"def get_title():",
"def getTitle(movieInfo):\n if \"title\" in movieInfo:\n #We remove the punctuation\n title = \"\".join(c for c in movieInfo[\"title... | [
"0.8006523",
"0.79383",
"0.79006845",
"0.7776308",
"0.7776308",
"0.7776308",
"0.7769293",
"0.763644",
"0.763644",
"0.763644",
"0.760456",
"0.75924677",
"0.75924677",
"0.756542",
"0.7538967",
"0.75355107",
"0.75276333",
"0.7488611",
"0.7444244",
"0.7436668",
"0.74352837",
"0... | 0.762117 | 10 |
Getter of ratings list for this movie. Pair (user, rating) | def get_ratings(self):
return self.ratings | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_ratings(user_id):\n return _fetch_records(f\"SELECT item_id, rating_type FROM ratings WHERE user_id = {user_id}\")",
"def _get_user_ratings(self, user_id):\n return self.ratings[self.ratings['user_id'] == user_id]",
"def ratings_usuarios(username, ratings):\n return list(filter(lambda x: ... | [
"0.7654455",
"0.75835025",
"0.7034352",
"0.7018935",
"0.68056756",
"0.67744166",
"0.6699223",
"0.66923803",
"0.66044664",
"0.6584102",
"0.64854413",
"0.63792723",
"0.6326823",
"0.63158023",
"0.63092196",
"0.62783813",
"0.62779266",
"0.6260052",
"0.62443334",
"0.62352544",
"0.... | 0.77323925 | 1 |
Get users with their ratings of the films | def get_users(self):
users = {}
for index, row in self.users.iterrows():
user_id = int(row[0])
description = row[1]
user_ratings = []
ratings = self.ratings.loc[self.ratings[0] == user_id]
# Get user ratings
for index_ratings, r... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def user_ratings(user_id):\n return _fetch_records(f\"SELECT item_id, rating_type FROM ratings WHERE user_id = {user_id}\")",
"def get_users_movies(myRatings):\n #return [x[1] for x in myRatings]\n return list(myRatings.map(lambda x: x[1]).collect())",
"def ratings_usuarios(username, ratings):\n re... | [
"0.6964112",
"0.6809451",
"0.67298615",
"0.65244675",
"0.6423165",
"0.6373602",
"0.63445354",
"0.6316285",
"0.6250459",
"0.6183882",
"0.6173987",
"0.6153373",
"0.614204",
"0.6126653",
"0.61181355",
"0.6086368",
"0.6040397",
"0.59927994",
"0.5991246",
"0.59750855",
"0.59494996... | 0.0 | -1 |
Get movies with their tags | def get_movies(self):
movies = {}
for index, movie in self.movies.iterrows():
id_movie = int(movie[0])
title = movie[1]
movie_tags = []
movie_ratings = []
# Get tags for each movie
tags = self.movies_tags.loc[self.movies_tags[0]... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_movies():\n tree = get_tree()\n movie_list = [movie.get(\"title\") for movie in tree.getroot().findall(\"movie\")]\n return movie_list",
"def get_keywords_for_movie(url):\n pass",
"def getMovies(idMovies):\n\n return [ getMovie(idMovie) for idMovie in idMovies ]",
"def __tags_to_movies... | [
"0.69026285",
"0.6240329",
"0.6185785",
"0.613752",
"0.60744643",
"0.6067202",
"0.6046541",
"0.60125107",
"0.5992258",
"0.5971938",
"0.59680724",
"0.59572107",
"0.59348136",
"0.5919582",
"0.5892605",
"0.5892192",
"0.5872411",
"0.5847143",
"0.58261526",
"0.58239055",
"0.580909... | 0.5151446 | 94 |
Write serialized object in a file | def write_serialized(self):
# If file is yet created, return data and do not create it again
if os.path.isfile(cfg.serialized):
return None
print("Creating users array...")
users = self.get_users()
print("Creating movies array...")
movies = self.get_movies(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def to_file(self, file_io):\n pickle.dump(self.__object, file_io)",
"def pickle_write(file_path, obj):\n\n with open(file_path, 'wb') as file:\n pickle.dump(obj, file)",
"def serialize_obj(obj, filename):\n\n f = open(filename, 'wb')\n pickle.dump(obj, f)\n f.close()",
"def write_to_f... | [
"0.7990699",
"0.78128994",
"0.7747138",
"0.77351314",
"0.770084",
"0.768513",
"0.76555765",
"0.76163775",
"0.7589536",
"0.7576737",
"0.7561195",
"0.75413436",
"0.7528892",
"0.75037986",
"0.7498625",
"0.7463269",
"0.744505",
"0.7435551",
"0.74297565",
"0.7413303",
"0.73993945"... | 0.0 | -1 |
Load file from pickle or create it if not exists | def load_serialized(self):
if not os.path.isfile(cfg.serialized):
serialized = self.write_serialized()
else:
print("Serialized object exists. Reading from disk...")
with open(cfg.serialized, 'rb') as file:
serialized = pickle.load(file)
return... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_or_create_db(self):\n try:\n with open(self._filename, 'rb') as f:\n self.db = pickle.load(f)\n except FileNotFoundError:\n pass",
"def pickle_load(path):\n if os.path.isfile(path):\n file = pickle.load(open(path, \"rb\"))\n return file... | [
"0.73671395",
"0.7074244",
"0.7026601",
"0.6962436",
"0.69058627",
"0.6887788",
"0.68675435",
"0.68597704",
"0.68209445",
"0.6775289",
"0.6747543",
"0.6731842",
"0.67144233",
"0.66686815",
"0.6662018",
"0.6662018",
"0.6638949",
"0.661873",
"0.65994537",
"0.659881",
"0.6575704... | 0.0 | -1 |
Write similarities data to file | def write_similarities(self, data):
# If file is yet created, return data and do not create it again
if os.path.isfile(cfg.similarities):
return None
with open(cfg.similarities, 'wb') as similarities:
print("Storing data as serialized object...")
pickle.dump(... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def record_similarities(similarities):\n writer = open(\"similarities.txt\", \"w\")\n for userA in similarities.keys():\n for userB in similarities[userA].keys():\n writer.write(userA + \"\\t\" + userB + \"\\t\" +\n str(similarities[userA][userB]) + \"\\n\")\n wri... | [
"0.68487245",
"0.6322778",
"0.62223566",
"0.608114",
"0.6032401",
"0.5957932",
"0.5846",
"0.581992",
"0.58038425",
"0.5798109",
"0.5784611",
"0.57362115",
"0.56961566",
"0.5652088",
"0.56154805",
"0.56049746",
"0.55978143",
"0.55934703",
"0.55828327",
"0.55662423",
"0.5545500... | 0.77305156 | 0 |
Load similarities pickle data | def load_similarities(self):
if not os.path.isfile(cfg.similarities):
return None
else:
print("Serialized object exists. Reading from disk...")
with open(cfg.similarities, 'rb') as file:
data = pickle.load(file)
return data | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def load_data():\r\n f = gzip.open('mnist.pkl.gz', 'rb')\r\n training_data, validation_data, test_data = pickle.load(f,encoding='bytes')\r\n f.close()\r\n return (training_data, validation_data, test_data)",
"def write_similarities(self, data):\n # If file is yet created, return data and do no... | [
"0.63505393",
"0.63323516",
"0.6323051",
"0.6226563",
"0.6211917",
"0.6082885",
"0.6041092",
"0.6009795",
"0.5966512",
"0.58577603",
"0.58408076",
"0.5830951",
"0.5827306",
"0.57913244",
"0.5778014",
"0.5771801",
"0.57601976",
"0.57570964",
"0.5746246",
"0.57078785",
"0.56944... | 0.7810446 | 0 |
Initializes our connectors by giving them a handler function. | def initConnectors(self):
def handlerFunc(message, responseFunc):
for h in self._handlers:
h.handleMessage(message, responseFunc)
getLogger(__name__).debug('Initializing %d connectors...' % len(self._connectors))
for c in self._connectors:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _init(self, connection_strings):\n # Init connections\n self._connections = []\n for s in connection_strings:\n d = Dict() # don't do Dict(foo=x) bc PyScript only supports that for dict\n self._connections.append(d)\n d.fullname = s\n d.type = s... | [
"0.6854127",
"0.6759487",
"0.6748176",
"0.6468161",
"0.6428388",
"0.63626826",
"0.6295971",
"0.62636906",
"0.6258875",
"0.62326473",
"0.616134",
"0.61134547",
"0.60776216",
"0.6075216",
"0.60286105",
"0.6026851",
"0.6011213",
"0.60032165",
"0.5989295",
"0.5989295",
"0.5989295... | 0.8177971 | 0 |
Iteratively splits data with stratification. This function is based on the iterative_train_test_split function from the skmultilearn.model_selection package, but uses pandas dataframes as input and output. | def iterative_train_test(X, y, test_size):
stratifier = IterativeStratification(n_splits=2, order=2, sample_distribution_per_fold=[test_size, 1.0-test_size])
train_indexes, test_indexes = next(stratifier.split(X, y))
X_train, y_train = X.iloc[train_indexes], y[train_indexes]
X_test, y_test = X.iloc[tes... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_data(input_df, output_df):\n return train_test_split(input_df, output_df, test_size=0.2, random_state=42,\n stratify=output_df)",
"def split(df, stratify_by=None):\n \n if stratify_by == None:\n train, test = train_test_split(df, test_size=.3, random_state=123... | [
"0.7940847",
"0.77700734",
"0.73608685",
"0.72325754",
"0.7231763",
"0.7201539",
"0.7191493",
"0.71370035",
"0.7097345",
"0.70749754",
"0.7068613",
"0.70635283",
"0.703297",
"0.7010203",
"0.69998264",
"0.6987067",
"0.69493777",
"0.6917207",
"0.69099796",
"0.6895471",
"0.68920... | 0.682493 | 24 |
Read a pulse of SPI data on a pin that corresponds to DYMO scale output protocol (12 bytes of data at about 14KHz), timeout is in seconds | def get_scale_data(pin, timeout=1.0):
timestamp = time.monotonic()
with pulseio.PulseIn(pin, maxlen=96, idle_state=True) as pulses:
pulses.pause()
pulses.clear()
pulses.resume()
while len(pulses) < 35:
if (time.monotonic() - timestamp) > timeout:
rais... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def s_read(self, timeout = 1):\n if self.s.is_open:\n data = [] \n b = bytearray()\n try:\n self.s.timeout = 3\n data = self.s.read(1)\n \n if not len(data):\n return b\n\n self.... | [
"0.6665904",
"0.6170786",
"0.6145323",
"0.61205214",
"0.6039192",
"0.6033334",
"0.59552085",
"0.5954513",
"0.58192575",
"0.5769836",
"0.5758939",
"0.56423473",
"0.5639176",
"0.5637689",
"0.56207716",
"0.56185025",
"0.5606741",
"0.5584944",
"0.55758065",
"0.5558758",
"0.554726... | 0.75666636 | 0 |
Summarizes all flag values in a string, to be used in output filenames. | def GetEncodedParams():
if FLAGS.debug:
import ptvsd
print("Waiting for debugger attach")
ptvsd.enable_attach(address=('localhost', 5678), redirect_output=True)
ptvsd.wait_for_attach()
breakpoint()
if FLAGS.use_signac:
import signac
project = signac.get_project(root=FLAGS.signac_root)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _parse_flags(self, flags):\n s = ''\n for flag in flags:\n if len(s):\n s += ' | '\n s += 'gf.sim.VariableFlag.%s' % (flag)\n if len(s):\n return s\n else:\n return '0'",
"def parseFlags(self):\n # Blank return value.\n retVal = \"\"\n \n try... | [
"0.62020266",
"0.596622",
"0.58193195",
"0.5534479",
"0.54420453",
"0.5390735",
"0.5235439",
"0.52093524",
"0.5140313",
"0.509892",
"0.4991748",
"0.49601457",
"0.49280116",
"0.49063626",
"0.49063626",
"0.48861432",
"0.4871902",
"0.48699248",
"0.48682913",
"0.48568994",
"0.482... | 0.0 | -1 |
encode convex hulls to network input format | def _encode_convex_hull(record):
max_encode_len = max(seq_len)
max_decode_len = max(seq_len) + 1 + 1
total_len = max_encode_len + max_decode_len
encoder_seq, hull = record
encoder_seq_len = len(encoder_seq)
# add new dimension for the [start] token
encoder_seq = [(0., *e) for e in encoder_seq]
# creat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _convex_hull(points):\n\n # Sort the points lexicographically (tuples are compared lexicographically).\n # Remove duplicates to detect the case we have just one unique point.\n points = sorted(set(points))\n\n # Boring case: no points or a single point, possibly repeated multiple times.\n if len... | [
"0.58518094",
"0.5845417",
"0.57677484",
"0.57292026",
"0.5701482",
"0.5699452",
"0.5666843",
"0.5633451",
"0.5616808",
"0.5535729",
"0.5463705",
"0.54190964",
"0.5377508",
"0.5347325",
"0.5336038",
"0.5333922",
"0.5331519",
"0.5311888",
"0.5309981",
"0.53056556",
"0.52919686... | 0.6956518 | 0 |
Stacks are comprised of multiple hosts. Each host may be located in different cloud accounts. This method returns a map of the underlying driver implementation and the hosts that running in the account. host_ids (list); a list of primary keys for the hosts we're interested in (dict); each key is a provider driver imple... | def get_driver_hosts_map(self, host_ids=None):
host_queryset = self.get_hosts(host_ids)
# Create an account -> hosts map
accounts = {}
for h in host_queryset:
accounts.setdefault(h.get_account(), []).append(h)
# Convert to a driver -> hosts map
result = {}
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_host_configs(self, hostids, **kwargs):\n host_configs = {}\n for hostid in hostids:\n host_configs[hostid] = self.get_host_config(hostid, **kwargs)\n return host_configs",
"def query_hosts(self, force=False):\n CACHE_KEY = 'salt-cloud-full-query'\n\n cached_r... | [
"0.6461176",
"0.62735856",
"0.60457814",
"0.5975142",
"0.5896362",
"0.5873509",
"0.5828188",
"0.5788435",
"0.5750981",
"0.574665",
"0.57066274",
"0.56011957",
"0.55321527",
"0.55266124",
"0.55064696",
"0.54972166",
"0.54785377",
"0.5460819",
"0.54548657",
"0.54415405",
"0.543... | 0.7679804 | 0 |
Quick way of getting all hosts or a subset for this stack. (list); list of primary keys of hosts in this stack (QuerySet); | def get_hosts(self, host_ids=None):
if not host_ids:
return self.hosts.all()
return self.hosts.filter(id__in=host_ids) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def list(self, **kwargs):\n\n return self.getResourceManager() \\\n .getSdk() \\\n .hosts \\\n .list(**kwargs)",
"def get_hosts(self):\n\n raise NotImplementedError",
"def hosts(self):\n\n return self._get_list_field(\"hosts\", lambda x... | [
"0.6386337",
"0.6371365",
"0.63523024",
"0.63523024",
"0.6272247",
"0.6215245",
"0.6201035",
"0.6201035",
"0.616472",
"0.6138865",
"0.6128013",
"0.6115967",
"0.6107518",
"0.60520285",
"0.6051724",
"0.60374975",
"0.6008605",
"0.6000928",
"0.599559",
"0.59938854",
"0.598613",
... | 0.6725173 | 0 |
Creates host objects on this Stack. If no arguments are given, then all hosts available based on the Stack's blueprint host definitions will be created. If args are given, then only the `count` for the given `host_definition` will be created. host_definition (BlueprintHostDefinition object); the host definition to use ... | def create_hosts(self, host_definition=None, count=None, backfill=False):
created_hosts = []
if host_definition is None:
host_definitions = self.blueprint.host_definitions.all()
else:
host_definitions = [host_definition]
for hostdef in host_definitions:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def post(self):\n\n try:\n if \"hosts\" in self.jbody:\n hostnames = self.jbody[\"hosts\"]\n else:\n hostnames = [{\"hostname\": self.jbody[\"hostname\"]}]\n except KeyError as err:\n raise exc.BadRequest(\n \"Missing Requi... | [
"0.4938579",
"0.48584768",
"0.47865078",
"0.47671604",
"0.47439453",
"0.47246405",
"0.4700411",
"0.46670032",
"0.45571178",
"0.45547783",
"0.44747478",
"0.43636113",
"0.43369415",
"0.42789087",
"0.4247567",
"0.4242754",
"0.4227977",
"0.4216803",
"0.42011896",
"0.42005447",
"0... | 0.8422698 | 0 |
Uses saltcloud to query all the hosts for the given stack id. | def query_hosts(self, force=False):
CACHE_KEY = 'salt-cloud-full-query'
cached_result = cache.get(CACHE_KEY)
if cached_result and not force:
logger.debug('salt-cloud query result cached')
result = cached_result
else:
logger.debug('salt-cloud query re... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def all_hosts(self):\n ...",
"def get_stacking_stacks_by_stack_id(self, stack_id, *, fields=None, **kwargs):\n function_endpoint = urljoin(self._baseurl, 'stacking/stacks/{stack_id}'.format(stack_id=stack_id))\n return self._call('GET', function_endpoint, **kwargs)",
"def get(self, request... | [
"0.6205435",
"0.6024829",
"0.60159945",
"0.59807694",
"0.595565",
"0.5935895",
"0.59275913",
"0.58967364",
"0.58842933",
"0.5843488",
"0.5838476",
"0.58124864",
"0.5785423",
"0.5756203",
"0.5662017",
"0.56044453",
"0.5555758",
"0.5528058",
"0.55251485",
"0.55106646",
"0.54707... | 0.6475528 | 0 |
It should delegate to the hardware API to calibrate the gripper. | async def test_calibrate_gripper(
decoy: Decoy,
ot3_hardware_api: OT3API,
_mock_ot3_calibration: None,
params_probe: CalibrateGripperParamsJaw,
expected_hc_probe: GripperProbe,
) -> None:
subject = CalibrateGripperImplementation(hardware_api=ot3_hardware_api)
params = CalibrateGripperParams... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def calibrate_gripper(self):\n self.gripper = Gripper(self.gripper_side)\n self.gripper.calibrate()\n self.gripper.open()\n self.vacuum_sensor = AnalogIO(self.gripper_side + '_vacuum_sensor_analog')\n if rospy.get_param('verbose'):\n rospy.loginfo('Calibrated gripper. ... | [
"0.75418216",
"0.7135867",
"0.67792577",
"0.6580618",
"0.65281117",
"0.6497911",
"0.6455138",
"0.63598543",
"0.6339586",
"0.6328379",
"0.62397826",
"0.6181482",
"0.6150413",
"0.6126467",
"0.61043966",
"0.6070043",
"0.6048816",
"0.6010795",
"0.59791523",
"0.59572184",
"0.59167... | 0.5706692 | 26 |
It should delegate to hardware API to calibrate the gripper & save calibration. | async def test_calibrate_gripper_saves_calibration(
decoy: Decoy,
ot3_hardware_api: OT3API,
_mock_ot3_calibration: None,
) -> None:
subject = CalibrateGripperImplementation(hardware_api=ot3_hardware_api)
params = CalibrateGripperParams(
jaw=CalibrateGripperParamsJaw.REAR,
otherJawOff... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _doCalibration(self):\n self._cmdCalibration(2)",
"def photometric_calibration():\n pass",
"def _calibrate(self, Otrain, Ftrain, Feval):\n raise NotImplementedError()",
"def calibrate_gripper(self):\n self.gripper = Gripper(self.gripper_side)\n self.gripper.calibrate()\... | [
"0.7903501",
"0.72188723",
"0.715543",
"0.6955527",
"0.6883555",
"0.68081695",
"0.6804072",
"0.67732644",
"0.67554444",
"0.66887903",
"0.66198134",
"0.6617778",
"0.6552011",
"0.65246826",
"0.6487285",
"0.6455561",
"0.644588",
"0.63531816",
"0.62793285",
"0.62448484",
"0.62343... | 0.5947198 | 36 |
Data should not be saved when an error is raised. | async def test_calibrate_gripper_does_not_save_during_error(
decoy: Decoy, ot3_hardware_api: OT3API
) -> None:
subject = CalibrateGripperImplementation(hardware_api=ot3_hardware_api)
params = CalibrateGripperParams(
jaw=CalibrateGripperParamsJaw.REAR,
otherJawOffset=Vec3f(x=4.4, y=5.5, z=6.... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def save_data(self):\n pass",
"def saveData(self):\n pass",
"def save(self):\r\n try:\r\n self.process_save()\r\n except InputError as ex:\r\n print(ex)\r\n self.save()\r\n except KeyError:\r\n print(\"No saved data to save/load. Pl... | [
"0.6786101",
"0.67231554",
"0.6600586",
"0.65661645",
"0.6451117",
"0.64248633",
"0.629678",
"0.62577516",
"0.6201316",
"0.6155443",
"0.61142343",
"0.611215",
"0.6106852",
"0.6094064",
"0.6088099",
"0.5968788",
"0.596374",
"0.5948944",
"0.59184533",
"0.591446",
"0.59111434",
... | 0.0 | -1 |
It should raise with a descriptive error if run on an OT2, instead of OT3. | async def test_calibrate_gripper_raises_on_ot2(
decoy: Decoy,
ot2_hardware_api: OT2API,
) -> None:
subject = CalibrateGripperImplementation(hardware_api=ot2_hardware_api)
params = CalibrateGripperParams(jaw=CalibrateGripperParamsJaw.REAR)
with pytest.raises(HardwareNotSupportedError):
awai... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def experiment3():\n raise FAKE_ERROR",
"def report_unexpected_exception(self, *args, **kwargs):\n pass",
"def unexpected_error(self, exception):",
"def test_error3(self):\n try:\n api = self.load_api_description('error3.json')\n self.fail('No error thrown for undefined input segment'... | [
"0.6747502",
"0.6558903",
"0.6558514",
"0.653314",
"0.6455933",
"0.63935745",
"0.6391505",
"0.6379069",
"0.6378044",
"0.6333795",
"0.6234843",
"0.6221498",
"0.61709213",
"0.6087179",
"0.60803807",
"0.6072119",
"0.6054898",
"0.6038267",
"0.6025209",
"0.6005897",
"0.59995884",
... | 0.0 | -1 |
Gets list of project users from taiga api, authorization token is provided Returns List of users emails | def project_users():
project_school = api.projects.get_by_slug('ps')
users_list = []
for member in project_school.members:
users_list.append(member.username + '@miem.hse.ru')
#replaces some users usernames as they are different in taiga than in google groups
for user... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fetch_all_users():\n url = \"{}/workspace/{}/users\".format(V1_API_URL, WORKSPACE_ID)\n responses = requests.get(url, headers=HEADERS)\n return [\n {\n \"acronym\": user[\"name\"].lower(),\n \"clockify_id\": user[\"id\"],\n \"email\":... | [
"0.73056626",
"0.72447586",
"0.70628095",
"0.6971299",
"0.69661814",
"0.6821465",
"0.68033063",
"0.67938226",
"0.674622",
"0.6712039",
"0.67060554",
"0.6679689",
"0.66765285",
"0.66745746",
"0.66613865",
"0.6642741",
"0.6589498",
"0.65809524",
"0.65250397",
"0.6493682",
"0.64... | 0.70697045 | 2 |
Given an array it splits the array in two parts at index i | def split_i(array:list, i:int) -> (list, list):
if i==len(array)-1:
return array[i], array[:-1]
else:
pre = array[0:i]
post = array[i+1:]
l = pre + post
x = array[i]
return x, l | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def split_array(a):\n n = len(a)\n if n == 1:\n return a\n index = n // 2\n b = a[:index]\n c = a[index:]\n return b, c",
"def even_split(a, n):\n n = min(n, len(a)) # if less elements in array than chunks to output, change chunks to array length\n k, m = divmod(len(a), n)\n ret... | [
"0.7665456",
"0.7067053",
"0.68895733",
"0.6825084",
"0.6575467",
"0.6566739",
"0.656526",
"0.6551348",
"0.65445685",
"0.6517187",
"0.64508444",
"0.6435194",
"0.6357571",
"0.63475424",
"0.6298871",
"0.6265837",
"0.6259398",
"0.6205831",
"0.6199721",
"0.61938316",
"0.61762506"... | 0.77543867 | 0 |
Since the architecture uses features computed through the image and its mask we precompute them to speed up the usage at runtime (Equation (13)) | def precompute_features(imgs:list, GTs:list, phi:models) -> list:
G_Ts = [1 - GTn for GTn in GTs]
IGms = [GTn * In for GTn, In in zip(GTs, imgs)]
I_Gms = [G_Tn * In for G_Tn, In in zip(G_Ts, imgs)]
features = [(phi(IGm), phi(I_Gm)) for IGm, I_Gm in zip(IGms, I_Gms)]
return features | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def feature(input_dir, input_img, mask, output_dir, window_size):\n\t# Get the pixel array of the ROI\n\tws = int(float(window_size))\n\tfilename = os.path.join(input_dir, input_img)\n\tim = nib.load(filename)\n\taffine = im.affine\n\timg = im.get_data() \n\t# img= (img - img.min()) / (np.sort(img,axis=None)[-10] ... | [
"0.6926122",
"0.67149717",
"0.66896415",
"0.6684665",
"0.66838753",
"0.65661734",
"0.6509679",
"0.6479813",
"0.6467656",
"0.64198256",
"0.6404838",
"0.6361878",
"0.63541794",
"0.6353836",
"0.63225704",
"0.62639576",
"0.6259601",
"0.62525296",
"0.6243414",
"0.62212324",
"0.616... | 0.62619364 | 16 |
Cross entropy loss for individual supervision, Equation (12) | def Ls(GTn:torch.tensor, Mn:torch.tensor) -> torch.tensor:
return (-(GTn * torch.log(Mn+1e-15) + (1- GTn) * torch.log((1- Mn)+1e-15))).sum() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def cross_entropy_loss():\n return nn.CrossEntropyLoss()",
"def cross_entropy(y_observed, p):\n\n pass",
"def cross_entropy_error(self, x, y):\n return -1 * sum([y[i] * np.log(self.logistic_function(self.weights.dot(x[i]))) + (1-y[i]) * np.log(1-self.logistic_function(self.weights.dot(x[i]))) for ... | [
"0.747013",
"0.7422436",
"0.7151027",
"0.7125091",
"0.68993956",
"0.6885498",
"0.68482375",
"0.68349075",
"0.6828572",
"0.6810557",
"0.6792025",
"0.6763931",
"0.6726077",
"0.6725324",
"0.6716315",
"0.6703539",
"0.6699556",
"0.66880083",
"0.6670996",
"0.66659564",
"0.66648346"... | 0.0 | -1 |
Triplet loss group wise constraint Equation (14) | def Lc(i:int, imgs:list, masks:list, features:list, phi:models) -> torch.tensor:
Ion = phi(masks[i] * imgs[i])
fi, fts = split_i(features, 1)
cumsum = 0
for IGm, I_Gm in fts:
P = torch.sqrt(((Ion - IGm)**2)+1e-016)
N = torch.sqrt(((Ion - I_Gm)**2)+1e-016)
cumsum += softplus(P-N).... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _auxiliary_loss(self, expert_mask, router_prob):\n # density_1's shape: (dp_group, self.expert_dim)\n density_1 = self.reduce_mean(expert_mask, 1)\n # density_1_proxy's shape: (dp_group, self.expert_dim)\n density_1_proxy = self.reduce_mean2(router_prob, 1)\n loss = self.mul(... | [
"0.5800624",
"0.5796773",
"0.5785705",
"0.5717265",
"0.570551",
"0.56547177",
"0.5628578",
"0.5609777",
"0.56024534",
"0.557875",
"0.557706",
"0.5565382",
"0.55586576",
"0.55550206",
"0.5553454",
"0.54859525",
"0.54835945",
"0.54827017",
"0.5469203",
"0.54655266",
"0.54564786... | 0.0 | -1 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.