self.current_step >= 0:\\n step = self.steps[self.current_step]\\n if step.is_fulfilled():\\n step.end(True)\",\n \"def _update_status(self):\\n if any([abs(v) > LIMITS[i] for i, v in enumerate(self.state)]):\\n self.terminal = True\\n elif abs(self.q[3]) < LIMITS[9]:\\n self.terminal = True\\n elif self.steps + 1 >= self.max_steps:\\n self.terminal = True\",\n \"async def async_update(self) -> None:\\n if (\\n self.device.appliance.status.get(BSH_POWER_STATE, {}).get(ATTR_VALUE)\\n == BSH_POWER_ON\\n ):\\n self._state = True\\n elif (\\n self.device.appliance.status.get(BSH_POWER_STATE, {}).get(ATTR_VALUE)\\n == self.device.power_off_state\\n ):\\n self._state = False\\n elif self.device.appliance.status.get(BSH_OPERATION_STATE, {}).get(\\n ATTR_VALUE, None\\n ) in [\\n \\\"BSH.Common.EnumType.OperationState.Ready\\\",\\n \\\"BSH.Common.EnumType.OperationState.DelayedStart\\\",\\n \\\"BSH.Common.EnumType.OperationState.Run\\\",\\n \\\"BSH.Common.EnumType.OperationState.Pause\\\",\\n \\\"BSH.Common.EnumType.OperationState.ActionRequired\\\",\\n \\\"BSH.Common.EnumType.OperationState.Aborting\\\",\\n \\\"BSH.Common.EnumType.OperationState.Finished\\\",\\n ]:\\n self._state = True\\n elif (\\n self.device.appliance.status.get(BSH_OPERATION_STATE, {}).get(ATTR_VALUE)\\n == \\\"BSH.Common.EnumType.OperationState.Inactive\\\"\\n ):\\n self._state = False\\n else:\\n self._state = None\\n _LOGGER.debug(\\\"Updated, new state: %s\\\", self._state)\",\n \"def update_waiting(self):\\n if not self.inputs[0]:\\n self.set_value(False, 0)\\n if self.desc_value in self.struct_variables:\\n struct = self.struct_variables[self.desc_value]\\n if struct[\\\"structure\\\"] in (\\\"list\\\", \\\"array\\\"):\\n values = self.struct_variables[self.desc_value][\\\"values\\\"]\\n if self.get_value(1) in values:\\n self.set_value(True, 0)\\n elif struct[\\\"structure\\\"] in (\\\"dict\\\", ):\\n values = self.struct_variables[self.desc_value][\\\"values\\\"].keys()\\n if self.get_value(1) in values:\\n self.set_value(True, 0)\\n self.state = ACTIVE\\n elif self.variant(map(lambda x: x is not None, self.get_value(0, True))):\\n self.set_value(False, 0)\\n for value in self.get_value(0, True):\\n if self.get_value(1) == value:\\n self.set_value(True, 0)\\n break\\n self.state = ACTIVE\",\n \"def update(self):\\n try:\\n self._state = self.robot.state\\n except req_HTTPError:\\n _LOGGER.error(\\\"Unable to retrieve to Robot State.\\\")\\n self._state = None\\n return False\",\n \"def update_waiting(self):\\n if self.variant(map(lambda x: x is not None, self.get_value(0, True))):\\n values = list(filter(lambda x: x is not None, self.get_value(0, True)))\\n if self.name == \\\"and\\\":\\n self.set_value(all(values), 0)\\n elif self.name == \\\"or\\\":\\n self.set_value(any(values), 0)\\n elif self.name == \\\"not and\\\":\\n self.set_value(not all(values), 0)\\n elif self.name == \\\"nor or\\\":\\n self.set_value(not any(values), 0)\\n elif self.name == \\\"equal\\\":\\n self.set_value(len(set(values)) == 1, 0)\\n self.state = ACTIVE\",\n \"def test_update_with_target_state(self):\\n self.switch._target_state = True\\n self.port.data = {}\\n self.port.data[\\\"output\\\"] = \\\"stale\\\"\\n self.switch.update()\\n assert 1.0 == self.port.data[\\\"output\\\"]\\n assert self.switch._target_state is None\\n self.port.data[\\\"output\\\"] = \\\"untouched\\\"\\n self.switch.update()\\n assert \\\"untouched\\\" == self.port.data[\\\"output\\\"]\",\n \"async def async_update(self):\\n\\n await self._data.async_update()\\n if not self._data:\\n _LOGGER.error(\\\"Didn't receive data from TOON\\\")\\n return\\n\\n boilerstatus = self._data.latest_data\\n\\n if 'sampleTime' in boilerstatus:\\n if boilerstatus[\\\"sampleTime\\\"] is not None:\\n self._last_updated = boilerstatus[\\\"sampleTime\\\"]\\n\\n if self._type == 'boilersetpoint':\\n if 'boilerSetpoint' in boilerstatus:\\n if boilerstatus[\\\"boilerSetpoint\\\"] is not None:\\n self._state = float(boilerstatus[\\\"boilerSetpoint\\\"])\\n\\n elif self._type == 'boilerintemp':\\n if 'boilerInTemp' in boilerstatus:\\n if boilerstatus[\\\"boilerInTemp\\\"] is not None:\\n self._state = float(boilerstatus[\\\"boilerInTemp\\\"])\\n\\n elif self._type == 'boilerouttemp':\\n if 'boilerOutTemp' in boilerstatus:\\n if boilerstatus[\\\"boilerOutTemp\\\"] is not None:\\n self._state = float(boilerstatus[\\\"boilerOutTemp\\\"])\\n\\n elif self._type == 'boilerpressure':\\n if 'boilerPressure' in boilerstatus:\\n if boilerstatus[\\\"boilerPressure\\\"] is not None:\\n self._state = float(boilerstatus[\\\"boilerPressure\\\"])\\n\\n elif self._type == 'boilermodulationlevel':\\n if 'boilerModulationLevel' in boilerstatus:\\n if boilerstatus[\\\"boilerModulationLevel\\\"] is not None:\\n self._state = float(boilerstatus[\\\"boilerModulationLevel\\\"])\\n\\n elif self._type == 'roomtemp':\\n if 'roomTemp' in boilerstatus:\\n if boilerstatus[\\\"roomTemp\\\"] is not None:\\n self._state = float(boilerstatus[\\\"roomTemp\\\"])\\n\\n elif self._type == 'roomtempsetpoint':\\n if 'roomTempSetpoint' in boilerstatus:\\n if boilerstatus[\\\"roomTempSetpoint\\\"] is not None:\\n self._state = float(boilerstatus[\\\"roomTempSetpoint\\\"])\\n\\n _LOGGER.debug(\\\"Device: {} State: {}\\\".format(self._type, self._state))\",\n \"def update_state(self):\\n self.last_position = self.current_position\\n self.last_distance = self.current_distance\\n self.last_collision_time_stamp = self.current_collision_time_stamp\\n self.current_kinematics = self.airsim_client.simGetGroundTruthKinematics(vehicle_name=self.drone_name)\\n self.current_position = self.current_kinematics.position + self.base_offset\\n self.current_collision_time_stamp = self.airsim_client.simGetCollisionInfo(vehicle_name=self.drone_name).time_stamp\\n # print(\\\"DEBUG: simGetCollisionInfo:\\\", self.airsim_client.simGetCollisionInfo(vehicle_name=self.drone_name))\\n # self.pending_death = self.airsim_client.simIsRacerDisqualified(vehicle_name=self.drone_name)\\n self.objective_status = self.current_objective.next_gate_status(self.last_position, self.current_position)\\n if self.objective_status == GateStatus.CROSSED or self.objective_status == GateStatus.PASSED:\\n if self.switch_to_next_objective(): # if track is finished (changes self.last_distance)\\n self.track_complete = True\\n self.current_distance = self.current_position.distance_to(self.current_objective.gate_pose.position)\",\n \"def update_waiting(self):\\n if self.get_value(0) is None:\\n self.set_value(False, 0)\\n else:\\n self.set_value(bool(self.get_value(0)), 0)\\n self.state = ACTIVE\",\n \"def check_state(self):\\n pass\",\n \"def bolt_check(self):\\n for x in self.get_bolts():\\n if x.get_velocity() > 0:\\n self.set_plyrbolts(1)\",\n \"def update_to_state(self, game_state):\\n pass\",\n \"def update_waiting(self):\\n if self.get_value(0) is None:\\n self.set_value(True, 0)\\n else:\\n self.set_value(not bool(self.get_value(0)), 0)\\n self.state = ACTIVE\",\n \"def update_waiting(self):\\n if self.get_value(0) is not None and self.get_value(1) is not None:\\n if self.name == \\\"greater\\\":\\n self.set_value(self.get_value(0) > self.get_value(1), 0)\\n if self.name == \\\"greater or equal\\\":\\n self.set_value(self.get_value(0) >= self.get_value(1), 0)\\n if self.name == \\\"less\\\":\\n self.set_value(self.get_value(0) < self.get_value(1), 0)\\n if self.name == \\\"less or equal\\\":\\n self.set_value(self.get_value(0) <= self.get_value(1), 0)\\n if self.name == \\\"not equal\\\":\\n self.set_value(self.get_value(0) != self.get_value(1), 0)\\n if self.name == \\\"xor\\\":\\n self.set_value(bool(self.get_value(0)) ^ bool(self.get_value(1)), 0)\\n self.state = ACTIVE\",\n \"def update_status(self):\\n num_nbrs = len(self.neighbors)\\n if not 2 <= num_nbrs <= 3:\\n self.status = 0\\n elif num_nbrs == 3:\\n self.status = 1\",\n \"def stopThinking(self):\\n self._brain.setState(\\\"controlled\\\")\",\n \"def _update_tbd(self, new_wss):\\n old_state = self.current_state\\n self.current_state = self._get_band_for_value(new_wss)\\n if (old_state != self.current_state):\\n self.num_intervals[self.current_state] += 1\",\n \"def updateState(self):\\n\\n if ('cutting' in self.step_ops) and (self.cut_state.user_cutting):\\n self.step_ops['cutting'] = True\\n \\n if ('cooking' in self.step_ops) and (self.cut_state.user_cooking):\\n self.step_ops['cooking'] = True\\n\\n # TODO: add the rest of the operations\\n\\n advance = True\\n\\n # Check if ALL operations are complete\\n for op in self.step_ops:\\n if self.step_ops[op] == False:\\n advance = False\\n break\\n\\n if advance:\\n self.nextStep()\",\n \"def init_bgn_end_cond( self ):\\n # NOTE: This function should be run before the first time 'update' is run\\n # Attempt to set the current update function. If it fails, assume that the user did not set up the FSM correctly\\n try:\\n # Check for the update function associated with the starting state\\n handler = self.handlers[ self.startState ]\\n self.active = True\\n except:\\n # If there was no function with this name 'startState', Then ask the user to set a start state\\n raise InitializationError( \\\"must call .set_start() before .run()\\\" )\\n # Warn the user if there were no end states \\n if not self.endStates:\\n raise InitializationError( \\\"At least one state must be an end_state\\\" )\",\n \"def _update(self, force_update=True):\\n with self._wemo_exception_handler(\\\"update status\\\"):\\n self._state = self.wemo.get_state(force_update)\",\n \"def update_vehicle_state(self):\\n #vel = self.v + self.commands['throttle']/self.m/self.simulation_rate\\n\\n vel = self.commands['speed']\\n steer = self.commands['steering_angle']\\n\\n if steer > 0.5:\\n steer_cmd = 25\\n elif steer < -0.5:\\n steer_cmd = 185\\n else:\\n steer_cmd = 100 - 160*steer ##linear\\n #steer_cmd = 100 - 640*steer**3 ##cubic\\n\\n #rospy.logwarn('Velocity command is '+ str(vel))\\n # 130 is the lowest vel_cmd that makes the truck move.\\n if vel > 12:\\n vel_cmd = 161\\n elif vel < 0:\\n vel_cmd = 0\\n else:\\n vel_cmd = 3.77*vel + 117\\n # rospy.logerr('throttle: ' + str(throttle))\\n hw_port.set_command(vel_cmd,steer_cmd,self.vehicle_id)\",\n \"async def async_update(self) -> None:\\n state = self.device.appliance.status.get(BSH_ACTIVE_PROGRAM, {})\\n if state.get(ATTR_VALUE) == self.program_name:\\n self._state = True\\n else:\\n self._state = False\\n _LOGGER.debug(\\\"Updated, new state: %s\\\", self._state)\",\n \"def updateState(self):\\n self.state = self.microgridPolicy.computeState();\",\n \"def tracking(self) -> None:\\n dist, delta_angle, timestamp = self.vision.get_vision_data()\\n # collect data only once per loop\\n if timestamp is None:\\n # self.next_state(\\\"searching\\\")\\n # print(f\\\"tracking -> searching {self.vision.get_vision_data()}\\\")\\n self.state = self.searching\\n else:\\n if abs(delta_angle) > self.find_allowable_angle(dist):\\n # print(f\\\"Telling turret to slew by {delta_angle}\\\")\\n self.turret.slew(delta_angle)\\n if self.ready_to_spin():\\n # self.next_state(\\\"firing\\\")\\n # print(f\\\"tracking -> spining_up {self.vision.get_vision_data()}\\\")\\n self.distance = dist\\n self.state = self.spining_up\",\n \"def _updateState(self):\\n\\n self.changeColorBtn.setEnabled(self.transformTypeCbx.isChecked() or self.shapeTypeCbx.isChecked())\",\n \"def is_boring(state):\\n return state.boring_moves >= state.just_stop\",\n \"def run(self):\\n ball = memory.world_objects.getObjPtr(core.WO_BALL)\\n if ball.seen:\\n self.finish()\\n \\n commands.setWalkVelocity(0, 0, -0.25)\",\n \"def simulation_step(self):\\n if not self.np_trajectory.size:\\n #No trajectory to go to.....\\n return\\n closest_ind = self.find_closest_trajectory_pose()\\n ref_ind = (closest_ind + 30) # closest_ind + numpy.round(self.v / 4)\\n traj_len = len(self.np_trajectory[0])\\n if self.loop is True:\\n ref_ind = ref_ind % traj_len\\n else:\\n if ref_ind > traj_len-1:\\n ref_ind = traj_len-1\\n if closest_ind == traj_len-1:\\n self.at_dest = True\\n else:\\n ref_ind = closest_ind\\n ref_state = self.np_trajectory[:, int(ref_ind)]\\n\\n # update vehicle state.\\n '''if self.class_name == 'TruckVehicle':\\n self.update_vehicle_state_qualisys()\\n self.UDP_receive()\\n if self.data == \\\"-1.00\\\":\\n self.set_control_commands_pp(ref_state, ref_ind)\\n else:\\n steer = int(self.data[-6:-3])\\n throttle = int(self.data[:-6]) + 5\\n hw_port.set_command(throttle,steer,2)\\n self.update_truck_hardware()\\n else:\\n self.set_control_commands(ref_state)\\n self.update_vehicle_state()'''\\n\\n self.set_control_commands(ref_state, ref_ind)\\n self.update_vehicle_state()\\n\\n # publish vehicle state.\\n vehicle_state = msgs.VehicleState(self.vehicle_id, self.class_name,\\n self.x, self.y, self.yaw, self.v)\\n self.pub_state.publish(vehicle_state)\\n self.update_current_node()\\n\\n #The way that the stop light waiting works, this is necessary\\n if not self.waiting_at_stop:\\n self.check_for_traffic_light()\\n self.get_traffic()\",\n \"def _update_model(self, new_state, data):\\n if new_state:\\n if (brightness := data) is not None:\\n self._brightness = brightness\\n\\n # _brightness is not defined when called from super\\n try:\\n self._state = self._brightness > 0\\n except AttributeError:\\n self._state = True\\n else:\\n self._state = False\",\n \"def update_state(self, elapsed_time):\\n if self.state == INITIAL_BUFFERING_STATE:\\n# config_pytomo.LOG.debug('State: INITIAL_BUFFERING_STATE')\\n# config_pytomo.LOG.debug('current_time=%s; Total_bytes=%s' %\\n# (self.current_time, self._total_bytes))\\n if (self.flv_timestamp > config_pytomo.INITIAL_BUFFER):\\n self.state = PLAYING_STATE\\n if config_pytomo.DEMO:\\n config_pytomo.LOG.info('\\\\n\\\\nStart\\\\n')\\n self.start_playback = elapsed_time\\n self.initial_data = self._total_bytes\\n try:\\n self.initial_rate = (self.initial_data * 8\\n / self.current_time / 1000)\\n except ZeroDivisionError:\\n self.initial_rate = 0\\n elif self.state == PLAYING_STATE:\\n# config_pytomo.LOG.debug('State: PLAYING_STATE')\\n# config_pytomo.LOG.debug('current_time=%s; Total_bytes=%s' %\\n# (self.current_time, self._total_bytes))\\n self.accumulated_playback = self.flv_timestamp\\n video_playback_time = (self.current_time - self.start_playback -\\n self.accumulated_buffer)\\n #print (\\\"PLaying state\\\", self.flv_timestamp, video_playback_time,\\n #self.accumulated_buffer)\\n if ((self.flv_timestamp - video_playback_time)\\n < config_pytomo.MIN_PLAYOUT_BUFFER):\\n self.state = BUFFERING_STATE\\n self.interruptions += 1\\n if config_pytomo.DEMO:\\n config_pytomo.LOG.info('\\\\n\\\\nInterruption\\\\n')\\n #import pdb; pdb.\\n elif self.state == BUFFERING_STATE:\\n# config_pytomo.LOG.debug('State: BUFFERING_STATE')\\n# config_pytomo.LOG.debug('current_time=%s; Total_bytes=%s' %\\n# (self.current_time, self._total_bytes))\\n self.accumulated_buffer += elapsed_time\\n video_playback_time = (self.current_time - self.start_playback -\\n self.accumulated_buffer)\\n #print \\\"BUFFERING_STATE \\\", self.flv_timestamp, video_playback_time\\n if (self.flv_timestamp - video_playback_time\\n > config_pytomo.MIN_PLAYOUT_RESTART):\\n self.state = PLAYING_STATE\\n if config_pytomo.DEMO:\\n config_pytomo.LOG.info('\\\\n\\\\nRestart\\\\n')\",\n \"def update_state(self, act):\\n\\n # check the checkbox logic\\n if act in ['follow', 'not_follow', 'locate', 'not_locate']:\\n self.check_locate_follow_logic(act)\\n # test/record logic\\n print(\\\"update function not implemented\\\")\",\n \"def testSettled(self):\\n self.injectEvent(safe.Settling.SETTLED)\\n self.assertCurrentState(safe.Grabbing)\",\n \"def update(self):\\n startstate = self.state\\n goalstates =self.env.getGoalStates()\\n inputs = self.env.sense(self)\\n self.action_sequence = self.drive(goalstates,inputs)\\n action = self.choose_action() # Choose an action\\n self.state = self.env.act(self,action) \\n return\",\n \"def update(self) -> None:\\n active = None\\n if self.type == \\\"on_off\\\":\\n self._data = self._tm_client.api.data\\n if self._data:\\n active = self._data.active_torrent_count > 0\\n\\n elif self.type == \\\"turtle_mode\\\":\\n active = self._tm_client.api.get_alt_speed_enabled()\\n\\n if active is None:\\n return\\n\\n self._state = STATE_ON if active else STATE_OFF\",\n \"def run(self):\\n memory.speech.say('Spinning!')\\n ball = memory.world_objects.getObjPtr(core.WO_BALL)\\n if ball.seen:\\n self.finish()\\n \\n commands.setWalkVelocity(0, 0, -0.25)\",\n \"def update_state(self, context):\\n pass\",\n \"def update_conditions(self) -> None:\\n self.log.debug(\\\"Updating conditions.\\\")\\n\\n self.models[\\\"sky\\\"].update(self.models[\\\"observatory_state\\\"].time)\\n\\n if self.is_night is None:\\n self.log.debug(\\\"Driver not initialized yet. Computing night parameters.\\\")\\n # Driver was not initialized yet. Need to compute night\\n # boundaries\\n\\n (self.current_sunset, self.current_sunrise) = self.models[\\n \\\"sky\\\"\\n ].get_night_boundaries(self.parameters.night_boundary)\\n\\n self.is_night = (\\n self.current_sunset\\n <= self.models[\\\"observatory_state\\\"].time\\n < self.current_sunrise\\n )\\n\\n self.log.debug(\\n f\\\"Sunset/Sunrise: {self.current_sunset}/{self.current_sunrise}, \\\"\\n f\\\"sun @ {self.parameters.night_boundary} degrees.\\\"\\n )\\n\\n is_night = self.is_night\\n\\n self.is_night = (\\n self.current_sunset\\n <= self.models[\\\"observatory_state\\\"].time\\n < self.current_sunrise\\n )\\n\\n # Only compute night boundaries when we transition from nighttime to\\n # daytime. Possibilities are:\\n # 1 - self.is_night=True and is_night = True: During the night (no need\\n # to compute anything).\\n # 2 - self.is_night=False and is_night = True: Transitioned from\\n # night/day (need to recompute night boundaries).\\n # 3 - self.is_night=True and is_night = False: Transitioned from\\n # day/night (no need to compute anything).\\n # 4 - self.is_night=False and is_night = False: During the day, no need\\n # to compute anything.\\n if not self.is_night and is_night:\\n self.log.debug(\\n \\\"Night over. Computing next night boundaries. \\\"\\n f\\\"Assuming sun elevation of {self.parameters.night_boundary}.\\\"\\n )\\n self.night += 1\\n (self.current_sunset, self.current_sunrise) = self.models[\\n \\\"sky\\\"\\n ].get_night_boundaries(self.parameters.night_boundary)\\n\\n self.log.debug(\\n f\\\"[{self.night}]: Sunset/Sunrise: {self.current_sunset}/{self.current_sunrise} \\\"\\n )\",\n \"def _run_state(self):\\n main_log.debug(\\\"Running state \\\" + self.state)\\n\\n if not self.get_state_info(\\\"condition\\\"):\\n self._run_next_state()\\n return\\n\\n try:\\n self._pre()\\n except StateSwitchException as e:\\n self.state = e.next_state\\n self._run_state()\\n return\\n\\n if self.get_state_info(\\\"wake_players\\\"):\\n self._waiting_for_players = True\\n self._wake_players()\\n else:\\n self._players_are_done()\",\n \"def check_status(self, sensor, state):\\n self.sensed = sensor\\n if state == 1:\\n self.winner = True\\n elif state == -1:\\n self.alive = False\",\n \"def update_state(self):\\n if not self.platforms:\\n self.state = self.states['Win']\\n elif self.player.y > 389:\\n self.state = self.states['Lose'] \\n else:\\n self.state = self.states['Game']\",\n \"async def async_set_turbo(self, turbo, state_mode):\\n if turbo not in ON_OFF_LIST:\\n return\\n self._turbo = turbo.lower()\\n self._state_mode = state_mode\\n await self.async_send_cmd()\",\n \"async def async_update(self):\\n self._state = await self._gate.is_light_on(self._light_id)\",\n \"def set_state( self ):\",\n \"async def receive_gate_state(self, bpb_state):\\n self._state = bpb_state == \\\"1\\\"\\n await self.async_update_ha_state()\",\n \"async def change_blower(self, newstate):\\n # this is a 4-mode switch\\n if not self.connected:\\n return\\n\\n # this is a toggle switch, not on/off\\n if self.blower_status == newstate:\\n return\\n\\n # what we know:\\n data = bytearray(9)\\n data[0] = M_START\\n data[1] = 7\\n data[2] = mtypes[BMTS_CONTROL_REQ][0]\\n data[3] = mtypes[BMTS_CONTROL_REQ][1]\\n data[4] = mtypes[BMTS_CONTROL_REQ][2]\\n data[6] = 0x00 # who knows?\\n data[8] = M_END\\n\\n # calculate how many times to push the button\\n for iter in range(1, 4+1):\\n if newstate == ((self.blower_status + iter) % 4):\\n break\\n\\n # now push the button until we hit desired state\\n for pushes in range(1, iter+1):\\n data[5] = C_BLOWER\\n data[7] = messages.Message.crc(data[1:7])\\n self.writer.write(data)\\n await self.writer.drain()\\n await asyncio.sleep(0.5)\",\n \"def run_state_machine(self):\\n\\n # Initial check for startup state\\n if self.status == 'STARTUP':\\n self.update_action(self.status, None, None, None)\\n # Get apriltag data from the detector\\n\\n return_tag_data = self.apriltag_detector.get_apriltag_data()\\n\\n # Check if it saw an apriltag\\n if len(return_tag_data) != 0:\\n\\n # Iterate over the data from each of the apriltags seen\\n for i in range(len(return_tag_data)):\\n\\n # Temp apriltag data\\n temp_tag = return_tag_data[i]\\n\\n print(\\\"current state: \\\", self.status)\\n\\n print(\\\"Statemachine x VAL: \\\", temp_tag[1])\\n\\n print(\\\"Statemachine y VAL: \\\", temp_tag[2])\\n\\n # If the smallbot is currently in the CREEP_FORWARD state\\n # handle cases for when the camera sees the side tags while it is driving forward\\n if self.status == 'CREEP_FORWARD' and (temp_tag[0] == self.back_tag):\\n self.current_tag = temp_tag[0]\\n print(\\\"ATTEMPTING TO UPDATE STATUS 1\\\")\\n self.update_action(self.status, temp_tag[1], temp_tag[2], temp_tag[3])\\n # Ignore cases when the camera sees the side apriltags\\n elif self.status == 'CREEP_FORWARD' and (temp_tag[0] == self.right_tag):\\n print(\\\"ATTEMPTING TO UPDATE STATUS 2\\\")\\n pass\\n elif self.status == 'CREEP_FORWARD' and (temp_tag[0] == self.left_tag):\\n print(\\\"ATTEMPTING TO UPDATE STATUS 2\\\")\\n pass\\n else:\\n self.current_tag = temp_tag[0]\\n print(\\\"ATTEMPTING TO UPDATE STATUS 3\\\")\\n self.update_action(self.status, temp_tag[1], temp_tag[2], temp_tag[3])\\n\\n # If the camera did not see any apriltags\\n else:\\n self.current_tag = None\\n self.update_action(None, None, None, None)\",\n \"def updateState(self) -> bool:\\n try:\\n\\n self.state[\\\"lastRunLocal\\\"] = datetime.utcnow()\\n\\n # Update pollingState which contains the details of the last record that has been pushed to LA for any resource.\\n self.state[POLLING_STATE] = self.pollingState\\n\\n self.tracer.info(\\n \\\"[%s] internal state successfully updated\\\" % self.fullName)\\n return True\\n except Exception as e:\\n self.tracer.error(\\n \\\"[%s] Could not update interanl state. (%s)\\\", self.fullName, e, exc_info=True)\\n return False\",\n \"def set_status_running(self) -> None:\\n if self._is_aborted():\\n return\\n assert self._status == self.Status.WAITING_FOR_TEST_START\\n self._status = self.Status.RUNNING\\n self.notify_update()\",\n \"def state_wait_validate(cfg, app, win, events):\",\n \"def execute(self, userdata):\\n rospy.loginfo(\\\"Executing state PLAY\\\")\\n\\n global currentRadius, BallDetected, BallCheck\\n\\n ## While loop to remain in the state until some conditions are missed\\n while True:\\n \\n ## Start moving the head if the robot is near to the ball\\n # @param currentRadious float passsed\\n if (currentRadius > 90):\\n #rospy.loginfo('muovo la testa')\\n head_control()\\n \\n ## Back to state normal if the ball is missed\\n # @param BAllDetected bool \\n if (BallDetected == False):\\n BallCheck = False\\n rospy.loginfo('WOOF! Ball missed :(')\\n return 'GoToNormal'\\n\\n time.sleep(3)\",\n \"def stop_watching(self, entity, attribute, old, new, kwargs):\\n self.sensor_living.set_state_boolean(True)\",\n \"def stopCond(self):\\n\\t\\treturn False\",\n \"def update(self):\\n bondState = self._bond.getDeviceState(self._deviceId)\\n if 'power' in bondState:\\n self._state = True if bondState['power'] == 1 else False\\n if self._state and bondState['speed'] in self._speed_name_by_value:\\n self._attributes['current_speed'] = self._speed_name_by_value[bondState['speed']]\\n else:\\n self._attributes['current_speed'] = SPEED_OFF\\n\\n if 'direction' in bondState:\\n if bondState['direction'] == Directions.REVERSE:\\n self._attributes['current_direction'] = \\\"reverse\\\"\\n else:\\n self._attributes['current_direction'] = \\\"forward\\\"\",\n \"def update(self, t):\\n self.state.send(t)\",\n \"def test_update_state(self):\\n pass\",\n \"def state_wait_do(cfg, app, win, events):\",\n \"def change_status(self):\\n if self.status == \\\"Still Loaned\\\":\\n self.status = \\\"Given Back\\\"\\n else:\\n self.status = \\\"Still Loaned\\\"\",\n \"def state_processing_validate(cfg, app, win, events):\",\n \"def _update_state(self) -> None:\\n raise NotImplementedError(\\\"\\\")\",\n \"def ok_to_confirm_ball_via_playfield_switch(self):\\n if not self.balls:\\n return True\\n else:\\n return False\\n\\n # todo look for other incoming balls?\",\n \"def stop(self):\\n\\n print(\\\"Status sent: stop\\\")\\n\\n offset = self.app_id * 10\\n\\n status_dict = {}\\n # Test run led\\n status_dict[offset + self.PIN_LED] = 0\\n\\n self.post_dict(status_dict)\",\n \"def performBreak(self, reason):\\n\\t\\tself.skyfall = False\\n\\t\\tself.fireball = False\\n\\t\\tself.catch_n_hold = False\\n\\t\\tself.tech_support = False\\n\\t\\tself.fading = True\\n\\t\\tself.break_reason = reason\",\n \"def _advance_to_running(self):\\n if all(character.status == Character.FINISHED for character in self.characters.filter(Q(owner__in=self.get_players()))):\\n self.status = Game.RUNNING\\n self.save()\\n else:\\n raise ValidationError('All player characters must be approved before continuing.')\",\n \"def update(self):\\n self._state = 23\",\n \"def grab_paused(self):\\n\\t\\tif time.time() - self.time_paused > PAUSE_INTERVAL:\\n\\t\\t\\tself.status.state = 'stop'\",\n \"def stop_bath(self):\\n\\n self.send(self.cmd.SET_HEATING_RUNNING, False)\",\n \"def set_game_state(self,winner):\\r\\n if winner == 'b':\\r\\n self._game_state = \\\"BLACK_WON\\\"\\r\\n else:\\r\\n self._game_state = \\\"RED_WON\\\"\",\n \"def test_update_team_state(self):\\n pass\",\n \"def _update_status(self):\\n self._db_update({'status': self.status})\",\n \"def execute(self,userdata):\\n\\n global BallDetected\\n \\n self.counter = random.randint(1,2)\\n goal = exp_assignment2.msg.PlanningGoal()\\n\\n while not rospy.is_shutdown(): \\n rospy.loginfo('Executing state NORMAL')\\n \\n ## If the Ball is Detcted, go to PLAY\\n # @return GoToPlay\\n if (BallDetected == True) and (BallCheck == True):\\n return 'GoToPlay'\\n\\n ## After some NORMAL state iteration, go to SLEEP mode\\n # @return GoToSleep\\n if self.counter == 3:\\n return 'GoToSleep'\\n \\n ## Setting the random goal position\\n goal.target_pose_robot.pose.position.x = random.randint(-6,6)\\n goal.target_pose_robot.pose.position.y = random.randint(-6,6)\\n rospy.loginfo('i m going to x: %d y: %d',goal.target_pose_robot.pose.position.x, goal.target_pose_robot.pose.position.y )\\n client.send_goal(goal) \\n client.wait_for_result()\\n rospy.loginfo('I m arrived')\\n time.sleep(2)\\n self.rate.sleep()\\n self.counter += 1\\n\\n return 'GoToSleep'\",\n \"def mark_running(self):\\r\\n self.status = RUNNING\",\n \"def changeExecutionState(self,stop=True):\\n rospy.loginfo(\\\"STOP executing behavior set to %d\\\"%stop)\\n self.baxter.hlm.stop(stop) \\n self.baxter.br.stopExecution(\\\"left\\\",stop)\\n self.baxter.br.stopExecution(\\\"right\\\",stop)\",\n \"def status(self):\\n return self.value > self.initial_value/2 \\\\\\n and self.bag > 0 \\\\\\n and self.balance > 1\",\n \"async def update(self):\\n resp = await self._request('get', 'state')\\n if resp:\\n for line in resp.splitlines():\\n key, val = line.strip().split(None, 1)\\n if val == 'on' or val == 'off':\\n val = (val == 'on')\\n self.state_data[key] = val\\n else:\\n self.state_data[key] = val\",\n \"def _state_update(self):\\n self.state = self.mesh.state()\\n if self.state < 0:\\n self.state = self.STATE_DISABLED\\n return self.state\",\n \"def set_boresight(self, session, params):\\n with self.boresight_lock.acquire_timeout(0, job='set_boresight') as acquired:\\n if not acquired:\\n return False, f\\\"Operation failed: {self.boresight_lock.job} is running.\\\"\\n\\n ok, msg = yield self._check_ready_motion(session)\\n if not ok:\\n return False, msg\\n\\n target = params['target']\\n\\n for axis, target in {'boresight': target}.items():\\n limit_func, limits = self._get_limit_func(axis)\\n if target != limit_func(target):\\n raise ocs_agent.ParamError(\\n f'{axis}={target} not in accepted range, '\\n f'[{limits[0]}, {limits[1]}].')\\n\\n self.log.info(f'Commanded position: boresight={target}')\\n session.set_status('running')\\n\\n ok, msg = yield self._go_to_axis(session, 'Boresight', target)\\n\\n if ok and params['end_stop']:\\n yield self.acu_control.http.Command('DataSets.CmdModeTransfer',\\n 'Set3rdAxisMode', 'Stop')\\n\\n return ok, msg\",\n \"def _check_classical_stop_conditions(self, changed):\\n searching = changed and (self._iteration < self._max_iterations) \\n if not changed:\\n self._notify(message=LocalSearchMessage.StoppedPrematurely)\\n elif not searching: \\n self._notify(message=LocalSearchMessage.Stopped)\\n elif self._target_fitness:\\n if self._solution.fitness >= self._target_fitness:\\n self._notify(message=LocalSearchMessage.StoppedTargetAchieved)\\n return False\\n return searching\",\n \"async def _toggle_pump(\\n self, update: Update, context: ContextTypes.DEFAULT_TYPE\\n ) -> None:\\n self.system_status_lock.acquire()\\n self.system_status_proxy[\\\"waterpump\\\"] = int(\\n not self.system_status_proxy[\\\"waterpump\\\"]\\n )\\n await update.message.reply_text(\\n f\\\"{__name__.split('.')[-1]}: Request Pump Status to {self.system_status_proxy['waterpump']}\\\"\\n )\\n self.system_status_lock.release()\",\n \"def update_state(self, a, obs, t):\\n \\n self.update_weights(a, obs, t) # only update weights, not particles \\n self.update_running_average_weights(t) \\n return None\",\n \"def update_state_v1(self, dbsession, state):\\n moving_player = self.active_player()\\n board = self.update(state)\\n table_game = dbsession.query(TableGame).filter(\\n TableGame.game == board.id).first()\\n table_board = TableBoard(\\n board_state=dumps(tuple(map(tuple, board.board))),\\n move_num=board._board.move_count,\\n player=board.active_player(),\\n game=board.id)\\n if table_game: # TODO(grandquista)\\n table_board.game_link.append(table_game)\\n dbsession.add(table_board)\\n if board:\\n board.poke_player(False)\\n return {'end': False}\\n board.poke_player(True, moving_player)\\n if board._board.has_kings():\\n table_game.one_won = False\\n table_game.two_won = False\\n elif moving_player == table_game.player_one:\\n table_game.two_won = False\\n else:\\n table_game.one_won = False\\n board.close()\\n return {'end': True}\",\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 server_cvar(event_var):\\r\\n global currentTurboMode\\r\\n global database\\r\\n debug.write(\\\"[SourceRPG] Handling server_cvar\\\", 1)\\r\\n if event_var['cvarname'] == \\\"srpg_turboMode\\\":\\r\\n debug.write(\\\"Altering turbo mode\\\", 1)\\r\\n newValue = bool( int(event_var['cvarvalue']))\\r\\n debug.write(\\\"New value of turbo mode: %s\\\" % newValue, 1)\\r\\n if newValue <> currentTurboMode:\\r\\n debug.write(\\\"New Value differs to the old value\\\", 1)\\r\\n if newValue:\\r\\n \\\"\\\"\\\" Turbo mode was activated. Restart the round \\\"\\\"\\\"\\r\\n debug.write(\\\"Closing database and creating a new memory object\\\", 1)\\r\\n gamethread.cancelDelayed('sourcerpg_databasesave')\\r\\n \\r\\n database = SQLiteManager(\\\":memory:\\\") # Calls deconstructor on the database\\r\\n es.server.queuecmd('mp_restartgame 2')\\r\\n else:\\r\\n debug.write(\\\"Closing database and opening the real database\\\",1 )\\r\\n \\\"\\\"\\\" Turbo mode was switched off \\\"\\\"\\\"\\r\\n database = SQLiteManager(databasePath)\\r\\n es.server.queuecmd('mp_restartgame 2')\\r\\n \\r\\n \\\"\\\"\\\" If we need to start the loop again \\\"\\\"\\\"\\r\\n gamethread.cancelDelayed('sourcerpg_databasesave')\\r\\n if str( saveType ) == \\\"intervals\\\":\\r\\n gamethread.delayedname(float(saveLength), 'sourcerpg_databasesave', saveDatabase)\\r\\n \\r\\n currentTurboMode = newValue\\r\\n \\r\\n \\\"\\\"\\\" Ensure that all players are activated and their new values are reset \\\"\\\"\\\"\\r\\n for player in es.getUseridList():\\r\\n debug.write(\\\"Reloading stats for player %s\\\" % es.getplayername(player), 2)\\r\\n tokens = {}\\r\\n tokens['userid'] = player\\r\\n tokens['es_steamid'] = es.getplayersteamid(player)\\r\\n player_activate(tokens)\\r\\n debug.write(\\\"[SourceRPG] server_cvar handled\\\", 1)\",\n \"def the_changed_brightness_should_be_reflected_in_the_state_10():\\n assert web_app.get_state()\\n assert web_app.check_value_in_state(\\\"brightness\\\",\\\"10\\\")\",\n \"def goal_test(self, state):\\n for x, y in state.alvos:\\n if state.tabuleiro[x][y] is not BOX_ON_TARGET:\\n return False\\n return True\",\n \"def test_update_task_states(self):\\r\\n changed = self.combinedoe.update_task_states()\\r\\n self.assertFalse(changed)\\r\\n\\r\\n current_task = self.combinedoe.current_task\\r\\n current_task.change_state(CombinedOpenEndedV1Module.DONE)\\r\\n changed = self.combinedoe.update_task_states()\\r\\n\\r\\n self.assertTrue(changed)\",\n \"def handle_start_stop(self, req):\\n\\n # if turtlebot is moving, stop it\\n if self.is_moving:\\n self.is_moving = False\\n\\n\\t r = rospy.Rate(2)\\n\\n cmd_msg = Twist()\\n cmd_msg.linear.x = NO_SPEED\\n cmd_msg.angular.z = NO_SPEED\\n self.cmd_pub.publish(cmd_msg)\\n\\n r.sleep()\\n\\n return TriggerResponse(True, \\\"Robot safely stopped.\\\")\\n\\n # if turtlebot is not moving, start it\\n else:\\n self.is_moving = True\\n self.state.reinitialize()\\n\\n return TriggerResponse(True, \\\"Robot safely started.\\\")\",\n \"def check(self, context):\\r\\n return context.config.stopAt is not None\",\n \"def goal_test(self, state):\\n #return state == self.goal\",\n \"def run_states(self):\\n if (self.state == \\\"off\\\"):\\n if (self.in_power.value == 1):\\n self.off_to_on()\\n \\n elif self.state == \\\"on\\\":\\n if (self.in_power.value == 0):\\n self.any_to_off()\\n elif (self.in_alert.value == 1):\\n self.on_to_alert()\\n \\n elif self.state == \\\"alert\\\":\\n if (self.in_power.value == 0):\\n self.any_to_off()\\n elif (self.in_alert.value == 0):\\n self.alert_to_was_alert()\\n\\n elif self.state == \\\"was_alert\\\":\\n if (self.in_power.value == 0):\\n self.any_to_off()\",\n \"def state_finish_validate(cfg, app, win, events):\",\n \"def state_processing_do(cfg, app, win, events):\",\n \"def buttonStatusChange(self,**kwargs):\\n # If the dictionary robot value is 'tb1' then change the button Style\\n if kwargs['robot']=='tb1':\\n if self.robot_TB1_Viewer.isChecked() is True:\\n self.robot_TB1_Status.setStyleSheet(\\\"background: rgba(25, 27, 33, 0.2);\\\\n\\\"\\n \\\"color: rgb(193, 69, 69);\\\\n\\\"\\n \\\"font: 7pt \\\\\\\"Khmer OS\\\\\\\";\\\")\\n else:\\n self.robot_TB1_Status.setStyleSheet(\\\"color: rgb(193, 69, 69);\\\\n\\\"\\n \\\"font: 7pt \\\\\\\"Khmer OS\\\\\\\";\\\")\\n # If the dictionary robot value is 'tb2' then change the button Style\\n if kwargs['robot']=='tb2':\\n if self.robot_TB2_Viewer.isChecked() is True:\\n self.robot_TB2_Status.setStyleSheet(\\\"background: rgba(25, 27, 33, 0.2);\\\\n\\\"\\n \\\"color: rgb(193, 69, 69);\\\\n\\\"\\n \\\"font: 7pt \\\\\\\"Khmer OS\\\\\\\";\\\")\\n else:\\n self.robot_TB2_Status.setStyleSheet(\\\"color: rgb(193, 69, 69);\\\\n\\\"\\n \\\"font: 7pt \\\\\\\"Khmer OS\\\\\\\";\\\")\\n # If the dictionary robot value is 'tb3' then change the button Style\\n if kwargs['robot']=='tb3':\\n if self.robot_TB3_Viewer.isChecked() is True:\\n self.robot_TB3_Status.setStyleSheet(\\\"background: rgba(25, 27, 33, 0.2);\\\\n\\\"\\n \\\"color: rgb(193, 69, 69);\\\\n\\\"\\n \\\"font: 7pt \\\\\\\"Khmer OS\\\\\\\";\\\")\\n else:\\n self.robot_TB3_Status.setStyleSheet(\\\"color: rgb(193, 69, 69);\\\\n\\\"\\n \\\"font: 7pt \\\\\\\"Khmer OS\\\\\\\";\\\")\\n # If the dictionary robot value is 'tb4' then change the button Style\\n if kwargs['robot']=='tb4':\\n if self.robot_TB4_Viewer.isChecked() is True:\\n self.robot_TB4_Status.setStyleSheet(\\\"background: rgba(25, 27, 33, 0.2);\\\\n\\\"\\n \\\"color: rgb(193, 69, 69);\\\\n\\\"\\n \\\"font: 7pt \\\\\\\"Khmer OS\\\\\\\";\\\")\\n else:\\n self.robot_TB4_Status.setStyleSheet(\\\"color: rgb(193, 69, 69);\\\\n\\\"\\n \\\"font: 7pt \\\\\\\"Khmer OS\\\\\\\";\\\")\",\n \"def stop_check(self):\\n pass\",\n \"def check_device_state(self):\",\n \"def _set_status(self):\\n result = self._get_status()\\n if result and result[0]['state'] == 'aborted':\\n raise Exception(\\\"Aborted because the status flag is set to 'aborted' in dynamodb\\\")\\n\\n # record the status\\n self.status['timestamp'] = time.strftime(\\\"%Y-%m-%dT%H:%M:%SZ\\\")\\n self.db_handler.update_item({'api_version': TsV2CatalogHandler.api_version}, self.status)\",\n \"def manualState(self, tfid, state):\\n self.trafficLights.get(int(tfid)).setState(state)\\n self.trafficLights.get(int(tfid)).updateState()\",\n \"def on_step(self, t, is_update): \\n if t >= self.t_learn_start + self.t_start:\\n if is_update:\\n self.has_updated = True\\n \\n if t % self.t_save == 0 and self.has_updated:\\n # Save model.\\n self.save_model(t, self.saver)\\n\\n # Increment iteration count.\\n self.t_add_op.eval(session=self.sess)\",\n \"def stop_updating():\\n data.stop_updating.set()\",\n \"def check(self, starttime, timebudget):\\n if not sys.version_info[0] == 3:\\n return\\n updated_blocks = []\\n\\n if bpy.context.mode == 'EDIT_MESH' or bpy.context.mode == 'SCULPT':\\n if bpy.context.scene.objects.active:\\n if bpy.context.scene.objects.active.name == 'terrain':\\n self.terrain.set_dirty()\\n elif self.terrain.is_dirty():\\n while self.terrain.is_dirty() and time.time() - starttime < timebudget:\\n updated_blocks.extend(self.terrain.check())\\n\\n if updated_blocks:\\n self.sendTerrainBlocks(updated_blocks)\\n\\n if self.terrain.is_dirty() or updated_blocks:\\n self._parent.queueRedraw()\",\n \"def stopped(self):\\n return self.state == 'stop'\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.625781","0.60271853","0.59617275","0.5868128","0.5811896","0.57584614","0.57368046","0.57330966","0.56894845","0.5651865","0.56268835","0.56053036","0.5596309","0.55944943","0.5593896","0.55907565","0.5581187","0.55652255","0.5562906","0.55497634","0.55401444","0.5538539","0.5532937","0.5474251","0.5472937","0.54634076","0.5453654","0.5445207","0.5434159","0.5425699","0.54216963","0.5406955","0.5397884","0.53935415","0.53914845","0.5383328","0.53829616","0.53802395","0.53770095","0.5373258","0.5358738","0.5353194","0.53463644","0.53376806","0.53277457","0.5325879","0.5317651","0.52925473","0.52840596","0.528308","0.5256137","0.52557296","0.52407223","0.52380043","0.5235812","0.52248675","0.52081704","0.5206372","0.5201425","0.5200741","0.51995385","0.51948935","0.51840556","0.5179754","0.51791114","0.51786435","0.5178196","0.51772344","0.5173426","0.517256","0.51718116","0.51637405","0.51519686","0.5150117","0.5149883","0.5145662","0.514094","0.5140189","0.5136901","0.5136443","0.5128365","0.51242244","0.5122922","0.51181626","0.51149786","0.5110294","0.5108733","0.5105722","0.5104413","0.51024956","0.5099433","0.50960594","0.50909203","0.508259","0.5082392","0.5082312","0.50780326","0.50769836","0.5075062","0.5073877","0.50721484"],"string":"[\n \"0.625781\",\n \"0.60271853\",\n \"0.59617275\",\n \"0.5868128\",\n \"0.5811896\",\n \"0.57584614\",\n \"0.57368046\",\n \"0.57330966\",\n \"0.56894845\",\n \"0.5651865\",\n \"0.56268835\",\n \"0.56053036\",\n \"0.5596309\",\n \"0.55944943\",\n \"0.5593896\",\n \"0.55907565\",\n \"0.5581187\",\n \"0.55652255\",\n \"0.5562906\",\n \"0.55497634\",\n \"0.55401444\",\n \"0.5538539\",\n \"0.5532937\",\n \"0.5474251\",\n \"0.5472937\",\n \"0.54634076\",\n \"0.5453654\",\n \"0.5445207\",\n \"0.5434159\",\n \"0.5425699\",\n \"0.54216963\",\n \"0.5406955\",\n \"0.5397884\",\n \"0.53935415\",\n \"0.53914845\",\n \"0.5383328\",\n \"0.53829616\",\n \"0.53802395\",\n \"0.53770095\",\n \"0.5373258\",\n \"0.5358738\",\n \"0.5353194\",\n \"0.53463644\",\n \"0.53376806\",\n \"0.53277457\",\n \"0.5325879\",\n \"0.5317651\",\n \"0.52925473\",\n \"0.52840596\",\n \"0.528308\",\n \"0.5256137\",\n \"0.52557296\",\n \"0.52407223\",\n \"0.52380043\",\n \"0.5235812\",\n \"0.52248675\",\n \"0.52081704\",\n \"0.5206372\",\n \"0.5201425\",\n \"0.5200741\",\n \"0.51995385\",\n \"0.51948935\",\n \"0.51840556\",\n \"0.5179754\",\n \"0.51791114\",\n \"0.51786435\",\n \"0.5178196\",\n \"0.51772344\",\n \"0.5173426\",\n \"0.517256\",\n \"0.51718116\",\n \"0.51637405\",\n \"0.51519686\",\n \"0.5150117\",\n \"0.5149883\",\n \"0.5145662\",\n \"0.514094\",\n \"0.5140189\",\n \"0.5136901\",\n \"0.5136443\",\n \"0.5128365\",\n \"0.51242244\",\n \"0.5122922\",\n \"0.51181626\",\n \"0.51149786\",\n \"0.5110294\",\n \"0.5108733\",\n \"0.5105722\",\n \"0.5104413\",\n \"0.51024956\",\n \"0.5099433\",\n \"0.50960594\",\n \"0.50909203\",\n \"0.508259\",\n \"0.5082392\",\n \"0.5082312\",\n \"0.50780326\",\n \"0.50769836\",\n \"0.5075062\",\n \"0.5073877\",\n \"0.50721484\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80892,"cells":{"query":{"kind":"string","value":"generate a batch for the Bayesian Optimization"},"document":{"kind":"string","value":"def generate_batch(\n state,\n model,\n X, \n Y,\n batch_size,\n n_candidates=None,\n num_restarts=10,\n raw_samples=512,\n acqf=\"ts\", # \"ei\" or \"ts\",\n dtype = torch.float32,\n device = None\n):\n assert acqf in (\"ts\", \"ei\")\n assert X.min() >= 0.0 and X.max() <= 1.0 and torch.all(torch.isfinite(Y))\n if n_candidates is None:\n n_candidates = min(5000, max(2000, 200 * X.shape[-1]))\n\n # Scale the TR to be proportional to the lengthscales\n x_center = X[Y.argmax(), :].clone()\n weights = model.covar_module.base_kernel.lengthscale.squeeze().detach()\n weights = weights / weights.mean()\n weights = weights / torch.prod(weights.pow(1.0 / len(weights)))\n tr_lb = clamp(x_center - weights * state.length / 2.0, 0.0, 1.0)\n tr_ub = clamp(x_center + weights * state.length / 2.0, 0.0, 1.0)\n\n if acqf == \"ts\":\n dim = X.shape[-1]\n sobol = SobolEngine(dim, scramble=True)\n pert = sobol.draw(n_candidates, dtype=dtype).to(dtype=dtype, device=device)\n pert = tr_lb + (tr_ub - tr_lb) * pert\n\n # Create a perturbation mask\n prob_perturb = min(20.0 / dim, 1.0)\n mask = (\n rand(n_candidates, dim, dtype=dtype, device=device)\n <= prob_perturb\n )\n ind = torch.where(mask.sum(dim=1) == 0)[0]\n mask[ind, randint(0, dim - 1, size=(len(ind),), device=device)] = 1\n\n # Create candidate points from the perturbations and the mask \n X_cand = x_center.expand(n_candidates, dim).clone()\n X_cand[mask] = pert[mask]\n\n # Sample on the candidate points\n thompson_sampling = MaxPosteriorSampling(model=model, replacement=False)\n X_next = thompson_sampling(X_cand, num_samples=batch_size)\n\n elif acqf == \"ei\":\n ei = qExpectedImprovement(model, train_Y.max(), maximize=True)\n X_next, acq_value = optimize_acqf(\n ei,\n bounds=stack([tr_lb, tr_ub]),\n q=batch_size,\n num_restarts=num_restarts,\n raw_samples=raw_samples,\n )\n\n return X_next"},"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 generate_batch():\n\n # Initialize variables\n example = np.zeros(self.batch_size)\n labels = np.zeros((self.batch_size, 1))\n alphas = np.zeros(self.batch_size)\n n_items = 0\n index = 0\n\n while index < len(data):\n reduced_window = random.randint(0, self.window_size)\n if data[index] is not None:\n\n left = max(0, index - self.window_size + reduced_window)\n right = min((index + self.window_size + 1 -\n reduced_window), len(data) - 1)\n for pos2 in range(left, right, 1):\n\n if n_items == self.batch_size:\n queue.put((example, labels, index))\n example = np.zeros(self.batch_size)\n labels = np.zeros((self.batch_size, 1))\n n_items = 0\n\n if pos2 != index and data[pos2] is not None:\n example[n_items] = data[pos2]\n labels[n_items] = data[index]\n alpha = self.learning_rate - \\\n (self.learning_rate - 0.001) * (index / self.n_words)\n alphas[n_items] = max(0.001, alpha)\n n_items += 1\n index += 1\n\n # Poison pills\n for _ in range(n_workers):\n queue.put(None)","def run_batch(bag):\n\n states = []\n\n for i in bag:\n a1 = i[0]\n a2 = i[1]\n a3 = i[2]\n a4 = i[3]\n a5 = i[4]\n prob = i[5]\n sheets = (a1 + a2 + a3 + a4 + a5)\n if sheets > 0:\n a1_prob = (float(a1) / sheets)\n a2_prob = (float(a2) / sheets)\n a3_prob = (float(a3) / sheets)\n a4_prob = (float(a4) / sheets)\n a5_prob = (float(a5) / sheets)\n if a1 > 0:\n out = a1_func(i)\n out[5] = (out[5] * a1_prob)\n states.append(out)\n if a2 > 0:\n out = a2_func(i)\n out[5] = (out[5] * a2_prob)\n states.append(out)\n if a3 > 0:\n out = a3_func(i)\n out[5] = (out[5] * a3_prob)\n states.append(out)\n if a4 > 0:\n out = a4_func(i)\n out[5] = (out[5] * a4_prob)\n states.append(out)\n if a5 > 0:\n out = a5_func(i)\n out[5] = (out[5] * a5_prob)\n states.append(out)\n if sheets == 1:\n global zero_probs\n zero_probs.append(prob)\n if sheets == 0:\n states.append([0, 1, 1, 1, 1, prob])\n return states","def _generate_batch(self, tasks: List):\n x_batch = np.stack([np.random.uniform(low=self.domain_bounds[0], high=self.domain_bounds[1], size=(self.inner_update_k, 1)) for _ in range(len(tasks))])\n y_batch = np.stack([[tasks[t](x) for x in x_batch[t]] for t in range(len(tasks))])\n\n return x_batch, y_batch","def generate(bat_size, s=\"train\"):\n while True:\n pairs, targets = get_batch(bat_size, s)\n yield (pairs, targets)","def get_batch_gen(self, config):\n\n ################\n # Def generators\n ################\n\n def random_balanced_gen():\n print('trying to generate batch series with ', self.num_train, 'shapes')\n\n # Initiate concatenation lists\n tp_list = [] # points\n tev_list = [] # eigen vectors\n tevt_list = [] # transposed eigen vectors\n tv_list = [] # eigen values\n tevf_list = [] # full eigen vectors for ground truth maps\n ti_list = [] # cloud indices\n\n batch_n = 0\n i_batch = 0\n\n gen_indices = np.random.permutation(int(self.num_train)) # initiate indices for the generator\n # if we had to test on this dataset we would need to introduce a test/val case with non-shuffled indices\n # print(gen_indices.shape, config.batch_num)\n # if config.split == 'test':\n # print('test setting here not fully supported')\n # n_shapes = self.num_test # has to be defined\n # gen_indices = []\n # for i in range(n_shapes - 1):\n # for j in range(i + 1, n_shapes):\n # gen_indices += [i, j] # put all the pairs in order\n # gen_indices = np.array(gen_indices)\n\n\n # Generator loop\n for p_i in gen_indices:\n\n # Get points and other input data\n new_points = self.input_points[p_i]\n new_evecs = self.input_evecs[p_i][:, :self.neig]\n new_evecs_trans = self.input_evecs_trans[p_i][:self.neig, :]\n new_evals = self.input_evals[p_i][:self.neig]\n\n new_evecs_full = self.input_evecs_full[p_i][:, :self.neig]\n\n n = new_points.shape[0]\n\n if i_batch == config.batch_num:\n\n yield (np.concatenate(tp_list, axis=0),\n np.concatenate(tev_list, axis=0),\n np.concatenate(tevt_list, axis=1),\n np.concatenate(tv_list, axis=1),\n np.concatenate(tevf_list, axis=0),\n np.array(ti_list, dtype=np.int32),\n np.array([tp.shape[0] for tp in tp_list]))\n\n tp_list = []\n tev_list = []\n tevt_list = []\n tv_list = []\n tevf_list = []\n ti_list = []\n\n batch_n = 0\n i_batch = 0\n\n # Add data to current batch\n tp_list += [new_points]\n tev_list += [new_evecs]\n tevt_list += [new_evecs_trans]\n tv_list += [new_evals]\n tevf_list += [new_evecs_full]\n ti_list += [p_i]\n\n # Update batch size\n batch_n += n\n i_batch += 1\n\n # yield the rest if necessary (it will not be a full batch and could lead to mistakes because of\n # shape matching needing pairs !!!!)\n yield (np.concatenate(tp_list, axis=0),\n np.concatenate(tev_list, axis=0),\n np.concatenate(tevt_list, axis=1),\n np.concatenate(tv_list, axis=1),\n np.concatenate(tevf_list, axis=0),\n np.array(ti_list, dtype=np.int32),\n np.array([tp.shape[0] for tp in tp_list]))\n\n ##################\n # Return generator\n ##################\n\n # Generator types and shapes\n gen_types = (tf.float32, tf.float32, tf.float32, tf.float32, tf.float32, tf.int32, tf.int32)\n gen_shapes = ([None, 3], [None, self.neig],\n [self.neig, None], [self.neig, None], [None, self.neig], [None], [None])\n\n return random_balanced_gen, gen_types, gen_shapes","def batch_generate(self, inputs, labels, batch_size=64):\n inputs_image, inputs, labels = check_inputs_labels(inputs, labels)\n arr_x = inputs\n arr_y = labels\n len_x = inputs_image.shape[0]\n batch_size = check_int_positive('batch_size', batch_size)\n batches = int(len_x / batch_size)\n rest = len_x - batches*batch_size\n res = []\n for i in range(batches):\n if isinstance(arr_x, tuple):\n x_batch = tuple([sub_items[i*batch_size: (i + 1)*batch_size] for sub_items in arr_x])\n else:\n x_batch = arr_x[i*batch_size: (i + 1)*batch_size]\n if isinstance(arr_y, tuple):\n y_batch = tuple([sub_labels[i*batch_size: (i + 1)*batch_size] for sub_labels in arr_y])\n else:\n y_batch = arr_y[i*batch_size: (i + 1)*batch_size]\n adv_x = self.generate(x_batch, y_batch)\n # Black-attack methods will return 3 values, just get the second.\n res.append(adv_x[1] if isinstance(adv_x, tuple) else adv_x)\n\n if rest != 0:\n if isinstance(arr_x, tuple):\n x_batch = tuple([sub_items[batches*batch_size:] for sub_items in arr_x])\n else:\n x_batch = arr_x[batches*batch_size:]\n if isinstance(arr_y, tuple):\n y_batch = tuple([sub_labels[batches*batch_size:] for sub_labels in arr_y])\n else:\n y_batch = arr_y[batches*batch_size:]\n adv_x = self.generate(x_batch, y_batch)\n # Black-attack methods will return 3 values, just get the second.\n res.append(adv_x[1] if isinstance(adv_x, tuple) else adv_x)\n\n adv_x = np.concatenate(res, axis=0)\n return adv_x","def generate_batch(self):\n\n # sbatch = list()\n # tbatch = list()\n # for i in range(self.dict_paras['batch_size']):\n # sbatch.append(self.lst_triplet_train_map[self.data_index])\n # self.data_index = (self.data_index + 1) % self.triplet_train_size\n\n sbatch = random.sample(self.lst_triplet_train_map, self.dict_paras['batch_size'])\n tbatch = list()\n\n for ele in sbatch:\n corrupted1, corrupted2 = self.get_corrupted_triplet(ele)\n tbatch.append((ele, corrupted1))\n tbatch.append((ele, corrupted2))\n return tbatch","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n mean = 0\n std_dev = 0.0001\n #print(in_features)\n #print(out_features)\n # create weight matrices\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\n #print(weight.shape)\n grad_weight = np.zeros((in_features, out_features))\n\n # create biases (in batches)\n bias = np.zeros(out_features)\n grad_bias = np.zeros(out_features)\n\n self.params = {'weight': weight, 'bias': bias}\n self.grads = {'weight': bias, 'bias': grad_bias}\n\n ########################\n # END OF YOUR CODE #\n #######################","def process_batch(self, batch):\n # extend with current batch\n self._extend(batch)\n\n # unpack and compute bounds\n length = len(self.obs)\n c = self.c\n\n # normally we cannot compute samples for the last c elements, but\n # in the terminal case, we halluciante values where necessary\n end = length if batch.terminal else length - c\n\n # collect samples to return in a FeudalBatch\n feudal_batch = FeudalBatch()\n for t in range(c, end):\n\n # state difference\n s_diff = self.s[t + c] - self.s[t]\n\n # intrinsic reward\n ri = 0\n # note that this for loop considers s and g values\n # 1 timestep to c timesteps (inclusively) ago\n for i in range(1, c + 1):\n ri_s_diff = self.s[t] - self.s[t - i]\n if np.linalg.norm(ri_s_diff) != 0:\n ri += cosine_similarity(ri_s_diff, self.g[t - i])\n ri /= c\n\n # sum of g values used to derive w, input to the linear transform\n gsum = np.zeros_like(self.g[t - c])\n for i in range(t - c, t + 1):\n gsum += self.g[i]\n\n # add to the batch\n feudal_batch.add(self.obs[t], self.a[t], self.returns[t], s_diff,\n ri, gsum, self.features[t])\n\n # in the terminal case, set reset flag\n if batch.terminal:\n self.last_terminal = True\n # in the general case, forget all but the last 2 * c elements\n # reason being that the first c of those we have already computed\n # a batch for, and the second c need those first c\n else:\n twoc = 2 * self.c\n self.obs = self.obs[-twoc:]\n self.a = self.a[-twoc:]\n self.returns = self.returns[-twoc:]\n self.s = self.s[-twoc:]\n self.g = self.g[-twoc:]\n self.features = self.features[-twoc:]\n\n return feudal_batch.get_batch()","def run_batch(self):\n\n print(\"Running experiment with batch_size {}...\".format(self.batch_size))\n\n errors = self.W.new_tensor([])\n energies = self.W.new_tensor([])\n\n x = (2 * self.W.new(self.N, self.batch_size).random_(2) - 1).float() # Initialize the x vector\n rands = self.W.new(self.t_max, self.batch_size).uniform_() # The random values which will be compared to the acceptance probabilities\n idxs = self.W.new(self.t_max, self.batch_size).random_(self.N).long() # The indices which will be flipped in x at each iteration\n\n energy, wx = utils.compute_energy_batch(x, self.W, self.Y) # Compute the initial value of the energy\n\n for iteration in range(self.t_max):\n self.beta_scheduler.step(energies) # Update the value of beta according to the cooling strategy\n\n x, energy, wx = self.chain.step_batch(x, self.W, self.Y, self.beta_scheduler.beta, energy, wx, idxs[iteration], rands[iteration])\n energies = torch.cat((energies, energy.unsqueeze(0)))\n\n e = utils.compute_reconstruction_error_batch(x, self.X) # Compute the current reconstruction error\n errors = torch.cat((errors, e.unsqueeze(0)))\n\n return errors, energies, x","def __call__(self):\n if self.numbatches is None:\n pool = self.pooler()\n if self.batchsize is None:\n self.batchsize = self.pooler.nInPool()\n self.numbatches = self.pooler.nInPool()//self.batchsize\n for i in xrange(self.numbatches):\n pool = self.pooler()\n self._reset_batch()\n if self.samplemethod == 'balance' and len(self.keysamplers)>0:\n batchinds,keyids = self._samplebalanced(pool)\n elif self.samplemethod == 'uniform':\n batchinds,keyids = self._sampleuniform(pool)\n else:\n batchinds,keyids = self._samplesequential(i)\n batch = self._extractInds(pool,batchinds,keyids)\n for k in batch:\n batch[k][np.isnan(batch[k])] = self.nanreplacement\n yield batch","def produce_query_batches(self):\n pass","def perform_bayesian_optimization(self):\n bounds = {'hunits': (self.hunits_lower, self.hunits_upper),\n 'embedding_dim': (self.embedding_dim_lower, self.embedding_dim_upper)}\n optimizer = BayesianOptimization(f=self.lstm_score, pbounds=bounds, random_state=1)\n optimizer.maximize(init_points=2, n_iter=self.iterations)\n print(optimizer.max)\n print(optimizer.res)","def step_batch(self, x_batch, W, Y, beta, energy_batch, wx, idx_batch, rand_batch):\n raise NotImplementedError()","def _generate_batch(self, tasks: List, plot=False): # Change batch generation to be done in pure PyTorch\n raise NotImplementedError","def batcher(params, batch):\n bpe_batch_indices = []\n for sentence in batch:\n sentence = ' '.join(sentence)\n if bert:\n indices = format_sentence_with_bert(sentence, params['wordpiece'], max_len)\n else:\n indices = format_sentence(sentence, params['bpe'], max_len)\n bpe_batch_indices.append(torch.LongTensor(indices))\n\n bpe_batch_indices = torch.stack(bpe_batch_indices, 0)\n\n # send to gpu\n bpe_batch_indices = bpe_batch_indices.to(params['device'])\n # if bert_max:\n # # we use max over BERT embeddings as sentence representation\n # with torch.no_grad():\n # all_embs, _ = params['bert'](bpe_batch_indices)[-2:]\n # all_embs, _ = torch.max(all_embs, 1) # get maximum value along the time dimension 1\n # all_embs = all_embs.cpu().detach().numpy()\n # elif bert_mean:\n # # we use mean over BERT embeddings as sentence representation\n # with torch.no_grad():\n # all_embs, _ = params['bert'](bpe_batch_indices)[-2:]\n # all_embs = torch.mean(all_embs, 1) # get maximum value along the time dimension 1\n # all_embs = all_embs.cpu().detach().numpy()\n # else:\n\n # we use model to calculate embeddings\n all_embs = calculate_model_outputs(params['model'], bpe_batch_indices)\n all_embs = all_embs.cpu().detach().numpy()\n\n return all_embs","def train_dynamic(batch_size=10):\n \n return","def SGD(epochs, eta):\n # print([[[k] for k in i] for i in self.x])\n # print([[j] for j in self.y])\n # print([i] for)\n\n # if test_data: n_test = len(test_data)\n for j in xrange(epochs):\n # mini_batches = [training_data[k:k + mini_batch_size] for k in xrange(0, n, mini_batch_size)]\n # for mini_batch in mini_batches:\n # update_mini_batch(mini_batch, eta)\n nabla_b = [np.zeros(b.shape) for b in self.biases]\n nabla_w = [np.zeros(w.shape) for w in self.weights]\n for x, y in training_data:\n delta_nabla_b, delta_nabla_w = backprop(x, y)\n nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n # for x, y in training_data:\n # delta_nabla_b, delta_nabla_w = backprop(x, y)\n # nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\n # nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\n self.weights = [w - (eta ) * nw\n for w, nw in zip(self.weights, nabla_w)]\n self.biases = [b - (eta ) * nb\n for b, nb in zip(self.biases, nabla_b)]\n\n # print 'Epoch {0}'.format(j)\n # print self.weights\n # print self.biases\n\n # if test_data:\n # print \"Epoch {0}: {1} / {2}\".format(\n # j, evaluate(test_data), n_test)\n # else:\n # print \"Epoch {0} complete\".format(j)","def generate_new_batches(Gs, features, y, idx, graph_window, shift, batch_size, device, test_sample):\n\n # print(\"...create batches...\")\n N = len(idx)\n n_nodes = Gs[0].number_of_nodes()\n n_state = 50 \n \n adj_lst = list()\n features_lst = list()\n y_lst = list()\n node_lst = list()\n\n batch_data = []\n for i in range(0, N, batch_size):\n if i+batch_size >= N:\n batch_data += [[idx[x] for x in range(i, N)]]\n else:\n batch_data += [[idx[x] for x in range(i, i+batch_size)]]\n\n for batch in batch_data:\n adj_tmp = list()\n features_tmp = list()\n y_tmp = list()\n num_tmp = list()\n line_idx = 0\n for val in batch:\n for k in range(val-graph_window+1,val+1):\n adj_tmp.append(nx.adjacency_matrix(Gs[k-1]).toarray()) \n for feat in features[k]:\n features_tmp.append(feat)\n num_tmp += list(range(line_idx, line_idx+50))\n line_idx += len(features[k])\n y_tmp.append(y[val+shift])\n\n adj_tmp = sparse_mx_to_torch_sparse_tensor(sp.block_diag(adj_tmp))\n adj_lst.append(adj_tmp.to(device))\n features_tmp = torch.FloatTensor(features_tmp)\n features_lst.append(features_tmp.to(device))\n y_tmp = torch.FloatTensor(y_tmp).reshape(-1)\n y_lst.append(y_tmp.to(device))\n node_lst.append(num_tmp)\n\n\n return adj_lst, features_lst, y_lst, node_lst","def train(self, num_batches: int):","def batches(set_name):\n global num_batches, args, ds_sizes \n # num_batches = how many batches in each dataset(train, valid, test)\n # ds_sizes = dataset_sizes \n for b in range(num_batches[set_name]):\n bi = b * args.batch_size # one batch mul batch_size \n bj = (b + 1) * args.batch_size \n if b == num_batches[set_name] - 1:\n bj = ds_sizes[set_name] # maybe only remainer set\n yield bi, bj","def _get_batch(self):\n # index = self._index[self._current]\n # im_path = self._imdb.image_path_from_index(0)\n # im_path = 'data/demo/dog.jpg'\n # with open(im_path, 'rb') as fp:\n # img_content = fp.read()\n\n batch_data = mx.nd.zeros((self.batch_size, 3, self._data_shape[0], self._data_shape[1]))\n batch_label = [] \n global imgi\n # img = mx.nd.array(imgi)\n # imgr = mx.img.imdecode(img_content)\n data = self._data_augmentation(imgi)\n batch_data[0] = data\n \n self._data = {'data': batch_data}\n self._label = {'label': None}","def postprocessing(batch, vocab):\n\n return batch","def batch_gen():\n i = 0\n while len(all_sentences) - i >= batch_size:\n # TODO this is a mess...\n yield np.stack([\n np.pad(\n np.stack(\n [embeddings[id]\n for id in sentence[:max_sentence_length]]), [[\n 0, max_sentence_length -\n min(len(sentence), max_sentence_length)\n ], [0, 0]],\n 'constant',\n constant_values=0)\n for sentence in all_sentences[i:i + batch_size]\n ])\n\n i += batch_size","def next(self):\n #print('next')\n batch_size = self.batch_size\n batch_data = nd.empty((batch_size,)+self.data_shape)\n batch_label = nd.empty((batch_size,)+self.label_shape)\n i = 0\n #self.cutoff = random.randint(800,1280)\n try:\n while i < batch_size:\n #print('N', i)\n data, label, annot = self.next_sample()\n R = self.get_data(data, label, annot)\n if R is None:\n continue\n data_out, label_out, flip_data_out, flip_label_out = R\n if not self.use_coherent:\n data = nd.array(data_out)\n data = nd.transpose(data, axes=(2, 0, 1))\n label = nd.array(label_out)\n #print(data.shape, label.shape)\n batch_data[i][:] = data\n batch_label[i][:] = label\n i += 1\n else:\n data = nd.array(data_out)\n data = nd.transpose(data, axes=(2, 0, 1))\n label = nd.array(label_out)\n data2 = nd.array(flip_data_out)\n data2 = nd.transpose(data2, axes=(2, 0, 1))\n label2 = nd.array(flip_label_out)\n #M = nd.array(M)\n #print(data.shape, label.shape)\n batch_data[i][:] = data\n batch_label[i][:] = label\n #i+=1\n j = i+self.per_batch_size//2\n batch_data[j][:] = data2\n batch_label[j][:] = label2\n i += 1\n if j%self.per_batch_size==self.per_batch_size-1:\n i = j+1\n except StopIteration:\n if i<batch_size:\n raise StopIteration\n\n #return {self.data_name : batch_data,\n # self.label_name : batch_label}\n #print(batch_data.shape, batch_label.shape)\n return mx.io.DataBatch([batch_data], [batch_label], batch_size - i)","def generate_batch(batch_ims):\n batch_X = np.zeros((len(batch_ims), 3, 224, 224))\n batch_y = np.zeros((len(batch_ims), 1))\n for i, im_file in enumerate(batch_ims):\n img = imread(im_file).astype(\"float32\")\n img[:, :, 0] -= 103.939\n img[:, :, 1] -= 116.779\n img[:, :, 2] -= 123.68\n img = img.transpose((2, 0, 1))\n batch_X[i, :, :, :] = img\n\n file_id = im_file.split(\"/\")[-1].split(\"_\")[0]\n score = labels_map[file_id][PERS_FIELD_NAME]\n if score >= 5.5:\n batch_y[i] = 1\n return (batch_X, batch_y)","def init_batch(self):\n pass","def produce_query_batches(self):\n self.__generate_queries()\n return self.__bobs","def compute_batch(self, duplicate_manager=None,context_manager=None):\n from ...acquisitions import AcquisitionTS\n assert isinstance(self.acquisition, AcquisitionTS)\n \n X_batch,_ = self.acquisition.optimize()\n k=1\n \n # --- GET the remaining elements\n while k<self.batch_size:\n new_sample,_ = self.acquisition.optimize()\n X_batch = np.vstack((X_batch,new_sample))\n k +=1\n \n return X_batch","def test_minibatches(self):\n batch_size = self.params['batch_size']\n start_index = 0\n while start_index + batch_size < 500:\n end_index = start_index + batch_size\n yield self.input[start_index:end_index], self.y[start_index:end_index]\n start_index = end_index","def Collecting_experiences(self)-> None:\n for epoch_no in range(self.epochs):\n print(\"EPOCH %d\", epoch_no + 1)\n \n #beam_dqn = self.beam_min + int(self.beam_max * epoch_no/self.epochs)\n #egreed = self.egreed_max*(1 - epoch_no/(1.1*self.epochs))\n #self.gamma = self.gamma_max*(1 - epoch_no/(2*self.epochs))\n\n beam_dqn = 1\n egreed = 0.5\n #self.gamma = self.gamma_max\n self.gamma = 0.6\n\n self.tb_writer.add_scalar(\"parameters/beam_dqn\",\n beam_dqn, epoch_no)\n self.tb_writer.add_scalar(\"parameters/egreed\",\n egreed, epoch_no)\n self.tb_writer.add_scalar(\"parameters/gamma\",\n self.gamma, epoch_no)\n if beam_dqn > self.actions_size:\n print(\"The beam_dqn cannot exceed the action size!\")\n print(\"then the beam_dqn = action size\")\n beam_dqn = self.actions_size\n\n print(' beam_dqn, egreed, gamma: ', beam_dqn, egreed, self.gamma)\n for _, data_set in self.data_to_train_dqn.items():\n \n valid_iter = make_data_iter(\n dataset=data_set, batch_size=1, batch_type=self.batch_type,\n shuffle=False, train=False)\n #valid_sources_raw = data_set.src\n # disable dropout\n #self.model.eval()\n\n i_sample = 0\n for valid_batch in iter(valid_iter):\n freeze_model(self.model)\n batch = Batch(valid_batch\n , self.pad_index, use_cuda=self.use_cuda)\n \n encoder_output, encoder_hidden = self.model.encode(\n batch.src, batch.src_lengths,\n batch.src_mask)\n # if maximum output length is not globally specified, adapt to src len\n \n if self.max_output_length is None:\n self.max_output_length = int(max(batch.src_lengths.cpu().numpy()) * 1.5)\n \n batch_size = batch.src_mask.size(0)\n prev_y = batch.src_mask.new_full(size=[batch_size, 1], fill_value=self.bos_index,\n dtype=torch.long)\n output = []\n hidden = self.model.decoder._init_hidden(encoder_hidden)\n prev_att_vector = None\n finished = batch.src_mask.new_zeros((batch_size, 1)).byte()\n\n # print(\"Source_raw: \", batch.src)\n # print(\"Target_raw: \", batch.trg_input)\n # print(\"y0: \", prev_y)\n \n \n \n exp_list = []\n # pylint: disable=unused-variable\n for t in range(self.max_output_length):\n if t != 0:\n if self.state_type == 'hidden':\n state = torch.cat(hidden, dim=2).squeeze(1).detach().cpu().numpy()[0]\n else:\n if t == 0:\n state = hidden[0].squeeze(1).detach().cpu().numpy()[0]\n else:\n state = prev_att_vector.squeeze(1).detach().cpu().numpy()[0]\n \n \n # decode one single step\n logits, hidden, att_probs, prev_att_vector = self.model.decoder(\n encoder_output=encoder_output,\n encoder_hidden=encoder_hidden,\n src_mask=batch.src_mask,\n trg_embed=self.model.trg_embed(prev_y),\n hidden=hidden,\n prev_att_vector=prev_att_vector,\n unroll_steps=1)\n # logits: batch x time=1 x vocab (logits)\n if t != 0:\n if self.state_type == 'hidden':\n state_ = torch.cat(hidden, dim=2).squeeze(1).detach().cpu().numpy()[0]\n else:\n state_ = prev_att_vector.squeeze(1).detach().cpu().numpy()[0]\n \n # if t == 0:\n # print('states0: ', state, state_)\n\n # greedy decoding: choose arg max over vocabulary in each step with egreedy porbability\n \n if random.uniform(0, 1) < egreed:\n i_ran = random.randint(0,beam_dqn-1)\n next_word = torch.argsort(logits, descending=True)[:, :, i_ran]\n else:\n next_word = torch.argmax(logits, dim=-1) # batch x time=1\n # if t != 0:\n a = prev_y.squeeze(1).detach().cpu().numpy()[0]\n #a = next_word.squeeze(1).detach().cpu().numpy()[0]\n \n # print(\"state \",t,\" : \", state )\n # print(\"state_ \",t,\" : \", state_ )\n # print(\"action \",t,\" : \", a )\n # print(\"__________________________________________\")\n\n output.append(next_word.squeeze(1).detach().cpu().numpy())\n\n #tup = (self.memory_counter, state, a, state_)\n \n \n prev_y = next_word\n # check if previous symbol was <eos>\n is_eos = torch.eq(next_word, self.eos_index)\n finished += is_eos\n if t != 0:\n self.memory_counter += 1\n tup = (self.memory_counter, state, a, state_, 1)\n exp_list.append(tup)\n \n #print(t)\n # stop predicting if <eos> reached for all elements in batch\n if (finished >= 1).sum() == batch_size:\n a = next_word.squeeze(1).detach().cpu().numpy()[0]\n self.memory_counter += 1\n #tup = (self.memory_counter, state_, a, np.zeros([self.state_size]) , is_eos[0,0])\n tup = (self.memory_counter, state_, a, np.zeros([self.state_size]), 0)\n exp_list.append(tup)\n #print('break')\n break\n if t == self.max_output_length-1:\n #print(\"reach the max output\")\n a = 0\n self.memory_counter += 1\n #tup = (self.memory_counter, state_, a, np.zeros([self.state_size]) , is_eos[0,0])\n tup = (self.memory_counter, state_, a, -1*np.ones([self.state_size]), 1)\n exp_list.append(tup)\n \n \n \n \n #Collecting rewards\n hyp = np.stack(output, axis=1) # batch, time\n\n if epoch_no == 0:\n if i_sample == 0 or i_sample == 3 or i_sample == 6:\n #print(i_sample)\n r = self.Reward(batch.trg, hyp, show=True) # 1 , time-1 \n else:\n r = self.Reward(batch.trg, hyp, show=False) # 1 , time -1 \n else:\n #print(\"aaaa - \",i_sample)\n r = self.Reward(batch.trg, hyp, show=False) # 1 , time -1 \n \n # if i_sample == 0 or i_sample == 3 or i_sample == 6:\n # print(\"\\n Sample Collected: \", i_sample, \"-------------Target vs Eval_net prediction:--Raw---and---Decoded-----\")\n # print(\"Target: \", batch.trg, decoded_valid_out_trg)\n # print(\"Eval : \", stacked_output, decoded_valid_out)\n # print(\"Reward: \", r, \"\\n\")\n \n i_sample += 1\n self.store_transition(exp_list, r)\n \n #Learning.....\n if self.memory_counter > self.mem_cap - self.max_output_length:\n self.learn()\n \n self.tb_writer.close()","def train(self, batch):\n pass","def get_batch(batch_data, config):\n N = len(batch_data['obs_traj_rel'])\n P = config.P\n OF = config.flow_size\n T_in = config.obs_len\n T_pred = config.pred_len\n\n returned_inputs = []\n traj_obs_gt = np.zeros([N, T_in, P], dtype='float32')\n traj_pred_gt = np.zeros([N, T_pred, P], dtype='float32')\n # --- xy input\n for i, (obs_data, pred_data) in enumerate(zip(batch_data['obs_traj_rel'],\n batch_data['pred_traj_rel'])):\n for j, xy in enumerate(obs_data):\n traj_obs_gt[i, j, :] = xy\n for j, xy in enumerate(pred_data):\n traj_pred_gt[i, j, :] = xy\n returned_inputs.append(traj_obs_gt)\n # ------------------------------------------------------\n # Social component (through optical flow)\n if config.add_social:\n obs_flow = np.zeros((N, T_in, OF),dtype ='float32')\n # each batch\n for i, flow_seq in enumerate(batch_data['obs_optical_flow']):\n for j , flow_step in enumerate(flow_seq):\n obs_flow[i,j,:] = flow_step\n returned_inputs.append(obs_flow)\n # -----------------------------------------------------------\n # Person pose input\n if config.add_kp:\n obs_kp = np.zeros((N, T_in, KP, 2), dtype='float32')\n # each bacth\n for i, obs_kp_rel in enumerate(batch_data['obs_kp_rel']):\n for j, obs_kp_step in enumerate(obs_kp_rel):\n obs_kp[i, j, :, :] = obs_kp_step\n return returned_inputs,traj_pred_gt","def data_gen(voc_size, batch, nbatches, seq_len = 15):\r\n for i in range(nbatches):\r\n # (batch_size, seq_len)\r\n data = torch.from_numpy(\r\n np.random.randint(1, voc_size, size=(batch, seq_len)))\r\n data[:, 0] = 1 # add start token\r\n src = Variable(data, requires_grad=False)\r\n tgt = Variable(data, requires_grad=False)\r\n yield Batch(src, tgt, 0) # Accessed by next function one by one\r","def prepare_batches(self, pairs, batch_size):\n\t\treturn MATHBatch.create_from_items(pairs, batch_size)","def batch_generator(batch_size):\n\n # Infinite loop.\n while True:\n # Get a list of random indices for images in the training-set.\n idx = np.random.randint(100,size=batch_size)\n \n # Get the pre-computed transfer-values for those images.\n # These are the outputs of the pre-trained image-model.\n transf_values = np.array([transfer_values[_] for _ in idx])\n\n # For each of the randomly chosen images there are\n # at least 5 captions describing the contents of the image.\n # Select one of those captions at random and get the\n # associated sequence of integer-tokens.\n tokens = [caps_markedwords[_] for _ in idx]\n\n # Count the number of tokens in all these token-sequences.\n num_tokens = [len(t) for t in tokens]\n \n # Max number of tokens.\n max_tokens = np.max(num_tokens)\n # Pad all the other token-sequences with zeros\n # so they all have the same length and can be\n # input to the neural network as a numpy array.\n tokens_padded = pad_sequences(tokens,\n maxlen=max_tokens,\n padding='post',\n truncating='post')\n \n # Further prepare the token-sequences.\n # The decoder-part of the neural network\n # will try to map the token-sequences to\n # themselves shifted one time-step.\n decoder_input_data = tokens_padded[:, 0:-1]\n decoder_output_data = tokens_padded[:, 1:]\n\n # Dict for the input-data. Because we have\n # several inputs, we use a named dict to\n # ensure that the data is assigned correctly.\n x_data = \\\n {\n 'decoder_input': decoder_input_data,\n 'transfer_values_input': transf_values\n }\n\n\n # Dict for the output-data.\n y_data = \\\n {\n 'decoder_output': decoder_output_data\n }\n \n yield (x_data, y_data)","def update_mini_batch2_4(self, mini_batch, eta):\r\n nabla_b = [np.zeros(b.shape) for b in self.biases]\r\n nabla_w = [np.zeros(w.shape) for w in self.weights]\r\n #backup_b = [np.zeros(b.shape) for b in self.biases]\r\n backup_w = [np.zeros(w.shape) for w in self.weights]\r\n rand = [list(set([np.random.randint(0,y) for i in range(int(y/2))])) for y in self.sizes]\r\n \r\n\r\n for i in range(len(self.biases)):\r\n bi=self.biases[i]\r\n we = self.weights[i]\r\n ra = rand[i]\r\n ra2 = rand[i+1]\r\n #bab = backup_b[i]\r\n baw = backup_w[i]\r\n for j in range(len(ra)):\r\n for a in range(len(we)):\r\n baw[a][ra[j]]=we[a][ra[j]]\r\n we[a][ra[j]]=np.zeros(baw[a][ra[j]].shape)\r\n #for j in range(len(ra2)):\r\n #bab[ra2[j]]=bi[ra2[j]]\r\n #bi[ra2[j]]=np.zeros(bab[ra2[j]].shape)\r\n\r\n \r\n for x, y in mini_batch:\r\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\r\n #print('w')\r\n #print(delta_nabla_w)\r\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\r\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\r\n\r\n self.weights = [w-(eta/len(mini_batch))*nw\r\n for w, nw in zip(self.weights, nabla_w)]\r\n self.biases = [b-(eta/len(mini_batch))*nb\r\n for b, nb in zip(self.biases, nabla_b)]\r\n\r\n for i in range(len(self.biases)):\r\n bi=self.biases[i]\r\n we = self.weights[i]\r\n ra = rand[i]\r\n ra2 = rand[i+1]\r\n #bab = backup_b[i]\r\n baw = backup_w[i]\r\n\r\n for j in range(len(ra)):\r\n for a in range(len(we)):\r\n we[a][ra[j]]=baw[a][ra[j]]\r\n \r\n #for j in range(len(ra2)):\r\n #bi[ra2[j]]=bab[ra2[j]]\r","def batchGD(self, x, y, epochs):\n print(\"Training using batch gradient descent\")\n epoch = 0\n #output training progress ten times in run\n outputChunk = int ( epochs / 10 )\n\n while epoch <= epochs:\n\n #output progress? \n if epoch % outputChunk is 0:\n J = self.costFunction(x,y)\n print(\"Epoch=\", epoch, \"J=\", J)\n\n #get analytic gradients \n partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o = \\\n self.deriv_costFunction( x, y )\n #take a GD step\n #To-do - implement variable learning rate\n self.w_ih -= partial_J_w_ih\n self.w_ho -= partial_J_w_ho\n self.b_h -= partial_J_b_h\n self.b_o -= partial_J_b_o\n \n epoch += 1","def next_batch(memory_dim, batch_length, task):\n batch_inputs = []\n batch_targets = []\n difficulty = 0.0\n for _ in xrange(batch_length):\n # Values as integers\n random_input = task.generate_random_input(difficulty, memory_dim)\n target_output = task.run(random_input)\n\n # Values as MxM memories\n batch_inputs.append(values_to_distribution_memory(random_input))\n batch_targets.append(values_to_distribution_memory(target_output))\n\n return batch_inputs, batch_targets","def instantiate_batch(self, inputs):\n return inputs","def batchlearn(self, final_state=False):\n # what to do anyway with finals states in batch learning ???\n\n TDe = self.estimate_TDioa() \n self.actQoa += self.alpha * TDe\n self.X = self.policy_func(self.actQoa)\n \n \n print(\"\\r>> batchlearn at {}\".format(self.total_step), \n end='', flush=True) if self.verbose else None\n print() if self.verbose else None\n print('actQ:\\n', self.actQoa) if self.verbose else None\n print('TDe:\\n', TDe) if self.verbose else None\n print() if self.verbose else None\n\n\n #re-init\n self.count_oa.fill(0)\n self.count_oao.fill(0)\n self.reward_oa.fill(0)\n # self.valQoa = self.actQoa.copy() # may not be needed\n self.batch_step = 0","def new_generate_batch(batch_size, context_window):\r\n global positive_index\r\n global negative_index\r\n\r\n global positive_word_index\r\n global negative_word_index\r\n\r\n global positive_sentence\r\n global negative_sentence\r\n\r\n pos_loops, neg_loops = 0, 0\r\n context_size = 2 * context_window\r\n batch = np.ndarray(shape=(batch_size, context_size), dtype=np.int32)\r\n labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)\r\n sentiment_labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)\r\n\r\n batch_index = 0\r\n while batch_index < batch_size:\r\n # do positive index stuff\r\n if positive_word_index == len(positive_sentence):\r\n positive_index = (positive_index + 1) % len(positive_data)\r\n if (positive_index == 0):\r\n pos_loops += 1\r\n positive_word_index = 0\r\n positive_sentence = positive_data[positive_index]\r\n # do work\r\n labels[batch_index, 0] = positive_sentence[positive_word_index]\r\n\r\n batch_input = num_sen_to_input(positive_sentence, positive_word_index, context_window)\r\n for i2 in range(len(batch_input)):\r\n batch[batch_index, i2] = batch_input[i2]\r\n sentiment_labels[batch_index] = [1]\r\n\r\n positive_word_index += 1\r\n batch_index += 1\r\n\r\n if (batch_index) == batch_size // 2:\r\n break\r\n\r\n # TIME TO DO NEGATIVE\r\n while batch_index < batch_size:\r\n # do negative stuff\r\n if negative_word_index == len(negative_sentence):\r\n negative_index = (negative_index + 1) % len(negative_data)\r\n if (negative_index == 0):\r\n neg_loops += 1\r\n negative_word_index = 0\r\n negative_sentence = negative_data[negative_index]\r\n\r\n # do work\r\n labels[batch_index, 0] = negative_sentence[negative_word_index]\r\n\r\n batch_input = num_sen_to_input(negative_sentence, negative_word_index, context_window)\r\n for i2 in range(len(batch_input)):\r\n batch[batch_index, i2] = batch_input[i2]\r\n\r\n sentiment_labels[batch_index] = [0]\r\n\r\n negative_word_index += 1\r\n batch_index += 1\r\n if batch_index == batch_size:\r\n break\r\n\r\n zipped = zip(batch, labels, sentiment_labels)\r\n shuffled = []\r\n batch_, labels_, sl_ = [], [], []\r\n for i in zipped:\r\n shuffled.append(i)\r\n\r\n np.random.shuffle(shuffled)\r\n\r\n for j in shuffled:\r\n batch_.append(j[0])\r\n labels_.append(j[1])\r\n sl_.append(j[2])\r\n\r\n batch_ = np.array(batch_)\r\n labels_ = np.array(labels_)\r\n sl_ = np.array(sl_)\r\n\r\n return batch_, labels_, sl_, pos_loops, neg_loops","def optimize(self, session, batch):\n X_batch, y_batch = zip(*batch) # Unzip batch, each returned element is a tuple of lists\n\n if(self.FLAGS.augment):\n X_batch = augment_batch(X_batch, self.FLAGS.img_H, self.FLAGS.img_W)\n\n input_feed = {}\n\n input_feed[self.X] = X_batch\n input_feed[self.y] = y_batch\n input_feed[self.is_training] = True\n input_feed[self.learning_rate] = self.current_lr\n\n output_feed = []\n\n output_feed.append(self.train_op)\n output_feed.append(self.loss)\n output_feed.append(self.global_norm)\n output_feed.append(self.global_step)\n\n\n if self.FLAGS.tb is True:\n output_feed.append(self.train_loss_tb)\n output_feed.append(self.global_norm_tb)\n output_feed.append(self.learning_rate_tb)\n output_feed.append(self.y_out_stddev_tb)\n output_feed.append(self.y_out_max_tb)\n tr, loss, norm, step, train_tb, norm_tb, lr_tb, y_out_stddev_tb, y_out_max_tb = session.run(output_feed, input_feed)\n self.tensorboard_writer.add_summary(train_tb, step)\n self.tensorboard_writer.add_summary(norm_tb, step)\n self.tensorboard_writer.add_summary(lr_tb, step)\n self.tensorboard_writer.add_summary(y_out_stddev_tb, step)\n self.tensorboard_writer.add_summary(y_out_max_tb, step)\n else:\n tr, loss, norm, step = session.run(output_feed, input_feed)\n\n return loss, norm, step","def one_step_gd(self, batch):\n\n # get target values yj\n targets = self.get_target(batch)\n phi_input = np.vstack(batch[0])\n masks = self.get_masks(batch[1])\n dummy_targets = targets.max(axis=1)\n\n X = [phi_input, targets, masks]\n Y = [dummy_targets, targets]\n\n # update main network with one step of gradient descent\n # self.Qmodel.fit(X, Y, batch_size=len(X))\n # pdb.set_trace()\n metrics = self.train_model.train_on_batch(X, Y)\n\n # every fixed number of steps, update target network\n self.c_count += 1\n # print(self.c_count, self.c)\n\n if self.c_count == self.c:\n # if self.verbose:\n # print('* Target network updated')\n\n # update target network to be equal the main network\n self.update_target_network()\n\n # reset counter\n self.c_count = 0\n\n return metrics[0]","def create_batch(batch, source, params, dv,\n t_end=1.3e5, exclude=None, basename='xrb', walltime=96,\n auto_t_end=True, notes='No notes given', nbursts=20, kgrid=None,\n nuc_heat=True, setup_test=False,\n auto_qnuc=False, grid_version=None, qnuc_source='heat',\n substrate='fe54', substrate_off=True, adapnet_filename=None,\n bdat_filename=None, params_full=None,\n numerical_params=None, scratch_file_sys=False):\n # TODO:\n # - WRITE ALL PARAM DESCRIPTIONS\n # - Overhaul/tidy up\n # - use pd table instead of dicts of arrays\n\n print_batch(batch=batch)\n source = grid_strings.source_shorthand(source=source)\n mass_ref = 1.4 # reference NS mass (Msun)\n radius_ref = 10 # default NS radius (km)\n\n specified = {'params': params,\n 'dv': dv,\n 'numerical_params': numerical_params}\n\n if specified['numerical_params'] is None:\n specified['numerical_params'] = {}\n\n config = grid_tools.setup_config(specified=specified, source=source)\n # TODO: print numerical_params being used\n\n if params_full is None:\n params_expanded, var = expand_params(params=config['params'], dv=config['dv'])\n params_full = exclude_params(params_expanded=params_expanded, exclude=exclude)\n\n n_models = len(params_full['x'])\n\n if kgrid is None:\n print('No kgrid provided. Loading default:')\n kgrid = grid_analyser.Kgrid(load_lc=False, linregress_burst_rate=True,\n source=source)\n\n params_full['y'] = 1 - params_full['x'] - params_full['z'] # helium-4 values\n params_full['geemult'] = params_full['mass'] / mass_ref # Gravity multiplier\n\n gravities = gravity.get_acceleration_newtonian(r=radius_ref,\n m=params_full['mass']).value\n params_full['radius'] = np.full(n_models, radius_ref)\n params_full['gravity'] = gravities\n\n if auto_qnuc:\n predict_qnuc(params_full=params_full, qnuc_source=qnuc_source,\n grid_version=grid_version)\n\n # ===== Create top grid folder =====\n batch_model_path = grid_strings.get_batch_models_path(batch, source)\n grid_tools.try_mkdir(batch_model_path)\n\n # Directory to keep MonARCH logs and sbatch files\n logpath = grid_strings.get_source_subdir(batch_model_path, 'logs')\n grid_tools.try_mkdir(logpath)\n\n # ===== Write parameter table MODELS.txt and NOTES.txt=====\n write_model_table(n=n_models, params=params_full, path=batch_model_path)\n filepath = os.path.join(batch_model_path, 'NOTES.txt')\n with open(filepath, 'w') as f:\n f.write(notes)\n\n # ===== Write jobscripts for submission on clusters =====\n print_dashes()\n kepler_jobs.write_both_jobscripts(run0=1, run1=n_models, batch=batch,\n source=source, basename=basename,\n path=logpath, walltime=walltime,\n adapnet_filename=adapnet_filename,\n bdat_filename=bdat_filename,\n scratch_file_sys=scratch_file_sys)\n\n # ===== Directories and templates for each model =====\n for i in range(n_models):\n # ==== Create directory tree ====\n print_dashes()\n model = i + 1\n run_path = grid_strings.get_model_path(model, batch, source, basename=basename)\n\n # ==== Create task directory ====\n grid_tools.try_mkdir(run_path)\n\n # ==== Write burn file, set initial composition ====\n x0 = params_full['x'][i]\n z0 = params_full['z'][i]\n kepler_files.write_rpabg(x0, z0, run_path, substrate=substrate)\n\n # ==== Create model generator file ====\n if auto_t_end:\n mdot = params_full['accrate'][i] * params_full['acc_mult'][i]\n rate_params = {}\n for param in ('x', 'z', 'qb', 'mass'):\n rate_params[param] = params_full[param][i]\n fudge = 0.5 # extra time to ensure complete final burst\n tdel = kgrid.predict_recurrence(accrate=mdot, params=rate_params)\n t_end = (nbursts + fudge) * tdel\n print(f'Using predicted dt={tdel/3600:.1f} hr')\n if t_end < 0:\n print('WARN! negative dt predicted. Defaulting n * 1.5hr')\n t_end = nbursts * 1.5 * 3600\n\n run = i + 1\n print(f'Writing genfile for xrb{run}')\n header = f'This generator belongs to model: {source}_{batch}/{basename}{run}'\n\n accdepth = params_full['accdepth'][i]\n if (params_full['x'][i] > 0.0) and (accdepth > 1e20):\n print(f\"!!!WARNING!!!: accdepth of {accdepth:.0e} may be too deep for\" +\n \" models accreting hydrogen\")\n print(f'Using accdepth = {accdepth:.1e}')\n\n kepler_files.write_genfile(h1=params_full['x'][i], he4=params_full['y'][i],\n n14=params_full['z'][i], qb=params_full['qb'][i],\n acc_mult=params_full['acc_mult'][i],\n qnuc=params_full['qnuc'][i],\n geemult=params_full['geemult'][i],\n accrate0=params_full['accrate'][i],\n accmass=params_full['accmass'][i],\n accdepth=params_full['accdepth'][i],\n path=run_path, t_end=t_end, header=header,\n nuc_heat=nuc_heat, setup_test=setup_test,\n substrate_off=substrate_off,\n numerical_params=config['numerical_params'])","def batch_generator(batch_size, file, dataset, indices, labels=\"labels\"):\n sample_size = len(indices)\n n_batches = int(sample_size/batch_size)\n h5f = h5py.File(file,'r')\n instarget = Target('AAAAAA')\n aa_to_int = instarget.predefining_dict()\n while True: \n for i in range(n_batches):\n if i == n_batches:\n batch_samples = h5f[dataset][i*batch_size:sample_size]\n seqs_onehot = instarget.int_to_onehot(list(batch_samples), len(aa_to_int))\n batch_y = h5f[labels][i*batch_size:sample_size]\n else:\n batch_samples = h5f[dataset][i*batch_size:i*batch_size+batch_size]\n seqs_onehot = instarget.int_to_onehot(list(batch_samples), len(aa_to_int))\n batch_y = h5f[labels][i*batch_size:i*batch_size+batch_size]\n yield (seqs_onehot, batch_y)","def forward(self, batch):\n self.output = np.dot(np.array(batch), self.weights) + self.biases","def _make_batches(self, n_batches: int) -> Iterable[Dict[Any, Any]]:\n batch_iters = []\n for problem in self.problems:\n service = problem.problem_service\n it = service.batch_iter(self.batch_size_per_problem, n_batches)\n batch_iters.append(it)\n combined = zip(*batch_iters)\n # yield a complete feed dict\n for combined_batch in combined:\n assert len(combined_batch) == len(self.problems)\n yield_val = {}\n for problem, batch in zip(self.problems, combined_batch):\n ph_obs_var, ph_q_values = self.obs_qv_inputs[problem.name]\n obs_tensor, qv_tensor = to_local(batch)\n yield_val[ph_obs_var] = obs_tensor\n yield_val[ph_q_values] = qv_tensor\n yield yield_val","def gen_batch(self):\n batch_size = self.batch_size\n shuffle = self.shuffle\n data = np.array(self.sentences)\n\n data_size = len(data)\n num_batches_per_epoch = int((len(data) - 1) / batch_size) + 1\n while True:\n # shuffle the data at starting of each epoch\n shuffled_data = data\n if shuffle:\n shuffle_indices = np.random.permutation(np.arange(data_size))\n shuffled_data = data[shuffle_indices]\n \n for batch_num in range(num_batches_per_epoch):\n start_index = batch_num * batch_size\n end_index = min((batch_num + 1) * batch_size, data_size)\n yield self._format_samples(shuffled_data[start_index:end_index], self.max_length)\n\n if self.mode in ['train', \"pred\"]:\n break","def bayes_model(feature_train, help_rank_train, model_name):\n model = MultinomialNB()\n model.fit(feature_train, help_rank_train)\n modelpkl = open(model_name,'wb')\n dump(model, modelpkl, -1)\n return","def batch_creator(batch_size, dataset_length, dataset_name):\n # batch_size = 128\n # dataset_length = 6000\n batch_mask = rng.choice(dataset_length, batch_size)\n\n batch_x = eval('x_' + dataset_name)[[batch_mask]].reshape(-1, input_num_units)\n batch_x = preproc(batch_x)\n\n if dataset_name == 'train':\n batch_y = eval('y_' + dataset_name)[[batch_mask]]\n batch_y = dense_to_one_hot(batch_y)\n\n return batch_x, batch_y","def get_evaluate_batches(data_dir='/home/yunhan/batchified'):\n # train 3 valid 1\n # Use batch 1 - 53 as train (60%), 54 - 71 as validation (20%), 72 - 89 as test (20%)\n n = 18\n idx = np.random.permutation(n)\n idx = idx + 54\n for i in range(n):\n X = np.load(\"%s/X%d.npy\" % (data_dir, idx[i]))/255.\n Y = np.load(\"%s/y%d.npy\" % (data_dir, idx[i])).reshape(-1)\n yield X, Y","def get_batch(self) -> CBInput:\n sample_batch_idx, batch_arms = self.gen_arms_per_batch()\n context_arm_features = self.gen_features_batch(batch_idx=sample_batch_idx)\n assert context_arm_features.ndim == 3\n rewards_all_arms = self.features_to_rewards(\n inp_feature=context_arm_features, sample_batch_idx=sample_batch_idx\n )\n batch = CBInput(\n context_arm_features=context_arm_features,\n arms=batch_arms, # ads of batch_size campaigns\n rewards_all_arms=rewards_all_arms,\n )\n return batch","def generate_samples(self, Nt, model=None, exe=0, ret_base ='binary'):\n if Nt == 0:\n print('Error: Nt must be greater than 0')\n return\n Nt = int(Nt)\n\n # establish an annealing factors array which contains all annealing related information to be sent to cpsl/ppsl\n annealing_factors = np.asarray([self.beta, self.start_beta, self.end_beta, self.growth_factor])\n\n # jit requires specific input types\n jit_beta = float64(self.beta)\n jit_m = float64(self.m)\n jit_J = np.ndarray.flatten(np.ndarray.astype(self.J, \"float64\"))\n jit_h = np.ndarray.flatten(np.ndarray.astype(self.h, \"float64\"))\n jit_Nm = np.int64(self.Nm)\n jit_rand = np.random.uniform(-1, 1, Nt * self.Nm)\n\n\n if model is None:\n model = self.model\n if model == \"cpsl\":\n if exe == 0:\n m_all = _cpsl(self.m, self.Nm, self.J, self.h, Nt, self.anneal, annealing_factors)\n m_all = np.reshape(m_all, (Nt, self.Nm))\n self.m = m_all[Nt - 1, :]\n elif exe == 1:\n m_all = _cpsl_fast(jit_m, jit_Nm, jit_J, jit_h, Nt, jit_rand, self.beta)\n m_all = np.reshape(m_all, (Nt, self.Nm))\n self.m = m_all[Nt - 1, :]\n else:\n # gpu requires sending variables\n NmNtbeta = np.array([self.Nm, Nt, self.beta], dtype=np.int)\n cpu_samples = np.zeros((Nt, self.Nm))\n rand_vals = jit_rand\n\n gpu_NmNtbeta = cp.asarray(NmNtbeta)\n gpu_samples = cp.asarray(cpu_samples)\n gpu_J = cp.asarray(self.J)\n gpu_h = cp.asarray(self.h)\n gpu_m = cp.asarray(self.m)\n gpu_rand_vals = cp.asarray(rand_vals)\n\n _cpsl_core_gpu(cpu_samples, gpu_samples, gpu_m, gpu_NmNtbeta, gpu_J, gpu_h, gpu_rand_vals)\n m_all = cpu_samples\n self.m = m_all[Nt - 1, :]\n elif model == \"ppsl\":\n if exe == 1 or exe == 0:\n m_all = _ppsl_fast(jit_m, jit_Nm, jit_J, jit_h, jit_beta, Nt, self.dt, jit_rand)\n m_all = np.reshape(m_all, (Nt, self.Nm))\n self.m = m_all[Nt - 1, :]\n else:\n # gpu requires sending variables\n\n NmNtbeta = np.array([self.Nm, Nt, self.beta], dtype=np.int)\n samples = np.zeros((Nt, self.Nm))\n rand_vals = jit_rand\n\n gpu_NmNtbeta = cp.asarray(NmNtbeta)\n gpu_samples = cp.asarray(samples)\n gpu_J = cp.asarray(self.J)\n gpu_h = cp.asarray(self.h)\n gpu_m = cp.asarray(self.m)\n gpu_rand_vals = cp.asarray(rand_vals)\n _ppsl_core_gpu(samples, gpu_samples, gpu_m, gpu_NmNtbeta, gpu_J, gpu_h, gpu_rand_vals)\n m_all = samples\n self.m = m_all[Nt - 1, :]\n else:\n print(\"Error: unknown model\")\n\n if ret_base == 'samples' or ret_base == 'sample' or ret_base == 'b' or ret_base == 'binary' or ret_base == 2:\n return m_all\n elif ret_base == 'decimal' or ret_base == 'd' or ret_base == 'deci' or ret_base == 'decimals' or ret_base == 10:\n return bi_arr2de(m_all)","def _prepare_batch(self, batch):\n try:\n from torch_geometric.data import Batch\n except:\n raise ValueError(\"This class requires PyTorch Geometric to be installed.\")\n\n inputs, labels, weights = batch\n pyg_graphs = [graph.to_pyg_graph() for graph in inputs[0]]\n inputs = Batch.from_data_list(pyg_graphs)\n _, labels, weights = super(GATModel, self)._prepare_batch(([], labels,\n weights))\n return inputs, labels, weights","def generate(self, batch_size, s=\"train\"):\n\t\twhile True:\n\t\t\tpairs = self.getBatch(batch_size)\n\t\t\tfeaturesX = self.getFeatures(pairs)\n\t\t\twordEmb = self.getWordEmbeddings(pairs)\n\t\t\tposEmb = self.getPosEmbeddings(pairs)\n\t\t\t#target = to_categorical(pairs['target'].values, num_classes=2)\n\t\t\tyield ([wordEmb, posEmb, featuresX])","def generator(features, labels, batch_size):\n \n # Create empty arrays to contain batch of features and labels#\n batch_features = np.zeros((batch_size, 160, 320, 3))\n batch_labels = np.zeros((batch_size, 1))\n while True:\n for i in range(batch_size):\n # choose random index in features\n index = random.choice(range(len(features)))\n batch_features[i] = features[index]\n batch_labels[i] = labels[index]\n yield batch_features, batch_labels","def append(self, batch: Batch):","def batch_generator(labels_df, set_kind):\n # Generate training batches\n if set_kind == \"train\" and (labels_df.shape[0] == 32384 or labels_df.shape[0] == 3120 or labels_df.shape[0] == 64):\n while 1:\n\n for i in range(labels_df.shape[0]//8):\n x_train = np.load('data/train-npy/npdatasetX{}.npy'.format(i))\n y_train = np.load('data/train-npy/npdatasetY{}.npy'.format(i))\n\n for j in range(1):\n x_trainj = x_train[j*8:j*8-1,:]\n y_trainj = y_train[j*8:j*8-1,:]\n\n yield (x_trainj, y_trainj)\n\n\n # Generate validation batches\n if set_kind == \"valid\" and (labels_df.shape[0] == 8080 or labels_df.shape[0] == 1920 or labels_df.shape[0] == 8):\n while 1:\n\n for i in range(labels_df.shape[0]//4): \n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\n y_valid = np.load('data/valid-npy/npdatasetY{}.npy'.format(i))\n\n for j in range(1): \n x_validj = x_valid[j*4:j*4-1,:]\n y_validj = y_valid[j*4:j*4-1,:]\n\n yield (x_validj, y_validj)\n\n\n # Generate test batches\n if set_kind == \"test\" and labels_df.shape[0] == 40669:\n while 1:\n\n for i in range(labels_df.shape[0]//4): #REPLACE 1 by 3\n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\n\n for j in range(1): #REPLACE 2 by 2816\n x_validj = x_valid[j*4:j*4-1,:]\n \n yield (x_validj, y_validj)\n\n if set_kind == \"test\" and (labels_df.shape[0] == 8080 or labels_df.shape[0] == 8):\n while 1:\n\n for i in range(labels_df.shape[0]//8): #REPLACE 1 by 3\n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\n\n for j in range(2): #REPLACE 2 by 2816\n x_validj = x_valid[j*4:j*4-1,:]\n\n yield x_validj","def train_batch(self, bs):\n # image IDs\n idx = torch.LongTensor(bs).random_(len(self.images))\n\n # select images / attributes\n batch_x = normalize_images(self.images.index_select(0, idx).cuda())\n batch_y = self.attributes.index_select(0, idx).cuda()\n\n # data augmentation\n if self.v_flip and np.random.rand() <= 0.5:\n batch_x = batch_x.index_select(2,\n torch.arange(batch_x.size(2) - 1, -1, -1).long().cuda())\n if self.h_flip and np.random.rand() <= 0.5:\n batch_x = batch_x.index_select(3,\n torch.arange(batch_x.size(3) - 1, -1, -1).long().cuda())\n\n return cuda_variable(batch_x), cuda_variable(batch_y)","def train_batches(feature_matrix,y):\r\n X_org,y_org = shuffle(feature_matrix, y, random_state=13)\r\n \r\n # Splitting 20% of dataset to be test later\r\n X_train_org, X_test_org, y_train_org, y_test_org = train_test_split(X_org, y_org,test_size=0.20)\r\n X = X_train_org\r\n y = y_train_org\r\n \r\n \r\n for name, clf in classifiers:\r\n inc = Incremental(clf, scoring='accuracy')\r\n batch_size=5000\r\n counter=0\r\n train_acc = [] \r\n test_acc = []\r\n \r\n # Initializing Standard Scaler and IPCA for each classifier\r\n \r\n SS = StandardScaler()\r\n # IPCA = IncrementalPCA(n_components = 500)\r\n n=1\r\n print(\"Training \", name,\".......\\n\")\r\n for j in range(80):\r\n if counter >= len(X):\r\n break\r\n \r\n # Splitting each batch into training and validation datset\r\n X_train, X_test, y_train, y_test = train_test_split(X[counter:counter+batch_size], y[counter:counter+batch_size],test_size=0.25)\r\n print(\"Iteration:\",n)\r\n \r\n classes = da.unique(y_train).compute()\r\n \r\n # Feature Scaling\r\n SS.partial_fit(np.asarray(X_train))\r\n SS.transform(np.asarray(X_test))\r\n \r\n # Feature Decomposition\r\n # IPCA.partial_fit(X_train)\r\n # IPCA.transform(X_test)\r\n \r\n # Partial fitting - Stochastic Gradient Descent\r\n inc.partial_fit(X_train, y_train, classes=classes)\r\n print('Training Score:', inc.score(X_train, y_train))\r\n print('Validation Score:', inc.score(X_test, y_test))\r\n print(\"\\n\")\r\n \r\n # Concatenating batch scores\r\n train_acc.append(inc.score(X_train, y_train)) \r\n test_acc.append(inc.score(X_test, y_test)) \r\n \r\n if(len(X)-counter < batch_size):\r\n batch_size = len(X)-counter\r\n counter += batch_size\r\n n += 1\r\n \r\n \r\n # Savings the model\r\n filename = r'C:\\PythonCodes\\MM803\\code\\Outputs\\New\\f_canny_'+name+'.sav'\r\n pickle.dump(inc, open(filename, 'wb'))\r\n \r\n # Printing Model Accuracy\r\n print(name,\" MODEL ACCURACY\")\r\n print(\"_______________________\")\r\n print(\"Avg Training Accuracy of \", name,\":\", statistics.mean(train_acc)) \r\n print(\"Avg Test Accuracy \", name,\":\",statistics.mean(test_acc))\r\n \r\n \r\n # Testing on Unseen Data\r\n SS.transform(np.asarray(X_test_org[:5000]))\r\n # IPCA.transform(X_test_org[:5000])\r\n print('\\nFinal Testing Score on Unseen data 1 by ', name,':', inc.score(X_test_org[:10], y_test_org[:10]))\r\n print('Final Testing Score on Unseen data 2 by ', name,':', inc.score(X_test_org[10:100], y_test_org[10:100]))\r\n print('Final Testing Score on Unseen data 3 by ', name,':', inc.score(X_test_org[500:1000], y_test_org[500:1000]))\r\n \r\n print('\\n\\nClassification Report of', name)\r\n print('------------------------------------')\r\n print(classification_report(y_test_org[:5000],inc.predict(X_test_org[:5000]), digits = 4))\r\n print('====================================')\r\n print('\\n')\r\n \r\n # Saving the trained StandardScaler to be used for testing\r\n filename_ss = r'C:\\PythonCodes\\MM803\\code\\Outputs\\New\\f_canny_SS.sav'\r\n pickle.dump(SS, open(filename_ss, 'wb'))\r\n \r\n # Saving the trained Incremental PCA to be used for testing\r\n #filename_ipca = r'C:\\PythonCodes\\MM803\\code\\Outputs\\New\\f_hed_IPCA.sav'\r\n #pickle.dump(IPCA, open(filename_ipca, 'wb')) \r","def _fillBatches(self):\n\n batchRE = r\"\"\"\n B\n (?P<observebatch>\\d+?)\n (?P<startend>[SE])\n (?P<sequence>\\d+?)\n _SR\n (?:_(?P<extraInjections>\\d+?|\\w+?))?\n $\n \"\"\"\n batchRE = re.compile(batchRE, re.VERBOSE)\n # We canot infer batches unless we have runorder\n if 'Run Order' in self.sampleMetadata.keys():\n currentBatch = 0\n # Loop over samples in run order\n for index, row in self.sampleMetadata.sort_values(by='Run Order').iterrows():\n nameComponents = batchRE.search(row['Sample File Name'])\n if nameComponents:\n # Batch start\n if nameComponents.group('startend') == 'S':\n # New batch - increment batch no\n if nameComponents.group('sequence') == '1':\n currentBatch = currentBatch + 1\n\n # Don't include the dilution series or blanks\n if not ((row['AssayRole'] == AssayRole.LinearityReference) or (row['SampleType'] == SampleType.ProceduralBlank)):\n self.sampleMetadata.loc[index, 'Batch'] = currentBatch\n self.sampleMetadata.loc[index, 'Correction Batch'] = currentBatch\n\n else:\n warnings.warn('Unable to infer batches without run order, skipping.')\n return","def bagxgb_train(X_train, y_train, size=10, write=False):\n list_models = []\n #d_train = lgb.Dataset(X_train, label=y_train)\n with tqdm(total=size) as pbar:\n for nb in range(size):\n model = xgb.XGBClassifier(max_depth=7, min_child_weight=1, learning_rate=0.01, n_estimators=5000, gamma=0.8, subsample=0.95, colsample_bytree=0.6, reg_alpha=0.0025, objective='binary:logistic', nthread=4, scale_pos_weight=1,\n seed=nb+1)\n model.fit(X_train, y_train)\n list_models.append(model)\n pbar.update()\n return list_models","def run_batch_filter(self):\n if self.speed_data is None and self.flow_data is None and self.traveltime_data is None:\n print(\n 'Warning: The measurement data must be set before running the batch filter: use function self.set_meas_data()')\n\n # =======================================================================\n # the initial ensembles, which should have been set externally\n X_init = np.matrix(np.zeros((self.dim_state, self.num_ensembles)))\n print(\n 'Setting initial ensembles: rho {0}; qin {1}; qout {2}'.format(self.init_rho, self.init_qin, self.init_qout))\n for ens in range(0, self.num_ensembles):\n X_init[self.x_index['density'][0]:\n self.x_index['density'][self.num_cells - 1], ens] = self.init_rho\n X_init[self.x_index['qin'], ens] = self.init_qin\n X_init[self.x_index['qout'], ens] = self.init_qout\n\n # print('setted qin {0}; qout {1}'.format(X_init[self.x_index['qin'], ens], X_init[self.x_index['qout'], ens] ))\n # add noise to each ensemble\n X_init[:, ens] += np.matrix(np.random.multivariate_normal(\n np.zeros(self.dim_state), self.Q)).reshape((self.dim_state, 1))\n\n self.set_initial_ensembles(X_init)\n\n # =======================================================================\n # DEBUG\n # save the qin and qout in the corresponding probe data\n # save the initial state\n if self.__debug:\n self.qin_f.append(np.squeeze(np.array(self.X_f[self.x_index['qin'], :])).tolist())\n self.qin_a.append(np.squeeze(np.array(self.X_a[self.x_index['qin'], :])).tolist())\n self.qin_obs.append(np.nan)\n\n self.qout_f.append(np.squeeze(np.array(self.X_f[self.x_index['qout'], :])).tolist())\n self.qout_a.append(np.squeeze(np.array(self.X_a[self.x_index['qout'], :])).tolist())\n self.qout_obs.append(np.nan)\n\n # The enKF runs at the finest time grid\n # for each step, update the system\n for step in range(0, self.num_steps):\n\n # update status\n sys.stdout.write('\\r')\n sys.stdout.write('Status: filtering step {0}/{1}'.format(step, self.num_steps))\n sys.stdout.flush()\n # print('Status: filtering step {0}'.format(step))\n\n cur_time = (step + 1) * self.dur_steps\n\n # get the effective measurement\n eff_flow, eff_speed, eff_traveltime = self.__get_eff_meas(cur_time)\n\n # build the observation index\n self.y_index, self.dim_obs, y_obs, cov_noise = self.__build_obs_index(eff_flow, eff_speed, eff_traveltime)\n\n # update the estimate for this step\n est_state = self.update_estimate(y_obs, cov_noise, cur_time)\n\n # =======================================================================\n # DEBUG\n # save the qin and qout in the corresponding probe data\n # save the updated state\n if self.__debug:\n self.qin_f.append(np.squeeze(np.array(self.X_f[self.x_index['qin'], :])).tolist())\n self.qin_a.append(np.squeeze(np.array(self.X_a[self.x_index['qin'], :])).tolist())\n if 'flow' in self.y_index.keys() and self.__debug_entrance_sensor in self.y_index['flow'].keys():\n self.qin_obs.append(y_obs[self.y_index['flow'][self.__debug_entrance_sensor]])\n # print('y_index[flow]:{0}'.format(self.y_index['flow'].keys()))\n # print('y_obs[ y_index[flow][entrance] ]:{0}'.format(\n # y_obs[ self.y_index['flow'][self.__debug_entrance_sensor]],\n # self.__debug_entrance_sensor))\n else:\n self.qin_obs.append(np.nan)\n\n self.qout_f.append(np.squeeze(np.array(self.X_f[self.x_index['qout'], :])).tolist())\n self.qout_a.append(np.squeeze(np.array(self.X_a[self.x_index['qout'], :])).tolist())\n if 'flow' in self.y_index.keys() and self.__debug_exit_sensor in self.y_index['flow'].keys():\n self.qout_obs.append(y_obs[self.y_index['flow'][self.__debug_exit_sensor]])\n else:\n self.qout_obs.append(np.nan)\n # =======================================================================\n # save the estimated state\n self.est_state_all[:, step] = est_state\n\n # decouple and save into self.est_density, self.est_speed, self.est_queue, self.est_traveltime\n self.est_density[:, step] = est_state[0:self.num_cells, 0]\n\n # the speed is computed using the fundamental diagram\n for cell_id in range(0, self.num_cells):\n # use the static FD at this step\n self.est_speed[cell_id, step] = self.__rho2v(self.vm_cells[cell_id, 0], self.beta_cells[cell_id, 0],\n self.rhoc_cells[cell_id, 0], self.wc_cells[cell_id, 0],\n self.est_density[cell_id, step])\n\n # REMARK: the queue and travel time a post-processed from the speed field.\n # They are computed in cross_evaluation class for all algorithms\n # the queue length starts from the first cell with speed below queue_threshold to the end of road\n # index = (self.est_speed[:, step] <= self.queue_threshold)\n #\n # # filter out the outliers\n # index_smoothed = deepcopy(index)\n # outlier_max = 3\n # counter = 0\n # for i in range(0, len(index)):\n #\n # if index[i] == True:\n # # trigger the coutner\n # counter += 1\n # elif index[i] == False and counter != 0:\n # if counter <= outlier_max:\n # # found outliers\n # index_smoothed[ i-counter : i ] = False\n # # reset counter\n # counter = 0\n #\n # # if i != 0 and i != len(index)-1:\n # # if sum( index[i-1:i+3] ) >=2:\n # # index_smoothed[i] = True\n # # else:\n # # index_smoothed[i] = False\n # # elif i == 0:\n # # if sum(index[0: 5] ) >= 3:\n # # index_smoothed[i] = True\n # # else:\n # # index_smoothed[i] = False\n # # elif i == len(index)-1:\n # # if sum(index[ i-4 :len(index)]) >= 3:\n # # index_smoothed[i] = True\n # # else:\n # # index_smoothed[i] = False\n #\n # if sum(index_smoothed) <= 3: # use 4 to suppress false alarms\n # # if less or equal then 2 cells are in congestion, it may be caused by noise.\n # self.est_queue[step] = 0\n # else:\n # # if step > 105 and step < 115:\n # # print(sum(index_smoothed))\n # # print(index_smoothed)\n # # print(index)\n #\n # self.est_queue[step] = \\\n # self.len_cells*( self.num_cells - np.argmax(index_smoothed) )\n # # try:\n # # first_cong_cell_id = [x[0] for x in enumerate( self.est_speed[:,step] ) if x[1] < self.queue_threshold][0]\n # # except IndexError:\n # # # no congested cell\n # # first_cong_cell_id = self.num_cells\n # # # the estimated queue length\n # # self.est_queue[step] = self.len_cells*( self.num_cells - first_cong_cell_id )\n #\n # # the travel time estimate is computed by summing up the travel time in each cell\n # self.est_traveltime[step] = np.sum(self.len_cells/self.est_speed[:,step])\n\n\n # =======================================================================\n # DEBUG\n # plot the update\n if self.__debug:\n plot_len = 19\n # qin\n if False:\n if not np.isnan(self.qin_obs[-1]):\n fig1 = plt.figure(figsize=(10, 5), dpi=100)\n ax1 = fig1.add_subplot(111)\n positions_f = np.arange(0, len(self.qin_f)) - 0.1\n positions_a = np.arange(0, len(self.qin_a)) + 0.1\n positions_obs = np.arange(0, len(self.qin_obs))\n # predicted as red\n bp = ax1.boxplot(self.qin_f[-plot_len:],\n positions=positions_f[-plot_len:], widths=0.15,\n patch_artist=False)\n for box in bp['boxes']:\n # change outline color\n box.set(color='#FF4633', linewidth=1)\n # change fill color\n # box.set( facecolor = '#FF4633' )\n # corrected as green\n bp = ax1.boxplot(self.qin_a[-plot_len:],\n positions=positions_a[-plot_len:], widths=0.15, patch_artist=False)\n for box in bp['boxes']:\n # change outline color\n box.set(color='#07891B', linewidth=1)\n # change fill color\n # box.set( facecolor = '#07891B' )\n # measurement as blue\n ax1.scatter(positions_obs[-plot_len:], self.qin_obs[-plot_len:], color='b', marker='o', s=40,\n label='Observation')\n ax1.set_title('qin')\n # x_ticks = np.arange(0, len(self.qin_f))\n # ax1.set_xticks(x_ticks[-plot_len:])\n plt.show()\n\n # qout\n if False:\n if not np.isnan(self.qout_obs[-1]):\n fig2 = plt.figure(figsize=(10, 5), dpi=100)\n ax2 = fig2.add_subplot(111)\n positions_f = np.arange(0, len(self.qout_f)) - 0.1\n positions_a = np.arange(0, len(self.qout_a)) + 0.1\n positions_obs = np.arange(0, len(self.qout_obs))\n # predicted as red\n bp = ax2.boxplot(self.qout_f[-plot_len:], positions=positions_f[-plot_len:], widths=0.18,\n patch_artist=True)\n for box in bp['boxes']:\n # change outline color\n box.set(color='#7570b3', linewidth=1)\n # change fill color\n box.set(facecolor='#FF4633')\n # corrected as green\n bp = ax2.boxplot(self.qout_a[-plot_len:], positions=positions_a[-plot_len:], widths=0.18,\n patch_artist=True)\n for box in bp['boxes']:\n # change outline color\n box.set(color='#7570b3', linewidth=1)\n # change fill color\n box.set(facecolor='#07891B')\n # measurement as blue\n ax2.scatter(positions_obs[-plot_len:], self.qout_obs[-plot_len:], color='b', marker='o', s=30,\n label='Observation')\n ax2.set_title('qout')\n # x_ticks = np.arange(0, len(self.qout_f))\n # ax2.set_xticks(x_ticks[-plot_len:])\n\n plt.show()\n\n # plot the estimated qin and qout\n if self.__debug:\n if True:\n qin = np.squeeze(np.array(self.est_state_all[self.x_index['qin'], :]))\n qin_meas = np.array(self.qin_obs)[1:]\n print(len(qin), len(qin_meas))\n fig1 = plt.figure(figsize=(10, 5), dpi=100)\n ax1 = fig1.add_subplot(111)\n t = np.arange(len(qin))\n ax1.plot(t, qin, 'r-', label='Estimated')\n not_nan = ~np.isnan(qin_meas)\n ax1.plot(t[not_nan], qin_meas[not_nan], 'b', label='Measured')\n ax1.legend()\n ax1.grid(True)\n ax1.set_title('qin')\n\n plt.draw()\n\n if True:\n qout = np.squeeze(np.array(self.est_state_all[self.x_index['qout'], :]))\n qout_meas = np.array(self.qout_obs)[1:]\n fig2 = plt.figure(figsize=(10, 5), dpi=100)\n ax2 = fig2.add_subplot(111)\n t = np.arange(len(qout))\n ax2.plot(t, qout, 'r-', label='Estimated')\n not_nan = ~np.isnan(qout_meas)\n ax2.plot(t[not_nan], qout_meas[not_nan], 'b', label='Measured')\n ax2.set_title('qout')\n ax2.legend()\n ax2.grid(True)\n plt.draw()","def batch_anneal(self, times=10):\n for i in range(1, times + 1):\n print(f\"Iteration {i}/{times} -------------------------------\")\n self.T = self.T_save\n self.iteration = 1\n self.cur_solution, self.cur_fitness = self.initial_solution()\n self.anneal()","def data_gen(\n v: int, batch: int, nbatches: int, device: torch.device = torch.device(\"cpu\")\n) -> Iterator[Batch]: # TODO bad name\n for i in range(nbatches):\n data = np.random.randint(1, v, size=(batch, 10))\n data[:, 0] = 1\n src: LongTensorType = torch.from_numpy(data)\n tgt: LongTensorType = torch.from_numpy(data)\n src, tgt = src.to(device), tgt.to(device)\n yield Batch(src, tgt, 0)","def generate_batch(self, cfactor, nsamples, terminals=True):\n weights = defaultdict(lambda: 1.0)\n return [self._generate(cfactor,'S',weights, terms=terminals) for _ in range(nsamples)]","def build_naive_bayes():\n nb_pipeline = None\n ##### Write code here\n nb_pipeline = Pipeline([\n ('vect', CountVectorizer()),\n ('clf', ComplementNB())\n ])\n\n ##### End of your work ######\n return nb_pipeline","def next_batch(self, batch_size):\n raise NotImplementedError","def batch_sample_beta(self):\n c_contexts = self.context[self.iter]\n\n old_beta = self.beta[self.iter]\n new_beta = -1\n proposal_sd = .1\n while new_beta <= 0:\n new_beta = random.gauss(mu = old_beta, sigma = proposal_sd)\n \n # set up to calculate the g densities for both the old and new beta values\n log_g_old = -1 * old_beta # which is np.log(np.exp(-1 * old_beta))\n log_g_new = -1 * new_beta # similar as above\n\n # derive contexts from breakpoints arrangement\n context_dict = self.make_context_dict(c_contexts)\n for context in context_dict.keys():\n log_g_old += math.lgamma(self.support_size * old_beta) \\\n - math.lgamma(self.support_size * old_beta + len(context_dict[context]))\n log_g_new += math.lgamma(self.support_size * new_beta) \\\n - math.lgamma(self.support_size * new_beta + len(context_dict[context]))\n \n for y in self.support:\n log_g_old += math.lgamma(context_dict[context].count(y) + old_beta) - math.lgamma(old_beta)\n log_g_new += math.lgamma(context_dict[context].count(y) + new_beta) - math.lgamma(new_beta)\n\n # compute candidate densities q for old and new beta\n # since the proposal distribution is normal this step is not needed\n log_q_old = 0#np.log(dnorm(old_beta, loc = new_beta, scale = proposal_sd))\n log_q_new = 0#np.log(dnorm(new_beta, loc = old_beta, scale = proposal_sd)) \n \n # compute the moving probability\n moving_prob = min(1, np.exp((log_g_new + log_q_old) - (log_g_old + log_q_new)))\n \n u = random.uniform(0,1)\n if u < moving_prob: self.beta[self.iter] = new_beta\n return self.beta[self.iter]","def add_batch(self, batch):\n x, e, f = batch\n\n if self.is_empty:\n self.x = x\n self.e = e\n self.f = f\n\n else:\n self.x = ch.cat([self.x, x], dim=0)\n self.e = ch.cat([self.e, e], dim=0)\n self.f = ch.cat([self.f, f], dim=0)","def run_batch(self, batch_x, batch_y):\n raise NotImplementedError()","def batch(self, coeff_count=13, db=False):\n mfccs, _ = self.mfcc(coeff_count)\n if db:\n mfccs = utils.dbspec(mfccs)\n delta1, delta2 = self.delta_coeffs(mfccs)\n self._annotate(mfccs)\n\n mfccs_len = mfccs.shape[1]\n batch_x = np.concatenate((mfccs, delta1, delta2), axis=0).transpose()\n batch_y = np.array(self.annotated_samples)\n print(\"AudioClip--Generated Batch\")\n return (batch_x, batch_y)","def extract_batch(self, T_idxs, B_idxs):\n s = self.samples\n target_T_idxs = (T_idxs + self.n_step_return) % self.T\n hyper_steps = np.random.randint(1, self.hyper_steps)\n hyper_idxs = (T_idxs + hyper_steps) % self.T\n batch = SamplesFromReplay(\n agent_inputs=AgentInputs(\n observation=self.extract_observation(T_idxs, B_idxs),\n prev_action=s.action[T_idxs - 1, B_idxs],\n prev_reward=s.reward[T_idxs - 1, B_idxs],\n ),\n action=s.action[T_idxs, B_idxs],\n return_=self.samples_return_[T_idxs, B_idxs],\n done=self.samples.done[T_idxs, B_idxs],\n done_n=self.samples_done_n[T_idxs, B_idxs],\n target_inputs=AgentInputs(\n observation=self.extract_observation(target_T_idxs, B_idxs),\n prev_action=s.action[target_T_idxs - 1, B_idxs],\n prev_reward=s.reward[target_T_idxs - 1, B_idxs],\n ),\n hyper_observation=self.extract_observation(hyper_idxs, B_idxs),\n hyper_done=self.extract_done(T_idxs, B_idxs, self.hyper_steps),\n )\n t_news = np.where(s.done[T_idxs - 1, B_idxs])[0]\n batch.agent_inputs.prev_action[t_news] = 0\n batch.agent_inputs.prev_reward[t_news] = 0\n return torchify_buffer(batch)","def _gibbs_sampling_iteration(self):\n for m, dm in enumerate(self.corpus):\n for n, w_mn in enumerate(dm):\n k = self.z_mn[m, n]\n self.n_mk[m, k] -= 1\n self.n_m[m] -= 1\n self.n_kt[k, w_mn] -= 1\n self.n_k[k] -= 1\n k = self._conditional_z(\n self.n_components, self.alpha, self.beta,\n self.n_mk, self.n_kt, m, w_mn, self.beta_sum, self.n_k)\n self.z_mn[m, n] = k\n self.n_mk[m, k] += 1\n self.n_m[m] += 1\n self.n_kt[k, w_mn] += 1\n self.n_k[k] += 1","def gen_batch_function(data_folder, image_shape):\n def get_batches_fn(batch_size):\n \"\"\"\n Create batches of training data\n :param batch_size: Batch Size\n :return: Batches of training data\n \"\"\"\n image_paths = glob(os.path.join(data_folder, 'image_2', '*.png'))\n label_paths = {\n re.sub(r'_(lane|road)_', '_', os.path.basename(path)): path\n for path in glob(os.path.join(data_folder, 'gt_image_2', '*_road_*.png'))}\n background_color = np.array([255, 0, 0])\n other_road_color = np.array([0,0,0])\n random.shuffle(image_paths)\n for batch_i in range(0, len(image_paths), batch_size):\n images = []\n gt_images = []\n for image_file in image_paths[batch_i:batch_i+batch_size]:\n gt_image_file = label_paths[os.path.basename(image_file)]\n\n image = scipy.misc.imresize(scipy.misc.imread(image_file), image_shape)\n image_flip = np.flip(image, axis=1)\n \n gt_image = scipy.misc.imresize(scipy.misc.imread(gt_image_file), image_shape)\n gt_image_flip = np.flip(gt_image, axis=1)\n \n #---------- classification : single road---------------------\n #gt_bg = np.all(gt_image == background_color, axis=2)\n #gt_bg = gt_bg.reshape(*gt_bg.shape, 1)\n #gt_image = np.concatenate((gt_bg, np.invert(gt_bg)), axis=2)\n #------------------------------------------------------------\n \n \n #---------- classification : multi road----------------------\n gt_bg = np.all(gt_image == background_color, axis=2)\n gt_bg_flip = np.all(gt_image_flip == background_color, axis=2)\n \n # road segment\n road_mask = ((gt_image == other_road_color) | (gt_image == background_color))\n gt_road = np.invert(np.all(road_mask, axis=2))\n \n # flip of road segment\n road_mask_flip = ((gt_image_flip == other_road_color) | (gt_image_flip == background_color))\n gt_road_flip = np.invert(np.all(road_mask_flip, axis=2))\n \n # other_road segment\n oher_road_mask = (gt_image == other_road_color)\n gt_other_road = np.all(oher_road_mask, axis=2)\n \n # flip of other_road segment\n other_road_mask_flip = (gt_image_flip == other_road_color)\n gt_oher_road_flip = np.all(other_road_mask_flip, axis=2)\n\n # reshaping segments\n gt_bg = gt_bg.reshape(*gt_bg.shape, 1)\n gt_other_road = gt_other_road.reshape(*gt_other_road.shape, 1)\n gt_road = gt_road.reshape(*gt_road.shape, 1)\n \n # reshaping flip segments\n gt_bg_flip = gt_bg_flip.reshape(*gt_bg_flip.shape, 1)\n gt_oher_road_flip = gt_oher_road_flip.reshape(*gt_oher_road_flip.shape, 1)\n gt_road_flip = gt_road_flip.reshape(*gt_road_flip.shape, 1)\n \n # concatenating classes bg, road, other_road\n gt_image = np.concatenate((gt_bg, gt_road, gt_other_road), axis=2)\n gt_image_flip = np.concatenate((gt_bg_flip, gt_road_flip, gt_oher_road_flip), axis=2)\n \n images.append(image)\n images.append(image_flip)\n \n gt_images.append(gt_image)\n gt_images.append(gt_image_flip)\n\n yield np.array(images), np.array(gt_images)\n return get_batches_fn","def eval_batch(self, outputs, target):\n raise NotImplementedError","def main():\n args = get_arguments()\n print(args.batch_size)","def batch_iter(input_data,batch_size):\r\n batch_ids,batch_mask,batch_segment,batch_label=[],[],[],[]\r\n for features in input_data:\r\n if len(batch_ids) == batch_size:\r\n yield batch_ids,batch_mask,batch_segment,batch_label\r\n batch_ids, batch_mask, batch_segment, batch_label = [], [], [], []\r\n\r\n batch_ids.append(features['input_ids'])\r\n batch_mask.append(features['input_mask'])\r\n batch_segment.append(features['segment_ids'])\r\n batch_label.append(features['label_ids'])\r\n\r\n if len(batch_ids) != 0:\r\n yield batch_ids, batch_mask, batch_segment, batch_label","def train(self, X, y, batch_size=5, num_epochs=10, alpha=0.1, gamma=0.9, learning=\"Delta\"):\n rem = int(np.ceil(len(X[0])/batch_size))\n for epoch in range(num_epochs):\n art = 0;\n for sample in range(rem):\n end = art + batch_size\n\n # Get a sample (column from X and Y) where the size of the sample is given by the batch size\n sampleX = X[:, art : end]\n sampleY = y[:, art : end]\n #print (sampleX)\n\n # Get the prediction\n results = self.predict(sampleX)\n art += batch_size\n\n if learning == \"Delta\" or learning == \"delta\":\n # Calculate e\n e = np.subtract(sampleY, results)\n\n # Calculate e dot p, where p is the input matrix\n ep = np.dot(e, np.transpose(sampleX))\n\n # Multiply this new matrix by the scalar alpha\n aep = np.multiply(alpha, ep)\n\n # Calculate the new weights along with the bias\n self.weights = np.add(self.weights, aep)\n \n elif learning == \"Filtered\" or learning == \"filtered\":\n\n # Calculate e dot p, where p is the input matrix\n ep = np.dot(sampleY, np.transpose(sampleX))\n\n # Multiply this new matrix by the scalar alpha\n aep = np.multiply(alpha, ep)\n\n # Multiply the old weights by some scalar gamma\n gw = np.multiply(1 - gamma, self.weights)\n\n self.weights = np.add(gw, aep)\n\n elif learning == \"Unsupervised_hebb\" or learning == \"unsupervised_hebb\":\n # Add a row of one's to the top of the input matrix\n #newX = np.vstack((np.array([1 for column in range(sampleX.shape[1])]), sampleX))\n\n # Calculate e dot p, where p is the input matrix\n ep = np.dot(results, np.transpose(sampleX))\n\n # Multiply this new matrix by the scalar alpha\n aep = np.multiply(alpha, ep)\n\n # Calculate the new weights along with the bias\n self.weights = np.add(self.weights, aep)","def _get_batch(self, index_array):\n # The transformation of images is not under thread lock\n # so it can be done in parallel\n batch_x = np.zeros((len(index_array),) + self.target_size,\n dtype=np.float32)\n batch_x = np.expand_dims(batch_x, axis=-1)\n # build batch of image data\n for i, j in enumerate(index_array):\n batch_x[i] = self.data[j]\n\n\n self.classes = np.asarray(self.classes, dtype=np.float32)\n # build batch of labels\n if self.class_mode == 'input':\n batch_y = batch_x.copy()\n elif self.class_mode == 'sparse':\n batch_y = self.classes[index_array]\n elif self.class_mode == 'binary':\n batch_y = self.classes[index_array]\n elif self.class_mode == 'categorical':\n batch_y = np.zeros((len(batch_x), self.num_classes),\n dtype=np.float32)\n for i, label in enumerate(self.classes[index_array]):\n\n batch_y[i, int(label)] = 1.\n else:\n return batch_x\n\n return batch_x, batch_y","def _get_batch(self,\n X_train, \n Y_train):\n\n raw_data_length = len(X_train)\n\n # partition raw data into batches and stack them vertically in a data matrix\n batch_partition_length = raw_data_length // self.model_parameters.batch_size\n data_x = np.zeros([self.model_parameters.batch_size, \n batch_partition_length, \n self.model_parameters.input_dimension], \n dtype=np.float32)\n\n data_y = np.zeros([self.model_parameters.batch_size, \n batch_partition_length, \n self.model_parameters.n_classes], \n dtype=np.float32)\n #data_y = np.zeros([batch_size, n_classes], dtype=np.int32)\n \n for i in range(self.model_parameters.batch_size):\n data_x[i] = X_train[batch_partition_length * i:batch_partition_length * (i + 1), :]\n data_y[i] = Y_train[batch_partition_length * i:batch_partition_length * (i + 1),:]\n \n # further divide batch partitions into sequence_length for truncated backprop\n epoch_size = batch_partition_length // self.model_parameters.sequence_length\n\n for i in range(epoch_size):\n x = data_x[:, i * self.model_parameters.sequence_length:(i + 1) * self.model_parameters.sequence_length,:]\n y = data_y[:, i * self.model_parameters.sequence_length:(i + 1) * self.model_parameters.sequence_length,:]\n yield (x, y)","def process_state_batch(self, batch):\n # batch = np.squeeze(batch, axis=1)\n batch = np.array([np.concatenate(obs, axis=-1) for obs in batch])\n return batch","def _batch(self, X, y, batch_size=16):\n X, y = self._shuffle(X, y) # shuffle the data\n self.batches = []\n idx = 0\n while idx < len(X):\n batch = (X[idx:idx+batch_size], y[idx:idx+batch_size])\n self.batches.append(batch)\n idx += batch_size","def generate_batch(self, batch_size, rand=None, *args, **kwargs):\n return [\n self.generate_datasets(rand, *args, **kwargs) for _ in range(batch_size)\n ]","def bellman(self, batch_size, gamma = 0.9):\n\n d_batch = random.sample(self.D, batch_size)\n\n inputs = np.zeros((batch_size, self.phi_len, ) \n + self.env.observation_space.shape)\n targets = np.zeros((batch_size, self.model.output_shape[1]))\n\n for i, (state, action, reward, state_new, done) in enumerate(d_batch):\n\n inputs[i] = state\n targets[i] = self.model.predict(np.expand_dims(state, axis = 0))\n\n if done:\n targets[i, action] = reward\n else:\n targets[i, action] = (reward \n + gamma \n * np.amax(self.model.predict(\n np.expand_dims(state_new, axis = 0))))\n\n return inputs, targets","def generate(self):\n self.training_data.gen_x(self.x_func)\n self.training_data.gen_a(self.a_func)\n self.training_data.gen_y(self.y_func)\n \n self.testing_data.gen_x(self.x_func)\n self.testing_data.gen_ys(self.y_func)\n self.testing_data.gen_azero(self.ytotal_func)","def train_next_batch(self, batch_size=None):","def get_batches(self, batch_size):\n if self.data.shape[0] % batch_size != 0:\n raise RuntimeError('num of data tuples is not a multiple of batch size')\n num_batch = self.data.shape[0] // batch_size\n for b in range(num_batch):\n yield self.data[b*batch_size:(b+1)*batch_size, :], \\\n self.target[b*batch_size:(b+1)*batch_size, :]","def _prepare_batch(self, batch):\n try:\n import dgl\n except:\n raise ImportError('This class requires dgl.')\n\n inputs, labels, weights = batch\n dgl_graphs = [\n graph.to_dgl_graph(self_loop=self._self_loop) for graph in inputs[0]\n ]\n inputs = dgl.batch(dgl_graphs).to(self.device)\n _, labels, weights = super(MPNNModel, self)._prepare_batch(\n ([], labels, weights))\n return inputs, labels, weights","def train_step(self, batch: dict, epoch: int):\n\n with torch.cuda.amp.autocast(self.mixed_precision):\n \n # Update momentum {key, pseudo} networks\n with torch.no_grad():\n self._momentum_update_key_net()\n self._momentum_update_pseudo_net()\n\n # Get data (3 views)\n x_q = batch['x1'].to(self.local_rank)\n x_k = batch['x2'].to(self.local_rank)\n x_ps = batch['x3'].to(self.local_rank)\n \n # Compute strong query features; (B, f)\n z_q = F.normalize(self.net_q(x_q), dim=1)\n\n with torch.no_grad():\n \n # Shuffle across nodes (gpus)\n x_k, idx_unshuffle_k = ForMoCo.batch_shuffle_ddp(x_k)\n x_ps, idx_unshuffle_ps = ForMoCo.batch_shuffle_ddp(x_ps)\n \n # Compute {key, pseudo} features; (B, f)\n z_k = F.normalize(self.net_k(x_k), dim=1)\n z_ps = F.normalize(self.net_ps(x_ps), dim=1)\n \n # Restore {key, pseudo} features to their original nodes\n z_k = ForMoCo.batch_unshuffle_ddp(z_k, idx_unshuffle_k)\n z_ps = ForMoCo.batch_unshuffle_ddp(z_ps, idx_unshuffle_ps)\n\n # Compute loss\n loss, logits, labels, loss_pseudo, probs_pseudo_neg = \\\n self.loss_function(z_q, z_ps, z_k, self.queue.buffer, threshold=self.threshold)\n \n # Backpropagate & update\n if loss_pseudo.isnan() or (epoch <= self.ramp_up):\n self.backprop(loss)\n else:\n alpha = 1.0\n self.backprop(loss + alpha * loss_pseudo)\n \n # Compute metrics\n with torch.no_grad():\n \n # Accuracy of true positives against all negatives\n rank_1 = TopKAccuracy(k=1)(logits, labels)\n \n # Accuracy of pseudo positives with ground truth labels\n above_threshold = probs_pseudo_neg.ge(self.threshold)\n num_pseudo = above_threshold.sum()\n \n # No pseudo positives may have been selected\n if self.queue.is_reliable and (num_pseudo > 0):\n labels_query = batch['y'].to(self.local_rank) # (B, )\n labels_queue = self.queue.labels # (k, )\n is_correct = labels_query.view(-1, 1).eq(labels_queue.view(1, -1)) # (B, 1) @ (1, k) -> (B, k)\n num_correct = is_correct.masked_select(above_threshold).sum()\n precision = torch.true_divide(num_correct, num_pseudo)\n else:\n num_correct = torch.zeros(1, dtype=torch.long, device=num_pseudo.device)\n precision = torch.zeros(1, dtype=torch.float32, device=num_pseudo.device)\n \n # Update memory queue\n self.queue.update(keys=z_k, labels=batch['y'].to(self.local_rank))\n\n return {\n 'loss': loss.detach(),\n 'loss_pseudo': loss_pseudo.detach(), # (1, ) or tensor(nan)\n 'rank@1': rank_1,\n 'num_correct': num_correct,\n 'num_pseudo': num_pseudo,\n 'precision': precision,\n }","def gen_batch(batch_size,\n num_voters,\n num_alternatives,\n voter_experience='default',\n max_experience=50,\n pull_variance=100.,\n count_noise=0.,\n random_count_prob=0.):\n gt = lambda: gen_trial(num_voters, num_alternatives, voter_experience, max_experience, pull_variance, count_noise, random_count_prob)\n arm_means, c, _, rankings = list(zip(*[gt() for _ in range(batch_size)]))\n return torch.tensor(arm_means).float(), torch.tensor(c).float(), torch.tensor(rankings).float()","def train_minibatches(self):\n batch_size = self.params['batch_size']\n start_index = 0\n while start_index + batch_size < 500:\n end_index = start_index + batch_size\n yield self.input[start_index:end_index], self.y[start_index:end_index]\n start_index = end_index","def batch_generate(self, text, mel_target):\n mel_in = torch.zeros(1,80,1).to(self.device)\n for i in range(mel_target.shape[2]):\n # forward pass\n y, ylogit, a = self.generate(text, mel_in)\n # create new mel_in\n mel_in = torch.cat((mel_in, y[:,:,-1].view(1,80,1)), dim=-1)\n\n # compute L1 loss to target and return target and prediction\n loss = F.l1_loss(y, mel_target)\n return loss, y, a","def generate(self, batch_size, s=\"train\"):\n while True:\n pairs, targets = self.get_batch(batch_size,s)\n yield (pairs, targets)","def backprop_batch(self, xs, ys):\n nabla_b = [cp.zeros(b.shape) for b in self.biases]\n nabla_w = [cp.zeros(w.shape) for w in self.weights]\n\n # forward pass\n activation = xs\n activations = [xs] # list to store all the activations, layer by layer\n zs = [] # list to store all the z vectors, layer by layer\n for b, w in zip(self.biases, self.weights):\n zs.append(w @ activation + b)\n activation = sigmoid(zs[-1])\n activations.append(activation)\n\n # backward pass\n delta = self.cost_derivative(activations[-1], ys) * f_sigmoid_prime(activations[-1])\n nabla_w[-1] = delta @ activations[-2].transpose((0, 2, 1))\n nabla_b[-1] = delta\n for t in range(self.num_layers - 2, 0, -1):\n delta = f_sigmoid_prime(activations[t]) * (self.weights[t].T @ delta)\n nabla_w[t - 1] = delta @ activations[t - 1].transpose((0, 2, 1))\n nabla_b[t - 1] = delta\n return nabla_b, nabla_w","def _get_batch(self, index_array):\n # The transformation of images is not under thread lock\n # so it can be done in parallel\n batch_x = np.zeros((len(index_array),) + self.target_size, dtype=np.float32)\n batch_x = np.expand_dims(batch_x, axis=-1)\n # build batch of image data\n for i, j in enumerate(index_array):\n img = vio.ext_load(self.path_str[j], self.target_size)\n batch_x[i] = deepcopy(img)\n\n self.classes = np.asarray(self.classes, dtype=np.float32)\n # build batch of labels\n if self.class_mode == 'input':\n batch_y = batch_x.copy()\n elif self.class_mode == 'sparse':\n batch_y = self.classes[index_array]\n elif self.class_mode == 'binary':\n batch_y = self.classes[index_array]\n elif self.class_mode == 'categorical':\n batch_y = np.zeros((len(batch_x), self.num_classes),dtype=np.float32)\n for i, label in enumerate(self.classes[index_array]):\n\n batch_y[i, int(label)] = 1.\n else:\n return batch_x\n\n return batch_x, batch_y","def generate_batches(data, labels, batch_size):\n for start in range(0, len(data), batch_size):\n yield Tensor(data[start:start+batch_size, ...]), Tensor(labels[start:start+batch_size, ...])","def next_batch(self, batch_size):\n # Get batch\n assert(batch_size == 1)\n em, mask_list, seed_list = self.next_example(self.K)\n\n # Reshape for batch size 1\n em_batch = np.expand_dims(em, 0)\n mask_list = [np.expand_dims(m,0) for m in mask_list]\n \n return em_batch, mask_list","def evaluate_batch(self, pipelines):","def main(tetrode_number=TETRODE_NUMBER,num_hidden_units=500,num_hidden_units_2=300,num_hidden_units_3=200,num_code_units=50):\n \n print(\"Making the model...\")\n network = model((None,200),200,num_hidden_units,num_hidden_units_2,num_hidden_units_3,num_code_units)\n print(\"Done!\")\n\n\n for tetrode_number in [10]:\n\n print(\"Loading the model parameters from {}\".format(MODEL_FILENAME+str(tetrode_number)))\n f = open(MODEL_FILENAME+str(tetrode_number),'r')\n all_param_values = pickle.load(f)\n f.close()\n # print(all_param_values)\n lasagne.layers.set_all_param_values(network, all_param_values)\n\n print(\"Loading the data...\")\n dataset = load_data(tetrode_number)\n print(\"Done!\")\n\n print(dataset['data'].shape)\n\n print(\"Setting up the training functions...\")\n training = funcs(dataset,network)\n print(\"Done!\")\n\n for i in range(NUM_EPOCHS):\n costs = []\n\n for start, end in zip(range(0, dataset['data'].shape[0], BATCH_SIZE), range(BATCH_SIZE, dataset['data'].shape[0], BATCH_SIZE)):\n cost = training['train'](dataset['data'][start:end],dataset['data'][start:end])\n costs.append(cost)\n\n meanTrainCost = np.mean(np.asarray(costs,dtype=np.float32))\n # accuracy = training['accuracy'](dataset['X_test'],dataset['y_test'])\n\n print(\"Epoch: {}, Training cost: {}\".format(i+1,meanTrainCost))\n # NUM_POINTS = 5000\n codes = training['code'](dataset['data'][0:NUM_POINTS])\n\n \n\n # y = set(list(d.predict(dataset['data'][0:NUM_POINTS])))\n\n # print(y)\n\n # activations_1 = training['activations_1'](dataset['data'][0:NUM_POINTS])\n # activations_2 = training['activations_2'](dataset['data'][0:NUM_POINTS])\n # codes = training['code'](dataset['data'][0:NUM_POINTS])\n # # print(codes.shape)\n # # codes_2d = bh_sne(codes)\n\n # for k in range(3):\n # print(k)\n\n # codes_2d = bh_sne(np.asarray(codes[:(k+1)*12000],dtype=np.float64))\n\n # # d = DPGMM(n_components=10, covariance_type='full')\n # d = DPGMM(n_components=15,n_iter=100)\n\n # d.fit(codes_2d[:(k+1)*12000])\n\n # hdp = d.predict_proba(codes_2d[:(k+1)*12000])\n\n # hdp_1d = [np.argmax(z) for z in hdp]\n\n # print(set(list(hdp_1d)))\n\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=hdp_1d, alpha=0.8,lw=0)\n # plt.savefig('dbscan_labels/deep/sparse/hdp_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\n # plt.close()\n\n # # m = TSNE(n_components=2, random_state=0)\n \n # # codes_2d = m.fit_transform(codes[:NUM_POINTS])\n # # activations_1_2d = bh_sne(activations_1)\n # # activations_2_2d = bh_sne(activations_2)\n\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=dataset['labels'][0:NUM_POINTS][:(k+1)*12000],alpha=0.8,lw=0)\n # plt.savefig('dbscan_labels/deep/sparse/tsne_codes_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\n # plt.close()\n\n # # This is where the code for the video will go\n # ##############################################################################\n # # Compute DBSCAN\n # db = None\n # core_samples_mask = None\n # labels = None\n\n # num_labels = 0\n # eps=1.0\n # while(num_labels < 10):\n # db = DBSCAN(eps=eps, min_samples=10).fit(codes_2d)\n # core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\n # core_samples_mask[db.core_sample_indices_] = True\n # labels = db.labels_\n # num_labels = np.amax(labels)\n # eps -= 0.1\n\n # print(\"Num learned labels: {}\".format(num_labels))\n\n # plt.title('Estimated number of clusters: {}'.format(np.amax(labels)))\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=labels[0:NUM_POINTS][:(k+1)*12000],lw=0)\n # plt.savefig('dbscan_labels/deep/sparse/dbscan_codes_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\n # plt.close()\n\n # # f=open('dbscan_labels/deep/sparse/tetrode_{}.npy'.format(tetrode_number),'w')\n # # pickle.dump(labels, f)\n # # f.close()\n\n codes_2d = bh_sne(np.asarray(codes,dtype=np.float64),theta=0.4)\n\n # d = DPGMM(n_components=10, covariance_type='full')\n d = DPGMM(n_components=15,n_iter=1000)\n\n d.fit(codes_2d)\n\n hdp = d.predict_proba(codes_2d)\n\n hdp_1d = [np.argmax(z) for z in hdp]\n\n print(set(list(hdp_1d)))\n\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=hdp_1d, alpha=0.8,lw=0)\n plt.savefig('dbscan_labels/deep/sparse/hdp_{}.png'.format(tetrode_number), bbox_inches='tight')\n plt.close()\n\n # m = TSNE(n_components=2, random_state=0)\n \n # codes_2d = m.fit_transform(codes[:NUM_POINTS])\n # activations_1_2d = bh_sne(activations_1)\n # activations_2_2d = bh_sne(activations_2)\n\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=dataset['labels'][0:NUM_POINTS],alpha=0.8,lw=0)\n plt.savefig('dbscan_labels/deep/sparse/tsne_codes_{}.png'.format(tetrode_number), bbox_inches='tight')\n plt.close()\n\n # This is where the code for the video will go\n ##############################################################################\n # Compute DBSCAN\n db = None\n core_samples_mask = None\n labels = None\n\n num_labels = 0\n eps=1.0\n while(num_labels < 10):\n db = DBSCAN(eps=eps, min_samples=10).fit(codes_2d)\n core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\n core_samples_mask[db.core_sample_indices_] = True\n labels = db.labels_\n num_labels = np.amax(labels)\n eps -= 0.1\n\n print(\"Num learned labels: {}\".format(num_labels))\n\n plt.title('Estimated number of clusters: {}'.format(np.amax(labels)))\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=labels[0:NUM_POINTS],lw=0)\n plt.savefig('dbscan_labels/deep/sparse/dbscan_codes_{}.png'.format(tetrode_number), bbox_inches='tight')\n plt.close()\n\n # f=open('dbscan_labels/deep/sparse/tetrode_{}.npy'.format(tetrode_number),'w')\n # pickle.dump(labels, f)\n # f.close()"],"string":"[\n \"def generate_batch():\\n\\n # Initialize variables\\n example = np.zeros(self.batch_size)\\n labels = np.zeros((self.batch_size, 1))\\n alphas = np.zeros(self.batch_size)\\n n_items = 0\\n index = 0\\n\\n while index < len(data):\\n reduced_window = random.randint(0, self.window_size)\\n if data[index] is not None:\\n\\n left = max(0, index - self.window_size + reduced_window)\\n right = min((index + self.window_size + 1 -\\n reduced_window), len(data) - 1)\\n for pos2 in range(left, right, 1):\\n\\n if n_items == self.batch_size:\\n queue.put((example, labels, index))\\n example = np.zeros(self.batch_size)\\n labels = np.zeros((self.batch_size, 1))\\n n_items = 0\\n\\n if pos2 != index and data[pos2] is not None:\\n example[n_items] = data[pos2]\\n labels[n_items] = data[index]\\n alpha = self.learning_rate - \\\\\\n (self.learning_rate - 0.001) * (index / self.n_words)\\n alphas[n_items] = max(0.001, alpha)\\n n_items += 1\\n index += 1\\n\\n # Poison pills\\n for _ in range(n_workers):\\n queue.put(None)\",\n \"def run_batch(bag):\\n\\n states = []\\n\\n for i in bag:\\n a1 = i[0]\\n a2 = i[1]\\n a3 = i[2]\\n a4 = i[3]\\n a5 = i[4]\\n prob = i[5]\\n sheets = (a1 + a2 + a3 + a4 + a5)\\n if sheets > 0:\\n a1_prob = (float(a1) / sheets)\\n a2_prob = (float(a2) / sheets)\\n a3_prob = (float(a3) / sheets)\\n a4_prob = (float(a4) / sheets)\\n a5_prob = (float(a5) / sheets)\\n if a1 > 0:\\n out = a1_func(i)\\n out[5] = (out[5] * a1_prob)\\n states.append(out)\\n if a2 > 0:\\n out = a2_func(i)\\n out[5] = (out[5] * a2_prob)\\n states.append(out)\\n if a3 > 0:\\n out = a3_func(i)\\n out[5] = (out[5] * a3_prob)\\n states.append(out)\\n if a4 > 0:\\n out = a4_func(i)\\n out[5] = (out[5] * a4_prob)\\n states.append(out)\\n if a5 > 0:\\n out = a5_func(i)\\n out[5] = (out[5] * a5_prob)\\n states.append(out)\\n if sheets == 1:\\n global zero_probs\\n zero_probs.append(prob)\\n if sheets == 0:\\n states.append([0, 1, 1, 1, 1, prob])\\n return states\",\n \"def _generate_batch(self, tasks: List):\\n x_batch = np.stack([np.random.uniform(low=self.domain_bounds[0], high=self.domain_bounds[1], size=(self.inner_update_k, 1)) for _ in range(len(tasks))])\\n y_batch = np.stack([[tasks[t](x) for x in x_batch[t]] for t in range(len(tasks))])\\n\\n return x_batch, y_batch\",\n \"def generate(bat_size, s=\\\"train\\\"):\\n while True:\\n pairs, targets = get_batch(bat_size, s)\\n yield (pairs, targets)\",\n \"def get_batch_gen(self, config):\\n\\n ################\\n # Def generators\\n ################\\n\\n def random_balanced_gen():\\n print('trying to generate batch series with ', self.num_train, 'shapes')\\n\\n # Initiate concatenation lists\\n tp_list = [] # points\\n tev_list = [] # eigen vectors\\n tevt_list = [] # transposed eigen vectors\\n tv_list = [] # eigen values\\n tevf_list = [] # full eigen vectors for ground truth maps\\n ti_list = [] # cloud indices\\n\\n batch_n = 0\\n i_batch = 0\\n\\n gen_indices = np.random.permutation(int(self.num_train)) # initiate indices for the generator\\n # if we had to test on this dataset we would need to introduce a test/val case with non-shuffled indices\\n # print(gen_indices.shape, config.batch_num)\\n # if config.split == 'test':\\n # print('test setting here not fully supported')\\n # n_shapes = self.num_test # has to be defined\\n # gen_indices = []\\n # for i in range(n_shapes - 1):\\n # for j in range(i + 1, n_shapes):\\n # gen_indices += [i, j] # put all the pairs in order\\n # gen_indices = np.array(gen_indices)\\n\\n\\n # Generator loop\\n for p_i in gen_indices:\\n\\n # Get points and other input data\\n new_points = self.input_points[p_i]\\n new_evecs = self.input_evecs[p_i][:, :self.neig]\\n new_evecs_trans = self.input_evecs_trans[p_i][:self.neig, :]\\n new_evals = self.input_evals[p_i][:self.neig]\\n\\n new_evecs_full = self.input_evecs_full[p_i][:, :self.neig]\\n\\n n = new_points.shape[0]\\n\\n if i_batch == config.batch_num:\\n\\n yield (np.concatenate(tp_list, axis=0),\\n np.concatenate(tev_list, axis=0),\\n np.concatenate(tevt_list, axis=1),\\n np.concatenate(tv_list, axis=1),\\n np.concatenate(tevf_list, axis=0),\\n np.array(ti_list, dtype=np.int32),\\n np.array([tp.shape[0] for tp in tp_list]))\\n\\n tp_list = []\\n tev_list = []\\n tevt_list = []\\n tv_list = []\\n tevf_list = []\\n ti_list = []\\n\\n batch_n = 0\\n i_batch = 0\\n\\n # Add data to current batch\\n tp_list += [new_points]\\n tev_list += [new_evecs]\\n tevt_list += [new_evecs_trans]\\n tv_list += [new_evals]\\n tevf_list += [new_evecs_full]\\n ti_list += [p_i]\\n\\n # Update batch size\\n batch_n += n\\n i_batch += 1\\n\\n # yield the rest if necessary (it will not be a full batch and could lead to mistakes because of\\n # shape matching needing pairs !!!!)\\n yield (np.concatenate(tp_list, axis=0),\\n np.concatenate(tev_list, axis=0),\\n np.concatenate(tevt_list, axis=1),\\n np.concatenate(tv_list, axis=1),\\n np.concatenate(tevf_list, axis=0),\\n np.array(ti_list, dtype=np.int32),\\n np.array([tp.shape[0] for tp in tp_list]))\\n\\n ##################\\n # Return generator\\n ##################\\n\\n # Generator types and shapes\\n gen_types = (tf.float32, tf.float32, tf.float32, tf.float32, tf.float32, tf.int32, tf.int32)\\n gen_shapes = ([None, 3], [None, self.neig],\\n [self.neig, None], [self.neig, None], [None, self.neig], [None], [None])\\n\\n return random_balanced_gen, gen_types, gen_shapes\",\n \"def batch_generate(self, inputs, labels, batch_size=64):\\n inputs_image, inputs, labels = check_inputs_labels(inputs, labels)\\n arr_x = inputs\\n arr_y = labels\\n len_x = inputs_image.shape[0]\\n batch_size = check_int_positive('batch_size', batch_size)\\n batches = int(len_x / batch_size)\\n rest = len_x - batches*batch_size\\n res = []\\n for i in range(batches):\\n if isinstance(arr_x, tuple):\\n x_batch = tuple([sub_items[i*batch_size: (i + 1)*batch_size] for sub_items in arr_x])\\n else:\\n x_batch = arr_x[i*batch_size: (i + 1)*batch_size]\\n if isinstance(arr_y, tuple):\\n y_batch = tuple([sub_labels[i*batch_size: (i + 1)*batch_size] for sub_labels in arr_y])\\n else:\\n y_batch = arr_y[i*batch_size: (i + 1)*batch_size]\\n adv_x = self.generate(x_batch, y_batch)\\n # Black-attack methods will return 3 values, just get the second.\\n res.append(adv_x[1] if isinstance(adv_x, tuple) else adv_x)\\n\\n if rest != 0:\\n if isinstance(arr_x, tuple):\\n x_batch = tuple([sub_items[batches*batch_size:] for sub_items in arr_x])\\n else:\\n x_batch = arr_x[batches*batch_size:]\\n if isinstance(arr_y, tuple):\\n y_batch = tuple([sub_labels[batches*batch_size:] for sub_labels in arr_y])\\n else:\\n y_batch = arr_y[batches*batch_size:]\\n adv_x = self.generate(x_batch, y_batch)\\n # Black-attack methods will return 3 values, just get the second.\\n res.append(adv_x[1] if isinstance(adv_x, tuple) else adv_x)\\n\\n adv_x = np.concatenate(res, axis=0)\\n return adv_x\",\n \"def generate_batch(self):\\n\\n # sbatch = list()\\n # tbatch = list()\\n # for i in range(self.dict_paras['batch_size']):\\n # sbatch.append(self.lst_triplet_train_map[self.data_index])\\n # self.data_index = (self.data_index + 1) % self.triplet_train_size\\n\\n sbatch = random.sample(self.lst_triplet_train_map, self.dict_paras['batch_size'])\\n tbatch = list()\\n\\n for ele in sbatch:\\n corrupted1, corrupted2 = self.get_corrupted_triplet(ele)\\n tbatch.append((ele, corrupted1))\\n tbatch.append((ele, corrupted2))\\n return tbatch\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n mean = 0\\n std_dev = 0.0001\\n #print(in_features)\\n #print(out_features)\\n # create weight matrices\\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\\n #print(weight.shape)\\n grad_weight = np.zeros((in_features, out_features))\\n\\n # create biases (in batches)\\n bias = np.zeros(out_features)\\n grad_bias = np.zeros(out_features)\\n\\n self.params = {'weight': weight, 'bias': bias}\\n self.grads = {'weight': bias, 'bias': grad_bias}\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def process_batch(self, batch):\\n # extend with current batch\\n self._extend(batch)\\n\\n # unpack and compute bounds\\n length = len(self.obs)\\n c = self.c\\n\\n # normally we cannot compute samples for the last c elements, but\\n # in the terminal case, we halluciante values where necessary\\n end = length if batch.terminal else length - c\\n\\n # collect samples to return in a FeudalBatch\\n feudal_batch = FeudalBatch()\\n for t in range(c, end):\\n\\n # state difference\\n s_diff = self.s[t + c] - self.s[t]\\n\\n # intrinsic reward\\n ri = 0\\n # note that this for loop considers s and g values\\n # 1 timestep to c timesteps (inclusively) ago\\n for i in range(1, c + 1):\\n ri_s_diff = self.s[t] - self.s[t - i]\\n if np.linalg.norm(ri_s_diff) != 0:\\n ri += cosine_similarity(ri_s_diff, self.g[t - i])\\n ri /= c\\n\\n # sum of g values used to derive w, input to the linear transform\\n gsum = np.zeros_like(self.g[t - c])\\n for i in range(t - c, t + 1):\\n gsum += self.g[i]\\n\\n # add to the batch\\n feudal_batch.add(self.obs[t], self.a[t], self.returns[t], s_diff,\\n ri, gsum, self.features[t])\\n\\n # in the terminal case, set reset flag\\n if batch.terminal:\\n self.last_terminal = True\\n # in the general case, forget all but the last 2 * c elements\\n # reason being that the first c of those we have already computed\\n # a batch for, and the second c need those first c\\n else:\\n twoc = 2 * self.c\\n self.obs = self.obs[-twoc:]\\n self.a = self.a[-twoc:]\\n self.returns = self.returns[-twoc:]\\n self.s = self.s[-twoc:]\\n self.g = self.g[-twoc:]\\n self.features = self.features[-twoc:]\\n\\n return feudal_batch.get_batch()\",\n \"def run_batch(self):\\n\\n print(\\\"Running experiment with batch_size {}...\\\".format(self.batch_size))\\n\\n errors = self.W.new_tensor([])\\n energies = self.W.new_tensor([])\\n\\n x = (2 * self.W.new(self.N, self.batch_size).random_(2) - 1).float() # Initialize the x vector\\n rands = self.W.new(self.t_max, self.batch_size).uniform_() # The random values which will be compared to the acceptance probabilities\\n idxs = self.W.new(self.t_max, self.batch_size).random_(self.N).long() # The indices which will be flipped in x at each iteration\\n\\n energy, wx = utils.compute_energy_batch(x, self.W, self.Y) # Compute the initial value of the energy\\n\\n for iteration in range(self.t_max):\\n self.beta_scheduler.step(energies) # Update the value of beta according to the cooling strategy\\n\\n x, energy, wx = self.chain.step_batch(x, self.W, self.Y, self.beta_scheduler.beta, energy, wx, idxs[iteration], rands[iteration])\\n energies = torch.cat((energies, energy.unsqueeze(0)))\\n\\n e = utils.compute_reconstruction_error_batch(x, self.X) # Compute the current reconstruction error\\n errors = torch.cat((errors, e.unsqueeze(0)))\\n\\n return errors, energies, x\",\n \"def __call__(self):\\n if self.numbatches is None:\\n pool = self.pooler()\\n if self.batchsize is None:\\n self.batchsize = self.pooler.nInPool()\\n self.numbatches = self.pooler.nInPool()//self.batchsize\\n for i in xrange(self.numbatches):\\n pool = self.pooler()\\n self._reset_batch()\\n if self.samplemethod == 'balance' and len(self.keysamplers)>0:\\n batchinds,keyids = self._samplebalanced(pool)\\n elif self.samplemethod == 'uniform':\\n batchinds,keyids = self._sampleuniform(pool)\\n else:\\n batchinds,keyids = self._samplesequential(i)\\n batch = self._extractInds(pool,batchinds,keyids)\\n for k in batch:\\n batch[k][np.isnan(batch[k])] = self.nanreplacement\\n yield batch\",\n \"def produce_query_batches(self):\\n pass\",\n \"def perform_bayesian_optimization(self):\\n bounds = {'hunits': (self.hunits_lower, self.hunits_upper),\\n 'embedding_dim': (self.embedding_dim_lower, self.embedding_dim_upper)}\\n optimizer = BayesianOptimization(f=self.lstm_score, pbounds=bounds, random_state=1)\\n optimizer.maximize(init_points=2, n_iter=self.iterations)\\n print(optimizer.max)\\n print(optimizer.res)\",\n \"def step_batch(self, x_batch, W, Y, beta, energy_batch, wx, idx_batch, rand_batch):\\n raise NotImplementedError()\",\n \"def _generate_batch(self, tasks: List, plot=False): # Change batch generation to be done in pure PyTorch\\n raise NotImplementedError\",\n \"def batcher(params, batch):\\n bpe_batch_indices = []\\n for sentence in batch:\\n sentence = ' '.join(sentence)\\n if bert:\\n indices = format_sentence_with_bert(sentence, params['wordpiece'], max_len)\\n else:\\n indices = format_sentence(sentence, params['bpe'], max_len)\\n bpe_batch_indices.append(torch.LongTensor(indices))\\n\\n bpe_batch_indices = torch.stack(bpe_batch_indices, 0)\\n\\n # send to gpu\\n bpe_batch_indices = bpe_batch_indices.to(params['device'])\\n # if bert_max:\\n # # we use max over BERT embeddings as sentence representation\\n # with torch.no_grad():\\n # all_embs, _ = params['bert'](bpe_batch_indices)[-2:]\\n # all_embs, _ = torch.max(all_embs, 1) # get maximum value along the time dimension 1\\n # all_embs = all_embs.cpu().detach().numpy()\\n # elif bert_mean:\\n # # we use mean over BERT embeddings as sentence representation\\n # with torch.no_grad():\\n # all_embs, _ = params['bert'](bpe_batch_indices)[-2:]\\n # all_embs = torch.mean(all_embs, 1) # get maximum value along the time dimension 1\\n # all_embs = all_embs.cpu().detach().numpy()\\n # else:\\n\\n # we use model to calculate embeddings\\n all_embs = calculate_model_outputs(params['model'], bpe_batch_indices)\\n all_embs = all_embs.cpu().detach().numpy()\\n\\n return all_embs\",\n \"def train_dynamic(batch_size=10):\\n \\n return\",\n \"def SGD(epochs, eta):\\n # print([[[k] for k in i] for i in self.x])\\n # print([[j] for j in self.y])\\n # print([i] for)\\n\\n # if test_data: n_test = len(test_data)\\n for j in xrange(epochs):\\n # mini_batches = [training_data[k:k + mini_batch_size] for k in xrange(0, n, mini_batch_size)]\\n # for mini_batch in mini_batches:\\n # update_mini_batch(mini_batch, eta)\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\n for x, y in training_data:\\n delta_nabla_b, delta_nabla_w = backprop(x, y)\\n nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\n nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\n # for x, y in training_data:\\n # delta_nabla_b, delta_nabla_w = backprop(x, y)\\n # nabla_b = [nb + dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\n # nabla_w = [nw + dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\n self.weights = [w - (eta ) * nw\\n for w, nw in zip(self.weights, nabla_w)]\\n self.biases = [b - (eta ) * nb\\n for b, nb in zip(self.biases, nabla_b)]\\n\\n # print 'Epoch {0}'.format(j)\\n # print self.weights\\n # print self.biases\\n\\n # if test_data:\\n # print \\\"Epoch {0}: {1} / {2}\\\".format(\\n # j, evaluate(test_data), n_test)\\n # else:\\n # print \\\"Epoch {0} complete\\\".format(j)\",\n \"def generate_new_batches(Gs, features, y, idx, graph_window, shift, batch_size, device, test_sample):\\n\\n # print(\\\"...create batches...\\\")\\n N = len(idx)\\n n_nodes = Gs[0].number_of_nodes()\\n n_state = 50 \\n \\n adj_lst = list()\\n features_lst = list()\\n y_lst = list()\\n node_lst = list()\\n\\n batch_data = []\\n for i in range(0, N, batch_size):\\n if i+batch_size >= N:\\n batch_data += [[idx[x] for x in range(i, N)]]\\n else:\\n batch_data += [[idx[x] for x in range(i, i+batch_size)]]\\n\\n for batch in batch_data:\\n adj_tmp = list()\\n features_tmp = list()\\n y_tmp = list()\\n num_tmp = list()\\n line_idx = 0\\n for val in batch:\\n for k in range(val-graph_window+1,val+1):\\n adj_tmp.append(nx.adjacency_matrix(Gs[k-1]).toarray()) \\n for feat in features[k]:\\n features_tmp.append(feat)\\n num_tmp += list(range(line_idx, line_idx+50))\\n line_idx += len(features[k])\\n y_tmp.append(y[val+shift])\\n\\n adj_tmp = sparse_mx_to_torch_sparse_tensor(sp.block_diag(adj_tmp))\\n adj_lst.append(adj_tmp.to(device))\\n features_tmp = torch.FloatTensor(features_tmp)\\n features_lst.append(features_tmp.to(device))\\n y_tmp = torch.FloatTensor(y_tmp).reshape(-1)\\n y_lst.append(y_tmp.to(device))\\n node_lst.append(num_tmp)\\n\\n\\n return adj_lst, features_lst, y_lst, node_lst\",\n \"def train(self, num_batches: int):\",\n \"def batches(set_name):\\n global num_batches, args, ds_sizes \\n # num_batches = how many batches in each dataset(train, valid, test)\\n # ds_sizes = dataset_sizes \\n for b in range(num_batches[set_name]):\\n bi = b * args.batch_size # one batch mul batch_size \\n bj = (b + 1) * args.batch_size \\n if b == num_batches[set_name] - 1:\\n bj = ds_sizes[set_name] # maybe only remainer set\\n yield bi, bj\",\n \"def _get_batch(self):\\n # index = self._index[self._current]\\n # im_path = self._imdb.image_path_from_index(0)\\n # im_path = 'data/demo/dog.jpg'\\n # with open(im_path, 'rb') as fp:\\n # img_content = fp.read()\\n\\n batch_data = mx.nd.zeros((self.batch_size, 3, self._data_shape[0], self._data_shape[1]))\\n batch_label = [] \\n global imgi\\n # img = mx.nd.array(imgi)\\n # imgr = mx.img.imdecode(img_content)\\n data = self._data_augmentation(imgi)\\n batch_data[0] = data\\n \\n self._data = {'data': batch_data}\\n self._label = {'label': None}\",\n \"def postprocessing(batch, vocab):\\n\\n return batch\",\n \"def batch_gen():\\n i = 0\\n while len(all_sentences) - i >= batch_size:\\n # TODO this is a mess...\\n yield np.stack([\\n np.pad(\\n np.stack(\\n [embeddings[id]\\n for id in sentence[:max_sentence_length]]), [[\\n 0, max_sentence_length -\\n min(len(sentence), max_sentence_length)\\n ], [0, 0]],\\n 'constant',\\n constant_values=0)\\n for sentence in all_sentences[i:i + batch_size]\\n ])\\n\\n i += batch_size\",\n \"def next(self):\\n #print('next')\\n batch_size = self.batch_size\\n batch_data = nd.empty((batch_size,)+self.data_shape)\\n batch_label = nd.empty((batch_size,)+self.label_shape)\\n i = 0\\n #self.cutoff = random.randint(800,1280)\\n try:\\n while i < batch_size:\\n #print('N', i)\\n data, label, annot = self.next_sample()\\n R = self.get_data(data, label, annot)\\n if R is None:\\n continue\\n data_out, label_out, flip_data_out, flip_label_out = R\\n if not self.use_coherent:\\n data = nd.array(data_out)\\n data = nd.transpose(data, axes=(2, 0, 1))\\n label = nd.array(label_out)\\n #print(data.shape, label.shape)\\n batch_data[i][:] = data\\n batch_label[i][:] = label\\n i += 1\\n else:\\n data = nd.array(data_out)\\n data = nd.transpose(data, axes=(2, 0, 1))\\n label = nd.array(label_out)\\n data2 = nd.array(flip_data_out)\\n data2 = nd.transpose(data2, axes=(2, 0, 1))\\n label2 = nd.array(flip_label_out)\\n #M = nd.array(M)\\n #print(data.shape, label.shape)\\n batch_data[i][:] = data\\n batch_label[i][:] = label\\n #i+=1\\n j = i+self.per_batch_size//2\\n batch_data[j][:] = data2\\n batch_label[j][:] = label2\\n i += 1\\n if j%self.per_batch_size==self.per_batch_size-1:\\n i = j+1\\n except StopIteration:\\n if i<batch_size:\\n raise StopIteration\\n\\n #return {self.data_name : batch_data,\\n # self.label_name : batch_label}\\n #print(batch_data.shape, batch_label.shape)\\n return mx.io.DataBatch([batch_data], [batch_label], batch_size - i)\",\n \"def generate_batch(batch_ims):\\n batch_X = np.zeros((len(batch_ims), 3, 224, 224))\\n batch_y = np.zeros((len(batch_ims), 1))\\n for i, im_file in enumerate(batch_ims):\\n img = imread(im_file).astype(\\\"float32\\\")\\n img[:, :, 0] -= 103.939\\n img[:, :, 1] -= 116.779\\n img[:, :, 2] -= 123.68\\n img = img.transpose((2, 0, 1))\\n batch_X[i, :, :, :] = img\\n\\n file_id = im_file.split(\\\"/\\\")[-1].split(\\\"_\\\")[0]\\n score = labels_map[file_id][PERS_FIELD_NAME]\\n if score >= 5.5:\\n batch_y[i] = 1\\n return (batch_X, batch_y)\",\n \"def init_batch(self):\\n pass\",\n \"def produce_query_batches(self):\\n self.__generate_queries()\\n return self.__bobs\",\n \"def compute_batch(self, duplicate_manager=None,context_manager=None):\\n from ...acquisitions import AcquisitionTS\\n assert isinstance(self.acquisition, AcquisitionTS)\\n \\n X_batch,_ = self.acquisition.optimize()\\n k=1\\n \\n # --- GET the remaining elements\\n while k<self.batch_size:\\n new_sample,_ = self.acquisition.optimize()\\n X_batch = np.vstack((X_batch,new_sample))\\n k +=1\\n \\n return X_batch\",\n \"def test_minibatches(self):\\n batch_size = self.params['batch_size']\\n start_index = 0\\n while start_index + batch_size < 500:\\n end_index = start_index + batch_size\\n yield self.input[start_index:end_index], self.y[start_index:end_index]\\n start_index = end_index\",\n \"def Collecting_experiences(self)-> None:\\n for epoch_no in range(self.epochs):\\n print(\\\"EPOCH %d\\\", epoch_no + 1)\\n \\n #beam_dqn = self.beam_min + int(self.beam_max * epoch_no/self.epochs)\\n #egreed = self.egreed_max*(1 - epoch_no/(1.1*self.epochs))\\n #self.gamma = self.gamma_max*(1 - epoch_no/(2*self.epochs))\\n\\n beam_dqn = 1\\n egreed = 0.5\\n #self.gamma = self.gamma_max\\n self.gamma = 0.6\\n\\n self.tb_writer.add_scalar(\\\"parameters/beam_dqn\\\",\\n beam_dqn, epoch_no)\\n self.tb_writer.add_scalar(\\\"parameters/egreed\\\",\\n egreed, epoch_no)\\n self.tb_writer.add_scalar(\\\"parameters/gamma\\\",\\n self.gamma, epoch_no)\\n if beam_dqn > self.actions_size:\\n print(\\\"The beam_dqn cannot exceed the action size!\\\")\\n print(\\\"then the beam_dqn = action size\\\")\\n beam_dqn = self.actions_size\\n\\n print(' beam_dqn, egreed, gamma: ', beam_dqn, egreed, self.gamma)\\n for _, data_set in self.data_to_train_dqn.items():\\n \\n valid_iter = make_data_iter(\\n dataset=data_set, batch_size=1, batch_type=self.batch_type,\\n shuffle=False, train=False)\\n #valid_sources_raw = data_set.src\\n # disable dropout\\n #self.model.eval()\\n\\n i_sample = 0\\n for valid_batch in iter(valid_iter):\\n freeze_model(self.model)\\n batch = Batch(valid_batch\\n , self.pad_index, use_cuda=self.use_cuda)\\n \\n encoder_output, encoder_hidden = self.model.encode(\\n batch.src, batch.src_lengths,\\n batch.src_mask)\\n # if maximum output length is not globally specified, adapt to src len\\n \\n if self.max_output_length is None:\\n self.max_output_length = int(max(batch.src_lengths.cpu().numpy()) * 1.5)\\n \\n batch_size = batch.src_mask.size(0)\\n prev_y = batch.src_mask.new_full(size=[batch_size, 1], fill_value=self.bos_index,\\n dtype=torch.long)\\n output = []\\n hidden = self.model.decoder._init_hidden(encoder_hidden)\\n prev_att_vector = None\\n finished = batch.src_mask.new_zeros((batch_size, 1)).byte()\\n\\n # print(\\\"Source_raw: \\\", batch.src)\\n # print(\\\"Target_raw: \\\", batch.trg_input)\\n # print(\\\"y0: \\\", prev_y)\\n \\n \\n \\n exp_list = []\\n # pylint: disable=unused-variable\\n for t in range(self.max_output_length):\\n if t != 0:\\n if self.state_type == 'hidden':\\n state = torch.cat(hidden, dim=2).squeeze(1).detach().cpu().numpy()[0]\\n else:\\n if t == 0:\\n state = hidden[0].squeeze(1).detach().cpu().numpy()[0]\\n else:\\n state = prev_att_vector.squeeze(1).detach().cpu().numpy()[0]\\n \\n \\n # decode one single step\\n logits, hidden, att_probs, prev_att_vector = self.model.decoder(\\n encoder_output=encoder_output,\\n encoder_hidden=encoder_hidden,\\n src_mask=batch.src_mask,\\n trg_embed=self.model.trg_embed(prev_y),\\n hidden=hidden,\\n prev_att_vector=prev_att_vector,\\n unroll_steps=1)\\n # logits: batch x time=1 x vocab (logits)\\n if t != 0:\\n if self.state_type == 'hidden':\\n state_ = torch.cat(hidden, dim=2).squeeze(1).detach().cpu().numpy()[0]\\n else:\\n state_ = prev_att_vector.squeeze(1).detach().cpu().numpy()[0]\\n \\n # if t == 0:\\n # print('states0: ', state, state_)\\n\\n # greedy decoding: choose arg max over vocabulary in each step with egreedy porbability\\n \\n if random.uniform(0, 1) < egreed:\\n i_ran = random.randint(0,beam_dqn-1)\\n next_word = torch.argsort(logits, descending=True)[:, :, i_ran]\\n else:\\n next_word = torch.argmax(logits, dim=-1) # batch x time=1\\n # if t != 0:\\n a = prev_y.squeeze(1).detach().cpu().numpy()[0]\\n #a = next_word.squeeze(1).detach().cpu().numpy()[0]\\n \\n # print(\\\"state \\\",t,\\\" : \\\", state )\\n # print(\\\"state_ \\\",t,\\\" : \\\", state_ )\\n # print(\\\"action \\\",t,\\\" : \\\", a )\\n # print(\\\"__________________________________________\\\")\\n\\n output.append(next_word.squeeze(1).detach().cpu().numpy())\\n\\n #tup = (self.memory_counter, state, a, state_)\\n \\n \\n prev_y = next_word\\n # check if previous symbol was <eos>\\n is_eos = torch.eq(next_word, self.eos_index)\\n finished += is_eos\\n if t != 0:\\n self.memory_counter += 1\\n tup = (self.memory_counter, state, a, state_, 1)\\n exp_list.append(tup)\\n \\n #print(t)\\n # stop predicting if <eos> reached for all elements in batch\\n if (finished >= 1).sum() == batch_size:\\n a = next_word.squeeze(1).detach().cpu().numpy()[0]\\n self.memory_counter += 1\\n #tup = (self.memory_counter, state_, a, np.zeros([self.state_size]) , is_eos[0,0])\\n tup = (self.memory_counter, state_, a, np.zeros([self.state_size]), 0)\\n exp_list.append(tup)\\n #print('break')\\n break\\n if t == self.max_output_length-1:\\n #print(\\\"reach the max output\\\")\\n a = 0\\n self.memory_counter += 1\\n #tup = (self.memory_counter, state_, a, np.zeros([self.state_size]) , is_eos[0,0])\\n tup = (self.memory_counter, state_, a, -1*np.ones([self.state_size]), 1)\\n exp_list.append(tup)\\n \\n \\n \\n \\n #Collecting rewards\\n hyp = np.stack(output, axis=1) # batch, time\\n\\n if epoch_no == 0:\\n if i_sample == 0 or i_sample == 3 or i_sample == 6:\\n #print(i_sample)\\n r = self.Reward(batch.trg, hyp, show=True) # 1 , time-1 \\n else:\\n r = self.Reward(batch.trg, hyp, show=False) # 1 , time -1 \\n else:\\n #print(\\\"aaaa - \\\",i_sample)\\n r = self.Reward(batch.trg, hyp, show=False) # 1 , time -1 \\n \\n # if i_sample == 0 or i_sample == 3 or i_sample == 6:\\n # print(\\\"\\\\n Sample Collected: \\\", i_sample, \\\"-------------Target vs Eval_net prediction:--Raw---and---Decoded-----\\\")\\n # print(\\\"Target: \\\", batch.trg, decoded_valid_out_trg)\\n # print(\\\"Eval : \\\", stacked_output, decoded_valid_out)\\n # print(\\\"Reward: \\\", r, \\\"\\\\n\\\")\\n \\n i_sample += 1\\n self.store_transition(exp_list, r)\\n \\n #Learning.....\\n if self.memory_counter > self.mem_cap - self.max_output_length:\\n self.learn()\\n \\n self.tb_writer.close()\",\n \"def train(self, batch):\\n pass\",\n \"def get_batch(batch_data, config):\\n N = len(batch_data['obs_traj_rel'])\\n P = config.P\\n OF = config.flow_size\\n T_in = config.obs_len\\n T_pred = config.pred_len\\n\\n returned_inputs = []\\n traj_obs_gt = np.zeros([N, T_in, P], dtype='float32')\\n traj_pred_gt = np.zeros([N, T_pred, P], dtype='float32')\\n # --- xy input\\n for i, (obs_data, pred_data) in enumerate(zip(batch_data['obs_traj_rel'],\\n batch_data['pred_traj_rel'])):\\n for j, xy in enumerate(obs_data):\\n traj_obs_gt[i, j, :] = xy\\n for j, xy in enumerate(pred_data):\\n traj_pred_gt[i, j, :] = xy\\n returned_inputs.append(traj_obs_gt)\\n # ------------------------------------------------------\\n # Social component (through optical flow)\\n if config.add_social:\\n obs_flow = np.zeros((N, T_in, OF),dtype ='float32')\\n # each batch\\n for i, flow_seq in enumerate(batch_data['obs_optical_flow']):\\n for j , flow_step in enumerate(flow_seq):\\n obs_flow[i,j,:] = flow_step\\n returned_inputs.append(obs_flow)\\n # -----------------------------------------------------------\\n # Person pose input\\n if config.add_kp:\\n obs_kp = np.zeros((N, T_in, KP, 2), dtype='float32')\\n # each bacth\\n for i, obs_kp_rel in enumerate(batch_data['obs_kp_rel']):\\n for j, obs_kp_step in enumerate(obs_kp_rel):\\n obs_kp[i, j, :, :] = obs_kp_step\\n return returned_inputs,traj_pred_gt\",\n \"def data_gen(voc_size, batch, nbatches, seq_len = 15):\\r\\n for i in range(nbatches):\\r\\n # (batch_size, seq_len)\\r\\n data = torch.from_numpy(\\r\\n np.random.randint(1, voc_size, size=(batch, seq_len)))\\r\\n data[:, 0] = 1 # add start token\\r\\n src = Variable(data, requires_grad=False)\\r\\n tgt = Variable(data, requires_grad=False)\\r\\n yield Batch(src, tgt, 0) # Accessed by next function one by one\\r\",\n \"def prepare_batches(self, pairs, batch_size):\\n\\t\\treturn MATHBatch.create_from_items(pairs, batch_size)\",\n \"def batch_generator(batch_size):\\n\\n # Infinite loop.\\n while True:\\n # Get a list of random indices for images in the training-set.\\n idx = np.random.randint(100,size=batch_size)\\n \\n # Get the pre-computed transfer-values for those images.\\n # These are the outputs of the pre-trained image-model.\\n transf_values = np.array([transfer_values[_] for _ in idx])\\n\\n # For each of the randomly chosen images there are\\n # at least 5 captions describing the contents of the image.\\n # Select one of those captions at random and get the\\n # associated sequence of integer-tokens.\\n tokens = [caps_markedwords[_] for _ in idx]\\n\\n # Count the number of tokens in all these token-sequences.\\n num_tokens = [len(t) for t in tokens]\\n \\n # Max number of tokens.\\n max_tokens = np.max(num_tokens)\\n # Pad all the other token-sequences with zeros\\n # so they all have the same length and can be\\n # input to the neural network as a numpy array.\\n tokens_padded = pad_sequences(tokens,\\n maxlen=max_tokens,\\n padding='post',\\n truncating='post')\\n \\n # Further prepare the token-sequences.\\n # The decoder-part of the neural network\\n # will try to map the token-sequences to\\n # themselves shifted one time-step.\\n decoder_input_data = tokens_padded[:, 0:-1]\\n decoder_output_data = tokens_padded[:, 1:]\\n\\n # Dict for the input-data. Because we have\\n # several inputs, we use a named dict to\\n # ensure that the data is assigned correctly.\\n x_data = \\\\\\n {\\n 'decoder_input': decoder_input_data,\\n 'transfer_values_input': transf_values\\n }\\n\\n\\n # Dict for the output-data.\\n y_data = \\\\\\n {\\n 'decoder_output': decoder_output_data\\n }\\n \\n yield (x_data, y_data)\",\n \"def update_mini_batch2_4(self, mini_batch, eta):\\r\\n nabla_b = [np.zeros(b.shape) for b in self.biases]\\r\\n nabla_w = [np.zeros(w.shape) for w in self.weights]\\r\\n #backup_b = [np.zeros(b.shape) for b in self.biases]\\r\\n backup_w = [np.zeros(w.shape) for w in self.weights]\\r\\n rand = [list(set([np.random.randint(0,y) for i in range(int(y/2))])) for y in self.sizes]\\r\\n \\r\\n\\r\\n for i in range(len(self.biases)):\\r\\n bi=self.biases[i]\\r\\n we = self.weights[i]\\r\\n ra = rand[i]\\r\\n ra2 = rand[i+1]\\r\\n #bab = backup_b[i]\\r\\n baw = backup_w[i]\\r\\n for j in range(len(ra)):\\r\\n for a in range(len(we)):\\r\\n baw[a][ra[j]]=we[a][ra[j]]\\r\\n we[a][ra[j]]=np.zeros(baw[a][ra[j]].shape)\\r\\n #for j in range(len(ra2)):\\r\\n #bab[ra2[j]]=bi[ra2[j]]\\r\\n #bi[ra2[j]]=np.zeros(bab[ra2[j]].shape)\\r\\n\\r\\n \\r\\n for x, y in mini_batch:\\r\\n delta_nabla_b, delta_nabla_w = self.backprop(x, y)\\r\\n #print('w')\\r\\n #print(delta_nabla_w)\\r\\n nabla_b = [nb+dnb for nb, dnb in zip(nabla_b, delta_nabla_b)]\\r\\n nabla_w = [nw+dnw for nw, dnw in zip(nabla_w, delta_nabla_w)]\\r\\n\\r\\n self.weights = [w-(eta/len(mini_batch))*nw\\r\\n for w, nw in zip(self.weights, nabla_w)]\\r\\n self.biases = [b-(eta/len(mini_batch))*nb\\r\\n for b, nb in zip(self.biases, nabla_b)]\\r\\n\\r\\n for i in range(len(self.biases)):\\r\\n bi=self.biases[i]\\r\\n we = self.weights[i]\\r\\n ra = rand[i]\\r\\n ra2 = rand[i+1]\\r\\n #bab = backup_b[i]\\r\\n baw = backup_w[i]\\r\\n\\r\\n for j in range(len(ra)):\\r\\n for a in range(len(we)):\\r\\n we[a][ra[j]]=baw[a][ra[j]]\\r\\n \\r\\n #for j in range(len(ra2)):\\r\\n #bi[ra2[j]]=bab[ra2[j]]\\r\",\n \"def batchGD(self, x, y, epochs):\\n print(\\\"Training using batch gradient descent\\\")\\n epoch = 0\\n #output training progress ten times in run\\n outputChunk = int ( epochs / 10 )\\n\\n while epoch <= epochs:\\n\\n #output progress? \\n if epoch % outputChunk is 0:\\n J = self.costFunction(x,y)\\n print(\\\"Epoch=\\\", epoch, \\\"J=\\\", J)\\n\\n #get analytic gradients \\n partial_J_w_ih, partial_J_w_ho, partial_J_b_h, partial_J_b_o = \\\\\\n self.deriv_costFunction( x, y )\\n #take a GD step\\n #To-do - implement variable learning rate\\n self.w_ih -= partial_J_w_ih\\n self.w_ho -= partial_J_w_ho\\n self.b_h -= partial_J_b_h\\n self.b_o -= partial_J_b_o\\n \\n epoch += 1\",\n \"def next_batch(memory_dim, batch_length, task):\\n batch_inputs = []\\n batch_targets = []\\n difficulty = 0.0\\n for _ in xrange(batch_length):\\n # Values as integers\\n random_input = task.generate_random_input(difficulty, memory_dim)\\n target_output = task.run(random_input)\\n\\n # Values as MxM memories\\n batch_inputs.append(values_to_distribution_memory(random_input))\\n batch_targets.append(values_to_distribution_memory(target_output))\\n\\n return batch_inputs, batch_targets\",\n \"def instantiate_batch(self, inputs):\\n return inputs\",\n \"def batchlearn(self, final_state=False):\\n # what to do anyway with finals states in batch learning ???\\n\\n TDe = self.estimate_TDioa() \\n self.actQoa += self.alpha * TDe\\n self.X = self.policy_func(self.actQoa)\\n \\n \\n print(\\\"\\\\r>> batchlearn at {}\\\".format(self.total_step), \\n end='', flush=True) if self.verbose else None\\n print() if self.verbose else None\\n print('actQ:\\\\n', self.actQoa) if self.verbose else None\\n print('TDe:\\\\n', TDe) if self.verbose else None\\n print() if self.verbose else None\\n\\n\\n #re-init\\n self.count_oa.fill(0)\\n self.count_oao.fill(0)\\n self.reward_oa.fill(0)\\n # self.valQoa = self.actQoa.copy() # may not be needed\\n self.batch_step = 0\",\n \"def new_generate_batch(batch_size, context_window):\\r\\n global positive_index\\r\\n global negative_index\\r\\n\\r\\n global positive_word_index\\r\\n global negative_word_index\\r\\n\\r\\n global positive_sentence\\r\\n global negative_sentence\\r\\n\\r\\n pos_loops, neg_loops = 0, 0\\r\\n context_size = 2 * context_window\\r\\n batch = np.ndarray(shape=(batch_size, context_size), dtype=np.int32)\\r\\n labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)\\r\\n sentiment_labels = np.ndarray(shape=(batch_size, 1), dtype=np.int32)\\r\\n\\r\\n batch_index = 0\\r\\n while batch_index < batch_size:\\r\\n # do positive index stuff\\r\\n if positive_word_index == len(positive_sentence):\\r\\n positive_index = (positive_index + 1) % len(positive_data)\\r\\n if (positive_index == 0):\\r\\n pos_loops += 1\\r\\n positive_word_index = 0\\r\\n positive_sentence = positive_data[positive_index]\\r\\n # do work\\r\\n labels[batch_index, 0] = positive_sentence[positive_word_index]\\r\\n\\r\\n batch_input = num_sen_to_input(positive_sentence, positive_word_index, context_window)\\r\\n for i2 in range(len(batch_input)):\\r\\n batch[batch_index, i2] = batch_input[i2]\\r\\n sentiment_labels[batch_index] = [1]\\r\\n\\r\\n positive_word_index += 1\\r\\n batch_index += 1\\r\\n\\r\\n if (batch_index) == batch_size // 2:\\r\\n break\\r\\n\\r\\n # TIME TO DO NEGATIVE\\r\\n while batch_index < batch_size:\\r\\n # do negative stuff\\r\\n if negative_word_index == len(negative_sentence):\\r\\n negative_index = (negative_index + 1) % len(negative_data)\\r\\n if (negative_index == 0):\\r\\n neg_loops += 1\\r\\n negative_word_index = 0\\r\\n negative_sentence = negative_data[negative_index]\\r\\n\\r\\n # do work\\r\\n labels[batch_index, 0] = negative_sentence[negative_word_index]\\r\\n\\r\\n batch_input = num_sen_to_input(negative_sentence, negative_word_index, context_window)\\r\\n for i2 in range(len(batch_input)):\\r\\n batch[batch_index, i2] = batch_input[i2]\\r\\n\\r\\n sentiment_labels[batch_index] = [0]\\r\\n\\r\\n negative_word_index += 1\\r\\n batch_index += 1\\r\\n if batch_index == batch_size:\\r\\n break\\r\\n\\r\\n zipped = zip(batch, labels, sentiment_labels)\\r\\n shuffled = []\\r\\n batch_, labels_, sl_ = [], [], []\\r\\n for i in zipped:\\r\\n shuffled.append(i)\\r\\n\\r\\n np.random.shuffle(shuffled)\\r\\n\\r\\n for j in shuffled:\\r\\n batch_.append(j[0])\\r\\n labels_.append(j[1])\\r\\n sl_.append(j[2])\\r\\n\\r\\n batch_ = np.array(batch_)\\r\\n labels_ = np.array(labels_)\\r\\n sl_ = np.array(sl_)\\r\\n\\r\\n return batch_, labels_, sl_, pos_loops, neg_loops\",\n \"def optimize(self, session, batch):\\n X_batch, y_batch = zip(*batch) # Unzip batch, each returned element is a tuple of lists\\n\\n if(self.FLAGS.augment):\\n X_batch = augment_batch(X_batch, self.FLAGS.img_H, self.FLAGS.img_W)\\n\\n input_feed = {}\\n\\n input_feed[self.X] = X_batch\\n input_feed[self.y] = y_batch\\n input_feed[self.is_training] = True\\n input_feed[self.learning_rate] = self.current_lr\\n\\n output_feed = []\\n\\n output_feed.append(self.train_op)\\n output_feed.append(self.loss)\\n output_feed.append(self.global_norm)\\n output_feed.append(self.global_step)\\n\\n\\n if self.FLAGS.tb is True:\\n output_feed.append(self.train_loss_tb)\\n output_feed.append(self.global_norm_tb)\\n output_feed.append(self.learning_rate_tb)\\n output_feed.append(self.y_out_stddev_tb)\\n output_feed.append(self.y_out_max_tb)\\n tr, loss, norm, step, train_tb, norm_tb, lr_tb, y_out_stddev_tb, y_out_max_tb = session.run(output_feed, input_feed)\\n self.tensorboard_writer.add_summary(train_tb, step)\\n self.tensorboard_writer.add_summary(norm_tb, step)\\n self.tensorboard_writer.add_summary(lr_tb, step)\\n self.tensorboard_writer.add_summary(y_out_stddev_tb, step)\\n self.tensorboard_writer.add_summary(y_out_max_tb, step)\\n else:\\n tr, loss, norm, step = session.run(output_feed, input_feed)\\n\\n return loss, norm, step\",\n \"def one_step_gd(self, batch):\\n\\n # get target values yj\\n targets = self.get_target(batch)\\n phi_input = np.vstack(batch[0])\\n masks = self.get_masks(batch[1])\\n dummy_targets = targets.max(axis=1)\\n\\n X = [phi_input, targets, masks]\\n Y = [dummy_targets, targets]\\n\\n # update main network with one step of gradient descent\\n # self.Qmodel.fit(X, Y, batch_size=len(X))\\n # pdb.set_trace()\\n metrics = self.train_model.train_on_batch(X, Y)\\n\\n # every fixed number of steps, update target network\\n self.c_count += 1\\n # print(self.c_count, self.c)\\n\\n if self.c_count == self.c:\\n # if self.verbose:\\n # print('* Target network updated')\\n\\n # update target network to be equal the main network\\n self.update_target_network()\\n\\n # reset counter\\n self.c_count = 0\\n\\n return metrics[0]\",\n \"def create_batch(batch, source, params, dv,\\n t_end=1.3e5, exclude=None, basename='xrb', walltime=96,\\n auto_t_end=True, notes='No notes given', nbursts=20, kgrid=None,\\n nuc_heat=True, setup_test=False,\\n auto_qnuc=False, grid_version=None, qnuc_source='heat',\\n substrate='fe54', substrate_off=True, adapnet_filename=None,\\n bdat_filename=None, params_full=None,\\n numerical_params=None, scratch_file_sys=False):\\n # TODO:\\n # - WRITE ALL PARAM DESCRIPTIONS\\n # - Overhaul/tidy up\\n # - use pd table instead of dicts of arrays\\n\\n print_batch(batch=batch)\\n source = grid_strings.source_shorthand(source=source)\\n mass_ref = 1.4 # reference NS mass (Msun)\\n radius_ref = 10 # default NS radius (km)\\n\\n specified = {'params': params,\\n 'dv': dv,\\n 'numerical_params': numerical_params}\\n\\n if specified['numerical_params'] is None:\\n specified['numerical_params'] = {}\\n\\n config = grid_tools.setup_config(specified=specified, source=source)\\n # TODO: print numerical_params being used\\n\\n if params_full is None:\\n params_expanded, var = expand_params(params=config['params'], dv=config['dv'])\\n params_full = exclude_params(params_expanded=params_expanded, exclude=exclude)\\n\\n n_models = len(params_full['x'])\\n\\n if kgrid is None:\\n print('No kgrid provided. Loading default:')\\n kgrid = grid_analyser.Kgrid(load_lc=False, linregress_burst_rate=True,\\n source=source)\\n\\n params_full['y'] = 1 - params_full['x'] - params_full['z'] # helium-4 values\\n params_full['geemult'] = params_full['mass'] / mass_ref # Gravity multiplier\\n\\n gravities = gravity.get_acceleration_newtonian(r=radius_ref,\\n m=params_full['mass']).value\\n params_full['radius'] = np.full(n_models, radius_ref)\\n params_full['gravity'] = gravities\\n\\n if auto_qnuc:\\n predict_qnuc(params_full=params_full, qnuc_source=qnuc_source,\\n grid_version=grid_version)\\n\\n # ===== Create top grid folder =====\\n batch_model_path = grid_strings.get_batch_models_path(batch, source)\\n grid_tools.try_mkdir(batch_model_path)\\n\\n # Directory to keep MonARCH logs and sbatch files\\n logpath = grid_strings.get_source_subdir(batch_model_path, 'logs')\\n grid_tools.try_mkdir(logpath)\\n\\n # ===== Write parameter table MODELS.txt and NOTES.txt=====\\n write_model_table(n=n_models, params=params_full, path=batch_model_path)\\n filepath = os.path.join(batch_model_path, 'NOTES.txt')\\n with open(filepath, 'w') as f:\\n f.write(notes)\\n\\n # ===== Write jobscripts for submission on clusters =====\\n print_dashes()\\n kepler_jobs.write_both_jobscripts(run0=1, run1=n_models, batch=batch,\\n source=source, basename=basename,\\n path=logpath, walltime=walltime,\\n adapnet_filename=adapnet_filename,\\n bdat_filename=bdat_filename,\\n scratch_file_sys=scratch_file_sys)\\n\\n # ===== Directories and templates for each model =====\\n for i in range(n_models):\\n # ==== Create directory tree ====\\n print_dashes()\\n model = i + 1\\n run_path = grid_strings.get_model_path(model, batch, source, basename=basename)\\n\\n # ==== Create task directory ====\\n grid_tools.try_mkdir(run_path)\\n\\n # ==== Write burn file, set initial composition ====\\n x0 = params_full['x'][i]\\n z0 = params_full['z'][i]\\n kepler_files.write_rpabg(x0, z0, run_path, substrate=substrate)\\n\\n # ==== Create model generator file ====\\n if auto_t_end:\\n mdot = params_full['accrate'][i] * params_full['acc_mult'][i]\\n rate_params = {}\\n for param in ('x', 'z', 'qb', 'mass'):\\n rate_params[param] = params_full[param][i]\\n fudge = 0.5 # extra time to ensure complete final burst\\n tdel = kgrid.predict_recurrence(accrate=mdot, params=rate_params)\\n t_end = (nbursts + fudge) * tdel\\n print(f'Using predicted dt={tdel/3600:.1f} hr')\\n if t_end < 0:\\n print('WARN! negative dt predicted. Defaulting n * 1.5hr')\\n t_end = nbursts * 1.5 * 3600\\n\\n run = i + 1\\n print(f'Writing genfile for xrb{run}')\\n header = f'This generator belongs to model: {source}_{batch}/{basename}{run}'\\n\\n accdepth = params_full['accdepth'][i]\\n if (params_full['x'][i] > 0.0) and (accdepth > 1e20):\\n print(f\\\"!!!WARNING!!!: accdepth of {accdepth:.0e} may be too deep for\\\" +\\n \\\" models accreting hydrogen\\\")\\n print(f'Using accdepth = {accdepth:.1e}')\\n\\n kepler_files.write_genfile(h1=params_full['x'][i], he4=params_full['y'][i],\\n n14=params_full['z'][i], qb=params_full['qb'][i],\\n acc_mult=params_full['acc_mult'][i],\\n qnuc=params_full['qnuc'][i],\\n geemult=params_full['geemult'][i],\\n accrate0=params_full['accrate'][i],\\n accmass=params_full['accmass'][i],\\n accdepth=params_full['accdepth'][i],\\n path=run_path, t_end=t_end, header=header,\\n nuc_heat=nuc_heat, setup_test=setup_test,\\n substrate_off=substrate_off,\\n numerical_params=config['numerical_params'])\",\n \"def batch_generator(batch_size, file, dataset, indices, labels=\\\"labels\\\"):\\n sample_size = len(indices)\\n n_batches = int(sample_size/batch_size)\\n h5f = h5py.File(file,'r')\\n instarget = Target('AAAAAA')\\n aa_to_int = instarget.predefining_dict()\\n while True: \\n for i in range(n_batches):\\n if i == n_batches:\\n batch_samples = h5f[dataset][i*batch_size:sample_size]\\n seqs_onehot = instarget.int_to_onehot(list(batch_samples), len(aa_to_int))\\n batch_y = h5f[labels][i*batch_size:sample_size]\\n else:\\n batch_samples = h5f[dataset][i*batch_size:i*batch_size+batch_size]\\n seqs_onehot = instarget.int_to_onehot(list(batch_samples), len(aa_to_int))\\n batch_y = h5f[labels][i*batch_size:i*batch_size+batch_size]\\n yield (seqs_onehot, batch_y)\",\n \"def forward(self, batch):\\n self.output = np.dot(np.array(batch), self.weights) + self.biases\",\n \"def _make_batches(self, n_batches: int) -> Iterable[Dict[Any, Any]]:\\n batch_iters = []\\n for problem in self.problems:\\n service = problem.problem_service\\n it = service.batch_iter(self.batch_size_per_problem, n_batches)\\n batch_iters.append(it)\\n combined = zip(*batch_iters)\\n # yield a complete feed dict\\n for combined_batch in combined:\\n assert len(combined_batch) == len(self.problems)\\n yield_val = {}\\n for problem, batch in zip(self.problems, combined_batch):\\n ph_obs_var, ph_q_values = self.obs_qv_inputs[problem.name]\\n obs_tensor, qv_tensor = to_local(batch)\\n yield_val[ph_obs_var] = obs_tensor\\n yield_val[ph_q_values] = qv_tensor\\n yield yield_val\",\n \"def gen_batch(self):\\n batch_size = self.batch_size\\n shuffle = self.shuffle\\n data = np.array(self.sentences)\\n\\n data_size = len(data)\\n num_batches_per_epoch = int((len(data) - 1) / batch_size) + 1\\n while True:\\n # shuffle the data at starting of each epoch\\n shuffled_data = data\\n if shuffle:\\n shuffle_indices = np.random.permutation(np.arange(data_size))\\n shuffled_data = data[shuffle_indices]\\n \\n for batch_num in range(num_batches_per_epoch):\\n start_index = batch_num * batch_size\\n end_index = min((batch_num + 1) * batch_size, data_size)\\n yield self._format_samples(shuffled_data[start_index:end_index], self.max_length)\\n\\n if self.mode in ['train', \\\"pred\\\"]:\\n break\",\n \"def bayes_model(feature_train, help_rank_train, model_name):\\n model = MultinomialNB()\\n model.fit(feature_train, help_rank_train)\\n modelpkl = open(model_name,'wb')\\n dump(model, modelpkl, -1)\\n return\",\n \"def batch_creator(batch_size, dataset_length, dataset_name):\\n # batch_size = 128\\n # dataset_length = 6000\\n batch_mask = rng.choice(dataset_length, batch_size)\\n\\n batch_x = eval('x_' + dataset_name)[[batch_mask]].reshape(-1, input_num_units)\\n batch_x = preproc(batch_x)\\n\\n if dataset_name == 'train':\\n batch_y = eval('y_' + dataset_name)[[batch_mask]]\\n batch_y = dense_to_one_hot(batch_y)\\n\\n return batch_x, batch_y\",\n \"def get_evaluate_batches(data_dir='/home/yunhan/batchified'):\\n # train 3 valid 1\\n # Use batch 1 - 53 as train (60%), 54 - 71 as validation (20%), 72 - 89 as test (20%)\\n n = 18\\n idx = np.random.permutation(n)\\n idx = idx + 54\\n for i in range(n):\\n X = np.load(\\\"%s/X%d.npy\\\" % (data_dir, idx[i]))/255.\\n Y = np.load(\\\"%s/y%d.npy\\\" % (data_dir, idx[i])).reshape(-1)\\n yield X, Y\",\n \"def get_batch(self) -> CBInput:\\n sample_batch_idx, batch_arms = self.gen_arms_per_batch()\\n context_arm_features = self.gen_features_batch(batch_idx=sample_batch_idx)\\n assert context_arm_features.ndim == 3\\n rewards_all_arms = self.features_to_rewards(\\n inp_feature=context_arm_features, sample_batch_idx=sample_batch_idx\\n )\\n batch = CBInput(\\n context_arm_features=context_arm_features,\\n arms=batch_arms, # ads of batch_size campaigns\\n rewards_all_arms=rewards_all_arms,\\n )\\n return batch\",\n \"def generate_samples(self, Nt, model=None, exe=0, ret_base ='binary'):\\n if Nt == 0:\\n print('Error: Nt must be greater than 0')\\n return\\n Nt = int(Nt)\\n\\n # establish an annealing factors array which contains all annealing related information to be sent to cpsl/ppsl\\n annealing_factors = np.asarray([self.beta, self.start_beta, self.end_beta, self.growth_factor])\\n\\n # jit requires specific input types\\n jit_beta = float64(self.beta)\\n jit_m = float64(self.m)\\n jit_J = np.ndarray.flatten(np.ndarray.astype(self.J, \\\"float64\\\"))\\n jit_h = np.ndarray.flatten(np.ndarray.astype(self.h, \\\"float64\\\"))\\n jit_Nm = np.int64(self.Nm)\\n jit_rand = np.random.uniform(-1, 1, Nt * self.Nm)\\n\\n\\n if model is None:\\n model = self.model\\n if model == \\\"cpsl\\\":\\n if exe == 0:\\n m_all = _cpsl(self.m, self.Nm, self.J, self.h, Nt, self.anneal, annealing_factors)\\n m_all = np.reshape(m_all, (Nt, self.Nm))\\n self.m = m_all[Nt - 1, :]\\n elif exe == 1:\\n m_all = _cpsl_fast(jit_m, jit_Nm, jit_J, jit_h, Nt, jit_rand, self.beta)\\n m_all = np.reshape(m_all, (Nt, self.Nm))\\n self.m = m_all[Nt - 1, :]\\n else:\\n # gpu requires sending variables\\n NmNtbeta = np.array([self.Nm, Nt, self.beta], dtype=np.int)\\n cpu_samples = np.zeros((Nt, self.Nm))\\n rand_vals = jit_rand\\n\\n gpu_NmNtbeta = cp.asarray(NmNtbeta)\\n gpu_samples = cp.asarray(cpu_samples)\\n gpu_J = cp.asarray(self.J)\\n gpu_h = cp.asarray(self.h)\\n gpu_m = cp.asarray(self.m)\\n gpu_rand_vals = cp.asarray(rand_vals)\\n\\n _cpsl_core_gpu(cpu_samples, gpu_samples, gpu_m, gpu_NmNtbeta, gpu_J, gpu_h, gpu_rand_vals)\\n m_all = cpu_samples\\n self.m = m_all[Nt - 1, :]\\n elif model == \\\"ppsl\\\":\\n if exe == 1 or exe == 0:\\n m_all = _ppsl_fast(jit_m, jit_Nm, jit_J, jit_h, jit_beta, Nt, self.dt, jit_rand)\\n m_all = np.reshape(m_all, (Nt, self.Nm))\\n self.m = m_all[Nt - 1, :]\\n else:\\n # gpu requires sending variables\\n\\n NmNtbeta = np.array([self.Nm, Nt, self.beta], dtype=np.int)\\n samples = np.zeros((Nt, self.Nm))\\n rand_vals = jit_rand\\n\\n gpu_NmNtbeta = cp.asarray(NmNtbeta)\\n gpu_samples = cp.asarray(samples)\\n gpu_J = cp.asarray(self.J)\\n gpu_h = cp.asarray(self.h)\\n gpu_m = cp.asarray(self.m)\\n gpu_rand_vals = cp.asarray(rand_vals)\\n _ppsl_core_gpu(samples, gpu_samples, gpu_m, gpu_NmNtbeta, gpu_J, gpu_h, gpu_rand_vals)\\n m_all = samples\\n self.m = m_all[Nt - 1, :]\\n else:\\n print(\\\"Error: unknown model\\\")\\n\\n if ret_base == 'samples' or ret_base == 'sample' or ret_base == 'b' or ret_base == 'binary' or ret_base == 2:\\n return m_all\\n elif ret_base == 'decimal' or ret_base == 'd' or ret_base == 'deci' or ret_base == 'decimals' or ret_base == 10:\\n return bi_arr2de(m_all)\",\n \"def _prepare_batch(self, batch):\\n try:\\n from torch_geometric.data import Batch\\n except:\\n raise ValueError(\\\"This class requires PyTorch Geometric to be installed.\\\")\\n\\n inputs, labels, weights = batch\\n pyg_graphs = [graph.to_pyg_graph() for graph in inputs[0]]\\n inputs = Batch.from_data_list(pyg_graphs)\\n _, labels, weights = super(GATModel, self)._prepare_batch(([], labels,\\n weights))\\n return inputs, labels, weights\",\n \"def generate(self, batch_size, s=\\\"train\\\"):\\n\\t\\twhile True:\\n\\t\\t\\tpairs = self.getBatch(batch_size)\\n\\t\\t\\tfeaturesX = self.getFeatures(pairs)\\n\\t\\t\\twordEmb = self.getWordEmbeddings(pairs)\\n\\t\\t\\tposEmb = self.getPosEmbeddings(pairs)\\n\\t\\t\\t#target = to_categorical(pairs['target'].values, num_classes=2)\\n\\t\\t\\tyield ([wordEmb, posEmb, featuresX])\",\n \"def generator(features, labels, batch_size):\\n \\n # Create empty arrays to contain batch of features and labels#\\n batch_features = np.zeros((batch_size, 160, 320, 3))\\n batch_labels = np.zeros((batch_size, 1))\\n while True:\\n for i in range(batch_size):\\n # choose random index in features\\n index = random.choice(range(len(features)))\\n batch_features[i] = features[index]\\n batch_labels[i] = labels[index]\\n yield batch_features, batch_labels\",\n \"def append(self, batch: Batch):\",\n \"def batch_generator(labels_df, set_kind):\\n # Generate training batches\\n if set_kind == \\\"train\\\" and (labels_df.shape[0] == 32384 or labels_df.shape[0] == 3120 or labels_df.shape[0] == 64):\\n while 1:\\n\\n for i in range(labels_df.shape[0]//8):\\n x_train = np.load('data/train-npy/npdatasetX{}.npy'.format(i))\\n y_train = np.load('data/train-npy/npdatasetY{}.npy'.format(i))\\n\\n for j in range(1):\\n x_trainj = x_train[j*8:j*8-1,:]\\n y_trainj = y_train[j*8:j*8-1,:]\\n\\n yield (x_trainj, y_trainj)\\n\\n\\n # Generate validation batches\\n if set_kind == \\\"valid\\\" and (labels_df.shape[0] == 8080 or labels_df.shape[0] == 1920 or labels_df.shape[0] == 8):\\n while 1:\\n\\n for i in range(labels_df.shape[0]//4): \\n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\\n y_valid = np.load('data/valid-npy/npdatasetY{}.npy'.format(i))\\n\\n for j in range(1): \\n x_validj = x_valid[j*4:j*4-1,:]\\n y_validj = y_valid[j*4:j*4-1,:]\\n\\n yield (x_validj, y_validj)\\n\\n\\n # Generate test batches\\n if set_kind == \\\"test\\\" and labels_df.shape[0] == 40669:\\n while 1:\\n\\n for i in range(labels_df.shape[0]//4): #REPLACE 1 by 3\\n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\\n\\n for j in range(1): #REPLACE 2 by 2816\\n x_validj = x_valid[j*4:j*4-1,:]\\n \\n yield (x_validj, y_validj)\\n\\n if set_kind == \\\"test\\\" and (labels_df.shape[0] == 8080 or labels_df.shape[0] == 8):\\n while 1:\\n\\n for i in range(labels_df.shape[0]//8): #REPLACE 1 by 3\\n x_valid = np.load('data/valid-npy/npdatasetX{}.npy'.format(i))\\n\\n for j in range(2): #REPLACE 2 by 2816\\n x_validj = x_valid[j*4:j*4-1,:]\\n\\n yield x_validj\",\n \"def train_batch(self, bs):\\n # image IDs\\n idx = torch.LongTensor(bs).random_(len(self.images))\\n\\n # select images / attributes\\n batch_x = normalize_images(self.images.index_select(0, idx).cuda())\\n batch_y = self.attributes.index_select(0, idx).cuda()\\n\\n # data augmentation\\n if self.v_flip and np.random.rand() <= 0.5:\\n batch_x = batch_x.index_select(2,\\n torch.arange(batch_x.size(2) - 1, -1, -1).long().cuda())\\n if self.h_flip and np.random.rand() <= 0.5:\\n batch_x = batch_x.index_select(3,\\n torch.arange(batch_x.size(3) - 1, -1, -1).long().cuda())\\n\\n return cuda_variable(batch_x), cuda_variable(batch_y)\",\n \"def train_batches(feature_matrix,y):\\r\\n X_org,y_org = shuffle(feature_matrix, y, random_state=13)\\r\\n \\r\\n # Splitting 20% of dataset to be test later\\r\\n X_train_org, X_test_org, y_train_org, y_test_org = train_test_split(X_org, y_org,test_size=0.20)\\r\\n X = X_train_org\\r\\n y = y_train_org\\r\\n \\r\\n \\r\\n for name, clf in classifiers:\\r\\n inc = Incremental(clf, scoring='accuracy')\\r\\n batch_size=5000\\r\\n counter=0\\r\\n train_acc = [] \\r\\n test_acc = []\\r\\n \\r\\n # Initializing Standard Scaler and IPCA for each classifier\\r\\n \\r\\n SS = StandardScaler()\\r\\n # IPCA = IncrementalPCA(n_components = 500)\\r\\n n=1\\r\\n print(\\\"Training \\\", name,\\\".......\\\\n\\\")\\r\\n for j in range(80):\\r\\n if counter >= len(X):\\r\\n break\\r\\n \\r\\n # Splitting each batch into training and validation datset\\r\\n X_train, X_test, y_train, y_test = train_test_split(X[counter:counter+batch_size], y[counter:counter+batch_size],test_size=0.25)\\r\\n print(\\\"Iteration:\\\",n)\\r\\n \\r\\n classes = da.unique(y_train).compute()\\r\\n \\r\\n # Feature Scaling\\r\\n SS.partial_fit(np.asarray(X_train))\\r\\n SS.transform(np.asarray(X_test))\\r\\n \\r\\n # Feature Decomposition\\r\\n # IPCA.partial_fit(X_train)\\r\\n # IPCA.transform(X_test)\\r\\n \\r\\n # Partial fitting - Stochastic Gradient Descent\\r\\n inc.partial_fit(X_train, y_train, classes=classes)\\r\\n print('Training Score:', inc.score(X_train, y_train))\\r\\n print('Validation Score:', inc.score(X_test, y_test))\\r\\n print(\\\"\\\\n\\\")\\r\\n \\r\\n # Concatenating batch scores\\r\\n train_acc.append(inc.score(X_train, y_train)) \\r\\n test_acc.append(inc.score(X_test, y_test)) \\r\\n \\r\\n if(len(X)-counter < batch_size):\\r\\n batch_size = len(X)-counter\\r\\n counter += batch_size\\r\\n n += 1\\r\\n \\r\\n \\r\\n # Savings the model\\r\\n filename = r'C:\\\\PythonCodes\\\\MM803\\\\code\\\\Outputs\\\\New\\\\f_canny_'+name+'.sav'\\r\\n pickle.dump(inc, open(filename, 'wb'))\\r\\n \\r\\n # Printing Model Accuracy\\r\\n print(name,\\\" MODEL ACCURACY\\\")\\r\\n print(\\\"_______________________\\\")\\r\\n print(\\\"Avg Training Accuracy of \\\", name,\\\":\\\", statistics.mean(train_acc)) \\r\\n print(\\\"Avg Test Accuracy \\\", name,\\\":\\\",statistics.mean(test_acc))\\r\\n \\r\\n \\r\\n # Testing on Unseen Data\\r\\n SS.transform(np.asarray(X_test_org[:5000]))\\r\\n # IPCA.transform(X_test_org[:5000])\\r\\n print('\\\\nFinal Testing Score on Unseen data 1 by ', name,':', inc.score(X_test_org[:10], y_test_org[:10]))\\r\\n print('Final Testing Score on Unseen data 2 by ', name,':', inc.score(X_test_org[10:100], y_test_org[10:100]))\\r\\n print('Final Testing Score on Unseen data 3 by ', name,':', inc.score(X_test_org[500:1000], y_test_org[500:1000]))\\r\\n \\r\\n print('\\\\n\\\\nClassification Report of', name)\\r\\n print('------------------------------------')\\r\\n print(classification_report(y_test_org[:5000],inc.predict(X_test_org[:5000]), digits = 4))\\r\\n print('====================================')\\r\\n print('\\\\n')\\r\\n \\r\\n # Saving the trained StandardScaler to be used for testing\\r\\n filename_ss = r'C:\\\\PythonCodes\\\\MM803\\\\code\\\\Outputs\\\\New\\\\f_canny_SS.sav'\\r\\n pickle.dump(SS, open(filename_ss, 'wb'))\\r\\n \\r\\n # Saving the trained Incremental PCA to be used for testing\\r\\n #filename_ipca = r'C:\\\\PythonCodes\\\\MM803\\\\code\\\\Outputs\\\\New\\\\f_hed_IPCA.sav'\\r\\n #pickle.dump(IPCA, open(filename_ipca, 'wb')) \\r\",\n \"def _fillBatches(self):\\n\\n batchRE = r\\\"\\\"\\\"\\n B\\n (?P<observebatch>\\\\d+?)\\n (?P<startend>[SE])\\n (?P<sequence>\\\\d+?)\\n _SR\\n (?:_(?P<extraInjections>\\\\d+?|\\\\w+?))?\\n $\\n \\\"\\\"\\\"\\n batchRE = re.compile(batchRE, re.VERBOSE)\\n # We canot infer batches unless we have runorder\\n if 'Run Order' in self.sampleMetadata.keys():\\n currentBatch = 0\\n # Loop over samples in run order\\n for index, row in self.sampleMetadata.sort_values(by='Run Order').iterrows():\\n nameComponents = batchRE.search(row['Sample File Name'])\\n if nameComponents:\\n # Batch start\\n if nameComponents.group('startend') == 'S':\\n # New batch - increment batch no\\n if nameComponents.group('sequence') == '1':\\n currentBatch = currentBatch + 1\\n\\n # Don't include the dilution series or blanks\\n if not ((row['AssayRole'] == AssayRole.LinearityReference) or (row['SampleType'] == SampleType.ProceduralBlank)):\\n self.sampleMetadata.loc[index, 'Batch'] = currentBatch\\n self.sampleMetadata.loc[index, 'Correction Batch'] = currentBatch\\n\\n else:\\n warnings.warn('Unable to infer batches without run order, skipping.')\\n return\",\n \"def bagxgb_train(X_train, y_train, size=10, write=False):\\n list_models = []\\n #d_train = lgb.Dataset(X_train, label=y_train)\\n with tqdm(total=size) as pbar:\\n for nb in range(size):\\n model = xgb.XGBClassifier(max_depth=7, min_child_weight=1, learning_rate=0.01, n_estimators=5000, gamma=0.8, subsample=0.95, colsample_bytree=0.6, reg_alpha=0.0025, objective='binary:logistic', nthread=4, scale_pos_weight=1,\\n seed=nb+1)\\n model.fit(X_train, y_train)\\n list_models.append(model)\\n pbar.update()\\n return list_models\",\n \"def run_batch_filter(self):\\n if self.speed_data is None and self.flow_data is None and self.traveltime_data is None:\\n print(\\n 'Warning: The measurement data must be set before running the batch filter: use function self.set_meas_data()')\\n\\n # =======================================================================\\n # the initial ensembles, which should have been set externally\\n X_init = np.matrix(np.zeros((self.dim_state, self.num_ensembles)))\\n print(\\n 'Setting initial ensembles: rho {0}; qin {1}; qout {2}'.format(self.init_rho, self.init_qin, self.init_qout))\\n for ens in range(0, self.num_ensembles):\\n X_init[self.x_index['density'][0]:\\n self.x_index['density'][self.num_cells - 1], ens] = self.init_rho\\n X_init[self.x_index['qin'], ens] = self.init_qin\\n X_init[self.x_index['qout'], ens] = self.init_qout\\n\\n # print('setted qin {0}; qout {1}'.format(X_init[self.x_index['qin'], ens], X_init[self.x_index['qout'], ens] ))\\n # add noise to each ensemble\\n X_init[:, ens] += np.matrix(np.random.multivariate_normal(\\n np.zeros(self.dim_state), self.Q)).reshape((self.dim_state, 1))\\n\\n self.set_initial_ensembles(X_init)\\n\\n # =======================================================================\\n # DEBUG\\n # save the qin and qout in the corresponding probe data\\n # save the initial state\\n if self.__debug:\\n self.qin_f.append(np.squeeze(np.array(self.X_f[self.x_index['qin'], :])).tolist())\\n self.qin_a.append(np.squeeze(np.array(self.X_a[self.x_index['qin'], :])).tolist())\\n self.qin_obs.append(np.nan)\\n\\n self.qout_f.append(np.squeeze(np.array(self.X_f[self.x_index['qout'], :])).tolist())\\n self.qout_a.append(np.squeeze(np.array(self.X_a[self.x_index['qout'], :])).tolist())\\n self.qout_obs.append(np.nan)\\n\\n # The enKF runs at the finest time grid\\n # for each step, update the system\\n for step in range(0, self.num_steps):\\n\\n # update status\\n sys.stdout.write('\\\\r')\\n sys.stdout.write('Status: filtering step {0}/{1}'.format(step, self.num_steps))\\n sys.stdout.flush()\\n # print('Status: filtering step {0}'.format(step))\\n\\n cur_time = (step + 1) * self.dur_steps\\n\\n # get the effective measurement\\n eff_flow, eff_speed, eff_traveltime = self.__get_eff_meas(cur_time)\\n\\n # build the observation index\\n self.y_index, self.dim_obs, y_obs, cov_noise = self.__build_obs_index(eff_flow, eff_speed, eff_traveltime)\\n\\n # update the estimate for this step\\n est_state = self.update_estimate(y_obs, cov_noise, cur_time)\\n\\n # =======================================================================\\n # DEBUG\\n # save the qin and qout in the corresponding probe data\\n # save the updated state\\n if self.__debug:\\n self.qin_f.append(np.squeeze(np.array(self.X_f[self.x_index['qin'], :])).tolist())\\n self.qin_a.append(np.squeeze(np.array(self.X_a[self.x_index['qin'], :])).tolist())\\n if 'flow' in self.y_index.keys() and self.__debug_entrance_sensor in self.y_index['flow'].keys():\\n self.qin_obs.append(y_obs[self.y_index['flow'][self.__debug_entrance_sensor]])\\n # print('y_index[flow]:{0}'.format(self.y_index['flow'].keys()))\\n # print('y_obs[ y_index[flow][entrance] ]:{0}'.format(\\n # y_obs[ self.y_index['flow'][self.__debug_entrance_sensor]],\\n # self.__debug_entrance_sensor))\\n else:\\n self.qin_obs.append(np.nan)\\n\\n self.qout_f.append(np.squeeze(np.array(self.X_f[self.x_index['qout'], :])).tolist())\\n self.qout_a.append(np.squeeze(np.array(self.X_a[self.x_index['qout'], :])).tolist())\\n if 'flow' in self.y_index.keys() and self.__debug_exit_sensor in self.y_index['flow'].keys():\\n self.qout_obs.append(y_obs[self.y_index['flow'][self.__debug_exit_sensor]])\\n else:\\n self.qout_obs.append(np.nan)\\n # =======================================================================\\n # save the estimated state\\n self.est_state_all[:, step] = est_state\\n\\n # decouple and save into self.est_density, self.est_speed, self.est_queue, self.est_traveltime\\n self.est_density[:, step] = est_state[0:self.num_cells, 0]\\n\\n # the speed is computed using the fundamental diagram\\n for cell_id in range(0, self.num_cells):\\n # use the static FD at this step\\n self.est_speed[cell_id, step] = self.__rho2v(self.vm_cells[cell_id, 0], self.beta_cells[cell_id, 0],\\n self.rhoc_cells[cell_id, 0], self.wc_cells[cell_id, 0],\\n self.est_density[cell_id, step])\\n\\n # REMARK: the queue and travel time a post-processed from the speed field.\\n # They are computed in cross_evaluation class for all algorithms\\n # the queue length starts from the first cell with speed below queue_threshold to the end of road\\n # index = (self.est_speed[:, step] <= self.queue_threshold)\\n #\\n # # filter out the outliers\\n # index_smoothed = deepcopy(index)\\n # outlier_max = 3\\n # counter = 0\\n # for i in range(0, len(index)):\\n #\\n # if index[i] == True:\\n # # trigger the coutner\\n # counter += 1\\n # elif index[i] == False and counter != 0:\\n # if counter <= outlier_max:\\n # # found outliers\\n # index_smoothed[ i-counter : i ] = False\\n # # reset counter\\n # counter = 0\\n #\\n # # if i != 0 and i != len(index)-1:\\n # # if sum( index[i-1:i+3] ) >=2:\\n # # index_smoothed[i] = True\\n # # else:\\n # # index_smoothed[i] = False\\n # # elif i == 0:\\n # # if sum(index[0: 5] ) >= 3:\\n # # index_smoothed[i] = True\\n # # else:\\n # # index_smoothed[i] = False\\n # # elif i == len(index)-1:\\n # # if sum(index[ i-4 :len(index)]) >= 3:\\n # # index_smoothed[i] = True\\n # # else:\\n # # index_smoothed[i] = False\\n #\\n # if sum(index_smoothed) <= 3: # use 4 to suppress false alarms\\n # # if less or equal then 2 cells are in congestion, it may be caused by noise.\\n # self.est_queue[step] = 0\\n # else:\\n # # if step > 105 and step < 115:\\n # # print(sum(index_smoothed))\\n # # print(index_smoothed)\\n # # print(index)\\n #\\n # self.est_queue[step] = \\\\\\n # self.len_cells*( self.num_cells - np.argmax(index_smoothed) )\\n # # try:\\n # # first_cong_cell_id = [x[0] for x in enumerate( self.est_speed[:,step] ) if x[1] < self.queue_threshold][0]\\n # # except IndexError:\\n # # # no congested cell\\n # # first_cong_cell_id = self.num_cells\\n # # # the estimated queue length\\n # # self.est_queue[step] = self.len_cells*( self.num_cells - first_cong_cell_id )\\n #\\n # # the travel time estimate is computed by summing up the travel time in each cell\\n # self.est_traveltime[step] = np.sum(self.len_cells/self.est_speed[:,step])\\n\\n\\n # =======================================================================\\n # DEBUG\\n # plot the update\\n if self.__debug:\\n plot_len = 19\\n # qin\\n if False:\\n if not np.isnan(self.qin_obs[-1]):\\n fig1 = plt.figure(figsize=(10, 5), dpi=100)\\n ax1 = fig1.add_subplot(111)\\n positions_f = np.arange(0, len(self.qin_f)) - 0.1\\n positions_a = np.arange(0, len(self.qin_a)) + 0.1\\n positions_obs = np.arange(0, len(self.qin_obs))\\n # predicted as red\\n bp = ax1.boxplot(self.qin_f[-plot_len:],\\n positions=positions_f[-plot_len:], widths=0.15,\\n patch_artist=False)\\n for box in bp['boxes']:\\n # change outline color\\n box.set(color='#FF4633', linewidth=1)\\n # change fill color\\n # box.set( facecolor = '#FF4633' )\\n # corrected as green\\n bp = ax1.boxplot(self.qin_a[-plot_len:],\\n positions=positions_a[-plot_len:], widths=0.15, patch_artist=False)\\n for box in bp['boxes']:\\n # change outline color\\n box.set(color='#07891B', linewidth=1)\\n # change fill color\\n # box.set( facecolor = '#07891B' )\\n # measurement as blue\\n ax1.scatter(positions_obs[-plot_len:], self.qin_obs[-plot_len:], color='b', marker='o', s=40,\\n label='Observation')\\n ax1.set_title('qin')\\n # x_ticks = np.arange(0, len(self.qin_f))\\n # ax1.set_xticks(x_ticks[-plot_len:])\\n plt.show()\\n\\n # qout\\n if False:\\n if not np.isnan(self.qout_obs[-1]):\\n fig2 = plt.figure(figsize=(10, 5), dpi=100)\\n ax2 = fig2.add_subplot(111)\\n positions_f = np.arange(0, len(self.qout_f)) - 0.1\\n positions_a = np.arange(0, len(self.qout_a)) + 0.1\\n positions_obs = np.arange(0, len(self.qout_obs))\\n # predicted as red\\n bp = ax2.boxplot(self.qout_f[-plot_len:], positions=positions_f[-plot_len:], widths=0.18,\\n patch_artist=True)\\n for box in bp['boxes']:\\n # change outline color\\n box.set(color='#7570b3', linewidth=1)\\n # change fill color\\n box.set(facecolor='#FF4633')\\n # corrected as green\\n bp = ax2.boxplot(self.qout_a[-plot_len:], positions=positions_a[-plot_len:], widths=0.18,\\n patch_artist=True)\\n for box in bp['boxes']:\\n # change outline color\\n box.set(color='#7570b3', linewidth=1)\\n # change fill color\\n box.set(facecolor='#07891B')\\n # measurement as blue\\n ax2.scatter(positions_obs[-plot_len:], self.qout_obs[-plot_len:], color='b', marker='o', s=30,\\n label='Observation')\\n ax2.set_title('qout')\\n # x_ticks = np.arange(0, len(self.qout_f))\\n # ax2.set_xticks(x_ticks[-plot_len:])\\n\\n plt.show()\\n\\n # plot the estimated qin and qout\\n if self.__debug:\\n if True:\\n qin = np.squeeze(np.array(self.est_state_all[self.x_index['qin'], :]))\\n qin_meas = np.array(self.qin_obs)[1:]\\n print(len(qin), len(qin_meas))\\n fig1 = plt.figure(figsize=(10, 5), dpi=100)\\n ax1 = fig1.add_subplot(111)\\n t = np.arange(len(qin))\\n ax1.plot(t, qin, 'r-', label='Estimated')\\n not_nan = ~np.isnan(qin_meas)\\n ax1.plot(t[not_nan], qin_meas[not_nan], 'b', label='Measured')\\n ax1.legend()\\n ax1.grid(True)\\n ax1.set_title('qin')\\n\\n plt.draw()\\n\\n if True:\\n qout = np.squeeze(np.array(self.est_state_all[self.x_index['qout'], :]))\\n qout_meas = np.array(self.qout_obs)[1:]\\n fig2 = plt.figure(figsize=(10, 5), dpi=100)\\n ax2 = fig2.add_subplot(111)\\n t = np.arange(len(qout))\\n ax2.plot(t, qout, 'r-', label='Estimated')\\n not_nan = ~np.isnan(qout_meas)\\n ax2.plot(t[not_nan], qout_meas[not_nan], 'b', label='Measured')\\n ax2.set_title('qout')\\n ax2.legend()\\n ax2.grid(True)\\n plt.draw()\",\n \"def batch_anneal(self, times=10):\\n for i in range(1, times + 1):\\n print(f\\\"Iteration {i}/{times} -------------------------------\\\")\\n self.T = self.T_save\\n self.iteration = 1\\n self.cur_solution, self.cur_fitness = self.initial_solution()\\n self.anneal()\",\n \"def data_gen(\\n v: int, batch: int, nbatches: int, device: torch.device = torch.device(\\\"cpu\\\")\\n) -> Iterator[Batch]: # TODO bad name\\n for i in range(nbatches):\\n data = np.random.randint(1, v, size=(batch, 10))\\n data[:, 0] = 1\\n src: LongTensorType = torch.from_numpy(data)\\n tgt: LongTensorType = torch.from_numpy(data)\\n src, tgt = src.to(device), tgt.to(device)\\n yield Batch(src, tgt, 0)\",\n \"def generate_batch(self, cfactor, nsamples, terminals=True):\\n weights = defaultdict(lambda: 1.0)\\n return [self._generate(cfactor,'S',weights, terms=terminals) for _ in range(nsamples)]\",\n \"def build_naive_bayes():\\n nb_pipeline = None\\n ##### Write code here\\n nb_pipeline = Pipeline([\\n ('vect', CountVectorizer()),\\n ('clf', ComplementNB())\\n ])\\n\\n ##### End of your work ######\\n return nb_pipeline\",\n \"def next_batch(self, batch_size):\\n raise NotImplementedError\",\n \"def batch_sample_beta(self):\\n c_contexts = self.context[self.iter]\\n\\n old_beta = self.beta[self.iter]\\n new_beta = -1\\n proposal_sd = .1\\n while new_beta <= 0:\\n new_beta = random.gauss(mu = old_beta, sigma = proposal_sd)\\n \\n # set up to calculate the g densities for both the old and new beta values\\n log_g_old = -1 * old_beta # which is np.log(np.exp(-1 * old_beta))\\n log_g_new = -1 * new_beta # similar as above\\n\\n # derive contexts from breakpoints arrangement\\n context_dict = self.make_context_dict(c_contexts)\\n for context in context_dict.keys():\\n log_g_old += math.lgamma(self.support_size * old_beta) \\\\\\n - math.lgamma(self.support_size * old_beta + len(context_dict[context]))\\n log_g_new += math.lgamma(self.support_size * new_beta) \\\\\\n - math.lgamma(self.support_size * new_beta + len(context_dict[context]))\\n \\n for y in self.support:\\n log_g_old += math.lgamma(context_dict[context].count(y) + old_beta) - math.lgamma(old_beta)\\n log_g_new += math.lgamma(context_dict[context].count(y) + new_beta) - math.lgamma(new_beta)\\n\\n # compute candidate densities q for old and new beta\\n # since the proposal distribution is normal this step is not needed\\n log_q_old = 0#np.log(dnorm(old_beta, loc = new_beta, scale = proposal_sd))\\n log_q_new = 0#np.log(dnorm(new_beta, loc = old_beta, scale = proposal_sd)) \\n \\n # compute the moving probability\\n moving_prob = min(1, np.exp((log_g_new + log_q_old) - (log_g_old + log_q_new)))\\n \\n u = random.uniform(0,1)\\n if u < moving_prob: self.beta[self.iter] = new_beta\\n return self.beta[self.iter]\",\n \"def add_batch(self, batch):\\n x, e, f = batch\\n\\n if self.is_empty:\\n self.x = x\\n self.e = e\\n self.f = f\\n\\n else:\\n self.x = ch.cat([self.x, x], dim=0)\\n self.e = ch.cat([self.e, e], dim=0)\\n self.f = ch.cat([self.f, f], dim=0)\",\n \"def run_batch(self, batch_x, batch_y):\\n raise NotImplementedError()\",\n \"def batch(self, coeff_count=13, db=False):\\n mfccs, _ = self.mfcc(coeff_count)\\n if db:\\n mfccs = utils.dbspec(mfccs)\\n delta1, delta2 = self.delta_coeffs(mfccs)\\n self._annotate(mfccs)\\n\\n mfccs_len = mfccs.shape[1]\\n batch_x = np.concatenate((mfccs, delta1, delta2), axis=0).transpose()\\n batch_y = np.array(self.annotated_samples)\\n print(\\\"AudioClip--Generated Batch\\\")\\n return (batch_x, batch_y)\",\n \"def extract_batch(self, T_idxs, B_idxs):\\n s = self.samples\\n target_T_idxs = (T_idxs + self.n_step_return) % self.T\\n hyper_steps = np.random.randint(1, self.hyper_steps)\\n hyper_idxs = (T_idxs + hyper_steps) % self.T\\n batch = SamplesFromReplay(\\n agent_inputs=AgentInputs(\\n observation=self.extract_observation(T_idxs, B_idxs),\\n prev_action=s.action[T_idxs - 1, B_idxs],\\n prev_reward=s.reward[T_idxs - 1, B_idxs],\\n ),\\n action=s.action[T_idxs, B_idxs],\\n return_=self.samples_return_[T_idxs, B_idxs],\\n done=self.samples.done[T_idxs, B_idxs],\\n done_n=self.samples_done_n[T_idxs, B_idxs],\\n target_inputs=AgentInputs(\\n observation=self.extract_observation(target_T_idxs, B_idxs),\\n prev_action=s.action[target_T_idxs - 1, B_idxs],\\n prev_reward=s.reward[target_T_idxs - 1, B_idxs],\\n ),\\n hyper_observation=self.extract_observation(hyper_idxs, B_idxs),\\n hyper_done=self.extract_done(T_idxs, B_idxs, self.hyper_steps),\\n )\\n t_news = np.where(s.done[T_idxs - 1, B_idxs])[0]\\n batch.agent_inputs.prev_action[t_news] = 0\\n batch.agent_inputs.prev_reward[t_news] = 0\\n return torchify_buffer(batch)\",\n \"def _gibbs_sampling_iteration(self):\\n for m, dm in enumerate(self.corpus):\\n for n, w_mn in enumerate(dm):\\n k = self.z_mn[m, n]\\n self.n_mk[m, k] -= 1\\n self.n_m[m] -= 1\\n self.n_kt[k, w_mn] -= 1\\n self.n_k[k] -= 1\\n k = self._conditional_z(\\n self.n_components, self.alpha, self.beta,\\n self.n_mk, self.n_kt, m, w_mn, self.beta_sum, self.n_k)\\n self.z_mn[m, n] = k\\n self.n_mk[m, k] += 1\\n self.n_m[m] += 1\\n self.n_kt[k, w_mn] += 1\\n self.n_k[k] += 1\",\n \"def gen_batch_function(data_folder, image_shape):\\n def get_batches_fn(batch_size):\\n \\\"\\\"\\\"\\n Create batches of training data\\n :param batch_size: Batch Size\\n :return: Batches of training data\\n \\\"\\\"\\\"\\n image_paths = glob(os.path.join(data_folder, 'image_2', '*.png'))\\n label_paths = {\\n re.sub(r'_(lane|road)_', '_', os.path.basename(path)): path\\n for path in glob(os.path.join(data_folder, 'gt_image_2', '*_road_*.png'))}\\n background_color = np.array([255, 0, 0])\\n other_road_color = np.array([0,0,0])\\n random.shuffle(image_paths)\\n for batch_i in range(0, len(image_paths), batch_size):\\n images = []\\n gt_images = []\\n for image_file in image_paths[batch_i:batch_i+batch_size]:\\n gt_image_file = label_paths[os.path.basename(image_file)]\\n\\n image = scipy.misc.imresize(scipy.misc.imread(image_file), image_shape)\\n image_flip = np.flip(image, axis=1)\\n \\n gt_image = scipy.misc.imresize(scipy.misc.imread(gt_image_file), image_shape)\\n gt_image_flip = np.flip(gt_image, axis=1)\\n \\n #---------- classification : single road---------------------\\n #gt_bg = np.all(gt_image == background_color, axis=2)\\n #gt_bg = gt_bg.reshape(*gt_bg.shape, 1)\\n #gt_image = np.concatenate((gt_bg, np.invert(gt_bg)), axis=2)\\n #------------------------------------------------------------\\n \\n \\n #---------- classification : multi road----------------------\\n gt_bg = np.all(gt_image == background_color, axis=2)\\n gt_bg_flip = np.all(gt_image_flip == background_color, axis=2)\\n \\n # road segment\\n road_mask = ((gt_image == other_road_color) | (gt_image == background_color))\\n gt_road = np.invert(np.all(road_mask, axis=2))\\n \\n # flip of road segment\\n road_mask_flip = ((gt_image_flip == other_road_color) | (gt_image_flip == background_color))\\n gt_road_flip = np.invert(np.all(road_mask_flip, axis=2))\\n \\n # other_road segment\\n oher_road_mask = (gt_image == other_road_color)\\n gt_other_road = np.all(oher_road_mask, axis=2)\\n \\n # flip of other_road segment\\n other_road_mask_flip = (gt_image_flip == other_road_color)\\n gt_oher_road_flip = np.all(other_road_mask_flip, axis=2)\\n\\n # reshaping segments\\n gt_bg = gt_bg.reshape(*gt_bg.shape, 1)\\n gt_other_road = gt_other_road.reshape(*gt_other_road.shape, 1)\\n gt_road = gt_road.reshape(*gt_road.shape, 1)\\n \\n # reshaping flip segments\\n gt_bg_flip = gt_bg_flip.reshape(*gt_bg_flip.shape, 1)\\n gt_oher_road_flip = gt_oher_road_flip.reshape(*gt_oher_road_flip.shape, 1)\\n gt_road_flip = gt_road_flip.reshape(*gt_road_flip.shape, 1)\\n \\n # concatenating classes bg, road, other_road\\n gt_image = np.concatenate((gt_bg, gt_road, gt_other_road), axis=2)\\n gt_image_flip = np.concatenate((gt_bg_flip, gt_road_flip, gt_oher_road_flip), axis=2)\\n \\n images.append(image)\\n images.append(image_flip)\\n \\n gt_images.append(gt_image)\\n gt_images.append(gt_image_flip)\\n\\n yield np.array(images), np.array(gt_images)\\n return get_batches_fn\",\n \"def eval_batch(self, outputs, target):\\n raise NotImplementedError\",\n \"def main():\\n args = get_arguments()\\n print(args.batch_size)\",\n \"def batch_iter(input_data,batch_size):\\r\\n batch_ids,batch_mask,batch_segment,batch_label=[],[],[],[]\\r\\n for features in input_data:\\r\\n if len(batch_ids) == batch_size:\\r\\n yield batch_ids,batch_mask,batch_segment,batch_label\\r\\n batch_ids, batch_mask, batch_segment, batch_label = [], [], [], []\\r\\n\\r\\n batch_ids.append(features['input_ids'])\\r\\n batch_mask.append(features['input_mask'])\\r\\n batch_segment.append(features['segment_ids'])\\r\\n batch_label.append(features['label_ids'])\\r\\n\\r\\n if len(batch_ids) != 0:\\r\\n yield batch_ids, batch_mask, batch_segment, batch_label\",\n \"def train(self, X, y, batch_size=5, num_epochs=10, alpha=0.1, gamma=0.9, learning=\\\"Delta\\\"):\\n rem = int(np.ceil(len(X[0])/batch_size))\\n for epoch in range(num_epochs):\\n art = 0;\\n for sample in range(rem):\\n end = art + batch_size\\n\\n # Get a sample (column from X and Y) where the size of the sample is given by the batch size\\n sampleX = X[:, art : end]\\n sampleY = y[:, art : end]\\n #print (sampleX)\\n\\n # Get the prediction\\n results = self.predict(sampleX)\\n art += batch_size\\n\\n if learning == \\\"Delta\\\" or learning == \\\"delta\\\":\\n # Calculate e\\n e = np.subtract(sampleY, results)\\n\\n # Calculate e dot p, where p is the input matrix\\n ep = np.dot(e, np.transpose(sampleX))\\n\\n # Multiply this new matrix by the scalar alpha\\n aep = np.multiply(alpha, ep)\\n\\n # Calculate the new weights along with the bias\\n self.weights = np.add(self.weights, aep)\\n \\n elif learning == \\\"Filtered\\\" or learning == \\\"filtered\\\":\\n\\n # Calculate e dot p, where p is the input matrix\\n ep = np.dot(sampleY, np.transpose(sampleX))\\n\\n # Multiply this new matrix by the scalar alpha\\n aep = np.multiply(alpha, ep)\\n\\n # Multiply the old weights by some scalar gamma\\n gw = np.multiply(1 - gamma, self.weights)\\n\\n self.weights = np.add(gw, aep)\\n\\n elif learning == \\\"Unsupervised_hebb\\\" or learning == \\\"unsupervised_hebb\\\":\\n # Add a row of one's to the top of the input matrix\\n #newX = np.vstack((np.array([1 for column in range(sampleX.shape[1])]), sampleX))\\n\\n # Calculate e dot p, where p is the input matrix\\n ep = np.dot(results, np.transpose(sampleX))\\n\\n # Multiply this new matrix by the scalar alpha\\n aep = np.multiply(alpha, ep)\\n\\n # Calculate the new weights along with the bias\\n self.weights = np.add(self.weights, aep)\",\n \"def _get_batch(self, index_array):\\n # The transformation of images is not under thread lock\\n # so it can be done in parallel\\n batch_x = np.zeros((len(index_array),) + self.target_size,\\n dtype=np.float32)\\n batch_x = np.expand_dims(batch_x, axis=-1)\\n # build batch of image data\\n for i, j in enumerate(index_array):\\n batch_x[i] = self.data[j]\\n\\n\\n self.classes = np.asarray(self.classes, dtype=np.float32)\\n # build batch of labels\\n if self.class_mode == 'input':\\n batch_y = batch_x.copy()\\n elif self.class_mode == 'sparse':\\n batch_y = self.classes[index_array]\\n elif self.class_mode == 'binary':\\n batch_y = self.classes[index_array]\\n elif self.class_mode == 'categorical':\\n batch_y = np.zeros((len(batch_x), self.num_classes),\\n dtype=np.float32)\\n for i, label in enumerate(self.classes[index_array]):\\n\\n batch_y[i, int(label)] = 1.\\n else:\\n return batch_x\\n\\n return batch_x, batch_y\",\n \"def _get_batch(self,\\n X_train, \\n Y_train):\\n\\n raw_data_length = len(X_train)\\n\\n # partition raw data into batches and stack them vertically in a data matrix\\n batch_partition_length = raw_data_length // self.model_parameters.batch_size\\n data_x = np.zeros([self.model_parameters.batch_size, \\n batch_partition_length, \\n self.model_parameters.input_dimension], \\n dtype=np.float32)\\n\\n data_y = np.zeros([self.model_parameters.batch_size, \\n batch_partition_length, \\n self.model_parameters.n_classes], \\n dtype=np.float32)\\n #data_y = np.zeros([batch_size, n_classes], dtype=np.int32)\\n \\n for i in range(self.model_parameters.batch_size):\\n data_x[i] = X_train[batch_partition_length * i:batch_partition_length * (i + 1), :]\\n data_y[i] = Y_train[batch_partition_length * i:batch_partition_length * (i + 1),:]\\n \\n # further divide batch partitions into sequence_length for truncated backprop\\n epoch_size = batch_partition_length // self.model_parameters.sequence_length\\n\\n for i in range(epoch_size):\\n x = data_x[:, i * self.model_parameters.sequence_length:(i + 1) * self.model_parameters.sequence_length,:]\\n y = data_y[:, i * self.model_parameters.sequence_length:(i + 1) * self.model_parameters.sequence_length,:]\\n yield (x, y)\",\n \"def process_state_batch(self, batch):\\n # batch = np.squeeze(batch, axis=1)\\n batch = np.array([np.concatenate(obs, axis=-1) for obs in batch])\\n return batch\",\n \"def _batch(self, X, y, batch_size=16):\\n X, y = self._shuffle(X, y) # shuffle the data\\n self.batches = []\\n idx = 0\\n while idx < len(X):\\n batch = (X[idx:idx+batch_size], y[idx:idx+batch_size])\\n self.batches.append(batch)\\n idx += batch_size\",\n \"def generate_batch(self, batch_size, rand=None, *args, **kwargs):\\n return [\\n self.generate_datasets(rand, *args, **kwargs) for _ in range(batch_size)\\n ]\",\n \"def bellman(self, batch_size, gamma = 0.9):\\n\\n d_batch = random.sample(self.D, batch_size)\\n\\n inputs = np.zeros((batch_size, self.phi_len, ) \\n + self.env.observation_space.shape)\\n targets = np.zeros((batch_size, self.model.output_shape[1]))\\n\\n for i, (state, action, reward, state_new, done) in enumerate(d_batch):\\n\\n inputs[i] = state\\n targets[i] = self.model.predict(np.expand_dims(state, axis = 0))\\n\\n if done:\\n targets[i, action] = reward\\n else:\\n targets[i, action] = (reward \\n + gamma \\n * np.amax(self.model.predict(\\n np.expand_dims(state_new, axis = 0))))\\n\\n return inputs, targets\",\n \"def generate(self):\\n self.training_data.gen_x(self.x_func)\\n self.training_data.gen_a(self.a_func)\\n self.training_data.gen_y(self.y_func)\\n \\n self.testing_data.gen_x(self.x_func)\\n self.testing_data.gen_ys(self.y_func)\\n self.testing_data.gen_azero(self.ytotal_func)\",\n \"def train_next_batch(self, batch_size=None):\",\n \"def get_batches(self, batch_size):\\n if self.data.shape[0] % batch_size != 0:\\n raise RuntimeError('num of data tuples is not a multiple of batch size')\\n num_batch = self.data.shape[0] // batch_size\\n for b in range(num_batch):\\n yield self.data[b*batch_size:(b+1)*batch_size, :], \\\\\\n self.target[b*batch_size:(b+1)*batch_size, :]\",\n \"def _prepare_batch(self, batch):\\n try:\\n import dgl\\n except:\\n raise ImportError('This class requires dgl.')\\n\\n inputs, labels, weights = batch\\n dgl_graphs = [\\n graph.to_dgl_graph(self_loop=self._self_loop) for graph in inputs[0]\\n ]\\n inputs = dgl.batch(dgl_graphs).to(self.device)\\n _, labels, weights = super(MPNNModel, self)._prepare_batch(\\n ([], labels, weights))\\n return inputs, labels, weights\",\n \"def train_step(self, batch: dict, epoch: int):\\n\\n with torch.cuda.amp.autocast(self.mixed_precision):\\n \\n # Update momentum {key, pseudo} networks\\n with torch.no_grad():\\n self._momentum_update_key_net()\\n self._momentum_update_pseudo_net()\\n\\n # Get data (3 views)\\n x_q = batch['x1'].to(self.local_rank)\\n x_k = batch['x2'].to(self.local_rank)\\n x_ps = batch['x3'].to(self.local_rank)\\n \\n # Compute strong query features; (B, f)\\n z_q = F.normalize(self.net_q(x_q), dim=1)\\n\\n with torch.no_grad():\\n \\n # Shuffle across nodes (gpus)\\n x_k, idx_unshuffle_k = ForMoCo.batch_shuffle_ddp(x_k)\\n x_ps, idx_unshuffle_ps = ForMoCo.batch_shuffle_ddp(x_ps)\\n \\n # Compute {key, pseudo} features; (B, f)\\n z_k = F.normalize(self.net_k(x_k), dim=1)\\n z_ps = F.normalize(self.net_ps(x_ps), dim=1)\\n \\n # Restore {key, pseudo} features to their original nodes\\n z_k = ForMoCo.batch_unshuffle_ddp(z_k, idx_unshuffle_k)\\n z_ps = ForMoCo.batch_unshuffle_ddp(z_ps, idx_unshuffle_ps)\\n\\n # Compute loss\\n loss, logits, labels, loss_pseudo, probs_pseudo_neg = \\\\\\n self.loss_function(z_q, z_ps, z_k, self.queue.buffer, threshold=self.threshold)\\n \\n # Backpropagate & update\\n if loss_pseudo.isnan() or (epoch <= self.ramp_up):\\n self.backprop(loss)\\n else:\\n alpha = 1.0\\n self.backprop(loss + alpha * loss_pseudo)\\n \\n # Compute metrics\\n with torch.no_grad():\\n \\n # Accuracy of true positives against all negatives\\n rank_1 = TopKAccuracy(k=1)(logits, labels)\\n \\n # Accuracy of pseudo positives with ground truth labels\\n above_threshold = probs_pseudo_neg.ge(self.threshold)\\n num_pseudo = above_threshold.sum()\\n \\n # No pseudo positives may have been selected\\n if self.queue.is_reliable and (num_pseudo > 0):\\n labels_query = batch['y'].to(self.local_rank) # (B, )\\n labels_queue = self.queue.labels # (k, )\\n is_correct = labels_query.view(-1, 1).eq(labels_queue.view(1, -1)) # (B, 1) @ (1, k) -> (B, k)\\n num_correct = is_correct.masked_select(above_threshold).sum()\\n precision = torch.true_divide(num_correct, num_pseudo)\\n else:\\n num_correct = torch.zeros(1, dtype=torch.long, device=num_pseudo.device)\\n precision = torch.zeros(1, dtype=torch.float32, device=num_pseudo.device)\\n \\n # Update memory queue\\n self.queue.update(keys=z_k, labels=batch['y'].to(self.local_rank))\\n\\n return {\\n 'loss': loss.detach(),\\n 'loss_pseudo': loss_pseudo.detach(), # (1, ) or tensor(nan)\\n 'rank@1': rank_1,\\n 'num_correct': num_correct,\\n 'num_pseudo': num_pseudo,\\n 'precision': precision,\\n }\",\n \"def gen_batch(batch_size,\\n num_voters,\\n num_alternatives,\\n voter_experience='default',\\n max_experience=50,\\n pull_variance=100.,\\n count_noise=0.,\\n random_count_prob=0.):\\n gt = lambda: gen_trial(num_voters, num_alternatives, voter_experience, max_experience, pull_variance, count_noise, random_count_prob)\\n arm_means, c, _, rankings = list(zip(*[gt() for _ in range(batch_size)]))\\n return torch.tensor(arm_means).float(), torch.tensor(c).float(), torch.tensor(rankings).float()\",\n \"def train_minibatches(self):\\n batch_size = self.params['batch_size']\\n start_index = 0\\n while start_index + batch_size < 500:\\n end_index = start_index + batch_size\\n yield self.input[start_index:end_index], self.y[start_index:end_index]\\n start_index = end_index\",\n \"def batch_generate(self, text, mel_target):\\n mel_in = torch.zeros(1,80,1).to(self.device)\\n for i in range(mel_target.shape[2]):\\n # forward pass\\n y, ylogit, a = self.generate(text, mel_in)\\n # create new mel_in\\n mel_in = torch.cat((mel_in, y[:,:,-1].view(1,80,1)), dim=-1)\\n\\n # compute L1 loss to target and return target and prediction\\n loss = F.l1_loss(y, mel_target)\\n return loss, y, a\",\n \"def generate(self, batch_size, s=\\\"train\\\"):\\n while True:\\n pairs, targets = self.get_batch(batch_size,s)\\n yield (pairs, targets)\",\n \"def backprop_batch(self, xs, ys):\\n nabla_b = [cp.zeros(b.shape) for b in self.biases]\\n nabla_w = [cp.zeros(w.shape) for w in self.weights]\\n\\n # forward pass\\n activation = xs\\n activations = [xs] # list to store all the activations, layer by layer\\n zs = [] # list to store all the z vectors, layer by layer\\n for b, w in zip(self.biases, self.weights):\\n zs.append(w @ activation + b)\\n activation = sigmoid(zs[-1])\\n activations.append(activation)\\n\\n # backward pass\\n delta = self.cost_derivative(activations[-1], ys) * f_sigmoid_prime(activations[-1])\\n nabla_w[-1] = delta @ activations[-2].transpose((0, 2, 1))\\n nabla_b[-1] = delta\\n for t in range(self.num_layers - 2, 0, -1):\\n delta = f_sigmoid_prime(activations[t]) * (self.weights[t].T @ delta)\\n nabla_w[t - 1] = delta @ activations[t - 1].transpose((0, 2, 1))\\n nabla_b[t - 1] = delta\\n return nabla_b, nabla_w\",\n \"def _get_batch(self, index_array):\\n # The transformation of images is not under thread lock\\n # so it can be done in parallel\\n batch_x = np.zeros((len(index_array),) + self.target_size, dtype=np.float32)\\n batch_x = np.expand_dims(batch_x, axis=-1)\\n # build batch of image data\\n for i, j in enumerate(index_array):\\n img = vio.ext_load(self.path_str[j], self.target_size)\\n batch_x[i] = deepcopy(img)\\n\\n self.classes = np.asarray(self.classes, dtype=np.float32)\\n # build batch of labels\\n if self.class_mode == 'input':\\n batch_y = batch_x.copy()\\n elif self.class_mode == 'sparse':\\n batch_y = self.classes[index_array]\\n elif self.class_mode == 'binary':\\n batch_y = self.classes[index_array]\\n elif self.class_mode == 'categorical':\\n batch_y = np.zeros((len(batch_x), self.num_classes),dtype=np.float32)\\n for i, label in enumerate(self.classes[index_array]):\\n\\n batch_y[i, int(label)] = 1.\\n else:\\n return batch_x\\n\\n return batch_x, batch_y\",\n \"def generate_batches(data, labels, batch_size):\\n for start in range(0, len(data), batch_size):\\n yield Tensor(data[start:start+batch_size, ...]), Tensor(labels[start:start+batch_size, ...])\",\n \"def next_batch(self, batch_size):\\n # Get batch\\n assert(batch_size == 1)\\n em, mask_list, seed_list = self.next_example(self.K)\\n\\n # Reshape for batch size 1\\n em_batch = np.expand_dims(em, 0)\\n mask_list = [np.expand_dims(m,0) for m in mask_list]\\n \\n return em_batch, mask_list\",\n \"def evaluate_batch(self, pipelines):\",\n \"def main(tetrode_number=TETRODE_NUMBER,num_hidden_units=500,num_hidden_units_2=300,num_hidden_units_3=200,num_code_units=50):\\n \\n print(\\\"Making the model...\\\")\\n network = model((None,200),200,num_hidden_units,num_hidden_units_2,num_hidden_units_3,num_code_units)\\n print(\\\"Done!\\\")\\n\\n\\n for tetrode_number in [10]:\\n\\n print(\\\"Loading the model parameters from {}\\\".format(MODEL_FILENAME+str(tetrode_number)))\\n f = open(MODEL_FILENAME+str(tetrode_number),'r')\\n all_param_values = pickle.load(f)\\n f.close()\\n # print(all_param_values)\\n lasagne.layers.set_all_param_values(network, all_param_values)\\n\\n print(\\\"Loading the data...\\\")\\n dataset = load_data(tetrode_number)\\n print(\\\"Done!\\\")\\n\\n print(dataset['data'].shape)\\n\\n print(\\\"Setting up the training functions...\\\")\\n training = funcs(dataset,network)\\n print(\\\"Done!\\\")\\n\\n for i in range(NUM_EPOCHS):\\n costs = []\\n\\n for start, end in zip(range(0, dataset['data'].shape[0], BATCH_SIZE), range(BATCH_SIZE, dataset['data'].shape[0], BATCH_SIZE)):\\n cost = training['train'](dataset['data'][start:end],dataset['data'][start:end])\\n costs.append(cost)\\n\\n meanTrainCost = np.mean(np.asarray(costs,dtype=np.float32))\\n # accuracy = training['accuracy'](dataset['X_test'],dataset['y_test'])\\n\\n print(\\\"Epoch: {}, Training cost: {}\\\".format(i+1,meanTrainCost))\\n # NUM_POINTS = 5000\\n codes = training['code'](dataset['data'][0:NUM_POINTS])\\n\\n \\n\\n # y = set(list(d.predict(dataset['data'][0:NUM_POINTS])))\\n\\n # print(y)\\n\\n # activations_1 = training['activations_1'](dataset['data'][0:NUM_POINTS])\\n # activations_2 = training['activations_2'](dataset['data'][0:NUM_POINTS])\\n # codes = training['code'](dataset['data'][0:NUM_POINTS])\\n # # print(codes.shape)\\n # # codes_2d = bh_sne(codes)\\n\\n # for k in range(3):\\n # print(k)\\n\\n # codes_2d = bh_sne(np.asarray(codes[:(k+1)*12000],dtype=np.float64))\\n\\n # # d = DPGMM(n_components=10, covariance_type='full')\\n # d = DPGMM(n_components=15,n_iter=100)\\n\\n # d.fit(codes_2d[:(k+1)*12000])\\n\\n # hdp = d.predict_proba(codes_2d[:(k+1)*12000])\\n\\n # hdp_1d = [np.argmax(z) for z in hdp]\\n\\n # print(set(list(hdp_1d)))\\n\\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=hdp_1d, alpha=0.8,lw=0)\\n # plt.savefig('dbscan_labels/deep/sparse/hdp_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\\n # plt.close()\\n\\n # # m = TSNE(n_components=2, random_state=0)\\n \\n # # codes_2d = m.fit_transform(codes[:NUM_POINTS])\\n # # activations_1_2d = bh_sne(activations_1)\\n # # activations_2_2d = bh_sne(activations_2)\\n\\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=dataset['labels'][0:NUM_POINTS][:(k+1)*12000],alpha=0.8,lw=0)\\n # plt.savefig('dbscan_labels/deep/sparse/tsne_codes_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\\n # plt.close()\\n\\n # # This is where the code for the video will go\\n # ##############################################################################\\n # # Compute DBSCAN\\n # db = None\\n # core_samples_mask = None\\n # labels = None\\n\\n # num_labels = 0\\n # eps=1.0\\n # while(num_labels < 10):\\n # db = DBSCAN(eps=eps, min_samples=10).fit(codes_2d)\\n # core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\\n # core_samples_mask[db.core_sample_indices_] = True\\n # labels = db.labels_\\n # num_labels = np.amax(labels)\\n # eps -= 0.1\\n\\n # print(\\\"Num learned labels: {}\\\".format(num_labels))\\n\\n # plt.title('Estimated number of clusters: {}'.format(np.amax(labels)))\\n # plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=labels[0:NUM_POINTS][:(k+1)*12000],lw=0)\\n # plt.savefig('dbscan_labels/deep/sparse/dbscan_codes_{}_{}.png'.format(tetrode_number,k), bbox_inches='tight')\\n # plt.close()\\n\\n # # f=open('dbscan_labels/deep/sparse/tetrode_{}.npy'.format(tetrode_number),'w')\\n # # pickle.dump(labels, f)\\n # # f.close()\\n\\n codes_2d = bh_sne(np.asarray(codes,dtype=np.float64),theta=0.4)\\n\\n # d = DPGMM(n_components=10, covariance_type='full')\\n d = DPGMM(n_components=15,n_iter=1000)\\n\\n d.fit(codes_2d)\\n\\n hdp = d.predict_proba(codes_2d)\\n\\n hdp_1d = [np.argmax(z) for z in hdp]\\n\\n print(set(list(hdp_1d)))\\n\\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=hdp_1d, alpha=0.8,lw=0)\\n plt.savefig('dbscan_labels/deep/sparse/hdp_{}.png'.format(tetrode_number), bbox_inches='tight')\\n plt.close()\\n\\n # m = TSNE(n_components=2, random_state=0)\\n \\n # codes_2d = m.fit_transform(codes[:NUM_POINTS])\\n # activations_1_2d = bh_sne(activations_1)\\n # activations_2_2d = bh_sne(activations_2)\\n\\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=dataset['labels'][0:NUM_POINTS],alpha=0.8,lw=0)\\n plt.savefig('dbscan_labels/deep/sparse/tsne_codes_{}.png'.format(tetrode_number), bbox_inches='tight')\\n plt.close()\\n\\n # This is where the code for the video will go\\n ##############################################################################\\n # Compute DBSCAN\\n db = None\\n core_samples_mask = None\\n labels = None\\n\\n num_labels = 0\\n eps=1.0\\n while(num_labels < 10):\\n db = DBSCAN(eps=eps, min_samples=10).fit(codes_2d)\\n core_samples_mask = np.zeros_like(db.labels_, dtype=bool)\\n core_samples_mask[db.core_sample_indices_] = True\\n labels = db.labels_\\n num_labels = np.amax(labels)\\n eps -= 0.1\\n\\n print(\\\"Num learned labels: {}\\\".format(num_labels))\\n\\n plt.title('Estimated number of clusters: {}'.format(np.amax(labels)))\\n plt.scatter(codes_2d[:, 0], codes_2d[:, 1], c=labels[0:NUM_POINTS],lw=0)\\n plt.savefig('dbscan_labels/deep/sparse/dbscan_codes_{}.png'.format(tetrode_number), bbox_inches='tight')\\n plt.close()\\n\\n # f=open('dbscan_labels/deep/sparse/tetrode_{}.npy'.format(tetrode_number),'w')\\n # pickle.dump(labels, f)\\n # f.close()\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.7156559","0.6675926","0.6484803","0.64537615","0.6439719","0.63298804","0.6313098","0.629422","0.6292286","0.6282321","0.62772465","0.62722385","0.62591076","0.6255684","0.6244277","0.6213893","0.62077737","0.6185972","0.6175707","0.61558586","0.6106689","0.6093691","0.60704774","0.6054737","0.60401285","0.60098493","0.60004926","0.5992814","0.5983814","0.59599733","0.59598905","0.59539694","0.5938701","0.5919277","0.58988684","0.5884839","0.58716935","0.5871339","0.58615273","0.58595836","0.5848191","0.58463234","0.58441544","0.58312434","0.58297783","0.5824874","0.5820776","0.5811968","0.58115906","0.58083725","0.580514","0.5798673","0.5788548","0.57855296","0.57817423","0.5781112","0.57802427","0.5779741","0.5776913","0.5756934","0.5743956","0.57420474","0.5737557","0.5734745","0.5733271","0.5732439","0.5731769","0.5721771","0.57213897","0.57086957","0.570207","0.56964535","0.5696387","0.56945497","0.5692182","0.56780756","0.56762266","0.56735766","0.5668933","0.56678456","0.5665496","0.5663101","0.56624204","0.56621253","0.5661983","0.5655512","0.5653566","0.56517535","0.56508464","0.56462944","0.5646112","0.5642216","0.56412673","0.56406605","0.5636497","0.5626976","0.5623124","0.5620181","0.56194115","0.5618313","0.56180596"],"string":"[\n \"0.7156559\",\n \"0.6675926\",\n \"0.6484803\",\n \"0.64537615\",\n \"0.6439719\",\n \"0.63298804\",\n \"0.6313098\",\n \"0.629422\",\n \"0.6292286\",\n \"0.6282321\",\n \"0.62772465\",\n \"0.62722385\",\n \"0.62591076\",\n \"0.6255684\",\n \"0.6244277\",\n \"0.6213893\",\n \"0.62077737\",\n \"0.6185972\",\n \"0.6175707\",\n \"0.61558586\",\n \"0.6106689\",\n \"0.6093691\",\n \"0.60704774\",\n \"0.6054737\",\n \"0.60401285\",\n \"0.60098493\",\n \"0.60004926\",\n \"0.5992814\",\n \"0.5983814\",\n \"0.59599733\",\n \"0.59598905\",\n \"0.59539694\",\n \"0.5938701\",\n \"0.5919277\",\n \"0.58988684\",\n \"0.5884839\",\n \"0.58716935\",\n \"0.5871339\",\n \"0.58615273\",\n \"0.58595836\",\n \"0.5848191\",\n \"0.58463234\",\n \"0.58441544\",\n \"0.58312434\",\n \"0.58297783\",\n \"0.5824874\",\n \"0.5820776\",\n \"0.5811968\",\n \"0.58115906\",\n \"0.58083725\",\n \"0.580514\",\n \"0.5798673\",\n \"0.5788548\",\n \"0.57855296\",\n \"0.57817423\",\n \"0.5781112\",\n \"0.57802427\",\n \"0.5779741\",\n \"0.5776913\",\n \"0.5756934\",\n \"0.5743956\",\n \"0.57420474\",\n \"0.5737557\",\n \"0.5734745\",\n \"0.5733271\",\n \"0.5732439\",\n \"0.5731769\",\n \"0.5721771\",\n \"0.57213897\",\n \"0.57086957\",\n \"0.570207\",\n \"0.56964535\",\n \"0.5696387\",\n \"0.56945497\",\n \"0.5692182\",\n \"0.56780756\",\n \"0.56762266\",\n \"0.56735766\",\n \"0.5668933\",\n \"0.56678456\",\n \"0.5665496\",\n \"0.5663101\",\n \"0.56624204\",\n \"0.56621253\",\n \"0.5661983\",\n \"0.5655512\",\n \"0.5653566\",\n \"0.56517535\",\n \"0.56508464\",\n \"0.56462944\",\n \"0.5646112\",\n \"0.5642216\",\n \"0.56412673\",\n \"0.56406605\",\n \"0.5636497\",\n \"0.5626976\",\n \"0.5623124\",\n \"0.5620181\",\n \"0.56194115\",\n \"0.5618313\",\n \"0.56180596\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80893,"cells":{"query":{"kind":"string","value":"Given a connectivity threshold, the method will return the sparse matrix most closely matching that threshold."},"document":{"kind":"string","value":"def get_approx_preRes(self, connectivity_threshold):\n #print(\"sparse_keys\", self.sparse_keys_, \"connectivity_threshold\", connectivity_threshold )\n key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]\n val = self.sparse_book[key_].clone()\n return val"},"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 get_approx_preRes_old(self, connectivity_threshold, i):\n key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]\n val = np.array(sparse_dict[key_]).copy()\n return val","def nearest_sparse(self, query):\n self.best_dist = float(\"inf\")\n self.best_element = None\n self._register_best_element = self._register_best_element_single \n self._nearest_sparse_recursive(self._sparse2seq(query), self.root, 0.0)\n return self.best_element,self.best_dist","def similarity_matrix_topk(item_score_matrix, topk=100,verbose=False):\n\n assert(item_score_matrix.shape[0] == item_score_matrix.shape[1]), \"the score matrix is not square\"\n start_time = time.time()\n if verbose:\n print(\"generaing topk matrix\")\n\n # iterate over each column and keep only the topk similar items\n\n data, row_indices, col_indptr = [], [], []\n item_score_matrix = item_score_matrix.tocsc()\n n_items = item_score_matrix.shape[0]\n\n for item_index in range(item_score_matrix.shape[0]):\n col_indptr.append(len(data))\n start_position = item_score_matrix.indptr[item_index]\n end_position = item_score_matrix.indptr[item_index+1]\n col_data = item_score_matrix.data[start_position:end_position]\n col_row_index = item_score_matrix.indices[start_position:end_position]\n\n index_sorted = np.argsort(col_data)\n topk_index = index_sorted[-topk:]\n\n data.extend(col_data[topk_index])\n row_indices.extend(col_row_index[topk_index])\n col_indptr.append(len(data))\n\n result = sps.csc_matrix((data, row_indices, col_indptr), shape=(n_items, n_items), dtype=np.float32)\n result = result.tocsr()\n\n if verbose:\n print(\"sparse topk matrix generated in {:.2f} seconds\".format(time.time()-start_time))\n\n return result","def best_match(psi1, psi2, threshold=None):\n if threshold is None:\n threshold = (2 * psi1.shape[0])**-0.25\n Q = np.abs(psi1.T.conj() @ psi2) # Overlap matrix\n orig, perm = so.linear_sum_assignment(-Q)\n return perm, Q[orig, perm] < threshold","def order_selection(C, threshold):\n return len([l for l in np.linalg.eigvalsh(C) if l >= threshold])","def get_most_similar(distances):\n threshold = get_threshold(distances)\n most_similar = list()\n distances = sorted(distances, key=lambda x: x[0])\n\n for i in distances:\n if i[0] < threshold:\n most_similar.append(i)\n else:\n break\n\n return most_similar","def Threshold(self, threshold=0.0):\n return _hypre.HypreParMatrix_Threshold(self, threshold)","def nearest_min(dist_matrix):\n # much faster than np.where\n i, j = np.unravel_index(\n np.argmin(dist_matrix), \n dims=dist_matrix.shape\n )\n return i, j","def get_pair_lookup(fold, threshold=1, force=False):\n try:\n assert not force # this is some hacky control flow right here\n M = load_cooc_matrix(fold)\n logging.info('Loaded cooc matrix')\n except (AssertionError, IOError):\n logging.info('Building cooc matrix')\n users = iterate_wrapped_users(fold)\n with time_me('Built cooc matrix', mode='print'):\n M = build_cooc_matrix(users)\n M = M.tocoo()\n # converting to coo at this point might provide some memory relief\n save_cooc_matrix(fold, M)\n\n logging.info('Loaded cooc matrix with {:,} nonzero entries'.format(M.nnz))\n next_ix = 0\n lookup = {}\n # Turns out using scipy.sparse.find is slow af\n #with time_me('finded'):\n # focals, others, counts = scipy.sparse.find(M)\n assert isinstance(M, scipy.sparse.coo_matrix)\n focals, others, counts = M.row, M.col, M.data\n #for i in xrange(len(counts)):\n # focal_pidx = focals[i]\n # other_pidx = others[i]\n # count = counts[i]\n for (focal_pidx, other_pidx, count) in itertools.izip(focals, others, counts):\n\n if count >= threshold:\n k = (focal_pidx+1, other_pidx+1)\n lookup[k] = next_ix\n next_ix += 1\n if next_ix % 10**6 == 0:\n print '{:,}... '.format(next_ix)\n\n logging.info('Went from {:,} non-zero entries to {:,} pairs after thresholding by {}'.format(\n M.nnz, next_ix, threshold))\n if next_ix + constants.N_PRODUCTS > 2**31:\n logging.warn(\"Too many features even after thresholding. You're gonna have a bad time.\")\n return lookup","def get_best_sensitivity_metrics(self,\n verbose: bool = True) -> Tuple[int, int]:\n sensitivity_scores = list()\n for i in self.search_space:\n classes = self.convert_classes(threshold=i)\n tn, fp, fn, tp = confusion_matrix(self.y_true, classes).ravel()\n sensitivity = tp / (tp + fn)\n sensitivity_scores.append(sensitivity)\n best_sensitivity_score, best_sensitivity_threshold = self._get_best_metrics(\n metric_type='sensitivity_score',\n scores=sensitivity_scores,\n greater_is_better=True,\n verbose=verbose\n )\n return best_sensitivity_score, best_sensitivity_threshold","def mkgraph(cmat, threshold=0.0, threshold2=None):\r\n\r\n # Input sanity check\r\n nrow, ncol = cmat.shape\r\n if nrow != ncol:\r\n raise ValueError(\"Adjacency matrix must be square\")\r\n\r\n row_idx, col_idx, vals = threshold_arr(cmat, threshold, threshold2)\r\n # Also make the full thresholded array available in the metadata\r\n cmat_th = np.empty_like(cmat)\r\n if threshold2 is None:\r\n cmat_th.fill(threshold)\r\n else:\r\n cmat_th.fill(-np.inf)\r\n cmat_th[row_idx, col_idx] = vals\r\n\r\n # Next, make a normalized copy of the values. For the 2-threshold case, we\r\n # use 'folding' normalization\r\n if threshold2 is None:\r\n vals_norm = minmax_norm(vals)\r\n else:\r\n vals_norm = minmax_norm(vals, 'folding', [threshold, threshold2])\r\n\r\n # Now make the actual graph\r\n G = nx.Graph(weighted=True)\r\n G.add_nodes_from(list(range(nrow)))\r\n # To keep the weights of the graph to simple values, we store the\r\n # normalize ones in a separate dict that we'll stuff into the graph\r\n # metadata.\r\n\r\n normed_values = {}\r\n for i, j, val, nval in zip(row_idx, col_idx, vals, vals_norm):\r\n if i == j:\r\n # no self-loops\r\n continue\r\n G.add_edge(i, j, weight=val)\r\n normed_values[i, j] = nval\r\n\r\n # Write a metadata dict into the graph and save the threshold info there\r\n G.metadata = dict(threshold1=threshold,\r\n threshold2=threshold2,\r\n cmat_raw=cmat,\r\n cmat_th=cmat_th,\r\n vals_norm=normed_values,\r\n )\r\n return G","def _fix_connectivity(X, connectivity, affinity):\n n_samples = X.shape[0]\n if connectivity.shape[0] != n_samples or connectivity.shape[1] != n_samples:\n raise ValueError(\n \"Wrong shape for connectivity matrix: %s when X is %s\"\n % (connectivity.shape, X.shape)\n )\n\n # Make the connectivity matrix symmetric:\n connectivity = connectivity + connectivity.T\n\n # Convert connectivity matrix to LIL\n if not sparse.issparse(connectivity):\n connectivity = sparse.lil_matrix(connectivity)\n\n # `connectivity` is a sparse matrix at this point\n if connectivity.format != \"lil\":\n connectivity = connectivity.tolil()\n\n # Compute the number of nodes\n n_connected_components, labels = connected_components(connectivity)\n\n if n_connected_components > 1:\n warnings.warn(\n \"the number of connected components of the \"\n \"connectivity matrix is %d > 1. Completing it to avoid \"\n \"stopping the tree early.\" % n_connected_components,\n stacklevel=2,\n )\n # XXX: Can we do without completing the matrix?\n connectivity = _fix_connected_components(\n X=X,\n graph=connectivity,\n n_connected_components=n_connected_components,\n component_labels=labels,\n metric=affinity,\n mode=\"connectivity\",\n )\n\n return connectivity, n_connected_components","def coef_to_adj(coef, threshold):\n # coef = 0.5 * (np.abs(coef) + np.abs(coef.T))\n # return coef\n\n coef = 0.5 * (coef + coef.T)\n # top_threshold = int(coef.shape[0] ** 2 * threshold)\n # top_index = np.unravel_index(np.argsort(coef.ravel())[-top_threshold:], coef.shape)\n # top_val = coef[top_index][0]\n # adj = np.where(np.abs(coef) > top_val, 1, 0)\n samples_number = coef.shape[0]\n neighbor_number = round(threshold*samples_number)\n adj = np.zeros((samples_number, samples_number), dtype=np.int)\n for i in range(samples_number):\n top_index = np.argsort(np.abs(coef[i]))[::-1][0: neighbor_number]\n adj[i][top_index] = 1\n # adj = adj - np.diag(adj.diagonal())\n # adj = sp.csr_matrix(adj)\n return adj","def bestF(score_matrix, gold_lex):\n np.seterr(divide='ignore', invalid='ignore') # get nans instead of division by zero\n best_f = 0\n best_th = 0\n\n for th in np.linspace(0, 1, 101): # threshold\n lex = (score_matrix >= th)\n p = np.sum(lex * (lex == gold_lex)) / np.sum(lex)\n r = np.sum(lex * (lex == gold_lex)) / np.sum(gold_lex)\n f = 2 * (p * r) / (p + r)\n\n if f > best_f:\n best_f = f\n best_th = th\n\n return best_f, best_th","def _kth_nearest_neighbor_dist(\n distance_matrix: Union[np.ndarray, scipy.sparse.csr_matrix], k\n) -> np.ndarray:\n\n if not is_integer(k):\n raise ValueError(f\"parameter 'k={k}' must be a positive integer\")\n else:\n # make sure we deal with Python built-in\n k = int(k)\n\n if not (0 <= k <= distance_matrix.shape[1]):\n raise ValueError(\n \"'k' must be an integer between 1 and \"\n f\"distance_matrix.shape[1]={distance_matrix.shape[1]}\"\n )\n\n if isinstance(distance_matrix, np.ndarray):\n dist_knn = np.partition(distance_matrix, k - 1, axis=1)[:, k - 1]\n elif isinstance(distance_matrix, scipy.sparse.csr_matrix):\n # see mircobenchmark_kth_nn.py for a comparison of implementations for the\n # sparse case\n\n def _get_kth_largest_elements_sparse(\n data: np.ndarray,\n indptr: np.ndarray,\n row_nnz,\n k_neighbor: int,\n ):\n dist_knn = np.zeros(len(row_nnz))\n for i in range(len(row_nnz)):\n start_row = indptr[i]\n dist_knn[i] = np.partition(\n data[start_row : start_row + row_nnz[i]], k_neighbor - 1\n )[k_neighbor - 1]\n\n return dist_knn\n\n row_nnz = distance_matrix.getnnz(axis=1)\n\n if (row_nnz < k).any():\n raise ValueError(\n f\"There are {(row_nnz < k).sum()} points that \"\n f\"do not have at least k_neighbor={k}.\"\n )\n\n dist_knn = _get_kth_largest_elements_sparse(\n distance_matrix.data,\n distance_matrix.indptr,\n row_nnz,\n k,\n )\n else:\n raise TypeError(f\"type {type(distance_matrix)} not supported\")\n\n return dist_knn","def analyze_sensitivity_sparse_grid(sparse_grid,max_order=2):\n from pyapprox.multivariate_polynomials import \\\n define_poly_options_from_variable_transformation\n from pyapprox.adaptive_sparse_grid import \\\n convert_sparse_grid_to_polynomial_chaos_expansion\n pce_opts=define_poly_options_from_variable_transformation(\n sparse_grid.variable_transformation)\n pce = convert_sparse_grid_to_polynomial_chaos_expansion(\n sparse_grid,pce_opts)\n pce_main_effects,pce_total_effects=\\\n get_main_and_total_effect_indices_from_pce(\n pce.get_coefficients(),pce.get_indices())\n\n interaction_terms, pce_sobol_indices = get_sobol_indices(\n pce.get_coefficients(),pce.get_indices(),max_order=max_order)\n \n return SensivitityResult(\n {'main_effects':pce_main_effects,\n 'total_effects':pce_total_effects,\n 'sobol_indices':pce_sobol_indices,\n 'sobol_interaction_indices':interaction_terms,\n 'pce':pce})","def mask_sparse(self, threshold=10):\n self.MaskPrefix = 's' + self.MaskPrefix\n print('Masking pixels that do not have at least {0} coherent values'.format(threshold))\n # each pixel assigned an integer corresponding to # of igrams where coherent\n # NOTE: save coverage map if it doesn't exist already\n coverage = self.get_coverage()\n sparse = ma.masked_less(coverage, threshold)\n for ig in self.Set:\n igram = self.load_ma(ig)\n igram[sparse.mask] = ma.masked\n self.save_ma(ig, igram)\n print('Done')","def makesparse(matrix):\n n = matrix[0].size\n elements = []\n for i in range(n):\n for j in range(n):\n if matrix[i][j] != 0 :\n temp = MatrixElement(i, j, matrix[i][j])\n elements.append(temp)\n return SparseMatrix(n, elements)","def count_matrix_largest(self, effective=False):\n return self.count_matrix(connected_set=0, effective=effective)","def search_similar(word_map, matrix, query, threshold=0.95):\n if query not in word_map:\n print(query, \"not found\")\n return None\n\n words = ['' for i in range(len(word_map))]\n for word in word_map:\n words[word_map[word]] = word\n\n num_rows = matrix.shape[0]\n vector = matrix[word_map[query]]\n for i in range(num_rows):\n test_vector = matrix[i]\n if cossim(test_vector, vector) >= threshold:\n print(words[i])","def convert_sparse_to_coo(s_mat):\n return np.vstack(find(s_mat)).T","def test_build_classification_matrix_sparse():\n import scnym\n\n # generate a sparse matrix with ~10% of elements filled\n B = np.zeros((100, 10))\n ridx = np.random.choice(B.size, size=100, replace=True)\n B.flat[ridx] = 1\n B = sparse.csr_matrix(B)\n\n # create dummy gene names where the order of\n # genes in `B` is permuted\n A_genes = np.arange(10)\n B_genes = np.random.permutation(A_genes)\n\n # build the classification matrix\n X = scnym.utils.build_classification_matrix(\n X=B,\n model_genes=A_genes,\n sample_genes=B_genes,\n )\n assert sparse.issparse(X)\n\n # X should have the genes of B in the order of A\n for i, g in enumerate(A_genes):\n j = int(np.where(B_genes == g)[0])\n assert np.all(X[:, i].toarray() == B[:, j].toarray())\n return","def nearest_points_values_with_self(matrix, num_to_keep):\n\n # Set the diagonal to 1\n np.fill_diagonal(matrix, 1)\n # Get the position for the resulted values\n sort = np.sort(matrix, axis=1)\n\n return sort[:, : num_to_keep]","def bipartite_matching(data=None, is_ascend=_Null, threshold=_Null, topk=_Null, out=None, name=None, **kwargs):\n return (0,)","def find_best_feature_threshold(self, X, Y):\n nan_direction = 0\n best_gain = - np.inf\n best_feature, best_threshold = None, None\n rsts = None\n\n # for each feature, find its best_threshold and best_gain, finally select the largest gain\n # implement in parallel\n cols = list(X.columns)\n data = pd.concat([X, Y], axis=1)\n\n func = partial(self.find_best_threshold, data)\n if self.num_thread == -1:\n pool = Pool()\n rsts = pool.map(func, cols)\n pool.close()\n\n else:\n pool = Pool(self.num_thread)\n rsts = pool.map(func, cols)\n pool.close()\n\n for rst in rsts:\n if rst[2] > best_gain:\n best_gain = rst[2]\n best_threshold = rst[1]\n best_feature = rst[0]\n\n return best_feature, best_threshold, best_gain","def nearest_points_indexes_with_self(matrix, num_to_keep):\n\n # Set the diagonal to 1\n np.fill_diagonal(matrix, 1)\n # Get the position for the resulted values\n sort_arg = np.argsort(matrix, axis=1)\n\n return sort_arg[:, : num_to_keep]","def label_simplex(grid, simplex, thresh):\n coords = [grid[:,x] for x in simplex]\n dist = squareform(pdist(coords,'euclidean'))\n adjacency = dist<thresh\n adjacency = adjacency.astype(int) \n graph = csr_matrix(adjacency)\n n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\n\n return n_components","def fit_from_scipy_sparse_matrix(self,\n adj,\n attr,\n spatially_extensive_attr,\n threshold,\n solver=\"cbc\",\n metric=\"euclidean\"):\n self.metric = get_metric_function(metric)\n check_solver(solver)\n\n prob = LpProblem(\"Max-p-Regions\", LpMinimize)\n\n # Parameters of the optimization problem\n n_areas = adj.shape[0]\n I = list(range(n_areas)) # index for areas\n II = [(i, j) for i in I for j in I]\n II_upper_triangle = [(i, j) for i, j in II if i < j]\n # index of potential regions, called k in [DAR2012]_:\n K = range(n_areas)\n # index of contiguity order, called c in [DAR2012]_:\n O = range(n_areas)\n d = {(i, j): self.metric(attr[i].reshape(1, -1), attr[j].reshape(\n 1, -1))\n for i, j in II_upper_triangle}\n h = 1 + floor(log10(sum(d[(i, j)] for i, j in II_upper_triangle)))\n\n # Decision variables\n t = LpVariable.dicts(\n \"t\", ((i, j) for i, j in II_upper_triangle),\n lowBound=0,\n upBound=1,\n cat=LpInteger)\n x = LpVariable.dicts(\n \"x\", ((i, k, o) for i in I for k in K for o in O),\n lowBound=0,\n upBound=1,\n cat=LpInteger)\n\n # Objective function\n # (1) in Duque et al. (2012): \"The Max-p-Regions Problem\"\n prob += -10**h * lpSum(x[i, k, 0] for k in K for i in I) \\\n + lpSum(d[i, j] * t[i, j] for i, j in II_upper_triangle)\n\n # Constraints\n # (2) in Duque et al. (2012): \"The Max-p-Regions Problem\"\n for k in K:\n prob += lpSum(x[i, k, 0] for i in I) <= 1\n # (3) in Duque et al. (2012): \"The Max-p-Regions Problem\"\n for i in I:\n prob += lpSum(x[i, k, o] for k in K for o in O) == 1\n # (4) in Duque et al. (2012): \"The Max-p-Regions Problem\"\n for i in I:\n for k in K:\n for o in range(1, len(O)):\n prob += x[i, k, o] <= lpSum(x[j, k, o - 1]\n for j in neighbors(adj, i))\n # (5) in Duque et al. (2012): \"The Max-p-Regions Problem\"\n if isinstance(spatially_extensive_attr[I[0]], numbers.Real):\n for k in K:\n lhs = lpSum(x[i, k, o] * spatially_extensive_attr[i] for i in I\n for o in O)\n prob += lhs >= threshold * lpSum(x[i, k, 0] for i in I)\n elif isinstance(spatially_extensive_attr[I[0]], collections.Iterable):\n for el in range(len(spatially_extensive_attr[I[0]])):\n for k in K:\n lhs = lpSum(x[i, k, o] * spatially_extensive_attr[i][el]\n for i in I for o in O)\n if isinstance(threshold, numbers.Real):\n rhs = threshold * lpSum(x[i, k, 0] for i in I)\n prob += lhs >= rhs\n elif isinstance(threshold, np.ndarray):\n rhs = threshold[el] * lpSum(x[i, k, 0] for i in I)\n prob += lhs >= rhs\n # (6) in Duque et al. (2012): \"The Max-p-Regions Problem\"\n for i, j in II_upper_triangle:\n for k in K:\n prob += t[i, j] >= \\\n lpSum(x[i, k, o] + x[j, k, o] for o in O) - 1\n # (7) in Duque et al. (2012): \"The Max-p-Regions Problem\"\n # already in LpVariable-definition\n # (8) in Duque et al. (2012): \"The Max-p-Regions Problem\"\n # already in LpVariable-definition\n\n # additional constraint for speedup (p. 405 in [DAR2012]_)\n for o in O:\n prob += x[I[0], K[0], o] == (1 if o == 0 else 0)\n\n # Solve the optimization problem\n solver = get_solver_instance(solver)\n prob.solve(solver=solver)\n result = np.zeros(n_areas)\n for i in I:\n for k in K:\n for o in O:\n if x[i, k, o].varValue == 1:\n result[i] = k\n self.labels_ = result\n self.solver = solver","def score(mat: Tensor, target: Tensor, k: int) -> tuple:\n # number of users with similarities larger than the matched users\n rank = (mat >= target).sum(1)\n # rank = min(rank, k + 1)\n rank = rank.min(torch.tensor(k + 1).cuda())\n tmp = (k + 1 - rank).float()\n # hit_precision@k\n hit_score = (tmp / k).mean()\n # precision@k\n coverage = (tmp > 0).float().mean()\n return coverage, hit_score","def get_top_k(matrix,k):\n assert k <= matrix.shape[1]\n col_inds = np.argpartition(matrix, -k)[:,-k:].flatten()\n row_inds = np.repeat(range(matrix.shape[0]),k)\n\n vals = matrix[row_inds, col_inds]\n\n return vals, col_inds","def constant_feature_detect(data, threshold=0.98):\n\n data_copy = data.copy(deep=True)\n quasi_constant_feature = []\n for feature in data_copy.columns:\n predominant = (\n (data_copy[feature].value_counts() / np.float(len(data_copy)))\n .sort_values(ascending=False)\n .values[0]\n )\n if predominant >= threshold:\n quasi_constant_feature.append(feature)\n print(len(quasi_constant_feature), \" variables are found to be almost constant\")\n return quasi_constant_feature","def find(a):\n\n a = coo_matrix(a, copy=True)\n a.sum_duplicates()\n # remove explicit zeros\n nz_mask = a.data != 0\n return a.row[nz_mask], a.col[nz_mask], a.data[nz_mask]","def filter_mat_simple(tol=1e-9, use_sparseness=False, **cov_kwargs):\n cmat_simple = covariances.cov_mat_simple(**cov_kwargs)\n cmat_simple = cmat_simple / tol + np.identity(cmat_simple.shape[0])\n if \"bl_cutoff_buffer\" in cov_kwargs and np.isfinite(cov_kwargs[\"bl_cutoff_buffer\"]) and use_sparseness:\n cmat_simple = covariances.convert_to_sparse_bands(cmat_simple)\n # compute sparse inversion and return array.\n filter_matrix = inv_banded(cmat_simple)\n else:\n filter_matrix = linalg.pinvh(cmat_simple)\n return filter_matrix","def largest_connected_submatrix(C, directed=True, lcc=None):\n if lcc is None:\n lcc = largest_connected_set(C, directed=directed)\n\n \"\"\"Row slicing\"\"\"\n if scipy.sparse.issparse(C):\n C_cc = C.tocsr()\n else:\n C_cc = C\n C_cc = C_cc[lcc, :]\n\n \"\"\"Column slicing\"\"\"\n if scipy.sparse.issparse(C):\n C_cc = C_cc.tocsc()\n C_cc = C_cc[:, lcc]\n\n if scipy.sparse.issparse(C):\n return C_cc.tocoo()\n else:\n return C_cc","def greedy_match(cost_matrix):\n num_detections, num_tracks = cost_matrix.shape\n distance_1d = cost_matrix.reshape(-1)\n index_1d = np.argsort(distance_1d)\n index_2d = np.stack([index_1d // num_tracks, index_1d % num_tracks], axis=1).astype(int, copy=False)\n\n matched_indices = []\n matched_firsts = set()\n matched_seconds = set()\n\n for (first_id, second_id) in index_2d:\n if first_id not in matched_firsts and second_id not in matched_seconds:\n matched_seconds.add(second_id)\n matched_firsts.add(first_id)\n matched_indices.append([first_id, second_id])\n return np.array(matched_indices)","def finalise_matrix(matrix):\n if get_density(matrix) < DENSITY_THRESHOLD:\n matrix = matrix.tocsc()\n matrix.sort_indices()\n else:\n matrix = matrix.toarray()\n if is_integer(matrix):\n matrix = convert_to_smallest_int_type(matrix)\n return matrix","def top_k_betweenness_centrality(self):\n d={}\n l=[]\n for v in vertices:\n a=self.betweenness_centrality(v)\n d[v]=a\n l.append(a)\n m=max(l)\n l1=[]\n for key in d:\n if d[key]==m:\n l1.append(key)\n\n return l1","def _get2dCostMatrix(c_hat, time_step_indices: TimeStepIndices, track_count, measurement_count):\n\n # Compute track-measurement cost for single scan problem from hypothesis\n # cost, including null assignment costs\n # Construct track to measurement assignment matrix at scan k\n cost = np.full((track_count, measurement_count), np.inf)\n nullCost = np.full((track_count,), np.inf)\n # store index of the single target hypothesis with the minimum cost for\n # each track and measurement\n idxCost = np.full((track_count, measurement_count), -1, dtype=np.int32)\n idxNullCost = np.full((track_count,), -1, dtype=np.int32)\n for track_id, trackNull_index_for_track in enumerate(time_step_indices.trackNull_index):\n if len(trackNull_index_for_track):\n min_index = c_hat[trackNull_index_for_track].argmin()\n min_index_all_c_hat = trackNull_index_for_track[min_index]\n nullCost[track_id] = c_hat[min_index_all_c_hat]\n idxNullCost[track_id] = min_index_all_c_hat\n # find single target hypotheses in track i that use this\n # measurement if found, find the single target hypothesis with\n # the minimum cost, and record its index\n for measurement in range(measurement_count):\n measTrack_index_for_meas = time_step_indices.measTrack_index[measurement, track_id]\n if len(measTrack_index_for_meas):\n min_index = c_hat[measTrack_index_for_meas].argmin()\n min_index_all_c_hat = measTrack_index_for_meas[min_index]\n cost[track_id, measurement] = c_hat[min_index_all_c_hat]\n idxCost[track_id, measurement] = min_index_all_c_hat\n\n # Create cost matrix for nulls with null costs on diagonal and inf\n # elsewhere (so we can have any number of null assignments)\n nullCostMatrix = np.full((track_count, track_count), np.inf, dtype=np.float64)\n # Pick out diagonal entries (like np.diagonal, but this is a writable view)\n nullCostMatrix.ravel()[::track_count + 1] = nullCost\n\n fullCostMatrix = np.concatenate((cost, nullCostMatrix), axis=1)\n return fullCostMatrix, idxCost, idxNullCost","def get_approx_preRes(self, connectivity_threshold, i):\n val = sparse_dict.get_approx_preRes(connectivity_threshold, index = i)\n return val","def connectivity(A, tol=1e-8):\n #calculate L and eigenvalues of L\n L = laplacian(A)\n eigs, eigvec = la.eig(L)\n num_cc = 0\n #check zeros\n for i in eigs:\n if i < tol:\n num_cc += 1\n #fins the algebraic connectivity of G\n sec_small = sorted(eigs)[1]\n return num_cc, sec_small","def modularity(self, threshold=0):\n\n N = self.K.shape[0] # number ROIs\n C = np.eye(N) - (1 / N) * np.ones_like(N) # centering matrix\n self.Kcen = C @ self.K @ C # center kernel matrix\n\n # Get eigenvector corresponding to maximum eigenvalue\n self.evals, self.evecs = np.linalg.eig(self.Kcen)\n self.qmax = self.evecs[:, np.argmax(np.diag(self.evals))]\n\n # Create community assignments\n self.mod = self.qmax.copy()\n self.mod[self.mod >= threshold] = 0\n self.mod[self.mod < threshold] = 1\n\n return self","def feature_selection(feature_matrix, missing_threshold=90, correlation_threshold=0.95):\n \n feature_matrix = pd.get_dummies(feature_matrix)\n n_features_start = feature_matrix.shape[1]\n print('Original shape: ', feature_matrix.shape)\n\n # Find missing and percentage\n missing = pd.DataFrame(feature_matrix.isnull().sum())\n missing['percent'] = 100 * (missing[0] / feature_matrix.shape[0])\n missing.sort_values('percent', ascending = False, inplace = True)\n\n # Missing above threshold\n missing_cols = list(missing[missing['percent'] > missing_threshold].index)\n n_missing_cols = len(missing_cols)\n\n # Remove missing columns\n feature_matrix = feature_matrix[[x for x in feature_matrix if x not in missing_cols]]\n print('{} missing columns with threshold: {}.'.format(n_missing_cols,\n missing_threshold))\n \n # Zero variance\n unique_counts = pd.DataFrame(feature_matrix.nunique()).sort_values(0, ascending = True)\n zero_variance_cols = list(unique_counts[unique_counts[0] == 1].index)\n n_zero_variance_cols = len(zero_variance_cols)\n\n # Remove zero variance columns\n feature_matrix = feature_matrix[[x for x in feature_matrix if x not in zero_variance_cols]]\n print('{} zero variance columns.'.format(n_zero_variance_cols))\n \n # Correlations\n corr_matrix = feature_matrix.corr()\n\n # Extract the upper triangle of the correlation matrix\n upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k = 1).astype(np.bool))\n\n # Select the features with correlations above the threshold\n # Need to use the absolute value\n to_drop = [column for column in upper.columns if any(upper[column].abs() > correlation_threshold)]\n\n n_collinear = len(to_drop)\n \n feature_matrix = feature_matrix[[x for x in feature_matrix if x not in to_drop]]\n print('{} collinear columns removed with threshold: {}.'.format(n_collinear,\n correlation_threshold))\n \n total_removed = n_missing_cols + n_zero_variance_cols + n_collinear\n \n print('Total columns removed: ', total_removed)\n print('Shape after feature selection: {}.'.format(feature_matrix.shape))\n return feature_matrix","def nearest_points_indexes_without_self(matrix, num_to_keep):\n\n # Set the diagonal to 0\n np.fill_diagonal(matrix, 0)\n # Get the position for the resulted values\n sort_arg = np.argsort(matrix, axis=1)\n\n return sort_arg[:, : num_to_keep]","def compute_conn(D_knn, sigma = None):\n\n # create an empty matrix\n conn = np.zeros(D_knn.shape)\n\n # extract the neirest neighbors\n rows, cols = D_knn.nonzero()\n\n # chose a kernel width\n if sigma is None:\n sigma = np.mean(D_knn[rows, cols]) *1.5\n\n for i in range(len(rows)):\n r = rows[i]\n c = cols[i]\n #print(\"r = \" + str(r) + \" \\nc = \" + str(c) + '\\nD_knn[r, c] = ' + str(D_knn[r, c]))\n conn[r, c] = np.exp(- D_knn[r, c]**2/(2 * sigma**2))\n\n\n # make this a sparse matrix\n conn_sparse = csr_matrix(conn)\n\n return conn_sparse\n # make the connectivities symmetric\n M = conn.T - conn\n if issparse(M):\n M.data[M.data < 0] = 0\n else:\n M = np.where(M > 0, M, 0)\n conn_sym = conn + M\n\n # eliminate new zeros\n if issparse(conn_sym): conn_sym.eliminate_zeros()\n\n return conn_sym","def build_adjacency(self, connectivity_matrix, n_neighbours):\n \n #Get k strongest connections\n connections, idx = self.get_k_strongest_connections(connectivity_matrix, n_neighbours)\n \n #Sparse matrix\n M, k = connections.shape\n assert M, k == idx.shape #M - number of vertices. k == nearest neighbours \n assert connections.min() >= 0\n\n # Weights.\n sigma2 = np.mean(connections[:, -1])**2\n connections = np.exp(- connections**2 / sigma2)\n\n # Weight matrix.\n I = np.arange(0, M).repeat(k) #row\n J = idx.reshape(M*k) #col\n V = connections.reshape(M*k) #data \n W = sparse.coo_matrix((V, (I, J)), shape=(M, M)) #COO is a fast format for constructing sparse matrices\n\n # No self-connections.\n W.setdiag(0)\n\n # Non-directed graph.\n bigger = W.T > W\n W = W - W.multiply(bigger) + W.T.multiply(bigger)\n return W","def nearest_points_values_without_self(matrix, num_to_keep):\n\n # Set the diagonal to 0\n np.fill_diagonal(matrix, 0)\n # Get the position for the resulted values\n sort = np.sort(matrix, axis=1)\n\n return sort[:, : num_to_keep]","def sparsify_weights(self, threshold = 1e-6):\n weights = self.list_cnn[-1].get_weights()\n sparsified_weights = []\n for w in weights:\n bool_mask = (abs(w) > threshold).astype(int)\n sparsified_weights.append(w * bool_mask)\n self.list_cnn[-1].set_weights(sparsified_weights)","def choose_k ( \n feature_matrix,\n target_array,\n model_call,\n param_grid,\n scoring_func = accuracy,\n cv = KFoldStratifiedCV ( number_of_folds = 3 ),\n):\n grid_search_cv = GridSearchCV (\n model_callable = model_call,\n param_grid = param_grid,\n scoring_func = scoring_func,\n cv_object = cv,\n )\n \n # Get the last sorted value and take k from that values\n return sorted ( list ( grid_search_cv.get_cv_scores ( feature_matrix, target_array ) ), key = lambda x: x [ 1 ] ) [ -1 ][ 0 ][ \"k\" ]\n # End choose_k()","def max_nondiag(input_matrix, tol=1e-8):\n temp_matrix = np.copy(input_matrix)**2\n\n currMax = 0 # Stores the current maximum\n for i in xrange(len(input_matrix)):\n for j in xrange(i + 1, len(input_matrix)):\n if temp_matrix[i, j]**2 >= currMax:\n currMax = temp_matrix[i, j]**2\n imax = i\n jmax = j\n else:\n pass\n\n return imax, jmax","def compute_assignment(cost_matrix, munkres):\n cost_matrix = np.array(cost_matrix)\n\n if np.any(cost_matrix < 0):\n raise ValueError(\"cost_matrix contains negative values!\")\n\n # Munkres only handles square and rectangular matrices. It does *not* handle irregular matrices!\n # As a workaround the matrix is transposed and corresponding pairs are flipped.\n h, w = cost_matrix.shape\n if h > w:\n low_cost_pairs = np.array(munkres.compute(cost_matrix.T))[:, ::-1]\n else:\n low_cost_pairs = np.array(munkres.compute(cost_matrix))\n\n return low_cost_pairs","def confusion_matrix(scorer: Scorer, threshold=-math.inf,\n normalize=False):\n # Detection link matrix (indexed by annot ind)\n link_matrix = scorer.det_link_map\n # Construct linkmatrix inverse mapping (indexed by decl ind)\n link_matrix_decl = OrderedDict()\n for annot_ind in link_matrix:\n for decl_ind in link_matrix[annot_ind]:\n if decl_ind not in link_matrix_decl:\n link_matrix_decl[decl_ind] = []\n link_matrix_decl[decl_ind].append(annot_ind)\n\n u_decl_classes = sorted(set(scorer.declarations_table['class'])) + ['N/A']\n u_annot_classes = sorted(set(scorer.annotations_table['class'])) + ['N/A']\n\n valid_decls = scorer.declarations_table['confidence'] > threshold\n # Index for decls into declaration table\n valid_decls_inds = valid_decls[valid_decls].index\n valid_decls_inds = valid_decls[valid_decls].index\n valid_decls_inds_set = set(valid_decls_inds)\n\n ignore_annots = scorer.annotations_table.apply(\n scorer.annotation_ignorable_function, axis=1, result_type='reduce')\n\n count_matrix = np.full((len(u_annot_classes), len(u_decl_classes)), np.nan)\n n_decls = np.full((len(u_decl_classes), 1), np.nan)\n n_annots = np.full((len(u_annot_classes), 1), np.nan)\n\n for i_decl_class, decl_class in enumerate(u_decl_classes):\n decl_indicator = (scorer.declarations_table['class'] == decl_class) & \\\n valid_decls\n # Index for decls into declaration table\n decl_indicator_inds = decl_indicator[decl_indicator].index\n\n n_decls[i_decl_class] = decl_indicator.sum()\n\n for i_annot_class, annot_class in enumerate(u_annot_classes):\n if annot_class == 'N/A':\n # Count all decls that are on NO annotations\n n_annots[i_annot_class] = np.nan\n count_decls_no_annots = 0\n for decl_indicator_ind in decl_indicator_inds:\n annot_links = link_matrix_decl.get(decl_indicator_ind, None)\n if (annot_links is None) or (len(annot_links) == 0):\n count_decls_no_annots += 1\n count_matrix[i_annot_class, i_decl_class] = count_decls_no_annots\n\n elif decl_class == 'N/A':\n # Count all the annotations with NO declarations; ignore\n # ignorable annotations\n n_decls[i_decl_class] = np.nan\n annot_indicator = \\\n (scorer.annotations_table['class'] == annot_class) \\\n & ~ignore_annots\n annot_indicator_inds = annot_indicator[annot_indicator].index\n count_annots_no_decls = 0\n for annot_indicator_ind in annot_indicator_inds:\n if ((annot_indicator_ind not in link_matrix) or\n len(set(link_matrix[annot_indicator_ind]).\n intersection(valid_decls_inds_set)) == 0):\n count_annots_no_decls += 1\n count_matrix[i_annot_class, i_decl_class] = \\\n count_annots_no_decls\n\n else:\n # Count all the annotations that have AT LEAST ONE declaration\n # on them; ignore ignorable annotations\n annot_indicator = \\\n (scorer.annotations_table['class'] == annot_class) \\\n & ~ignore_annots\n annot_indicator_inds = annot_indicator[annot_indicator].index\n n_annots[i_annot_class] = annot_indicator.sum()\n\n count_annots_with_decls = 0\n for annot_indicator_ind in annot_indicator_inds:\n if annot_indicator_ind in link_matrix:\n if len(set(link_matrix[annot_indicator_ind]).\n intersection(decl_indicator_inds)) > 0:\n count_annots_with_decls += 1\n count_matrix[i_annot_class, i_decl_class] = \\\n count_annots_with_decls\n\n if normalize:\n count_matrix[0:-1, :] = count_matrix[0:-1, :] / n_annots[0:-1]\n count_matrix[-1, :] = count_matrix[-1, :] / scorer.num_frames\n\n # Store relevant confusion matrix outputs for returning\n ret_val = ConfusionMatrixResult(\n normalize=normalize, threshold=threshold,\n count_matrix=count_matrix, u_annot_classes=u_annot_classes,\n u_decl_classes=u_decl_classes, num_decls=n_decls,\n num_annots=n_annots)\n\n return ret_val","def get_communities_above_threshold(data, threshold_size):\n index_counts = data.index.value_counts()\n count_list = index_counts[index_counts > threshold_size].index.values.tolist()\n return count_list","def threshold_connect_components(map, threshold, copy=True):\n labels, _ = ndimage.label(map)\n weights = np.bincount(labels.ravel())\n if copy:\n map = map.copy()\n for label, weight in enumerate(weights):\n if label == 0:\n continue\n if weight < threshold:\n map[labels == label] = 0\n return map","def get_common_scoring_matrix(matrix_name):\n pass","def nearest_cluster(X,c):\n K = np.size(c,0)\n idx = np.zeros((np.size(X,0),1))\n arr = np.empty((np.size(X,0),1))\n for i in range(0,K):\n y = c[i]\n temp = np.ones((np.size(X,0),1))*y\n b = np.power(np.subtract(X,temp),2)\n a = np.sum(b,axis = 1)\n a.resize((np.size(X,0),1))\n arr = np.append(arr, a, axis=1)\n arr = np.delete(arr,0,axis=1)\n idx = np.argmin(arr, axis=1)\n return idx","def test_concentration():\n\n dense = np.random.randn(5, 10).astype('float32')\n sparse = np.random.randn(5, 10).astype('float32')\n sparse[:, 1:] /= 1e5\n weights = Variable(dense)\n dhl_dense_10 = dirichlet_likelihood(weights, alpha=10.0).data\n dhl_dense_01 = dirichlet_likelihood(weights, alpha=0.1).data\n weights = Variable(sparse)\n dhl_sparse_10 = dirichlet_likelihood(weights, alpha=10.0).data\n dhl_sparse_01 = dirichlet_likelihood(weights, alpha=0.1).data\n\n msg = \"Sparse vector has higher likelihood than dense with alpha=0.1\"\n assert dhl_sparse_01 > dhl_dense_01, msg\n msg = \"Dense vector has higher likelihood than sparse with alpha=10.0\"\n assert dhl_dense_10 > dhl_sparse_10, msg","def get_cvxopt_sparse_intf():\n import cvxpy.interface.cvxopt_interface.sparse_matrix_interface as smi\n return smi.SparseMatrixInterface()","def filter_collinearity(c, threshold):\n\t# ensure symmetric\n\tif c.shape[0] != c.shape[1]:\n\t\traise ValueError('input dataframe should be symmetrical in dimensions')\n\n\t# init drops list\n\tdrops = []\n\tmacor = [] # mean abs corrs\n\tcorrz = [] # the correlations\n\n\t## Iterate over each feature\n\tfinished = False\n\twhile not finished:\n\n\t\t# Whenever there's a break, this loop will start over\n\t\tfor i,nm in enumerate(c.columns):\n\t\t\tthis_col = c[nm].drop(nm).sort_values(na_position='first') # gets the column, drops the index of itself, and sorts\n\t\t\tthis_col_nms = this_col.index.tolist()\n\t\t\tthis_col = np.array(this_col)\n\n\t\t\t# check if last value is over thresh\n\t\t\tmax_cor = this_col[-1]\n\t\t\tif pd.isnull(max_cor) or max_cor < threshold or this_col.shape[0] == 1:\n\t\t\t\tif i == c.columns.shape[0] - 1:\n\t\t\t\t\tfinished = True\n\n\t\t\t\t# control passes to next column name or end if finished\n\t\t\t\tcontinue\n\n\t\t\t# otherwise, we know the corr is over the threshold\n\t\t\t# gets the current col, and drops the same row, sorts asc and gets other col\n\t\t\tother_col_nm = this_col_nms[-1]\n\t\t\tthat_col = c[other_col_nm].drop(other_col_nm)\n\n\t\t\t# get the mean absolute correlations of each\n\t\t\tmn_1, mn_2 = np.nanmean(this_col), np.nanmean(that_col)\n\n\t\t\t# we might get nans?\n\t\t\t# if pd.isnull(mn_1) and pd.isnull(mn_2):\n\t\t\t\t# this condition is literally impossible, as it would\n\t\t\t\t# require every corr to be NaN, and it wouldn't have\n\t\t\t\t# even gotten here without hitting the continue block.\n\t\t\tif pd.isnull(mn_1):\n\t\t\t\tdrop_nm = other_col_nm\n\t\t\telif pd.isnull(mn_2):\n\t\t\t\tdrop_nm = nm\n\t\t\telse:\n\t\t\t\tdrop_nm = nm if mn_1 > mn_2 else other_col_nm\n\n\t\t\t# drop the bad col, row\n\t\t\tc.drop(drop_nm, axis=1, inplace=True)\n\t\t\tc.drop(drop_nm, axis=0, inplace=True)\n\n\t\t\t# add the bad col to drops\n\t\t\tdrops.append(drop_nm)\n\t\t\tmacor.append(np.maximum(mn_1, mn_2))\n\t\t\tcorrz.append(_MCFTuple(\n\t\t\t\t\tfeature_x=drop_nm,\n\t\t\t\t\tfeature_y=nm if not nm == drop_nm else other_col_nm,\n\t\t\t\t\tabs_corr=max_cor,\n\t\t\t\t\tmac=macor[-1]\n\t\t\t\t))\n\n\t\t\t# if we get here, we have to break so the loop will \n\t\t\t# start over from the first (non-popped) column\n\t\t\tbreak\n\n\t\t# if not finished, restarts loop, otherwise will exit loop\n\n\t# return\n\treturn drops, macor, corrz","def create_preference_weighted_similarity_matrix(self):\n # We only need to compare the distances to points within the epsilon shell (to determine if a point is a core point)\n # Since the subspace scaling factor kappa is >>1 (and not <1), no distances to other points will be needed for \n # the core point evaluation\n\n # get points in epsilon shell: attententio point itself is not in neigh_ind list\n _, neigh_ind = self.neigbors_clf.radius_neighbors(radius=self.epsilon)\n row, col, pwsim = [], [], []\n for i, ith_neigh_ind in enumerate(neigh_ind):\n # Calculate preference weighted similarity measure with point and neighbors in eps shell\n sq_diffs = np.square(self.data[ith_neigh_ind,:] - self.data[i,:])\n sum_weighted_sq_diffs = np.inner(self.subspace_preference_vectors[i,:], sq_diffs)\n pwsim_ith = np.sqrt(sum_weighted_sq_diffs)\n \n # Info for sparse matrix\n pwsim.extend(pwsim_ith.tolist()) # Data\n row.extend([i]*(pwsim_ith.shape[0])) # ith Row \n col.extend(ith_neigh_ind.tolist()) # column info\n\n # Construct sparse matrix with data, row, and column info\n A = csr_matrix((pwsim, (row, col)), shape=(self.nb_points, self.nb_points))\n # Create symmetric version: take the elementwise maximum of A and its transpose A.T\n transpose_is_bigger = A.T>A\n A = A - A.multiply(transpose_is_bigger) + (A.T).multiply(transpose_is_bigger)\n \n return A","def find_metric_threshold(self):\n logger.info(\"compute metric threshold\")\n\n ### Beaucoup trop lent quand on a beaucoup de models ###\n\n df_results_not_aggregated = self.result_reader.load_all_results(aggregate=False)\n\n if len(df_results_not_aggregated) == 0:\n logger.info(\"threshold = None\")\n return None\n\n main_scorer = \"test_%s\" % self.job_config.main_scorer\n (df_results_not_aggregated[main_scorer].fillna(df_results_not_aggregated[main_scorer].min(), inplace=True))\n min_cv = df_results_not_aggregated.groupby(\"job_id\")[main_scorer].min().values\n delta_min_max_cv = np.median(\n df_results_not_aggregated.groupby(\"job_id\")[main_scorer].apply(lambda x: x.max() - x.min())\n )\n\n if len(min_cv) <= self.min_nb_of_models:\n logger.info(\"threshold = None\")\n return None\n\n min_cv = -np.sort(-min_cv)\n result = min_cv[self.min_nb_of_models] - delta_min_max_cv\n\n # result = np.percentile( min_cv, self._get_quantile(len(min_cv)) * 100)\n # TODO : ici peut etre faire une estimation parametric du quantile avec un Kernel, plus smooth et moins sensible quand peu de valeurs\n\n logger.info(\"threshold : %2.2f\" % result)\n return result","def apply_threshold(heatmap, threshold):\n heatmap_thresh = np.copy(heatmap)\n ind = np.where(np.logical_and(heatmap_thresh>1, heatmap_thresh<=threshold))\n heatmap_thresh[ind] = 0\n #heatmap_thresh[(heatmap_thresh <= threshold)] = 0\n return heatmap_thresh","def keep_topk(adj_mat, top_k=3, directed=True):\n # Set values that are not of top-k neighbors to 0:\n adj_mat_noSelfEdge = adj_mat.copy()\n for i in range(adj_mat_noSelfEdge.shape[0]):\n adj_mat_noSelfEdge[i, i] = 0\n\n top_k_idx = (-adj_mat_noSelfEdge).argsort(axis=-1)[:, :top_k]\n\n mask = np.eye(adj_mat.shape[0], dtype=bool)\n for i in range(0, top_k_idx.shape[0]):\n for j in range(0, top_k_idx.shape[1]):\n mask[i, top_k_idx[i, j]] = 1\n if not directed:\n mask[top_k_idx[i, j], i] = 1 # symmetric\n\n adj_mat = mask * adj_mat\n return adj_mat","def search_matrix(to_search: int, a_matrix: list) -> (int, int):\n row = 0\n column = len(a_matrix[0]) - 1\n while row < len(a_matrix) and column >= 0:\n if to_search < a_matrix[row][column]:\n column -= 1\n elif to_search > a_matrix[row][column]:\n row += 1\n else:\n return row, column\n return -1, -1","def threshold_arr(cmat, threshold=0.0, threshold2=None):\r\n # Select thresholds\r\n if threshold2 is None:\r\n th_low = -np.inf\r\n th_hi = threshold\r\n else:\r\n th_low = threshold\r\n th_hi = threshold2\r\n\r\n # Mask out the values we are actually going to use\r\n idx = np.where((cmat < th_low) | (cmat > th_hi))\r\n vals = cmat[idx]\r\n\r\n return idx + (vals,)","def min(weightData , dataSetVector ):\r\n # weightData: pass the whole weightData array.\r\n # dataSetVector: pass the a data vector to compare with weightdata array, to find its closest match\r\n winnerIndex = 0 #flag for initalizing the winner index\r\n minValue = EcuDist(dataSetVector,weightData[0]) # initalize the minValue\r\n # iterate through all weighdata rows to find the closest match, depending on ecu. distance,\r\n #and then return the index of the closest match(winner)\r\n for i in range(weightData.shape[0]):\r\n if(EcuDist(dataSetVector,weightData[i]) < minValue):\r\n minValue = EcuDist(dataSetVector,weightData[i])\r\n winnerIndex = i\r\n return winnerIndex","def test_build_stump(self):\n D = np.mat(np.ones((5, 1)) / 5)\n best, min_err, best_estimate =\\\n ada_boost.build_stump(self.larger_matrix,\n self.larger_class_labels,\n D)\n expected = {'threshold': 1.3, 'dim': 0, 'inequal': 'lt'}\n self.assertEqual(best, expected)","def sparse2cvxopt(value):\n import cvxopt\n if isinstance(value, (np.ndarray, np.matrix)):\n return cvxopt.sparse(cvxopt.matrix(value.astype('float64')), tc='d')\n # Convert scipy sparse matrices to coo form first.\n elif sp.issparse(value):\n value = value.tocoo()\n return cvxopt.spmatrix(value.data.tolist(), value.row.tolist(),\n value.col.tolist(), size=value.shape, tc='d')","def search_matrix_parallel(to_search: int, a_matrix) -> (int, int):\n pool_size = len(a_matrix)\n\n with Pool(pool_size) as p:\n res = p.starmap(binary_search, [(a_matrix[i], to_search) for i in range(len(a_matrix))])\n\n for i, r in enumerate(res):\n if r != -1:\n return i, r\n\n return -1, -1","def get_sparse_knn_graph(df, k, algorithm):\n print(\"df shape\", df.shape)\n X = np.array(df)\n nbrs = NearestNeighbors(n_neighbors=k, algorithm=algorithm).fit(X)\n distances, indices = nbrs.kneighbors(X)\n knn_graph = nbrs.kneighbors_graph(X).toarray()\n print(\"indices, graph\", len(indices), knn_graph.shape)\n return indices, knn_graph","def matrix_search(m, el):\n rows, cols = len(m), len(m[0])\n r, c = 0, cols - 1\n\n while r < rows and c >= 0:\n if m[r][c] == el:\n break\n elif m[r][c] > el:\n c -= 1\n else:\n r += 1\n\n return r, c","def _find_min_pair(pandas_matrix):\n numpy_matrix = pandas_matrix.values\n mins = np.where(numpy_matrix == np.nanmin(numpy_matrix))\n min_col_idx = mins[0][0]\n min_row_idx = mins[1][0]\n (min_col, min_row) = (pandas_matrix.index[min_col_idx], \n pandas_matrix.columns[min_row_idx])\n\n return (min_col, min_row)","def apply_threshold(heatmap, threshold):\n # Zero out pixels below the threshold\n thresh_heatmap = np.copy(heatmap)\n thresh_heatmap[heatmap <= threshold] = 0\n # Return thresholded map\n return thresh_heatmap","def ZSparseMatrix2Scipy(matrix):\n data = np.ndarray(matrix.get_value_size(), dtype=float);\n outer_idx = np.ndarray(matrix.get_outer_size(), dtype=np.int32);\n inner_idx = np.ndarray(matrix.get_inner_size(), dtype=np.int32);\n\n matrix.get_values(data);\n matrix.get_outer_indices(outer_idx);\n matrix.get_inner_indices(inner_idx);\n\n return scipy.sparse.csc_matrix((data, inner_idx, outer_idx),\n shape = (matrix.num_rows(), matrix.num_cols()),\n dtype = float);","def get_top_segs_threshold(num_topics, doc_topic_matrix, threshold):\n\n\ttop_segs = []\n\tfor i in range(0, num_topics):\n\t\ttop_segs.append([])\n\tfor i in range(0, num_topics):\n\t\ttopic_doc = doc_topic_matrix[:,i]\n\t\tfor j in range(0, len(topic_doc)):\t\t\n\t\t\tif topic_doc[j] > threshold:\n\t\t\t\ttop_segs[i].append(j)\n\t\t\n\t\t\n\t\t\n\n\n\n\n\treturn top_segs","def _estimate_threshold(self, **kwargs):\n recompute_threshold = kwargs.pop('recompute_threshold', False)\n # if threshold is in table, then use it.\n current_setting = (self.beta, self.chi2dist.kwds['df'])\n threshold = None\n res = False\n if not recompute_threshold and current_setting in _gaussian_cusum_thresholds.keys():\n for e in _gaussian_cusum_thresholds[current_setting]:\n if e[0] == self.arl:\n threshold = np.array([e[1]])\n res = True\n # if threshold not is in table, estimate it\n if threshold is None:\n len_simulation = kwargs.pop('len_simulation', None)\n if len_simulation is None:\n len_simulation = 10 * self.arl\n self.log.info(\"estimating threshold...\")\n plain_cusum = Cusum(arl=self.arl, beta=self.beta)\n plain_cusum.gamma = self.gamma\n d2_training = self.chi2dist.rvs(size=(int(len_simulation), 1))\n kwargs.pop('x', None)\n res = plain_cusum._estimate_threshold(x=d2_training, dof=self.chi2dist.kwds['df'],\n **kwargs)\n threshold = plain_cusum.threshold\n self.threshold = threshold\n return res","def _solve_cg(lap_sparse, B, tol, return_full_prob=False):\n lap_sparse = lap_sparse.tocsc()\n X = []\n for i in range(len(B)):\n x0 = cg(lap_sparse, -B[i].toarray(), tol=tol)[0]\n X.append(x0)\n if not return_full_prob:\n X = np.array(X)\n X = np.argmax(X, axis=0)\n return X","def majority_voting(distances, labels, k):\n nearest_index = np.argsort(distances)\n k_neighbor_labels = []\n for i in range(k):\n index = nearest_index[i]\n label = labels[index]\n k_neighbor_labels.append(label)\n major_class = np.argmax(np.bincount(k_neighbor_labels))\n return major_class","def get_output(interpreter, top_k, score_threshold):\n scores = cvtf.output_tensor(interpreter, 0)\n categories = [\n Category(i, scores[i])\n for i in np.argpartition(scores, -top_k)[-top_k:]\n if scores[i] >= score_threshold\n ]\n return sorted(categories, key=operator.itemgetter(1), reverse=True)","def coranking_matrix(high_data, low_data):\n n, m = high_data.shape\n high_distance = distance.squareform(distance.pdist(high_data))\n low_distance = distance.squareform(distance.pdist(low_data))\n\n high_ranking = high_distance.argsort(axis=1).argsort(axis=1)\n low_ranking = low_distance.argsort(axis=1).argsort(axis=1)\n\n Q, xedges, yedges = np.histogram2d(high_ranking.flatten(),\n low_ranking.flatten(),\n bins=n)\n\n Q = Q[1:, 1:] # remove rankings which correspond to themselves\n return Q","def _matrix_store_smooth_downhill(self):\n \n import time\n from scipy import sparse as sparse\n from scipy.sparse import linalg as linalgs \n \n\n t = time.clock()\n\n\n size = 0\n for nl in self.neighbour_array_lo_hi:\n size += 3 # len(nl)\n\n row_array = np.empty(size, dtype = int)\n col_array = np.empty(size, dtype = int)\n slope_array = np.zeros(size)\n local_slope_array = np.zeros(64)\n\n\n idx=0 \n for row in range(0, len(self.neighbour_array_lo_hi)): \n neighbours = self.neighbour_array_lo_hi[row] \n npoints = self.tri.points[neighbours]\n\n ## work out (downhill) gradient to (max of three) nearby neighbours\n \n\n for col, column in enumerate(neighbours[0:3]): \n \n delta_h = self.height[column] - self.height[row] \n\n\n if delta_h < 0.0:\n delta_s2 = (self.x[column] - self.x[row])**2 + (self.y[column] - self.y[row])**2\n local_slope_array[col] = ( delta_h**2 / delta_s2 )**5\n\n elif delta_h == 0.0 and self.bmask[row] == False:\n local_slope_array[col] = 1.0e-20\n\n else:\n local_slope_array[col] = 1.0e-20 \n \n # Normalise this so that it conserves mass (note - low points will have no contributions here !) \n \n norm = local_slope_array[0:len(neighbours)].sum()\n if norm != 0.0:\n norm = 1.0 / norm\n\n for col, column in enumerate(neighbours[0:3]): \n row_array[idx] = row\n col_array[idx] = column \n slope_array[idx] = local_slope_array[col] * norm\n\n idx += 1\n\n # We can re-pack this array into a sparse matrix for v. fast computation of downhill operator \n\n slopeCOO = sparse.coo_matrix( (slope_array, (row_array, col_array)) ).T\n slopeMat = slopeCOO.tocsr() \n \n print \"SlopeMat.shape \", slopeMat.shape, size\n\n # slopeNormVec = np.array(slopeMat.sum(axis=1)).T[0]\n # slopeNormVec[slopeNormVec != 0.0] = 1.0 / slopeNormVec[slopeNormVec != 0.0]\n # slopeNormMat = sparse.eye(self.tri.npoints)\n # slopeNormMat.setdiag(slopeNormVec)\n # slopeMat = slopeNormMat.dot(slopeMat)\n\n slopeMat.eliminate_zeros()\n self.smoothDownhillMat = slopeMat\n\n return","def get_score_matrix(self) -> int:","def feature_selection(cls, tbl, thresh=-1):\n\n numerical_columns = [col for col in tbl.columns if col not in [\"F21\", \"F20\", \"F54\", \"Name\"]]\n X = tbl[numerical_columns[:-1]].values\n y = tbl[numerical_columns[-1]].values\n\n n = X.shape[1]\n slist = np.zeros((n, 3))\n slist[:, -1] = 1\n\n # identify relevant features\n slist[:, 0] = cls._c_correlation(X, y) # compute 'C-correlation'\n idx = slist[:, 0].argsort()[::-1]\n slist = slist[idx,]\n slist[:, 1] = idx\n if thresh < 0:\n thresh = np.median(slist[-1, 0])\n\n slist = slist[slist[:, 0] > thresh, :] # desc. ordered per SU[i,c]\n\n \"Identify redundant features among the relevant ones\"\n cache = {}\n m = len(slist)\n p_su, p, p_idx = cls._get_first_element(slist)\n for i in xrange(m):\n q_su, q, q_idx = cls._get_next_element(slist, p_idx)\n if q:\n # p, q = int(p), int(q)\n while q:\n if (p, q) in cache:\n pq_su = cache[(p, q)]\n else:\n pq_su = cls._symmetrical_uncertainty(X[:, int(p)], X[:, int(q)])\n cache[(p, q)] = pq_su\n\n if pq_su >= q_su:\n slist = cls._remove_element(slist, q_idx)\n q_su, q, q_idx = cls._get_next_element(slist, q_idx)\n\n p_su, p, p_idx = cls._get_next_element(slist, p_idx)\n if not p_idx:\n break\n\n sbest = slist[slist[:, 2] > 0, :2]\n selected_features = [int(ff) for ff in sbest[:, 1]]\n selected_features = [numerical_columns[i] for i in selected_features]\n selected_features.insert(0, \"Name\")\n selected_features.append(\"category\")\n new_tbl = tbl[selected_features]\n\n return new_tbl","def connected_component(self, threshold: float = 0.5, \n connectivity: int = 26):\n global_offset = self.global_offset\n seg = self > threshold\n seg = cc3d.connected_components(seg.array, connectivity=connectivity)\n return Chunk(seg, global_offset=global_offset)","def getRowHeuristics(matrix):\n row, col = matrix.shape\n rHeuristic = np.zeros((row,2)) # Dos columnas. La primera para indicar la columna la segunda para la Heuristica\n for i in range(0,row):\n rHeuristic[i,0] = int(i)\n #print (i,sum(matrix[:,i]), pesos[i], float(pesos[i]/sum(matrix[:,i])))\n rHeuristic[i,1] = 1/sum(matrix[i,:])\n return rHeuristic[rHeuristic[:,1].argsort()]","def find_most_coins_path(matrix):\n if type(matrix) != list or len(matrix) <= 0:\n return None\n\n def find_coin_path(matrix_2d, x=0, y=0):\n if x == len(matrix_2d) - 1 and y == len(matrix_2d[0]) - 1:\n return matrix_2d[x][y]\n else:\n right = None\n down = None\n if x + 1 < len(matrix_2d):\n right = matrix_2d[x][y] + find_coin_path(matrix_2d, x + 1, y)\n if y + 1 < len(matrix[0]):\n down = matrix_2d[x][y] + find_coin_path(matrix_2d, x, y + 1)\n if right and down:\n return right if right > down else down\n elif type(right) is int:\n return right\n elif type(down) is int:\n return down\n\n result = find_coin_path(matrix)\n\n return result","def high_level(low_scores, query, template_length):\n h_mat = prog_dynam_matrix(list(range(template_length)), query)\n h_mat.create_content()\n h_mat.fill_high(low_scores)\n h_mat.show()\n h_mat.optimal_path()","def test_sparsity_topk_mask_dykstra(self, l=1e-2):\n n = int(1e3)\n seed = np.random.RandomState(0)\n y = jnp.array(seed.randn(n))\n k = 10\n out_top_k_dykstra = sparse_soft_topk_mask_dykstra(y, k, l=l)\n self.assertAlmostEqual(\n y.argsort()[::-1][:k].sort().sum(),\n out_top_k_dykstra.argsort()[::-1][:k].sort().sum(),\n )\n self.assertAlmostEqual(len(jnp.where(out_top_k_dykstra > 0)[0]), k)","def calibrate_threshold(test_graphs):\r\n best_threshold = None\r\n best_result = None\r\n for threhold in range(1, 50):\r\n cur_res = evaluate_argument_mention(test_graphs, threhold)\r\n if (best_result is None) or (cur_res > best_result):\r\n best_result = cur_res\r\n best_threshold = threhold\r\n return (best_threshold, best_result)","def to_sparse(self):\n from divisi2.sparse import SparseMatrix\n return SparseMatrix(self, self.row_labels, self.col_labels)","def bestThreshold(lda_imlementation, vectorized_coded_revs, column, best_tops,\n coded_reviews_df):\n cat_array = lda_imlementation.transform(vectorized_coded_revs)\n\n topic_array = []\n for i in range(lda_imlementation.n_topics):\n coded_reviews_df['topic_'+str(i)] = cat_array[:, i]\n topic_array += ['topic_'+str(i)]\n\n # Compute ROC curve point\n y_score = sum([coded_reviews_df[top] for top in best_tops])\n fpr, tpr, thresholds = roc_curve(coded_reviews_df[column], y_score)\n\n\n auc_thresh = zip(fpr, tpr, thresholds)\n auc_df = pd.DataFrame(auc_thresh, columns=['fpr', 'tpr', 'threshold'])\n auc_df['dist'] = ((0-auc_df.fpr)**2 + (1-auc_df.tpr)**2)**.5\n return auc_df.threshold.iloc[auc_df.dist.argmin()]","def find_matching(confusion_matrix):\r\n _, n = confusion_matrix.shape\r\n path = []\r\n for i in range(n):\r\n max_val = -1e10\r\n max_ind = -1\r\n for j in range(n):\r\n if j in path:\r\n pass\r\n else:\r\n temp = confusion_matrix[i, j]\r\n if temp > max_val:\r\n max_val = temp\r\n max_ind = j\r\n path.append(max_ind)\r\n return path","def get_energy_sparse(self, circuit):\n return sparse_expectation(self.sparse, circuit.run())","def find_min_path(s, t, dist):\n\n rows = len(dist) - 1\n cols = len(dist[0]) - 1\n col = cols\n row = rows\n pos_str = \"Position: (row={} col={}) -> (row={} col={})\"\n cst_str = \"Cost: {}\"\n prev_row = row\n prev_col = col\n\n # init sparse path matrix\n sparse_path = [[\" \" for x in range(cols + 1)] for x in range(rows + 1)]\n sparse_path[0][0] = \"0\"\n\n # start with operation at (rows, cols) and work backwards\n sparse_path[rows][cols] = dist[rows][cols]\n\n if verbose == 2:\n print()\n print(\"Initial Minimum Path Matrix:\")\n print_matrix(s, t, sparse_path)\n\n while True:\n\n # bail out if we are in the corner\n if row == 0 and col == 0:\n break\n\n # if we are not at a matrix boundary\n if row != 0 and col != 0: # if at left edge or top row, cannot move diagonally\n\n # diagonal\n if (dist[row - 1][col - 1] == min(dist[row - 1][col],\n dist[row][col - 1],\n dist[row - 1][col - 1])) and (dist[row - 1][col - 1] == dist[row][col] or dist[row - 1][col - 1] == dist[row][col] - 1):\n sparse_path[row - 1][col - 1] = dist[row - 1][col - 1]\n temp_cost = dist[row - 1][col - 1]\n\n # move current cell\n prev_row = row\n prev_col = col\n if col > 0:\n col -= 1\n if row > 0:\n row -= 1\n\n if verbose == 2:\n print(pos_str.format(str(prev_row), str(prev_col), str(row), str(col)))\n print(cst_str.format(temp_cost))\n print()\n\n # left\n elif dist[row][col - 1] <= dist[row][col]:\n sparse_path[row][col - 1] = dist[row][col - 1]\n temp_cost = dist[row][col - 1]\n\n # move current cell\n prev_row = row\n prev_col = col\n if col > 0:\n col -= 1\n\n if verbose == 2:\n print(pos_str.format(str(prev_row), str(prev_col), str(row), str(col)))\n print(cst_str.format(temp_cost))\n print()\n\n # above\n else:\n sparse_path[row - 1][col] = dist[row - 1][col]\n temp_cost = dist[row - 1][col]\n\n # move current cell\n prev_row = row\n prev_col = col\n if row > 0:\n row -= 1\n\n if verbose == 2:\n print(pos_str.format(str(prev_row), str(prev_col), str(row), str(col)))\n print(cst_str.format(temp_cost))\n print()\n\n # if at matrix edge, can only move up\n elif col == 0:\n # above\n sparse_path[row - 1][col] = dist[row - 1][col]\n temp_cost = dist[row - 1][col]\n\n # move current cell\n prev_row = row\n prev_col = col\n if row > 0:\n row -= 1\n\n if verbose == 2:\n print(pos_str.format(str(prev_row), str(prev_col), str(row), str(col)))\n print(cst_str.format(temp_cost))\n print()\n\n # must be at row boundary, can only move left\n else:\n # left\n if dist[row][col - 1] <= dist[row][col]:\n sparse_path[row][col - 1] = dist[row][col - 1]\n temp_cost = dist[row][col - 1]\n\n # move current cell\n prev_row = row\n prev_col = col\n if col > 0:\n col -= 1\n\n if verbose == 2:\n print(pos_str.format(str(prev_row), str(prev_col), str(row), str(col)))\n print(cst_str.format(temp_cost))\n print()\n\n # print matrix\n if verbose == 2:\n print_matrix(s, t, sparse_path)\n\n return sparse_path","def getThreshold(similarities, scores):\n if len(similarities) < 3:\n return 0.8 # Default high threshold so that we start making some posts.\n posts = [{\"similarity\" : similarities[i], \"score\" : scores[i]}\n for i in range(len(similarities))]\n # Sort by similarity for convenience.\n posts = sorted(posts, key=lambda k: k[\"similarity\"])\n # Possible thresholds are midpoints between similarity scores.\n possibleThresholds = [(posts[i][\"similarity\"] + posts[i+1][\"similarity\"]) / 2.0\n for i in range(len(posts)-1)]\n # Return the threshold that minimizes the objective function.\n return min(possibleThresholds, key=lambda t: evaluateObjective(posts, t))","def adaptive_selection(p_values, data, alpha):\n HC_stat, max_idx_HC, HC_vec = HC_update(p_values, alpha)\n cscshm_stat, max_idx_cscshm, cscshm_vec = CsCsHM_update(p_values, alpha)\n thresh_HC = data[max_idx_HC]\n thresh_cscshm = data[max_idx_cscshm]\n nonnull_HC = np.where(data < thresh_HC, 0, data)\n nonnull_cscshm = np.where(data < thresh_cscshm, 0, data)\n return nonnull_HC, nonnull_cscshm","def _compute_adjacency_matrix(self):\n\n # Set up a quick-reference index to map cells to indexes\n for i, cell in enumerate(self.sim.cells):\n self._cell_indexes[cell] = i\n\n if all([self.sim.hub.cells == [self.sim.damaged],\n self.sim.damaged not in self.sim.cells]):\n # Add the \"damaged\" virtual cell to the index if we need it\n self._cell_indexes[self.sim.damaged] = len(self.sim.cells)\n\n node_count = len(list(self._cell_indexes.keys()))\n g_sparse = np.zeros((node_count, node_count), dtype=float)\n g_sparse[:] = np.inf\n\n for cluster in self.sim.clusters + [self.sim.hub]:\n cluster_tour = cluster.tour\n i = len(cluster_tour.vertices) - 1\n j = 0\n while j < len(cluster_tour.vertices):\n start_vertex = cluster_tour.vertices[i]\n stop_vertex = cluster_tour.vertices[j]\n\n start_pt = cluster_tour.points[start_vertex]\n stop_pt = cluster_tour.points[stop_vertex]\n distance = np.linalg.norm(stop_pt - start_pt)\n\n start_seg = cluster_tour.objects[start_vertex]\n stop_seg = cluster_tour.objects[stop_vertex]\n\n start_index = self._cell_indexes[start_seg]\n stop_index = self._cell_indexes[stop_seg]\n\n g_sparse[start_index, stop_index] = distance\n\n i = j\n j += 1\n\n g_sparse = sp.csgraph_from_dense(g_sparse, null_value=np.inf)\n return g_sparse","def feature_calculator(args, graph):\n index_1 = [edge[0] for edge in graph.edges()]\n index_2 = [edge[1] for edge in graph.edges()]\n values = [1 for edge in graph.edges()]\n node_count = max(max(index_1)+1,max(index_2)+1)\n adjacency_matrix = sparse.coo_matrix((values, (index_1,index_2)),shape=(node_count,node_count),dtype=np.float32)\n degrees = adjacency_matrix.sum(axis=0)[0].tolist()\n degs = sparse.diags(degrees, [0])\n normalized_adjacency_matrix = degs.dot(adjacency_matrix)\n target_matrices = [normalized_adjacency_matrix.todense()]\n powered_A = normalized_adjacency_matrix\n if args.window_size > 1:\n for power in tqdm(range(args.window_size-1), desc = \"Adjacency matrix powers\"):\n powered_A = powered_A.dot(normalized_adjacency_matrix)\n to_add = powered_A.todense()\n target_matrices.append(to_add)\n target_matrices = np.array(target_matrices)\n return target_matrices","def bestThreshold2(lda_imlementation, vectorized_coded_revs, column, best_tops,\n coded_reviews_df):\n cat_array = lda_imlementation.transform(vectorized_coded_revs)\n\n topic_array = []\n for i in range(lda_imlementation.n_topics):\n coded_reviews_df['topic_'+str(i)] = cat_array[:, i]\n topic_array += ['topic_'+str(i)]\n\n # Compute ROC curve point\n y_score = sum([coded_reviews_df[top] for top in best_tops])\n precision, recall, thresh = precision_recall_curve(\n coded_reviews_df[column], y_score)\n\n\n prc_thresh = zip(precision, recall, thresh)\n prc_df = pd.DataFrame(prc_thresh, columns=['prec', 'recall', 'threshold'])\n prc_df['dist'] = ((1-prc_df.prec)**2 + (1-prc_df.recall)**2)**.5\n return prc_df.threshold.iloc[prc_df.dist.argmin()]","def cluster_threshold(stat_map, domain, th, csize):\n if stat_map.shape[0] != domain.size:\n raise ValueError('incompatible dimensions')\n\n # first build a domain of supra_threshold regions\n thresholded_domain = domain.mask(stat_map > th)\n\n # get the connected components\n label = thresholded_domain.connected_components()\n\n binary = - np.ones(domain.size)\n binary[stat_map > th] = label\n nbcc = len(np.unique(label))\n for i in range(nbcc):\n if np.sum(label == i) < csize:\n binary[binary == i] = - 1\n\n binary = (binary > -1)\n return binary","def train_threshold(ref_centroids, feature_mat, k):\n all_dist = list()\n overall_max_dist = 0\n for i in range(len(feature_mat)):\n feature_vec = feature_mat[i]\n centroids_, distortion_ = cluster_feature(feature_vec, k)\n centroids_ = centroids_.reshape(len(centroids_), -1)\n\n # Compute distortion to decide the threshold\n # scipy.cdist: Computes distance between each pair of the two collections of inputs\n # Get the average minimum distance of each i to j pair where i is not equal to j\n dist = cdist(ref_centroids, centroids_, 'euclidean')\n code = dist.argmin(axis=1)\n min_dist_list = dist[np.arange(len(code)), code]\n avg_min_dist = min_dist_list.mean(axis=-1)\n all_dist.append(avg_min_dist)\n overall_max_dist = max(overall_max_dist, avg_min_dist)\n np_all_dist = np.asarray(all_dist)\n mean = np_all_dist.mean()\n std = np_all_dist.std()\n threshold = mean + 2 * std\n return threshold"],"string":"[\n \"def get_approx_preRes_old(self, connectivity_threshold, i):\\n key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]\\n val = np.array(sparse_dict[key_]).copy()\\n return val\",\n \"def nearest_sparse(self, query):\\n self.best_dist = float(\\\"inf\\\")\\n self.best_element = None\\n self._register_best_element = self._register_best_element_single \\n self._nearest_sparse_recursive(self._sparse2seq(query), self.root, 0.0)\\n return self.best_element,self.best_dist\",\n \"def similarity_matrix_topk(item_score_matrix, topk=100,verbose=False):\\n\\n assert(item_score_matrix.shape[0] == item_score_matrix.shape[1]), \\\"the score matrix is not square\\\"\\n start_time = time.time()\\n if verbose:\\n print(\\\"generaing topk matrix\\\")\\n\\n # iterate over each column and keep only the topk similar items\\n\\n data, row_indices, col_indptr = [], [], []\\n item_score_matrix = item_score_matrix.tocsc()\\n n_items = item_score_matrix.shape[0]\\n\\n for item_index in range(item_score_matrix.shape[0]):\\n col_indptr.append(len(data))\\n start_position = item_score_matrix.indptr[item_index]\\n end_position = item_score_matrix.indptr[item_index+1]\\n col_data = item_score_matrix.data[start_position:end_position]\\n col_row_index = item_score_matrix.indices[start_position:end_position]\\n\\n index_sorted = np.argsort(col_data)\\n topk_index = index_sorted[-topk:]\\n\\n data.extend(col_data[topk_index])\\n row_indices.extend(col_row_index[topk_index])\\n col_indptr.append(len(data))\\n\\n result = sps.csc_matrix((data, row_indices, col_indptr), shape=(n_items, n_items), dtype=np.float32)\\n result = result.tocsr()\\n\\n if verbose:\\n print(\\\"sparse topk matrix generated in {:.2f} seconds\\\".format(time.time()-start_time))\\n\\n return result\",\n \"def best_match(psi1, psi2, threshold=None):\\n if threshold is None:\\n threshold = (2 * psi1.shape[0])**-0.25\\n Q = np.abs(psi1.T.conj() @ psi2) # Overlap matrix\\n orig, perm = so.linear_sum_assignment(-Q)\\n return perm, Q[orig, perm] < threshold\",\n \"def order_selection(C, threshold):\\n return len([l for l in np.linalg.eigvalsh(C) if l >= threshold])\",\n \"def get_most_similar(distances):\\n threshold = get_threshold(distances)\\n most_similar = list()\\n distances = sorted(distances, key=lambda x: x[0])\\n\\n for i in distances:\\n if i[0] < threshold:\\n most_similar.append(i)\\n else:\\n break\\n\\n return most_similar\",\n \"def Threshold(self, threshold=0.0):\\n return _hypre.HypreParMatrix_Threshold(self, threshold)\",\n \"def nearest_min(dist_matrix):\\n # much faster than np.where\\n i, j = np.unravel_index(\\n np.argmin(dist_matrix), \\n dims=dist_matrix.shape\\n )\\n return i, j\",\n \"def get_pair_lookup(fold, threshold=1, force=False):\\n try:\\n assert not force # this is some hacky control flow right here\\n M = load_cooc_matrix(fold)\\n logging.info('Loaded cooc matrix')\\n except (AssertionError, IOError):\\n logging.info('Building cooc matrix')\\n users = iterate_wrapped_users(fold)\\n with time_me('Built cooc matrix', mode='print'):\\n M = build_cooc_matrix(users)\\n M = M.tocoo()\\n # converting to coo at this point might provide some memory relief\\n save_cooc_matrix(fold, M)\\n\\n logging.info('Loaded cooc matrix with {:,} nonzero entries'.format(M.nnz))\\n next_ix = 0\\n lookup = {}\\n # Turns out using scipy.sparse.find is slow af\\n #with time_me('finded'):\\n # focals, others, counts = scipy.sparse.find(M)\\n assert isinstance(M, scipy.sparse.coo_matrix)\\n focals, others, counts = M.row, M.col, M.data\\n #for i in xrange(len(counts)):\\n # focal_pidx = focals[i]\\n # other_pidx = others[i]\\n # count = counts[i]\\n for (focal_pidx, other_pidx, count) in itertools.izip(focals, others, counts):\\n\\n if count >= threshold:\\n k = (focal_pidx+1, other_pidx+1)\\n lookup[k] = next_ix\\n next_ix += 1\\n if next_ix % 10**6 == 0:\\n print '{:,}... '.format(next_ix)\\n\\n logging.info('Went from {:,} non-zero entries to {:,} pairs after thresholding by {}'.format(\\n M.nnz, next_ix, threshold))\\n if next_ix + constants.N_PRODUCTS > 2**31:\\n logging.warn(\\\"Too many features even after thresholding. You're gonna have a bad time.\\\")\\n return lookup\",\n \"def get_best_sensitivity_metrics(self,\\n verbose: bool = True) -> Tuple[int, int]:\\n sensitivity_scores = list()\\n for i in self.search_space:\\n classes = self.convert_classes(threshold=i)\\n tn, fp, fn, tp = confusion_matrix(self.y_true, classes).ravel()\\n sensitivity = tp / (tp + fn)\\n sensitivity_scores.append(sensitivity)\\n best_sensitivity_score, best_sensitivity_threshold = self._get_best_metrics(\\n metric_type='sensitivity_score',\\n scores=sensitivity_scores,\\n greater_is_better=True,\\n verbose=verbose\\n )\\n return best_sensitivity_score, best_sensitivity_threshold\",\n \"def mkgraph(cmat, threshold=0.0, threshold2=None):\\r\\n\\r\\n # Input sanity check\\r\\n nrow, ncol = cmat.shape\\r\\n if nrow != ncol:\\r\\n raise ValueError(\\\"Adjacency matrix must be square\\\")\\r\\n\\r\\n row_idx, col_idx, vals = threshold_arr(cmat, threshold, threshold2)\\r\\n # Also make the full thresholded array available in the metadata\\r\\n cmat_th = np.empty_like(cmat)\\r\\n if threshold2 is None:\\r\\n cmat_th.fill(threshold)\\r\\n else:\\r\\n cmat_th.fill(-np.inf)\\r\\n cmat_th[row_idx, col_idx] = vals\\r\\n\\r\\n # Next, make a normalized copy of the values. For the 2-threshold case, we\\r\\n # use 'folding' normalization\\r\\n if threshold2 is None:\\r\\n vals_norm = minmax_norm(vals)\\r\\n else:\\r\\n vals_norm = minmax_norm(vals, 'folding', [threshold, threshold2])\\r\\n\\r\\n # Now make the actual graph\\r\\n G = nx.Graph(weighted=True)\\r\\n G.add_nodes_from(list(range(nrow)))\\r\\n # To keep the weights of the graph to simple values, we store the\\r\\n # normalize ones in a separate dict that we'll stuff into the graph\\r\\n # metadata.\\r\\n\\r\\n normed_values = {}\\r\\n for i, j, val, nval in zip(row_idx, col_idx, vals, vals_norm):\\r\\n if i == j:\\r\\n # no self-loops\\r\\n continue\\r\\n G.add_edge(i, j, weight=val)\\r\\n normed_values[i, j] = nval\\r\\n\\r\\n # Write a metadata dict into the graph and save the threshold info there\\r\\n G.metadata = dict(threshold1=threshold,\\r\\n threshold2=threshold2,\\r\\n cmat_raw=cmat,\\r\\n cmat_th=cmat_th,\\r\\n vals_norm=normed_values,\\r\\n )\\r\\n return G\",\n \"def _fix_connectivity(X, connectivity, affinity):\\n n_samples = X.shape[0]\\n if connectivity.shape[0] != n_samples or connectivity.shape[1] != n_samples:\\n raise ValueError(\\n \\\"Wrong shape for connectivity matrix: %s when X is %s\\\"\\n % (connectivity.shape, X.shape)\\n )\\n\\n # Make the connectivity matrix symmetric:\\n connectivity = connectivity + connectivity.T\\n\\n # Convert connectivity matrix to LIL\\n if not sparse.issparse(connectivity):\\n connectivity = sparse.lil_matrix(connectivity)\\n\\n # `connectivity` is a sparse matrix at this point\\n if connectivity.format != \\\"lil\\\":\\n connectivity = connectivity.tolil()\\n\\n # Compute the number of nodes\\n n_connected_components, labels = connected_components(connectivity)\\n\\n if n_connected_components > 1:\\n warnings.warn(\\n \\\"the number of connected components of the \\\"\\n \\\"connectivity matrix is %d > 1. Completing it to avoid \\\"\\n \\\"stopping the tree early.\\\" % n_connected_components,\\n stacklevel=2,\\n )\\n # XXX: Can we do without completing the matrix?\\n connectivity = _fix_connected_components(\\n X=X,\\n graph=connectivity,\\n n_connected_components=n_connected_components,\\n component_labels=labels,\\n metric=affinity,\\n mode=\\\"connectivity\\\",\\n )\\n\\n return connectivity, n_connected_components\",\n \"def coef_to_adj(coef, threshold):\\n # coef = 0.5 * (np.abs(coef) + np.abs(coef.T))\\n # return coef\\n\\n coef = 0.5 * (coef + coef.T)\\n # top_threshold = int(coef.shape[0] ** 2 * threshold)\\n # top_index = np.unravel_index(np.argsort(coef.ravel())[-top_threshold:], coef.shape)\\n # top_val = coef[top_index][0]\\n # adj = np.where(np.abs(coef) > top_val, 1, 0)\\n samples_number = coef.shape[0]\\n neighbor_number = round(threshold*samples_number)\\n adj = np.zeros((samples_number, samples_number), dtype=np.int)\\n for i in range(samples_number):\\n top_index = np.argsort(np.abs(coef[i]))[::-1][0: neighbor_number]\\n adj[i][top_index] = 1\\n # adj = adj - np.diag(adj.diagonal())\\n # adj = sp.csr_matrix(adj)\\n return adj\",\n \"def bestF(score_matrix, gold_lex):\\n np.seterr(divide='ignore', invalid='ignore') # get nans instead of division by zero\\n best_f = 0\\n best_th = 0\\n\\n for th in np.linspace(0, 1, 101): # threshold\\n lex = (score_matrix >= th)\\n p = np.sum(lex * (lex == gold_lex)) / np.sum(lex)\\n r = np.sum(lex * (lex == gold_lex)) / np.sum(gold_lex)\\n f = 2 * (p * r) / (p + r)\\n\\n if f > best_f:\\n best_f = f\\n best_th = th\\n\\n return best_f, best_th\",\n \"def _kth_nearest_neighbor_dist(\\n distance_matrix: Union[np.ndarray, scipy.sparse.csr_matrix], k\\n) -> np.ndarray:\\n\\n if not is_integer(k):\\n raise ValueError(f\\\"parameter 'k={k}' must be a positive integer\\\")\\n else:\\n # make sure we deal with Python built-in\\n k = int(k)\\n\\n if not (0 <= k <= distance_matrix.shape[1]):\\n raise ValueError(\\n \\\"'k' must be an integer between 1 and \\\"\\n f\\\"distance_matrix.shape[1]={distance_matrix.shape[1]}\\\"\\n )\\n\\n if isinstance(distance_matrix, np.ndarray):\\n dist_knn = np.partition(distance_matrix, k - 1, axis=1)[:, k - 1]\\n elif isinstance(distance_matrix, scipy.sparse.csr_matrix):\\n # see mircobenchmark_kth_nn.py for a comparison of implementations for the\\n # sparse case\\n\\n def _get_kth_largest_elements_sparse(\\n data: np.ndarray,\\n indptr: np.ndarray,\\n row_nnz,\\n k_neighbor: int,\\n ):\\n dist_knn = np.zeros(len(row_nnz))\\n for i in range(len(row_nnz)):\\n start_row = indptr[i]\\n dist_knn[i] = np.partition(\\n data[start_row : start_row + row_nnz[i]], k_neighbor - 1\\n )[k_neighbor - 1]\\n\\n return dist_knn\\n\\n row_nnz = distance_matrix.getnnz(axis=1)\\n\\n if (row_nnz < k).any():\\n raise ValueError(\\n f\\\"There are {(row_nnz < k).sum()} points that \\\"\\n f\\\"do not have at least k_neighbor={k}.\\\"\\n )\\n\\n dist_knn = _get_kth_largest_elements_sparse(\\n distance_matrix.data,\\n distance_matrix.indptr,\\n row_nnz,\\n k,\\n )\\n else:\\n raise TypeError(f\\\"type {type(distance_matrix)} not supported\\\")\\n\\n return dist_knn\",\n \"def analyze_sensitivity_sparse_grid(sparse_grid,max_order=2):\\n from pyapprox.multivariate_polynomials import \\\\\\n define_poly_options_from_variable_transformation\\n from pyapprox.adaptive_sparse_grid import \\\\\\n convert_sparse_grid_to_polynomial_chaos_expansion\\n pce_opts=define_poly_options_from_variable_transformation(\\n sparse_grid.variable_transformation)\\n pce = convert_sparse_grid_to_polynomial_chaos_expansion(\\n sparse_grid,pce_opts)\\n pce_main_effects,pce_total_effects=\\\\\\n get_main_and_total_effect_indices_from_pce(\\n pce.get_coefficients(),pce.get_indices())\\n\\n interaction_terms, pce_sobol_indices = get_sobol_indices(\\n pce.get_coefficients(),pce.get_indices(),max_order=max_order)\\n \\n return SensivitityResult(\\n {'main_effects':pce_main_effects,\\n 'total_effects':pce_total_effects,\\n 'sobol_indices':pce_sobol_indices,\\n 'sobol_interaction_indices':interaction_terms,\\n 'pce':pce})\",\n \"def mask_sparse(self, threshold=10):\\n self.MaskPrefix = 's' + self.MaskPrefix\\n print('Masking pixels that do not have at least {0} coherent values'.format(threshold))\\n # each pixel assigned an integer corresponding to # of igrams where coherent\\n # NOTE: save coverage map if it doesn't exist already\\n coverage = self.get_coverage()\\n sparse = ma.masked_less(coverage, threshold)\\n for ig in self.Set:\\n igram = self.load_ma(ig)\\n igram[sparse.mask] = ma.masked\\n self.save_ma(ig, igram)\\n print('Done')\",\n \"def makesparse(matrix):\\n n = matrix[0].size\\n elements = []\\n for i in range(n):\\n for j in range(n):\\n if matrix[i][j] != 0 :\\n temp = MatrixElement(i, j, matrix[i][j])\\n elements.append(temp)\\n return SparseMatrix(n, elements)\",\n \"def count_matrix_largest(self, effective=False):\\n return self.count_matrix(connected_set=0, effective=effective)\",\n \"def search_similar(word_map, matrix, query, threshold=0.95):\\n if query not in word_map:\\n print(query, \\\"not found\\\")\\n return None\\n\\n words = ['' for i in range(len(word_map))]\\n for word in word_map:\\n words[word_map[word]] = word\\n\\n num_rows = matrix.shape[0]\\n vector = matrix[word_map[query]]\\n for i in range(num_rows):\\n test_vector = matrix[i]\\n if cossim(test_vector, vector) >= threshold:\\n print(words[i])\",\n \"def convert_sparse_to_coo(s_mat):\\n return np.vstack(find(s_mat)).T\",\n \"def test_build_classification_matrix_sparse():\\n import scnym\\n\\n # generate a sparse matrix with ~10% of elements filled\\n B = np.zeros((100, 10))\\n ridx = np.random.choice(B.size, size=100, replace=True)\\n B.flat[ridx] = 1\\n B = sparse.csr_matrix(B)\\n\\n # create dummy gene names where the order of\\n # genes in `B` is permuted\\n A_genes = np.arange(10)\\n B_genes = np.random.permutation(A_genes)\\n\\n # build the classification matrix\\n X = scnym.utils.build_classification_matrix(\\n X=B,\\n model_genes=A_genes,\\n sample_genes=B_genes,\\n )\\n assert sparse.issparse(X)\\n\\n # X should have the genes of B in the order of A\\n for i, g in enumerate(A_genes):\\n j = int(np.where(B_genes == g)[0])\\n assert np.all(X[:, i].toarray() == B[:, j].toarray())\\n return\",\n \"def nearest_points_values_with_self(matrix, num_to_keep):\\n\\n # Set the diagonal to 1\\n np.fill_diagonal(matrix, 1)\\n # Get the position for the resulted values\\n sort = np.sort(matrix, axis=1)\\n\\n return sort[:, : num_to_keep]\",\n \"def bipartite_matching(data=None, is_ascend=_Null, threshold=_Null, topk=_Null, out=None, name=None, **kwargs):\\n return (0,)\",\n \"def find_best_feature_threshold(self, X, Y):\\n nan_direction = 0\\n best_gain = - np.inf\\n best_feature, best_threshold = None, None\\n rsts = None\\n\\n # for each feature, find its best_threshold and best_gain, finally select the largest gain\\n # implement in parallel\\n cols = list(X.columns)\\n data = pd.concat([X, Y], axis=1)\\n\\n func = partial(self.find_best_threshold, data)\\n if self.num_thread == -1:\\n pool = Pool()\\n rsts = pool.map(func, cols)\\n pool.close()\\n\\n else:\\n pool = Pool(self.num_thread)\\n rsts = pool.map(func, cols)\\n pool.close()\\n\\n for rst in rsts:\\n if rst[2] > best_gain:\\n best_gain = rst[2]\\n best_threshold = rst[1]\\n best_feature = rst[0]\\n\\n return best_feature, best_threshold, best_gain\",\n \"def nearest_points_indexes_with_self(matrix, num_to_keep):\\n\\n # Set the diagonal to 1\\n np.fill_diagonal(matrix, 1)\\n # Get the position for the resulted values\\n sort_arg = np.argsort(matrix, axis=1)\\n\\n return sort_arg[:, : num_to_keep]\",\n \"def label_simplex(grid, simplex, thresh):\\n coords = [grid[:,x] for x in simplex]\\n dist = squareform(pdist(coords,'euclidean'))\\n adjacency = dist<thresh\\n adjacency = adjacency.astype(int) \\n graph = csr_matrix(adjacency)\\n n_components, labels = connected_components(csgraph=graph, directed=False, return_labels=True)\\n\\n return n_components\",\n \"def fit_from_scipy_sparse_matrix(self,\\n adj,\\n attr,\\n spatially_extensive_attr,\\n threshold,\\n solver=\\\"cbc\\\",\\n metric=\\\"euclidean\\\"):\\n self.metric = get_metric_function(metric)\\n check_solver(solver)\\n\\n prob = LpProblem(\\\"Max-p-Regions\\\", LpMinimize)\\n\\n # Parameters of the optimization problem\\n n_areas = adj.shape[0]\\n I = list(range(n_areas)) # index for areas\\n II = [(i, j) for i in I for j in I]\\n II_upper_triangle = [(i, j) for i, j in II if i < j]\\n # index of potential regions, called k in [DAR2012]_:\\n K = range(n_areas)\\n # index of contiguity order, called c in [DAR2012]_:\\n O = range(n_areas)\\n d = {(i, j): self.metric(attr[i].reshape(1, -1), attr[j].reshape(\\n 1, -1))\\n for i, j in II_upper_triangle}\\n h = 1 + floor(log10(sum(d[(i, j)] for i, j in II_upper_triangle)))\\n\\n # Decision variables\\n t = LpVariable.dicts(\\n \\\"t\\\", ((i, j) for i, j in II_upper_triangle),\\n lowBound=0,\\n upBound=1,\\n cat=LpInteger)\\n x = LpVariable.dicts(\\n \\\"x\\\", ((i, k, o) for i in I for k in K for o in O),\\n lowBound=0,\\n upBound=1,\\n cat=LpInteger)\\n\\n # Objective function\\n # (1) in Duque et al. (2012): \\\"The Max-p-Regions Problem\\\"\\n prob += -10**h * lpSum(x[i, k, 0] for k in K for i in I) \\\\\\n + lpSum(d[i, j] * t[i, j] for i, j in II_upper_triangle)\\n\\n # Constraints\\n # (2) in Duque et al. (2012): \\\"The Max-p-Regions Problem\\\"\\n for k in K:\\n prob += lpSum(x[i, k, 0] for i in I) <= 1\\n # (3) in Duque et al. (2012): \\\"The Max-p-Regions Problem\\\"\\n for i in I:\\n prob += lpSum(x[i, k, o] for k in K for o in O) == 1\\n # (4) in Duque et al. (2012): \\\"The Max-p-Regions Problem\\\"\\n for i in I:\\n for k in K:\\n for o in range(1, len(O)):\\n prob += x[i, k, o] <= lpSum(x[j, k, o - 1]\\n for j in neighbors(adj, i))\\n # (5) in Duque et al. (2012): \\\"The Max-p-Regions Problem\\\"\\n if isinstance(spatially_extensive_attr[I[0]], numbers.Real):\\n for k in K:\\n lhs = lpSum(x[i, k, o] * spatially_extensive_attr[i] for i in I\\n for o in O)\\n prob += lhs >= threshold * lpSum(x[i, k, 0] for i in I)\\n elif isinstance(spatially_extensive_attr[I[0]], collections.Iterable):\\n for el in range(len(spatially_extensive_attr[I[0]])):\\n for k in K:\\n lhs = lpSum(x[i, k, o] * spatially_extensive_attr[i][el]\\n for i in I for o in O)\\n if isinstance(threshold, numbers.Real):\\n rhs = threshold * lpSum(x[i, k, 0] for i in I)\\n prob += lhs >= rhs\\n elif isinstance(threshold, np.ndarray):\\n rhs = threshold[el] * lpSum(x[i, k, 0] for i in I)\\n prob += lhs >= rhs\\n # (6) in Duque et al. (2012): \\\"The Max-p-Regions Problem\\\"\\n for i, j in II_upper_triangle:\\n for k in K:\\n prob += t[i, j] >= \\\\\\n lpSum(x[i, k, o] + x[j, k, o] for o in O) - 1\\n # (7) in Duque et al. (2012): \\\"The Max-p-Regions Problem\\\"\\n # already in LpVariable-definition\\n # (8) in Duque et al. (2012): \\\"The Max-p-Regions Problem\\\"\\n # already in LpVariable-definition\\n\\n # additional constraint for speedup (p. 405 in [DAR2012]_)\\n for o in O:\\n prob += x[I[0], K[0], o] == (1 if o == 0 else 0)\\n\\n # Solve the optimization problem\\n solver = get_solver_instance(solver)\\n prob.solve(solver=solver)\\n result = np.zeros(n_areas)\\n for i in I:\\n for k in K:\\n for o in O:\\n if x[i, k, o].varValue == 1:\\n result[i] = k\\n self.labels_ = result\\n self.solver = solver\",\n \"def score(mat: Tensor, target: Tensor, k: int) -> tuple:\\n # number of users with similarities larger than the matched users\\n rank = (mat >= target).sum(1)\\n # rank = min(rank, k + 1)\\n rank = rank.min(torch.tensor(k + 1).cuda())\\n tmp = (k + 1 - rank).float()\\n # hit_precision@k\\n hit_score = (tmp / k).mean()\\n # precision@k\\n coverage = (tmp > 0).float().mean()\\n return coverage, hit_score\",\n \"def get_top_k(matrix,k):\\n assert k <= matrix.shape[1]\\n col_inds = np.argpartition(matrix, -k)[:,-k:].flatten()\\n row_inds = np.repeat(range(matrix.shape[0]),k)\\n\\n vals = matrix[row_inds, col_inds]\\n\\n return vals, col_inds\",\n \"def constant_feature_detect(data, threshold=0.98):\\n\\n data_copy = data.copy(deep=True)\\n quasi_constant_feature = []\\n for feature in data_copy.columns:\\n predominant = (\\n (data_copy[feature].value_counts() / np.float(len(data_copy)))\\n .sort_values(ascending=False)\\n .values[0]\\n )\\n if predominant >= threshold:\\n quasi_constant_feature.append(feature)\\n print(len(quasi_constant_feature), \\\" variables are found to be almost constant\\\")\\n return quasi_constant_feature\",\n \"def find(a):\\n\\n a = coo_matrix(a, copy=True)\\n a.sum_duplicates()\\n # remove explicit zeros\\n nz_mask = a.data != 0\\n return a.row[nz_mask], a.col[nz_mask], a.data[nz_mask]\",\n \"def filter_mat_simple(tol=1e-9, use_sparseness=False, **cov_kwargs):\\n cmat_simple = covariances.cov_mat_simple(**cov_kwargs)\\n cmat_simple = cmat_simple / tol + np.identity(cmat_simple.shape[0])\\n if \\\"bl_cutoff_buffer\\\" in cov_kwargs and np.isfinite(cov_kwargs[\\\"bl_cutoff_buffer\\\"]) and use_sparseness:\\n cmat_simple = covariances.convert_to_sparse_bands(cmat_simple)\\n # compute sparse inversion and return array.\\n filter_matrix = inv_banded(cmat_simple)\\n else:\\n filter_matrix = linalg.pinvh(cmat_simple)\\n return filter_matrix\",\n \"def largest_connected_submatrix(C, directed=True, lcc=None):\\n if lcc is None:\\n lcc = largest_connected_set(C, directed=directed)\\n\\n \\\"\\\"\\\"Row slicing\\\"\\\"\\\"\\n if scipy.sparse.issparse(C):\\n C_cc = C.tocsr()\\n else:\\n C_cc = C\\n C_cc = C_cc[lcc, :]\\n\\n \\\"\\\"\\\"Column slicing\\\"\\\"\\\"\\n if scipy.sparse.issparse(C):\\n C_cc = C_cc.tocsc()\\n C_cc = C_cc[:, lcc]\\n\\n if scipy.sparse.issparse(C):\\n return C_cc.tocoo()\\n else:\\n return C_cc\",\n \"def greedy_match(cost_matrix):\\n num_detections, num_tracks = cost_matrix.shape\\n distance_1d = cost_matrix.reshape(-1)\\n index_1d = np.argsort(distance_1d)\\n index_2d = np.stack([index_1d // num_tracks, index_1d % num_tracks], axis=1).astype(int, copy=False)\\n\\n matched_indices = []\\n matched_firsts = set()\\n matched_seconds = set()\\n\\n for (first_id, second_id) in index_2d:\\n if first_id not in matched_firsts and second_id not in matched_seconds:\\n matched_seconds.add(second_id)\\n matched_firsts.add(first_id)\\n matched_indices.append([first_id, second_id])\\n return np.array(matched_indices)\",\n \"def finalise_matrix(matrix):\\n if get_density(matrix) < DENSITY_THRESHOLD:\\n matrix = matrix.tocsc()\\n matrix.sort_indices()\\n else:\\n matrix = matrix.toarray()\\n if is_integer(matrix):\\n matrix = convert_to_smallest_int_type(matrix)\\n return matrix\",\n \"def top_k_betweenness_centrality(self):\\n d={}\\n l=[]\\n for v in vertices:\\n a=self.betweenness_centrality(v)\\n d[v]=a\\n l.append(a)\\n m=max(l)\\n l1=[]\\n for key in d:\\n if d[key]==m:\\n l1.append(key)\\n\\n return l1\",\n \"def _get2dCostMatrix(c_hat, time_step_indices: TimeStepIndices, track_count, measurement_count):\\n\\n # Compute track-measurement cost for single scan problem from hypothesis\\n # cost, including null assignment costs\\n # Construct track to measurement assignment matrix at scan k\\n cost = np.full((track_count, measurement_count), np.inf)\\n nullCost = np.full((track_count,), np.inf)\\n # store index of the single target hypothesis with the minimum cost for\\n # each track and measurement\\n idxCost = np.full((track_count, measurement_count), -1, dtype=np.int32)\\n idxNullCost = np.full((track_count,), -1, dtype=np.int32)\\n for track_id, trackNull_index_for_track in enumerate(time_step_indices.trackNull_index):\\n if len(trackNull_index_for_track):\\n min_index = c_hat[trackNull_index_for_track].argmin()\\n min_index_all_c_hat = trackNull_index_for_track[min_index]\\n nullCost[track_id] = c_hat[min_index_all_c_hat]\\n idxNullCost[track_id] = min_index_all_c_hat\\n # find single target hypotheses in track i that use this\\n # measurement if found, find the single target hypothesis with\\n # the minimum cost, and record its index\\n for measurement in range(measurement_count):\\n measTrack_index_for_meas = time_step_indices.measTrack_index[measurement, track_id]\\n if len(measTrack_index_for_meas):\\n min_index = c_hat[measTrack_index_for_meas].argmin()\\n min_index_all_c_hat = measTrack_index_for_meas[min_index]\\n cost[track_id, measurement] = c_hat[min_index_all_c_hat]\\n idxCost[track_id, measurement] = min_index_all_c_hat\\n\\n # Create cost matrix for nulls with null costs on diagonal and inf\\n # elsewhere (so we can have any number of null assignments)\\n nullCostMatrix = np.full((track_count, track_count), np.inf, dtype=np.float64)\\n # Pick out diagonal entries (like np.diagonal, but this is a writable view)\\n nullCostMatrix.ravel()[::track_count + 1] = nullCost\\n\\n fullCostMatrix = np.concatenate((cost, nullCostMatrix), axis=1)\\n return fullCostMatrix, idxCost, idxNullCost\",\n \"def get_approx_preRes(self, connectivity_threshold, i):\\n val = sparse_dict.get_approx_preRes(connectivity_threshold, index = i)\\n return val\",\n \"def connectivity(A, tol=1e-8):\\n #calculate L and eigenvalues of L\\n L = laplacian(A)\\n eigs, eigvec = la.eig(L)\\n num_cc = 0\\n #check zeros\\n for i in eigs:\\n if i < tol:\\n num_cc += 1\\n #fins the algebraic connectivity of G\\n sec_small = sorted(eigs)[1]\\n return num_cc, sec_small\",\n \"def modularity(self, threshold=0):\\n\\n N = self.K.shape[0] # number ROIs\\n C = np.eye(N) - (1 / N) * np.ones_like(N) # centering matrix\\n self.Kcen = C @ self.K @ C # center kernel matrix\\n\\n # Get eigenvector corresponding to maximum eigenvalue\\n self.evals, self.evecs = np.linalg.eig(self.Kcen)\\n self.qmax = self.evecs[:, np.argmax(np.diag(self.evals))]\\n\\n # Create community assignments\\n self.mod = self.qmax.copy()\\n self.mod[self.mod >= threshold] = 0\\n self.mod[self.mod < threshold] = 1\\n\\n return self\",\n \"def feature_selection(feature_matrix, missing_threshold=90, correlation_threshold=0.95):\\n \\n feature_matrix = pd.get_dummies(feature_matrix)\\n n_features_start = feature_matrix.shape[1]\\n print('Original shape: ', feature_matrix.shape)\\n\\n # Find missing and percentage\\n missing = pd.DataFrame(feature_matrix.isnull().sum())\\n missing['percent'] = 100 * (missing[0] / feature_matrix.shape[0])\\n missing.sort_values('percent', ascending = False, inplace = True)\\n\\n # Missing above threshold\\n missing_cols = list(missing[missing['percent'] > missing_threshold].index)\\n n_missing_cols = len(missing_cols)\\n\\n # Remove missing columns\\n feature_matrix = feature_matrix[[x for x in feature_matrix if x not in missing_cols]]\\n print('{} missing columns with threshold: {}.'.format(n_missing_cols,\\n missing_threshold))\\n \\n # Zero variance\\n unique_counts = pd.DataFrame(feature_matrix.nunique()).sort_values(0, ascending = True)\\n zero_variance_cols = list(unique_counts[unique_counts[0] == 1].index)\\n n_zero_variance_cols = len(zero_variance_cols)\\n\\n # Remove zero variance columns\\n feature_matrix = feature_matrix[[x for x in feature_matrix if x not in zero_variance_cols]]\\n print('{} zero variance columns.'.format(n_zero_variance_cols))\\n \\n # Correlations\\n corr_matrix = feature_matrix.corr()\\n\\n # Extract the upper triangle of the correlation matrix\\n upper = corr_matrix.where(np.triu(np.ones(corr_matrix.shape), k = 1).astype(np.bool))\\n\\n # Select the features with correlations above the threshold\\n # Need to use the absolute value\\n to_drop = [column for column in upper.columns if any(upper[column].abs() > correlation_threshold)]\\n\\n n_collinear = len(to_drop)\\n \\n feature_matrix = feature_matrix[[x for x in feature_matrix if x not in to_drop]]\\n print('{} collinear columns removed with threshold: {}.'.format(n_collinear,\\n correlation_threshold))\\n \\n total_removed = n_missing_cols + n_zero_variance_cols + n_collinear\\n \\n print('Total columns removed: ', total_removed)\\n print('Shape after feature selection: {}.'.format(feature_matrix.shape))\\n return feature_matrix\",\n \"def nearest_points_indexes_without_self(matrix, num_to_keep):\\n\\n # Set the diagonal to 0\\n np.fill_diagonal(matrix, 0)\\n # Get the position for the resulted values\\n sort_arg = np.argsort(matrix, axis=1)\\n\\n return sort_arg[:, : num_to_keep]\",\n \"def compute_conn(D_knn, sigma = None):\\n\\n # create an empty matrix\\n conn = np.zeros(D_knn.shape)\\n\\n # extract the neirest neighbors\\n rows, cols = D_knn.nonzero()\\n\\n # chose a kernel width\\n if sigma is None:\\n sigma = np.mean(D_knn[rows, cols]) *1.5\\n\\n for i in range(len(rows)):\\n r = rows[i]\\n c = cols[i]\\n #print(\\\"r = \\\" + str(r) + \\\" \\\\nc = \\\" + str(c) + '\\\\nD_knn[r, c] = ' + str(D_knn[r, c]))\\n conn[r, c] = np.exp(- D_knn[r, c]**2/(2 * sigma**2))\\n\\n\\n # make this a sparse matrix\\n conn_sparse = csr_matrix(conn)\\n\\n return conn_sparse\\n # make the connectivities symmetric\\n M = conn.T - conn\\n if issparse(M):\\n M.data[M.data < 0] = 0\\n else:\\n M = np.where(M > 0, M, 0)\\n conn_sym = conn + M\\n\\n # eliminate new zeros\\n if issparse(conn_sym): conn_sym.eliminate_zeros()\\n\\n return conn_sym\",\n \"def build_adjacency(self, connectivity_matrix, n_neighbours):\\n \\n #Get k strongest connections\\n connections, idx = self.get_k_strongest_connections(connectivity_matrix, n_neighbours)\\n \\n #Sparse matrix\\n M, k = connections.shape\\n assert M, k == idx.shape #M - number of vertices. k == nearest neighbours \\n assert connections.min() >= 0\\n\\n # Weights.\\n sigma2 = np.mean(connections[:, -1])**2\\n connections = np.exp(- connections**2 / sigma2)\\n\\n # Weight matrix.\\n I = np.arange(0, M).repeat(k) #row\\n J = idx.reshape(M*k) #col\\n V = connections.reshape(M*k) #data \\n W = sparse.coo_matrix((V, (I, J)), shape=(M, M)) #COO is a fast format for constructing sparse matrices\\n\\n # No self-connections.\\n W.setdiag(0)\\n\\n # Non-directed graph.\\n bigger = W.T > W\\n W = W - W.multiply(bigger) + W.T.multiply(bigger)\\n return W\",\n \"def nearest_points_values_without_self(matrix, num_to_keep):\\n\\n # Set the diagonal to 0\\n np.fill_diagonal(matrix, 0)\\n # Get the position for the resulted values\\n sort = np.sort(matrix, axis=1)\\n\\n return sort[:, : num_to_keep]\",\n \"def sparsify_weights(self, threshold = 1e-6):\\n weights = self.list_cnn[-1].get_weights()\\n sparsified_weights = []\\n for w in weights:\\n bool_mask = (abs(w) > threshold).astype(int)\\n sparsified_weights.append(w * bool_mask)\\n self.list_cnn[-1].set_weights(sparsified_weights)\",\n \"def choose_k ( \\n feature_matrix,\\n target_array,\\n model_call,\\n param_grid,\\n scoring_func = accuracy,\\n cv = KFoldStratifiedCV ( number_of_folds = 3 ),\\n):\\n grid_search_cv = GridSearchCV (\\n model_callable = model_call,\\n param_grid = param_grid,\\n scoring_func = scoring_func,\\n cv_object = cv,\\n )\\n \\n # Get the last sorted value and take k from that values\\n return sorted ( list ( grid_search_cv.get_cv_scores ( feature_matrix, target_array ) ), key = lambda x: x [ 1 ] ) [ -1 ][ 0 ][ \\\"k\\\" ]\\n # End choose_k()\",\n \"def max_nondiag(input_matrix, tol=1e-8):\\n temp_matrix = np.copy(input_matrix)**2\\n\\n currMax = 0 # Stores the current maximum\\n for i in xrange(len(input_matrix)):\\n for j in xrange(i + 1, len(input_matrix)):\\n if temp_matrix[i, j]**2 >= currMax:\\n currMax = temp_matrix[i, j]**2\\n imax = i\\n jmax = j\\n else:\\n pass\\n\\n return imax, jmax\",\n \"def compute_assignment(cost_matrix, munkres):\\n cost_matrix = np.array(cost_matrix)\\n\\n if np.any(cost_matrix < 0):\\n raise ValueError(\\\"cost_matrix contains negative values!\\\")\\n\\n # Munkres only handles square and rectangular matrices. It does *not* handle irregular matrices!\\n # As a workaround the matrix is transposed and corresponding pairs are flipped.\\n h, w = cost_matrix.shape\\n if h > w:\\n low_cost_pairs = np.array(munkres.compute(cost_matrix.T))[:, ::-1]\\n else:\\n low_cost_pairs = np.array(munkres.compute(cost_matrix))\\n\\n return low_cost_pairs\",\n \"def confusion_matrix(scorer: Scorer, threshold=-math.inf,\\n normalize=False):\\n # Detection link matrix (indexed by annot ind)\\n link_matrix = scorer.det_link_map\\n # Construct linkmatrix inverse mapping (indexed by decl ind)\\n link_matrix_decl = OrderedDict()\\n for annot_ind in link_matrix:\\n for decl_ind in link_matrix[annot_ind]:\\n if decl_ind not in link_matrix_decl:\\n link_matrix_decl[decl_ind] = []\\n link_matrix_decl[decl_ind].append(annot_ind)\\n\\n u_decl_classes = sorted(set(scorer.declarations_table['class'])) + ['N/A']\\n u_annot_classes = sorted(set(scorer.annotations_table['class'])) + ['N/A']\\n\\n valid_decls = scorer.declarations_table['confidence'] > threshold\\n # Index for decls into declaration table\\n valid_decls_inds = valid_decls[valid_decls].index\\n valid_decls_inds = valid_decls[valid_decls].index\\n valid_decls_inds_set = set(valid_decls_inds)\\n\\n ignore_annots = scorer.annotations_table.apply(\\n scorer.annotation_ignorable_function, axis=1, result_type='reduce')\\n\\n count_matrix = np.full((len(u_annot_classes), len(u_decl_classes)), np.nan)\\n n_decls = np.full((len(u_decl_classes), 1), np.nan)\\n n_annots = np.full((len(u_annot_classes), 1), np.nan)\\n\\n for i_decl_class, decl_class in enumerate(u_decl_classes):\\n decl_indicator = (scorer.declarations_table['class'] == decl_class) & \\\\\\n valid_decls\\n # Index for decls into declaration table\\n decl_indicator_inds = decl_indicator[decl_indicator].index\\n\\n n_decls[i_decl_class] = decl_indicator.sum()\\n\\n for i_annot_class, annot_class in enumerate(u_annot_classes):\\n if annot_class == 'N/A':\\n # Count all decls that are on NO annotations\\n n_annots[i_annot_class] = np.nan\\n count_decls_no_annots = 0\\n for decl_indicator_ind in decl_indicator_inds:\\n annot_links = link_matrix_decl.get(decl_indicator_ind, None)\\n if (annot_links is None) or (len(annot_links) == 0):\\n count_decls_no_annots += 1\\n count_matrix[i_annot_class, i_decl_class] = count_decls_no_annots\\n\\n elif decl_class == 'N/A':\\n # Count all the annotations with NO declarations; ignore\\n # ignorable annotations\\n n_decls[i_decl_class] = np.nan\\n annot_indicator = \\\\\\n (scorer.annotations_table['class'] == annot_class) \\\\\\n & ~ignore_annots\\n annot_indicator_inds = annot_indicator[annot_indicator].index\\n count_annots_no_decls = 0\\n for annot_indicator_ind in annot_indicator_inds:\\n if ((annot_indicator_ind not in link_matrix) or\\n len(set(link_matrix[annot_indicator_ind]).\\n intersection(valid_decls_inds_set)) == 0):\\n count_annots_no_decls += 1\\n count_matrix[i_annot_class, i_decl_class] = \\\\\\n count_annots_no_decls\\n\\n else:\\n # Count all the annotations that have AT LEAST ONE declaration\\n # on them; ignore ignorable annotations\\n annot_indicator = \\\\\\n (scorer.annotations_table['class'] == annot_class) \\\\\\n & ~ignore_annots\\n annot_indicator_inds = annot_indicator[annot_indicator].index\\n n_annots[i_annot_class] = annot_indicator.sum()\\n\\n count_annots_with_decls = 0\\n for annot_indicator_ind in annot_indicator_inds:\\n if annot_indicator_ind in link_matrix:\\n if len(set(link_matrix[annot_indicator_ind]).\\n intersection(decl_indicator_inds)) > 0:\\n count_annots_with_decls += 1\\n count_matrix[i_annot_class, i_decl_class] = \\\\\\n count_annots_with_decls\\n\\n if normalize:\\n count_matrix[0:-1, :] = count_matrix[0:-1, :] / n_annots[0:-1]\\n count_matrix[-1, :] = count_matrix[-1, :] / scorer.num_frames\\n\\n # Store relevant confusion matrix outputs for returning\\n ret_val = ConfusionMatrixResult(\\n normalize=normalize, threshold=threshold,\\n count_matrix=count_matrix, u_annot_classes=u_annot_classes,\\n u_decl_classes=u_decl_classes, num_decls=n_decls,\\n num_annots=n_annots)\\n\\n return ret_val\",\n \"def get_communities_above_threshold(data, threshold_size):\\n index_counts = data.index.value_counts()\\n count_list = index_counts[index_counts > threshold_size].index.values.tolist()\\n return count_list\",\n \"def threshold_connect_components(map, threshold, copy=True):\\n labels, _ = ndimage.label(map)\\n weights = np.bincount(labels.ravel())\\n if copy:\\n map = map.copy()\\n for label, weight in enumerate(weights):\\n if label == 0:\\n continue\\n if weight < threshold:\\n map[labels == label] = 0\\n return map\",\n \"def get_common_scoring_matrix(matrix_name):\\n pass\",\n \"def nearest_cluster(X,c):\\n K = np.size(c,0)\\n idx = np.zeros((np.size(X,0),1))\\n arr = np.empty((np.size(X,0),1))\\n for i in range(0,K):\\n y = c[i]\\n temp = np.ones((np.size(X,0),1))*y\\n b = np.power(np.subtract(X,temp),2)\\n a = np.sum(b,axis = 1)\\n a.resize((np.size(X,0),1))\\n arr = np.append(arr, a, axis=1)\\n arr = np.delete(arr,0,axis=1)\\n idx = np.argmin(arr, axis=1)\\n return idx\",\n \"def test_concentration():\\n\\n dense = np.random.randn(5, 10).astype('float32')\\n sparse = np.random.randn(5, 10).astype('float32')\\n sparse[:, 1:] /= 1e5\\n weights = Variable(dense)\\n dhl_dense_10 = dirichlet_likelihood(weights, alpha=10.0).data\\n dhl_dense_01 = dirichlet_likelihood(weights, alpha=0.1).data\\n weights = Variable(sparse)\\n dhl_sparse_10 = dirichlet_likelihood(weights, alpha=10.0).data\\n dhl_sparse_01 = dirichlet_likelihood(weights, alpha=0.1).data\\n\\n msg = \\\"Sparse vector has higher likelihood than dense with alpha=0.1\\\"\\n assert dhl_sparse_01 > dhl_dense_01, msg\\n msg = \\\"Dense vector has higher likelihood than sparse with alpha=10.0\\\"\\n assert dhl_dense_10 > dhl_sparse_10, msg\",\n \"def get_cvxopt_sparse_intf():\\n import cvxpy.interface.cvxopt_interface.sparse_matrix_interface as smi\\n return smi.SparseMatrixInterface()\",\n \"def filter_collinearity(c, threshold):\\n\\t# ensure symmetric\\n\\tif c.shape[0] != c.shape[1]:\\n\\t\\traise ValueError('input dataframe should be symmetrical in dimensions')\\n\\n\\t# init drops list\\n\\tdrops = []\\n\\tmacor = [] # mean abs corrs\\n\\tcorrz = [] # the correlations\\n\\n\\t## Iterate over each feature\\n\\tfinished = False\\n\\twhile not finished:\\n\\n\\t\\t# Whenever there's a break, this loop will start over\\n\\t\\tfor i,nm in enumerate(c.columns):\\n\\t\\t\\tthis_col = c[nm].drop(nm).sort_values(na_position='first') # gets the column, drops the index of itself, and sorts\\n\\t\\t\\tthis_col_nms = this_col.index.tolist()\\n\\t\\t\\tthis_col = np.array(this_col)\\n\\n\\t\\t\\t# check if last value is over thresh\\n\\t\\t\\tmax_cor = this_col[-1]\\n\\t\\t\\tif pd.isnull(max_cor) or max_cor < threshold or this_col.shape[0] == 1:\\n\\t\\t\\t\\tif i == c.columns.shape[0] - 1:\\n\\t\\t\\t\\t\\tfinished = True\\n\\n\\t\\t\\t\\t# control passes to next column name or end if finished\\n\\t\\t\\t\\tcontinue\\n\\n\\t\\t\\t# otherwise, we know the corr is over the threshold\\n\\t\\t\\t# gets the current col, and drops the same row, sorts asc and gets other col\\n\\t\\t\\tother_col_nm = this_col_nms[-1]\\n\\t\\t\\tthat_col = c[other_col_nm].drop(other_col_nm)\\n\\n\\t\\t\\t# get the mean absolute correlations of each\\n\\t\\t\\tmn_1, mn_2 = np.nanmean(this_col), np.nanmean(that_col)\\n\\n\\t\\t\\t# we might get nans?\\n\\t\\t\\t# if pd.isnull(mn_1) and pd.isnull(mn_2):\\n\\t\\t\\t\\t# this condition is literally impossible, as it would\\n\\t\\t\\t\\t# require every corr to be NaN, and it wouldn't have\\n\\t\\t\\t\\t# even gotten here without hitting the continue block.\\n\\t\\t\\tif pd.isnull(mn_1):\\n\\t\\t\\t\\tdrop_nm = other_col_nm\\n\\t\\t\\telif pd.isnull(mn_2):\\n\\t\\t\\t\\tdrop_nm = nm\\n\\t\\t\\telse:\\n\\t\\t\\t\\tdrop_nm = nm if mn_1 > mn_2 else other_col_nm\\n\\n\\t\\t\\t# drop the bad col, row\\n\\t\\t\\tc.drop(drop_nm, axis=1, inplace=True)\\n\\t\\t\\tc.drop(drop_nm, axis=0, inplace=True)\\n\\n\\t\\t\\t# add the bad col to drops\\n\\t\\t\\tdrops.append(drop_nm)\\n\\t\\t\\tmacor.append(np.maximum(mn_1, mn_2))\\n\\t\\t\\tcorrz.append(_MCFTuple(\\n\\t\\t\\t\\t\\tfeature_x=drop_nm,\\n\\t\\t\\t\\t\\tfeature_y=nm if not nm == drop_nm else other_col_nm,\\n\\t\\t\\t\\t\\tabs_corr=max_cor,\\n\\t\\t\\t\\t\\tmac=macor[-1]\\n\\t\\t\\t\\t))\\n\\n\\t\\t\\t# if we get here, we have to break so the loop will \\n\\t\\t\\t# start over from the first (non-popped) column\\n\\t\\t\\tbreak\\n\\n\\t\\t# if not finished, restarts loop, otherwise will exit loop\\n\\n\\t# return\\n\\treturn drops, macor, corrz\",\n \"def create_preference_weighted_similarity_matrix(self):\\n # We only need to compare the distances to points within the epsilon shell (to determine if a point is a core point)\\n # Since the subspace scaling factor kappa is >>1 (and not <1), no distances to other points will be needed for \\n # the core point evaluation\\n\\n # get points in epsilon shell: attententio point itself is not in neigh_ind list\\n _, neigh_ind = self.neigbors_clf.radius_neighbors(radius=self.epsilon)\\n row, col, pwsim = [], [], []\\n for i, ith_neigh_ind in enumerate(neigh_ind):\\n # Calculate preference weighted similarity measure with point and neighbors in eps shell\\n sq_diffs = np.square(self.data[ith_neigh_ind,:] - self.data[i,:])\\n sum_weighted_sq_diffs = np.inner(self.subspace_preference_vectors[i,:], sq_diffs)\\n pwsim_ith = np.sqrt(sum_weighted_sq_diffs)\\n \\n # Info for sparse matrix\\n pwsim.extend(pwsim_ith.tolist()) # Data\\n row.extend([i]*(pwsim_ith.shape[0])) # ith Row \\n col.extend(ith_neigh_ind.tolist()) # column info\\n\\n # Construct sparse matrix with data, row, and column info\\n A = csr_matrix((pwsim, (row, col)), shape=(self.nb_points, self.nb_points))\\n # Create symmetric version: take the elementwise maximum of A and its transpose A.T\\n transpose_is_bigger = A.T>A\\n A = A - A.multiply(transpose_is_bigger) + (A.T).multiply(transpose_is_bigger)\\n \\n return A\",\n \"def find_metric_threshold(self):\\n logger.info(\\\"compute metric threshold\\\")\\n\\n ### Beaucoup trop lent quand on a beaucoup de models ###\\n\\n df_results_not_aggregated = self.result_reader.load_all_results(aggregate=False)\\n\\n if len(df_results_not_aggregated) == 0:\\n logger.info(\\\"threshold = None\\\")\\n return None\\n\\n main_scorer = \\\"test_%s\\\" % self.job_config.main_scorer\\n (df_results_not_aggregated[main_scorer].fillna(df_results_not_aggregated[main_scorer].min(), inplace=True))\\n min_cv = df_results_not_aggregated.groupby(\\\"job_id\\\")[main_scorer].min().values\\n delta_min_max_cv = np.median(\\n df_results_not_aggregated.groupby(\\\"job_id\\\")[main_scorer].apply(lambda x: x.max() - x.min())\\n )\\n\\n if len(min_cv) <= self.min_nb_of_models:\\n logger.info(\\\"threshold = None\\\")\\n return None\\n\\n min_cv = -np.sort(-min_cv)\\n result = min_cv[self.min_nb_of_models] - delta_min_max_cv\\n\\n # result = np.percentile( min_cv, self._get_quantile(len(min_cv)) * 100)\\n # TODO : ici peut etre faire une estimation parametric du quantile avec un Kernel, plus smooth et moins sensible quand peu de valeurs\\n\\n logger.info(\\\"threshold : %2.2f\\\" % result)\\n return result\",\n \"def apply_threshold(heatmap, threshold):\\n heatmap_thresh = np.copy(heatmap)\\n ind = np.where(np.logical_and(heatmap_thresh>1, heatmap_thresh<=threshold))\\n heatmap_thresh[ind] = 0\\n #heatmap_thresh[(heatmap_thresh <= threshold)] = 0\\n return heatmap_thresh\",\n \"def keep_topk(adj_mat, top_k=3, directed=True):\\n # Set values that are not of top-k neighbors to 0:\\n adj_mat_noSelfEdge = adj_mat.copy()\\n for i in range(adj_mat_noSelfEdge.shape[0]):\\n adj_mat_noSelfEdge[i, i] = 0\\n\\n top_k_idx = (-adj_mat_noSelfEdge).argsort(axis=-1)[:, :top_k]\\n\\n mask = np.eye(adj_mat.shape[0], dtype=bool)\\n for i in range(0, top_k_idx.shape[0]):\\n for j in range(0, top_k_idx.shape[1]):\\n mask[i, top_k_idx[i, j]] = 1\\n if not directed:\\n mask[top_k_idx[i, j], i] = 1 # symmetric\\n\\n adj_mat = mask * adj_mat\\n return adj_mat\",\n \"def search_matrix(to_search: int, a_matrix: list) -> (int, int):\\n row = 0\\n column = len(a_matrix[0]) - 1\\n while row < len(a_matrix) and column >= 0:\\n if to_search < a_matrix[row][column]:\\n column -= 1\\n elif to_search > a_matrix[row][column]:\\n row += 1\\n else:\\n return row, column\\n return -1, -1\",\n \"def threshold_arr(cmat, threshold=0.0, threshold2=None):\\r\\n # Select thresholds\\r\\n if threshold2 is None:\\r\\n th_low = -np.inf\\r\\n th_hi = threshold\\r\\n else:\\r\\n th_low = threshold\\r\\n th_hi = threshold2\\r\\n\\r\\n # Mask out the values we are actually going to use\\r\\n idx = np.where((cmat < th_low) | (cmat > th_hi))\\r\\n vals = cmat[idx]\\r\\n\\r\\n return idx + (vals,)\",\n \"def min(weightData , dataSetVector ):\\r\\n # weightData: pass the whole weightData array.\\r\\n # dataSetVector: pass the a data vector to compare with weightdata array, to find its closest match\\r\\n winnerIndex = 0 #flag for initalizing the winner index\\r\\n minValue = EcuDist(dataSetVector,weightData[0]) # initalize the minValue\\r\\n # iterate through all weighdata rows to find the closest match, depending on ecu. distance,\\r\\n #and then return the index of the closest match(winner)\\r\\n for i in range(weightData.shape[0]):\\r\\n if(EcuDist(dataSetVector,weightData[i]) < minValue):\\r\\n minValue = EcuDist(dataSetVector,weightData[i])\\r\\n winnerIndex = i\\r\\n return winnerIndex\",\n \"def test_build_stump(self):\\n D = np.mat(np.ones((5, 1)) / 5)\\n best, min_err, best_estimate =\\\\\\n ada_boost.build_stump(self.larger_matrix,\\n self.larger_class_labels,\\n D)\\n expected = {'threshold': 1.3, 'dim': 0, 'inequal': 'lt'}\\n self.assertEqual(best, expected)\",\n \"def sparse2cvxopt(value):\\n import cvxopt\\n if isinstance(value, (np.ndarray, np.matrix)):\\n return cvxopt.sparse(cvxopt.matrix(value.astype('float64')), tc='d')\\n # Convert scipy sparse matrices to coo form first.\\n elif sp.issparse(value):\\n value = value.tocoo()\\n return cvxopt.spmatrix(value.data.tolist(), value.row.tolist(),\\n value.col.tolist(), size=value.shape, tc='d')\",\n \"def search_matrix_parallel(to_search: int, a_matrix) -> (int, int):\\n pool_size = len(a_matrix)\\n\\n with Pool(pool_size) as p:\\n res = p.starmap(binary_search, [(a_matrix[i], to_search) for i in range(len(a_matrix))])\\n\\n for i, r in enumerate(res):\\n if r != -1:\\n return i, r\\n\\n return -1, -1\",\n \"def get_sparse_knn_graph(df, k, algorithm):\\n print(\\\"df shape\\\", df.shape)\\n X = np.array(df)\\n nbrs = NearestNeighbors(n_neighbors=k, algorithm=algorithm).fit(X)\\n distances, indices = nbrs.kneighbors(X)\\n knn_graph = nbrs.kneighbors_graph(X).toarray()\\n print(\\\"indices, graph\\\", len(indices), knn_graph.shape)\\n return indices, knn_graph\",\n \"def matrix_search(m, el):\\n rows, cols = len(m), len(m[0])\\n r, c = 0, cols - 1\\n\\n while r < rows and c >= 0:\\n if m[r][c] == el:\\n break\\n elif m[r][c] > el:\\n c -= 1\\n else:\\n r += 1\\n\\n return r, c\",\n \"def _find_min_pair(pandas_matrix):\\n numpy_matrix = pandas_matrix.values\\n mins = np.where(numpy_matrix == np.nanmin(numpy_matrix))\\n min_col_idx = mins[0][0]\\n min_row_idx = mins[1][0]\\n (min_col, min_row) = (pandas_matrix.index[min_col_idx], \\n pandas_matrix.columns[min_row_idx])\\n\\n return (min_col, min_row)\",\n \"def apply_threshold(heatmap, threshold):\\n # Zero out pixels below the threshold\\n thresh_heatmap = np.copy(heatmap)\\n thresh_heatmap[heatmap <= threshold] = 0\\n # Return thresholded map\\n return thresh_heatmap\",\n \"def ZSparseMatrix2Scipy(matrix):\\n data = np.ndarray(matrix.get_value_size(), dtype=float);\\n outer_idx = np.ndarray(matrix.get_outer_size(), dtype=np.int32);\\n inner_idx = np.ndarray(matrix.get_inner_size(), dtype=np.int32);\\n\\n matrix.get_values(data);\\n matrix.get_outer_indices(outer_idx);\\n matrix.get_inner_indices(inner_idx);\\n\\n return scipy.sparse.csc_matrix((data, inner_idx, outer_idx),\\n shape = (matrix.num_rows(), matrix.num_cols()),\\n dtype = float);\",\n \"def get_top_segs_threshold(num_topics, doc_topic_matrix, threshold):\\n\\n\\ttop_segs = []\\n\\tfor i in range(0, num_topics):\\n\\t\\ttop_segs.append([])\\n\\tfor i in range(0, num_topics):\\n\\t\\ttopic_doc = doc_topic_matrix[:,i]\\n\\t\\tfor j in range(0, len(topic_doc)):\\t\\t\\n\\t\\t\\tif topic_doc[j] > threshold:\\n\\t\\t\\t\\ttop_segs[i].append(j)\\n\\t\\t\\n\\t\\t\\n\\t\\t\\n\\n\\n\\n\\n\\treturn top_segs\",\n \"def _estimate_threshold(self, **kwargs):\\n recompute_threshold = kwargs.pop('recompute_threshold', False)\\n # if threshold is in table, then use it.\\n current_setting = (self.beta, self.chi2dist.kwds['df'])\\n threshold = None\\n res = False\\n if not recompute_threshold and current_setting in _gaussian_cusum_thresholds.keys():\\n for e in _gaussian_cusum_thresholds[current_setting]:\\n if e[0] == self.arl:\\n threshold = np.array([e[1]])\\n res = True\\n # if threshold not is in table, estimate it\\n if threshold is None:\\n len_simulation = kwargs.pop('len_simulation', None)\\n if len_simulation is None:\\n len_simulation = 10 * self.arl\\n self.log.info(\\\"estimating threshold...\\\")\\n plain_cusum = Cusum(arl=self.arl, beta=self.beta)\\n plain_cusum.gamma = self.gamma\\n d2_training = self.chi2dist.rvs(size=(int(len_simulation), 1))\\n kwargs.pop('x', None)\\n res = plain_cusum._estimate_threshold(x=d2_training, dof=self.chi2dist.kwds['df'],\\n **kwargs)\\n threshold = plain_cusum.threshold\\n self.threshold = threshold\\n return res\",\n \"def _solve_cg(lap_sparse, B, tol, return_full_prob=False):\\n lap_sparse = lap_sparse.tocsc()\\n X = []\\n for i in range(len(B)):\\n x0 = cg(lap_sparse, -B[i].toarray(), tol=tol)[0]\\n X.append(x0)\\n if not return_full_prob:\\n X = np.array(X)\\n X = np.argmax(X, axis=0)\\n return X\",\n \"def majority_voting(distances, labels, k):\\n nearest_index = np.argsort(distances)\\n k_neighbor_labels = []\\n for i in range(k):\\n index = nearest_index[i]\\n label = labels[index]\\n k_neighbor_labels.append(label)\\n major_class = np.argmax(np.bincount(k_neighbor_labels))\\n return major_class\",\n \"def get_output(interpreter, top_k, score_threshold):\\n scores = cvtf.output_tensor(interpreter, 0)\\n categories = [\\n Category(i, scores[i])\\n for i in np.argpartition(scores, -top_k)[-top_k:]\\n if scores[i] >= score_threshold\\n ]\\n return sorted(categories, key=operator.itemgetter(1), reverse=True)\",\n \"def coranking_matrix(high_data, low_data):\\n n, m = high_data.shape\\n high_distance = distance.squareform(distance.pdist(high_data))\\n low_distance = distance.squareform(distance.pdist(low_data))\\n\\n high_ranking = high_distance.argsort(axis=1).argsort(axis=1)\\n low_ranking = low_distance.argsort(axis=1).argsort(axis=1)\\n\\n Q, xedges, yedges = np.histogram2d(high_ranking.flatten(),\\n low_ranking.flatten(),\\n bins=n)\\n\\n Q = Q[1:, 1:] # remove rankings which correspond to themselves\\n return Q\",\n \"def _matrix_store_smooth_downhill(self):\\n \\n import time\\n from scipy import sparse as sparse\\n from scipy.sparse import linalg as linalgs \\n \\n\\n t = time.clock()\\n\\n\\n size = 0\\n for nl in self.neighbour_array_lo_hi:\\n size += 3 # len(nl)\\n\\n row_array = np.empty(size, dtype = int)\\n col_array = np.empty(size, dtype = int)\\n slope_array = np.zeros(size)\\n local_slope_array = np.zeros(64)\\n\\n\\n idx=0 \\n for row in range(0, len(self.neighbour_array_lo_hi)): \\n neighbours = self.neighbour_array_lo_hi[row] \\n npoints = self.tri.points[neighbours]\\n\\n ## work out (downhill) gradient to (max of three) nearby neighbours\\n \\n\\n for col, column in enumerate(neighbours[0:3]): \\n \\n delta_h = self.height[column] - self.height[row] \\n\\n\\n if delta_h < 0.0:\\n delta_s2 = (self.x[column] - self.x[row])**2 + (self.y[column] - self.y[row])**2\\n local_slope_array[col] = ( delta_h**2 / delta_s2 )**5\\n\\n elif delta_h == 0.0 and self.bmask[row] == False:\\n local_slope_array[col] = 1.0e-20\\n\\n else:\\n local_slope_array[col] = 1.0e-20 \\n \\n # Normalise this so that it conserves mass (note - low points will have no contributions here !) \\n \\n norm = local_slope_array[0:len(neighbours)].sum()\\n if norm != 0.0:\\n norm = 1.0 / norm\\n\\n for col, column in enumerate(neighbours[0:3]): \\n row_array[idx] = row\\n col_array[idx] = column \\n slope_array[idx] = local_slope_array[col] * norm\\n\\n idx += 1\\n\\n # We can re-pack this array into a sparse matrix for v. fast computation of downhill operator \\n\\n slopeCOO = sparse.coo_matrix( (slope_array, (row_array, col_array)) ).T\\n slopeMat = slopeCOO.tocsr() \\n \\n print \\\"SlopeMat.shape \\\", slopeMat.shape, size\\n\\n # slopeNormVec = np.array(slopeMat.sum(axis=1)).T[0]\\n # slopeNormVec[slopeNormVec != 0.0] = 1.0 / slopeNormVec[slopeNormVec != 0.0]\\n # slopeNormMat = sparse.eye(self.tri.npoints)\\n # slopeNormMat.setdiag(slopeNormVec)\\n # slopeMat = slopeNormMat.dot(slopeMat)\\n\\n slopeMat.eliminate_zeros()\\n self.smoothDownhillMat = slopeMat\\n\\n return\",\n \"def get_score_matrix(self) -> int:\",\n \"def feature_selection(cls, tbl, thresh=-1):\\n\\n numerical_columns = [col for col in tbl.columns if col not in [\\\"F21\\\", \\\"F20\\\", \\\"F54\\\", \\\"Name\\\"]]\\n X = tbl[numerical_columns[:-1]].values\\n y = tbl[numerical_columns[-1]].values\\n\\n n = X.shape[1]\\n slist = np.zeros((n, 3))\\n slist[:, -1] = 1\\n\\n # identify relevant features\\n slist[:, 0] = cls._c_correlation(X, y) # compute 'C-correlation'\\n idx = slist[:, 0].argsort()[::-1]\\n slist = slist[idx,]\\n slist[:, 1] = idx\\n if thresh < 0:\\n thresh = np.median(slist[-1, 0])\\n\\n slist = slist[slist[:, 0] > thresh, :] # desc. ordered per SU[i,c]\\n\\n \\\"Identify redundant features among the relevant ones\\\"\\n cache = {}\\n m = len(slist)\\n p_su, p, p_idx = cls._get_first_element(slist)\\n for i in xrange(m):\\n q_su, q, q_idx = cls._get_next_element(slist, p_idx)\\n if q:\\n # p, q = int(p), int(q)\\n while q:\\n if (p, q) in cache:\\n pq_su = cache[(p, q)]\\n else:\\n pq_su = cls._symmetrical_uncertainty(X[:, int(p)], X[:, int(q)])\\n cache[(p, q)] = pq_su\\n\\n if pq_su >= q_su:\\n slist = cls._remove_element(slist, q_idx)\\n q_su, q, q_idx = cls._get_next_element(slist, q_idx)\\n\\n p_su, p, p_idx = cls._get_next_element(slist, p_idx)\\n if not p_idx:\\n break\\n\\n sbest = slist[slist[:, 2] > 0, :2]\\n selected_features = [int(ff) for ff in sbest[:, 1]]\\n selected_features = [numerical_columns[i] for i in selected_features]\\n selected_features.insert(0, \\\"Name\\\")\\n selected_features.append(\\\"category\\\")\\n new_tbl = tbl[selected_features]\\n\\n return new_tbl\",\n \"def connected_component(self, threshold: float = 0.5, \\n connectivity: int = 26):\\n global_offset = self.global_offset\\n seg = self > threshold\\n seg = cc3d.connected_components(seg.array, connectivity=connectivity)\\n return Chunk(seg, global_offset=global_offset)\",\n \"def getRowHeuristics(matrix):\\n row, col = matrix.shape\\n rHeuristic = np.zeros((row,2)) # Dos columnas. La primera para indicar la columna la segunda para la Heuristica\\n for i in range(0,row):\\n rHeuristic[i,0] = int(i)\\n #print (i,sum(matrix[:,i]), pesos[i], float(pesos[i]/sum(matrix[:,i])))\\n rHeuristic[i,1] = 1/sum(matrix[i,:])\\n return rHeuristic[rHeuristic[:,1].argsort()]\",\n \"def find_most_coins_path(matrix):\\n if type(matrix) != list or len(matrix) <= 0:\\n return None\\n\\n def find_coin_path(matrix_2d, x=0, y=0):\\n if x == len(matrix_2d) - 1 and y == len(matrix_2d[0]) - 1:\\n return matrix_2d[x][y]\\n else:\\n right = None\\n down = None\\n if x + 1 < len(matrix_2d):\\n right = matrix_2d[x][y] + find_coin_path(matrix_2d, x + 1, y)\\n if y + 1 < len(matrix[0]):\\n down = matrix_2d[x][y] + find_coin_path(matrix_2d, x, y + 1)\\n if right and down:\\n return right if right > down else down\\n elif type(right) is int:\\n return right\\n elif type(down) is int:\\n return down\\n\\n result = find_coin_path(matrix)\\n\\n return result\",\n \"def high_level(low_scores, query, template_length):\\n h_mat = prog_dynam_matrix(list(range(template_length)), query)\\n h_mat.create_content()\\n h_mat.fill_high(low_scores)\\n h_mat.show()\\n h_mat.optimal_path()\",\n \"def test_sparsity_topk_mask_dykstra(self, l=1e-2):\\n n = int(1e3)\\n seed = np.random.RandomState(0)\\n y = jnp.array(seed.randn(n))\\n k = 10\\n out_top_k_dykstra = sparse_soft_topk_mask_dykstra(y, k, l=l)\\n self.assertAlmostEqual(\\n y.argsort()[::-1][:k].sort().sum(),\\n out_top_k_dykstra.argsort()[::-1][:k].sort().sum(),\\n )\\n self.assertAlmostEqual(len(jnp.where(out_top_k_dykstra > 0)[0]), k)\",\n \"def calibrate_threshold(test_graphs):\\r\\n best_threshold = None\\r\\n best_result = None\\r\\n for threhold in range(1, 50):\\r\\n cur_res = evaluate_argument_mention(test_graphs, threhold)\\r\\n if (best_result is None) or (cur_res > best_result):\\r\\n best_result = cur_res\\r\\n best_threshold = threhold\\r\\n return (best_threshold, best_result)\",\n \"def to_sparse(self):\\n from divisi2.sparse import SparseMatrix\\n return SparseMatrix(self, self.row_labels, self.col_labels)\",\n \"def bestThreshold(lda_imlementation, vectorized_coded_revs, column, best_tops,\\n coded_reviews_df):\\n cat_array = lda_imlementation.transform(vectorized_coded_revs)\\n\\n topic_array = []\\n for i in range(lda_imlementation.n_topics):\\n coded_reviews_df['topic_'+str(i)] = cat_array[:, i]\\n topic_array += ['topic_'+str(i)]\\n\\n # Compute ROC curve point\\n y_score = sum([coded_reviews_df[top] for top in best_tops])\\n fpr, tpr, thresholds = roc_curve(coded_reviews_df[column], y_score)\\n\\n\\n auc_thresh = zip(fpr, tpr, thresholds)\\n auc_df = pd.DataFrame(auc_thresh, columns=['fpr', 'tpr', 'threshold'])\\n auc_df['dist'] = ((0-auc_df.fpr)**2 + (1-auc_df.tpr)**2)**.5\\n return auc_df.threshold.iloc[auc_df.dist.argmin()]\",\n \"def find_matching(confusion_matrix):\\r\\n _, n = confusion_matrix.shape\\r\\n path = []\\r\\n for i in range(n):\\r\\n max_val = -1e10\\r\\n max_ind = -1\\r\\n for j in range(n):\\r\\n if j in path:\\r\\n pass\\r\\n else:\\r\\n temp = confusion_matrix[i, j]\\r\\n if temp > max_val:\\r\\n max_val = temp\\r\\n max_ind = j\\r\\n path.append(max_ind)\\r\\n return path\",\n \"def get_energy_sparse(self, circuit):\\n return sparse_expectation(self.sparse, circuit.run())\",\n \"def find_min_path(s, t, dist):\\n\\n rows = len(dist) - 1\\n cols = len(dist[0]) - 1\\n col = cols\\n row = rows\\n pos_str = \\\"Position: (row={} col={}) -> (row={} col={})\\\"\\n cst_str = \\\"Cost: {}\\\"\\n prev_row = row\\n prev_col = col\\n\\n # init sparse path matrix\\n sparse_path = [[\\\" \\\" for x in range(cols + 1)] for x in range(rows + 1)]\\n sparse_path[0][0] = \\\"0\\\"\\n\\n # start with operation at (rows, cols) and work backwards\\n sparse_path[rows][cols] = dist[rows][cols]\\n\\n if verbose == 2:\\n print()\\n print(\\\"Initial Minimum Path Matrix:\\\")\\n print_matrix(s, t, sparse_path)\\n\\n while True:\\n\\n # bail out if we are in the corner\\n if row == 0 and col == 0:\\n break\\n\\n # if we are not at a matrix boundary\\n if row != 0 and col != 0: # if at left edge or top row, cannot move diagonally\\n\\n # diagonal\\n if (dist[row - 1][col - 1] == min(dist[row - 1][col],\\n dist[row][col - 1],\\n dist[row - 1][col - 1])) and (dist[row - 1][col - 1] == dist[row][col] or dist[row - 1][col - 1] == dist[row][col] - 1):\\n sparse_path[row - 1][col - 1] = dist[row - 1][col - 1]\\n temp_cost = dist[row - 1][col - 1]\\n\\n # move current cell\\n prev_row = row\\n prev_col = col\\n if col > 0:\\n col -= 1\\n if row > 0:\\n row -= 1\\n\\n if verbose == 2:\\n print(pos_str.format(str(prev_row), str(prev_col), str(row), str(col)))\\n print(cst_str.format(temp_cost))\\n print()\\n\\n # left\\n elif dist[row][col - 1] <= dist[row][col]:\\n sparse_path[row][col - 1] = dist[row][col - 1]\\n temp_cost = dist[row][col - 1]\\n\\n # move current cell\\n prev_row = row\\n prev_col = col\\n if col > 0:\\n col -= 1\\n\\n if verbose == 2:\\n print(pos_str.format(str(prev_row), str(prev_col), str(row), str(col)))\\n print(cst_str.format(temp_cost))\\n print()\\n\\n # above\\n else:\\n sparse_path[row - 1][col] = dist[row - 1][col]\\n temp_cost = dist[row - 1][col]\\n\\n # move current cell\\n prev_row = row\\n prev_col = col\\n if row > 0:\\n row -= 1\\n\\n if verbose == 2:\\n print(pos_str.format(str(prev_row), str(prev_col), str(row), str(col)))\\n print(cst_str.format(temp_cost))\\n print()\\n\\n # if at matrix edge, can only move up\\n elif col == 0:\\n # above\\n sparse_path[row - 1][col] = dist[row - 1][col]\\n temp_cost = dist[row - 1][col]\\n\\n # move current cell\\n prev_row = row\\n prev_col = col\\n if row > 0:\\n row -= 1\\n\\n if verbose == 2:\\n print(pos_str.format(str(prev_row), str(prev_col), str(row), str(col)))\\n print(cst_str.format(temp_cost))\\n print()\\n\\n # must be at row boundary, can only move left\\n else:\\n # left\\n if dist[row][col - 1] <= dist[row][col]:\\n sparse_path[row][col - 1] = dist[row][col - 1]\\n temp_cost = dist[row][col - 1]\\n\\n # move current cell\\n prev_row = row\\n prev_col = col\\n if col > 0:\\n col -= 1\\n\\n if verbose == 2:\\n print(pos_str.format(str(prev_row), str(prev_col), str(row), str(col)))\\n print(cst_str.format(temp_cost))\\n print()\\n\\n # print matrix\\n if verbose == 2:\\n print_matrix(s, t, sparse_path)\\n\\n return sparse_path\",\n \"def getThreshold(similarities, scores):\\n if len(similarities) < 3:\\n return 0.8 # Default high threshold so that we start making some posts.\\n posts = [{\\\"similarity\\\" : similarities[i], \\\"score\\\" : scores[i]}\\n for i in range(len(similarities))]\\n # Sort by similarity for convenience.\\n posts = sorted(posts, key=lambda k: k[\\\"similarity\\\"])\\n # Possible thresholds are midpoints between similarity scores.\\n possibleThresholds = [(posts[i][\\\"similarity\\\"] + posts[i+1][\\\"similarity\\\"]) / 2.0\\n for i in range(len(posts)-1)]\\n # Return the threshold that minimizes the objective function.\\n return min(possibleThresholds, key=lambda t: evaluateObjective(posts, t))\",\n \"def adaptive_selection(p_values, data, alpha):\\n HC_stat, max_idx_HC, HC_vec = HC_update(p_values, alpha)\\n cscshm_stat, max_idx_cscshm, cscshm_vec = CsCsHM_update(p_values, alpha)\\n thresh_HC = data[max_idx_HC]\\n thresh_cscshm = data[max_idx_cscshm]\\n nonnull_HC = np.where(data < thresh_HC, 0, data)\\n nonnull_cscshm = np.where(data < thresh_cscshm, 0, data)\\n return nonnull_HC, nonnull_cscshm\",\n \"def _compute_adjacency_matrix(self):\\n\\n # Set up a quick-reference index to map cells to indexes\\n for i, cell in enumerate(self.sim.cells):\\n self._cell_indexes[cell] = i\\n\\n if all([self.sim.hub.cells == [self.sim.damaged],\\n self.sim.damaged not in self.sim.cells]):\\n # Add the \\\"damaged\\\" virtual cell to the index if we need it\\n self._cell_indexes[self.sim.damaged] = len(self.sim.cells)\\n\\n node_count = len(list(self._cell_indexes.keys()))\\n g_sparse = np.zeros((node_count, node_count), dtype=float)\\n g_sparse[:] = np.inf\\n\\n for cluster in self.sim.clusters + [self.sim.hub]:\\n cluster_tour = cluster.tour\\n i = len(cluster_tour.vertices) - 1\\n j = 0\\n while j < len(cluster_tour.vertices):\\n start_vertex = cluster_tour.vertices[i]\\n stop_vertex = cluster_tour.vertices[j]\\n\\n start_pt = cluster_tour.points[start_vertex]\\n stop_pt = cluster_tour.points[stop_vertex]\\n distance = np.linalg.norm(stop_pt - start_pt)\\n\\n start_seg = cluster_tour.objects[start_vertex]\\n stop_seg = cluster_tour.objects[stop_vertex]\\n\\n start_index = self._cell_indexes[start_seg]\\n stop_index = self._cell_indexes[stop_seg]\\n\\n g_sparse[start_index, stop_index] = distance\\n\\n i = j\\n j += 1\\n\\n g_sparse = sp.csgraph_from_dense(g_sparse, null_value=np.inf)\\n return g_sparse\",\n \"def feature_calculator(args, graph):\\n index_1 = [edge[0] for edge in graph.edges()]\\n index_2 = [edge[1] for edge in graph.edges()]\\n values = [1 for edge in graph.edges()]\\n node_count = max(max(index_1)+1,max(index_2)+1)\\n adjacency_matrix = sparse.coo_matrix((values, (index_1,index_2)),shape=(node_count,node_count),dtype=np.float32)\\n degrees = adjacency_matrix.sum(axis=0)[0].tolist()\\n degs = sparse.diags(degrees, [0])\\n normalized_adjacency_matrix = degs.dot(adjacency_matrix)\\n target_matrices = [normalized_adjacency_matrix.todense()]\\n powered_A = normalized_adjacency_matrix\\n if args.window_size > 1:\\n for power in tqdm(range(args.window_size-1), desc = \\\"Adjacency matrix powers\\\"):\\n powered_A = powered_A.dot(normalized_adjacency_matrix)\\n to_add = powered_A.todense()\\n target_matrices.append(to_add)\\n target_matrices = np.array(target_matrices)\\n return target_matrices\",\n \"def bestThreshold2(lda_imlementation, vectorized_coded_revs, column, best_tops,\\n coded_reviews_df):\\n cat_array = lda_imlementation.transform(vectorized_coded_revs)\\n\\n topic_array = []\\n for i in range(lda_imlementation.n_topics):\\n coded_reviews_df['topic_'+str(i)] = cat_array[:, i]\\n topic_array += ['topic_'+str(i)]\\n\\n # Compute ROC curve point\\n y_score = sum([coded_reviews_df[top] for top in best_tops])\\n precision, recall, thresh = precision_recall_curve(\\n coded_reviews_df[column], y_score)\\n\\n\\n prc_thresh = zip(precision, recall, thresh)\\n prc_df = pd.DataFrame(prc_thresh, columns=['prec', 'recall', 'threshold'])\\n prc_df['dist'] = ((1-prc_df.prec)**2 + (1-prc_df.recall)**2)**.5\\n return prc_df.threshold.iloc[prc_df.dist.argmin()]\",\n \"def cluster_threshold(stat_map, domain, th, csize):\\n if stat_map.shape[0] != domain.size:\\n raise ValueError('incompatible dimensions')\\n\\n # first build a domain of supra_threshold regions\\n thresholded_domain = domain.mask(stat_map > th)\\n\\n # get the connected components\\n label = thresholded_domain.connected_components()\\n\\n binary = - np.ones(domain.size)\\n binary[stat_map > th] = label\\n nbcc = len(np.unique(label))\\n for i in range(nbcc):\\n if np.sum(label == i) < csize:\\n binary[binary == i] = - 1\\n\\n binary = (binary > -1)\\n return binary\",\n \"def train_threshold(ref_centroids, feature_mat, k):\\n all_dist = list()\\n overall_max_dist = 0\\n for i in range(len(feature_mat)):\\n feature_vec = feature_mat[i]\\n centroids_, distortion_ = cluster_feature(feature_vec, k)\\n centroids_ = centroids_.reshape(len(centroids_), -1)\\n\\n # Compute distortion to decide the threshold\\n # scipy.cdist: Computes distance between each pair of the two collections of inputs\\n # Get the average minimum distance of each i to j pair where i is not equal to j\\n dist = cdist(ref_centroids, centroids_, 'euclidean')\\n code = dist.argmin(axis=1)\\n min_dist_list = dist[np.arange(len(code)), code]\\n avg_min_dist = min_dist_list.mean(axis=-1)\\n all_dist.append(avg_min_dist)\\n overall_max_dist = max(overall_max_dist, avg_min_dist)\\n np_all_dist = np.asarray(all_dist)\\n mean = np_all_dist.mean()\\n std = np_all_dist.std()\\n threshold = mean + 2 * std\\n return threshold\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.601332","0.5888134","0.5505533","0.5345215","0.53447497","0.5290988","0.5274916","0.52567625","0.5246018","0.52018654","0.5155741","0.5143733","0.51208174","0.51169515","0.50919425","0.50628674","0.5052682","0.5040834","0.5035942","0.5035092","0.4997945","0.49954045","0.4984232","0.49730277","0.49595013","0.49475038","0.49254593","0.49243957","0.49235755","0.49235168","0.49220595","0.49148408","0.4894566","0.48913524","0.48899874","0.48857","0.48823825","0.48659885","0.48620382","0.4855026","0.4836129","0.48288226","0.48205626","0.4812793","0.48124436","0.480902","0.4779614","0.4777053","0.47763553","0.47572586","0.47545934","0.47534692","0.4753243","0.47394544","0.4734551","0.47336492","0.4732944","0.47286502","0.47240588","0.47231397","0.47160897","0.46952337","0.46910545","0.46907774","0.46903083","0.46689525","0.4655332","0.46498516","0.46400017","0.46361774","0.46324956","0.46290785","0.4614225","0.46140292","0.46107695","0.46066728","0.46040183","0.46039492","0.45992455","0.4598746","0.4598254","0.45972872","0.45949638","0.45917037","0.45895165","0.45890775","0.4587665","0.45875663","0.4585813","0.4585058","0.45807374","0.45784923","0.45761228","0.4574483","0.4571817","0.45694715","0.45598826","0.45485052","0.45483443","0.4548089"],"string":"[\n \"0.601332\",\n \"0.5888134\",\n \"0.5505533\",\n \"0.5345215\",\n \"0.53447497\",\n \"0.5290988\",\n \"0.5274916\",\n \"0.52567625\",\n \"0.5246018\",\n \"0.52018654\",\n \"0.5155741\",\n \"0.5143733\",\n \"0.51208174\",\n \"0.51169515\",\n \"0.50919425\",\n \"0.50628674\",\n \"0.5052682\",\n \"0.5040834\",\n \"0.5035942\",\n \"0.5035092\",\n \"0.4997945\",\n \"0.49954045\",\n \"0.4984232\",\n \"0.49730277\",\n \"0.49595013\",\n \"0.49475038\",\n \"0.49254593\",\n \"0.49243957\",\n \"0.49235755\",\n \"0.49235168\",\n \"0.49220595\",\n \"0.49148408\",\n \"0.4894566\",\n \"0.48913524\",\n \"0.48899874\",\n \"0.48857\",\n \"0.48823825\",\n \"0.48659885\",\n \"0.48620382\",\n \"0.4855026\",\n \"0.4836129\",\n \"0.48288226\",\n \"0.48205626\",\n \"0.4812793\",\n \"0.48124436\",\n \"0.480902\",\n \"0.4779614\",\n \"0.4777053\",\n \"0.47763553\",\n \"0.47572586\",\n \"0.47545934\",\n \"0.47534692\",\n \"0.4753243\",\n \"0.47394544\",\n \"0.4734551\",\n \"0.47336492\",\n \"0.4732944\",\n \"0.47286502\",\n \"0.47240588\",\n \"0.47231397\",\n \"0.47160897\",\n \"0.46952337\",\n \"0.46910545\",\n \"0.46907774\",\n \"0.46903083\",\n \"0.46689525\",\n \"0.4655332\",\n \"0.46498516\",\n \"0.46400017\",\n \"0.46361774\",\n \"0.46324956\",\n \"0.46290785\",\n \"0.4614225\",\n \"0.46140292\",\n \"0.46107695\",\n \"0.46066728\",\n \"0.46040183\",\n \"0.46039492\",\n \"0.45992455\",\n \"0.4598746\",\n \"0.4598254\",\n \"0.45972872\",\n \"0.45949638\",\n \"0.45917037\",\n \"0.45895165\",\n \"0.45890775\",\n \"0.4587665\",\n \"0.45875663\",\n \"0.4585813\",\n \"0.4585058\",\n \"0.45807374\",\n \"0.45784923\",\n \"0.45761228\",\n \"0.4574483\",\n \"0.4571817\",\n \"0.45694715\",\n \"0.45598826\",\n \"0.45485052\",\n \"0.45483443\",\n \"0.4548089\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.628852"},"document_rank":{"kind":"string","value":"0"}}},{"rowIdx":80894,"cells":{"query":{"kind":"string","value":"Add a sparse reservoir set by looping through different different connectivity values and assigining one reservoir weight matrix per connetivity level and storing these for downstream use by EchoStateNetwork We generate the reservoir weights and store them in the sparse library."},"document":{"kind":"string","value":"def addBook(self, random_seed):\n book = {}\n n = self.n_nodes_\n \n random_state = Generator(device = self.device).manual_seed(random_seed)\n\n accept = rand(n, n, generator = random_state, device = self.device) \n reservoir_pre_weights = rand(n, n, generator = random_state, device = self.device) * 2 -1\n\n \"for now we're going to avoid sparse matrices\"\n for connectivity in np.logspace(self.ub, self.lb, self.precision): #, device = self.device):\n #book[connectivity] = csc_matrix((accept < connectivity ) * reservoir_pre_weights)\n \n book[connectivity] = (accept < connectivity ) * reservoir_pre_weights\n sparse_keys_ = sorted(book)\n\n self.library[random_seed] = SparseBooklet(book = book, keys = sparse_keys_)\n self.book_indices.append(random_seed)"},"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 sparsify(W,conn):\n \n N = W.shape[0]\n W_sparse = sparse.lil_matrix((N,N)) \n for row, weights in itertools.izip(conn, W):\n W_sparse[row[0],row[1:]] = weights[1:]\n return W_sparse","def set_sparse_signals(self):\n\t\n\t\tparams_dSs = [self.mu_dSs, self.sigma_dSs]\n\t\tparams_Ss0 = [self.mu_Ss0, self.sigma_Ss0]\n\t\tself.dSs, self.idxs = sparse_vector([self.Nn, self.Kk], \n\t\t\t\t\t\t\t\t\t\t\t\tparams_dSs,\tseed=self.seed_dSs)\n\t\t\n\t\t# Replace components with conflicting background odor \n\t\tif self.Kk_split is not None and self.Kk_split != 0:\n\t\t\tassert 0 <= self.Kk_split <= self.Kk, \\\n\t\t\t\t\"Splitting sparse signal into two levels requires Kk_split\" \\\n\t\t\t\t\" to be non-negative and less than or equal to Kk.\"\n\t\t\tassert self.mu_dSs_2 is not None \\\n\t\t\t\tand self.sigma_dSs_2 is not None, \\\n\t\t\t\t\"Splitting sparse signal into two levels requires that\" \\\n\t\t\t\t\" mu_dSs_2 and sigma_dSs_2 are set.\"\n\n\t\t\tsp.random.seed(self.seed_dSs)\n\t\t\tself.idxs_2 = sp.random.choice(self.idxs[0], self.Kk_split, \n\t\t\t\t\t\t\t\t\t\t\treplace=False)\n\t\t\tfor idx_2 in self.idxs_2:\n\t\t\t\tself.dSs[idx_2] = sp.random.normal(self.mu_dSs_2, \n\t\t\t\t\t\t\t\t\t\t\t\t\tself.sigma_dSs_2)\n\t\telse:\n\t\t\tself.idxs_2 = []\n\t\t\tself.Kk_split = 0\n\t\t\t\n\t\t# Ss0 is the ideal (learned) background stimulus without noise\n\t\tself.Ss0, self.Ss0_noisy = sparse_vector_bkgrnd([self.Nn, self.Kk], \n\t\t\t\t\t\t\t\t\t\t\t\t\t\tself.idxs, params_Ss0,\n\t\t\t\t\t\t\t\t\t\t\t\t\t\tseed=self.seed_Ss0)\n\t\t\n\t\tself.Ss = self.dSs + self.Ss0_noisy","def connection(self, sampleseq, num):\n self.Adjmatrix = np.zeros((self.nodenum, self.nodenum), dtype = int)\n \n for i in range(self.supplynum):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.trandemandseries], sampleseq[self.supplyseries[i]]))\n self.Adjmatrix[self.supplyseries[i], self.trandemandseries[minindex]] = 1\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\n \n for i in range(self.trannum):\n if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) == 0):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\n self.Adjmatrix[minindex, self.transeries[i]] = 1\n# self.Adjmatrix[self.transeries[i], minindex] = 1\n \n \n# for i in range(self.supplynum):\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.supplyseries], num))\n# self.Adjmatrix[self.supplyseries[i], minindex] = 1\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\n \n# for i in range(self.trannum):\n# if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) != 0):\n# continue\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\n## self.Adjmatrix[self.transeries[i], minindex] = 1\n# \n for i in range(self.trannum):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.demandseries], min(sampleseq[self.transeries[i]], self.demandnum))) + self.supplynum + self.trannum\n self.Adjmatrix[self.transeries[i], minindex] = 1\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\n \n# for i in range(self.demandnum):\n# if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], 1)) + self.supplynum\n# self.Adjmatrix[minindex, self.demandseries[i]] = 1\n \n# for i in range(self.trannum):\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.transeries], num)) + self.supplynum\n# self.Adjmatrix[self.transeries[i], minindex] = 1\n \n for i in range(self.demandnum):\n if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], num)) + self.supplynum\n self.Adjmatrix[minindex, self.demandseries[i]] = 1\n# self.Adjmatrix[self.demandseries[i], minindex] = 1\n \n for i in range(self.demandnum):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.demandseries[i], self.demandseries], min(sampleseq[self.demandseries[i]] + 1, self.demandnum))) + self.supplynum + self.trannum\n minindex = minindex[1:-1]\n for j in range(len(minindex)):\n if(self.Adjmatrix[self.demandseries[i], minindex[j]] == 1 or self.Adjmatrix[minindex[j], self.demandseries[i]] == 1):\n continue\n self.Adjmatrix[self.demandseries[i], minindex[j]] = 1","def _build_sparse(self, name, wrt, consize, param_vals, sub_param_conns,\n full_param_conns, rels):\n\n jac = None\n\n # Additional sparsity for index connections\n for param in wrt:\n\n sub_conns = sub_param_conns.get(param)\n if not sub_conns:\n continue\n\n # If we have a simultaneous full connection, then we move on\n full_conns = full_param_conns.get(param)\n if full_conns.intersection(rels):\n continue\n\n rel_idx = set()\n for target, idx in iteritems(sub_conns):\n\n # If a target of the indexed desvar connection is\n # in the relevant path for this constraint, then\n # those indices are relevant.\n if target in rels:\n rel_idx.update(idx)\n\n nrel = len(rel_idx)\n if nrel > 0:\n\n if jac is None:\n jac = {}\n\n if param not in jac:\n # A coo matrix for the Jacobian\n # mat = {'coo':[row, col, data],\n # 'shape':[nrow, ncols]}\n coo = {}\n coo['shape'] = [consize, len(param_vals[param])]\n jac[param] = coo\n\n row = []\n col = []\n for i in range(consize):\n row.extend([i]*nrel)\n col.extend(rel_idx)\n data = np.ones((len(row), ))\n\n jac[param]['coo'] = [np.array(row), np.array(col), data]\n\n if name not in self.sub_sparsity:\n self.sub_sparsity[name] = {}\n self.sub_sparsity[name][param] = np.array(list(rel_idx))\n\n return jac","def create_sparseDB():\n datas = data.Kmercount_to_matrix()\n datas.run()\n print('***Sparse matrix created***')","def create_sparse_matrix(self, matrix_df):\n\n print('creating sparse matrix...')\n sparse_seg_tmp_df = matrix_df.groupby(['segment_id','day_of_week','time_idx'])[self.args['cluster_variable']].mean().reset_index()\n sparse_rt_tmp_df = matrix_df.groupby(['road_type','day_of_week','time_idx'])[self.args['cluster_variable']].mean().reset_index()\n time_seg_df = sparse_seg_tmp_df.groupby(['day_of_week','time_idx'])[self.args['cluster_variable']].mean().reset_index()\n time_rt_df = sparse_rt_tmp_df.groupby(['day_of_week','time_idx'])[self.args['cluster_variable']].mean().reset_index()\n #time_seg_df['time_id'] = time_seg_df.index\n #time_rt_df['time_id'] = time_rt_df.index\n times = list(range(24*60/self.args['time_resolution']))\n full_time_idx = pd.DataFrame([i * 30 for i in times],columns = ['time_idx'])\n full_time_idx['key'] = 1\n full_day_of_week = pd.DataFrame(list(range(7)), columns = ['day_of_week'])\n full_day_of_week['key'] = 1\n full_times = pd.merge(full_time_idx, full_day_of_week, on='key')\n full_times['time_id'] = full_times.index\n time_seg_df = pd.merge(time_seg_df, full_times[['time_idx','day_of_week','time_id']], on=['time_idx','day_of_week'])\n time_rt_df = pd.merge(time_rt_df, full_times[['time_idx','day_of_week','time_id']], on=['time_idx','day_of_week'])\n \n matrix_seg_keys_df = pd.merge(sparse_seg_tmp_df, time_seg_df[['time_id','day_of_week','time_idx']], how='left', on=['day_of_week','time_idx'])\n matrix_rt_keys_df = pd.merge(sparse_rt_tmp_df, time_rt_df[['time_id','day_of_week','time_idx']], how='left', on=['day_of_week','time_idx'])\n\n time_seg_array = np.array(matrix_seg_keys_df['time_id'])\n time_rt_array = np.array(matrix_rt_keys_df['time_id'])\n segment_array = np.array(matrix_seg_keys_df['segment_id'])\n rt_array = np.array(matrix_rt_keys_df['road_type'])\n\n uniquesegments = np.array(list(set(segment_array)))\n uniquerts = np.array(list(set(rt_array)))\n keyuniquesegments = np.array(range(len(uniquesegments)))\n keyuniquerts = np.array(range(len(uniquerts)))\n uniquesegments_df = pd.DataFrame({'segmentskey':keyuniquesegments, 'segment_id':uniquesegments})\n uniquerts_df = pd.DataFrame({'roadtypekey':keyuniquerts, 'road_type':uniquerts})\n\n segments_df = pd.DataFrame(segment_array, columns = ['segment_id'])\n rt_df = pd.DataFrame(rt_array, columns = ['road_type'])\n segments_keys_df = pd.merge(segments_df, uniquesegments_df, how='left', on=['segment_id'])\n rt_keys_df = pd.merge(rt_df, uniquerts_df, how='left', on=['road_type'])\n segmentkeys = np.array(segments_keys_df['segmentskey'])\n rtkeys = np.array(rt_keys_df['road_type'])\n\n level_array_seg = np.array(matrix_seg_keys_df['level_max'])\n sparse_matrix_s = csr_matrix((level_array_seg, (segmentkeys,time_seg_array))).toarray()\n sparse_matrix_seg = preprocessing.scale(sparse_matrix_s)\n level_array_rt = np.array(matrix_rt_keys_df['level_max'])\n sparse_matrix_r = csr_matrix((level_array_rt, (rtkeys,time_rt_array))).toarray()\n sparse_matrix_rt = preprocessing.scale(sparse_matrix_r)\n \n if self.args['perform_pca']:\n sparse_matrix_seg, self.pca_model = self.run_PCA(sparse_matrix_seg)\n sparse_matrix_rt, self.pca_model = self.run_PCA(sparse_matrix_rt)\n else:\n sparse_matrix_seg = sparse_matrix_seg\n sparse_matrix_rt = sparse_matrix_rt\n \n sparse_matrix_withsegkey = pd.DataFrame(sparse_matrix_seg)\n sparse_matrix_withrtkey = pd.DataFrame(sparse_matrix_rt)\n sparse_matrix_withsegkey['segmentskey'] = sparse_matrix_withsegkey.index\n sparse_matrix_withseg = pd.merge(uniquesegments_df, sparse_matrix_withsegkey, on=['segmentskey'])\n sparse_matrix_withrtkey['roadtypekey'] = sparse_matrix_withrtkey.index\n sparse_matrix_withrt = pd.merge(uniquerts_df, sparse_matrix_withrtkey, on=['roadtypekey'])\n \n # write sparse_matrix to database as 'clustering' table\n print('writing sparse matrix to db...')\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\n engine = create_engine(sqlalchemy_conn_str)\n if self.split_type == 'random':\n sparse_matrix_withseg.to_sql(name='clust_sparse_avebysegment_random', con=engine, if_exists='replace')\n sparse_matrix_withrt.to_sql(name='clust_sparse_avebyrt_random', con=engine, if_exists='replace')\n elif self.split_type == 'date':\n sparse_matrix_withseg.to_sql(name='clust_sparse_avebysegment_date', con=engine, if_exists='replace')\n sparse_matrix_withrt.to_sql(name='clust_sparse_avebyrt_date', con=engine, if_exists='replace')\n \n print('returning train sparse matrix...')\n return (uniquesegments_df, sparse_matrix_seg)","def simulate_sparse(n_rows, n_columns, row_density=0.001):\n # X = sparse.lil_matrix((n_rows, n_columns))\n X = []\n counter = 0\n for row in range(n_rows):\n counter += 1\n if (counter % 1000) == 0:\n print(counter)\n\n # X[row] = sparse.random(1, n_columns, density=row_density)\n X.append(sparse.random(1, n_columns, density=row_density, format='lil'))\n\n return sparse.vstack(X).tocsr()","def _create_sparse_train_and_test(ratings, n_users, n_items):\n \n # pick a random set of data as testing data, sorted ascending\n test_set_size = len(ratings) / TEST_SET_RATIO\n test_set_idx = np.random.choice(xrange(len(ratings)), size=test_set_size, replace=False)\n test_set_idx = sorted(test_set_idx)\n \n # use the remaining data to create a training set\n ts_ratings = ratings[test_set_idx]\n tr_ratings = np.delete(ratings, test_set_idx, axis=0)\n \n # create training and test matrices as coo_matrix\n u_tr, i_tr, r_tr = zip(*tr_ratings)\n tr_sparse = coo_matrix((r_tr, (u_tr, i_tr)), shape=(n_users, n_items))\n u_ts, i_ts, r_ts = zip(*ts_ratings)\n test_sparse = coo_matrix((r_ts, (u_ts, i_ts)), shape=(n_users, n_items))\n \n return tr_sparse, test_sparse","def convert_sparse_to_igraph(indices, matrix):\n # sources, targets = matrix.nonzero()\n # weights = matrix[sources, targets]\n # weights = np.array(weights)[0]\n # print(dir(louvain))\n # ig = igraph.Graph(zip(sources, targets), directed=True,\n # edge_attrs={'weight': weights})\n # return ig\n g = igraph.Graph.Adjacency((matrix > 0).tolist())\n g.es['weight'] = matrix[matrix.nonzero()]\n # g.vs['label'] = node_names # or a.index/a.columns\n return g","def add_sparse(self, key, element):\n self.add(self._sparse2seq(key), element)","def makesparse(matrix):\n n = matrix[0].size\n elements = []\n for i in range(n):\n for j in range(n):\n if matrix[i][j] != 0 :\n temp = MatrixElement(i, j, matrix[i][j])\n elements.append(temp)\n return SparseMatrix(n, elements)","def build_adjacency(self, connectivity_matrix, n_neighbours):\n \n #Get k strongest connections\n connections, idx = self.get_k_strongest_connections(connectivity_matrix, n_neighbours)\n \n #Sparse matrix\n M, k = connections.shape\n assert M, k == idx.shape #M - number of vertices. k == nearest neighbours \n assert connections.min() >= 0\n\n # Weights.\n sigma2 = np.mean(connections[:, -1])**2\n connections = np.exp(- connections**2 / sigma2)\n\n # Weight matrix.\n I = np.arange(0, M).repeat(k) #row\n J = idx.reshape(M*k) #col\n V = connections.reshape(M*k) #data \n W = sparse.coo_matrix((V, (I, J)), shape=(M, M)) #COO is a fast format for constructing sparse matrices\n\n # No self-connections.\n W.setdiag(0)\n\n # Non-directed graph.\n bigger = W.T > W\n W = W - W.multiply(bigger) + W.T.multiply(bigger)\n return W","def compress_csr(self):\n _, unique, indices = np.unique(\n self.m*self.rows + self.cols,\n return_index=True, return_inverse=True)\n self.rows = self.rows[unique]\n self.cols = self.cols[unique]\n self.vals = np.bincount(indices, weights=self.vals)","def init_sg_weights(self):\n n = self.weights_shape[0] # size of current layer\n # pylint: disable=no-member\n A = np.random.randn(n, n) / np.sqrt(n)\n B = np.random.randn(10, n) / np.sqrt(n)\n C = np.random.randn(1, n) / np.sqrt(n)\n # pylint: enable=no-member\n self.sg_weights = [A, B, C]","def sparse_initialization_weights(self):\n W = []\n mu, sigma = 0, 1/self.non_zero_units\n\n for i in xrange(self.n_in):\n row = np.zeros(self.n_out)\n non_zeros = self.rng.normal(mu, sigma, self.non_zero_units)\n # non_zeros /= non_zeros.sum()\n non_zero_idxs = self.rng.permutation(\n self.n_out)[0:self.non_zero_units]\n for j in xrange(self.non_zero_units):\n row[non_zero_idxs[j]] = non_zeros[j]\n W.append(row)\n W = np.asarray(W, dtype=theano.config.floatX)\n return W","def create_sparse_matrix(self, filename, matrix_length, density):\n pos = 0\n aux_pos = 0\n matrix = []\n pointerB = []\n pointerE = []\n columns = []\n values = []\n\n for i in range(0, matrix_length):\n row = []\n pointerB.append(pos)\n aux_pos = pos\n for j in range(0, matrix_length):\n probability = random.random()\n if probability < density:\n pos += 1\n val = random.randint(1, 10)\n values.append(val)\n columns.append(j)\n else:\n val = 0\n row.append(val)\n matrix.append(row)\n pointerE.append(pos)\n vector_b = SparseMatrix.gen_vector(matrix_length)\n matrix_A = np.matrix(matrix)\n vector_res = np.dot(matrix_A, vector_b).reshape(matrix_length, 1)\n data = {\"values\": values, \"columns\": columns, \"pointerB\": pointerB, \"pointerE\": pointerE}\n CSR_A = json.dumps(data)\n '''\n print(\"x: \", vector_x)\n print(\"A: \", matrix_A)\n print(\"b: \", vector_b)\n data = {\"values\": values, \"columns\": columns, \"pointerB\": pointerB, \"pointerE\": pointerE}\n data_json = json.dumps(data)\n file = open(filename, 'w')\n file.write(data_json)\n file.close()\n np.savetxt(\"vector.txt\", vector_x, fmt=\"%1.9f\", delimiter=\" \")\n '''\n return matrix_A, CSR_A, vector_b, vector_res","def copy(self, shareWeights):\n newNode = SparseLinear(self.inputDim, self.outputDim, self.stdv)\n #newNode.receiveGradFrom = self.receiveGradFrom[:]\n #newNode.receiveInputFrom = self.receiveInputFrom[:]\n if shareWeights:\n newNode.weight = self.weight\n newNode.gradWeight = self.gradWeight\n newNode.bias = self.bias\n newNode.gradBias = self.gradBias\n return newNode","def _resource_apply_sparse(self, grad, var, indices):\n\n return self._apply_sparse_shared(grad, var, indices, self._resource_scatter_add)","def _resource_apply_sparse(self, grad, var, indices):\n\n return self._apply_sparse_shared(grad, var, indices, self._resource_scatter_add)","def train_clustermodel_sparse(self):\n\n print('Clustering using: ' + self.algorithm)\n uniquesegments_df, sparse_matrix = self.create_sparse_matrix(self.data)\n\n clusterer = self.clustering_algorithms[self.algorithm]\n self.clustering_model = clusterer.fit(sparse_matrix)\n \n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_sparse'])\n clusters_df['segmentskey'] = clusters_df.index\n clusters_df = clusters_df.reset_index(drop=True)\n self.clusters_df_final = pd.merge(uniquesegments_df, clusters_df, on=['segmentskey'])\n self.clusters_df_final['cluster_sparse'].value_counts()\n \n today = datetime.date.today()\n filename = self.algorithm + '_sparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\n joblib.dump(self.clustering_model, filename)\n \n print('Stored ' + filename)\n \n return self.clustering_model, self.clusters_df_final[['segment_id','cluster_sparse']]","def compute_pw_sparse_out_of_memory2(tr,\n row_size = 500,\n pm_processes = 2,\n pm_pbar = True,\n max_distance = 50,\n reassemble = True,\n cleanup = True,\n assign = True): \n\n # Early warning to save heartache\n if assign is True and reassemble is False:\n raise ValueError(\"If you want to assign results to a TCRrep instance, you must set reassemble to True\")\n\n dest = secrets.token_hex(6)\n os.mkdir(dest)\n print(f\"CREATED /{dest}/ FOR HOLDING DISTANCE OUT OF MEMORY\")\n row_chunks = memory._partition(range(tr.clone_df.shape[0]), row_size)\n\n\n smatrix_chunks = [(tr, ind, f\"{dest}/{i}\") for i,ind in enumerate(row_chunks)]\n csrfragments = parmap.starmap(memory.gen_sparse_rw_on_fragment2, \n smatrix_chunks, \n max_distance=max_distance, \n pm_pbar=pm_pbar, \n pm_processes = pm_processes)\n\n if reassemble:\n csr_full_dict = dict()\n for chain in tr.chains:\n chain_str = f\"rw_{chain}\"\n csr_full = memory.collapse_csrs([f\"{x[2]}.{chain_str}.npz\" for x in smatrix_chunks])\n print(f\"RETURNING scipy.sparse csr_matrix w/dims {csr_full.shape}\")\n csr_full_dict[chain] = csr_full\n else: \n csr_full_dict= None\n \n if assign:\n for chain in tr.chains:\n setattr(tr, f\"pw_{chain}\", csr_full_dict[chain])\n\n if cleanup: \n assert os.path.isdir(dest)\n print(f\"CLEANING UP {dest}\")\n shutil.rmtree(dest)\n \n return csr_full_dict, smatrix_chunks","def __call__(self, sparse_matrix: PipelinedRDD):\n rows = sparse_matrix.collect()\n\n mat_index, mat_weights = zip(*rows)\n mat_row, mat_col = zip(*mat_index)\n tokens_num = len(self.tokens_list)\n\n self._log.info(\"Building matrix...\")\n matrix = sparse.coo_matrix((mat_weights, (mat_row, mat_col)),\n shape=(tokens_num, tokens_num))\n Cooccurrences() \\\n .construct(self.tokens_list, matrix) \\\n .save(output=self.output, series=\"id2vec\", deps=(self.df_model,))","def make_sparse(data):\n assert data.train_pos_edge_index is not None\n\n (row, col), N = data.train_pos_edge_index, data.num_nodes\n perm = (col * N + row).argsort()\n row, col = row[perm], col[perm]\n\n value = [data.edge_id[(row[i] * N + col[i]).item()].item() for i in perm]\n\n data.adj_t = SparseTensor(\n row=col,\n col=row,\n value=torch.tensor(value, dtype=torch.float32),\n sparse_sizes=(N, N),\n is_sorted=True,\n )\n\n # Pre-process some important attributes.\n data.adj_t.storage.rowptr()\n data.adj_t.storage.csr2csc()\n\n return data","def to_sparse_matrix(self, grid, format=None):\n S = self.centered_stencil()\n # print(\"grid :\")\n\n grid = tuple(grid)\n # print(grid)\n if not (np.asarray(S.shape) % 2 == 1).all():\n raise ValueError('all stencil dimensions must be odd')\n\n assert_condition(len(grid) == np.rank(S), ValueError,\n 'stencil rank must equal number of grid dimensions')\n assert_condition(min(grid) >= 1, ValueError,\n 'grid dimensions must be positive')\n\n N_v = np.prod(grid) # number of vertices in the mesh\n N_s = (S != 0).sum() # number of nonzero stencil entries\n\n # diagonal offsets\n diags = np.zeros(N_s, dtype=int)\n\n # compute index offset of each dof within the stencil\n strides = np.cumprod([1] + list(reversed(grid)))[:-1]\n indices = tuple(i.copy() for i in S.nonzero())\n for i,s in zip(indices,S.shape):\n i -= s // 2\n for stride,coords in zip(strides, reversed(indices)):\n diags += stride * coords\n\n #\n data = S[S != 0].repeat(N_v).reshape(N_s, N_v)\n indices = np.vstack(indices).T\n\n # zero boundary connections\n for index,diag in zip(indices,data):\n diag = diag.reshape(grid)\n for n,i in enumerate(index):\n if i > 0:\n s = [ slice(None) ]*len(grid)\n s[n] = slice(0,i)\n diag[s] = 0\n elif i < 0:\n s = [ slice(None) ]*len(grid)\n s[n] = slice(i,None)\n diag[s] = 0\n\n # remove diagonals that lie outside matrix\n mask = abs(diags) < N_v\n if not mask.all():\n diags = diags[mask]\n data = data[mask]\n\n # sum duplicate diagonals\n if len(np.unique(diags)) != len(diags):\n new_diags = np.unique(diags)\n new_data = np.zeros( (len(new_diags),data.shape[1]), dtype=data.dtype)\n for dia,dat in zip(diags,data):\n n = np.searchsorted(new_diags,dia)\n new_data[n,:] += dat\n\n diags = new_diags\n data = new_data\n\n return sprs.dia_matrix((data,diags), shape=(N_v, N_v)).asformat(format)","def sparse_esn_reservoir(size, spectral_radius, density, symmetric):\n rvs = stats.uniform(loc=-1., scale=2.).rvs\n matrix = sparse.random(size, size, density=density, data_rvs=rvs)\n matrix = matrix.tocsr()\n if symmetric:\n matrix = sparse.triu(matrix)\n tril = sparse.tril(matrix.transpose(), k=-1)\n matrix = matrix + tril\n # calc eigenvalues with scipy's lanczos implementation:\n eig, _ = sparse.linalg.eigsh(matrix, k=2, tol=1e-4)\n else:\n eig, _ = sparse.linalg.eigs(matrix, k=2, tol=1e-4)\n\n rho = np.abs(eig).max()\n matrix = matrix.multiply(1. / rho)\n matrix = matrix.multiply(spectral_radius)\n return matrix","def to_sparse(self):\n if self.rep.fmt == 'sparse':\n return self\n\n return self.from_rep(self.rep.to_sdm())","def set_DirichletSS_sparse(self):\n \n \n self.set_Dirichlet_vessel(self.inlet)\n\n\n self.tissue_consumption(self.Mt)\n \n #REINITIALISATION OF THE VECTOR OF TISSUE PHI!!!\n self.phi_t=np.zeros(len(self.phit))\n \n self.set_Dirichlet_north(0)\n self.set_Dirichlet_east(0)\n self.set_Dirichlet_west(0)\n \n self.A.eliminate_zeros()","def convert_sparse_layer(layer_name: str,\n weights: Dict[str, np.ndarray],\n coordinates: np.ndarray,\n input_size: int,\n output_size: int,\n is_msp: bool) -> str:\n components: List[str] = []\n var_name = convert_name(layer_name)\n\n # Create the 1d weight array\n weight_name = '{0}_DATA'.format(var_name)\n if is_msp:\n persistent = '#pragma PERSISTENT({0})'.format(weight_name)\n components.append(persistent)\n\n kernel_name = '{0}/kernel:0'.format(layer_name)\n\n fp_weights = array_to_fixed_point(weights[kernel_name],\n precision=PRECISION,\n width=WIDTH)\n weight_array = '{{{0}}}'.format(','.join(map(str, fp_weights)))\n weight_var = 'static int16_t {0}[] = {1};'.format(weight_name, weight_array)\n components.append(weight_var)\n\n # Convert to a sparse CSR matrix\n rows = coordinates[:, 0]\n cols = coordinates[:, 1]\n coo_mat = sp.coo_matrix((weights[kernel_name], (rows, cols)))\n\n csr_mat = coo_mat.tocsr()\n\n # Create the row and column arrays\n row_name = '{0}_ROWS'.format(var_name)\n\n if is_msp:\n persistent = '#pragma PERSISTENT({0})'.format(row_name)\n components.append(persistent)\n\n row_array = '{{{0}}}'.format(','.join(map(str, csr_mat.indptr)))\n row_var = 'static uint16_t {0}[] = {1};'.format(row_name, row_array)\n components.append(row_var)\n\n col_name = '{0}_COLS'.format(var_name)\n\n if is_msp:\n persistent = '#pragma PERSISTENT({0})'.format(col_name)\n components.append(persistent)\n\n col_array = '{{{0}}}'.format(','.join(map(str, csr_mat.indices)))\n col_var = 'static uint16_t {0}[] = {1};'.format(col_name, col_array)\n components.append(col_var)\n\n # Create the block sparse matrix\n mat_name = '{0}_KERNEL'.format(var_name)\n nnz = len(coordinates)\n mat_var = 'static SparseMatrix {0} = {{ {1}, {2}, {3}, {4}, {5}, {6} }};'.format(mat_name, weight_name, output_size, input_size, row_name, col_name, nnz)\n components.append(mat_var)\n\n # Create the bias vector\n bias_name = '{0}/bias:0'.format(layer_name)\n bias_var = convert_matrix(name=bias_name,\n mat=weights[bias_name],\n precision=PRECISION,\n width=WIDTH,\n is_msp=is_msp)\n components.append(bias_var)\n\n return '\\n'.join(components)","def main():\n\n \"\"\"\n nodes, hd3 = erdos_rennie_like(100,8333,5)\n export('d3',hd3)\n\n nodes, hd5 = erdos_rennie_like(100,8333,6)\n export('d5',hd5)\n\n nodes, hd6 = erdos_rennie_like(100,8333,7)\n export('d6',hd6)\n \"\"\"\n\n \"\"\"\n nodes, sparse1 = erdos_rennie_like(600, 1200, 3)\n export('sparse_diag1', sparse1)\n\n nodes, sparse2 = erdos_rennie_like(600, 2400, 3)\n export('sparse_diag2',sparse2)\n\n nodes, sparse3 = erdos_rennie_like(600, 5800, 3)\n export('sparse_diag3',sparse3)\n\n nodes, sparse4 = erdos_rennie_like(600,11600, 3)\n export('sparse_diag4',sparse4)\n\n nodes, sparse5 = erdos_rennie_like(600,23200, 3)\n export('sparse_diag5',sparse5)\n \"\"\"\n\n nodes, size1 = erdos_rennie_like(100, 500, 3)\n nodes, size2 = erdos_rennie_like(200,1000,3)\n nodes,size3 = erdos_rennie_like(300,1500,3)\n nodes,size4 = erdos_rennie_like(400,2000,3)\n nodes,size5 = erdos_rennie_like(500,2500,3)\n\n export('size_diag1',size1)\n export('size_diag2',size2)\n export('size_diag3',size3)\n export('size_diag4',size4)\n export('size_diag5',size5)","def expand_csr_adj(adj, count:int):\n r,c = adj.shape\n \n adj = sp.vstack(\n [adj, sp.csr_matrix(np.zeros((count, c)))])\n adj = sp.hstack(\n [adj, sp.csr_matrix(np.zeros((r + count, count)))])\n \n return adj","def so_sparse(nspins):\n sigma_x = sparse.COO(np.array([[0, 1 / 2], [1 / 2, 0]]))\n sigma_y = sparse.COO(np.array([[0, -1j / 2], [1j / 2, 0]]))\n sigma_z = sparse.COO(np.array([[1 / 2, 0], [0, -1 / 2]]))\n unit = sparse.COO(np.array([[1, 0], [0, 1]]))\n\n L = np.empty((3, nspins, 2 ** nspins, 2 ** nspins), dtype=np.complex128) # consider other dtype?\n # Lxs = []\n # Lys = []\n # Lzs = []\n\n for n in range(nspins):\n Lx_current = 1\n Ly_current = 1\n Lz_current = 1\n\n for k in range(nspins):\n if k == n:\n Lx_current = sparse.kron(Lx_current, sigma_x)\n Ly_current = sparse.kron(Ly_current, sigma_y)\n Lz_current = sparse.kron(Lz_current, sigma_z)\n else:\n Lx_current = sparse.kron(Lx_current, unit)\n Ly_current = sparse.kron(Ly_current, unit)\n Lz_current = sparse.kron(Lz_current, unit)\n\n # Lxs[n] = Lx_current\n # Lys[n] = Ly_current\n # Lzs[n] = Lz_current\n # print(Lx_current.todense())\n L[0][n] = Lx_current.todense()\n L[1][n] = Ly_current.todense()\n L[2][n] = Lz_current.todense()\n Lz_sparse = sparse.COO(L[2])\n L_T = L.transpose(1, 0, 2, 3)\n L_sparse = sparse.COO(L)\n L_T_sparse = sparse.COO(L_T)\n Lproduct = sparse.tensordot(L_T_sparse, L_sparse, axes=((1, 3), (0, 2))).swapaxes(1, 2)\n # Lz_sparse = sparse.COO(L[2])\n Lproduct_sparse = sparse.COO(Lproduct)\n\n return Lz_sparse, Lproduct_sparse","def calculate_assignments_sparse(topics, data, voc_size, iterations = 1000, threshold = 1e-4): \n #calulate block size\n Ndocs_batch = (50000*10000) // voc_size #fits in 4GB of memory\n \n Nbatches = len(data) // Ndocs_batch\n if Nbatches*Ndocs_batch < len(data):\n Nbatches += 1\n \n start_time = time()\n for i in range(Nbatches):\n \n \n partial_assignments = calculate_assignments(topics, data[i*Ndocs_batch:(i+1)*Ndocs_batch], voc_size, iterations)\n partial_assignments[partial_assignments < threshold] = 0 \n #re-normalize\n partial_assignments /= partial_assignments.sum(axis=1)[:,np.newaxis]\n \n if i==0:\n sparse_assignments = csr_matrix(partial_assignments)\n else: \n sparse_assignments = _csr_vappend(sparse_assignments, csr_matrix(partial_assignments))\n \n\n print('Done batch {} out of {}. Elapsed {:.2f} min.'.format(i,Nbatches, (time()-start_time)/60 ))\n \n return sparse_assignments","def __init__(self, rows, cols, bandwidth=0, sizeHint=None, matrix=None, storeZeros=True):\n sizeHint = sizeHint or max(rows, cols) * bandwidth\n if matrix is None:\n tmpMatrix = spmatrix.ll_mat(1, 1, 1)\n if hasattr(tmpMatrix, 'storeZeros'):\n matrix = spmatrix.ll_mat(rows, cols, sizeHint, storeZeros)\n else:\n matrix = spmatrix.ll_mat(rows, cols, sizeHint)\n\n _PysparseMatrix.__init__(self, matrix=matrix)","def construct_network(self):\n r = 0\n n = self.nbr_0_splxs\n for k in range(n):\n self.splxs.append((0, (0, k)))\n self.nbr_splxs += 1\n r, edge = self.find_next_edge(r)\n # this while loop finds the new edge to treat and add it to the 1-splx list and then finds out if a 2-splx is created\n while edge != (-1, -1):\n # Add the new edge\n self.one_splxs.append((edge, self.nbr_splxs))\n self.splxs.append((1, self.nbr_1_splxs))\n self.nbr_1_splxs += 1\n self.nbr_splxs += 1\n self.dist_appearance.append(r)\n a, b = edge\n # find out if a 2-splx has been created\n for i in range(self.nbr_1_splxs - 1):\n c, d = self.one_splxs[i][0]\n if d == a:\n for j in range(i + 1, self.nbr_1_splxs - 1):\n e, f = self.one_splxs[j][0]\n if e == c and f == b:\n self.two_splxs.append((self.nbr_1_splxs - 1, i, j))\n self.splxs.append((2, self.nbr_2_splxs))\n self.nbr_2_splxs += 1\n self.nbr_splxs += 1\n self.dist_appearance.append(r)\n # find the next edge to treat\n r, edge = self.find_next_edge(r)\n print(\"Network created\")\n return ()","def create_sparse_coo_matrix(df, n_users, n_items, movie_dict):\n\n\t# Map the movie_ids in the data to the new movie_ids given by the dictionary movie_dict\n\tmovie_id_list = list(map(lambda x: movie_dict[x], df['movieId'].tolist()))\n\t# Map the user_id in the dataframe to userid - 1 [to account for zero based indexing]\n\tuser_id_list = list(map(lambda x: x - 1, df['userId'].tolist()))\n\tsparse_matrix_coo = sparse.coo_matrix((df['rating'].tolist(),(user_id_list, movie_id_list)),shape=(n_users,n_items))\n\tlogger.debug(\"Shape of created sparse matrix: \" + str(sparse_matrix_coo.shape))\n\tlogger.debug(\"Number of non_zero elements in the sparse matrix: \" + str(sparse_matrix_coo.nnz))\n\tlogger.debug(\"Number of entries in the input dataframe:[should match the number of non zero entries in sparse matrix] \" + str(df.shape[0]))\n\treturn sparse_matrix_coo","def create_nonsparse_matrix(self, matrix_df):\n\n print('creating nonsparse matrix...')\n clustering_df_tmp = matrix_df[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2', 'level_min', 'level_max', 'level_mean', 'level_count', 'level_binary']]\n seg_averages = clustering_df_tmp.groupby(['segment_id', 'day_of_week', 'time_idx'])[['level_min', 'level_max', 'level_mean', 'level_count', 'level_binary']].mean().reset_index()\n rt_averages = clustering_df_tmp.groupby(['road_type', 'day_of_week', 'time_idx'])[['level_min', 'level_max', 'level_mean', 'level_count', 'level_binary']].mean().reset_index()\n \n # write nonsparse_matrix_db to database as 'clustering' table\n print('writing nonsparse matrix to db...')\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\n engine = create_engine(sqlalchemy_conn_str)\n if self.split_type == 'random':\n seg_averages.to_sql(name='clust_nonsparse_avebysegment_random', con=engine, if_exists='replace')\n rt_averages.to_sql(name='clust_nonsparse_avebyrt_random', con=engine, if_exists='replace')\n elif self.split_type == 'date':\n seg_averages.to_sql(name='clust_nonsparse_avebysegment_date', con=engine, if_exists='replace')\n rt_averages.to_sql(name='clust_nonsparse_avebyrt_date', con=engine, if_exists='replace')\n \n print('returning train nonsparse matrix...')\n train_averages = clustering_df_tmp.groupby(['segment_id', 'day_of_week', 'time_idx'])[['level_min', 'level_max', 'level_mean', 'level_count','level_binary']].mean().reset_index()\n train_averages.columns = ['segment_id', 'day_of_week', 'time_idx', 'ave_level_min', 'ave_level_max', 'ave_level_mean', 'ave_level_count', 'ave_level_binary']\n nonsparse_matrix = pd.merge(clustering_df_tmp, train_averages, how='left', on=['segment_id', 'day_of_week', 'time_idx'])\n segtimes_df = nonsparse_matrix[['segment_id', 'date', 'time']]\n nonsparse_matrix_final = nonsparse_matrix.drop(columns=['segment_id', 'date','time', 'level_min', 'level_max', 'level_mean', 'level_count', 'level_binary'])\n \n return (segtimes_df, nonsparse_matrix_final)","def _compute_adjacency_matrix(self):\n\n # Set up a quick-reference index to map cells to indexes\n for i, cell in enumerate(self.sim.cells):\n self._cell_indexes[cell] = i\n\n if all([self.sim.hub.cells == [self.sim.damaged],\n self.sim.damaged not in self.sim.cells]):\n # Add the \"damaged\" virtual cell to the index if we need it\n self._cell_indexes[self.sim.damaged] = len(self.sim.cells)\n\n node_count = len(list(self._cell_indexes.keys()))\n g_sparse = np.zeros((node_count, node_count), dtype=float)\n g_sparse[:] = np.inf\n\n for cluster in self.sim.clusters + [self.sim.hub]:\n cluster_tour = cluster.tour\n i = len(cluster_tour.vertices) - 1\n j = 0\n while j < len(cluster_tour.vertices):\n start_vertex = cluster_tour.vertices[i]\n stop_vertex = cluster_tour.vertices[j]\n\n start_pt = cluster_tour.points[start_vertex]\n stop_pt = cluster_tour.points[stop_vertex]\n distance = np.linalg.norm(stop_pt - start_pt)\n\n start_seg = cluster_tour.objects[start_vertex]\n stop_seg = cluster_tour.objects[stop_vertex]\n\n start_index = self._cell_indexes[start_seg]\n stop_index = self._cell_indexes[stop_seg]\n\n g_sparse[start_index, stop_index] = distance\n\n i = j\n j += 1\n\n g_sparse = sp.csgraph_from_dense(g_sparse, null_value=np.inf)\n return g_sparse","def _buildMatrix(self, SparseMatrix, Ncells, MaxFaces, coeff):\n return (0, 0)","def __init__(self, size):\n _PysparseMatrixFromShape.__init__(self, rows=size, cols=size, bandwidth = 1)\n ids = numerix.arange(size)\n self.put(numerix.ones(size, 'd'), ids, ids)","def construct(self, weights):\n in_weights = weights # first to append zero column as the last output (no out-degree)\n weights = np.zeros((weights.shape[0], weights.shape[1]+1))\n weights[:,:-1] = in_weights\n din, dout, dhid = self.dim_in, self.dim_out, self.dim_hid # the max dim\n hid = weights.shape[0] - dout # this hidden dim\n if not (weights.shape[1]-din-dout==hid and (0<hid<=dhid)):\n raise self.ANNException('weight matrix hidden nodes not matching')\n if not (dout < weights.shape[0] <= hid+dout):\n raise self.ANNException('weight matrix row shape not matching')\n if not (din+dout < weights.shape[1] <= din+hid+dout):\n raise self.ANNException('weight matrix column shape not matching')\n\n self.weight[din:din+hid,:din+hid] = weights[:hid,:din+hid]\n self.weight[din:din+hid,din+dhid:] = weights[:hid,din+hid:]\n self.weight[din+dhid:,:din+hid] = weights[hid:,:din+hid]\n self.weight[din+dhid:,din+dhid:] = weights[hid:,din+hid:]\n\n for i in range(hid):\n self.connectivity[din+i,:din+i] = True\n self.connectivity[din+dhid:,:din+hid] = True\n for i in range(dout):\n self.connectivity[din+dhid+i,din+dhid:din+dhid+i] = True\n\n self.hidden[:hid] = True","def train_clustermodel_nonsparse(self):\n \n segtimes_df, nonsparse_matrix = self.create_nonsparse_matrix(self.data)\n segtimes_df['index']=segtimes_df.index\n nonsparse_matrix['index']=nonsparse_matrix.index\n data_to_scale = pd.merge(segtimes_df, nonsparse_matrix, on=['index'])\n data_scaled = self.scale_matrix(data_to_scale)\n data_to_cluster = data_scaled.drop(columns = ['segment_id','level_0','date','time'])\n \n print('Clustering using nonsparse segment/time matrix and: ' + self.algorithm)\n clusterer = self.clustering_algorithms[self.algorithm]\n self.clustering_model = clusterer.fit(data_to_cluster)\n \n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_nonsparse'])\n clusters_df['segtimekey'] = clusters_df.index\n segtimes_df['segtimekey'] = segtimes_df.index\n clusters_df = clusters_df.reset_index(drop=True)\n self.clusters_df_final = pd.merge(segtimes_df, clusters_df, on=['segtimekey'])\n self.clusters_df_final['cluster_nonsparse'].value_counts()\n \n today = datetime.date.today()\n filename = self.algorithm + '_nonsparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\n joblib.dump(self.clustering_model, filename)\n \n print('Stored ' + filename)\n \n return self.clustering_model, self.clusters_df_final[['segment_id','date','time','cluster_nonsparse']]","def prepare_set(N_ITEMS, N_FEATURES, dict_data, sol_cont):\n\tX = np.zeros((N_ITEMS, N_FEATURES))\n\tfor i in range(N_ITEMS):\n\t\t\tpositive_syn, negative_syn = countSynergies(str(i), dict_data['polynomial_gains'])\n\t\t\tX[i, 0] = sol_cont[i]\n\t\t\tX[i, 1] = dict_data['profits'][i]\n\t\t\tX[i, 2] = dict_data['costs'][i][0]/dict_data['budget']\n\t\t\tX[i, 3] = dict_data['costs'][i][1]/dict_data['budget']\n\t\t\tX[i, 4] = positive_syn\n\t\t\tX[i, 5] = negative_syn\n\treturn X","def generate_sparse(n, s):\n x = np.zeros(n)\n I = np.random.randint(0, n, s)\n x[I] = 1\n return x","def _apply_sparse(self, grad, var):\n return self._apply_sparse_shared(\n grad.values,\n var,\n grad.indices,\n lambda x, i, v: state_ops.scatter_add( # pylint: disable=g-long-lambda\n x,\n i,\n v,\n use_locking=self._use_locking))","def create_user_item_matrix(data,type='unary'): \n if type == 'unary':\n\n # for unary rating drop duplicates\n data = data.drop_duplicates()\n\n # create sparse matrix\n matrix = csr_matrix((data['rating'], (data['user_id'],data['product_id'])))\n\n # rows and cols with empty values will be dropped (doesnt make any difference in size for sparse matrix, but if later converted to dense, it saves space)\n # get all non empty rows and cols\n rows, cols = matrix.nonzero()\n unique_rows = np.unique(rows)\n unique_cols = np.unique(cols)\n\n # select only rows and cols with values\n matrix = matrix[unique_rows]\n matrix = matrix[:,unique_cols]\n\n return matrix\n\n if type == 'count':\n\n # create sparse matrix with counted ratings\n matrix = csr_matrix((data['rating'], (data['user_id'],data['product_id'])))\n\n # rows and cols with empty values will be dropped (doesnt make any difference in size for sparse matrix, but if later converted to dense, it saves space)\n # get all non empty rows and cols\n rows, cols = matrix.nonzero()\n unique_rows = np.unique(rows)\n unique_cols = np.unique(cols)\n\n # select only rows and cols with values\n matrix = matrix[unique_rows]\n matrix = matrix[:,unique_cols]\n\n '''\n Im Gegensatz zum Memory Based approach, muss beim Model Based Approach noch das Rating angepasst werden. \n Das heisst, dass Produkte die viel eingekauft wurden ein höhers Rating erhalten und solche die weniger \n eingekauft wudren ein tieferes. Gleichzeitig muss das Maximum limitiert werden. Dies wird mittels \n dem max_count integer in der Funktion bewerkstelligt\n '''\n\n # create diagonal Matrix with 1 divided by maximum values per row. This needs to be done because there is no divide function for csr matrices implemented\n # source: https://stackoverflow.com/questions/42225269/scipy-sparse-matrix-division\n diag = diags(1/matrix.max(axis=1).A.ravel())\n\n # multipy the matrix with the maximum values to get range from 0-1\n matrix = diag.dot(matrix)\n\n # sort indices; not really needed, just cosmetics\n matrix.sort_indices()\n\n return matrix","def reservoir_generator(\n number_of_reservoirs=None, sparsity_level=None, reservoir_dim=None\n):\n reservoir_computing = ReservoirComputing(\n reservoir_dim=reservoir_dim, sparsity_level=sparsity_level\n )\n\n return [reservoir_computing.create_reservoir() for n in range(number_of_reservoirs)]","def test_assign_clusters_sparse(self, new_data, filename):\n\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\n engine = create_engine(sqlalchemy_conn_str)\n \n print('creating test sparse matrix...')\n if self.split_type == 'random':\n averages_seg = pd.read_sql('SELECT * FROM clust_sparse_avebysegment_random',con=engine)\n averages_rt = pd.read_sql('SELECT * FROM clust_sparse_avebyrt_random',con=engine)\n if self.split_type == 'date':\n averages_seg = pd.read_sql('SELECT * FROM clust_sparse_avebysegment_date',con=engine)\n averages_rt = pd.read_sql('SELECT * FROM clust_sparse_avebyrt_date',con=engine)\n\n averages_seg['exists'] = 1\n test_data_exists = pd.merge(new_data, averages_seg[['segment_id', 'exists']], on=['segment_id'])\n test_exists = test_data_exists[test_data_exists['exists']==1]\n test_notexists = test_data_exists[test_data_exists['exists']!=1] \n \n test_matrix_exists = pd.merge(test_exists[['segment_id', 'road_type']], averages_seg, how='left', on=['segment_id'])\n test_matrix_notexists = pd.merge(test_notexists[['segment_id', 'road_type']], averages_rt, how='left', on=['road_type'])\n test_matrix = pd.concat([test_matrix_exists, test_matrix_notexists])\n test_matrix = test_matrix.fillna(0) \n \n test_sparse_matrix = test_matrix.drop(columns = ['segment_id', 'road_type', 'exists', 'index', 'roadtypekey', 'segmentskey'])\n num = list(range(len(list(averages_seg))-4))\n columns = [str(item) for item in num]\n test_sparse_matrix = test_sparse_matrix[columns] \n \n print('clustering new data...')\n cluster_model = joblib.load(filename)\n cluster_predictions = cluster_model.predict(test_sparse_matrix)\n \n clusterdf = pd.DataFrame(cluster_predictions,columns = ['cluster_sparse'])\n clusterdf['index'] = clusterdf.index\n segmentdf = test_matrix['segment_id'].to_frame()\n segmentdf['index'] = segmentdf.index\n test_cluster_df_sparse = pd.merge(clusterdf, segmentdf, on=['index'])\n test_cluster_df_sparse = test_cluster_df_sparse[['segment_id','cluster_sparse']].groupby(['segment_id','cluster_sparse']).count()\n \n return test_cluster_df_sparse.reset_index()","def _apply_sparse(self, grad, var):\n\n return self._apply_sparse_shared(\n grad.values,\n var,\n grad.indices,\n lambda x, i, v: state_ops.scatter_add( # pylint: disable=g-long-lambda\n x,\n i,\n v,\n use_locking=self._use_locking))","def build_hybrid_sparse_matrix(run_parameters, normalize_by_sum, construct_by_union):\n pg_network_df = kn.get_network_df(run_parameters['pg_network_name_full_path'])\n gg_network_df = kn.get_network_df(run_parameters['gg_network_name_full_path'])\n\n pg_network_n1_names, \\\n pg_network_n2_names = kn.extract_network_node_names(pg_network_df)\n\n gg_network_n1_names, \\\n gg_network_n2_names = kn.extract_network_node_names(gg_network_df)\n\n # limit the gene set to the intersection of networks (gene_gene and prop_gene) and user gene set\n unique_gene_names = kn.find_unique_node_names(gg_network_n1_names, gg_network_n2_names)\n\n if construct_by_union is True:\n unique_gene_names = kn.find_unique_node_names(unique_gene_names, pg_network_n2_names)\n else:\n pg_network_df = kn.update_network_df(pg_network_df, unique_gene_names, 'node_2')\n\n unique_gene_names_dict = kn.create_node_names_dict(unique_gene_names)\n pg_network_n1_names_dict = kn.create_node_names_dict(\n pg_network_n1_names, len(unique_gene_names))\n\n unique_all_node_names = unique_gene_names + pg_network_n1_names\n # map every gene name to a sequential integer index\n gg_network_df = kn.map_node_names_to_index(gg_network_df, unique_gene_names_dict, \"node_1\")\n gg_network_df = kn.map_node_names_to_index(gg_network_df, unique_gene_names_dict, \"node_2\")\n pg_network_df = kn.map_node_names_to_index(pg_network_df, pg_network_n1_names_dict, \"node_1\")\n pg_network_df = kn.map_node_names_to_index(pg_network_df, unique_gene_names_dict, \"node_2\")\n\n gg_network_df = kn.symmetrize_df(gg_network_df)\n pg_network_df = kn.symmetrize_df(pg_network_df)\n\n if normalize_by_sum is True:\n gg_network_df = kn.normalize_network_df_by_sum(gg_network_df, 'wt')\n pg_network_df = kn.normalize_network_df_by_sum(pg_network_df, 'wt')\n\n hybrid_network_df = kn.form_hybrid_network_df([gg_network_df, pg_network_df])\n\n # store the network in a csr sparse format\n network_sparse = kn.convert_network_df_to_sparse(\n hybrid_network_df, len(unique_all_node_names), len(unique_all_node_names))\n\n return network_sparse, unique_gene_names, pg_network_n1_names","def compute_pw_sparse_out_of_memory(tr,\n row_size = 500,\n pm_processes = 2,\n pm_pbar = True,\n max_distance = 50,\n matrix_name = 'rw_beta',\n reassemble = True,\n cleanup = True): \n dest = secrets.token_hex(6)\n os.mkdir(dest)\n print(f\"CREATED /{dest}/ FOR HOLDING DISTANCE OUT OF MEMORY\")\n row_chunks = memory._partition(range(tr.clone_df.shape[0]), row_size)\n\n smatrix_chunks = [(tr, ind, f\"{dest}/{i}.{matrix_name}.npz\") for i,ind in enumerate(row_chunks)]\n csrfragments = parmap.starmap(memory.gen_sparse_rw_on_fragment, \n smatrix_chunks, \n matrix_name = matrix_name, \n max_distance=max_distance, \n pm_pbar=pm_pbar, \n pm_processes = pm_processes)\n if reassemble:\n csr_full = memory.collapse_csrs([x[2] for x in smatrix_chunks])\n print(f\"RETURNING scipy.sparse csr_matrix w/dims {csr_full.shape}\")\n else: \n csr_full = None\n \n if cleanup: \n assert os.path.isdir(dest)\n print(f\"CLEANING UP {dest}\")\n shutil.rmtree(dest)\n \n \n return csr_full, smatrix_chunks","def localInitialize(self):\n SVL = self.readFromROM()\n self._generateQuadsAndPolys(SVL)\n #print out the setup for each variable.\n msg = self.printTag+' INTERPOLATION INFO:\\n'\n msg += ' Variable | Distribution | Quadrature | Polynomials\\n'\n for v in self.quadDict:\n msg += ' '+' | '.join([v,self.distDict[v].type,self.quadDict[v].type,self.polyDict[v].type])+'\\n'\n msg += ' Polynomial Set Degree: '+str(self.maxPolyOrder)+'\\n'\n msg += ' Polynomial Set Type : '+str(SVL.indexSetType)+'\\n'\n self.raiseADebug(msg)\n\n self.raiseADebug('Starting index set generation...')\n self.indexSet = IndexSets.factory.returnInstance(SVL.indexSetType)\n self.indexSet.initialize(self.features, self.importanceDict, self.maxPolyOrder)\n if self.indexSet.type=='Custom':\n self.indexSet.setPoints(SVL.indexSetVals)\n\n self.sparseGrid = Quadratures.factory.returnInstance(self.sparseGridType)\n self.raiseADebug(f'Starting {self.sparseGridType} sparse grid generation...')\n self.sparseGrid.initialize(self.features, self.indexSet, self.dists, self.quadDict, self.jobHandler)\n\n if self.writeOut is not None:\n msg = self.sparseGrid.__csv__()\n outFile = open(self.writeOut,'w')\n outFile.writelines(msg)\n outFile.close()\n\n self.limit=len(self.sparseGrid)\n self.raiseADebug(f'Size of Sparse Grid: {self.limit}')\n self.raiseADebug('Finished sampler generation.')\n\n self.raiseADebug('indexset:',self.indexSet)\n for SVL in self.ROM.supervisedContainer:\n SVL.initialize({'SG': self.sparseGrid,\n 'dists': self.dists,\n 'quads': self.quadDict,\n 'polys': self.polyDict,\n 'iSet': self.indexSet})","def __init__(self, no_vertices=0):\r\n self.__neighbours = {}\r\n self.__cost = {}\r\n for i in range(no_vertices):\r\n self.__neighbours[i] = []","def dict2sparseMatrix(wDict,std=0,diag=0):\n data = lil_matrix((len(list(wDict.keys())),len(list(wDict.keys()))))\n nAreas = len(list(wDict.keys()))\n for i in wDict:\n data[i,i] = diag\n ne = len(wDict[i])+ diag\n for j in wDict[i]:\n if std:\n data[i,j] = 1 / float(ne)\n else:\n data[i,j] = 1\n return data","def initialize_dense_cost(height, width):\n cost = sparse.initialize_dense_cost_cpp(height, width)\n return cost","def __init__(self):\n super().__init__()\n self.type = 'SparseGridCollocationSampler'\n self.printTag = 'SAMPLER '+self.type.upper()\n self.maxPolyOrder = None #L, the relative maximum polynomial order to use in any dimension\n self.indexSetType = None #TP, TD, or HC; the type of index set to use\n self.polyDict = {} #varName-indexed dict of polynomial types\n self.quadDict = {} #varName-indexed dict of quadrature types\n self.importanceDict = {} #varName-indexed dict of importance weights\n self.maxPolyOrder = None #integer, relative maximum polynomial order to be used in any one dimension\n self.lastOutput = None #pointer to output dataObjects object\n self.ROM = None #pointer to ROM\n self.jobHandler = None #pointer to job handler for parallel runs\n self.doInParallel = True #compute sparse grid in parallel flag, recommended True\n self.dists = {} #Contains the instance of the distribution to be used. keys are the variable names\n self.writeOut = None\n self.indexSet = None\n self.sparseGrid = None\n self.features = None\n self.sparseGridType = None\n self.addAssemblerObject('ROM', InputData.Quantity.one)","def SparseData(Input,Output,Fraction):\r\n # Take a fraction of the full data\r\n MFull = np.column_stack((Input,Output))\r\n np.random.shuffle(MFull)\r\n split = int(np.ceil((MFull.shape[0])*Fraction)) \r\n # Generate a Sparse Set\r\n C = MFull[:split,:np.shape(Input)[1]]\r\n V = MFull[:split,np.shape(Input)[1]:]\r\n return C,V","def calculateGlobalStiffnessMatrix(self):\n \n globalRowIndices = []\n globalColumnIndices=[]\n globalData = []\n \n\n for ele,triPoints in enumerate(self.triangulation.simplices):\n eleStiffness = self.calculateElementStiffnessMatrix(ele)\n\n #append the entries at the correct position in the global matrix, only if no Boundary\n #condition is prescribed at this degree of freedom \n for row in range(3):\n if self.prescribedValues != [] and triPoints[row] in self.prescribedValues[:,0]:\n continue\n else:\n for column in range(3):\n globalRowIndices.append(triPoints[row])\n globalColumnIndices.append(triPoints[column])\n globalData.append(eleStiffness[row,column])\n #Dirichlet boundaries at position j are enforced, by adding a row (0,0,..,1,...,0) (j-th entry),\n #and the value in the right hand side at the position j \n for v in self.prescribedValues:\n\n globalRowIndices.append(v[0])\n globalColumnIndices.append(v[0])\n globalData.append(1)\n\n #create global matrix in coordinate format and convert it to csc for faster solving\n self.GlobalStiffness = sparse.coo_matrix((globalData,(globalRowIndices,globalColumnIndices))).tocsc() \n # print(self.GlobalStiffness.toarray())","def __init__(self, n4, L, k, randomize=False, non_k=-1, given_weight_matrix = None):\n\n self.n4 = n4\n self.L = L\n self.k = k\n self.weightMatrix = numpy.full((self.n4, self.L), non_k, dtype=numpy.int16)\n\n # initializing from the start\n if given_weight_matrix == None: \n if randomize == \"True\":\n #initialize weight matrix: for each stimulus, pick k neurons that respond randomly\n for stim in range(self.L):\n # randomly samples k neurons to respond (out of n4)\n responds = random.sample(range(n4), k=self.k)\n # updates the values of those k neurons' responses to stimulus \n for nrn in responds: \n self.weightMatrix[nrn][stim] = 1\n else:\n start_nrn = 0\n # the first k neurons respond to first stimulus, and so on\n for stim in range(self.L):\n for nrn_offset in range(self.k):\n self.weightMatrix[start_nrn + nrn_offset][stim] = 1\n start_nrn += self.k\n\n # initializing from previous weight matrix, given as string or as prepared weight matrix\n else: \n if type(given_weight_matrix) is str:\n l4_weight_list = [int(i) for i in given_weight_matrix.split(\",\")]\n \n if len(l4_weight_list) != (self.n4 * self.L):\n print(\"Error! String provided to initialize L4 weight matrix must have length n4 * L.\")\n sys.exit(1)\n\n for nrn in range(self.n4):\n start = nrn * self.L \n end = start + self.L\n self.weightMatrix[nrn] = numpy.array(l4_weight_list[start:end])\n else:\n if given_weight_matrix.shape != (n4, L):\n print(\"Error! Matrix provided to initialize L4 weight matrix must have shape (n4, L)\")\n sys.exit(1)\n self.weightMatrix = given_weight_matrix","def expand_conn_mat(conn_mat, nr_of_traps):\n\n r, c = conn_mat._shape\n new_indptr = np.hstack((conn_mat.indptr, np.asarray([conn_mat.indptr[-1]] * nr_of_traps)))\n expanded_mat = csr_matrix((conn_mat.data, conn_mat.indices, new_indptr),\n shape=(r + nr_of_traps, c + nr_of_traps))\n\n return expanded_mat","def adjacency(G, nodelist=None, weight=\"weight\"):\n\n if nodelist is None:\n nodelist = G.nodes()\n\n A = nx.to_scipy_sparse_matrix(G, nodelist=nodelist, weight=weight, format=\"csr\")\n\n return A","def prepare_graph(\n self,\n adjacency,\n weights,\n weighted=False,\n undirected=False,\n force_dense=True,\n noselfloop=True,\n verbose=True,\n ):\n\n # df_adj = pd.read_csv(in_folder + adj_name, index_col=0) # read adjacency file\n print(\"\\nAdjacency shape: {0}\".format(adjacency.shape), flush=True)\n\n # create the graph adding nodes and edges\n A = self.read_graph(\n adj=adjacency,\n weights=weights,\n weighted=weighted,\n undirected=undirected,\n noselfloop=noselfloop,\n verbose=verbose,\n )\n\n nodes = list(A[0].nodes)\n print(\"\\nNumber of nodes =\", len(nodes), flush=True)\n print(\"Number of layers =\", len(A), flush=True)\n if verbose:\n self.print_graph_stat(A)\n\n # save the multilayer network in a tensor with all layers\n if force_dense:\n B = self.build_B_from_A(A, nodes=nodes)\n else:\n B = self.build_sparse_B_from_A(A)\n\n return A, B, nodes","def construct_4adj_graph(X):\n s0, s1, s2 = X.shape\n \n size_data = s0*s1\n \n xGrid, yGrid = np.meshgrid(np.arange(s0), np.arange(s1))\n totGrid = (xGrid*s1 + yGrid).transpose()\n \n horiz_edges = np.sqrt(np.sum((X[1:,:,:] - X[:-1,:,:])**2, axis=-1).flatten())\n indx_horiz_edges = totGrid[1:,:].flatten()\n indy_horiz_edges = totGrid[:-1,:].flatten()\n \n vert_edges = np.sqrt(np.sum((X[:,1:,:] - X[:,:-1,:])**2, axis=-1).flatten())\n indx_vert_edges = totGrid[:,1:].flatten()\n indy_vert_edges = totGrid[:,:-1].flatten()\n \n w = np.concatenate((horiz_edges, vert_edges), axis=0) + 1e-6\n u = np.concatenate((indx_horiz_edges, indx_vert_edges), axis=0)\n v = np.concatenate((indy_horiz_edges, indy_vert_edges), axis=0)\n \n return sp.sparse.csr_matrix((w,(u,v)), shape=(size_data, size_data))","def add_sdn_resources(self, slice_urn, nodes):\n # Cannot use information extracted from the manifest here!\n # Look into the db-table containing the requested dpids and matches.\n if slice_urn not in self.__stored:\n logger.error(\"Slice monitoring: unable to find topology \" +\n \"info from %s!\" % slice_urn)\n return\n\n topology = self.__stored.get(slice_urn)\n groups, matches = db_sync_manager.get_slice_sdn(slice_urn)\n link_ids = []\n # Nodes info\n logger.debug(\"add_sdn_resources Groups(%d)=%s\" % (len(groups), groups))\n logger.debug(\"add_sdn_resources Matches=%d\" % (len(matches),))\n\n for m in matches:\n logger.debug(\"Match=%s\" % (m,))\n self.__update_match_with_groups(m, groups)\n\n ## TODO Check db.topology.slice (maybe some information stored?)\n for dpid in m.get(\"dpids\"):\n if MonitoringUtils.check_existing_tag_in_topology(topology, \"node\", \"switch\", dpid.get(\"component_id\")):\n break\n logger.debug(\"Dpid=%s\" % (dpid,))\n\n node_ = etree.SubElement(\n topology, \"node\", id=dpid.get(\"component_id\"),\n type=\"switch\")\n\n for p in dpid.get(\"ports\"):\n ifid = dpid.get(\"component_id\") + \"_\" + str(p.get(\"num\"))\n if_ = etree.SubElement(node_, \"interface\", id=ifid)\n\n etree.SubElement(if_, \"port\", num=str(p.get(\"num\")))\n\n link_ids.append(\n self.__create_link_id(dpid.get(\"dpid\"), p.get(\"num\")))\n\n self.__add_packet_info(node_, m.get(\"packet\"))\n\n logger.info(\"add_sdn_resources Link identifiers(%d)=%s\" %\n (len(link_ids), link_ids,))\n # C-SDN link info\n for l in link_ids:\n com_link = db_sync_manager.get_com_link_by_sdnkey(l)\n if com_link:\n logger.debug(\"COM link=%s\" % (com_link,))\n for eps in com_link.get(\"links\"):\n if MonitoringUtils.check_existing_tag_in_topology(topology, \"link\",\\\n self.MS_LINK_TYPE, [eps.get(\"source_id\"), eps.get(\"dest_id\")]):\n break\n\n # Modify link on-the-fly to add the DPID port as needed\n eps = MonitoringUtilsLinks._set_dpid_port_from_link(\n com_link.get(\"component_id\"), eps)\n\n eps_src_id, eps_dst_id = self.__get_eps_ids(\n eps.get(\"source_id\"), eps.get(\"dest_id\"))\n\n logger.info(\"eps_src_id=%s, eps_dst_id=%s\" %\n (eps_src_id, eps_dst_id,))\n self.__add_link_info(topology, eps_src_id, eps_dst_id, com_link.get(\"link_type\"))\n\n # SDN-SDN link info\n ext_link_ids = self.__extend_link_ids(link_ids)\n logger.info(\"add_sdn_resources Extended link identifiers(%d)=%s\" %\n (len(ext_link_ids), ext_link_ids,))\n for l in ext_link_ids:\n sdn_link = db_sync_manager.get_sdn_link_by_sdnkey(l)\n if sdn_link:\n logger.debug(\"SDN link=%s\" % (sdn_link,))\n if len(sdn_link.get(\"dpids\")) == 2 and\\\n len(sdn_link.get(\"ports\")) == 2:\n ep1 = self.__create_link_id(\n sdn_link.get(\"dpids\")[0].get(\"component_id\"),\n sdn_link.get(\"ports\")[0].get(\"port_num\"))\n ep2 = self.__create_link_id(\n sdn_link.get(\"dpids\")[1].get(\"component_id\").\n sdn_link.get(\"ports\")[1].get(\"port_num\"))\n # Local SDN-SDN links are not inserted under the nested link\n# if self.__check_ids_same_domain(ep1, ep2):\n self.__add_link_info(topology, ep1, ep2, self.SDN2SDN_LINK_TYPE)\n# else:\n# self.__sdn_links.append(\n# {'id': sdn_link.get(\"component_id\"),\n# 'source': ep1,\n# 'destination': ep2})\n else:\n logger.info(\"Slice monitoring: cannot find link that \" +\n \"ends with %s\" % l)","def SSC_test():\n \n # generating data\n\n D = 40 # Dimension of ambient space\n k = 4 # Number of subspaces\n d = 1\n N = 90 # Number of points in subspaces\n # Generating N points in d dim. subspaces\n Xi = [np.random.randn(D, d).dot(np.random.randn(d, N))\n for _ in range(k)]\n X = np.concatenate(Xi, axis=1)\n\n # Generating the ground-truth for evaluating clustering results\n lbls = [i * np.ones([1, N]) for i in range(k)]\n s = np.concatenate(lbls, axis=1)\n r = 0 # Enter the projection dimension e.g. r = d*n, enter r = 0 to not project\n Cst = 0 # Enter 1 to use the additional affine constraint sum(c) == 1\n OptM = 'L1Noise' # OptM can be {'L1Perfect','L1Noise','Lasso','L1ED'}\n lmbda = 0.001 # Regularization parameter in 'Lasso' or the noise level for 'L1Noise'\n # Number of top coefficients to build the similarity graph, enter K=0 for using the whole coefficients\n K = 0 #max(d1, d2)\n if Cst == 1:\n K = d + 1 # For affine subspaces, the number of coefficients to pick is dimension + 1\n\n Xp = DataProjection(X, r, 'NormalProj')\n \n # testing clustering\n \n '''\n # using wrapper function\n Grps, sc = sparseSubspaceClustering(\n Xp.T, n, ground_truth=s, affine=Cst, OptM=OptM, lam=lmbda)\n Grps = BestMap(sc, Grps)\n Missrate = float(np.sum(sc != Grps)) / sc.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))\n '''\n \n '''\n # calling internal tools\n CMat = SparseCoefRecovery(Xp, Cst, OptM, lmbda)\n # Make small values 0\n eps = np.finfo(float).eps\n CMat[np.abs(CMat) < eps] = 0\n\n CMatC, sc, OutlierIndx, Fail = OutlierDetection(CMat, s)\n\n if Fail == False:\n CKSym = BuildAdjacency(CMatC, K)\n Grps = SpectralClustering(CKSym, n)\n Grps = BestMap(sc, Grps)\n Missrate = float(np.sum(sc != Grps)) / sc.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))\n else:\n print(\"Something failed\")\n '''\n \n labels, _, __ = KSubspaces(Xp.T, k, d)\n labels = BestMap(s, labels)\n Missrate = float(np.sum(s != labels)) / s.size\n print(\"\\n\\nMisclassification rate: {:.4f} %\\n\\n\".format(Missrate * 100))","def _make_train(data, smooth_factor):\n train_matrix = data_to_sparse(data).tolil()\n user_counts = np.array(train_matrix.sum(axis=1))[:, 0]\n train_matrix[np.where(user_counts == 0)] = smooth_factor\n train_matrix = normalize(train_matrix, 'l1', axis=1)\n return train_matrix.tocsr()","def to_sparse(self):\n from divisi2.sparse import SparseMatrix\n return SparseMatrix(self, self.row_labels, self.col_labels)","def convert_sparse_network(weights: Dict[str, np.ndarray],\n metadata: Dict[str, Any],\n hypers: Dict[str, Any],\n is_msp: bool):\n # List to hold all variables\n components: List[str] = []\n\n # Start the input units at the input shape\n input_size = metadata[INPUT_SHAPE][-1]\n\n for i, output_size in enumerate(hypers['hidden_units']):\n\n # Convert the sparse variable\n layer_name = 'hidden_{0}'.format(i)\n\n sparse_layer = convert_sparse_layer(layer_name=layer_name,\n weights=weights,\n input_size=input_size,\n output_size=output_size,\n coordinates=metadata['sparse_indices'][layer_name],\n is_msp=is_msp)\n\n components.append(sparse_layer)\n\n # Reset the input size as we progress\n input_size = output_size\n\n # Include the output layer\n output_kernel_name = 'output/kernel:0'\n output_kernel = convert_matrix(name=output_kernel_name,\n mat=weights[output_kernel_name],\n precision=PRECISION,\n width=WIDTH,\n is_msp=is_msp)\n components.append(output_kernel)\n\n output_bias_name = 'output/bias:0'\n output_bias = convert_matrix(name=output_bias_name,\n mat=weights[output_bias_name],\n precision=PRECISION,\n width=WIDTH,\n is_msp=is_msp)\n components.append(output_bias)\n\n return '\\n'.join(components)","def construct_graph(indices, distances, n):\n CSR_graph = scipy.sparse.csr_matrix((distances, [indices[:, 0], indices[:, 1]]), shape=(n, n))\n return CSR_graph","def prepare4iCSD(self, index=0):\n if (\n self.surveys[index].x0_ini_guess == True\n or self.surveys[index].x0_prior == True\n ):\n self._estimateM0_(index=index)\n\n # CONSTRAINSTED INVERSION\n # -----------------------\n # Create vector with weight (data weigth, constrainsts weight and regularisation weigth)\n if self.surveys[index].x0_prior == True: # if relative smallness\n self.reg_w_0_b, self.reg_w_0_A = regularize_w(\n self.surveys[index].reg_A,\n self.wr,\n self.surveys[index].x0_prior,\n x0=self.x0,\n )\n\n # stack weight matrix\n self.W_s_A, self.W_s_b = stack_w(\n self.surveys[index].obs_w,\n self.surveys[index].con_w,\n self.surveys[index].x0_prior,\n reg_w_0_A=self.reg_w_0_A,\n reg_w_0_b=self.reg_w_0_b,\n )\n\n # apply weight to A and b (data weigth, constrainsts weight and regularisation weigth)\n self.A_w = weight_A(\n self.surveys[index].x0_prior, self.surveys[index].A_s, W_s_A=self.W_s_A\n )\n self.b_w = weight_b(\n self.surveys[index].x0_prior, self.surveys[index].b_s, W_s_b=self.W_s_b\n )\n\n # UNCONSTRAINSTED INVERSION\n # -------------------------\n else:\n self.reg_w = regularize_w(self.surveys[index].reg_A, self.wr, self.x0_prior)\n\n self.W_s = stack_w(\n self.surveys[index].obs_w,\n self.surveys[index].con_w,\n self.x0_prior,\n reg_w=self.reg_w,\n )\n self.A_w = weight_A(self.x0_prior, self.surveys[index].A_s, W_s=self.W_s)\n self.b_w = weight_b(self.x0_prior, self.surveys[index].b_s, W_s=self.W_s)","def __initialize_connection_strengths(G):\n G_prime = G.__deepcopy__() # construct a deepcopy of the graph\n # for every vertex in the graph, initialize the connection strength to zero\n for node in G_prime.get_nodeset(): node.add_attribute(StoerWagner.CONNECTION_STRENGTH_ATTRIBUTE, float(0))\n return G_prime # return the new graph","def sparse_matrix (base_type=float):\n return defaultdict (lambda: sparse_vector (base_type))","def build(self):\n\n self.W = self.init([self.n_atom_input_feat, self.n_output])\n self.b = model_ops.zeros(shape=[\n self.n_output,\n ])\n\n self.trainable_weights = self.W + self.b","def gen_W(users, items, ratings):\n\n # initiate graph\n user = users.tolist()\n item = items.tolist()\n rating = ratings.tolist()\n B = nx.Graph()\n B.add_nodes_from(user, bipartite=0)\n B.add_nodes_from(item, bipartite=1)\n\n # create edges\n for i in range(len(user)):\n B.add_edges_from([(user[i], item[i])])\n B[user[i]][item[i]]['weight'] = rating[i]\n\n users_unique = users.unique() \n items_unique = items.unique()\n\n # BiAdjacency matrix - for bipartite network\n W = biadjacency_matrix(B, users_unique,items_unique).toarray()\n\n # sparce form of Biadjacency matrix\n W = spa.csr_matrix(W)\n print('Shape of W: '+str(W.shape))\n\n return W, users_unique, items_unique","def generate_connectivity_constraint(problem, b_list, add_S):\n\n # Constructing A_iq and b_iq for inequality (38) for all S in add_S as sp.coo matrix\n A_iq_row = []\n A_iq_col = []\n A_iq_data = []\n\n constraint_idx = 0\n # For each base\n for b, S_v_t in product(b_list, add_S):\n pre_S_transition = problem.graph.pre_tran_vt(S_v_t)\n pre_S_connectivity = problem.graph.pre_conn_vt(S_v_t)\n for v, t in S_v_t:\n # add y\n A_iq_row.append(constraint_idx)\n A_iq_col.append(problem.get_yb_idx(b, v, t))\n A_iq_data.append(1)\n for v0, v1, t0 in pre_S_transition:\n A_iq_row.append(constraint_idx)\n A_iq_col.append(problem.get_x_idx(b, v0, v1, t0))\n A_iq_data.append(-1)\n for v0, v1, t1 in pre_S_connectivity:\n A_iq_row.append(constraint_idx)\n A_iq_col.append(problem.get_xbar_idx(b, v0, v1, t1))\n A_iq_data.append(-1)\n constraint_idx += 1\n A_iq_38 = sp.coo_matrix(\n (A_iq_data, (A_iq_row, A_iq_col)), shape=(constraint_idx, problem.num_vars)\n )\n\n return Constraint(A_iq=A_iq_38, b_iq=np.zeros(constraint_idx))","def _init_vertex_adjacency_matrix(self, verbose=False):\n self._init_from_cdd_input(self.cdd_Vrepresentation(),\n '--adjacency', verbose)","def test_example_10_sparse():\n import pandas as pd\n from tcrdist.repertoire import TCRrep\n from tcrdist.rep_funcs import pw2dense\n import numpy as np\n\n df = pd.read_csv(\"dash.csv\")\n df2 = pd.read_csv(\"dash2.csv\")\n df = df.head(10) #(1)\n tr = TCRrep(cell_df = df, #(2)\n df2 = df2, \n organism = 'mouse', \n chains = ['alpha','beta'], \n db_file = 'alphabeta_gammadelta_db.tsv')\n\n tr.compute_rect_distances(df = tr.clone_df, df2 = df2)\n assert tr.rw_alpha.shape == (10,1924) \n assert tr.rw_beta.shape == (10,1924)\n\n rw_alpha = tr.rw_alpha.copy()\n rw_beta = tr.rw_beta.copy()\n\n radius = 100\n tr.cpus = 1\n tr.compute_sparse_rect_distances(df = tr.clone_df, df2 = df2, radius = radius)\n d = pw2dense(tr.rw_alpha, radius)\n print(rw_alpha[:2, :10])\n print(tr.rw_alpha.todense()[:2, :10])\n print(d[:2, :10])\n assert np.all(rw_alpha[rw_alpha <= radius] == d[d <= radius])\n\n d = pw2dense(tr.rw_beta, radius)\n assert np.all(rw_beta[rw_beta <= radius] == d[d <= radius])\n\n \n radius = 5000\n tr.compute_sparse_rect_distances(df = tr.clone_df, df2 = df2, radius = radius)\n d = pw2dense(tr.rw_alpha, radius)\n print(rw_alpha[:2, :10])\n print(tr.rw_alpha.todense()[:2, :10])\n assert np.all(rw_alpha == d)\n\n d = pw2dense(tr.rw_beta, radius)\n assert np.all(rw_beta == d)","def to_sparse(self):\n from divisi2.sparse import SparseVector\n return SparseVector(self, self.labels)","def add_c_resources(self, slice_urn, nodes):\n if slice_urn not in self.__stored:\n logger.error(\"Unable to find Topology info from %s!\" % slice_urn)\n return\n\n topology = self.__stored.get(slice_urn)\n\n logger.debug(\"add_c_resources Nodes=%d\" % (len(nodes),))\n for n in nodes:\n logger.debug(\"Node=%s\" % (n,))\n\n node_ = etree.SubElement(\n topology, \"node\", id=n.get(\"component_id\"), type=\"server\")\n\n inner_node_ = etree.SubElement(\n node_, \"node\", id=n.get(\"sliver_id\"),\n type=n.get(\"sliver_type_name\").lower())\n\n # Add the interface identifier of the server node here!\n # In the future, it will be the vlan-tagged interface of the\n # virtual machine (much more sense)\n nodekey = n.get(\"component_id\").replace(\"+node+\", \":\")\n logger.debug(\"Node key=%s\" % (nodekey,))\n interfaces = db_sync_manager.get_com_interface_by_nodekey(nodekey)\n logger.info(\"Stored COM interfaces=%s\" % (interfaces,))\n for i in interfaces:\n if_index = i.rfind(\"interface\")\n if_name = n.get(\"sliver_id\") + \"+\" + i[if_index:len(i)]\n etree.SubElement(inner_node_, \"interface\", id=if_name)\n self.__mapping_c_interface[i] = if_name\n\n if len(n.get(\"services\")) > 0:\n self.__add_snmp_management(\n inner_node_,\n n.get(\"services\")[0].get(\"login\").get(\"hostname\"))","def __init__(self):\r\n self.adjacent = {}\r\n self.capacity = {}\r\n self.flow = {}","def __init__(self,numagents,bits,in_nodes,print_flag=False):\n self.numagents = numagents\n self.agent = []\n self.in_bits = in_nodes\n\n \"\"\" initialize empty dict for trajectories\"\"\"\n self.trajectories={}\n self.accepted_changes = 0\n self.learning_rate = numpy.zeros((3,1),dtype=int)\n\n \"\"\" initialize network topology \"\"\"\n self.adjacency = numpy.zeros((numagents,numagents),dtype=int)\n\n\n # Erdös Renyi network; symmetric G(n,p) with p=0.5;\n # if p > ln(n)/n graph is almost surely connected\n \n p0=0.75\n for ia1 in range(self.numagents):\n for ia2 in range(ia1+1,self.numagents):\n if ia1 < 3 and ia2 < 3: self.adjacency[ia1,ia2] = 1 #fully connected in_nodes\n else:\n pER = numpy.random.random()\n if pER <= p0: self.adjacency[ia1,ia2] = 1\n self.adjacency[ia2,ia1] = self.adjacency[ia1,ia2] #symmetrize\n\n\n\n \"\"\"#complete graph (dense)\n for ia1 in range(self.numagents):\n for ia2 in range(ia1+1,self.numagents):\n self.adjacency[ia1,ia2] = 1\n self.adjacency[ia2,ia1] = 1\n \"\"\"\n\n\n \"\"\"\n #4-lattice\n for ia in range(self.numagents):\n if ia > 1 and ia < self.numagents-2:\n ia1 = ia + 1\n ia2 = ia + 2\n ia3 = ia - 1\n ia4 = ia - 2\n\n elif ia == 0:\n ia1 = ia + 1\n ia2 = ia + 2\n ia3 = self.numagents-1\n ia4 = self.numagents-2\n\n elif ia == 1:\n ia1 = ia + 1\n ia2 = ia + 2\n ia3 = ia - 1\n ia4 = self.numagents-1\n\n elif ia == self.numagents-2:\n ia1 = ia + 1\n ia2 = 0\n ia3 = ia - 1\n ia4 = ia - 2\n elif ia == self.numagents-1:\n ia1 = 0\n ia2 = 1\n ia3 = ia- 1\n ia4 = ia -2\n\n self.adjacency[ia,ia1] = 1\n self.adjacency[ia1,ia] = 1\n self.adjacency[ia,ia2] = 1\n self.adjacency[ia2,ia] = 1\n self.adjacency[ia,ia3] = 1\n self.adjacency[ia3,ia] = 1\n self.adjacency[ia, ia4] = 1\n self.adjacency[ia4, ia] = 1\n \"\"\"\n\n \n #SF-network, BA(m=1)\n \"\"\"\n m=1\n main_graph = networkx.barabasi_albert_graph(self.numagents, m)\n self.adjacency = networkx.to_numpy_array(main_graph)\n \"\"\"\n\n # density is number of edges/number of possible edges\n self.graph_density = numpy.sum(self.adjacency)/(self.numagents*(self.numagents-1) )\n\n\n \"\"\" initialize agents: \"\"\"\n iagents = range(self.in_bits)\n majority = True\n for ia in range(self.numagents):\n nbh = 3 #ALT: take mean neighborhood from graph; nbh = global_functions.dict_from_adj(self.adjacency)\n mu1 = numpy.random.randint(1, nbh + 1) # int(thresh)\n mu2 = numpy.random.randint(mu1, nbh + 1) #\n if ia in iagents: i = True\n else: i = False\n self.agent.append(agent(ia,ia,bits,nbh,i,mu1,mu2,majority=majority)) #initialize with majority rule\n #print(ia,self.agent[ia].rule)\n\n if print_flag:\n adj_dict = global_functions.dict_from_adj(self.adjacency)\n numagents = 0\n for ia in range(len(self.adjacency)):\n if numpy.sum(self.adjacency[ia]) != 0 or numpy.sum(self.adjacency[:, ia]) != 0: numagents += 1\n print(\"Initialize network with\", self.numagents, \"agents on a graph with\"\n , len(adj_dict), \"edges and density of\", numpy.around(self.graph_density,2))\n print(\"Input agents:\", iagents)\n print(\"Average degree:\", numpy.around(numpy.sum(self.adjacency)/self.numagents,2))\n\n if self.numagents <= 12:\n for l in self.adjacency: print(l)\n else:\n for key in adj_dict: print(key,\"->\",adj_dict[key])\n\n print(\"Perceptual rule of type:\")\n if majority: print(\"majority rule: x -> 1: if sum(input) >= out_degree/2\")\n else:\n print(\"x -> 1: if mu1 <= sum(input) <= mu2\")\n print(\"mu1 =\",[self.agent[ia].mu1 for ia in range(self.numagents)],\n \"mu2 =\",[self.agent[ia].mu2 for ia in range(self.numagents)])\n #for key in itertools.product({0, 1}, repeat = self.out_bits):\n # print(key, self.agent[0].update(key))\n print(\"Network successfully initialized\")","def compute_weights(self):\n\n # Init lists\n weights, weights_k_idx = [], []\n for i_order in range(self.n_orders): # For each orders\n\n weights_n, k_idx_n = self.get_w(i_order) # Compute weights\n\n # Convert to sparse matrix\n # First get the dimension of the convolved grid\n n_kc = np.diff(self.i_bounds[i_order]).astype(int)[0]\n\n # Then convert to sparse\n weights_n = atoca_utils.sparse_k(weights_n, k_idx_n, n_kc)\n weights.append(weights_n), weights_k_idx.append(k_idx_n)\n\n return weights, weights_k_idx","def sample_from_ibp(K, alpha, sigma, c):\n pp = poissonparams(K, alpha, sigma, c)\n new_nodes = np.random.poisson(pp)\n Ncols = new_nodes.sum()\n node_count = np.zeros(Ncols)\n\n # used to build sparse matrix, entries of each Zij=1\n colidx = [] \n rowidx = []\n rightmost_node = 0\n\n # for each clique\n for n in range(K):\n # revisit each previously seen node\n for k in range(rightmost_node):\n prob_repeat = (node_count[k] - sigma) / (n + c)\n r = np.random.rand()\n if r < prob_repeat:\n rowidx.append(n)\n colidx.append(k)\n node_count[k] += 1\n\n for k in range(rightmost_node, rightmost_node + new_nodes[n]):\n rowidx.append(n)\n colidx.append(k)\n node_count[k] += 1\n \n rightmost_node += new_nodes[n]\n\n # build sparse matrix\n data = np.ones(len(rowidx), int)\n shape = (K, Ncols)\n Z = csr_matrix((data, (rowidx, colidx)), shape)\n\n return Z","def constructConnMatrices(nE=4000, nI=1000, n_clusters=50,\n pEE=.2, pEI=.5, pIE=.5, pII=.5, rEE=1.0,\n jEE_out=0.024, jEE_in=1.9, jEI=0.014, jIE=-0.045, jII=-0.057): # Need to add synaptic strengths\n # Structural connectivity (probabilities taken from Litwin-Kumar & Doiron, 2012)\n if rEE==1:\n sEE = np.random.binomial(1,pEE,size=(nE,nE))\n wEE = sEE*jEE_out\n else:\n neurons_per_clust = int(nE/float(n_clusters))\n pEE_out = (pEE*(nE-1))/(rEE*neurons_per_clust + (nE-1) - neurons_per_clust)\n pEE_in = rEE*pEE_out\n\n # First define all pEE_out connections\n sEE = np.random.binomial(1,pEE_out,size=(nE,nE))\n wEE = sEE * jEE_out\n # Now we will re-do clustered connections\n neuron_count = 0\n for clust in range(n_clusters):\n i = int(neuron_count)\n j = int(neuron_count + neurons_per_clust)\n sEE[i:j,i:j] = 0\n sEE[i:j,i:j] = np.random.binomial(1,pEE_in,size=(neurons_per_clust,neurons_per_clust))\n wEE[i:j,i:j] = sEE[i:j,i:j] * jEE_in\n neuron_count += neurons_per_clust\n\n # No self connections\n np.fill_diagonal(wEE,0)\n\n # Structural matrices\n sEI = np.random.binomial(1,pEI,size=(nE,nI))\n sIE = np.random.binomial(1,pIE,size=(nI,nE))\n sII = np.random.binomial(1,pII,size=(nI,nI))\n\n # Synaptic weights\n wEI = sEI * jEI\n wIE = sIE * jIE\n wII = sII * jII\n\n # No self connections\n np.fill_diagonal(wII,0)\n\n return wEE, wEI, wIE, wII","def _get_sparse_data(self):\n data = self._normalize_dataset()\n\n n_users = data.user_id.unique().shape[0]\n n_movies = data.movie_id.unique().shape[0]\n\n ratings = np.zeros((n_users, n_movies))\n\n for row in data.itertuples():\n ratings[row[1]-1, row[2]-1] = row[3]\n return ratings","def make_sparse(self, fmt='csc', make_method=None):\n if make_method:\n self.sparse = make_method(self.hamiltonian)\n else:\n self.sparse = self.hamiltonian.to_matrix(sparse=fmt)","def OffsetSparseMatrix(SparseMatrix, numberOfVariables, numberOfEquations):\n\n class OffsetSparseMatrixClass(SparseMatrix):\n equationIndex = 0\n varIndex = 0\n\n def __init__(self, mesh, bandwidth=0, sizeHint=None,\n numberOfVariables=numberOfVariables, numberOfEquations=numberOfEquations):\n SparseMatrix.__init__(self, mesh=mesh, bandwidth=bandwidth, sizeHint=sizeHint,\n numberOfVariables=numberOfVariables, numberOfEquations=numberOfEquations)\n\n def put(self, vector, id1, id2):\n SparseMatrix.put(self, vector, id1 + self.mesh.numberOfCells * self.equationIndex, id2 + self.mesh.numberOfCells * self.varIndex)\n\n def addAt(self, vector, id1, id2):\n SparseMatrix.addAt(self, vector, id1 + self.mesh.numberOfCells * self.equationIndex, id2 + self.mesh.numberOfCells * self.varIndex)\n\n def addAtDiagonal(self, vector):\n if type(vector) in [type(1), type(1.)]:\n tmp = numerix.zeros((self.mesh.numberOfCells,), 'd')\n tmp[:] = vector\n SparseMatrix.addAtDiagonal(self, tmp)\n else:\n SparseMatrix.addAtDiagonal(self, vector)\n\n return OffsetSparseMatrixClass","def OffsetSparseMatrix(SparseMatrix, numberOfVariables, numberOfEquations):\n\n class OffsetSparseMatrixClass(SparseMatrix):\n equationIndex = 0\n varIndex = 0\n\n def __init__(self, mesh, bandwidth=0, sizeHint=None,\n numberOfVariables=numberOfVariables, numberOfEquations=numberOfEquations):\n SparseMatrix.__init__(self, mesh=mesh, bandwidth=bandwidth, sizeHint=sizeHint,\n numberOfVariables=numberOfVariables, numberOfEquations=numberOfEquations)\n\n def put(self, vector, id1, id2):\n SparseMatrix.put(self, vector, id1 + self.mesh.numberOfCells * self.equationIndex, id2 + self.mesh.numberOfCells * self.varIndex)\n\n def addAt(self, vector, id1, id2):\n SparseMatrix.addAt(self, vector, id1 + self.mesh.numberOfCells * self.equationIndex, id2 + self.mesh.numberOfCells * self.varIndex)\n\n def addAtDiagonal(self, vector):\n if type(vector) in [type(1), type(1.)]:\n tmp = numerix.zeros((self.mesh.numberOfCells,), 'd')\n tmp[:] = vector\n SparseMatrix.addAtDiagonal(self, tmp)\n else:\n SparseMatrix.addAtDiagonal(self, vector)\n\n return OffsetSparseMatrixClass","def create_sparse_matrix_long(self, matrix_df):\n\n time_df_tmp = matrix_df.groupby(['date_idx','time_idx']).count().reset_index()\n time_df = time_df_tmp[['date_idx','time_idx']]\n time_df['time_id'] = time_df.index.copy()\n matrix_df_tid = pd.merge(matrix_df, time_df, how='left', on=['date_idx','time_idx'])\n\n time_array = np.array(matrix_df_tid['time_id'])\n segment_array = np.array(matrix_df_tid['segment_id'])\n\n uniquesegments = np.array(list(set(segment_array)))\n keyuniquesegments = np.array(range(len(uniquesegments)))\n uniquesegments_df = pd.DataFrame({'segmentskey':keyuniquesegments, 'segment_id':uniquesegments})\n\n segments_df = pd.DataFrame(segment_array, columns = ['segment_id'])\n segments_keys_df = pd.merge(segments_df, uniquesegments_df, how='left', on=['segment_id'])\n segmentkeys = np.array(segments_keys_df['segmentskey'])\n\n level_array = np.array(matrix_df_tid[self.args['cluster_variable']])\n sparse_matrix = csr_matrix((level_array, (segmentkeys,time_array))).toarray()\n sparse_matrix = preprocessing.scale(sparse_matrix)\n \n if self.args['perform_pca']:\n data_to_cluster, self.pca_model = self.run_PCA_long(sparse_matrix)\n else:\n data_to_cluster = sparse_matrix\n\n sparse_matrix_withsegkey = pd.DataFrame(data_to_cluster)\n sparse_matrix_withsegkey['segmentskey'] = sparse_matrix_withsegkey.index\n sparse_matrix_withseg = pd.merge(uniquesegments_df, sparse_matrix_withsegkey, on=['segmentskey'])\n \n print('writing sparse matrix_long to db...')\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\n engine = create_engine(sqlalchemy_conn_str)\n if self.split_type == 'random':\n sparse_matrix_withseg.to_sql(name='clust_sparse_long_avebysegment_random', con=engine, if_exists='replace')\n elif self.split_type == 'date':\n sparse_matrix_withseg.to_sql(name='clust_sparse_long_avebysegment_date', con=engine, if_exists='replace')\n \n print('returning train sparse_long matrix...')\n return (uniquesegments_df, data_to_cluster)","def allocate(self, models, edges, nrnodes, totalActivities):\n # Return something of the form: {0: 0, 1: 0, 2: 0, 3: 1}\n # To allocate model_ids 0, 1 and 2 to node 0 and model_id 3 to node 1\n return {0: 0, 1: 0, 2: 0, 3: 1}","def metis(W, levels, rid=None):\n # Function written by M. Defferrard, taken verbatim, from \n # https://github.com/mdeff/cnn_graph/blob/master/lib/coarsening.py#L34\n\n N, N = W.shape\n if rid is None:\n rid = np.random.permutation(range(N))\n parents = []\n degree = W.sum(axis=0) - W.diagonal()\n graphs = []\n graphs.append(W)\n #supernode_size = np.ones(N)\n #nd_sz = [supernode_size]\n #count = 0\n\n #while N > maxsize:\n for _ in range(levels):\n\n #count += 1\n\n # CHOOSE THE WEIGHTS FOR THE PAIRING\n # weights = ones(N,1) # metis weights\n weights = degree # graclus weights\n # weights = supernode_size # other possibility\n weights = np.array(weights).squeeze()\n\n # PAIR THE VERTICES AND CONSTRUCT THE ROOT VECTOR\n idx_row, idx_col, val = scipy.sparse.find(W)\n perm = np.argsort(idx_row)\n rr = idx_row[perm]\n cc = idx_col[perm]\n vv = val[perm]\n cluster_id = metis_one_level(rr,cc,vv,rid,weights) # rr is ordered\n parents.append(cluster_id)\n\n # TO DO\n # COMPUTE THE SIZE OF THE SUPERNODES AND THEIR DEGREE \n #supernode_size = full( sparse(cluster_id, ones(N,1) ,\n #\tsupernode_size ) )\n #print(cluster_id)\n #print(supernode_size)\n #nd_sz{count+1}=supernode_size;\n\n # COMPUTE THE EDGES WEIGHTS FOR THE NEW GRAPH\n nrr = cluster_id[rr]\n ncc = cluster_id[cc]\n nvv = vv\n Nnew = cluster_id.max() + 1\n # CSR is more appropriate: row,val pairs appear multiple times\n W = scipy.sparse.csr_matrix((nvv,(nrr,ncc)), shape=(Nnew,Nnew))\n W.eliminate_zeros()\n # Add new graph to the list of all coarsened graphs\n graphs.append(W)\n N, N = W.shape\n\n # COMPUTE THE DEGREE (OMIT OR NOT SELF LOOPS)\n degree = W.sum(axis=0)\n #degree = W.sum(axis=0) - W.diagonal()\n\n # CHOOSE THE ORDER IN WHICH VERTICES WILL BE VISTED AT THE NEXT PASS\n #[~, rid]=sort(ss); # arthur strategy\n #[~, rid]=sort(supernode_size); # thomas strategy\n #rid=randperm(N); # metis/graclus strategy\n ss = np.array(W.sum(axis=0)).squeeze()\n rid = np.argsort(ss)\n\n return graphs, parents","def create_weight_matrices(self):\n rad = 1 / np.sqrt(self.no_of_in_nodes)\n X = truncated_normal(mean=0, \n sd=1, \n low=-rad, \n upp=rad)\n self.wih = X.rvs((self.no_of_hidden_nodes, \n self.no_of_in_nodes))\n rad = 1 / np.sqrt(self.no_of_hidden_nodes)\n X = truncated_normal(mean=0, sd=1, low=-rad, upp=rad)\n self.who = X.rvs((self.no_of_out_nodes, \n self.no_of_hidden_nodes))","def compute_sparse_masks(cls):\n with torch.no_grad():\n for module_name, module, p_name, p, mask, pruned in cls.__sparse_parameters:\n if mask.sum() < mask.numel(): # when recalculating masks\n # restore dense parameter if allow_recompute_mask is enabled\n assert (pruned is not None), \"Unable to restore dense parameter because allow_recompute_mask == False\"\n p.add_(pruned.cuda())\n\n mask.set_(cls.__calculate_mask(p))\n\n if pruned is not None: # stow away pruned weights to cpu\n pruned.set_((p * (~mask)).cpu())\n\n p.mul_(mask) # in-place multiplication, so pruned weights are 0-values, hence checkpoint will have 0s for pruned weights\n if cls.__verbosity >= 2:\n print(\"[ASP] Enabled %.2f%% sparsity for %s::%s of size=%s and type=%s\" % (100.0*mask.sum()/mask.numel(), module_name, p_name, str(p.size()), str(p.dtype)))","def next_sparse(sparse_number):\n\n # print(\"sparse_number 0b{0:b}\".format(sparse_number))\n\n # Edge case. Handle explicitly for clarity\n if sparse_number == 0:\n return 1\n\n power_max = twos_power_max(sparse_number)\n\n for power in range(0, power_max):\n # print(\"power\", power)\n if is_zero_bit_and_no_neighbor_ones(sparse_number, power):\n # print(\"at middle of 000 change to 010\")\n return sparse_number + (2 ** power)\n if is_right_end_of_001(sparse_number, power):\n # print(\"at right of 001 change to 01 followed by all zeros\")\n sparse_zeroed_low_bits = (sparse_number >> (power + 1)) * (2 ** (power + 1))\n # print(\"sparse_zeroed_low_bits {0:b}\".format(sparse_zeroed_low_bits))\n return sparse_zeroed_low_bits + (2 ** (power + 1))\n\n return (2 ** (power_max + 1))","def test_build_classification_matrix_sparse():\n import scnym\n\n # generate a sparse matrix with ~10% of elements filled\n B = np.zeros((100, 10))\n ridx = np.random.choice(B.size, size=100, replace=True)\n B.flat[ridx] = 1\n B = sparse.csr_matrix(B)\n\n # create dummy gene names where the order of\n # genes in `B` is permuted\n A_genes = np.arange(10)\n B_genes = np.random.permutation(A_genes)\n\n # build the classification matrix\n X = scnym.utils.build_classification_matrix(\n X=B,\n model_genes=A_genes,\n sample_genes=B_genes,\n )\n assert sparse.issparse(X)\n\n # X should have the genes of B in the order of A\n for i, g in enumerate(A_genes):\n j = int(np.where(B_genes == g)[0])\n assert np.all(X[:, i].toarray() == B[:, j].toarray())\n return","def get_weight_from_minflow(self):\n start_nodes = []\n end_nodes = []\n capacities = []\n unit_costs = []\n A = 0\n s_prime = self.sink() + 1\n t_prime = self.sink() + 2\n x = self.sink() + 3\n # for every edge in the graph, add edge to mincost flow instance with\n # infinite capacity and cost 1\n # also add backwards edge\n for arc in self.arc_info.keys():\n # forward edge\n start_nodes.append(self.arc_info[arc][\"start\"])\n end_nodes.append(self.arc_info[arc][\"destin\"])\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"start\"],\n self.arc_info[arc][\"destin\"]))\n # backward edge\n start_nodes.append(self.arc_info[arc][\"destin\"])\n end_nodes.append(self.arc_info[arc][\"start\"])\n capacities.append(int(self.arc_info[arc][\"weight\"])) # no negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.arc_info[arc][\"destin\"],\n self.arc_info[arc][\"start\"]))\n # add (x,s) and (t,x) edges with same cap, cost as above\n in_weight_x = 0\n for in_arc in self.in_arcs_lists[self.sink()]:\n in_weight_x += self.arc_info[in_arc][\"weight\"]\n out_weight_x = 0\n for out_arc in self.out_arcs_lists[self.source()]:\n out_weight_x += self.arc_info[out_arc][\"weight\"]\n # (x,s)\n start_nodes.append(x)\n end_nodes.append(self.source())\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.source()))\n # backward\n start_nodes.append(self.source())\n end_nodes.append(x)\n capacities.append(int(out_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.source(),\n x))\n # (t,x)\n start_nodes.append(self.sink())\n end_nodes.append(x)\n capacities.append(100000) # capacity of 100,000 instead of inf\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n self.sink(),\n x))\n # backward\n start_nodes.append(x)\n end_nodes.append(self.sink())\n capacities.append(int(in_weight_x)) # don't go negative\n unit_costs.append(1)\n print(\"Adding arc ({}, {}) with unit cost and cap inf\".format(\n x,\n self.sink()))\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\n # and cost 0.\n for v in self:\n # process internal verts only, since we assume source and sink have\n # no in and out edges respectively\n if v != self.source() and v != self.sink():\n # compute a-exc(v)\n in_weight = 0\n for in_arc in self.in_arcs_lists[v]:\n in_weight += self.arc_info[in_arc][\"weight\"]\n out_weight = 0\n for out_arc in self.out_arcs_lists[v]:\n out_weight += self.arc_info[out_arc][\"weight\"]\n a_exc = out_weight - in_weight\n if a_exc < 0:\n # add edge (s', v)\n start_nodes.append(s_prime)\n end_nodes.append(v)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n v,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (v, t')\n start_nodes.append(v)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n v,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # process x node\n a_exc = out_weight_x - in_weight_x\n if a_exc < 0:\n # add edge (s', x)\n start_nodes.append(s_prime)\n end_nodes.append(x)\n capacities.append(int(-a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n s_prime,\n x,\n int(-a_exc)))\n if a_exc > 0:\n # add edge (x, t')\n start_nodes.append(x)\n end_nodes.append(t_prime)\n capacities.append(int(a_exc))\n unit_costs.append(0)\n print(\"Adding arc ({}, {}) with cost 0 and cap {}\".format(\n x,\n t_prime,\n int(a_exc)))\n # update A\n A += a_exc\n # we must send flow of A from s_prime to t_prime\n supplies = [0]*(len(self) + 3)\n supplies[s_prime] = int(A)\n supplies[t_prime] = int(-A)\n # Instantiate a SimpleMinCostFlow solver.\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\n # Add each arc.\n for i in range(len(start_nodes)):\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\n end_nodes[i], capacities[i], unit_costs[i])\n # Add node supplies\n for i in range(0, len(supplies)):\n min_cost_flow.SetNodeSupply(i, supplies[i])\n # Find the minimum cost flow between node s' and t'.\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\n print('Minimum cost:', min_cost_flow.OptimalCost())\n print('')\n print(' Arc Flow / Capacity Cost')\n for i in range(min_cost_flow.NumArcs()):\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\n print('%1s -> %1s %3s / %3s %3s' % (\n min_cost_flow.Tail(i),\n min_cost_flow.Head(i),\n min_cost_flow.Flow(i),\n min_cost_flow.Capacity(i),\n cost))\n # update arcs\n start = min_cost_flow.Tail(i)\n destin = min_cost_flow.Head(i)\n if start != s_prime and \\\n start != t_prime and \\\n start != x and \\\n destin != s_prime and \\\n destin != t_prime and \\\n destin != x:\n # if forward, increase flow. otherwise decrease.\n print(\"Processing edge ({}, {})\".format(start, destin))\n if start < destin:\n sup_flow = min_cost_flow.Flow(i)\n else:\n sup_flow = -min_cost_flow.Flow(i)\n temp_start = start\n start = destin\n destin = temp_start\n print(\"Has become ({}, {}) with sup {}\".format(start,\n destin,\n sup_flow))\n arc = self.get_arc(start, destin)\n if (sup_flow != 0) or (\"lower_bound\" not in \\\n self.arc_info[arc].keys()):\n print(\"We should add this\")\n old_flow = self.arc_info[arc][\"weight\"]\n new_flow = old_flow + sup_flow\n self.arc_info[arc][\"weight\"] = int(new_flow)\n print(\"Edge ({},{}) weight is changed from {} to {}\".format(\n start,\n destin,\n old_flow,\n new_flow))\n else:\n print('There was an issue with the min cost flow input.')\n #self.check_conservation_of_flow() # check that solution is valid","def make_ws_graph(num_nodes, clockwise_neighbours, rewiring_prob):\r\n #initialize empty graph\r\n ws_graph = {}\r\n for vertex in range(num_nodes): ws_graph[vertex] = []\r\n #add each vertex to clockwise neighbours\r\n for vertex in range(num_nodes):\r\n for neighbour in range(vertex + 1, vertex + clockwise_neighbours + 1):\r\n neighbour = neighbour % num_nodes\r\n ws_graph[vertex] += [neighbour]\r\n ws_graph[neighbour] += [vertex]\r\n for vertex in range(num_nodes):\r\n for neighbour in ws_graph[vertex]:\r\n if random.random() < rewiring_prob:\r\n ws_graph[vertex].remove(neighbour)\r\n ws_graph[neighbour].remove(vertex)\r\n randNode = random.randint(0, num_nodes-1)\r\n while(vertex == randNode):\r\n randNode = random.randint(0, num_nodes - 1)\r\n ws_graph[vertex] += [randNode]\r\n ws_graph[randNode] += [vertex]\r\n\r\n\r\n return ws_graph\r\n #rewire each edge with probability rewiring_prob\r\n\r\n #consider each vertex\r\n\r\n #consider each neighbour\r\n\r\n #decide whether to rewire and join to a random node\r\n\r\n #update if necessary\r","def make_demand_tensor(city):\n # remove file\n # filter_station(city)\n\n\n # calculate each time unit for each city, and get a average count map\n # 0. get station number map {station: [num1, num2, num3]}(num3 == num1 + num2)\n # 1. get all record into a map {time unit: {station: [amount1, count1, amount2, count2, amount3, count3]}}\n # 2. combine two maps, then change into {time unit: {station: [emp1, num1, r1, emp2, num2, r2, emp3, num3, r3]}}\n number_map = {}\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as f:\n reader = csv.reader(f)\n for line in reader:\n if line[0] not in number_map:\n number_map[line[0]] = [line[2],line[5],line[8]]\n if len(number_map) == station_count[city]:\n break\n\n count_map = {}\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\n time_unit = file[8:12]\n if time_unit not in count_map:\n count_map[time_unit] = {}\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as f:\n reader = csv.reader(f)\n for line in reader:\n if len(line) < 10:\n continue\n station_id = line[0]\n amount1, amount2, amount3 = float(line[3]), float(line[6]), float(line[9])\n if station_id not in count_map[time_unit]:\n count_map[time_unit][station_id] = [0, 0, 0, 0, 0, 0]\n count_map[time_unit][station_id][0] += amount1\n count_map[time_unit][station_id][2] += amount2\n count_map[time_unit][station_id][4] += amount3\n count_map[time_unit][station_id][1] += 1\n count_map[time_unit][station_id][3] += 1\n count_map[time_unit][station_id][5] += 1\n\n average_map = {}\n for time_unit, station_map in count_map.items():\n average_map[time_unit] = {}\n for station_id, info in station_map.items():\n rate1 = count_map[time_unit][station_id][0] / count_map[time_unit][station_id][1]\n rate2 = count_map[time_unit][station_id][2] / count_map[time_unit][station_id][3]\n rate3 = count_map[time_unit][station_id][4] / count_map[time_unit][station_id][5]\n count1 = int(number_map[station_id][0])\n count2 = int(number_map[station_id][1])\n count3 = int(number_map[station_id][2])\n emp1, emp2, emp3 = math.ceil(rate1 * count1), math.ceil(rate2 * count2), math.ceil(rate3 * count3)\n average_map[time_unit][station_id] = [station_id, emp1, count1, rate1, emp2, count2, rate2, emp3, count3, rate3]\n\n\n # fill the missing record according to the above map\n num = 0\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as f:\n count = len(f.readlines())\n if count == station_count[city]:\n continue\n num += 1\n print('fill for', file)\n print('before', count)\n\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as f:\n reader = csv.reader(f)\n a = [int(line[0]) for line in reader]\n\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file, \"a\") as f:\n writer = csv.writer(f)\n diff_set = set(range(0, station_count[city])) - set(a)\n time_unit = file[8:12]\n for station_id in sorted(diff_set):\n writer.writerow(average_map[time_unit][str(station_id)])\n\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file, \"r\") as f:\n print('after', len(f.readlines()))\n print('fill', num, 'files')\n\n\n # change csv file into npy file\n time_index_map = np.load(exp_data_path + os.sep + 'station_list' + os.sep + 'time_index.npy', allow_pickle=True)\n time_index_map = dict(time_index_map.tolist())\n\n numpy_all_data = np.empty((station_count[city], len(time_index_map['index']), 6))\n numpy_data = np.empty((station_count[city], len(time_index_map['index']), 3))\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\n time_index = int(time_index_map['rev_index'][file[0:12]])\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as f:\n reader = csv.reader(f)\n for line in reader:\n station_id = int(line[0])\n try:\n # 交流(慢充)，直流（慢充），总数\n count1, count2, count3 = int(line[2]), int(line[5]), int(line[8])\n # 慢充需求，快充需求，总需求\n rate1, rate2, rate3 = float(line[3]), float(line[6]), float(line[9])\n except:\n print(file, line)\n break\n numpy_data[station_id, time_index] = [rate1, rate2, rate3]\n numpy_all_data[station_id, time_index] = [count1, rate1, count2, rate2, count3, rate3]\n\n data_file_name = exp_data_path + os.sep + 'station' + os.sep + 'demand_{}'.format(city)\n if os.path.exists(data_file_name):\n os.remove(data_file_name)\n np.save(data_file_name, numpy_data)\n print(numpy_data.shape)\n print(numpy_all_data.shape)\n\n all_data_file_name = exp_data_path + os.sep + 'station' + os.sep + 'all_demand_{}'.format(city)\n if os.path.exists(all_data_file_name):\n os.remove(all_data_file_name)\n np.save(all_data_file_name, numpy_all_data)\n pass","def copy(self):\n return SparseN(self)","def formAdjacencyMatrix(self):\n self.adjacencyMatrix = dict()\n for i in self.node:\n self.adjacencyMatrix[i] = dict()\n for j in self.node:\n self.adjacencyMatrix[i][j] = 0\n \n for ij in self.link:\n self.adjacencyMatrix[self.link[ij].tail][self.link[ij].head] = 1","def _update_attributes(self,circuit_graph,name,lib_name,lib_graph, Gsub):\n #PnR can route primitive power but not subckt power\n if lib_name in self.all_lef:\n pg = []\n else:\n pg = self.pg\n G1 = circuit_graph\n num = len([key for key in Gsub\n if 'net' not in G1.nodes[key][\"inst_type\"]])\n # Define ports for subblock\n matched_ports = {}\n ports_weight = {}\n G2 = lib_graph.copy()\n for g1_n, g2_n in Gsub.items():\n if 'net' in G2.nodes[g2_n][\"inst_type\"]:\n if 'external' in G2.nodes[g2_n][\"net_type\"]:\n if num > 1 and g1_n in pg:\n # remove power connections\n G2=nx.relabel_nodes(G2,{g2_n:g1_n},copy=False)\n else:\n matched_ports[g2_n] = g1_n\n ports_weight[g2_n] = []\n for nbr in list(G2.neighbors(g2_n)):\n ports_weight[g2_n].append(G2.get_edge_data(g2_n, nbr)['weight'])\n else:\n G2.nodes[g2_n]['values'] = G1.nodes[g1_n]['values']\n G2.nodes[g2_n]['real_inst_type'] = G1.nodes[g1_n]['real_inst_type']\n return matched_ports,ports_weight,G2"],"string":"[\n \"def sparsify(W,conn):\\n \\n N = W.shape[0]\\n W_sparse = sparse.lil_matrix((N,N)) \\n for row, weights in itertools.izip(conn, W):\\n W_sparse[row[0],row[1:]] = weights[1:]\\n return W_sparse\",\n \"def set_sparse_signals(self):\\n\\t\\n\\t\\tparams_dSs = [self.mu_dSs, self.sigma_dSs]\\n\\t\\tparams_Ss0 = [self.mu_Ss0, self.sigma_Ss0]\\n\\t\\tself.dSs, self.idxs = sparse_vector([self.Nn, self.Kk], \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tparams_dSs,\\tseed=self.seed_dSs)\\n\\t\\t\\n\\t\\t# Replace components with conflicting background odor \\n\\t\\tif self.Kk_split is not None and self.Kk_split != 0:\\n\\t\\t\\tassert 0 <= self.Kk_split <= self.Kk, \\\\\\n\\t\\t\\t\\t\\\"Splitting sparse signal into two levels requires Kk_split\\\" \\\\\\n\\t\\t\\t\\t\\\" to be non-negative and less than or equal to Kk.\\\"\\n\\t\\t\\tassert self.mu_dSs_2 is not None \\\\\\n\\t\\t\\t\\tand self.sigma_dSs_2 is not None, \\\\\\n\\t\\t\\t\\t\\\"Splitting sparse signal into two levels requires that\\\" \\\\\\n\\t\\t\\t\\t\\\" mu_dSs_2 and sigma_dSs_2 are set.\\\"\\n\\n\\t\\t\\tsp.random.seed(self.seed_dSs)\\n\\t\\t\\tself.idxs_2 = sp.random.choice(self.idxs[0], self.Kk_split, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\treplace=False)\\n\\t\\t\\tfor idx_2 in self.idxs_2:\\n\\t\\t\\t\\tself.dSs[idx_2] = sp.random.normal(self.mu_dSs_2, \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.sigma_dSs_2)\\n\\t\\telse:\\n\\t\\t\\tself.idxs_2 = []\\n\\t\\t\\tself.Kk_split = 0\\n\\t\\t\\t\\n\\t\\t# Ss0 is the ideal (learned) background stimulus without noise\\n\\t\\tself.Ss0, self.Ss0_noisy = sparse_vector_bkgrnd([self.Nn, self.Kk], \\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tself.idxs, params_Ss0,\\n\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\t\\tseed=self.seed_Ss0)\\n\\t\\t\\n\\t\\tself.Ss = self.dSs + self.Ss0_noisy\",\n \"def connection(self, sampleseq, num):\\n self.Adjmatrix = np.zeros((self.nodenum, self.nodenum), dtype = int)\\n \\n for i in range(self.supplynum):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.trandemandseries], sampleseq[self.supplyseries[i]]))\\n self.Adjmatrix[self.supplyseries[i], self.trandemandseries[minindex]] = 1\\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\\n \\n for i in range(self.trannum):\\n if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) == 0):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\\n self.Adjmatrix[minindex, self.transeries[i]] = 1\\n# self.Adjmatrix[self.transeries[i], minindex] = 1\\n \\n \\n# for i in range(self.supplynum):\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.supplyseries], num))\\n# self.Adjmatrix[self.supplyseries[i], minindex] = 1\\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\\n \\n# for i in range(self.trannum):\\n# if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) != 0):\\n# continue\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\\n## self.Adjmatrix[self.transeries[i], minindex] = 1\\n# \\n for i in range(self.trannum):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.demandseries], min(sampleseq[self.transeries[i]], self.demandnum))) + self.supplynum + self.trannum\\n self.Adjmatrix[self.transeries[i], minindex] = 1\\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\\n \\n# for i in range(self.demandnum):\\n# if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], 1)) + self.supplynum\\n# self.Adjmatrix[minindex, self.demandseries[i]] = 1\\n \\n# for i in range(self.trannum):\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.transeries], num)) + self.supplynum\\n# self.Adjmatrix[self.transeries[i], minindex] = 1\\n \\n for i in range(self.demandnum):\\n if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], num)) + self.supplynum\\n self.Adjmatrix[minindex, self.demandseries[i]] = 1\\n# self.Adjmatrix[self.demandseries[i], minindex] = 1\\n \\n for i in range(self.demandnum):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.demandseries[i], self.demandseries], min(sampleseq[self.demandseries[i]] + 1, self.demandnum))) + self.supplynum + self.trannum\\n minindex = minindex[1:-1]\\n for j in range(len(minindex)):\\n if(self.Adjmatrix[self.demandseries[i], minindex[j]] == 1 or self.Adjmatrix[minindex[j], self.demandseries[i]] == 1):\\n continue\\n self.Adjmatrix[self.demandseries[i], minindex[j]] = 1\",\n \"def _build_sparse(self, name, wrt, consize, param_vals, sub_param_conns,\\n full_param_conns, rels):\\n\\n jac = None\\n\\n # Additional sparsity for index connections\\n for param in wrt:\\n\\n sub_conns = sub_param_conns.get(param)\\n if not sub_conns:\\n continue\\n\\n # If we have a simultaneous full connection, then we move on\\n full_conns = full_param_conns.get(param)\\n if full_conns.intersection(rels):\\n continue\\n\\n rel_idx = set()\\n for target, idx in iteritems(sub_conns):\\n\\n # If a target of the indexed desvar connection is\\n # in the relevant path for this constraint, then\\n # those indices are relevant.\\n if target in rels:\\n rel_idx.update(idx)\\n\\n nrel = len(rel_idx)\\n if nrel > 0:\\n\\n if jac is None:\\n jac = {}\\n\\n if param not in jac:\\n # A coo matrix for the Jacobian\\n # mat = {'coo':[row, col, data],\\n # 'shape':[nrow, ncols]}\\n coo = {}\\n coo['shape'] = [consize, len(param_vals[param])]\\n jac[param] = coo\\n\\n row = []\\n col = []\\n for i in range(consize):\\n row.extend([i]*nrel)\\n col.extend(rel_idx)\\n data = np.ones((len(row), ))\\n\\n jac[param]['coo'] = [np.array(row), np.array(col), data]\\n\\n if name not in self.sub_sparsity:\\n self.sub_sparsity[name] = {}\\n self.sub_sparsity[name][param] = np.array(list(rel_idx))\\n\\n return jac\",\n \"def create_sparseDB():\\n datas = data.Kmercount_to_matrix()\\n datas.run()\\n print('***Sparse matrix created***')\",\n \"def create_sparse_matrix(self, matrix_df):\\n\\n print('creating sparse matrix...')\\n sparse_seg_tmp_df = matrix_df.groupby(['segment_id','day_of_week','time_idx'])[self.args['cluster_variable']].mean().reset_index()\\n sparse_rt_tmp_df = matrix_df.groupby(['road_type','day_of_week','time_idx'])[self.args['cluster_variable']].mean().reset_index()\\n time_seg_df = sparse_seg_tmp_df.groupby(['day_of_week','time_idx'])[self.args['cluster_variable']].mean().reset_index()\\n time_rt_df = sparse_rt_tmp_df.groupby(['day_of_week','time_idx'])[self.args['cluster_variable']].mean().reset_index()\\n #time_seg_df['time_id'] = time_seg_df.index\\n #time_rt_df['time_id'] = time_rt_df.index\\n times = list(range(24*60/self.args['time_resolution']))\\n full_time_idx = pd.DataFrame([i * 30 for i in times],columns = ['time_idx'])\\n full_time_idx['key'] = 1\\n full_day_of_week = pd.DataFrame(list(range(7)), columns = ['day_of_week'])\\n full_day_of_week['key'] = 1\\n full_times = pd.merge(full_time_idx, full_day_of_week, on='key')\\n full_times['time_id'] = full_times.index\\n time_seg_df = pd.merge(time_seg_df, full_times[['time_idx','day_of_week','time_id']], on=['time_idx','day_of_week'])\\n time_rt_df = pd.merge(time_rt_df, full_times[['time_idx','day_of_week','time_id']], on=['time_idx','day_of_week'])\\n \\n matrix_seg_keys_df = pd.merge(sparse_seg_tmp_df, time_seg_df[['time_id','day_of_week','time_idx']], how='left', on=['day_of_week','time_idx'])\\n matrix_rt_keys_df = pd.merge(sparse_rt_tmp_df, time_rt_df[['time_id','day_of_week','time_idx']], how='left', on=['day_of_week','time_idx'])\\n\\n time_seg_array = np.array(matrix_seg_keys_df['time_id'])\\n time_rt_array = np.array(matrix_rt_keys_df['time_id'])\\n segment_array = np.array(matrix_seg_keys_df['segment_id'])\\n rt_array = np.array(matrix_rt_keys_df['road_type'])\\n\\n uniquesegments = np.array(list(set(segment_array)))\\n uniquerts = np.array(list(set(rt_array)))\\n keyuniquesegments = np.array(range(len(uniquesegments)))\\n keyuniquerts = np.array(range(len(uniquerts)))\\n uniquesegments_df = pd.DataFrame({'segmentskey':keyuniquesegments, 'segment_id':uniquesegments})\\n uniquerts_df = pd.DataFrame({'roadtypekey':keyuniquerts, 'road_type':uniquerts})\\n\\n segments_df = pd.DataFrame(segment_array, columns = ['segment_id'])\\n rt_df = pd.DataFrame(rt_array, columns = ['road_type'])\\n segments_keys_df = pd.merge(segments_df, uniquesegments_df, how='left', on=['segment_id'])\\n rt_keys_df = pd.merge(rt_df, uniquerts_df, how='left', on=['road_type'])\\n segmentkeys = np.array(segments_keys_df['segmentskey'])\\n rtkeys = np.array(rt_keys_df['road_type'])\\n\\n level_array_seg = np.array(matrix_seg_keys_df['level_max'])\\n sparse_matrix_s = csr_matrix((level_array_seg, (segmentkeys,time_seg_array))).toarray()\\n sparse_matrix_seg = preprocessing.scale(sparse_matrix_s)\\n level_array_rt = np.array(matrix_rt_keys_df['level_max'])\\n sparse_matrix_r = csr_matrix((level_array_rt, (rtkeys,time_rt_array))).toarray()\\n sparse_matrix_rt = preprocessing.scale(sparse_matrix_r)\\n \\n if self.args['perform_pca']:\\n sparse_matrix_seg, self.pca_model = self.run_PCA(sparse_matrix_seg)\\n sparse_matrix_rt, self.pca_model = self.run_PCA(sparse_matrix_rt)\\n else:\\n sparse_matrix_seg = sparse_matrix_seg\\n sparse_matrix_rt = sparse_matrix_rt\\n \\n sparse_matrix_withsegkey = pd.DataFrame(sparse_matrix_seg)\\n sparse_matrix_withrtkey = pd.DataFrame(sparse_matrix_rt)\\n sparse_matrix_withsegkey['segmentskey'] = sparse_matrix_withsegkey.index\\n sparse_matrix_withseg = pd.merge(uniquesegments_df, sparse_matrix_withsegkey, on=['segmentskey'])\\n sparse_matrix_withrtkey['roadtypekey'] = sparse_matrix_withrtkey.index\\n sparse_matrix_withrt = pd.merge(uniquerts_df, sparse_matrix_withrtkey, on=['roadtypekey'])\\n \\n # write sparse_matrix to database as 'clustering' table\\n print('writing sparse matrix to db...')\\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\\n engine = create_engine(sqlalchemy_conn_str)\\n if self.split_type == 'random':\\n sparse_matrix_withseg.to_sql(name='clust_sparse_avebysegment_random', con=engine, if_exists='replace')\\n sparse_matrix_withrt.to_sql(name='clust_sparse_avebyrt_random', con=engine, if_exists='replace')\\n elif self.split_type == 'date':\\n sparse_matrix_withseg.to_sql(name='clust_sparse_avebysegment_date', con=engine, if_exists='replace')\\n sparse_matrix_withrt.to_sql(name='clust_sparse_avebyrt_date', con=engine, if_exists='replace')\\n \\n print('returning train sparse matrix...')\\n return (uniquesegments_df, sparse_matrix_seg)\",\n \"def simulate_sparse(n_rows, n_columns, row_density=0.001):\\n # X = sparse.lil_matrix((n_rows, n_columns))\\n X = []\\n counter = 0\\n for row in range(n_rows):\\n counter += 1\\n if (counter % 1000) == 0:\\n print(counter)\\n\\n # X[row] = sparse.random(1, n_columns, density=row_density)\\n X.append(sparse.random(1, n_columns, density=row_density, format='lil'))\\n\\n return sparse.vstack(X).tocsr()\",\n \"def _create_sparse_train_and_test(ratings, n_users, n_items):\\n \\n # pick a random set of data as testing data, sorted ascending\\n test_set_size = len(ratings) / TEST_SET_RATIO\\n test_set_idx = np.random.choice(xrange(len(ratings)), size=test_set_size, replace=False)\\n test_set_idx = sorted(test_set_idx)\\n \\n # use the remaining data to create a training set\\n ts_ratings = ratings[test_set_idx]\\n tr_ratings = np.delete(ratings, test_set_idx, axis=0)\\n \\n # create training and test matrices as coo_matrix\\n u_tr, i_tr, r_tr = zip(*tr_ratings)\\n tr_sparse = coo_matrix((r_tr, (u_tr, i_tr)), shape=(n_users, n_items))\\n u_ts, i_ts, r_ts = zip(*ts_ratings)\\n test_sparse = coo_matrix((r_ts, (u_ts, i_ts)), shape=(n_users, n_items))\\n \\n return tr_sparse, test_sparse\",\n \"def convert_sparse_to_igraph(indices, matrix):\\n # sources, targets = matrix.nonzero()\\n # weights = matrix[sources, targets]\\n # weights = np.array(weights)[0]\\n # print(dir(louvain))\\n # ig = igraph.Graph(zip(sources, targets), directed=True,\\n # edge_attrs={'weight': weights})\\n # return ig\\n g = igraph.Graph.Adjacency((matrix > 0).tolist())\\n g.es['weight'] = matrix[matrix.nonzero()]\\n # g.vs['label'] = node_names # or a.index/a.columns\\n return g\",\n \"def add_sparse(self, key, element):\\n self.add(self._sparse2seq(key), element)\",\n \"def makesparse(matrix):\\n n = matrix[0].size\\n elements = []\\n for i in range(n):\\n for j in range(n):\\n if matrix[i][j] != 0 :\\n temp = MatrixElement(i, j, matrix[i][j])\\n elements.append(temp)\\n return SparseMatrix(n, elements)\",\n \"def build_adjacency(self, connectivity_matrix, n_neighbours):\\n \\n #Get k strongest connections\\n connections, idx = self.get_k_strongest_connections(connectivity_matrix, n_neighbours)\\n \\n #Sparse matrix\\n M, k = connections.shape\\n assert M, k == idx.shape #M - number of vertices. k == nearest neighbours \\n assert connections.min() >= 0\\n\\n # Weights.\\n sigma2 = np.mean(connections[:, -1])**2\\n connections = np.exp(- connections**2 / sigma2)\\n\\n # Weight matrix.\\n I = np.arange(0, M).repeat(k) #row\\n J = idx.reshape(M*k) #col\\n V = connections.reshape(M*k) #data \\n W = sparse.coo_matrix((V, (I, J)), shape=(M, M)) #COO is a fast format for constructing sparse matrices\\n\\n # No self-connections.\\n W.setdiag(0)\\n\\n # Non-directed graph.\\n bigger = W.T > W\\n W = W - W.multiply(bigger) + W.T.multiply(bigger)\\n return W\",\n \"def compress_csr(self):\\n _, unique, indices = np.unique(\\n self.m*self.rows + self.cols,\\n return_index=True, return_inverse=True)\\n self.rows = self.rows[unique]\\n self.cols = self.cols[unique]\\n self.vals = np.bincount(indices, weights=self.vals)\",\n \"def init_sg_weights(self):\\n n = self.weights_shape[0] # size of current layer\\n # pylint: disable=no-member\\n A = np.random.randn(n, n) / np.sqrt(n)\\n B = np.random.randn(10, n) / np.sqrt(n)\\n C = np.random.randn(1, n) / np.sqrt(n)\\n # pylint: enable=no-member\\n self.sg_weights = [A, B, C]\",\n \"def sparse_initialization_weights(self):\\n W = []\\n mu, sigma = 0, 1/self.non_zero_units\\n\\n for i in xrange(self.n_in):\\n row = np.zeros(self.n_out)\\n non_zeros = self.rng.normal(mu, sigma, self.non_zero_units)\\n # non_zeros /= non_zeros.sum()\\n non_zero_idxs = self.rng.permutation(\\n self.n_out)[0:self.non_zero_units]\\n for j in xrange(self.non_zero_units):\\n row[non_zero_idxs[j]] = non_zeros[j]\\n W.append(row)\\n W = np.asarray(W, dtype=theano.config.floatX)\\n return W\",\n \"def create_sparse_matrix(self, filename, matrix_length, density):\\n pos = 0\\n aux_pos = 0\\n matrix = []\\n pointerB = []\\n pointerE = []\\n columns = []\\n values = []\\n\\n for i in range(0, matrix_length):\\n row = []\\n pointerB.append(pos)\\n aux_pos = pos\\n for j in range(0, matrix_length):\\n probability = random.random()\\n if probability < density:\\n pos += 1\\n val = random.randint(1, 10)\\n values.append(val)\\n columns.append(j)\\n else:\\n val = 0\\n row.append(val)\\n matrix.append(row)\\n pointerE.append(pos)\\n vector_b = SparseMatrix.gen_vector(matrix_length)\\n matrix_A = np.matrix(matrix)\\n vector_res = np.dot(matrix_A, vector_b).reshape(matrix_length, 1)\\n data = {\\\"values\\\": values, \\\"columns\\\": columns, \\\"pointerB\\\": pointerB, \\\"pointerE\\\": pointerE}\\n CSR_A = json.dumps(data)\\n '''\\n print(\\\"x: \\\", vector_x)\\n print(\\\"A: \\\", matrix_A)\\n print(\\\"b: \\\", vector_b)\\n data = {\\\"values\\\": values, \\\"columns\\\": columns, \\\"pointerB\\\": pointerB, \\\"pointerE\\\": pointerE}\\n data_json = json.dumps(data)\\n file = open(filename, 'w')\\n file.write(data_json)\\n file.close()\\n np.savetxt(\\\"vector.txt\\\", vector_x, fmt=\\\"%1.9f\\\", delimiter=\\\" \\\")\\n '''\\n return matrix_A, CSR_A, vector_b, vector_res\",\n \"def copy(self, shareWeights):\\n newNode = SparseLinear(self.inputDim, self.outputDim, self.stdv)\\n #newNode.receiveGradFrom = self.receiveGradFrom[:]\\n #newNode.receiveInputFrom = self.receiveInputFrom[:]\\n if shareWeights:\\n newNode.weight = self.weight\\n newNode.gradWeight = self.gradWeight\\n newNode.bias = self.bias\\n newNode.gradBias = self.gradBias\\n return newNode\",\n \"def _resource_apply_sparse(self, grad, var, indices):\\n\\n return self._apply_sparse_shared(grad, var, indices, self._resource_scatter_add)\",\n \"def _resource_apply_sparse(self, grad, var, indices):\\n\\n return self._apply_sparse_shared(grad, var, indices, self._resource_scatter_add)\",\n \"def train_clustermodel_sparse(self):\\n\\n print('Clustering using: ' + self.algorithm)\\n uniquesegments_df, sparse_matrix = self.create_sparse_matrix(self.data)\\n\\n clusterer = self.clustering_algorithms[self.algorithm]\\n self.clustering_model = clusterer.fit(sparse_matrix)\\n \\n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_sparse'])\\n clusters_df['segmentskey'] = clusters_df.index\\n clusters_df = clusters_df.reset_index(drop=True)\\n self.clusters_df_final = pd.merge(uniquesegments_df, clusters_df, on=['segmentskey'])\\n self.clusters_df_final['cluster_sparse'].value_counts()\\n \\n today = datetime.date.today()\\n filename = self.algorithm + '_sparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\\n joblib.dump(self.clustering_model, filename)\\n \\n print('Stored ' + filename)\\n \\n return self.clustering_model, self.clusters_df_final[['segment_id','cluster_sparse']]\",\n \"def compute_pw_sparse_out_of_memory2(tr,\\n row_size = 500,\\n pm_processes = 2,\\n pm_pbar = True,\\n max_distance = 50,\\n reassemble = True,\\n cleanup = True,\\n assign = True): \\n\\n # Early warning to save heartache\\n if assign is True and reassemble is False:\\n raise ValueError(\\\"If you want to assign results to a TCRrep instance, you must set reassemble to True\\\")\\n\\n dest = secrets.token_hex(6)\\n os.mkdir(dest)\\n print(f\\\"CREATED /{dest}/ FOR HOLDING DISTANCE OUT OF MEMORY\\\")\\n row_chunks = memory._partition(range(tr.clone_df.shape[0]), row_size)\\n\\n\\n smatrix_chunks = [(tr, ind, f\\\"{dest}/{i}\\\") for i,ind in enumerate(row_chunks)]\\n csrfragments = parmap.starmap(memory.gen_sparse_rw_on_fragment2, \\n smatrix_chunks, \\n max_distance=max_distance, \\n pm_pbar=pm_pbar, \\n pm_processes = pm_processes)\\n\\n if reassemble:\\n csr_full_dict = dict()\\n for chain in tr.chains:\\n chain_str = f\\\"rw_{chain}\\\"\\n csr_full = memory.collapse_csrs([f\\\"{x[2]}.{chain_str}.npz\\\" for x in smatrix_chunks])\\n print(f\\\"RETURNING scipy.sparse csr_matrix w/dims {csr_full.shape}\\\")\\n csr_full_dict[chain] = csr_full\\n else: \\n csr_full_dict= None\\n \\n if assign:\\n for chain in tr.chains:\\n setattr(tr, f\\\"pw_{chain}\\\", csr_full_dict[chain])\\n\\n if cleanup: \\n assert os.path.isdir(dest)\\n print(f\\\"CLEANING UP {dest}\\\")\\n shutil.rmtree(dest)\\n \\n return csr_full_dict, smatrix_chunks\",\n \"def __call__(self, sparse_matrix: PipelinedRDD):\\n rows = sparse_matrix.collect()\\n\\n mat_index, mat_weights = zip(*rows)\\n mat_row, mat_col = zip(*mat_index)\\n tokens_num = len(self.tokens_list)\\n\\n self._log.info(\\\"Building matrix...\\\")\\n matrix = sparse.coo_matrix((mat_weights, (mat_row, mat_col)),\\n shape=(tokens_num, tokens_num))\\n Cooccurrences() \\\\\\n .construct(self.tokens_list, matrix) \\\\\\n .save(output=self.output, series=\\\"id2vec\\\", deps=(self.df_model,))\",\n \"def make_sparse(data):\\n assert data.train_pos_edge_index is not None\\n\\n (row, col), N = data.train_pos_edge_index, data.num_nodes\\n perm = (col * N + row).argsort()\\n row, col = row[perm], col[perm]\\n\\n value = [data.edge_id[(row[i] * N + col[i]).item()].item() for i in perm]\\n\\n data.adj_t = SparseTensor(\\n row=col,\\n col=row,\\n value=torch.tensor(value, dtype=torch.float32),\\n sparse_sizes=(N, N),\\n is_sorted=True,\\n )\\n\\n # Pre-process some important attributes.\\n data.adj_t.storage.rowptr()\\n data.adj_t.storage.csr2csc()\\n\\n return data\",\n \"def to_sparse_matrix(self, grid, format=None):\\n S = self.centered_stencil()\\n # print(\\\"grid :\\\")\\n\\n grid = tuple(grid)\\n # print(grid)\\n if not (np.asarray(S.shape) % 2 == 1).all():\\n raise ValueError('all stencil dimensions must be odd')\\n\\n assert_condition(len(grid) == np.rank(S), ValueError,\\n 'stencil rank must equal number of grid dimensions')\\n assert_condition(min(grid) >= 1, ValueError,\\n 'grid dimensions must be positive')\\n\\n N_v = np.prod(grid) # number of vertices in the mesh\\n N_s = (S != 0).sum() # number of nonzero stencil entries\\n\\n # diagonal offsets\\n diags = np.zeros(N_s, dtype=int)\\n\\n # compute index offset of each dof within the stencil\\n strides = np.cumprod([1] + list(reversed(grid)))[:-1]\\n indices = tuple(i.copy() for i in S.nonzero())\\n for i,s in zip(indices,S.shape):\\n i -= s // 2\\n for stride,coords in zip(strides, reversed(indices)):\\n diags += stride * coords\\n\\n #\\n data = S[S != 0].repeat(N_v).reshape(N_s, N_v)\\n indices = np.vstack(indices).T\\n\\n # zero boundary connections\\n for index,diag in zip(indices,data):\\n diag = diag.reshape(grid)\\n for n,i in enumerate(index):\\n if i > 0:\\n s = [ slice(None) ]*len(grid)\\n s[n] = slice(0,i)\\n diag[s] = 0\\n elif i < 0:\\n s = [ slice(None) ]*len(grid)\\n s[n] = slice(i,None)\\n diag[s] = 0\\n\\n # remove diagonals that lie outside matrix\\n mask = abs(diags) < N_v\\n if not mask.all():\\n diags = diags[mask]\\n data = data[mask]\\n\\n # sum duplicate diagonals\\n if len(np.unique(diags)) != len(diags):\\n new_diags = np.unique(diags)\\n new_data = np.zeros( (len(new_diags),data.shape[1]), dtype=data.dtype)\\n for dia,dat in zip(diags,data):\\n n = np.searchsorted(new_diags,dia)\\n new_data[n,:] += dat\\n\\n diags = new_diags\\n data = new_data\\n\\n return sprs.dia_matrix((data,diags), shape=(N_v, N_v)).asformat(format)\",\n \"def sparse_esn_reservoir(size, spectral_radius, density, symmetric):\\n rvs = stats.uniform(loc=-1., scale=2.).rvs\\n matrix = sparse.random(size, size, density=density, data_rvs=rvs)\\n matrix = matrix.tocsr()\\n if symmetric:\\n matrix = sparse.triu(matrix)\\n tril = sparse.tril(matrix.transpose(), k=-1)\\n matrix = matrix + tril\\n # calc eigenvalues with scipy's lanczos implementation:\\n eig, _ = sparse.linalg.eigsh(matrix, k=2, tol=1e-4)\\n else:\\n eig, _ = sparse.linalg.eigs(matrix, k=2, tol=1e-4)\\n\\n rho = np.abs(eig).max()\\n matrix = matrix.multiply(1. / rho)\\n matrix = matrix.multiply(spectral_radius)\\n return matrix\",\n \"def to_sparse(self):\\n if self.rep.fmt == 'sparse':\\n return self\\n\\n return self.from_rep(self.rep.to_sdm())\",\n \"def set_DirichletSS_sparse(self):\\n \\n \\n self.set_Dirichlet_vessel(self.inlet)\\n\\n\\n self.tissue_consumption(self.Mt)\\n \\n #REINITIALISATION OF THE VECTOR OF TISSUE PHI!!!\\n self.phi_t=np.zeros(len(self.phit))\\n \\n self.set_Dirichlet_north(0)\\n self.set_Dirichlet_east(0)\\n self.set_Dirichlet_west(0)\\n \\n self.A.eliminate_zeros()\",\n \"def convert_sparse_layer(layer_name: str,\\n weights: Dict[str, np.ndarray],\\n coordinates: np.ndarray,\\n input_size: int,\\n output_size: int,\\n is_msp: bool) -> str:\\n components: List[str] = []\\n var_name = convert_name(layer_name)\\n\\n # Create the 1d weight array\\n weight_name = '{0}_DATA'.format(var_name)\\n if is_msp:\\n persistent = '#pragma PERSISTENT({0})'.format(weight_name)\\n components.append(persistent)\\n\\n kernel_name = '{0}/kernel:0'.format(layer_name)\\n\\n fp_weights = array_to_fixed_point(weights[kernel_name],\\n precision=PRECISION,\\n width=WIDTH)\\n weight_array = '{{{0}}}'.format(','.join(map(str, fp_weights)))\\n weight_var = 'static int16_t {0}[] = {1};'.format(weight_name, weight_array)\\n components.append(weight_var)\\n\\n # Convert to a sparse CSR matrix\\n rows = coordinates[:, 0]\\n cols = coordinates[:, 1]\\n coo_mat = sp.coo_matrix((weights[kernel_name], (rows, cols)))\\n\\n csr_mat = coo_mat.tocsr()\\n\\n # Create the row and column arrays\\n row_name = '{0}_ROWS'.format(var_name)\\n\\n if is_msp:\\n persistent = '#pragma PERSISTENT({0})'.format(row_name)\\n components.append(persistent)\\n\\n row_array = '{{{0}}}'.format(','.join(map(str, csr_mat.indptr)))\\n row_var = 'static uint16_t {0}[] = {1};'.format(row_name, row_array)\\n components.append(row_var)\\n\\n col_name = '{0}_COLS'.format(var_name)\\n\\n if is_msp:\\n persistent = '#pragma PERSISTENT({0})'.format(col_name)\\n components.append(persistent)\\n\\n col_array = '{{{0}}}'.format(','.join(map(str, csr_mat.indices)))\\n col_var = 'static uint16_t {0}[] = {1};'.format(col_name, col_array)\\n components.append(col_var)\\n\\n # Create the block sparse matrix\\n mat_name = '{0}_KERNEL'.format(var_name)\\n nnz = len(coordinates)\\n mat_var = 'static SparseMatrix {0} = {{ {1}, {2}, {3}, {4}, {5}, {6} }};'.format(mat_name, weight_name, output_size, input_size, row_name, col_name, nnz)\\n components.append(mat_var)\\n\\n # Create the bias vector\\n bias_name = '{0}/bias:0'.format(layer_name)\\n bias_var = convert_matrix(name=bias_name,\\n mat=weights[bias_name],\\n precision=PRECISION,\\n width=WIDTH,\\n is_msp=is_msp)\\n components.append(bias_var)\\n\\n return '\\\\n'.join(components)\",\n \"def main():\\n\\n \\\"\\\"\\\"\\n nodes, hd3 = erdos_rennie_like(100,8333,5)\\n export('d3',hd3)\\n\\n nodes, hd5 = erdos_rennie_like(100,8333,6)\\n export('d5',hd5)\\n\\n nodes, hd6 = erdos_rennie_like(100,8333,7)\\n export('d6',hd6)\\n \\\"\\\"\\\"\\n\\n \\\"\\\"\\\"\\n nodes, sparse1 = erdos_rennie_like(600, 1200, 3)\\n export('sparse_diag1', sparse1)\\n\\n nodes, sparse2 = erdos_rennie_like(600, 2400, 3)\\n export('sparse_diag2',sparse2)\\n\\n nodes, sparse3 = erdos_rennie_like(600, 5800, 3)\\n export('sparse_diag3',sparse3)\\n\\n nodes, sparse4 = erdos_rennie_like(600,11600, 3)\\n export('sparse_diag4',sparse4)\\n\\n nodes, sparse5 = erdos_rennie_like(600,23200, 3)\\n export('sparse_diag5',sparse5)\\n \\\"\\\"\\\"\\n\\n nodes, size1 = erdos_rennie_like(100, 500, 3)\\n nodes, size2 = erdos_rennie_like(200,1000,3)\\n nodes,size3 = erdos_rennie_like(300,1500,3)\\n nodes,size4 = erdos_rennie_like(400,2000,3)\\n nodes,size5 = erdos_rennie_like(500,2500,3)\\n\\n export('size_diag1',size1)\\n export('size_diag2',size2)\\n export('size_diag3',size3)\\n export('size_diag4',size4)\\n export('size_diag5',size5)\",\n \"def expand_csr_adj(adj, count:int):\\n r,c = adj.shape\\n \\n adj = sp.vstack(\\n [adj, sp.csr_matrix(np.zeros((count, c)))])\\n adj = sp.hstack(\\n [adj, sp.csr_matrix(np.zeros((r + count, count)))])\\n \\n return adj\",\n \"def so_sparse(nspins):\\n sigma_x = sparse.COO(np.array([[0, 1 / 2], [1 / 2, 0]]))\\n sigma_y = sparse.COO(np.array([[0, -1j / 2], [1j / 2, 0]]))\\n sigma_z = sparse.COO(np.array([[1 / 2, 0], [0, -1 / 2]]))\\n unit = sparse.COO(np.array([[1, 0], [0, 1]]))\\n\\n L = np.empty((3, nspins, 2 ** nspins, 2 ** nspins), dtype=np.complex128) # consider other dtype?\\n # Lxs = []\\n # Lys = []\\n # Lzs = []\\n\\n for n in range(nspins):\\n Lx_current = 1\\n Ly_current = 1\\n Lz_current = 1\\n\\n for k in range(nspins):\\n if k == n:\\n Lx_current = sparse.kron(Lx_current, sigma_x)\\n Ly_current = sparse.kron(Ly_current, sigma_y)\\n Lz_current = sparse.kron(Lz_current, sigma_z)\\n else:\\n Lx_current = sparse.kron(Lx_current, unit)\\n Ly_current = sparse.kron(Ly_current, unit)\\n Lz_current = sparse.kron(Lz_current, unit)\\n\\n # Lxs[n] = Lx_current\\n # Lys[n] = Ly_current\\n # Lzs[n] = Lz_current\\n # print(Lx_current.todense())\\n L[0][n] = Lx_current.todense()\\n L[1][n] = Ly_current.todense()\\n L[2][n] = Lz_current.todense()\\n Lz_sparse = sparse.COO(L[2])\\n L_T = L.transpose(1, 0, 2, 3)\\n L_sparse = sparse.COO(L)\\n L_T_sparse = sparse.COO(L_T)\\n Lproduct = sparse.tensordot(L_T_sparse, L_sparse, axes=((1, 3), (0, 2))).swapaxes(1, 2)\\n # Lz_sparse = sparse.COO(L[2])\\n Lproduct_sparse = sparse.COO(Lproduct)\\n\\n return Lz_sparse, Lproduct_sparse\",\n \"def calculate_assignments_sparse(topics, data, voc_size, iterations = 1000, threshold = 1e-4): \\n #calulate block size\\n Ndocs_batch = (50000*10000) // voc_size #fits in 4GB of memory\\n \\n Nbatches = len(data) // Ndocs_batch\\n if Nbatches*Ndocs_batch < len(data):\\n Nbatches += 1\\n \\n start_time = time()\\n for i in range(Nbatches):\\n \\n \\n partial_assignments = calculate_assignments(topics, data[i*Ndocs_batch:(i+1)*Ndocs_batch], voc_size, iterations)\\n partial_assignments[partial_assignments < threshold] = 0 \\n #re-normalize\\n partial_assignments /= partial_assignments.sum(axis=1)[:,np.newaxis]\\n \\n if i==0:\\n sparse_assignments = csr_matrix(partial_assignments)\\n else: \\n sparse_assignments = _csr_vappend(sparse_assignments, csr_matrix(partial_assignments))\\n \\n\\n print('Done batch {} out of {}. Elapsed {:.2f} min.'.format(i,Nbatches, (time()-start_time)/60 ))\\n \\n return sparse_assignments\",\n \"def __init__(self, rows, cols, bandwidth=0, sizeHint=None, matrix=None, storeZeros=True):\\n sizeHint = sizeHint or max(rows, cols) * bandwidth\\n if matrix is None:\\n tmpMatrix = spmatrix.ll_mat(1, 1, 1)\\n if hasattr(tmpMatrix, 'storeZeros'):\\n matrix = spmatrix.ll_mat(rows, cols, sizeHint, storeZeros)\\n else:\\n matrix = spmatrix.ll_mat(rows, cols, sizeHint)\\n\\n _PysparseMatrix.__init__(self, matrix=matrix)\",\n \"def construct_network(self):\\n r = 0\\n n = self.nbr_0_splxs\\n for k in range(n):\\n self.splxs.append((0, (0, k)))\\n self.nbr_splxs += 1\\n r, edge = self.find_next_edge(r)\\n # this while loop finds the new edge to treat and add it to the 1-splx list and then finds out if a 2-splx is created\\n while edge != (-1, -1):\\n # Add the new edge\\n self.one_splxs.append((edge, self.nbr_splxs))\\n self.splxs.append((1, self.nbr_1_splxs))\\n self.nbr_1_splxs += 1\\n self.nbr_splxs += 1\\n self.dist_appearance.append(r)\\n a, b = edge\\n # find out if a 2-splx has been created\\n for i in range(self.nbr_1_splxs - 1):\\n c, d = self.one_splxs[i][0]\\n if d == a:\\n for j in range(i + 1, self.nbr_1_splxs - 1):\\n e, f = self.one_splxs[j][0]\\n if e == c and f == b:\\n self.two_splxs.append((self.nbr_1_splxs - 1, i, j))\\n self.splxs.append((2, self.nbr_2_splxs))\\n self.nbr_2_splxs += 1\\n self.nbr_splxs += 1\\n self.dist_appearance.append(r)\\n # find the next edge to treat\\n r, edge = self.find_next_edge(r)\\n print(\\\"Network created\\\")\\n return ()\",\n \"def create_sparse_coo_matrix(df, n_users, n_items, movie_dict):\\n\\n\\t# Map the movie_ids in the data to the new movie_ids given by the dictionary movie_dict\\n\\tmovie_id_list = list(map(lambda x: movie_dict[x], df['movieId'].tolist()))\\n\\t# Map the user_id in the dataframe to userid - 1 [to account for zero based indexing]\\n\\tuser_id_list = list(map(lambda x: x - 1, df['userId'].tolist()))\\n\\tsparse_matrix_coo = sparse.coo_matrix((df['rating'].tolist(),(user_id_list, movie_id_list)),shape=(n_users,n_items))\\n\\tlogger.debug(\\\"Shape of created sparse matrix: \\\" + str(sparse_matrix_coo.shape))\\n\\tlogger.debug(\\\"Number of non_zero elements in the sparse matrix: \\\" + str(sparse_matrix_coo.nnz))\\n\\tlogger.debug(\\\"Number of entries in the input dataframe:[should match the number of non zero entries in sparse matrix] \\\" + str(df.shape[0]))\\n\\treturn sparse_matrix_coo\",\n \"def create_nonsparse_matrix(self, matrix_df):\\n\\n print('creating nonsparse matrix...')\\n clustering_df_tmp = matrix_df[['date','time','date_idx', 'time_idx', 'day_of_week', 'segment_id', 'road_type', 'lat1', 'lat2', 'lon1', 'lon2', 'level_min', 'level_max', 'level_mean', 'level_count', 'level_binary']]\\n seg_averages = clustering_df_tmp.groupby(['segment_id', 'day_of_week', 'time_idx'])[['level_min', 'level_max', 'level_mean', 'level_count', 'level_binary']].mean().reset_index()\\n rt_averages = clustering_df_tmp.groupby(['road_type', 'day_of_week', 'time_idx'])[['level_min', 'level_max', 'level_mean', 'level_count', 'level_binary']].mean().reset_index()\\n \\n # write nonsparse_matrix_db to database as 'clustering' table\\n print('writing nonsparse matrix to db...')\\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\\n engine = create_engine(sqlalchemy_conn_str)\\n if self.split_type == 'random':\\n seg_averages.to_sql(name='clust_nonsparse_avebysegment_random', con=engine, if_exists='replace')\\n rt_averages.to_sql(name='clust_nonsparse_avebyrt_random', con=engine, if_exists='replace')\\n elif self.split_type == 'date':\\n seg_averages.to_sql(name='clust_nonsparse_avebysegment_date', con=engine, if_exists='replace')\\n rt_averages.to_sql(name='clust_nonsparse_avebyrt_date', con=engine, if_exists='replace')\\n \\n print('returning train nonsparse matrix...')\\n train_averages = clustering_df_tmp.groupby(['segment_id', 'day_of_week', 'time_idx'])[['level_min', 'level_max', 'level_mean', 'level_count','level_binary']].mean().reset_index()\\n train_averages.columns = ['segment_id', 'day_of_week', 'time_idx', 'ave_level_min', 'ave_level_max', 'ave_level_mean', 'ave_level_count', 'ave_level_binary']\\n nonsparse_matrix = pd.merge(clustering_df_tmp, train_averages, how='left', on=['segment_id', 'day_of_week', 'time_idx'])\\n segtimes_df = nonsparse_matrix[['segment_id', 'date', 'time']]\\n nonsparse_matrix_final = nonsparse_matrix.drop(columns=['segment_id', 'date','time', 'level_min', 'level_max', 'level_mean', 'level_count', 'level_binary'])\\n \\n return (segtimes_df, nonsparse_matrix_final)\",\n \"def _compute_adjacency_matrix(self):\\n\\n # Set up a quick-reference index to map cells to indexes\\n for i, cell in enumerate(self.sim.cells):\\n self._cell_indexes[cell] = i\\n\\n if all([self.sim.hub.cells == [self.sim.damaged],\\n self.sim.damaged not in self.sim.cells]):\\n # Add the \\\"damaged\\\" virtual cell to the index if we need it\\n self._cell_indexes[self.sim.damaged] = len(self.sim.cells)\\n\\n node_count = len(list(self._cell_indexes.keys()))\\n g_sparse = np.zeros((node_count, node_count), dtype=float)\\n g_sparse[:] = np.inf\\n\\n for cluster in self.sim.clusters + [self.sim.hub]:\\n cluster_tour = cluster.tour\\n i = len(cluster_tour.vertices) - 1\\n j = 0\\n while j < len(cluster_tour.vertices):\\n start_vertex = cluster_tour.vertices[i]\\n stop_vertex = cluster_tour.vertices[j]\\n\\n start_pt = cluster_tour.points[start_vertex]\\n stop_pt = cluster_tour.points[stop_vertex]\\n distance = np.linalg.norm(stop_pt - start_pt)\\n\\n start_seg = cluster_tour.objects[start_vertex]\\n stop_seg = cluster_tour.objects[stop_vertex]\\n\\n start_index = self._cell_indexes[start_seg]\\n stop_index = self._cell_indexes[stop_seg]\\n\\n g_sparse[start_index, stop_index] = distance\\n\\n i = j\\n j += 1\\n\\n g_sparse = sp.csgraph_from_dense(g_sparse, null_value=np.inf)\\n return g_sparse\",\n \"def _buildMatrix(self, SparseMatrix, Ncells, MaxFaces, coeff):\\n return (0, 0)\",\n \"def __init__(self, size):\\n _PysparseMatrixFromShape.__init__(self, rows=size, cols=size, bandwidth = 1)\\n ids = numerix.arange(size)\\n self.put(numerix.ones(size, 'd'), ids, ids)\",\n \"def construct(self, weights):\\n in_weights = weights # first to append zero column as the last output (no out-degree)\\n weights = np.zeros((weights.shape[0], weights.shape[1]+1))\\n weights[:,:-1] = in_weights\\n din, dout, dhid = self.dim_in, self.dim_out, self.dim_hid # the max dim\\n hid = weights.shape[0] - dout # this hidden dim\\n if not (weights.shape[1]-din-dout==hid and (0<hid<=dhid)):\\n raise self.ANNException('weight matrix hidden nodes not matching')\\n if not (dout < weights.shape[0] <= hid+dout):\\n raise self.ANNException('weight matrix row shape not matching')\\n if not (din+dout < weights.shape[1] <= din+hid+dout):\\n raise self.ANNException('weight matrix column shape not matching')\\n\\n self.weight[din:din+hid,:din+hid] = weights[:hid,:din+hid]\\n self.weight[din:din+hid,din+dhid:] = weights[:hid,din+hid:]\\n self.weight[din+dhid:,:din+hid] = weights[hid:,:din+hid]\\n self.weight[din+dhid:,din+dhid:] = weights[hid:,din+hid:]\\n\\n for i in range(hid):\\n self.connectivity[din+i,:din+i] = True\\n self.connectivity[din+dhid:,:din+hid] = True\\n for i in range(dout):\\n self.connectivity[din+dhid+i,din+dhid:din+dhid+i] = True\\n\\n self.hidden[:hid] = True\",\n \"def train_clustermodel_nonsparse(self):\\n \\n segtimes_df, nonsparse_matrix = self.create_nonsparse_matrix(self.data)\\n segtimes_df['index']=segtimes_df.index\\n nonsparse_matrix['index']=nonsparse_matrix.index\\n data_to_scale = pd.merge(segtimes_df, nonsparse_matrix, on=['index'])\\n data_scaled = self.scale_matrix(data_to_scale)\\n data_to_cluster = data_scaled.drop(columns = ['segment_id','level_0','date','time'])\\n \\n print('Clustering using nonsparse segment/time matrix and: ' + self.algorithm)\\n clusterer = self.clustering_algorithms[self.algorithm]\\n self.clustering_model = clusterer.fit(data_to_cluster)\\n \\n clusters_df = pd.DataFrame(self.clustering_model.labels_, columns = ['cluster_nonsparse'])\\n clusters_df['segtimekey'] = clusters_df.index\\n segtimes_df['segtimekey'] = segtimes_df.index\\n clusters_df = clusters_df.reset_index(drop=True)\\n self.clusters_df_final = pd.merge(segtimes_df, clusters_df, on=['segtimekey'])\\n self.clusters_df_final['cluster_nonsparse'].value_counts()\\n \\n today = datetime.date.today()\\n filename = self.algorithm + '_nonsparse_cluster_model_' + today.strftime('%Y%m%d') + '.pkl'\\n joblib.dump(self.clustering_model, filename)\\n \\n print('Stored ' + filename)\\n \\n return self.clustering_model, self.clusters_df_final[['segment_id','date','time','cluster_nonsparse']]\",\n \"def prepare_set(N_ITEMS, N_FEATURES, dict_data, sol_cont):\\n\\tX = np.zeros((N_ITEMS, N_FEATURES))\\n\\tfor i in range(N_ITEMS):\\n\\t\\t\\tpositive_syn, negative_syn = countSynergies(str(i), dict_data['polynomial_gains'])\\n\\t\\t\\tX[i, 0] = sol_cont[i]\\n\\t\\t\\tX[i, 1] = dict_data['profits'][i]\\n\\t\\t\\tX[i, 2] = dict_data['costs'][i][0]/dict_data['budget']\\n\\t\\t\\tX[i, 3] = dict_data['costs'][i][1]/dict_data['budget']\\n\\t\\t\\tX[i, 4] = positive_syn\\n\\t\\t\\tX[i, 5] = negative_syn\\n\\treturn X\",\n \"def generate_sparse(n, s):\\n x = np.zeros(n)\\n I = np.random.randint(0, n, s)\\n x[I] = 1\\n return x\",\n \"def _apply_sparse(self, grad, var):\\n return self._apply_sparse_shared(\\n grad.values,\\n var,\\n grad.indices,\\n lambda x, i, v: state_ops.scatter_add( # pylint: disable=g-long-lambda\\n x,\\n i,\\n v,\\n use_locking=self._use_locking))\",\n \"def create_user_item_matrix(data,type='unary'): \\n if type == 'unary':\\n\\n # for unary rating drop duplicates\\n data = data.drop_duplicates()\\n\\n # create sparse matrix\\n matrix = csr_matrix((data['rating'], (data['user_id'],data['product_id'])))\\n\\n # rows and cols with empty values will be dropped (doesnt make any difference in size for sparse matrix, but if later converted to dense, it saves space)\\n # get all non empty rows and cols\\n rows, cols = matrix.nonzero()\\n unique_rows = np.unique(rows)\\n unique_cols = np.unique(cols)\\n\\n # select only rows and cols with values\\n matrix = matrix[unique_rows]\\n matrix = matrix[:,unique_cols]\\n\\n return matrix\\n\\n if type == 'count':\\n\\n # create sparse matrix with counted ratings\\n matrix = csr_matrix((data['rating'], (data['user_id'],data['product_id'])))\\n\\n # rows and cols with empty values will be dropped (doesnt make any difference in size for sparse matrix, but if later converted to dense, it saves space)\\n # get all non empty rows and cols\\n rows, cols = matrix.nonzero()\\n unique_rows = np.unique(rows)\\n unique_cols = np.unique(cols)\\n\\n # select only rows and cols with values\\n matrix = matrix[unique_rows]\\n matrix = matrix[:,unique_cols]\\n\\n '''\\n Im Gegensatz zum Memory Based approach, muss beim Model Based Approach noch das Rating angepasst werden. \\n Das heisst, dass Produkte die viel eingekauft wurden ein höhers Rating erhalten und solche die weniger \\n eingekauft wudren ein tieferes. Gleichzeitig muss das Maximum limitiert werden. Dies wird mittels \\n dem max_count integer in der Funktion bewerkstelligt\\n '''\\n\\n # create diagonal Matrix with 1 divided by maximum values per row. This needs to be done because there is no divide function for csr matrices implemented\\n # source: https://stackoverflow.com/questions/42225269/scipy-sparse-matrix-division\\n diag = diags(1/matrix.max(axis=1).A.ravel())\\n\\n # multipy the matrix with the maximum values to get range from 0-1\\n matrix = diag.dot(matrix)\\n\\n # sort indices; not really needed, just cosmetics\\n matrix.sort_indices()\\n\\n return matrix\",\n \"def reservoir_generator(\\n number_of_reservoirs=None, sparsity_level=None, reservoir_dim=None\\n):\\n reservoir_computing = ReservoirComputing(\\n reservoir_dim=reservoir_dim, sparsity_level=sparsity_level\\n )\\n\\n return [reservoir_computing.create_reservoir() for n in range(number_of_reservoirs)]\",\n \"def test_assign_clusters_sparse(self, new_data, filename):\\n\\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\\n engine = create_engine(sqlalchemy_conn_str)\\n \\n print('creating test sparse matrix...')\\n if self.split_type == 'random':\\n averages_seg = pd.read_sql('SELECT * FROM clust_sparse_avebysegment_random',con=engine)\\n averages_rt = pd.read_sql('SELECT * FROM clust_sparse_avebyrt_random',con=engine)\\n if self.split_type == 'date':\\n averages_seg = pd.read_sql('SELECT * FROM clust_sparse_avebysegment_date',con=engine)\\n averages_rt = pd.read_sql('SELECT * FROM clust_sparse_avebyrt_date',con=engine)\\n\\n averages_seg['exists'] = 1\\n test_data_exists = pd.merge(new_data, averages_seg[['segment_id', 'exists']], on=['segment_id'])\\n test_exists = test_data_exists[test_data_exists['exists']==1]\\n test_notexists = test_data_exists[test_data_exists['exists']!=1] \\n \\n test_matrix_exists = pd.merge(test_exists[['segment_id', 'road_type']], averages_seg, how='left', on=['segment_id'])\\n test_matrix_notexists = pd.merge(test_notexists[['segment_id', 'road_type']], averages_rt, how='left', on=['road_type'])\\n test_matrix = pd.concat([test_matrix_exists, test_matrix_notexists])\\n test_matrix = test_matrix.fillna(0) \\n \\n test_sparse_matrix = test_matrix.drop(columns = ['segment_id', 'road_type', 'exists', 'index', 'roadtypekey', 'segmentskey'])\\n num = list(range(len(list(averages_seg))-4))\\n columns = [str(item) for item in num]\\n test_sparse_matrix = test_sparse_matrix[columns] \\n \\n print('clustering new data...')\\n cluster_model = joblib.load(filename)\\n cluster_predictions = cluster_model.predict(test_sparse_matrix)\\n \\n clusterdf = pd.DataFrame(cluster_predictions,columns = ['cluster_sparse'])\\n clusterdf['index'] = clusterdf.index\\n segmentdf = test_matrix['segment_id'].to_frame()\\n segmentdf['index'] = segmentdf.index\\n test_cluster_df_sparse = pd.merge(clusterdf, segmentdf, on=['index'])\\n test_cluster_df_sparse = test_cluster_df_sparse[['segment_id','cluster_sparse']].groupby(['segment_id','cluster_sparse']).count()\\n \\n return test_cluster_df_sparse.reset_index()\",\n \"def _apply_sparse(self, grad, var):\\n\\n return self._apply_sparse_shared(\\n grad.values,\\n var,\\n grad.indices,\\n lambda x, i, v: state_ops.scatter_add( # pylint: disable=g-long-lambda\\n x,\\n i,\\n v,\\n use_locking=self._use_locking))\",\n \"def build_hybrid_sparse_matrix(run_parameters, normalize_by_sum, construct_by_union):\\n pg_network_df = kn.get_network_df(run_parameters['pg_network_name_full_path'])\\n gg_network_df = kn.get_network_df(run_parameters['gg_network_name_full_path'])\\n\\n pg_network_n1_names, \\\\\\n pg_network_n2_names = kn.extract_network_node_names(pg_network_df)\\n\\n gg_network_n1_names, \\\\\\n gg_network_n2_names = kn.extract_network_node_names(gg_network_df)\\n\\n # limit the gene set to the intersection of networks (gene_gene and prop_gene) and user gene set\\n unique_gene_names = kn.find_unique_node_names(gg_network_n1_names, gg_network_n2_names)\\n\\n if construct_by_union is True:\\n unique_gene_names = kn.find_unique_node_names(unique_gene_names, pg_network_n2_names)\\n else:\\n pg_network_df = kn.update_network_df(pg_network_df, unique_gene_names, 'node_2')\\n\\n unique_gene_names_dict = kn.create_node_names_dict(unique_gene_names)\\n pg_network_n1_names_dict = kn.create_node_names_dict(\\n pg_network_n1_names, len(unique_gene_names))\\n\\n unique_all_node_names = unique_gene_names + pg_network_n1_names\\n # map every gene name to a sequential integer index\\n gg_network_df = kn.map_node_names_to_index(gg_network_df, unique_gene_names_dict, \\\"node_1\\\")\\n gg_network_df = kn.map_node_names_to_index(gg_network_df, unique_gene_names_dict, \\\"node_2\\\")\\n pg_network_df = kn.map_node_names_to_index(pg_network_df, pg_network_n1_names_dict, \\\"node_1\\\")\\n pg_network_df = kn.map_node_names_to_index(pg_network_df, unique_gene_names_dict, \\\"node_2\\\")\\n\\n gg_network_df = kn.symmetrize_df(gg_network_df)\\n pg_network_df = kn.symmetrize_df(pg_network_df)\\n\\n if normalize_by_sum is True:\\n gg_network_df = kn.normalize_network_df_by_sum(gg_network_df, 'wt')\\n pg_network_df = kn.normalize_network_df_by_sum(pg_network_df, 'wt')\\n\\n hybrid_network_df = kn.form_hybrid_network_df([gg_network_df, pg_network_df])\\n\\n # store the network in a csr sparse format\\n network_sparse = kn.convert_network_df_to_sparse(\\n hybrid_network_df, len(unique_all_node_names), len(unique_all_node_names))\\n\\n return network_sparse, unique_gene_names, pg_network_n1_names\",\n \"def compute_pw_sparse_out_of_memory(tr,\\n row_size = 500,\\n pm_processes = 2,\\n pm_pbar = True,\\n max_distance = 50,\\n matrix_name = 'rw_beta',\\n reassemble = True,\\n cleanup = True): \\n dest = secrets.token_hex(6)\\n os.mkdir(dest)\\n print(f\\\"CREATED /{dest}/ FOR HOLDING DISTANCE OUT OF MEMORY\\\")\\n row_chunks = memory._partition(range(tr.clone_df.shape[0]), row_size)\\n\\n smatrix_chunks = [(tr, ind, f\\\"{dest}/{i}.{matrix_name}.npz\\\") for i,ind in enumerate(row_chunks)]\\n csrfragments = parmap.starmap(memory.gen_sparse_rw_on_fragment, \\n smatrix_chunks, \\n matrix_name = matrix_name, \\n max_distance=max_distance, \\n pm_pbar=pm_pbar, \\n pm_processes = pm_processes)\\n if reassemble:\\n csr_full = memory.collapse_csrs([x[2] for x in smatrix_chunks])\\n print(f\\\"RETURNING scipy.sparse csr_matrix w/dims {csr_full.shape}\\\")\\n else: \\n csr_full = None\\n \\n if cleanup: \\n assert os.path.isdir(dest)\\n print(f\\\"CLEANING UP {dest}\\\")\\n shutil.rmtree(dest)\\n \\n \\n return csr_full, smatrix_chunks\",\n \"def localInitialize(self):\\n SVL = self.readFromROM()\\n self._generateQuadsAndPolys(SVL)\\n #print out the setup for each variable.\\n msg = self.printTag+' INTERPOLATION INFO:\\\\n'\\n msg += ' Variable | Distribution | Quadrature | Polynomials\\\\n'\\n for v in self.quadDict:\\n msg += ' '+' | '.join([v,self.distDict[v].type,self.quadDict[v].type,self.polyDict[v].type])+'\\\\n'\\n msg += ' Polynomial Set Degree: '+str(self.maxPolyOrder)+'\\\\n'\\n msg += ' Polynomial Set Type : '+str(SVL.indexSetType)+'\\\\n'\\n self.raiseADebug(msg)\\n\\n self.raiseADebug('Starting index set generation...')\\n self.indexSet = IndexSets.factory.returnInstance(SVL.indexSetType)\\n self.indexSet.initialize(self.features, self.importanceDict, self.maxPolyOrder)\\n if self.indexSet.type=='Custom':\\n self.indexSet.setPoints(SVL.indexSetVals)\\n\\n self.sparseGrid = Quadratures.factory.returnInstance(self.sparseGridType)\\n self.raiseADebug(f'Starting {self.sparseGridType} sparse grid generation...')\\n self.sparseGrid.initialize(self.features, self.indexSet, self.dists, self.quadDict, self.jobHandler)\\n\\n if self.writeOut is not None:\\n msg = self.sparseGrid.__csv__()\\n outFile = open(self.writeOut,'w')\\n outFile.writelines(msg)\\n outFile.close()\\n\\n self.limit=len(self.sparseGrid)\\n self.raiseADebug(f'Size of Sparse Grid: {self.limit}')\\n self.raiseADebug('Finished sampler generation.')\\n\\n self.raiseADebug('indexset:',self.indexSet)\\n for SVL in self.ROM.supervisedContainer:\\n SVL.initialize({'SG': self.sparseGrid,\\n 'dists': self.dists,\\n 'quads': self.quadDict,\\n 'polys': self.polyDict,\\n 'iSet': self.indexSet})\",\n \"def __init__(self, no_vertices=0):\\r\\n self.__neighbours = {}\\r\\n self.__cost = {}\\r\\n for i in range(no_vertices):\\r\\n self.__neighbours[i] = []\",\n \"def dict2sparseMatrix(wDict,std=0,diag=0):\\n data = lil_matrix((len(list(wDict.keys())),len(list(wDict.keys()))))\\n nAreas = len(list(wDict.keys()))\\n for i in wDict:\\n data[i,i] = diag\\n ne = len(wDict[i])+ diag\\n for j in wDict[i]:\\n if std:\\n data[i,j] = 1 / float(ne)\\n else:\\n data[i,j] = 1\\n return data\",\n \"def initialize_dense_cost(height, width):\\n cost = sparse.initialize_dense_cost_cpp(height, width)\\n return cost\",\n \"def __init__(self):\\n super().__init__()\\n self.type = 'SparseGridCollocationSampler'\\n self.printTag = 'SAMPLER '+self.type.upper()\\n self.maxPolyOrder = None #L, the relative maximum polynomial order to use in any dimension\\n self.indexSetType = None #TP, TD, or HC; the type of index set to use\\n self.polyDict = {} #varName-indexed dict of polynomial types\\n self.quadDict = {} #varName-indexed dict of quadrature types\\n self.importanceDict = {} #varName-indexed dict of importance weights\\n self.maxPolyOrder = None #integer, relative maximum polynomial order to be used in any one dimension\\n self.lastOutput = None #pointer to output dataObjects object\\n self.ROM = None #pointer to ROM\\n self.jobHandler = None #pointer to job handler for parallel runs\\n self.doInParallel = True #compute sparse grid in parallel flag, recommended True\\n self.dists = {} #Contains the instance of the distribution to be used. keys are the variable names\\n self.writeOut = None\\n self.indexSet = None\\n self.sparseGrid = None\\n self.features = None\\n self.sparseGridType = None\\n self.addAssemblerObject('ROM', InputData.Quantity.one)\",\n \"def SparseData(Input,Output,Fraction):\\r\\n # Take a fraction of the full data\\r\\n MFull = np.column_stack((Input,Output))\\r\\n np.random.shuffle(MFull)\\r\\n split = int(np.ceil((MFull.shape[0])*Fraction)) \\r\\n # Generate a Sparse Set\\r\\n C = MFull[:split,:np.shape(Input)[1]]\\r\\n V = MFull[:split,np.shape(Input)[1]:]\\r\\n return C,V\",\n \"def calculateGlobalStiffnessMatrix(self):\\n \\n globalRowIndices = []\\n globalColumnIndices=[]\\n globalData = []\\n \\n\\n for ele,triPoints in enumerate(self.triangulation.simplices):\\n eleStiffness = self.calculateElementStiffnessMatrix(ele)\\n\\n #append the entries at the correct position in the global matrix, only if no Boundary\\n #condition is prescribed at this degree of freedom \\n for row in range(3):\\n if self.prescribedValues != [] and triPoints[row] in self.prescribedValues[:,0]:\\n continue\\n else:\\n for column in range(3):\\n globalRowIndices.append(triPoints[row])\\n globalColumnIndices.append(triPoints[column])\\n globalData.append(eleStiffness[row,column])\\n #Dirichlet boundaries at position j are enforced, by adding a row (0,0,..,1,...,0) (j-th entry),\\n #and the value in the right hand side at the position j \\n for v in self.prescribedValues:\\n\\n globalRowIndices.append(v[0])\\n globalColumnIndices.append(v[0])\\n globalData.append(1)\\n\\n #create global matrix in coordinate format and convert it to csc for faster solving\\n self.GlobalStiffness = sparse.coo_matrix((globalData,(globalRowIndices,globalColumnIndices))).tocsc() \\n # print(self.GlobalStiffness.toarray())\",\n \"def __init__(self, n4, L, k, randomize=False, non_k=-1, given_weight_matrix = None):\\n\\n self.n4 = n4\\n self.L = L\\n self.k = k\\n self.weightMatrix = numpy.full((self.n4, self.L), non_k, dtype=numpy.int16)\\n\\n # initializing from the start\\n if given_weight_matrix == None: \\n if randomize == \\\"True\\\":\\n #initialize weight matrix: for each stimulus, pick k neurons that respond randomly\\n for stim in range(self.L):\\n # randomly samples k neurons to respond (out of n4)\\n responds = random.sample(range(n4), k=self.k)\\n # updates the values of those k neurons' responses to stimulus \\n for nrn in responds: \\n self.weightMatrix[nrn][stim] = 1\\n else:\\n start_nrn = 0\\n # the first k neurons respond to first stimulus, and so on\\n for stim in range(self.L):\\n for nrn_offset in range(self.k):\\n self.weightMatrix[start_nrn + nrn_offset][stim] = 1\\n start_nrn += self.k\\n\\n # initializing from previous weight matrix, given as string or as prepared weight matrix\\n else: \\n if type(given_weight_matrix) is str:\\n l4_weight_list = [int(i) for i in given_weight_matrix.split(\\\",\\\")]\\n \\n if len(l4_weight_list) != (self.n4 * self.L):\\n print(\\\"Error! String provided to initialize L4 weight matrix must have length n4 * L.\\\")\\n sys.exit(1)\\n\\n for nrn in range(self.n4):\\n start = nrn * self.L \\n end = start + self.L\\n self.weightMatrix[nrn] = numpy.array(l4_weight_list[start:end])\\n else:\\n if given_weight_matrix.shape != (n4, L):\\n print(\\\"Error! Matrix provided to initialize L4 weight matrix must have shape (n4, L)\\\")\\n sys.exit(1)\\n self.weightMatrix = given_weight_matrix\",\n \"def expand_conn_mat(conn_mat, nr_of_traps):\\n\\n r, c = conn_mat._shape\\n new_indptr = np.hstack((conn_mat.indptr, np.asarray([conn_mat.indptr[-1]] * nr_of_traps)))\\n expanded_mat = csr_matrix((conn_mat.data, conn_mat.indices, new_indptr),\\n shape=(r + nr_of_traps, c + nr_of_traps))\\n\\n return expanded_mat\",\n \"def adjacency(G, nodelist=None, weight=\\\"weight\\\"):\\n\\n if nodelist is None:\\n nodelist = G.nodes()\\n\\n A = nx.to_scipy_sparse_matrix(G, nodelist=nodelist, weight=weight, format=\\\"csr\\\")\\n\\n return A\",\n \"def prepare_graph(\\n self,\\n adjacency,\\n weights,\\n weighted=False,\\n undirected=False,\\n force_dense=True,\\n noselfloop=True,\\n verbose=True,\\n ):\\n\\n # df_adj = pd.read_csv(in_folder + adj_name, index_col=0) # read adjacency file\\n print(\\\"\\\\nAdjacency shape: {0}\\\".format(adjacency.shape), flush=True)\\n\\n # create the graph adding nodes and edges\\n A = self.read_graph(\\n adj=adjacency,\\n weights=weights,\\n weighted=weighted,\\n undirected=undirected,\\n noselfloop=noselfloop,\\n verbose=verbose,\\n )\\n\\n nodes = list(A[0].nodes)\\n print(\\\"\\\\nNumber of nodes =\\\", len(nodes), flush=True)\\n print(\\\"Number of layers =\\\", len(A), flush=True)\\n if verbose:\\n self.print_graph_stat(A)\\n\\n # save the multilayer network in a tensor with all layers\\n if force_dense:\\n B = self.build_B_from_A(A, nodes=nodes)\\n else:\\n B = self.build_sparse_B_from_A(A)\\n\\n return A, B, nodes\",\n \"def construct_4adj_graph(X):\\n s0, s1, s2 = X.shape\\n \\n size_data = s0*s1\\n \\n xGrid, yGrid = np.meshgrid(np.arange(s0), np.arange(s1))\\n totGrid = (xGrid*s1 + yGrid).transpose()\\n \\n horiz_edges = np.sqrt(np.sum((X[1:,:,:] - X[:-1,:,:])**2, axis=-1).flatten())\\n indx_horiz_edges = totGrid[1:,:].flatten()\\n indy_horiz_edges = totGrid[:-1,:].flatten()\\n \\n vert_edges = np.sqrt(np.sum((X[:,1:,:] - X[:,:-1,:])**2, axis=-1).flatten())\\n indx_vert_edges = totGrid[:,1:].flatten()\\n indy_vert_edges = totGrid[:,:-1].flatten()\\n \\n w = np.concatenate((horiz_edges, vert_edges), axis=0) + 1e-6\\n u = np.concatenate((indx_horiz_edges, indx_vert_edges), axis=0)\\n v = np.concatenate((indy_horiz_edges, indy_vert_edges), axis=0)\\n \\n return sp.sparse.csr_matrix((w,(u,v)), shape=(size_data, size_data))\",\n \"def add_sdn_resources(self, slice_urn, nodes):\\n # Cannot use information extracted from the manifest here!\\n # Look into the db-table containing the requested dpids and matches.\\n if slice_urn not in self.__stored:\\n logger.error(\\\"Slice monitoring: unable to find topology \\\" +\\n \\\"info from %s!\\\" % slice_urn)\\n return\\n\\n topology = self.__stored.get(slice_urn)\\n groups, matches = db_sync_manager.get_slice_sdn(slice_urn)\\n link_ids = []\\n # Nodes info\\n logger.debug(\\\"add_sdn_resources Groups(%d)=%s\\\" % (len(groups), groups))\\n logger.debug(\\\"add_sdn_resources Matches=%d\\\" % (len(matches),))\\n\\n for m in matches:\\n logger.debug(\\\"Match=%s\\\" % (m,))\\n self.__update_match_with_groups(m, groups)\\n\\n ## TODO Check db.topology.slice (maybe some information stored?)\\n for dpid in m.get(\\\"dpids\\\"):\\n if MonitoringUtils.check_existing_tag_in_topology(topology, \\\"node\\\", \\\"switch\\\", dpid.get(\\\"component_id\\\")):\\n break\\n logger.debug(\\\"Dpid=%s\\\" % (dpid,))\\n\\n node_ = etree.SubElement(\\n topology, \\\"node\\\", id=dpid.get(\\\"component_id\\\"),\\n type=\\\"switch\\\")\\n\\n for p in dpid.get(\\\"ports\\\"):\\n ifid = dpid.get(\\\"component_id\\\") + \\\"_\\\" + str(p.get(\\\"num\\\"))\\n if_ = etree.SubElement(node_, \\\"interface\\\", id=ifid)\\n\\n etree.SubElement(if_, \\\"port\\\", num=str(p.get(\\\"num\\\")))\\n\\n link_ids.append(\\n self.__create_link_id(dpid.get(\\\"dpid\\\"), p.get(\\\"num\\\")))\\n\\n self.__add_packet_info(node_, m.get(\\\"packet\\\"))\\n\\n logger.info(\\\"add_sdn_resources Link identifiers(%d)=%s\\\" %\\n (len(link_ids), link_ids,))\\n # C-SDN link info\\n for l in link_ids:\\n com_link = db_sync_manager.get_com_link_by_sdnkey(l)\\n if com_link:\\n logger.debug(\\\"COM link=%s\\\" % (com_link,))\\n for eps in com_link.get(\\\"links\\\"):\\n if MonitoringUtils.check_existing_tag_in_topology(topology, \\\"link\\\",\\\\\\n self.MS_LINK_TYPE, [eps.get(\\\"source_id\\\"), eps.get(\\\"dest_id\\\")]):\\n break\\n\\n # Modify link on-the-fly to add the DPID port as needed\\n eps = MonitoringUtilsLinks._set_dpid_port_from_link(\\n com_link.get(\\\"component_id\\\"), eps)\\n\\n eps_src_id, eps_dst_id = self.__get_eps_ids(\\n eps.get(\\\"source_id\\\"), eps.get(\\\"dest_id\\\"))\\n\\n logger.info(\\\"eps_src_id=%s, eps_dst_id=%s\\\" %\\n (eps_src_id, eps_dst_id,))\\n self.__add_link_info(topology, eps_src_id, eps_dst_id, com_link.get(\\\"link_type\\\"))\\n\\n # SDN-SDN link info\\n ext_link_ids = self.__extend_link_ids(link_ids)\\n logger.info(\\\"add_sdn_resources Extended link identifiers(%d)=%s\\\" %\\n (len(ext_link_ids), ext_link_ids,))\\n for l in ext_link_ids:\\n sdn_link = db_sync_manager.get_sdn_link_by_sdnkey(l)\\n if sdn_link:\\n logger.debug(\\\"SDN link=%s\\\" % (sdn_link,))\\n if len(sdn_link.get(\\\"dpids\\\")) == 2 and\\\\\\n len(sdn_link.get(\\\"ports\\\")) == 2:\\n ep1 = self.__create_link_id(\\n sdn_link.get(\\\"dpids\\\")[0].get(\\\"component_id\\\"),\\n sdn_link.get(\\\"ports\\\")[0].get(\\\"port_num\\\"))\\n ep2 = self.__create_link_id(\\n sdn_link.get(\\\"dpids\\\")[1].get(\\\"component_id\\\").\\n sdn_link.get(\\\"ports\\\")[1].get(\\\"port_num\\\"))\\n # Local SDN-SDN links are not inserted under the nested link\\n# if self.__check_ids_same_domain(ep1, ep2):\\n self.__add_link_info(topology, ep1, ep2, self.SDN2SDN_LINK_TYPE)\\n# else:\\n# self.__sdn_links.append(\\n# {'id': sdn_link.get(\\\"component_id\\\"),\\n# 'source': ep1,\\n# 'destination': ep2})\\n else:\\n logger.info(\\\"Slice monitoring: cannot find link that \\\" +\\n \\\"ends with %s\\\" % l)\",\n \"def SSC_test():\\n \\n # generating data\\n\\n D = 40 # Dimension of ambient space\\n k = 4 # Number of subspaces\\n d = 1\\n N = 90 # Number of points in subspaces\\n # Generating N points in d dim. subspaces\\n Xi = [np.random.randn(D, d).dot(np.random.randn(d, N))\\n for _ in range(k)]\\n X = np.concatenate(Xi, axis=1)\\n\\n # Generating the ground-truth for evaluating clustering results\\n lbls = [i * np.ones([1, N]) for i in range(k)]\\n s = np.concatenate(lbls, axis=1)\\n r = 0 # Enter the projection dimension e.g. r = d*n, enter r = 0 to not project\\n Cst = 0 # Enter 1 to use the additional affine constraint sum(c) == 1\\n OptM = 'L1Noise' # OptM can be {'L1Perfect','L1Noise','Lasso','L1ED'}\\n lmbda = 0.001 # Regularization parameter in 'Lasso' or the noise level for 'L1Noise'\\n # Number of top coefficients to build the similarity graph, enter K=0 for using the whole coefficients\\n K = 0 #max(d1, d2)\\n if Cst == 1:\\n K = d + 1 # For affine subspaces, the number of coefficients to pick is dimension + 1\\n\\n Xp = DataProjection(X, r, 'NormalProj')\\n \\n # testing clustering\\n \\n '''\\n # using wrapper function\\n Grps, sc = sparseSubspaceClustering(\\n Xp.T, n, ground_truth=s, affine=Cst, OptM=OptM, lam=lmbda)\\n Grps = BestMap(sc, Grps)\\n Missrate = float(np.sum(sc != Grps)) / sc.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\\n '''\\n \\n '''\\n # calling internal tools\\n CMat = SparseCoefRecovery(Xp, Cst, OptM, lmbda)\\n # Make small values 0\\n eps = np.finfo(float).eps\\n CMat[np.abs(CMat) < eps] = 0\\n\\n CMatC, sc, OutlierIndx, Fail = OutlierDetection(CMat, s)\\n\\n if Fail == False:\\n CKSym = BuildAdjacency(CMatC, K)\\n Grps = SpectralClustering(CKSym, n)\\n Grps = BestMap(sc, Grps)\\n Missrate = float(np.sum(sc != Grps)) / sc.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\\n else:\\n print(\\\"Something failed\\\")\\n '''\\n \\n labels, _, __ = KSubspaces(Xp.T, k, d)\\n labels = BestMap(s, labels)\\n Missrate = float(np.sum(s != labels)) / s.size\\n print(\\\"\\\\n\\\\nMisclassification rate: {:.4f} %\\\\n\\\\n\\\".format(Missrate * 100))\",\n \"def _make_train(data, smooth_factor):\\n train_matrix = data_to_sparse(data).tolil()\\n user_counts = np.array(train_matrix.sum(axis=1))[:, 0]\\n train_matrix[np.where(user_counts == 0)] = smooth_factor\\n train_matrix = normalize(train_matrix, 'l1', axis=1)\\n return train_matrix.tocsr()\",\n \"def to_sparse(self):\\n from divisi2.sparse import SparseMatrix\\n return SparseMatrix(self, self.row_labels, self.col_labels)\",\n \"def convert_sparse_network(weights: Dict[str, np.ndarray],\\n metadata: Dict[str, Any],\\n hypers: Dict[str, Any],\\n is_msp: bool):\\n # List to hold all variables\\n components: List[str] = []\\n\\n # Start the input units at the input shape\\n input_size = metadata[INPUT_SHAPE][-1]\\n\\n for i, output_size in enumerate(hypers['hidden_units']):\\n\\n # Convert the sparse variable\\n layer_name = 'hidden_{0}'.format(i)\\n\\n sparse_layer = convert_sparse_layer(layer_name=layer_name,\\n weights=weights,\\n input_size=input_size,\\n output_size=output_size,\\n coordinates=metadata['sparse_indices'][layer_name],\\n is_msp=is_msp)\\n\\n components.append(sparse_layer)\\n\\n # Reset the input size as we progress\\n input_size = output_size\\n\\n # Include the output layer\\n output_kernel_name = 'output/kernel:0'\\n output_kernel = convert_matrix(name=output_kernel_name,\\n mat=weights[output_kernel_name],\\n precision=PRECISION,\\n width=WIDTH,\\n is_msp=is_msp)\\n components.append(output_kernel)\\n\\n output_bias_name = 'output/bias:0'\\n output_bias = convert_matrix(name=output_bias_name,\\n mat=weights[output_bias_name],\\n precision=PRECISION,\\n width=WIDTH,\\n is_msp=is_msp)\\n components.append(output_bias)\\n\\n return '\\\\n'.join(components)\",\n \"def construct_graph(indices, distances, n):\\n CSR_graph = scipy.sparse.csr_matrix((distances, [indices[:, 0], indices[:, 1]]), shape=(n, n))\\n return CSR_graph\",\n \"def prepare4iCSD(self, index=0):\\n if (\\n self.surveys[index].x0_ini_guess == True\\n or self.surveys[index].x0_prior == True\\n ):\\n self._estimateM0_(index=index)\\n\\n # CONSTRAINSTED INVERSION\\n # -----------------------\\n # Create vector with weight (data weigth, constrainsts weight and regularisation weigth)\\n if self.surveys[index].x0_prior == True: # if relative smallness\\n self.reg_w_0_b, self.reg_w_0_A = regularize_w(\\n self.surveys[index].reg_A,\\n self.wr,\\n self.surveys[index].x0_prior,\\n x0=self.x0,\\n )\\n\\n # stack weight matrix\\n self.W_s_A, self.W_s_b = stack_w(\\n self.surveys[index].obs_w,\\n self.surveys[index].con_w,\\n self.surveys[index].x0_prior,\\n reg_w_0_A=self.reg_w_0_A,\\n reg_w_0_b=self.reg_w_0_b,\\n )\\n\\n # apply weight to A and b (data weigth, constrainsts weight and regularisation weigth)\\n self.A_w = weight_A(\\n self.surveys[index].x0_prior, self.surveys[index].A_s, W_s_A=self.W_s_A\\n )\\n self.b_w = weight_b(\\n self.surveys[index].x0_prior, self.surveys[index].b_s, W_s_b=self.W_s_b\\n )\\n\\n # UNCONSTRAINSTED INVERSION\\n # -------------------------\\n else:\\n self.reg_w = regularize_w(self.surveys[index].reg_A, self.wr, self.x0_prior)\\n\\n self.W_s = stack_w(\\n self.surveys[index].obs_w,\\n self.surveys[index].con_w,\\n self.x0_prior,\\n reg_w=self.reg_w,\\n )\\n self.A_w = weight_A(self.x0_prior, self.surveys[index].A_s, W_s=self.W_s)\\n self.b_w = weight_b(self.x0_prior, self.surveys[index].b_s, W_s=self.W_s)\",\n \"def __initialize_connection_strengths(G):\\n G_prime = G.__deepcopy__() # construct a deepcopy of the graph\\n # for every vertex in the graph, initialize the connection strength to zero\\n for node in G_prime.get_nodeset(): node.add_attribute(StoerWagner.CONNECTION_STRENGTH_ATTRIBUTE, float(0))\\n return G_prime # return the new graph\",\n \"def sparse_matrix (base_type=float):\\n return defaultdict (lambda: sparse_vector (base_type))\",\n \"def build(self):\\n\\n self.W = self.init([self.n_atom_input_feat, self.n_output])\\n self.b = model_ops.zeros(shape=[\\n self.n_output,\\n ])\\n\\n self.trainable_weights = self.W + self.b\",\n \"def gen_W(users, items, ratings):\\n\\n # initiate graph\\n user = users.tolist()\\n item = items.tolist()\\n rating = ratings.tolist()\\n B = nx.Graph()\\n B.add_nodes_from(user, bipartite=0)\\n B.add_nodes_from(item, bipartite=1)\\n\\n # create edges\\n for i in range(len(user)):\\n B.add_edges_from([(user[i], item[i])])\\n B[user[i]][item[i]]['weight'] = rating[i]\\n\\n users_unique = users.unique() \\n items_unique = items.unique()\\n\\n # BiAdjacency matrix - for bipartite network\\n W = biadjacency_matrix(B, users_unique,items_unique).toarray()\\n\\n # sparce form of Biadjacency matrix\\n W = spa.csr_matrix(W)\\n print('Shape of W: '+str(W.shape))\\n\\n return W, users_unique, items_unique\",\n \"def generate_connectivity_constraint(problem, b_list, add_S):\\n\\n # Constructing A_iq and b_iq for inequality (38) for all S in add_S as sp.coo matrix\\n A_iq_row = []\\n A_iq_col = []\\n A_iq_data = []\\n\\n constraint_idx = 0\\n # For each base\\n for b, S_v_t in product(b_list, add_S):\\n pre_S_transition = problem.graph.pre_tran_vt(S_v_t)\\n pre_S_connectivity = problem.graph.pre_conn_vt(S_v_t)\\n for v, t in S_v_t:\\n # add y\\n A_iq_row.append(constraint_idx)\\n A_iq_col.append(problem.get_yb_idx(b, v, t))\\n A_iq_data.append(1)\\n for v0, v1, t0 in pre_S_transition:\\n A_iq_row.append(constraint_idx)\\n A_iq_col.append(problem.get_x_idx(b, v0, v1, t0))\\n A_iq_data.append(-1)\\n for v0, v1, t1 in pre_S_connectivity:\\n A_iq_row.append(constraint_idx)\\n A_iq_col.append(problem.get_xbar_idx(b, v0, v1, t1))\\n A_iq_data.append(-1)\\n constraint_idx += 1\\n A_iq_38 = sp.coo_matrix(\\n (A_iq_data, (A_iq_row, A_iq_col)), shape=(constraint_idx, problem.num_vars)\\n )\\n\\n return Constraint(A_iq=A_iq_38, b_iq=np.zeros(constraint_idx))\",\n \"def _init_vertex_adjacency_matrix(self, verbose=False):\\n self._init_from_cdd_input(self.cdd_Vrepresentation(),\\n '--adjacency', verbose)\",\n \"def test_example_10_sparse():\\n import pandas as pd\\n from tcrdist.repertoire import TCRrep\\n from tcrdist.rep_funcs import pw2dense\\n import numpy as np\\n\\n df = pd.read_csv(\\\"dash.csv\\\")\\n df2 = pd.read_csv(\\\"dash2.csv\\\")\\n df = df.head(10) #(1)\\n tr = TCRrep(cell_df = df, #(2)\\n df2 = df2, \\n organism = 'mouse', \\n chains = ['alpha','beta'], \\n db_file = 'alphabeta_gammadelta_db.tsv')\\n\\n tr.compute_rect_distances(df = tr.clone_df, df2 = df2)\\n assert tr.rw_alpha.shape == (10,1924) \\n assert tr.rw_beta.shape == (10,1924)\\n\\n rw_alpha = tr.rw_alpha.copy()\\n rw_beta = tr.rw_beta.copy()\\n\\n radius = 100\\n tr.cpus = 1\\n tr.compute_sparse_rect_distances(df = tr.clone_df, df2 = df2, radius = radius)\\n d = pw2dense(tr.rw_alpha, radius)\\n print(rw_alpha[:2, :10])\\n print(tr.rw_alpha.todense()[:2, :10])\\n print(d[:2, :10])\\n assert np.all(rw_alpha[rw_alpha <= radius] == d[d <= radius])\\n\\n d = pw2dense(tr.rw_beta, radius)\\n assert np.all(rw_beta[rw_beta <= radius] == d[d <= radius])\\n\\n \\n radius = 5000\\n tr.compute_sparse_rect_distances(df = tr.clone_df, df2 = df2, radius = radius)\\n d = pw2dense(tr.rw_alpha, radius)\\n print(rw_alpha[:2, :10])\\n print(tr.rw_alpha.todense()[:2, :10])\\n assert np.all(rw_alpha == d)\\n\\n d = pw2dense(tr.rw_beta, radius)\\n assert np.all(rw_beta == d)\",\n \"def to_sparse(self):\\n from divisi2.sparse import SparseVector\\n return SparseVector(self, self.labels)\",\n \"def add_c_resources(self, slice_urn, nodes):\\n if slice_urn not in self.__stored:\\n logger.error(\\\"Unable to find Topology info from %s!\\\" % slice_urn)\\n return\\n\\n topology = self.__stored.get(slice_urn)\\n\\n logger.debug(\\\"add_c_resources Nodes=%d\\\" % (len(nodes),))\\n for n in nodes:\\n logger.debug(\\\"Node=%s\\\" % (n,))\\n\\n node_ = etree.SubElement(\\n topology, \\\"node\\\", id=n.get(\\\"component_id\\\"), type=\\\"server\\\")\\n\\n inner_node_ = etree.SubElement(\\n node_, \\\"node\\\", id=n.get(\\\"sliver_id\\\"),\\n type=n.get(\\\"sliver_type_name\\\").lower())\\n\\n # Add the interface identifier of the server node here!\\n # In the future, it will be the vlan-tagged interface of the\\n # virtual machine (much more sense)\\n nodekey = n.get(\\\"component_id\\\").replace(\\\"+node+\\\", \\\":\\\")\\n logger.debug(\\\"Node key=%s\\\" % (nodekey,))\\n interfaces = db_sync_manager.get_com_interface_by_nodekey(nodekey)\\n logger.info(\\\"Stored COM interfaces=%s\\\" % (interfaces,))\\n for i in interfaces:\\n if_index = i.rfind(\\\"interface\\\")\\n if_name = n.get(\\\"sliver_id\\\") + \\\"+\\\" + i[if_index:len(i)]\\n etree.SubElement(inner_node_, \\\"interface\\\", id=if_name)\\n self.__mapping_c_interface[i] = if_name\\n\\n if len(n.get(\\\"services\\\")) > 0:\\n self.__add_snmp_management(\\n inner_node_,\\n n.get(\\\"services\\\")[0].get(\\\"login\\\").get(\\\"hostname\\\"))\",\n \"def __init__(self):\\r\\n self.adjacent = {}\\r\\n self.capacity = {}\\r\\n self.flow = {}\",\n \"def __init__(self,numagents,bits,in_nodes,print_flag=False):\\n self.numagents = numagents\\n self.agent = []\\n self.in_bits = in_nodes\\n\\n \\\"\\\"\\\" initialize empty dict for trajectories\\\"\\\"\\\"\\n self.trajectories={}\\n self.accepted_changes = 0\\n self.learning_rate = numpy.zeros((3,1),dtype=int)\\n\\n \\\"\\\"\\\" initialize network topology \\\"\\\"\\\"\\n self.adjacency = numpy.zeros((numagents,numagents),dtype=int)\\n\\n\\n # Erdös Renyi network; symmetric G(n,p) with p=0.5;\\n # if p > ln(n)/n graph is almost surely connected\\n \\n p0=0.75\\n for ia1 in range(self.numagents):\\n for ia2 in range(ia1+1,self.numagents):\\n if ia1 < 3 and ia2 < 3: self.adjacency[ia1,ia2] = 1 #fully connected in_nodes\\n else:\\n pER = numpy.random.random()\\n if pER <= p0: self.adjacency[ia1,ia2] = 1\\n self.adjacency[ia2,ia1] = self.adjacency[ia1,ia2] #symmetrize\\n\\n\\n\\n \\\"\\\"\\\"#complete graph (dense)\\n for ia1 in range(self.numagents):\\n for ia2 in range(ia1+1,self.numagents):\\n self.adjacency[ia1,ia2] = 1\\n self.adjacency[ia2,ia1] = 1\\n \\\"\\\"\\\"\\n\\n\\n \\\"\\\"\\\"\\n #4-lattice\\n for ia in range(self.numagents):\\n if ia > 1 and ia < self.numagents-2:\\n ia1 = ia + 1\\n ia2 = ia + 2\\n ia3 = ia - 1\\n ia4 = ia - 2\\n\\n elif ia == 0:\\n ia1 = ia + 1\\n ia2 = ia + 2\\n ia3 = self.numagents-1\\n ia4 = self.numagents-2\\n\\n elif ia == 1:\\n ia1 = ia + 1\\n ia2 = ia + 2\\n ia3 = ia - 1\\n ia4 = self.numagents-1\\n\\n elif ia == self.numagents-2:\\n ia1 = ia + 1\\n ia2 = 0\\n ia3 = ia - 1\\n ia4 = ia - 2\\n elif ia == self.numagents-1:\\n ia1 = 0\\n ia2 = 1\\n ia3 = ia- 1\\n ia4 = ia -2\\n\\n self.adjacency[ia,ia1] = 1\\n self.adjacency[ia1,ia] = 1\\n self.adjacency[ia,ia2] = 1\\n self.adjacency[ia2,ia] = 1\\n self.adjacency[ia,ia3] = 1\\n self.adjacency[ia3,ia] = 1\\n self.adjacency[ia, ia4] = 1\\n self.adjacency[ia4, ia] = 1\\n \\\"\\\"\\\"\\n\\n \\n #SF-network, BA(m=1)\\n \\\"\\\"\\\"\\n m=1\\n main_graph = networkx.barabasi_albert_graph(self.numagents, m)\\n self.adjacency = networkx.to_numpy_array(main_graph)\\n \\\"\\\"\\\"\\n\\n # density is number of edges/number of possible edges\\n self.graph_density = numpy.sum(self.adjacency)/(self.numagents*(self.numagents-1) )\\n\\n\\n \\\"\\\"\\\" initialize agents: \\\"\\\"\\\"\\n iagents = range(self.in_bits)\\n majority = True\\n for ia in range(self.numagents):\\n nbh = 3 #ALT: take mean neighborhood from graph; nbh = global_functions.dict_from_adj(self.adjacency)\\n mu1 = numpy.random.randint(1, nbh + 1) # int(thresh)\\n mu2 = numpy.random.randint(mu1, nbh + 1) #\\n if ia in iagents: i = True\\n else: i = False\\n self.agent.append(agent(ia,ia,bits,nbh,i,mu1,mu2,majority=majority)) #initialize with majority rule\\n #print(ia,self.agent[ia].rule)\\n\\n if print_flag:\\n adj_dict = global_functions.dict_from_adj(self.adjacency)\\n numagents = 0\\n for ia in range(len(self.adjacency)):\\n if numpy.sum(self.adjacency[ia]) != 0 or numpy.sum(self.adjacency[:, ia]) != 0: numagents += 1\\n print(\\\"Initialize network with\\\", self.numagents, \\\"agents on a graph with\\\"\\n , len(adj_dict), \\\"edges and density of\\\", numpy.around(self.graph_density,2))\\n print(\\\"Input agents:\\\", iagents)\\n print(\\\"Average degree:\\\", numpy.around(numpy.sum(self.adjacency)/self.numagents,2))\\n\\n if self.numagents <= 12:\\n for l in self.adjacency: print(l)\\n else:\\n for key in adj_dict: print(key,\\\"->\\\",adj_dict[key])\\n\\n print(\\\"Perceptual rule of type:\\\")\\n if majority: print(\\\"majority rule: x -> 1: if sum(input) >= out_degree/2\\\")\\n else:\\n print(\\\"x -> 1: if mu1 <= sum(input) <= mu2\\\")\\n print(\\\"mu1 =\\\",[self.agent[ia].mu1 for ia in range(self.numagents)],\\n \\\"mu2 =\\\",[self.agent[ia].mu2 for ia in range(self.numagents)])\\n #for key in itertools.product({0, 1}, repeat = self.out_bits):\\n # print(key, self.agent[0].update(key))\\n print(\\\"Network successfully initialized\\\")\",\n \"def compute_weights(self):\\n\\n # Init lists\\n weights, weights_k_idx = [], []\\n for i_order in range(self.n_orders): # For each orders\\n\\n weights_n, k_idx_n = self.get_w(i_order) # Compute weights\\n\\n # Convert to sparse matrix\\n # First get the dimension of the convolved grid\\n n_kc = np.diff(self.i_bounds[i_order]).astype(int)[0]\\n\\n # Then convert to sparse\\n weights_n = atoca_utils.sparse_k(weights_n, k_idx_n, n_kc)\\n weights.append(weights_n), weights_k_idx.append(k_idx_n)\\n\\n return weights, weights_k_idx\",\n \"def sample_from_ibp(K, alpha, sigma, c):\\n pp = poissonparams(K, alpha, sigma, c)\\n new_nodes = np.random.poisson(pp)\\n Ncols = new_nodes.sum()\\n node_count = np.zeros(Ncols)\\n\\n # used to build sparse matrix, entries of each Zij=1\\n colidx = [] \\n rowidx = []\\n rightmost_node = 0\\n\\n # for each clique\\n for n in range(K):\\n # revisit each previously seen node\\n for k in range(rightmost_node):\\n prob_repeat = (node_count[k] - sigma) / (n + c)\\n r = np.random.rand()\\n if r < prob_repeat:\\n rowidx.append(n)\\n colidx.append(k)\\n node_count[k] += 1\\n\\n for k in range(rightmost_node, rightmost_node + new_nodes[n]):\\n rowidx.append(n)\\n colidx.append(k)\\n node_count[k] += 1\\n \\n rightmost_node += new_nodes[n]\\n\\n # build sparse matrix\\n data = np.ones(len(rowidx), int)\\n shape = (K, Ncols)\\n Z = csr_matrix((data, (rowidx, colidx)), shape)\\n\\n return Z\",\n \"def constructConnMatrices(nE=4000, nI=1000, n_clusters=50,\\n pEE=.2, pEI=.5, pIE=.5, pII=.5, rEE=1.0,\\n jEE_out=0.024, jEE_in=1.9, jEI=0.014, jIE=-0.045, jII=-0.057): # Need to add synaptic strengths\\n # Structural connectivity (probabilities taken from Litwin-Kumar & Doiron, 2012)\\n if rEE==1:\\n sEE = np.random.binomial(1,pEE,size=(nE,nE))\\n wEE = sEE*jEE_out\\n else:\\n neurons_per_clust = int(nE/float(n_clusters))\\n pEE_out = (pEE*(nE-1))/(rEE*neurons_per_clust + (nE-1) - neurons_per_clust)\\n pEE_in = rEE*pEE_out\\n\\n # First define all pEE_out connections\\n sEE = np.random.binomial(1,pEE_out,size=(nE,nE))\\n wEE = sEE * jEE_out\\n # Now we will re-do clustered connections\\n neuron_count = 0\\n for clust in range(n_clusters):\\n i = int(neuron_count)\\n j = int(neuron_count + neurons_per_clust)\\n sEE[i:j,i:j] = 0\\n sEE[i:j,i:j] = np.random.binomial(1,pEE_in,size=(neurons_per_clust,neurons_per_clust))\\n wEE[i:j,i:j] = sEE[i:j,i:j] * jEE_in\\n neuron_count += neurons_per_clust\\n\\n # No self connections\\n np.fill_diagonal(wEE,0)\\n\\n # Structural matrices\\n sEI = np.random.binomial(1,pEI,size=(nE,nI))\\n sIE = np.random.binomial(1,pIE,size=(nI,nE))\\n sII = np.random.binomial(1,pII,size=(nI,nI))\\n\\n # Synaptic weights\\n wEI = sEI * jEI\\n wIE = sIE * jIE\\n wII = sII * jII\\n\\n # No self connections\\n np.fill_diagonal(wII,0)\\n\\n return wEE, wEI, wIE, wII\",\n \"def _get_sparse_data(self):\\n data = self._normalize_dataset()\\n\\n n_users = data.user_id.unique().shape[0]\\n n_movies = data.movie_id.unique().shape[0]\\n\\n ratings = np.zeros((n_users, n_movies))\\n\\n for row in data.itertuples():\\n ratings[row[1]-1, row[2]-1] = row[3]\\n return ratings\",\n \"def make_sparse(self, fmt='csc', make_method=None):\\n if make_method:\\n self.sparse = make_method(self.hamiltonian)\\n else:\\n self.sparse = self.hamiltonian.to_matrix(sparse=fmt)\",\n \"def OffsetSparseMatrix(SparseMatrix, numberOfVariables, numberOfEquations):\\n\\n class OffsetSparseMatrixClass(SparseMatrix):\\n equationIndex = 0\\n varIndex = 0\\n\\n def __init__(self, mesh, bandwidth=0, sizeHint=None,\\n numberOfVariables=numberOfVariables, numberOfEquations=numberOfEquations):\\n SparseMatrix.__init__(self, mesh=mesh, bandwidth=bandwidth, sizeHint=sizeHint,\\n numberOfVariables=numberOfVariables, numberOfEquations=numberOfEquations)\\n\\n def put(self, vector, id1, id2):\\n SparseMatrix.put(self, vector, id1 + self.mesh.numberOfCells * self.equationIndex, id2 + self.mesh.numberOfCells * self.varIndex)\\n\\n def addAt(self, vector, id1, id2):\\n SparseMatrix.addAt(self, vector, id1 + self.mesh.numberOfCells * self.equationIndex, id2 + self.mesh.numberOfCells * self.varIndex)\\n\\n def addAtDiagonal(self, vector):\\n if type(vector) in [type(1), type(1.)]:\\n tmp = numerix.zeros((self.mesh.numberOfCells,), 'd')\\n tmp[:] = vector\\n SparseMatrix.addAtDiagonal(self, tmp)\\n else:\\n SparseMatrix.addAtDiagonal(self, vector)\\n\\n return OffsetSparseMatrixClass\",\n \"def OffsetSparseMatrix(SparseMatrix, numberOfVariables, numberOfEquations):\\n\\n class OffsetSparseMatrixClass(SparseMatrix):\\n equationIndex = 0\\n varIndex = 0\\n\\n def __init__(self, mesh, bandwidth=0, sizeHint=None,\\n numberOfVariables=numberOfVariables, numberOfEquations=numberOfEquations):\\n SparseMatrix.__init__(self, mesh=mesh, bandwidth=bandwidth, sizeHint=sizeHint,\\n numberOfVariables=numberOfVariables, numberOfEquations=numberOfEquations)\\n\\n def put(self, vector, id1, id2):\\n SparseMatrix.put(self, vector, id1 + self.mesh.numberOfCells * self.equationIndex, id2 + self.mesh.numberOfCells * self.varIndex)\\n\\n def addAt(self, vector, id1, id2):\\n SparseMatrix.addAt(self, vector, id1 + self.mesh.numberOfCells * self.equationIndex, id2 + self.mesh.numberOfCells * self.varIndex)\\n\\n def addAtDiagonal(self, vector):\\n if type(vector) in [type(1), type(1.)]:\\n tmp = numerix.zeros((self.mesh.numberOfCells,), 'd')\\n tmp[:] = vector\\n SparseMatrix.addAtDiagonal(self, tmp)\\n else:\\n SparseMatrix.addAtDiagonal(self, vector)\\n\\n return OffsetSparseMatrixClass\",\n \"def create_sparse_matrix_long(self, matrix_df):\\n\\n time_df_tmp = matrix_df.groupby(['date_idx','time_idx']).count().reset_index()\\n time_df = time_df_tmp[['date_idx','time_idx']]\\n time_df['time_id'] = time_df.index.copy()\\n matrix_df_tid = pd.merge(matrix_df, time_df, how='left', on=['date_idx','time_idx'])\\n\\n time_array = np.array(matrix_df_tid['time_id'])\\n segment_array = np.array(matrix_df_tid['segment_id'])\\n\\n uniquesegments = np.array(list(set(segment_array)))\\n keyuniquesegments = np.array(range(len(uniquesegments)))\\n uniquesegments_df = pd.DataFrame({'segmentskey':keyuniquesegments, 'segment_id':uniquesegments})\\n\\n segments_df = pd.DataFrame(segment_array, columns = ['segment_id'])\\n segments_keys_df = pd.merge(segments_df, uniquesegments_df, how='left', on=['segment_id'])\\n segmentkeys = np.array(segments_keys_df['segmentskey'])\\n\\n level_array = np.array(matrix_df_tid[self.args['cluster_variable']])\\n sparse_matrix = csr_matrix((level_array, (segmentkeys,time_array))).toarray()\\n sparse_matrix = preprocessing.scale(sparse_matrix)\\n \\n if self.args['perform_pca']:\\n data_to_cluster, self.pca_model = self.run_PCA_long(sparse_matrix)\\n else:\\n data_to_cluster = sparse_matrix\\n\\n sparse_matrix_withsegkey = pd.DataFrame(data_to_cluster)\\n sparse_matrix_withsegkey['segmentskey'] = sparse_matrix_withsegkey.index\\n sparse_matrix_withseg = pd.merge(uniquesegments_df, sparse_matrix_withsegkey, on=['segmentskey'])\\n \\n print('writing sparse matrix_long to db...')\\n sqlalchemy_conn_str = open('../conf/sqlalchemy_conn_str.txt', 'r').read()\\n engine = create_engine(sqlalchemy_conn_str)\\n if self.split_type == 'random':\\n sparse_matrix_withseg.to_sql(name='clust_sparse_long_avebysegment_random', con=engine, if_exists='replace')\\n elif self.split_type == 'date':\\n sparse_matrix_withseg.to_sql(name='clust_sparse_long_avebysegment_date', con=engine, if_exists='replace')\\n \\n print('returning train sparse_long matrix...')\\n return (uniquesegments_df, data_to_cluster)\",\n \"def allocate(self, models, edges, nrnodes, totalActivities):\\n # Return something of the form: {0: 0, 1: 0, 2: 0, 3: 1}\\n # To allocate model_ids 0, 1 and 2 to node 0 and model_id 3 to node 1\\n return {0: 0, 1: 0, 2: 0, 3: 1}\",\n \"def metis(W, levels, rid=None):\\n # Function written by M. Defferrard, taken verbatim, from \\n # https://github.com/mdeff/cnn_graph/blob/master/lib/coarsening.py#L34\\n\\n N, N = W.shape\\n if rid is None:\\n rid = np.random.permutation(range(N))\\n parents = []\\n degree = W.sum(axis=0) - W.diagonal()\\n graphs = []\\n graphs.append(W)\\n #supernode_size = np.ones(N)\\n #nd_sz = [supernode_size]\\n #count = 0\\n\\n #while N > maxsize:\\n for _ in range(levels):\\n\\n #count += 1\\n\\n # CHOOSE THE WEIGHTS FOR THE PAIRING\\n # weights = ones(N,1) # metis weights\\n weights = degree # graclus weights\\n # weights = supernode_size # other possibility\\n weights = np.array(weights).squeeze()\\n\\n # PAIR THE VERTICES AND CONSTRUCT THE ROOT VECTOR\\n idx_row, idx_col, val = scipy.sparse.find(W)\\n perm = np.argsort(idx_row)\\n rr = idx_row[perm]\\n cc = idx_col[perm]\\n vv = val[perm]\\n cluster_id = metis_one_level(rr,cc,vv,rid,weights) # rr is ordered\\n parents.append(cluster_id)\\n\\n # TO DO\\n # COMPUTE THE SIZE OF THE SUPERNODES AND THEIR DEGREE \\n #supernode_size = full( sparse(cluster_id, ones(N,1) ,\\n #\\tsupernode_size ) )\\n #print(cluster_id)\\n #print(supernode_size)\\n #nd_sz{count+1}=supernode_size;\\n\\n # COMPUTE THE EDGES WEIGHTS FOR THE NEW GRAPH\\n nrr = cluster_id[rr]\\n ncc = cluster_id[cc]\\n nvv = vv\\n Nnew = cluster_id.max() + 1\\n # CSR is more appropriate: row,val pairs appear multiple times\\n W = scipy.sparse.csr_matrix((nvv,(nrr,ncc)), shape=(Nnew,Nnew))\\n W.eliminate_zeros()\\n # Add new graph to the list of all coarsened graphs\\n graphs.append(W)\\n N, N = W.shape\\n\\n # COMPUTE THE DEGREE (OMIT OR NOT SELF LOOPS)\\n degree = W.sum(axis=0)\\n #degree = W.sum(axis=0) - W.diagonal()\\n\\n # CHOOSE THE ORDER IN WHICH VERTICES WILL BE VISTED AT THE NEXT PASS\\n #[~, rid]=sort(ss); # arthur strategy\\n #[~, rid]=sort(supernode_size); # thomas strategy\\n #rid=randperm(N); # metis/graclus strategy\\n ss = np.array(W.sum(axis=0)).squeeze()\\n rid = np.argsort(ss)\\n\\n return graphs, parents\",\n \"def create_weight_matrices(self):\\n rad = 1 / np.sqrt(self.no_of_in_nodes)\\n X = truncated_normal(mean=0, \\n sd=1, \\n low=-rad, \\n upp=rad)\\n self.wih = X.rvs((self.no_of_hidden_nodes, \\n self.no_of_in_nodes))\\n rad = 1 / np.sqrt(self.no_of_hidden_nodes)\\n X = truncated_normal(mean=0, sd=1, low=-rad, upp=rad)\\n self.who = X.rvs((self.no_of_out_nodes, \\n self.no_of_hidden_nodes))\",\n \"def compute_sparse_masks(cls):\\n with torch.no_grad():\\n for module_name, module, p_name, p, mask, pruned in cls.__sparse_parameters:\\n if mask.sum() < mask.numel(): # when recalculating masks\\n # restore dense parameter if allow_recompute_mask is enabled\\n assert (pruned is not None), \\\"Unable to restore dense parameter because allow_recompute_mask == False\\\"\\n p.add_(pruned.cuda())\\n\\n mask.set_(cls.__calculate_mask(p))\\n\\n if pruned is not None: # stow away pruned weights to cpu\\n pruned.set_((p * (~mask)).cpu())\\n\\n p.mul_(mask) # in-place multiplication, so pruned weights are 0-values, hence checkpoint will have 0s for pruned weights\\n if cls.__verbosity >= 2:\\n print(\\\"[ASP] Enabled %.2f%% sparsity for %s::%s of size=%s and type=%s\\\" % (100.0*mask.sum()/mask.numel(), module_name, p_name, str(p.size()), str(p.dtype)))\",\n \"def next_sparse(sparse_number):\\n\\n # print(\\\"sparse_number 0b{0:b}\\\".format(sparse_number))\\n\\n # Edge case. Handle explicitly for clarity\\n if sparse_number == 0:\\n return 1\\n\\n power_max = twos_power_max(sparse_number)\\n\\n for power in range(0, power_max):\\n # print(\\\"power\\\", power)\\n if is_zero_bit_and_no_neighbor_ones(sparse_number, power):\\n # print(\\\"at middle of 000 change to 010\\\")\\n return sparse_number + (2 ** power)\\n if is_right_end_of_001(sparse_number, power):\\n # print(\\\"at right of 001 change to 01 followed by all zeros\\\")\\n sparse_zeroed_low_bits = (sparse_number >> (power + 1)) * (2 ** (power + 1))\\n # print(\\\"sparse_zeroed_low_bits {0:b}\\\".format(sparse_zeroed_low_bits))\\n return sparse_zeroed_low_bits + (2 ** (power + 1))\\n\\n return (2 ** (power_max + 1))\",\n \"def test_build_classification_matrix_sparse():\\n import scnym\\n\\n # generate a sparse matrix with ~10% of elements filled\\n B = np.zeros((100, 10))\\n ridx = np.random.choice(B.size, size=100, replace=True)\\n B.flat[ridx] = 1\\n B = sparse.csr_matrix(B)\\n\\n # create dummy gene names where the order of\\n # genes in `B` is permuted\\n A_genes = np.arange(10)\\n B_genes = np.random.permutation(A_genes)\\n\\n # build the classification matrix\\n X = scnym.utils.build_classification_matrix(\\n X=B,\\n model_genes=A_genes,\\n sample_genes=B_genes,\\n )\\n assert sparse.issparse(X)\\n\\n # X should have the genes of B in the order of A\\n for i, g in enumerate(A_genes):\\n j = int(np.where(B_genes == g)[0])\\n assert np.all(X[:, i].toarray() == B[:, j].toarray())\\n return\",\n \"def get_weight_from_minflow(self):\\n start_nodes = []\\n end_nodes = []\\n capacities = []\\n unit_costs = []\\n A = 0\\n s_prime = self.sink() + 1\\n t_prime = self.sink() + 2\\n x = self.sink() + 3\\n # for every edge in the graph, add edge to mincost flow instance with\\n # infinite capacity and cost 1\\n # also add backwards edge\\n for arc in self.arc_info.keys():\\n # forward edge\\n start_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"start\\\"],\\n self.arc_info[arc][\\\"destin\\\"]))\\n # backward edge\\n start_nodes.append(self.arc_info[arc][\\\"destin\\\"])\\n end_nodes.append(self.arc_info[arc][\\\"start\\\"])\\n capacities.append(int(self.arc_info[arc][\\\"weight\\\"])) # no negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.arc_info[arc][\\\"destin\\\"],\\n self.arc_info[arc][\\\"start\\\"]))\\n # add (x,s) and (t,x) edges with same cap, cost as above\\n in_weight_x = 0\\n for in_arc in self.in_arcs_lists[self.sink()]:\\n in_weight_x += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight_x = 0\\n for out_arc in self.out_arcs_lists[self.source()]:\\n out_weight_x += self.arc_info[out_arc][\\\"weight\\\"]\\n # (x,s)\\n start_nodes.append(x)\\n end_nodes.append(self.source())\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.source()))\\n # backward\\n start_nodes.append(self.source())\\n end_nodes.append(x)\\n capacities.append(int(out_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.source(),\\n x))\\n # (t,x)\\n start_nodes.append(self.sink())\\n end_nodes.append(x)\\n capacities.append(100000) # capacity of 100,000 instead of inf\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n self.sink(),\\n x))\\n # backward\\n start_nodes.append(x)\\n end_nodes.append(self.sink())\\n capacities.append(int(in_weight_x)) # don't go negative\\n unit_costs.append(1)\\n print(\\\"Adding arc ({}, {}) with unit cost and cap inf\\\".format(\\n x,\\n self.sink()))\\n # for all verts, if a-exc < 0, add edge (s', v) with capacity -a-exc(v)\\n # and cost 0, and if a-exc > 0, add edge (v, t') with capacity a-exc(v)\\n # and cost 0.\\n for v in self:\\n # process internal verts only, since we assume source and sink have\\n # no in and out edges respectively\\n if v != self.source() and v != self.sink():\\n # compute a-exc(v)\\n in_weight = 0\\n for in_arc in self.in_arcs_lists[v]:\\n in_weight += self.arc_info[in_arc][\\\"weight\\\"]\\n out_weight = 0\\n for out_arc in self.out_arcs_lists[v]:\\n out_weight += self.arc_info[out_arc][\\\"weight\\\"]\\n a_exc = out_weight - in_weight\\n if a_exc < 0:\\n # add edge (s', v)\\n start_nodes.append(s_prime)\\n end_nodes.append(v)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n v,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (v, t')\\n start_nodes.append(v)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n v,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # process x node\\n a_exc = out_weight_x - in_weight_x\\n if a_exc < 0:\\n # add edge (s', x)\\n start_nodes.append(s_prime)\\n end_nodes.append(x)\\n capacities.append(int(-a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n s_prime,\\n x,\\n int(-a_exc)))\\n if a_exc > 0:\\n # add edge (x, t')\\n start_nodes.append(x)\\n end_nodes.append(t_prime)\\n capacities.append(int(a_exc))\\n unit_costs.append(0)\\n print(\\\"Adding arc ({}, {}) with cost 0 and cap {}\\\".format(\\n x,\\n t_prime,\\n int(a_exc)))\\n # update A\\n A += a_exc\\n # we must send flow of A from s_prime to t_prime\\n supplies = [0]*(len(self) + 3)\\n supplies[s_prime] = int(A)\\n supplies[t_prime] = int(-A)\\n # Instantiate a SimpleMinCostFlow solver.\\n min_cost_flow = pywrapgraph.SimpleMinCostFlow()\\n # Add each arc.\\n for i in range(len(start_nodes)):\\n min_cost_flow.AddArcWithCapacityAndUnitCost(start_nodes[i],\\n end_nodes[i], capacities[i], unit_costs[i])\\n # Add node supplies\\n for i in range(0, len(supplies)):\\n min_cost_flow.SetNodeSupply(i, supplies[i])\\n # Find the minimum cost flow between node s' and t'.\\n if min_cost_flow.Solve() == min_cost_flow.OPTIMAL:\\n print('Minimum cost:', min_cost_flow.OptimalCost())\\n print('')\\n print(' Arc Flow / Capacity Cost')\\n for i in range(min_cost_flow.NumArcs()):\\n cost = min_cost_flow.Flow(i)*min_cost_flow.UnitCost(i)\\n print('%1s -> %1s %3s / %3s %3s' % (\\n min_cost_flow.Tail(i),\\n min_cost_flow.Head(i),\\n min_cost_flow.Flow(i),\\n min_cost_flow.Capacity(i),\\n cost))\\n # update arcs\\n start = min_cost_flow.Tail(i)\\n destin = min_cost_flow.Head(i)\\n if start != s_prime and \\\\\\n start != t_prime and \\\\\\n start != x and \\\\\\n destin != s_prime and \\\\\\n destin != t_prime and \\\\\\n destin != x:\\n # if forward, increase flow. otherwise decrease.\\n print(\\\"Processing edge ({}, {})\\\".format(start, destin))\\n if start < destin:\\n sup_flow = min_cost_flow.Flow(i)\\n else:\\n sup_flow = -min_cost_flow.Flow(i)\\n temp_start = start\\n start = destin\\n destin = temp_start\\n print(\\\"Has become ({}, {}) with sup {}\\\".format(start,\\n destin,\\n sup_flow))\\n arc = self.get_arc(start, destin)\\n if (sup_flow != 0) or (\\\"lower_bound\\\" not in \\\\\\n self.arc_info[arc].keys()):\\n print(\\\"We should add this\\\")\\n old_flow = self.arc_info[arc][\\\"weight\\\"]\\n new_flow = old_flow + sup_flow\\n self.arc_info[arc][\\\"weight\\\"] = int(new_flow)\\n print(\\\"Edge ({},{}) weight is changed from {} to {}\\\".format(\\n start,\\n destin,\\n old_flow,\\n new_flow))\\n else:\\n print('There was an issue with the min cost flow input.')\\n #self.check_conservation_of_flow() # check that solution is valid\",\n \"def make_ws_graph(num_nodes, clockwise_neighbours, rewiring_prob):\\r\\n #initialize empty graph\\r\\n ws_graph = {}\\r\\n for vertex in range(num_nodes): ws_graph[vertex] = []\\r\\n #add each vertex to clockwise neighbours\\r\\n for vertex in range(num_nodes):\\r\\n for neighbour in range(vertex + 1, vertex + clockwise_neighbours + 1):\\r\\n neighbour = neighbour % num_nodes\\r\\n ws_graph[vertex] += [neighbour]\\r\\n ws_graph[neighbour] += [vertex]\\r\\n for vertex in range(num_nodes):\\r\\n for neighbour in ws_graph[vertex]:\\r\\n if random.random() < rewiring_prob:\\r\\n ws_graph[vertex].remove(neighbour)\\r\\n ws_graph[neighbour].remove(vertex)\\r\\n randNode = random.randint(0, num_nodes-1)\\r\\n while(vertex == randNode):\\r\\n randNode = random.randint(0, num_nodes - 1)\\r\\n ws_graph[vertex] += [randNode]\\r\\n ws_graph[randNode] += [vertex]\\r\\n\\r\\n\\r\\n return ws_graph\\r\\n #rewire each edge with probability rewiring_prob\\r\\n\\r\\n #consider each vertex\\r\\n\\r\\n #consider each neighbour\\r\\n\\r\\n #decide whether to rewire and join to a random node\\r\\n\\r\\n #update if necessary\\r\",\n \"def make_demand_tensor(city):\\n # remove file\\n # filter_station(city)\\n\\n\\n # calculate each time unit for each city, and get a average count map\\n # 0. get station number map {station: [num1, num2, num3]}(num3 == num1 + num2)\\n # 1. get all record into a map {time unit: {station: [amount1, count1, amount2, count2, amount3, count3]}}\\n # 2. combine two maps, then change into {time unit: {station: [emp1, num1, r1, emp2, num2, r2, emp3, num3, r3]}}\\n number_map = {}\\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as f:\\n reader = csv.reader(f)\\n for line in reader:\\n if line[0] not in number_map:\\n number_map[line[0]] = [line[2],line[5],line[8]]\\n if len(number_map) == station_count[city]:\\n break\\n\\n count_map = {}\\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\\n time_unit = file[8:12]\\n if time_unit not in count_map:\\n count_map[time_unit] = {}\\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as f:\\n reader = csv.reader(f)\\n for line in reader:\\n if len(line) < 10:\\n continue\\n station_id = line[0]\\n amount1, amount2, amount3 = float(line[3]), float(line[6]), float(line[9])\\n if station_id not in count_map[time_unit]:\\n count_map[time_unit][station_id] = [0, 0, 0, 0, 0, 0]\\n count_map[time_unit][station_id][0] += amount1\\n count_map[time_unit][station_id][2] += amount2\\n count_map[time_unit][station_id][4] += amount3\\n count_map[time_unit][station_id][1] += 1\\n count_map[time_unit][station_id][3] += 1\\n count_map[time_unit][station_id][5] += 1\\n\\n average_map = {}\\n for time_unit, station_map in count_map.items():\\n average_map[time_unit] = {}\\n for station_id, info in station_map.items():\\n rate1 = count_map[time_unit][station_id][0] / count_map[time_unit][station_id][1]\\n rate2 = count_map[time_unit][station_id][2] / count_map[time_unit][station_id][3]\\n rate3 = count_map[time_unit][station_id][4] / count_map[time_unit][station_id][5]\\n count1 = int(number_map[station_id][0])\\n count2 = int(number_map[station_id][1])\\n count3 = int(number_map[station_id][2])\\n emp1, emp2, emp3 = math.ceil(rate1 * count1), math.ceil(rate2 * count2), math.ceil(rate3 * count3)\\n average_map[time_unit][station_id] = [station_id, emp1, count1, rate1, emp2, count2, rate2, emp3, count3, rate3]\\n\\n\\n # fill the missing record according to the above map\\n num = 0\\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as f:\\n count = len(f.readlines())\\n if count == station_count[city]:\\n continue\\n num += 1\\n print('fill for', file)\\n print('before', count)\\n\\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as f:\\n reader = csv.reader(f)\\n a = [int(line[0]) for line in reader]\\n\\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file, \\\"a\\\") as f:\\n writer = csv.writer(f)\\n diff_set = set(range(0, station_count[city])) - set(a)\\n time_unit = file[8:12]\\n for station_id in sorted(diff_set):\\n writer.writerow(average_map[time_unit][str(station_id)])\\n\\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file, \\\"r\\\") as f:\\n print('after', len(f.readlines()))\\n print('fill', num, 'files')\\n\\n\\n # change csv file into npy file\\n time_index_map = np.load(exp_data_path + os.sep + 'station_list' + os.sep + 'time_index.npy', allow_pickle=True)\\n time_index_map = dict(time_index_map.tolist())\\n\\n numpy_all_data = np.empty((station_count[city], len(time_index_map['index']), 6))\\n numpy_data = np.empty((station_count[city], len(time_index_map['index']), 3))\\n for file in os.listdir(exp_data_path + os.sep + 'station' + os.sep + city):\\n time_index = int(time_index_map['rev_index'][file[0:12]])\\n with open(exp_data_path + os.sep + 'station' + os.sep + city + os.sep + file) as f:\\n reader = csv.reader(f)\\n for line in reader:\\n station_id = int(line[0])\\n try:\\n # 交流(慢充)，直流（慢充），总数\\n count1, count2, count3 = int(line[2]), int(line[5]), int(line[8])\\n # 慢充需求，快充需求，总需求\\n rate1, rate2, rate3 = float(line[3]), float(line[6]), float(line[9])\\n except:\\n print(file, line)\\n break\\n numpy_data[station_id, time_index] = [rate1, rate2, rate3]\\n numpy_all_data[station_id, time_index] = [count1, rate1, count2, rate2, count3, rate3]\\n\\n data_file_name = exp_data_path + os.sep + 'station' + os.sep + 'demand_{}'.format(city)\\n if os.path.exists(data_file_name):\\n os.remove(data_file_name)\\n np.save(data_file_name, numpy_data)\\n print(numpy_data.shape)\\n print(numpy_all_data.shape)\\n\\n all_data_file_name = exp_data_path + os.sep + 'station' + os.sep + 'all_demand_{}'.format(city)\\n if os.path.exists(all_data_file_name):\\n os.remove(all_data_file_name)\\n np.save(all_data_file_name, numpy_all_data)\\n pass\",\n \"def copy(self):\\n return SparseN(self)\",\n \"def formAdjacencyMatrix(self):\\n self.adjacencyMatrix = dict()\\n for i in self.node:\\n self.adjacencyMatrix[i] = dict()\\n for j in self.node:\\n self.adjacencyMatrix[i][j] = 0\\n \\n for ij in self.link:\\n self.adjacencyMatrix[self.link[ij].tail][self.link[ij].head] = 1\",\n \"def _update_attributes(self,circuit_graph,name,lib_name,lib_graph, Gsub):\\n #PnR can route primitive power but not subckt power\\n if lib_name in self.all_lef:\\n pg = []\\n else:\\n pg = self.pg\\n G1 = circuit_graph\\n num = len([key for key in Gsub\\n if 'net' not in G1.nodes[key][\\\"inst_type\\\"]])\\n # Define ports for subblock\\n matched_ports = {}\\n ports_weight = {}\\n G2 = lib_graph.copy()\\n for g1_n, g2_n in Gsub.items():\\n if 'net' in G2.nodes[g2_n][\\\"inst_type\\\"]:\\n if 'external' in G2.nodes[g2_n][\\\"net_type\\\"]:\\n if num > 1 and g1_n in pg:\\n # remove power connections\\n G2=nx.relabel_nodes(G2,{g2_n:g1_n},copy=False)\\n else:\\n matched_ports[g2_n] = g1_n\\n ports_weight[g2_n] = []\\n for nbr in list(G2.neighbors(g2_n)):\\n ports_weight[g2_n].append(G2.get_edge_data(g2_n, nbr)['weight'])\\n else:\\n G2.nodes[g2_n]['values'] = G1.nodes[g1_n]['values']\\n G2.nodes[g2_n]['real_inst_type'] = G1.nodes[g1_n]['real_inst_type']\\n return matched_ports,ports_weight,G2\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6089268","0.6017336","0.5878965","0.5767021","0.56920177","0.55312884","0.54914916","0.5485382","0.5406257","0.5383976","0.53821015","0.5346184","0.5324348","0.5309101","0.5281269","0.5279852","0.5268382","0.5256985","0.5256985","0.52415115","0.5205314","0.5180603","0.51800793","0.5158689","0.51560986","0.51519746","0.5139873","0.5114334","0.5109219","0.5101371","0.5095056","0.50845665","0.5073414","0.50601923","0.5031194","0.5019997","0.5011938","0.5008719","0.50060993","0.5004229","0.49945295","0.49904916","0.49890167","0.49740097","0.4967596","0.49661082","0.49657622","0.49629325","0.49475566","0.4946123","0.49398163","0.4938625","0.49302322","0.49214125","0.4918444","0.48945785","0.48866135","0.48865244","0.4876653","0.4869008","0.48542306","0.484931","0.48441127","0.48440397","0.48382932","0.483603","0.48355055","0.4830835","0.48297942","0.4829249","0.48144597","0.48100322","0.480354","0.47909284","0.47808686","0.47762913","0.47656178","0.4762483","0.47615567","0.47610658","0.47564006","0.4754668","0.4748714","0.47485465","0.47402716","0.47375852","0.47375852","0.47364792","0.47361705","0.47318572","0.47295886","0.4729432","0.47238168","0.4723255","0.47228396","0.47190556","0.47114772","0.47096896","0.47077268","0.47058728"],"string":"[\n \"0.6089268\",\n \"0.6017336\",\n \"0.5878965\",\n \"0.5767021\",\n \"0.56920177\",\n \"0.55312884\",\n \"0.54914916\",\n \"0.5485382\",\n \"0.5406257\",\n \"0.5383976\",\n \"0.53821015\",\n \"0.5346184\",\n \"0.5324348\",\n \"0.5309101\",\n \"0.5281269\",\n \"0.5279852\",\n \"0.5268382\",\n \"0.5256985\",\n \"0.5256985\",\n \"0.52415115\",\n \"0.5205314\",\n \"0.5180603\",\n \"0.51800793\",\n \"0.5158689\",\n \"0.51560986\",\n \"0.51519746\",\n \"0.5139873\",\n \"0.5114334\",\n \"0.5109219\",\n \"0.5101371\",\n \"0.5095056\",\n \"0.50845665\",\n \"0.5073414\",\n \"0.50601923\",\n \"0.5031194\",\n \"0.5019997\",\n \"0.5011938\",\n \"0.5008719\",\n \"0.50060993\",\n \"0.5004229\",\n \"0.49945295\",\n \"0.49904916\",\n \"0.49890167\",\n \"0.49740097\",\n \"0.4967596\",\n \"0.49661082\",\n \"0.49657622\",\n \"0.49629325\",\n \"0.49475566\",\n \"0.4946123\",\n \"0.49398163\",\n \"0.4938625\",\n \"0.49302322\",\n \"0.49214125\",\n \"0.4918444\",\n \"0.48945785\",\n \"0.48866135\",\n \"0.48865244\",\n \"0.4876653\",\n \"0.4869008\",\n \"0.48542306\",\n \"0.484931\",\n \"0.48441127\",\n \"0.48440397\",\n \"0.48382932\",\n \"0.483603\",\n \"0.48355055\",\n \"0.4830835\",\n \"0.48297942\",\n \"0.4829249\",\n \"0.48144597\",\n \"0.48100322\",\n \"0.480354\",\n \"0.47909284\",\n \"0.47808686\",\n \"0.47762913\",\n \"0.47656178\",\n \"0.4762483\",\n \"0.47615567\",\n \"0.47610658\",\n \"0.47564006\",\n \"0.4754668\",\n \"0.4748714\",\n \"0.47485465\",\n \"0.47402716\",\n \"0.47375852\",\n \"0.47375852\",\n \"0.47364792\",\n \"0.47361705\",\n \"0.47318572\",\n \"0.47295886\",\n \"0.4729432\",\n \"0.47238168\",\n \"0.4723255\",\n \"0.47228396\",\n \"0.47190556\",\n \"0.47114772\",\n \"0.47096896\",\n \"0.47077268\",\n \"0.47058728\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.56783235"},"document_rank":{"kind":"string","value":"5"}}},{"rowIdx":80895,"cells":{"query":{"kind":"string","value":"This function is for use by EchoStateNetwork to access different sets of reservoir matrices. Given a connectivity threshold we access a reservoir by approximate sparcity / connectivity. But which randomly generated reservoir we select is determined by the index, which is what ESN uses if the one reservoir is nilpotent."},"document":{"kind":"string","value":"def get_approx_preRes(self, connectivity_threshold, index = 0):\n if self.flip_the_script:\n index = np.random.randint(len(self.book_indices))\n #print(\"index\", index, \"book indices\", self.book_indices, \"self.library\", self.library)\n book = self.library[self.book_indices[index]]\n if index != 0:\n printc(\"retrieving book from library\" + str(self.book_indices[index]), 'green')\n return book.get_approx_preRes(connectivity_threshold)"},"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 test(indices_to_visit = None):\n ##0 Chicago\n ##1 New York City\n ##2 Los Angeles\n ##3 Minneapolis\n ##4 Denver\n ##5 Dallas\n ##6 Seattle\n ##7 Boston\n ##8 San Francisco\n ##9 St. Louis\n ##10 Houston\n ##11 Phoenix\n ##12 Salt Lake City\n ##13 Miami\n ##14 Atlanta\n ##15 Kansas City\n home_index = 15 # Kansas city\n # 15x15 matrix with main diagonal consisting of 0s and to which data is mirrored along\n # (values are derived from external resource and multiplied by 1000 for higher accuracy)\n matrix = np.array([[0.0, 1148413.3550047704, 2813453.6297408855, 572861.4368351421, 1483440.7452179305, 1296355.2188721865, 2801269.1215845253, 1370943.3069385102, 2996683.256068982, 422589.4697157836, 1515737.0196676727, 2343639.7107855356, 2031500.319603397, 1913900.3015914203, 946854.1020487415, 665894.0336505901],\n [1148413.3550047704, 0.0, 3949451.153672887, 1642119.4792808082, 2628946.6435325537, 2212019.1209020815, 3882177.952930788, 306997.0343229422, 4144977.810718553, 1408454.3261387087, 2286054.8575902223, 3455343.3108375454, 3179102.5335818897, 1754834.3710577146, 1202616.154562711, 1766599.1336905772],\n [2813453.6297408855, 3949451.153672887, 0.0, 2455296.3791196346, 1339227.410707824, 1998182.1420783552, 1545364.434045008, 4184394.186016967, 559978.4273194656, 2560790.9591738936, 2212581.51715849, 575975.8749662543, 933602.6426595236, 3767490.41517038, 3120118.850020503, 2186473.1552241463],\n [572861.4368351421, 1642119.4792808082, 2455296.3791196346, 0.0, 1127312.7583590776, 1390159.7734006236, 2249169.1308160927, 1811513.5290266906, 2554165.8167895717, 750916.7305340832, 1701189.1538312144, 2062079.2399570548, 1590460.9488364782, 2434801.332310659, 1462408.5353501518, 662752.1291133759],\n [1483440.7452179305, 2628946.6435325537, 1339227.410707824, 1127312.7583590776, 0.0, 1067257.7993323756, 1646308.7967673023, 2852307.4164419994, 1530510.2790658756, 1283707.511393525, 1414308.8805983758, 943721.1931707633, 598728.757362067, 2779561.192116527, 1952618.0544916363, 899656.1020173575],\n [1296355.2188721865, 2212019.1209020815, 1998182.1420783552, 1390159.7734006236, 1067257.7993323756, 0.0, 2709804.112590561, 2500314.4507069485, 2390841.4329337194, 882457.80942383, 361482.7025425731, 1427995.4150203674, 1610768.421819668, 1788903.6065106322, 1161480.3557326929, 730446.8613086065],\n [2801269.1215845253, 3882177.952930788, 1545364.434045008, 2249169.1308160927, 1646308.7967673023, 2709804.112590561, 0.0, 4018059.834330202, 1093104.7332788548, 2778905.575804111, 3046648.362755992, 1794989.6453295103, 1129464.5539648102, 4404737.747850686, 3516794.375197078, 2427457.036285458],\n [1370943.3069385102, 306997.0343229422, 4184394.186016967, 1811513.5290266906, 2852307.4164419994, 2500314.4507069485, 4018059.834330202, 0.0, 4350710.853063807, 1673216.4080939887, 2586942.3262796295, 3706392.097841614, 3382851.415271485, 2022974.6418062754, 1509585.60107986, 2015770.1390589625],\n [2996683.256068982, 4144977.810718553, 559978.4273194656, 2554165.8167895717, 1530510.2790658756, 2390841.4329337194, 1093104.7332788548, 4350710.853063807, 0.0, 2812916.3098878833, 2650547.941880299, 1053620.7288649315, 967859.8344376946, 4179636.203479384, 3448359.745690545, 2428862.4239271535],\n [422589.4697157836, 1408454.3261387087, 2560790.9591738936, 750916.7305340832, 1283707.511393525, 882457.80942383, 2778905.575804111, 1673216.4080939887, 2812916.3098878833, 0.0, 1093601.4408876144, 2050115.5214378452, 1872971.1741522516, 1708236.6189296674, 752855.8488125347, 384122.2000072272],\n [1515737.0196676727, 2286054.8575902223, 2212581.51715849, 1701189.1538312144, 1414308.8805983758, 361482.7025425731, 3046648.362755992, 2586942.3262796295, 2650547.941880299, 1093601.4408876144, 0.0, 1636770.4499809493, 1932616.2801687205, 1559260.024532222, 1130480.278513877, 1039856.4844335921],\n [2343639.7107855356, 3455343.3108375454, 575975.8749662543, 2062079.2399570548, 943721.1931707633, 1427995.4150203674, 1794989.6453295103, 3706392.097841614, 1053620.7288649315, 2050115.5214378452, 1636770.4499809493, 0.0, 812548.5062332726, 3191662.5092484164, 2564665.4531581327, 1690942.142157212],\n [2031500.319603397, 3179102.5335818897, 933602.6426595236, 1590460.9488364782, 598728.757362067, 1610768.421819668, 1129464.5539648102, 3382851.415271485, 967859.8344376946, 1872971.1741522516, 1932616.2801687205, 812548.5062332726, 0.0, 3364908.7076308434, 2551338.215149899, 1490589.7393085626],\n [1913900.3015914203, 1754834.3710577146, 3767490.41517038, 2434801.332310659, 2779561.192116527, 1788903.6065106322, 4404737.747850686, 2022974.6418062754, 4179636.203479384, 1708236.6189296674, 1559260.024532222, 3191662.5092484164, 3364908.7076308434, 0.0, 973244.7750437199, 2000112.4162614697],\n [946854.1020487415, 1202616.154562711, 3120118.850020503, 1462408.5353501518, 1952618.0544916363, 1161480.3557326929, 3516794.375197078, 1509585.60107986, 3448359.745690545, 752855.8488125347, 1130480.278513877, 2564665.4531581327, 2551338.215149899, 973244.7750437199, 0.0, 1089830.6426635552],\n [665894.0336505901, 1766599.1336905772, 2186473.1552241463, 662752.1291133759, 899656.1020173575, 730446.8613086065, 2427457.036285458, 2015770.1390589625, 2428862.4239271535, 384122.2000072272, 1039856.4844335921, 1690942.142157212, 1490589.7393085626, 2000112.4162614697, 1089830.6426635552, 0.0]])\n\n solver = FacilityOrderSolver(matrix, home_index)\n \n return solver.solve(indices_to_visit)","def get_tuned_excitatory_weights(self):\n \n self.W_ee=np.zeros((self.N_e,self.N_e))\n \n if not hasattr(self,'fixed_connectivity_tuning'):\n self.fixed_connectivity_tuning=1\n \n num_tuned_conns=int(np.floor(self.fixed_connectivity_tuning*self.num_conns_ee))\n num_untuned_conns=self.num_conns_ee-num_tuned_conns\n \n for i in xrange(self.N_e):\n ref_phase=self.gp.phases[i,:]\n dists=gl.get_periodic_dist_on_rhombus(self.n_e,ref_phase,self.gp.phases,self.gp.u1,self.gp.u2)\n sorted_idxs=np.argsort(dists)\n \n tuned_idxs=sorted_idxs[:self.num_conns_ee]\n np.random.shuffle(tuned_idxs)\n\n #untuned_idxs=np.setdiff1d(np.arange(self.N_e),tuned_idxs)\n all_idxs=np.arange(self.N_e)\n np.random.shuffle(all_idxs)\n \n self.W_ee[i,tuned_idxs[0:num_tuned_conns]]=self.W_max_ee\n self.W_ee[i,all_idxs[:num_untuned_conns]]=self.W_max_ee\n \n \n self.W[:self.N_e,:self.N_e]=self.W_ee","def get_random_inhibitory_weights(self):\n \n self.W_ei=np.zeros((self.N_e,self.N_i))\n self.W_ie=np.zeros((self.N_i,self.N_e)) \n self. W_ii=np.zeros((self.N_i,self.N_i))\n\n \n # connections to the excitatory neurons \n for row_idx in xrange(self.N_e):\n \n # from ihibitory\n all_idxs_ei=np.arange(self.N_i)\n np.random.shuffle(all_idxs_ei)\n self.W_ei[row_idx,all_idxs_ei[0:self.num_conns_ei]]=self.W_max_ei \n \n # connections to inhibitory neurons\n for row_idx in range(self.N_i):\n \n # from exitatory \n all_idxs_ie=np.arange(self.N_e)\n np.random.shuffle(all_idxs_ie)\n self.W_ie[row_idx,all_idxs_ie[0:self.num_conns_ie]]=self.W_max_ie\n \n # from inhibitory\n all_idxs_ii=np.arange(self.N_i)\n np.random.shuffle(all_idxs_ii)\n self.W_ii[row_idx,all_idxs_ii[0:self.num_conns_ii]]=self.W_max_ii\n \n \n self.W[:self.N_e,self.N_e:]=self.W_ei\n self.W[self.N_e:,:self.N_e]=self.W_ie\n self.W[self.N_e:,self.N_e:]=self.W_ii","def random_subsample(neuron, num):\n\n I = np.arange(neuron.n_soma, neuron.n_node)\n np.random.shuffle(I)\n selected_index = I[0:num - 1]\n selected_index = np.union1d([0], selected_index)\n selected_index = selected_index.astype(int)\n selected_index = np.unique(np.sort(selected_index))\n\n return neuron_with_selected_nodes(neuron, selected_index)","def shortest_tips(neuron):\n (branch_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 2)\n (endpoint_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 0)\n selected_index = np.union1d(endpoint_index + 1,\n branch_index + 1)\n selected_index = np.append(0, selected_index)","def get_neigh_demand(city):\n\n # get station set S with more than 10 charge equipment\n static_file_path = exp_data_path + os.sep + 'static' + os.sep + 'static_feature_{}.csv'.format(city)\n static_feature = pd.read_csv(static_file_path, header=0)\n station_set = set(static_feature[static_feature.num >= 10].index)\n\n # calculate 10 nearest neighborhoods for each station, sort by distance and store their index, get a map\n neighbor_distance_map = {}\n matrix_distance = np.load(exp_data_path + os.sep + 'similarity' + os.sep + 'similarity_distance_{}_numpy.npy'.format(city), allow_pickle=True)\n all_distance_map = {i: [] for i in range(station_count[city])}\n for i in range(station_count[city]):\n if i not in station_set:\n continue\n for j in range(station_count[city]):\n if j not in station_set:\n continue\n all_distance_map[i].append((j, matrix_distance[i][j]))\n all_distance_map[i].sort(key=lambda x : x[1], reverse=True)\n neighbor_distance_map[i] = [idx for idx, distance in all_distance_map[i][:10]]\n\n # 11 times header, get static neighborhood feature for each station(in S), get csv: neighbor_feature_{city}.csv\n ALL_HEADER = ['index']\n ALL_HEADER.extend(GENERAL_HEADER)\n for i in range(10):\n for j in GENERAL_HEADER:\n ALL_HEADER.append('{}_{}'.format(j, i))\n\n raw_data = np.empty((len(neighbor_distance_map), len(ALL_HEADER)))\n for i, idx in enumerate(neighbor_distance_map.keys()):\n raw_data[i][0] = idx\n raw_data[i][1:1+len(GENERAL_HEADER)] = static_feature.iloc[idx]['num':'mall']\n for j in range(10):\n neighbor_idx = neighbor_distance_map[idx][j]\n raw_data[i][1+len(GENERAL_HEADER)*(j+1):1+len(GENERAL_HEADER)*(j+2)] = static_feature.iloc[neighbor_idx]['num':'mall']\n neighbor_feature_data = pd.DataFrame(raw_data, columns=ALL_HEADER)\n print('neighbor feature')\n print(neighbor_feature_data)\n\n neighbor_feature_path = exp_data_path + os.sep + 'static' + os.sep + 'static_neighor_feature_{}.csv'.format(city)\n if os.path.exists(neighbor_feature_path):\n os.remove(neighbor_feature_path)\n neighbor_feature_data.to_csv(neighbor_feature_path)\n\n # create final csv(11 times header with basic info(time_index + time_embed_index))\n # if index in S, fill basic info, neighbor_feature and demand\n\n demand = np.load(exp_data_path + os.sep + 'station' + os.sep + 'demand_{}.npy'.format(city), allow_pickle=True)\n time_count = demand.shape[1]\n\n DEMAND_HEADER = []\n DEMAND_HEADER.extend(ALL_HEADER)\n DEMAND_HEADER.extend(['time_index', 'time_embed', 'demand'])\n neighbor_demand_raw_data = np.empty(((len(neighbor_distance_map)*time_count, len(DEMAND_HEADER))))\n\n # get time map like {\"0800\": 1, \"0830\": 2, ....}\n time_index_map = np.load(exp_data_path + os.sep + 'station_list' + os.sep + 'time_index.npy', allow_pickle=True)\n time_index_map = dict(time_index_map.tolist())\n time_map = {t: i for i, t in enumerate(sorted(set([k[-4:] for k in time_index_map['rev_index'].keys()])))}\n\n cur_idx = 0\n for time_idx in range(time_count):\n time_embed_idx = time_map[time_index_map['index'][time_idx][-4:]]\n for station_idx in station_set:\n neighbor_demand_raw_data[cur_idx][0:len(ALL_HEADER)] = neighbor_feature_data.loc[neighbor_feature_data['index']==station_idx, 'index':'mall_9']\n neighbor_demand_raw_data[cur_idx][len(ALL_HEADER)] = time_idx\n neighbor_demand_raw_data[cur_idx][len(ALL_HEADER)+1] = time_embed_idx\n neighbor_demand_raw_data[cur_idx][len(ALL_HEADER)+2] = demand[station_idx][time_idx][-1]\n # todo add slow demand and quick demand here\n cur_idx = cur_idx + 1\n print(cur_idx, neighbor_demand_raw_data.shape)\n\n neighbor_demand_data = pd.DataFrame(neighbor_demand_raw_data, columns=DEMAND_HEADER)\n print('neighbor demand')\n print(neighbor_demand_data)\n\n neighbor_demand_path = exp_data_path + os.sep + 'static' + os.sep + 'neighbor_demand_{}.csv'.format(city)\n if os.path.exists(neighbor_demand_path):\n os.remove(neighbor_demand_path)\n neighbor_demand_data.to_csv(neighbor_demand_path)","def get_approx_preRes(self, connectivity_threshold):\n #print(\"sparse_keys\", self.sparse_keys_, \"connectivity_threshold\", connectivity_threshold )\n key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]\n val = self.sparse_book[key_].clone()\n return val","def get_approx_preRes_old(self, connectivity_threshold, i):\n key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]\n val = np.array(sparse_dict[key_]).copy()\n return val","def connection(self, sampleseq, num):\n self.Adjmatrix = np.zeros((self.nodenum, self.nodenum), dtype = int)\n \n for i in range(self.supplynum):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.trandemandseries], sampleseq[self.supplyseries[i]]))\n self.Adjmatrix[self.supplyseries[i], self.trandemandseries[minindex]] = 1\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\n \n for i in range(self.trannum):\n if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) == 0):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\n self.Adjmatrix[minindex, self.transeries[i]] = 1\n# self.Adjmatrix[self.transeries[i], minindex] = 1\n \n \n# for i in range(self.supplynum):\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.supplyseries], num))\n# self.Adjmatrix[self.supplyseries[i], minindex] = 1\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\n \n# for i in range(self.trannum):\n# if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) != 0):\n# continue\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\n## self.Adjmatrix[self.transeries[i], minindex] = 1\n# \n for i in range(self.trannum):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.demandseries], min(sampleseq[self.transeries[i]], self.demandnum))) + self.supplynum + self.trannum\n self.Adjmatrix[self.transeries[i], minindex] = 1\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\n \n# for i in range(self.demandnum):\n# if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], 1)) + self.supplynum\n# self.Adjmatrix[minindex, self.demandseries[i]] = 1\n \n# for i in range(self.trannum):\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.transeries], num)) + self.supplynum\n# self.Adjmatrix[self.transeries[i], minindex] = 1\n \n for i in range(self.demandnum):\n if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], num)) + self.supplynum\n self.Adjmatrix[minindex, self.demandseries[i]] = 1\n# self.Adjmatrix[self.demandseries[i], minindex] = 1\n \n for i in range(self.demandnum):\n minindex = np.array(sf.minimumk(self.Dismatrix[self.demandseries[i], self.demandseries], min(sampleseq[self.demandseries[i]] + 1, self.demandnum))) + self.supplynum + self.trannum\n minindex = minindex[1:-1]\n for j in range(len(minindex)):\n if(self.Adjmatrix[self.demandseries[i], minindex[j]] == 1 or self.Adjmatrix[minindex[j], self.demandseries[i]] == 1):\n continue\n self.Adjmatrix[self.demandseries[i], minindex[j]] = 1","def find_standby2(model, limit, w_a, w_b, w_m, demand_path, demand_dict, slink_dict):\n #print slink_dict\n #print \"FIND\"\n failed_dict = model.failed_dict\n #print failed_dict, limit\n dist_matrix = model.cost_dict['dist']\n rtt_matrix = model.cost_dict['rtt']\n bw_matrix = model.cost_dict['bw']\n #cpu_vector = model.cost_dict['cpu']\n selected_dict = {}\n \n # get aggregated residual bw for all substrate nodes, and store it as a list\n snode_bw_list = total_bw(bw_matrix)\n \n # get total capacity and used bw for each snode\n node_port_list, used_bw_list = total_port(model)\n #vnet_set = model.vnets\n sorted_vn = sort_vnet(model)\n\n #for vnet in vnet_set:\n if w_m[2] >= 10*w_m[1]:\n threshold = 0.8\n else:\n threshold = 0.8\n snode_traffic = {}\n for vn_traffic in sorted_vn:\n vnet = vn_traffic[0]\n failed_vr = failed_dict[vnet.vnet_id]\n if failed_vr != -1: \n # this node is failed\n standby_list = vnet.get_standby_ids()\n standby_cost = {}\n for s_vr in standby_list:\n dist_f = float(dist_matrix[s_vr][failed_vr + 1])\n failed_node = vnet.vnodes[failed_vr]\n vneighbors = failed_node.vneighbors\n dist_k = 0\n rtt_k = 0\n for k in vneighbors:\n dist_k += float(dist_matrix[s_vr][k + 1])\n rtt_k += float(rtt_matrix[s_vr][k + 1])\n\n connect_cost = w_b[0] * (w_a[0] * dist_f + w_a[1] * dist_k) +\\\n w_b[1] * rtt_k\n res_cost = snode_bw_list[s_vr]\n req_bw = sum(failed_node.neighbor_traffic.values())\n total = w_m[1] * connect_cost + w_m[2] * req_bw / res_cost\n standby_cost[s_vr] = total\n sorted_x = sorted(standby_cost.iteritems(), key=operator.itemgetter(1))\n #print \"SORTED\", sorted_x\n \n for item in sorted_x:\n if item[0] not in snode_traffic:\n #utilization = vn_traffic[1] / total_bw(bw_matrix)[item[0]]\n utilization = (vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\n else:\n #utilization = (snode_traffic[item[0]] + vn_traffic[1]) / total_bw(bw_matrix)[item[0]]\n utilization = (snode_traffic[item[0]] + vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\n #print utilization\n # Link-Path selsection add-on\n path_alloc = 1\n for k in vneighbors:\n demand_id = find_demand_id(demand_dict, vnet.vnet_id, failed_vr + 1,\n item[0] + 1, k + 1)\n demand = demand_dict[demand_id]['capacity']\n find, path = find_path(demand_path, demand_id, \n slink_dict, demand) \n if find == 0:\n print \"No available path between svr and nbr on the substrate network\" \n path_alloc = 0\n #print \"FIND PATH\", find, path\n # End link-path block \n #print \"ALLOCATED: \", path_alloc\n if path_alloc == 1:\n if selected_dict.values().count(item[0]) < limit:\n if utilization < threshold and w_m[2] >= 10*w_m[1]:\n if item[0] not in snode_traffic: \n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n snode_traffic[item[0]] = vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1], slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n break;\n else:\n min_id = find_min(sorted_x, bw_matrix, snode_traffic, vn_traffic[1]) \n if min_id == item[0]:\n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n snode_traffic[item[0]] += vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n #threshold = (threshold + 0.01)/2\n break\n elif utilization < threshold:\n selected_dict[vnet.vnet_id] = item[0]\n snode_bw_list[item[0]] -= vn_traffic[1]\n if item[0] not in snode_traffic: \n snode_traffic[item[0]] = vn_traffic[1]\n else:\n snode_traffic[item[0]] += vn_traffic[1]\n for slink_id in path:\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\n #print slink_dict[slink_id]['capacity']\n break\n else:\n print \"does not satisfy the threshold\" \n # if a svr is selected -- item[0]\n \n \n \n else:\n print \"cannot allocate paths\"\n \n #print slink_dict \n return selected_dict, slink_dict","def get_obj_new(model_old, demand_path, slink_dict, demand_dict, w_a, w_b, theta, s_limit):\n model = copy.deepcopy(model_old)\n \n #cpu_vector = model.cost_dict['cpu']\n dist_matrix = model.cost_dict['dist']\n rtt_matrix = model.cost_dict['rtt']\n #bw_matrix = model.cost_dict['bw']\n w_a1, w_a2 = w_a\n w_b1, w_b2 = w_b\n theta1, theta2, theta3 = theta\n # find total capacity and used bw on substrate nodes\n node_port_list, used_bw_list = total_port(model)\n #print \"CHECK POINT-1\", used_bw_list, node_port_list\n vnet_info = model.get_vnet_info()\n infeasible = 0\n\n fail_nodes = model.failed_dict\n start_time = time.time()\n select_dict, slink_dict = find_standby2(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\n # random selection\n #select_dict, slink_dict = find_random(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\n #print \"selection takes: \", time.time() - start_time\n #print \"Selected\", select_dict\n sum_cost_1_2 = 0\n r_list = {}\n \n for node_id in range(0,len(used_bw_list)):\n r_list[node_id] = used_bw_list[node_id]/node_port_list[node_id]\n #print \"INITIAL\", r_list\n svr_subset = {}\n for vnet in model.vnets:\n j = vnet.vnet_id\n f = fail_nodes[j]\n # only count the failed virtual network\n if f == -1:\n pass\n else:\n for node_id in vnet_info[j]['standby']:\n svr_subset[node_id] = r_list[node_id]\n #print \"Subset SVR: \", svr_subset\n \n if j in select_dict:\n #print \"FEASIBLE FOUND\"\n #print vnet_info[j]['standby']\n i = select_dict[j]\n failed_node = vnet.vnodes[f]\n vneighbors = failed_node.vneighbors\n for k in vneighbors: \n eta = operation_cost()\n #print \"a1: \", w_a1, \"a2: \", w_a2, \"b1: \", w_b1, \"b2: \", w_b2\n dist_c = dist_cost(i, f, k, dist_matrix, w_a1, w_a2)\n rtt_c = rtt_cost(i, k, rtt_matrix)\n sigma = connect_cost(dist_c, rtt_c, w_b1, w_b2)\n sum_cost_1_2 += theta1 * eta + theta2 * sigma\n #find residual bw on substrate node\n #xi = resource_cost(bw_matrix, i)\n req_bw = sum(failed_node.neighbor_traffic.values())\n #util = req_bw / xi\n #print req_bw, i, used_bw_list[i], node_port_list[i]\n util = req_bw/node_port_list[i]\n \n if i not in r_list:\n r_list[i] = util #+ used_bw_list[i]/node_port_list[i]\n else:\n r_list[i] += util\n svr_subset[i] = r_list[i]\n #print sigma, \" v_\" + str(vnet.vnet_id) + \"_\" + str(f) + \"_\" + str(i) + \"_\" + str(k) + \"_\" + str(k)\n else:\n print \"INFEASIBLE at vnet: \", j\n infeasible = 1\n #print \"DONE\"\n \n if infeasible == 0:\n #print svr_subset\n max_util = max(svr_subset.values())\n obj = sum_cost_1_2 + theta3 * max_util\n else:\n obj = \"infeasible\"\n max_util = \"none\"\n #print obj\n used_time = time.time() - start_time\n return obj, select_dict, max_util, used_time","def straigh_subsample(neuorn, distance):\n\n # Selecting the main points: branching nodes and end nodes\n selected_index = get_main_points()\n\n # for each segment between two consecuative main points, a few nodes from the segment will be added to the selected node.\n # These new nodes will be selected base on the fact that neural distance of two consecuative nodes is around 'distance'.\n # Specifically, it starts from the far main point, and goes on the segment toward the near main point. Then the first node which is\n # going to add has the property that it is the farest node from begining on the segment such that its distance from begining is\n # less than 'distance'. The next nodes will be selected similarly.\n\n for i in selected_index:\n upList = np.array([i], dtype = int)\n index = neuorn.parent_index[i]\n dist = neuorn.distance_from_parent[i]\n while(~np.any(selected_index == index)):\n upList = np.append(upList,index)\n index = neuorn.parent_index[index]\n dist = np.append(dist, sum(neuorn.distance_from_parent[upList]))\n dist = np.append(0, dist)\n (I,) = np.where(np.diff(np.floor(dist/distance))>0)\n I = upList[I]\n selected_index = np.append(selected_index, I)\n selected_index = np.unique(selected_index)\n neuron = neuron_with_selected_nodes(selected_index)\n return neuron","def __call__(self, circuit):\n gates_qubits_pairs = find_gates_qubits_pairs(circuit)\n nodes = self.connectivity.number_of_nodes()\n keys = list(self.connectivity.nodes())\n final_mapping = dict(zip(keys, range(nodes)))\n final_graph = nx.relabel_nodes(self.connectivity, final_mapping)\n final_cost = self.cost(final_graph, gates_qubits_pairs)\n for _ in range(self.samples):\n mapping = dict(zip(keys, random.sample(range(nodes), nodes)))\n graph = nx.relabel_nodes(self.connectivity, mapping)\n cost = self.cost(graph, gates_qubits_pairs)\n if cost == 0:\n return mapping\n if cost < final_cost:\n final_graph = graph\n final_mapping = mapping\n final_cost = cost\n return final_mapping","def regular_subsample(neuron):\n # select all the main points\n selected_index = get_main_points(neuorn)\n\n # Computing the parent id of the selected nodes\n neuron = neuron_with_selected_nodes(selected_index)\n return neuron","def sampleIndex(self):\r\n x=random.random()\r\n i = 0\r\n n = len(self.weights)-1\r\n cummulativeWeight = 0\r\n if len(self.sampledActions) == 0:\r\n explorationWeight = 0\r\n else:\r\n explorationWeight = self.explorationFund / len(self.sampledActions)\r\n if n < 0:\r\n normalizationFactor = self.priorBelief\r\n else:\r\n normalizationFactor = sum(self.weights) + self.explorationFund + \\\r\n self.priorBelief*(1-self.priorTopicDistr.cummulative[n])\r\n while True:\r\n w = self.__getitem__(i)\r\n if i in self.sampledActions:\r\n w += explorationWeight\r\n cummulativeWeight += w\r\n if x <= cummulativeWeight/normalizationFactor:\r\n if i not in self.sampledActions:\r\n self.sampledActions.append(i)\r\n return i\r\n i += 1","def get_main_points(neuron):\n (branch_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 2)\n (endpoint_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 0)\n selected_index = np.union1d(branch_index + neuron.n_soma,\n endpoint_index + neuron.n_soma)\n selected_index = np.append(range(neuron.n_soma), selected_index)\n return selected_index","def neighbours(indexing, random_stream=None):\n\n # pre-compute some necessary values\n counts = compute_index_counts(indexing)\n binary_sm = compute_binary_set_mappings(indexing, counts)\n unary_sm = compute_unary_set_mappings(indexing, counts)\n empty = find_empty(counts)\n image = [idx for idx,count in enumerate(counts) if count != 0]\n \n def candidates(vertex, index, image, binary_sm, unary_sm, counts, empty):\n \"\"\"generates the set of possible target indices for a given vertex\n\n :param vertex: the vertex\n :type vertex: int\n :param index: the current index of the vertex\n :type index: int\n :param image: the image of the current indexing\n :type image: list\n :param binary_sm: result of `compute_binary_set_mappings`\n :type binary_sm: np.array[n,dtype=int]\n :param unary_sm: result of `compute_unary_set_mappings`\n :type unary_sm: np.array[n,dtype=int]\n :param counts: number of vertices/index\n :type counts: np.array[n,dtype=int]\n :param empty: an index that is assigned no vertex, None is also allowed\n :type empty: int/None\n :yield: iterator over target indices\n :rtype: Iterator[int]\n \"\"\"\n for k in image:\n if k == index:\n continue\n if counts[index] > 1 or counts[k] > 1:\n yield k\n elif vertex < unary_sm[k]: # implicitly: counts[index]==1 and counts[k]==1\n yield k\n if counts[index] > 2 or (counts[index] == 2 and vertex==binary_sm[index]):\n yield empty\n \n if random_stream is not None:\n # Random Move-Enumeration\n pweights = compute_probability_weights(indexing, counts, image, binary_sm)\n vertices = np.random.choice(indexing.shape[0], random_stream, p=pweights)\n for vertex in vertices:\n index = indexing[vertex]\n ks = list(candidates(vertex, index, image, binary_sm, unary_sm, counts, empty))\n k = random.choice(ks)\n yield vertex, k\n else:\n # Move-Enumeration\n for vertex, index in enumerate(indexing):\n for k in candidates(vertex, index, image, binary_sm, unary_sm, counts, empty):\n yield vertex, k","def test_extreme_neighborhoods(self):\n\n ## Radius = 0 ==> all points are noise\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.0,\n min_core_neighbors=3,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 0)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"noise\"), self.n)\n\n ## Min_neighbors > 30 ==> all points are noise\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.0,\n min_core_neighbors=31,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 0)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"noise\"), self.n)\n\n ## Radius very large ==> all points are core points\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=100.0,\n min_core_neighbors=3,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 1)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"core\"), self.n)\n\n ## Min_neighbors = 0 ==> all points are core points\n m = tc.dbscan.create(\n self.sf,\n distance=\"euclidean\",\n radius=0.5,\n min_core_neighbors=0,\n verbose=False,\n )\n\n self.assertEqual(m.num_clusters, 1)\n self.assertEqual(sum(m.cluster_id[\"type\"] == \"core\"), self.n)","def test_indexes_connectivity(epochs):\n electrodes = analyses.indices_connectivity_intrabrain(epochs.epo1)\n length = len(epochs.epo1.info['ch_names'])\n L = []\n for i in range(1, length):\n L.append(length-i)\n tot = sum(L)\n assert len(electrodes) == tot\n electrodes_hyper = analyses.indices_connectivity_interbrain(\n epochs.epoch_merge)\n assert len(electrodes_hyper) == length*length\n # format that do not work for mne.spectral_connectivity","def random_index(\r\n ngrid: int, nt: int, dim_subset: Union[tuple, list], warmup_length=0\r\n) -> tuple:\r\n batch_size, rho = dim_subset\r\n i_grid = np.random.randint(0, ngrid, [batch_size])\r\n i_t = np.random.randint(0 + warmup_length, nt - rho, [batch_size])\r\n return i_grid, i_t","def get_random_neighbor(self):\r\n r_mask = np.random.randint(0, 2, 7)\r\n r_exp = np.random.randint(0, 2, 7)\r\n changes = r_mask*self.attr_factors*np.power(-1.0, r_exp)\r\n Sp = self.S + changes\r\n basal_C = Sp[4]\r\n Sp = np.maximum(Sp, 0.0)\r\n Sp[4] = basal_C\r\n return Sp","def prepare4iCSD(self, index=0):\n if (\n self.surveys[index].x0_ini_guess == True\n or self.surveys[index].x0_prior == True\n ):\n self._estimateM0_(index=index)\n\n # CONSTRAINSTED INVERSION\n # -----------------------\n # Create vector with weight (data weigth, constrainsts weight and regularisation weigth)\n if self.surveys[index].x0_prior == True: # if relative smallness\n self.reg_w_0_b, self.reg_w_0_A = regularize_w(\n self.surveys[index].reg_A,\n self.wr,\n self.surveys[index].x0_prior,\n x0=self.x0,\n )\n\n # stack weight matrix\n self.W_s_A, self.W_s_b = stack_w(\n self.surveys[index].obs_w,\n self.surveys[index].con_w,\n self.surveys[index].x0_prior,\n reg_w_0_A=self.reg_w_0_A,\n reg_w_0_b=self.reg_w_0_b,\n )\n\n # apply weight to A and b (data weigth, constrainsts weight and regularisation weigth)\n self.A_w = weight_A(\n self.surveys[index].x0_prior, self.surveys[index].A_s, W_s_A=self.W_s_A\n )\n self.b_w = weight_b(\n self.surveys[index].x0_prior, self.surveys[index].b_s, W_s_b=self.W_s_b\n )\n\n # UNCONSTRAINSTED INVERSION\n # -------------------------\n else:\n self.reg_w = regularize_w(self.surveys[index].reg_A, self.wr, self.x0_prior)\n\n self.W_s = stack_w(\n self.surveys[index].obs_w,\n self.surveys[index].con_w,\n self.x0_prior,\n reg_w=self.reg_w,\n )\n self.A_w = weight_A(self.x0_prior, self.surveys[index].A_s, W_s=self.W_s)\n self.b_w = weight_b(self.x0_prior, self.surveys[index].b_s, W_s=self.W_s)","def n_finder_v2(gt_mat, x, eps):\n numsnps = int(0.9*gt_mat.shape[0])\n assert(x < numsnps)\n assert(eps > 0 and eps<= 1.0)\n n = 0\n avg_array = np.zeros(gt_mat.shape[0])\n going = True\n while going:\n indices = np.random.choice(numsnps, size=x, replace=False)\n r2_list = [np.corrcoef(gt_mat[i,:],gt_mat[i+n,:])[0,1]**2 for i in indices]\n avg_array[n] = np.nanmean(r2_list)\n n += 1\n if np.mean(r2_list) < eps:\n going = False \n return n,avg_array[:n]","def omission_index(n, sample_size):\n \n \"randomly pick some subset of sample_size agents\"\n index = np.sort(np.random.choice(n,sample_size,replace=False))\n \"double up index to choose x and y positions columns. both are used.\"\n index2 = np.repeat(2*index,2) \n \"nudge every second item to take the ith+1 column (y coordinate corresponding to chosen x)\"\n index2[1::2] += 1\n return index, index2","def get_state(tip_speed):\n states = np.linspace(-3,3,num=discretization) # Discretized table of tip speeds. Range of 3 indicates possible speeds\n for rounded_tip_speed in states:\n if rounded_tip_speed >= tip_speed:\n index = np.where(states == rounded_tip_speed)\n index = index[0][0]\n return index","def _choose_sample(self):\n\n \t #periodically generate a new reconstruction for the purposes of sampling","def select_move(self, from_search=False, verbose=False) -> Tuple[int, str]:\n node = self.current\n c0 = 1\n N = sum(e.visits for e in node.edges) + c0\n eps = self.cpuct * len(node.edges) * np.sqrt(N)\n ucb = [e.value + eps * e.prior / (c0 + e.visits) for e in node.edges]\n\n if from_search:\n #\n tau = 0.01 + self.temperature *\\\n (1.0 - self.current.level() / self.max_steps)\n\n probs = [(e.search_outcome + 0.01)**(1/tau) for e in node.edges]\n probs = np.array(probs) / sum(probs)\n dnoise = np.random.dirichlet(np.ones(len(probs)))\n eps = self.dnoise\n probs = (1.0 - eps) * probs + eps * dnoise\n\n # chooce proportionally\n index = np.random.choice(np.arange(len(probs)), p=probs)\n # index = np.argmax(probs)\n msg = \"Chooosing {} with probability {:.4f}\"\n print(msg.format(node.edges[index].cmd, probs[index]))\n else:\n node = self.current\n index = np.argmax(ucb)\n\n if verbose:\n msg = \"NODE: Visits: {}, Reward: {:.2f}, \" +\\\n \"Score: {:.2f}, Envscore: {}\"\n print(msg.format(\n node.visits, node.reward, node.score, node.envscore))\n # print(\"CMD HISTORY:\", node.cmd_history(cmds_only=True))\n\n values = [e.value for e in node.edges]\n counts = [e.search_outcome for e in node.edges]\n cmds = [e.cmd for e in node.edges]\n priors = [e.prior for e in node.edges]\n ix = range(len(node.edges))\n\n msg = ''.join((\"EDGE {}: V: {:.2f}, P: {:.2f}, S: {}, \",\n \"UCB: {:.2f}, cmd: {} SP: {:.2f}\"))\n if not from_search:\n probs = np.zeros(len(node.edges))\n\n for i, c, p, v, n, u, r in zip(ix, cmds, priors,\n values, counts, ucb, probs):\n print(msg.format(i, v, p, n, u, c, r))\n\n edge = node.edges[index]\n edge.search_outcome += 1\n\n return index, edge.cmd","def greedy_selector(self):\n r_k = 0 \n best_route = []\n cities_to_visit = [i for i in range(1, self.city_count)]\n for _ in range(1, self.city_count):\n s_ind = np.argmax([self.tau[(r_k, u)] for u in cities_to_visit])\n s_k = cities_to_visit.pop(s_ind)\n best_route.append((r_k, s_k))\n r_k = s_k\n best_route.append((r_k, 0))\n \n shortest_path = np.sum([self.phi[(p)] for p in best_route])\n return best_route, shortest_path","def n_finder(gt_mat, x, eps):\n numsnps = int(0.9*gt_mat.shape[0])\n assert(x < numsnps)\n assert(eps > 0 and eps<= 1.0)\n indices = np.random.choice(numsnps, size=x, replace=False)\n n = 0\n avg_array = np.zeros(gt_mat.shape[0])\n going = True\n while going:\n r2_list = [np.corrcoef(gt_mat[i,:],gt_mat[i+n,:])[0,1]**2 for i in indices]\n avg_array[n] = np.nanmean(r2_list)\n n += 1\n if np.mean(r2_list) < eps:\n going = False \n return n,avg_array[:n]","def select(self, batch_size):\n\n #if self.tree.filled_size() < batch_size:\n # print('CALLING REPLAY SAMPLING WHEN NOT FULL ENOUGH')\n # #return None, None\n\n out = []\n indices = []\n #weights = []\n priorities = []\n avoid_resampling = False\n for _ in range(batch_size):\n r = random.random()\n #return (idx, self.tree[idx], self.data[dataIdx])\n data, priority, index = self.tree.find(r)\n #index, priority, data = self.tree.find(r)\n #print(index)\n #print(\"d: {}, \\n priority: {}, \\n index: {}\".format(data, priority, index))\n priorities.append(priority)\n #weights.append((1. / self.memory_size / priority) ** beta if priority > 1e-16 else 0)\n indices.append(index)\n out.append(data)\n if avoid_resampling: self.priority_update([index], [self.epsilon_priority]) # To avoid resampling same transition too much\n\n for i in range(len(priorities)):\n if priorities[i] >= self.bonus_priority: # remove priority bonus\n priorities[i] -= self.bonus_priority\n self.priority_update([indices[i]],[priorities[i]])\n\n # avoid resampling part self.priority_update(indices, priorities) # Revert priorities\n #weights /= max(weights) # Normalize for stability\n return out, indices","def test_subset_reconstruction_iterable(self, wires):\n circuit = hadamard_circuit(wires)\n bits, recipes = circuit()\n shadow = ClassicalShadow(bits, recipes)\n\n # choose 1000 random indices\n snapshots = np.random.choice(np.arange(10000, dtype=np.int64), size=1000, replace=False)\n state = shadow.global_snapshots(snapshots=snapshots)\n assert state.shape == (len(snapshots), 2**wires, 2**wires)\n\n # check the results against obtaining the full global snapshots\n expected = shadow.global_snapshots()\n for i, t in enumerate(snapshots):\n assert np.allclose(expected[t], state[i])","def select_random_node(cluster_ips):\n return random.choice(cluster_ips)","def __init__(self, n4, L, k, randomize=False, non_k=-1, given_weight_matrix = None):\n\n self.n4 = n4\n self.L = L\n self.k = k\n self.weightMatrix = numpy.full((self.n4, self.L), non_k, dtype=numpy.int16)\n\n # initializing from the start\n if given_weight_matrix == None: \n if randomize == \"True\":\n #initialize weight matrix: for each stimulus, pick k neurons that respond randomly\n for stim in range(self.L):\n # randomly samples k neurons to respond (out of n4)\n responds = random.sample(range(n4), k=self.k)\n # updates the values of those k neurons' responses to stimulus \n for nrn in responds: \n self.weightMatrix[nrn][stim] = 1\n else:\n start_nrn = 0\n # the first k neurons respond to first stimulus, and so on\n for stim in range(self.L):\n for nrn_offset in range(self.k):\n self.weightMatrix[start_nrn + nrn_offset][stim] = 1\n start_nrn += self.k\n\n # initializing from previous weight matrix, given as string or as prepared weight matrix\n else: \n if type(given_weight_matrix) is str:\n l4_weight_list = [int(i) for i in given_weight_matrix.split(\",\")]\n \n if len(l4_weight_list) != (self.n4 * self.L):\n print(\"Error! String provided to initialize L4 weight matrix must have length n4 * L.\")\n sys.exit(1)\n\n for nrn in range(self.n4):\n start = nrn * self.L \n end = start + self.L\n self.weightMatrix[nrn] = numpy.array(l4_weight_list[start:end])\n else:\n if given_weight_matrix.shape != (n4, L):\n print(\"Error! Matrix provided to initialize L4 weight matrix must have shape (n4, L)\")\n sys.exit(1)\n self.weightMatrix = given_weight_matrix","def _sample(self, rnn_output, temperature):\n pass","def best_move(data, indexing, cf, cf_prime, N=20, M=30): \n stats = {}\n timer = time()\n ns = list(neighbours(indexing, random_stream=N))\n stats[\"n_neighbours\"] = len(ns)\n stats[\"t_neighbours\"] = 1000*(time() - timer)\n\n dt_rcs = []\n bestpair, best_rcost = None, None\n for v,k in ns:\n timer = time()\n rc = reduced_cost(data, indexing, cf, cf_prime, v, k, uw_sample_count=M)\n dt_rcs.append(1000*(time() - timer))\n if bestpair is None or rc > best_rcost:\n bestpair = v,k\n best_rcost = rc\n\n stats[\"t_rcs_mean\"] = np.mean(dt_rcs)\n stats[\"t_rcs_std\"] = np.std(dt_rcs)\n stats[\"t_rcs_sum\"] = np.sum(dt_rcs)\n stats[\"rc\"] = best_rcost\n stats[\"partcount\"] = np.unique(indexing).shape[0]\n return bestpair, best_rcost, stats","def test_lifted_index():\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\n 400.]) * units.hPa\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\n -23.5]) * units.degC\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\n -57.5]) * units.degC\n parcel_prof = parcel_profile(pressure, temperature[0], dewpoint[0])\n li = lifted_index(pressure, temperature, parcel_prof)\n assert_almost_equal(li, -7.9115691 * units.delta_degree_Celsius, 2)","def two_temps(L, n_cycles, temp):\n\n E = np.zeros((2, len(temp), n_cycles))\n Mag = np.zeros((2, len(temp), n_cycles))\n MagAbs = np.zeros((2, len(temp), n_cycles))\n SH = np.zeros((2, len(temp), n_cycles))\n Suscept = np.zeros((2, len(temp), n_cycles))\n\n Naccept = np.zeros((2, len(temp), n_cycles))\n\n ground_spin_mat = np.ones((L, L), np.int8) # initial state (ground state)\n\n for m in range(2):\n for t in range(len(temp)):\n\n #m=0 is ground state, all spin-up\n #m=1 is random state\n if m==0:\n spin_matrix = ground_spin_mat\n else:\n s_mat_random = np.ones((L, L), np.int8) # spin matrix of ones\n #random indices switched to -1\n for sw in range(len(s_mat_random)):\n for sl in range(len(s_mat_random)):\n rint = np.random.randint(-1,1)\n if rint == -1:\n s_mat_random[sw,sl] *= -1\n spin_matrix = s_mat_random\n\n\n print(\"hi\")#; sys.exit(1)\n Energy, Magnetization, MagnetizationAbs, SpecificHeat, Susceptibility, Nacc \\\n = numerical_solution(spin_matrix, n_cycles, temp[t], L, abs=False)\n\n\n E[m,t,:] = Energy\n Mag[m,t,:] = Magnetization\n MagAbs[m,t,:] = MagnetizationAbs\n SH[m,t,:] = SpecificHeat\n Suscept[m,t,:] = Susceptibility\n\n Naccept[m,t,:] = Nacc\n\n return E, Mag, MagAbs, SH, Suscept, Naccept","def choose_best_neighbour_simple(self):\n\t\trejected = set([]) #list of prohibited indexes which are rejected because of tabu and energy\n\t\tnIndex = -1\n\t\twhile(True):\n\t\t\tnIndex = self._find_min_diff(rejected=rejected)\t\t#index of best neighbor\n\n\t\t\tif self.is_tabu(nIndex):\n\t\t\t\toutput(message=\"\\t Neuron is in tabu. Need to check the aspiration criteria\",isDebug=True)\n\t\t\t\tif self.aspiration_criteria_satisfied(nIndex):\n\t\t\t\t\tbreak\n\t\t\t\telse:\n\t\t\t\t\trejected.add(nIndex)\n\t\t\telse:\n\t\t\t\tbreak\n\t\t# output(\"Neuron is found\",isDebug=True)\n\t\treturn nIndex","def test_sweat_index():\n pressure = np.array([1008., 1000., 947., 925., 921., 896., 891., 889., 866.,\n 858., 850., 835., 820., 803., 733., 730., 700., 645.,\n 579., 500., 494., 466., 455., 441., 433., 410., 409.,\n 402., 400., 390., 388., 384., 381., 349., 330., 320.,\n 306., 300., 278., 273., 250., 243., 208., 200., 196.,\n 190., 179., 159., 151., 150., 139.]) * units.hPa\n temperature = np.array([27.4, 26.4, 22.9, 21.4, 21.2, 20.7, 20.6, 21.2, 19.4,\n 19.1, 18.8, 17.8, 17.4, 16.3, 11.4, 11.2, 10.2, 6.1,\n 0.6, -4.9, -5.5, -8.5, -9.9, -11.7, -12.3, -13.7, -13.8,\n -14.9, -14.9, -16.1, -16.1, -16.9, -17.3, -21.7, -24.5, -26.1,\n -28.3, -29.5, -33.1, -34.2, -39.3, -41., -50.2, -52.5, -53.5,\n -55.2, -58.6, -65.2, -68.1, -68.5, -72.5]) * units.degC\n dewpoint = np.array([24.9, 24.6, 22., 20.9, 20.7, 14.8, 13.6, 12.2, 16.8,\n 16.6, 16.5, 15.9, 13.6, 13.2, 11.3, 11.2, 8.6, 4.5,\n -0.8, -8.1, -9.5, -12.7, -12.7, -12.8, -13.1, -24.7, -24.4,\n -21.9, -24.9, -36.1, -31.1, -26.9, -27.4, -33., -36.5, -47.1,\n -31.4, -33.5, -40.1, -40.8, -44.1, -45.6, -54., -56.1, -56.9,\n -58.6, -61.9, -68.4, -71.2, -71.6, -77.2]) * units.degC\n speed = np.array([0., 3., 10., 12., 12., 14., 14., 14., 12.,\n 12., 12., 12., 11., 11., 12., 12., 10., 10.,\n 8., 5., 4., 1., 0., 3., 5., 10., 10.,\n 11., 11., 13., 14., 14., 15., 23., 23., 24.,\n 24., 24., 26., 27., 28., 30., 25., 24., 26.,\n 28., 33., 29., 32., 26., 26.]) * units.knot\n direction = np.array([0., 170., 200., 205., 204., 200., 197., 195., 180.,\n 175., 175., 178., 181., 185., 160., 160., 165., 165.,\n 203., 255., 268., 333., 0., 25., 40., 83., 85.,\n 89., 90., 100., 103., 107., 110., 90., 88., 87.,\n 86., 85., 85., 85., 60., 55., 60., 50., 46.,\n 40., 45., 35., 50., 50., 50.]) * units.degree\n\n sweat = sweat_index(pressure, temperature, dewpoint, speed, direction)\n assert_almost_equal(sweat, 227., 2)","def select(individuals, n):\r\n # return selBest(individuals, n)\r\n return individuals[:n]","def compute_rwse(self, traffic_density):\r\n # Ensure experiment has not beem done before\r\n np.random.seed(2020)\r\n file_names = os.listdir(self.dirName)\r\n if traffic_density+'rwse' in file_names:\r\n print(\"This experiment has been done already!\")\r\n return None\r\n elif traffic_density == '':\r\n print(\"select a traffic dinsity level!\")\r\n return None\r\n rwse_dict = {'vel_m':0,\r\n 'lat_vel':1,\r\n 'vel_y':2,\r\n 'vel_f':3,\r\n 'vel_fadj':4}\r\n\r\n pred_step_n = self.pred_h*10+1\r\n splits_n = 6 # number of splits across an entire trajectory\r\n pred_arrs = [np.zeros([self.episode_n*self.traj_n*6,\r\n pred_step_n]) for i in range(5)]\r\n truth_arrs = [np.zeros([self.episode_n*self.traj_n*6,\r\n pred_step_n]) for i in range(5)]\r\n _row = 0\r\n\r\n for episode_id in self.test_data.test_episodes[:self.episode_n]:\r\n # for episode_id in [1289]:\r\n st_seq, cond_seq, st_arr, targ_arr = self.episodeSetup(episode_id)\r\n self.gen_model.max_pc = max(st_arr[:, self.gen_model.indx_m['pc']])\r\n self.gen_model.min_pc = min(st_arr[:, self.gen_model.indx_m['pc']])\r\n if len(st_seq) >= 6:\r\n splits_n = 6\r\n else:\r\n splits_n = len(st_seq)\r\n obs_n = self.test_data.data_obj.obs_n\r\n traj_splits = np.random.choice(range(19, 19+len(st_seq)), splits_n, replace=False)\r\n # leave value of 19 to ensure scenarios remain consistent\r\n for split in traj_splits:\r\n st_seq_i, cond_seq_i, bc_der_i, _, st_i, targ_i = self.sceneSetup(st_seq,\r\n cond_seq,\r\n st_arr,\r\n targ_arr,\r\n current_step=split,\r\n pred_h=self.pred_h)\r\n targ_i.shape = (1, pred_step_n, 5)\r\n st_init = np.repeat(np.reshape(st_i[0,:], [1,17]), self.traj_n, axis=0)\r\n\r\n actions, _, _ = self.policy.get_actions([st_seq_i, cond_seq_i], bc_der_i,\r\n traj_n=self.traj_n, pred_h=self.pred_h)\r\n st_pred = self.gen_model.forwardSim(st_init, actions, pred_step_n)\r\n\r\n truth_arrs[0][_row:_row+self.traj_n, :] = \\\r\n st_i[:,self.gen_model.indx_m['vel']]\r\n pred_arrs[0][_row:_row+self.traj_n, :] = \\\r\n st_pred[:,:,self.gen_model.indx_m['vel']]\r\n\r\n truth_arrs[1][_row:_row+self.traj_n, :] = \\\r\n st_i[:,self.gen_model.indx_m['act_lat_p']]\r\n pred_arrs[1][_row:_row+self.traj_n, :] = \\\r\n st_pred[:,:,self.gen_model.indx_m['act_lat_p']]\r\n\r\n truth_arrs[2][_row:_row+self.traj_n, :] = \\\r\n st_i[:,self.gen_model.indx_y['vel']]\r\n pred_arrs[2][_row:_row+self.traj_n, :] = \\\r\n st_pred[:,:,self.gen_model.indx_y['vel']]\r\n\r\n truth_arrs[3][_row:_row+self.traj_n, :] = \\\r\n st_i[:,self.gen_model.indx_f['vel']]\r\n pred_arrs[3][_row:_row+self.traj_n, :] = \\\r\n st_pred[:,:,self.gen_model.indx_f['vel']]\r\n\r\n truth_arrs[4][_row:_row+self.traj_n, :] = \\\r\n st_i[:,self.gen_model.indx_fadj['vel']]\r\n pred_arrs[4][_row:_row+self.traj_n, :] = \\\r\n st_pred[:,:,self.gen_model.indx_fadj['vel']]\r\n\r\n\r\n _row += self.traj_n\r\n # return st_pred\r\n print('Episode ', episode_id, ' has been completed!')\r\n for key in rwse_dict.keys():\r\n rwse_dict[key] = self.root_weightet_sqr(truth_arrs[rwse_dict[key]], \\\r\n pred_arrs[rwse_dict[key]])\r\n\r\n with open(self.dirName+'/'+ traffic_density + 'rwse', \"wb\") as f:\r\n pickle.dump(rwse_dict, f)\r\n return rwse_dict","def test_should_only_get_specific_indices(self):\n print(\"Testing that get_region returns correct amount of data\")\n\n test_many = get_region_data(self.wmo_boxes, self.float_name, self.config,\n self.index, self.pres)\n\n self.assertTrue(test_many[0].shape[1] == self.index.__len__())\n\n test_one = get_region_data(self.wmo_boxes, self.float_name, self.config,\n [50], self.pres)\n\n self.assertTrue(test_one[0].shape[1] == 1)","def constructConnMatrices(nE=4000, nI=1000, n_clusters=50,\n pEE=.2, pEI=.5, pIE=.5, pII=.5, rEE=1.0,\n jEE_out=0.024, jEE_in=1.9, jEI=0.014, jIE=-0.045, jII=-0.057): # Need to add synaptic strengths\n # Structural connectivity (probabilities taken from Litwin-Kumar & Doiron, 2012)\n if rEE==1:\n sEE = np.random.binomial(1,pEE,size=(nE,nE))\n wEE = sEE*jEE_out\n else:\n neurons_per_clust = int(nE/float(n_clusters))\n pEE_out = (pEE*(nE-1))/(rEE*neurons_per_clust + (nE-1) - neurons_per_clust)\n pEE_in = rEE*pEE_out\n\n # First define all pEE_out connections\n sEE = np.random.binomial(1,pEE_out,size=(nE,nE))\n wEE = sEE * jEE_out\n # Now we will re-do clustered connections\n neuron_count = 0\n for clust in range(n_clusters):\n i = int(neuron_count)\n j = int(neuron_count + neurons_per_clust)\n sEE[i:j,i:j] = 0\n sEE[i:j,i:j] = np.random.binomial(1,pEE_in,size=(neurons_per_clust,neurons_per_clust))\n wEE[i:j,i:j] = sEE[i:j,i:j] * jEE_in\n neuron_count += neurons_per_clust\n\n # No self connections\n np.fill_diagonal(wEE,0)\n\n # Structural matrices\n sEI = np.random.binomial(1,pEI,size=(nE,nI))\n sIE = np.random.binomial(1,pIE,size=(nI,nE))\n sII = np.random.binomial(1,pII,size=(nI,nI))\n\n # Synaptic weights\n wEI = sEI * jEI\n wIE = sIE * jIE\n wII = sII * jII\n\n # No self connections\n np.fill_diagonal(wII,0)\n\n return wEE, wEI, wIE, wII","def setValue(matrix, line, indexRef, noiseLevel):\n #print \"getValue for \", value, noiseLevel\n maxIndex = matrix.shape[0] - 1\n sum = 0\n summedItems = 0\n \n if line[0][0] == 3 and indexRef[3,0] < maxIndex:\n return\n if line[0][1] == 3 and indexRef[3,1] < maxIndex:\n return\n if line[0][2] == 3 and indexRef[3,2] < maxIndex:\n return\n \n for i in range(1, len(line)):\n point = line[i]\n r = indexRef[point[0],0]\n c = indexRef[point[1],1]\n f = indexRef[point[2],2]\n if r >= 0 and c >= 0 and f >= 0 and matrix[r,c,f] >= 0:\n sum += matrix[r,c,f]\n summedItems += 1\n value = 0\n average = 0\n if (summedItems > 0):\n average = sum / float(summedItems)\n \n # determine the target index\n r = indexRef[line[0][0],0]\n c = indexRef[line[0][1],1]\n f = indexRef[line[0][2],2]\n # set the target cell \n matrix[r,c,f] = (noiseLevel * random.random()) + ((1-noiseLevel) * average)\n \n #print \"setting\", r, c, f, \"to \", matrix[r, c, f]","def spectralIndices(\n x: Union[ee.Image, ee.ImageCollection],\n index: Union[str, List[str]] = \"NDVI\",\n G: Union[float, int] = 2.5,\n C1: Union[float, int] = 6.0,\n C2: Union[float, int] = 7.5,\n L: Union[float, int] = 1.0,\n cexp: Union[float, int] = 1.16,\n nexp: Union[float, int] = 2.0,\n alpha: Union[float, int] = 0.1,\n slope: Union[float, int] = 1.0,\n intercept: Union[float, int] = 0.0,\n gamma: Union[float, int] = 1.0,\n kernel: str = \"RBF\",\n sigma: Union[float, str] = \"0.5 * (a + b)\",\n p: Union[float, int] = 2,\n c: Union[float, int] = 1.0,\n online: bool = False,\n drop: bool = False,\n) -> Union[ee.Image, ee.ImageCollection]:\n platformDict = _get_platform_STAC(x)\n\n if isinstance(sigma, int) or isinstance(sigma, float):\n if sigma < 0:\n raise Exception(f\"[sigma] must be positive! Value passed: sigma = {sigma}\")\n\n if p <= 0 or c < 0:\n raise Exception(\n f\"[p] and [c] must be positive! Values passed: p = {p}, c = {c}\"\n )\n\n additionalParameters = {\n \"g\": float(G),\n \"C1\": float(C1),\n \"C2\": float(C2),\n \"L\": float(L),\n \"cexp\": float(cexp),\n \"nexp\": float(nexp),\n \"alpha\": float(alpha),\n \"sla\": float(slope),\n \"slb\": float(intercept),\n \"gamma\": float(gamma),\n \"p\": float(p),\n \"c\": float(c),\n }\n\n spectralIndices = _get_indices(online)\n indicesNames = list(spectralIndices.keys())\n\n if not isinstance(index, list):\n if index == \"all\":\n index = list(spectralIndices.keys())\n elif index in [\n \"vegetation\",\n \"burn\",\n \"water\",\n \"snow\",\n \"drought\",\n \"urban\",\n \"kernel\",\n ]:\n temporalListOfIndices = []\n for idx in indicesNames:\n if spectralIndices[idx][\"type\"] == index:\n temporalListOfIndices.append(idx)\n index = temporalListOfIndices\n else:\n index = [index]\n\n for idx in index:\n if idx not in list(spectralIndices.keys()):\n warnings.warn(\n f\"Index {idx} is not a built-in index and it won't be computed!\"\n )\n else:\n\n def temporalIndex(img):\n lookupDic = _get_expression_map(img, platformDict)\n lookupDic = {**lookupDic, **additionalParameters}\n kernelParameters = _get_kernel_parameters(img, lookupDic, kernel, sigma)\n lookupDic = {**lookupDic, **kernelParameters}\n lookupDicCurated = _remove_none_dict(lookupDic)\n if all(\n band in list(lookupDicCurated.keys())\n for band in spectralIndices[idx][\"bands\"]\n ):\n return img.addBands(\n img.expression(\n spectralIndices[idx][\"formula\"], lookupDicCurated\n ).rename(idx)\n )\n else:\n warnings.warn(\n f\"This platform doesn't have the required bands for {idx} computation!\"\n )\n return img\n\n if isinstance(x, ee.imagecollection.ImageCollection):\n x = x.map(temporalIndex)\n elif isinstance(x, ee.image.Image):\n x = temporalIndex(x)\n\n if drop:\n x = x.select(index)\n\n return x","def random_select_revealed_node(self, alpha, index1, index2):\n same_nodes = set(self.graphs[index1].nodes()) & set(self.graphs[index2].nodes())\n s = int(alpha * len(same_nodes))\n logging.info(\"graph {}-{} random revealed nodes {}/{}.\".format\n (index1, index2, s, len(same_nodes)))\n revealed_nodes = random.sample(same_nodes, s)\n self.revealed_nodes[(index1, index2)] = set(revealed_nodes)\n self.same_nodes[(index1, index2)] = same_nodes\n return revealed_nodes","def get_neighbour(self, sol):\n std_dev = min(np.sqrt(self._temp), (self.domain[1]-self.domain[0])/3/self.cool_rate)\n solution = [None] * self.dimensions\n for i in range(self.dimensions):\n #rand = np.random.uniform(-np.pi/2, np.pi/2)\n #solution[i] = self.bind(sol[i] + self.cool_rate * self.T * np.tan(rand))\n solution[i] = self.bind(sol[i] + np.random.normal(0, 1) * std_dev * self.cool_rate)\n return solution","def select(weights):\n r = random.random() * sum(weights)\n s = 0.0\n for k,w in enumerate(weights):\n s += w\n if r <= s:\n return k\n raise RuntimeError(\"select WTF from %s\" % weights)","def weighted_random_choice(self, cands):\n # Only consider the entries with the highest priority (lowest service priority value)\n lowest_priority = min(conn.srv_priority for conn in cands)\n result = [conn for conn in cands if conn.srv_priority == lowest_priority]\n result.sort(key=lambda a: a.weight)\n if not result:\n raise LVPError(\"No connection available for cloning\")\n\n total_weight = sum(e.weight for e in result)\n random_pos = random.random() * total_weight\n weight_pos = 0.0\n for conn in result:\n weight_pos += conn.weight\n if weight_pos >= random_pos:\n return conn\n\n assert False, \"execution should never end up here\"","def test_k_index():\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\n 400.]) * units.hPa\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\n -23.5]) * units.degC\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\n -57.5]) * units.degC\n ki = k_index(pressure, temperature, dewpoint)\n assert_almost_equal(ki, 33.5 * units.degC, 2)","def __init__(self,\n name,\n vertices_location,\n connectivity,\n connectivity_ids=None,\n connectivity_label=None,\n connectivity_label_metadata=None,\n connectivity_colormap = None,\n connector_size=2.6,\n global_deselect_alpha=0.2,\n global_select_alpha=1.0,\n skeleton_linewidth=2.0):\n super(Microcircuit, self).__init__( name )\n\n if not connectivity_ids is None:\n self.connectivity_ids = connectivity_ids\n\n if not connectivity_label is None:\n self.connectivity_labels = connectivity_label\n\n if not connectivity_label_metadata is None:\n\n for semanticdict in connectivity_label_metadata:\n # name needs to be based on convention, TODO: best from ontology id rather than string!\n # TODO: use microcircuit convention\n if semanticdict.has_key(\"name\"):\n name = semanticdict[\"name\"]\n if \"skeleton\" in name:\n self.con_skeleton = int(semanticdict[\"value\"])\n elif \"presynaptic\" in name:\n self.con_pre = int(semanticdict[\"value\"])\n elif \"postsynaptic\" in name:\n self.con_post = int(semanticdict[\"value\"])\n\n else:\n # TODO: default\n self.con_skeleton = 1\n self.con_pre = 2\n self.con_post = 3\n\n # selection stores integer ids from connectivity_selectionID\n # when selected\n self.skeleton_selection = []\n\n # use the connectivity labels to extract the connectivity for the skeletons\n self.index_skeleton = np.where(self.connectivity_labels == self.con_skeleton)[0]\n self.index_allpre = np.where(self.connectivity_labels == self.con_pre)[0]\n self.index_allpost = np.where(self.connectivity_labels == self.con_post)[0]\n \n self.vertices = vertices_location\n self.connectivity = connectivity\n\n connectivity_skeleton = self.connectivity[self.index_skeleton]\n self.vertices_skeleton = self.vertices[ connectivity_skeleton.ravel() ]\n \n # we have a simplified connectivity now\n self.connectivity_skeleton = np.array( range(len(self.vertices_skeleton)), dtype = np.uint32 )\n self.connectivity_skeleton = self.connectivity_skeleton.reshape( (len(self.connectivity_skeleton)/2, 2) )\n self.connectivity_ids_skeleton = self.connectivity_ids[ self.index_skeleton ]\n\n # look up the start and end vertex id\n # map these to _skeleton arrays, and further to actor???\n\n # colors for skeletons\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_skeleton ):\n self.connectivity_skeleton_colors = np.repeat(connectivity_colormap[self.con_skeleton], len(self.connectivity_skeleton), axis=0).astype( np.float32 )\n\n ##########\n # Incoming connectors\n ##########\n\n # extract the pre connectivity and create cones\n # store the indices for to be used to create the vector scatter\n # by itself, it represent implicitly the index used to select/deselect the vectors\n if len(self.index_allpre) == 0:\n if DEBUG:\n print \"no presynaptic connection\"\n self.pre_actor = None\n else:\n self.vertices_pre = self.vertices[ connectivity[self.index_allpre].ravel() ]\n self.pre_p1 = self.vertices_pre[::2, :] # data is NOT copied here\n self.pre_p2 = self.vertices_pre[1::2, :]\n pren = len(self.index_allpre)\n r1 = np.ones( pren, dtype = np.float32 ) * connector_size\n r2 = np.zeros( pren, dtype = np.float32 )\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_pre ):\n preval = np.ones( pren, dtype = np.dtype(type(self.con_pre)) ) * self.con_pre\n else:\n preval = None\n self.pre_actor = VectorScatter( \"PreConnector\", self.pre_p1, self.pre_p2, r1, r2, values = preval,\n resolution = 8, colormap = connectivity_colormap )\n # len(self.index_pre) = len(self.pre_p1) = len(preval)\n\n ##########\n # Outgoing connectors\n ##########\n\n # extract the post connectivity and create cones\n if len(self.index_allpost) == 0:\n if DEBUG:\n print \"no postsynaptic connection\"\n self.post_actor = None\n else:\n self.vertices_post = self.vertices[ connectivity[self.index_allpost].ravel() ]\n self.post_p1 = self.vertices_post[::2, :]\n self.post_p2 = self.vertices_post[1::2, :]\n postn = len(self.index_allpost)\n r1 = np.zeros( postn, dtype = np.float32 )\n r2 = np.ones( postn, dtype = np.float32 ) * connector_size\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_post ):\n postval = np.ones( postn, dtype = np.dtype(type(self.con_post)) ) * self.con_post\n else:\n postval = None\n self.post_actor = VectorScatter( \"PostConnector\", self.post_p1, self.post_p2, r1, r2, values = postval,\n resolution = 8, colormap = connectivity_colormap )\n\n ##########\n # Skeletons\n ##########\n self.skeleton = Skeleton( name = \"Polygon Lines\",\n vertices = self.vertices_skeleton,\n connectivity = self.connectivity_skeleton,\n connectivity_colors = self.connectivity_skeleton_colors,\n connectivity_ID = self.connectivity_ids_skeleton,\n linewidth = skeleton_linewidth,\n global_deselect_alpha = global_deselect_alpha,\n global_select_alpha = global_select_alpha )\n\n self.connectivity_skeletononly_ids = None\n self.connectivity_preonly_ids = None\n self.connectivity_postonly_ids = None\n\n self.global_deselect_alpha = global_deselect_alpha\n self.global_select_alpha = global_select_alpha","def CreateAtrium(L,v,d,seed): \n Neighbours = np.ndarray(L*L, dtype = list)\n rnd.seed(seed)\n Phases = np.ndarray(L*L,dtype = float)\n Phases.fill(4)\n Functionality = np.ndarray([L*L], dtype = bool)\n index = np.indices((1, L*L))[1][0]\n Atrium = index.reshape(L,L) # The index for that site within the long arrays\n for j in index:\n z = rnd.uniform(0,1)\n if d > z: # dysfunctional\n Functionality[j] = False\n if d <= z: # functional\n Functionality[j] = True\n if j in np.arange(0,L*L,L): # first column\n Neighbours[j] = list()\n Neighbours[j].extend([j+1])\n elif j in (np.arange(0,L*L,L)+L-1): # last column\n Neighbours[j] = list()\n Neighbours[j].extend([j-1])\n else: # body columns\n Neighbours[j] = list()\n Neighbours[j].extend([j-1,j+1])\n w = rnd.uniform(0,1)\n for j in np.arange(L*L):\n if w <= v: # transverse connections\n if j in np.arange(L*L-L,L*L):\n Neighbours[j].extend([j-(L*L-L)])\n Neighbours[j-(L*L-L)].extend([j])\n else:\n Neighbours[j].extend([j+L])\n Neighbours[(j+L)].extend([j])\n return Neighbours, Phases, Functionality, Atrium, index","def scoreCirc_CmosVoltageReference(circuit, gen, indi, makeRedundancyInMatrix): #TODO 6.9.2016 napisi cost function ki se sklada z evaluateCmosVoltageRef\n #----------#\n VREF = 1.5\n #----------#\n \n FullBigCircuitMatrix = deepcopy(circuit.fullRedundancyMatrix)\n rowsR,columnsR,columnsC,rowsC = sortedNonZeroIndices(FullBigCircuitMatrix)\n\n matrixDensity = float(len(rowsR))/float((BigMatrixSize*BigMatrixSize/2))\t#(ones/(all/2))\n matrixQuaziID = sum(rowsR)+sum(columnsR)-BigMatrixSize*(BigMatrixSize-1)\n OcSc, IcNc, SelfConnElm = checkConnsConnected(FullBigCircuitMatrix) #Outer connections Short cut, Inner connections Not connected\n \n results = None\n if OcSc > 1:\n score = 1e4*np.exp(OcSc)\n else:\n makeNetlist(circuit, gen, indi, FullBigCircuitMatrix)\n results = runme2.evaluateCmosVoltageRef(gen, indi)\n disfCount = 0\n \n \n #Vdd sweeps on 3 temperatures - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # -20 deg\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\n vdd_sweep_t1 = np.array(results['vout_vdd_temp1']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_t1)):\n disfCount = disfCount + 1\n vdd_s_t1 = 0\n vdd_s_t1_d = 0\n else:\n x = np.median(vdd_sweep_t1)\n vdd_s_t1 = abs(x - VREF) #if x > VREF else 0\n vdd_s_t1_d = np.max(vdd_sweep_t1) - np.min(vdd_sweep_t1)\n \n \n # 25 deg\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\n vdd_sweep_t2 = np.array(results['vout_vdd_temp2']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_t2)):\n disfCount = disfCount + 1\n vdd_s_t2 = 0\n vdd_s_t2_d = 0\n else:\n x = np.median(vdd_sweep_t2)\n vdd_s_t2 = abs(x - VREF) #if x > VREF else 0\n vdd_s_t2_d = np.max(vdd_sweep_t2) - np.min(vdd_sweep_t2) \n \n # 120 deg\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\n vdd_sweep_t3 = np.array(results['vout_vdd_temp3']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_t3)):\n disfCount = disfCount + 1\n vdd_s_t3 = 0\n vdd_s_t3_d = 0\n else:\n x = np.median(vdd_sweep_t3)\n vdd_s_t3 = abs(x - VREF) #if x > VREF else 0\n vdd_s_t3_d = np.max(vdd_sweep_t3) - np.min(vdd_sweep_t3) \n \n #Vdd sweeps on 3 loads - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\n # 10e6 Ohm\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\n vdd_sweep_r1 = np.array(results['vout_vdd_res1']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_r1)):\n disfCount = disfCount + 1\n vdd_s_r1 = 0\n vdd_s_r1_d = 0\n else:\n x = np.median(vdd_sweep_r1)\n vdd_s_r1 = abs(x - VREF) #if x > VREF else 0\n vdd_s_r1_d = np.max(vdd_sweep_r1) - np.min(vdd_sweep_r1)\n \n # 10e4 Ohm\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\n vdd_sweep_r2 = np.array(results['vout_vdd_res2']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_r2)):\n disfCount = disfCount + 1\n vdd_s_r2 = 0\n vdd_s_r2_d = 0\n else:\n x = np.median(vdd_sweep_r2)\n vdd_s_r2 = abs(x - VREF) #if x > VREF else 0\n vdd_s_r2_d = np.max(vdd_sweep_r2) - np.min(vdd_sweep_r2) \n \n # 10e2 Ohm\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\n vdd_sweep_r3 = np.array(results['vout_vdd_res3']['nominal'], dtype=float) #This line changes Nones to np.nans\n # if measurement is empty \n if np.any(np.isnan(vdd_sweep_r3)):\n disfCount = disfCount + 1\n vdd_s_r3 = 0\n vdd_s_r3_d = 0\n else:\n x = np.median(vdd_sweep_r3)\n vdd_s_r3 = abs(x - VREF) #if x > VREF else 0\n vdd_s_r3_d = np.max(vdd_sweep_r3) - np.min(vdd_sweep_r3) \n \n power = results['power']['nominal']\n if np.isnan(np.array(power, dtype=float)):\n disfCount = disfCount + 1\n powe = 0\n else:\n powe = power\n \n #---COST FUNCTION DEFINITION---#\n score = vdd_s_t1 + vdd_s_t1_d + \\\n\t vdd_s_t2 + vdd_s_t2_d + \\\n\t vdd_s_t3 + vdd_s_t3_d + \\\n\t vdd_s_r1 + vdd_s_r1_d + \\\n\t vdd_s_r2 + vdd_s_r2_d + \\\n\t vdd_s_r3 + vdd_s_r3_d + \\\n\t (100*powe)\n\n #print disfCount\n if disfCount > 0:\n score = np.exp(disfCount) * 1e3\n if np.isnan(score):\n score = 2e4\n score = score + (IcNc+1) #add small punishment if not all nodes connected\n\n #print \"\\t\\t\\t\\t\\tG_\" + str(gen) + \"_I_\" + str(indi) + \" SCORE:\", score\n \n filename = \"g_\" + str(gen) + \"_i_\" + str(indi) + \"_subckt.cir\"\n os.remove(filename) #cleanup current subcircuit\n\n return score, matrixDensity, matrixQuaziID, results","def __getitem__(self, ind):\n # This is used to make discrete sampling without replacement memory\n # efficient.\n 1 / 0\n for sub_grid in self.param_grid:\n # XXX: could memoize information used here\n if not sub_grid:\n if ind == 0:\n return {}\n else:\n ind -= 1\n continue\n\n # Reverse so most frequent cycling parameter comes first\n keys, values_lists = zip(*sorted(sub_grid.items())[::-1])\n sizes = [len(v_list) for v_list in values_lists]\n total = np.product(sizes)\n\n if ind >= total:\n # Try the next grid\n ind -= total\n else:\n out = {}\n for key, v_list, n in zip(keys, values_lists, sizes):\n ind, offset = divmod(ind, n)\n out[key] = v_list[offset]\n return out\n\n raise IndexError('ParameterGrid index out of range')","def _index_select_nd(source: torch.Tensor, index: torch.Tensor) -> torch.Tensor:\n index_size = index.size() # (num_atoms/num_bonds, max_num_bonds)\n suffix_dim = source.size()[1:] # (hidden_size,)\n final_size = index_size + suffix_dim # (num_atoms/num_bonds, max_num_bonds, hidden_size)\n\n target = source.index_select(dim=0, index=index.view(\n -1)) # (num_atoms/num_bonds * max_num_bonds, hidden_size)\n target = target.view(\n final_size) # (num_atoms/num_bonds, max_num_bonds, hidden_size)\n\n return target","def lns_sa(self, sol_in, veh_type_in, cost_in):\r\n\r\n itr_cost = []\r\n solu = copy.deepcopy(sol_in)\r\n solu_type = copy.deepcopy(veh_type_in)\r\n best_solu = sol_in\r\n best_val = cost_in\r\n tabu_list = []\r\n random.seed(10)\r\n itr = 0\r\n temp = initial_temp\r\n t_run = time.time()\r\n while temp > stop_temp:\r\n itr += 1\r\n print(itr)\r\n if itr <= 0:\r\n sa_lns = True # use sa or lns\r\n else:\r\n sa_lns = False\r\n c = random.randint(1, store_num - 1) # randomly generated moving customer\r\n while c in tabu_list:\r\n c = random.randint(1, store_num - 1) # randint(a, b), both a and b are selectable\r\n c_loc = cust_loc(solu, c)\r\n\r\n if len(solu[c_loc[0]]) < 4: # customer number less than 2, can only implement shift1 and exchange1 operator\r\n wheel_value1 = random.uniform(0, 1)\r\n if wheel_value1 < 0.45:\r\n self.shift_1_cust(solu, c, c_loc, temp, solu_type, sa_lns)\r\n elif wheel_value1 < 0.9:\r\n self.exchange_1_cust(solu, c, c_loc, temp, solu_type, sa_lns)\r\n else:\r\n self.two_opt(solu, c, c_loc, temp, solu_type, sa_lns)\r\n\r\n # customer number more than 2, can implement all operators\r\n elif len(solu[c_loc[0]]) >= 4 and c_loc[1] <= len(solu[c_loc[0]]) - 3:\r\n wheel_value2 = random.uniform(0, 1)\r\n if wheel_value2 < 0.2:\r\n self.shift_1_cust(solu, c, c_loc, temp, solu_type, sa_lns)\r\n elif wheel_value2 < 0.4:\r\n self.shift_2_cust(solu, c, c_loc, temp, solu_type, sa_lns)\r\n elif wheel_value2 < 0.6:\r\n self.exchange_1_cust(solu, c, c_loc, temp, solu_type, sa_lns)\r\n elif wheel_value2 < 0.8:\r\n self.exchange_2_cust(solu, c, c_loc, temp, solu_type, sa_lns)\r\n else:\r\n self.two_opt(solu, c, c_loc, temp, solu_type, sa_lns)\r\n\r\n\r\n if itr % 100 == 0: # implement two-exchange operator every 200 iteration\r\n self.two_exchange_sol(solu, temp, solu_type, sa_lns)\r\n\r\n\r\n temp -= delta\r\n tabu_list.append(c)\r\n if len(tabu_list) > 100:\r\n tabu_list.pop(0)\r\n\r\n\r\n cost_i = of.print_result(solu, solu_type, False)\r\n # print(solu_type)\r\n itr_cost.append(cost_i)\r\n if cost_i < best_val:\r\n best_solu = solu\r\n best_val = cost_i\r\n\r\n\r\n t_run = time.time()\r\n\r\n # Adjust0: delete [0, 0] routes\r\n adjust_sol0 = []\r\n for route0 in best_solu:\r\n if len(route0) <= 2: # [0, 0] route\r\n continue\r\n else:\r\n adjust_sol0.append(route0)\r\n\r\n # Adjust1: use small vehicle if posiible\r\n adjust_type = []\r\n for route1 in adjust_sol0:\r\n adjust_type.append(route_type(route1))\r\n\r\n\r\n\r\n return adjust_sol0, adjust_type, best_val, itr_cost","def greedy(constraint, indexes, m_l, parallel=False):\n\n selected = np.array([])\n plot = False\n choices = np.array(indexes)\n bar = ChargingBar(\"Calculating index set with greedy method\", max=m_l)\n\n for i in range(len(selected), m_l):\n # print(\"i = %d\" % i)\n start = time.time()\n\n def calc(node):\n return constraint(np.union1d(selected, node))\n\n if parallel:\n pickle_fix.calc = calc\n available_cores = odin.config.get(\"available_cores\", 4)\n pool = multiprocessing.Pool(processes=available_cores)\n values = pool.map(pickle_fix, choices)\n pool.close()\n else:\n # values: [float]\n values = list(map(calc, choices))\n\n greedy_choice = choices[np.argmax(values)]\n\n if plot:\n values = np.sort(values)\n oplt.plot(values)\n oplt.show()\n # current_best = np.max(values)\n\n selected = np.union1d(selected, [greedy_choice])\n choices = np.setdiff1d(choices, [greedy_choice])\n logging.debug(\"selected = %s; choice = %s; time = %.5f\" % (\n selected, greedy_choice, time.time() - start))\n bar.next()\n bar.finish()\n\n return selected","def eg_sk():\n\n rxs = []\n a = []\n b = []\n c = []\n d = []\n e = []\n f = []\n g = []\n h = []\n i = []\n j = []\n\n for _ in range(1000):\n a.append(utils.gaussian(10, 1))\n\n for _ in range(1000):\n b.append(utils.gaussian(10.1, 1))\n\n for _ in range(1000):\n c.append(utils.gaussian(20, 1))\n\n for _ in range(1000):\n d.append(utils.gaussian(30, 1))\n\n for _ in range(1000):\n e.append(utils.gaussian(30.1, 1))\n\n for _ in range(1000):\n f.append(utils.gaussian(10, 1))\n\n for _ in range(1000):\n g.append(utils.gaussian(10, 1))\n\n for _ in range(1000):\n h.append(utils.gaussian(40, 1))\n\n for _ in range(1000):\n i.append(utils.gaussian(40, 3))\n\n for _ in range(1000):\n j.append(utils.gaussian(10, 1))\n\n for k, v in enumerate([a, b, c, d, e, f, g, h, i, j]):\n rxs.append(creation.RX(v, \"rx{}\".format(k)))\n\n for rx in stats.tiles(stats.scottKnot(rxs)):\n print(\"\", rx[\"rank\"], rx[\"name\"], rx[\"show\"], sep=\"\\t\")","def random_element(self):\n from sage.graphs.schnyder import minimal_schnyder_wood\n from sage.graphs.generators.random import RandomTriangulation\n n = self._size\n tri = RandomTriangulation(n + 3)\n TIP = TamariIntervalPosets\n schnyder = minimal_schnyder_wood(tri, root_edge=('a', 'b'),\n check=False)\n return TIP.from_minimal_schnyder_wood(schnyder)","def find_nearest_neighbours_SURF(averageDistance,inst,distanceArray,maxInst): \r\n NN=[]\r\n min_indices=[] \r\n\r\n for j in range(maxInst):\r\n if inst != j:\r\n locator = [inst,j]\r\n locator = sorted(locator, reverse=True) #Access corect half of table (result of removed table redundancy)\r\n d = distanceArray[locator[0]][locator[1]]\r\n if d<averageDistance:\r\n min_indices.append(j)\r\n \r\n for j in range(len(min_indices)):\r\n NN.append(min_indices[j])\r\n \r\n return NN","def get_pulling_indices(self, weight):\n pass","def test_subset_reconstruction_integer(self, wires, snapshots):\n circuit = hadamard_circuit(wires)\n bits, recipes = circuit()\n shadow = ClassicalShadow(bits, recipes)\n\n state = shadow.global_snapshots(snapshots=snapshots)\n assert state.shape == (snapshots, 2**wires, 2**wires)","def ind_sim(n,CV,BV,N,p,d): \n dic={}\n dic2={}\n for i in range(N):\n Bt=random.choices('HL', weights=(p,1-p), k=n)\n pb=[round((1-p), 5) if x=='L' else p for x in Bt] \n Ct=random.choices('HL', weights=(p,1-p), k=n)\n pc=[round((1-p), 5) if x=='L' else p for x in Ct] \n [npvt,pr]=NPV(Bt,Ct,BV,CV,d,np.prod(pb),np.prod(pc))\n if npvt in dic.keys():\n dic[npvt] += 1\n else:\n dic[npvt] = 1\n dic2[npvt] =pr\n return (dic, dic2)","def select(self):\n warnings.filterwarnings(\"ignore\", category=DeprecationWarning)\n\n best_bic_score = float(\"inf\")\n best_model = self.base_model(self.n_constant)\n for n in range(self.min_n_components, self.max_n_components + 1):\n try:\n # bic = - 2*log(likelihood) + p*log(N)\n # N is number of data points\n # p => number of parameters\n # p = initial state occupation probabilities\n # + transition probabilities\n # + emission probabilities\n # initial state occupation probabilities, can be obtained from n,\n # as the probabilities add up to 1.0 => initial state occupation probabilities = n - 1\n # transition probabilities => n*(n - 1)\n # emission probabilities => n * num_features * 2 = num_means + num_covar\n # Hence, p = n - 1 + n*(n - 1) + 2* n * num_features\n # p = n*n + 2*n*num_features - 1\n\n model = self.base_model(n)\n log_likelihood = model.score(self.X, self.lengths)\n num_features = len(self.X[0])\n log_n = math.log(self.X.shape[0])\n\n p = n*n + 2*n*num_features - 1\n bic = -2 * log_likelihood + p * log_n\n if bic < best_bic_score:\n best_bic_score = bic\n best_model = model\n except:\n continue\n\n return best_model","def spark_index(n):\n return int(round((clamp(n) - minimum) * coefficient))","def initialize(N0,L,Nt,pflag):\n qmax,qnet,enet = net.generate(N0,L,Nt)\n N = (N0+Nt)\n #generate initial conditions. all nodes have S,E,C=(1,0,0)\n #except the infected node which has S,E,C=(0.1,0.05,0.05)\n init = np.zeros(3*N)\n for i in range(N):\n init[i] = 1\n #the highest degree node is infected\n infnode = qnet.argmax(axis=0)+1\n init[infnode-1] = 0.1\n init[N+infnode-1] = 0.05\n init[2*N+infnode-1] = 0.05\n if (pflag==True):\n #compute the transport matrix from the degree vector\n #and the adjacency matrix\n A = net.adjacency_matrix(N,enet)\n P = np.zeros([N,N])\n for j in range(N):\n for i in range(N):\n P[i,j] = qnet[i]*A[i,j]\n P[:,j] = P[:,j]/sum(P[:,j])\n return init,infnode,P\n return init,infnode","def screening_graph_estimate(S, lambdaL, p, maxdf, idx_scr, threshold=1e-4, max_iter=10000):\n nlambda = lambdaL.shape[0]\n nscr = idx_scr.shape[0]\n x = np.zeros(p * maxdf * nlambda)\n col_cnz = np.zeros(p + 1).astype(int)\n row_idx = np.zeros(p * maxdf * nlambda).astype(int)\n idx_a = np.zeros(nscr).astype(int)\n w1 = np.zeros(p)\n\n cnz = 0\n for m in range(p):\n idx_i = np.copy(idx_scr[:, m])\n w0 = np.zeros(p)\n size_a = 0\n\n for i in range(nlambda):\n ilambda = lambdaL[i]\n gap_ext = 1\n iter_ext = 0\n while gap_ext > 0 and iter_ext < max_iter:\n size_a_prev = size_a\n for j in range(nscr):\n w_idx = idx_i[j]\n if w_idx != -1:\n r = S[m, w_idx]\n for k in range(size_a):\n rss_idx = idx_a[k]\n r -= S[w_idx, rss_idx] * w0[rss_idx]\n\n if abs(r) > ilambda:\n if r >= 0:\n w1[w_idx] = r - ilambda\n else:\n w1[w_idx] = r + ilambda\n idx_a[size_a] = w_idx\n size_a += 1\n idx_i[j] = -1\n else:\n w1[w_idx] = 0\n w0[w_idx] = w1[w_idx]\n\n gap_ext = size_a - size_a_prev\n\n gap_int = 1\n iter_int = 0\n while gap_int > threshold and iter_int < max_iter:\n tmp1 = 0\n tmp2 = 1e-4\n for j in range(size_a):\n w_idx = idx_a[j]\n r = S[m, w_idx] + w0[w_idx]\n\n for k in range(size_a):\n rss_idx = idx_a[k]\n r -= S[w_idx, rss_idx] * w0[rss_idx]\n\n if abs(r) > ilambda:\n if r >= 0:\n w1[w_idx] = r - ilambda\n else:\n w1[w_idx] = r + ilambda\n tmp2 += abs(w1[w_idx])\n else:\n w1[w_idx] = 0\n tmp1 += abs(w1[w_idx] - w0[w_idx])\n w0[w_idx] = w1[w_idx]\n gap_int = tmp1 / tmp2\n iter_int += 1\n iter_ext += 1\n\n for j in range(size_a):\n w_idx = idx_a[j]\n x[cnz] = w1[w_idx]\n row_idx[cnz] = i * p + w_idx\n cnz += 1\n col_cnz[m + 1] = cnz\n\n return col_cnz, row_idx, x","def pick_next(self, STATUS, N=100, nysamples=100):\n untested = [i for i in range(self.n) if STATUS[i] == 0]\n if self.acquisition_function == 'Thompson':\n alpha = self.samples()\n \n elif self.acquisition_function == 'Greedy_N':\n y_samples = self.samples(nysamples)\n alpha = np.zeros(self.n)\n for j in range(nysamples):\n # count number of times each point is in the top N for a sample \n alpha[np.argpartition(y_samples[:, j], -N)[-N:]] += 1\n \n elif self.acquisition_function == 'Greedy_tau':\n if np.mod(self.estimate_tau_counter, self.tau_update) == 0:\n self.estimate_tau()\n self.estimate_tau_counter += 1\n else:\n self.estimate_tau_counter += 1\n mu_X_pos, var_X_pos = self.predict()\n alpha = 1-norm.cdf(np.divide(self.tau-mu_X_pos,var_X_pos**0.5))\n \n elif self.acquisition_function == 'EI':\n mu_X_pos, var_X_pos = self.predict()\n sig_X_pos = var_X_pos**0.5\n alpha = (mu_X_pos-self.y_max)*norm.cdf(np.divide(mu_X_pos-self.y_max,sig_X_pos))+sig_X_pos*norm.pdf(np.divide(mu_X_pos-self.y_max,sig_X_pos))\n \n else:\n # if no valid acquisition_function entered then pick at random \n alpha = np.random.rand(self.n)\n print('enter a valid acquisition function - picking randomly')\n ipick = untested[np.argmax(alpha[untested])]\n return ipick","def selectedRvs(self, discardedElems):\n if not self.memory:\n self.raiseAnError(IOError,' The distribution '+ str(self.name) + ' does not support the method selectedRVS.')\n else:\n rvsValue = self.selectedPpf(random(),discardedElems)\n return rvsValue","def getWINDNMRdefault(n):\n # The list of spinsystems begins with empty tuples. This allows intuitive\n # access to a particular spin system. So, spinsystem[4] is the data for the\n # 4-spin system.\"\"\"\n spinsystem = [(), (), spin2(), spin3(), spin4(), spin5(), spin6(), spin7(),\n spin8()]\n\n # Changes to the tkinter GUI require frequency to be a (0,n) 2D array,\n # and J to be an array and not a sparse matrix.\n freq, J = spinsystem[n]\n freq2D = np.array([freq]) # converts to 2D array\n J = J.todense()\n\n return freq2D, J","def __init__(self, neuron_count):\n # The current state of the thermal network.\n self.current_state = [0.0] * neuron_count\n\n # The weights.\n self.weights = np.zeros( [neuron_count*neuron_count] )\n\n # The neuron count.\n self.neuron_count = neuron_count","def __optimize_configuration(self):\r\n index_neighbor = 0\r\n counter = 0\r\n while (index_neighbor < self.__maxneighbor):\r\n # get random current medoid that is to be replaced\r\n current_medoid_index = self.__current[random.randint(0, self.__number_clusters - 1)]\r\n current_medoid_cluster_index = self.__belong[current_medoid_index]\r\n\r\n # get new candidate to be medoid\r\n candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)\r\n\r\n while candidate_medoid_index in self.__current:\r\n candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)\r\n\r\n candidate_cost = 0.0\r\n for point_index in range(0, len(self.__pointer_data)):\r\n if point_index not in self.__current:\r\n # get non-medoid point and its medoid\r\n point_cluster_index = self.__belong[point_index]\r\n point_medoid_index = self.__current[point_cluster_index]\r\n\r\n # get other medoid that is nearest to the point (except current and candidate)\r\n other_medoid_index = self.__find_another_nearest_medoid(point_index, current_medoid_index)\r\n other_medoid_cluster_index = self.__belong[other_medoid_index]\r\n\r\n # for optimization calculate all required distances\r\n # from the point to current medoid\r\n distance_current = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])\r\n\r\n # from the point to candidate median\r\n distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[candidate_medoid_index])\r\n\r\n # from the point to nearest (own) medoid\r\n distance_nearest = float('inf')\r\n if ( (point_medoid_index != candidate_medoid_index) and (point_medoid_index != current_medoid_cluster_index) ):\r\n distance_nearest = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[point_medoid_index])\r\n\r\n # apply rules for cost calculation\r\n if (point_cluster_index == current_medoid_cluster_index):\r\n # case 1:\r\n if (distance_candidate >= distance_nearest):\r\n candidate_cost += distance_nearest - distance_current\r\n\r\n # case 2:\r\n else:\r\n candidate_cost += distance_candidate - distance_current\r\n\r\n elif (point_cluster_index == other_medoid_cluster_index):\r\n # case 3 ('nearest medoid' is the representative object of that cluster and object is more similar to 'nearest' than to 'candidate'):\r\n if (distance_candidate > distance_nearest):\r\n pass;\r\n\r\n # case 4:\r\n else:\r\n candidate_cost += distance_candidate - distance_nearest\r\n\r\n if (candidate_cost < 0):\r\n counter+=1\r\n # set candidate that has won\r\n self.__current[current_medoid_cluster_index] = candidate_medoid_index\r\n\r\n # recalculate clusters\r\n self.__update_clusters(self.__current)\r\n\r\n # reset iterations and starts investigation from the begining\r\n index_neighbor = 0\r\n\r\n else:\r\n\r\n index_neighbor += 1\r\n\r\n print(\"Medoid set changed {0} times\".format(counter))","def sample_from(self, weights):\n total = sum(weights)\n rnd = total * random.random() # uniform between 0 and total\n for i, w in enumerate(weights):\n rnd -= w # return the smallest i such that\n if rnd <= 0:\n return i # weights[0] + ... + weights[i] >= rnd","def get_selected_subsamples(sample_func, clusters, trajs_dict, visit_profile, Nsample, false_rate=80):\n print('The desired false rate is %f'%(false_rate/Nsample))\n crter = 0\n done_first_round = False\n nclusters = len(clusters)\n \n print('Start the first selection until the number of potential profiles is more than Nsample')\n while crter < Nsample:\n i = np.random.choice(range(nclusters))\n if len(clusters[i]) > Nsample*5 or len(clusters[i]) < Nsample: continue\n # try sampling\n selected_spl, plist_spl = sample_func(trajs_dict, plist=None, usrs=clusters[i])\n # do the deterministic attack\n a2 = get_trick_mat(clusters[i] , selected_spl, visit_profile)\n nonzero_list = [np.sum(np.count_nonzero(ai))>=1 for ai in make_sym_mat(a2)] \n crter = np.sum(nonzero_list)\n \n print('Finish the first round selection, %d candidates are selected from cluster %d'%(crter, i))\n round_one_usrs = np.array(clusters[i])[nonzero_list]\n \n crter2 = 0; len_rone = len(round_one_usrs)\n print('Start the second selection until false rate %f'%(false_rate/Nsample))\n while crter2 < false_rate:\n final_selected_usrs = round_one_usrs[np.random.choice(len_rone, Nsample, replace=False)]\n tmp = get_trick_mat(final_selected_usrs, selected_spl, visit_profile)\n crter2 = np.sum([np.sum(np.count_nonzero(ai))>=1 for ai in make_sym_mat(tmp)])\n print('Final false rate for deterministic attack%f'%(crter2/Nsample))\n return selected_spl, final_selected_usrs, plist_spl","def randomSelection(self):\n indA = self.matingPool[ random.randint(0, self.popSize-1) ]\n indB = self.matingPool[ random.randint(0, self.popSize-1) ]\n return [indA, indB]","def select_action(self, env, state, **kwargs):\n\n self.epsilon = 1 - (len(self.memory.memory)*1.0)/self.memory.max_size + 0.05\n if np.random.uniform() <= self.epsilon:\n index = env.action_space.sample()\n else:\n index = np.argmax(self.Q.predict(state))\n\n return index","def selectedRvs(self,discardedElems):\n if self.nPoints is None:\n self.xArray = np.arange(self.lowerBound,self.upperBound+1)\n else:\n self.xArray = np.linspace(self.lowerBound,self.upperBound,self.nPoints)\n\n self.xArray = np.setdiff1d(self.xArray,discardedElems)\n\n self.pdfArray = 1/self.xArray.size * np.ones(self.xArray.size)\n paramsDict={}\n paramsDict['outcome'] = self.xArray\n paramsDict['state'] = self.pdfArray\n paramsDict['strategy'] = self.strategy\n\n self.tempUniformDiscrete = UniformDiscrete()\n self.tempUniformDiscrete.initializeFromDict(paramsDict)\n\n rvsValue = self.tempUniformDiscrete.rvs()\n return rvsValue","def init_solution(weight_cost,max_weight):\r\n solution = [] #empty list\r\n allowed_positions = list(range (len(weight_cost))) # (0,10)\r\n while len(allowed_positions)>0:\r\n idx = random.randint(0,len(allowed_positions)-1) # any random number between 0 to 9\r\n selected_position = allowed_positions.pop(idx)\r\n if get_cost_and_weight_of_knapsack(solution + [selected_position],weight_cost)[1] <= max_weight:\r\n solution.append(selected_position)\r\n else:\r\n break\r\n return solution","def __optimize_configuration(self):\n index_neighbor = 0\n counter = 0\n while index_neighbor < self.__maxneighbor:\n # get random current medoid that is to be replaced\n current_medoid_index = self.__current[\n random.randint(0, self.__number_clusters - 1)\n ]\n current_medoid_cluster_index = self.__belong[current_medoid_index]\n\n # get new candidate to be medoid\n candidate_medoid_index = random.randint(\n 0, len(self.__pointer_data) - 1\n )\n\n while candidate_medoid_index in self.__current:\n candidate_medoid_index = random.randint(\n 0, len(self.__pointer_data) - 1\n )\n\n candidate_cost = 0.0\n for point_index in range(0, len(self.__pointer_data)):\n if point_index not in self.__current:\n # get non-medoid point and its medoid\n point_cluster_index = self.__belong[point_index]\n point_medoid_index = self.__current[point_cluster_index]\n\n # get other medoid that is nearest to the point (except current and candidate)\n other_medoid_index = self.__find_another_nearest_medoid(\n point_index, current_medoid_index\n )\n other_medoid_cluster_index = self.__belong[\n other_medoid_index\n ]\n\n # for optimization calculate all required distances\n # from the point to current medoid\n distance_current = euclidean_distance_square(\n self.__pointer_data[point_index],\n self.__pointer_data[current_medoid_index],\n )\n\n # from the point to candidate median\n distance_candidate = euclidean_distance_square(\n self.__pointer_data[point_index],\n self.__pointer_data[candidate_medoid_index],\n )\n\n # from the point to nearest (own) medoid\n distance_nearest = float(\"inf\")\n if (point_medoid_index != candidate_medoid_index) and (\n point_medoid_index != current_medoid_cluster_index\n ):\n distance_nearest = euclidean_distance_square(\n self.__pointer_data[point_index],\n self.__pointer_data[point_medoid_index],\n )\n\n # apply rules for cost calculation\n if point_cluster_index == current_medoid_cluster_index:\n # case 1:\n if distance_candidate >= distance_nearest:\n candidate_cost += (\n distance_nearest - distance_current\n )\n\n # case 2:\n else:\n candidate_cost += (\n distance_candidate - distance_current\n )\n\n elif point_cluster_index == other_medoid_cluster_index:\n # case 3 ('nearest medoid' is the representative object of that cluster and object is more\n # similar to 'nearest' than to 'candidate'):\n if distance_candidate > distance_nearest:\n pass\n\n # case 4:\n else:\n candidate_cost += (\n distance_candidate - distance_nearest\n )\n\n if candidate_cost < 0:\n counter += 1\n # set candidate that has won\n self.__current[\n current_medoid_cluster_index\n ] = candidate_medoid_index\n\n # recalculate clusters\n self.__update_clusters(self.__current)\n\n # reset iterations and starts investigation from the begining\n index_neighbor = 0\n\n else:\n\n index_neighbor += 1\n\n print(\"Medoid set changed {0} times\".format(counter))","def greedy_initial(self):\r\n sol = [] # [[0;2;5;0;4;6;0],[],...]\r\n sol_veh_type = [] # corresponding vehicle type for the solution\r\n route_way_time = []\r\n\r\n to_vist = [i+1 for i in range(store_num - 1)] # [1,5,8,...]\r\n itr = 0\r\n\r\n while len(to_vist) > 0 and itr < 500:\r\n itr += 1\r\n\r\n if itr <= small_veh_cnt:\r\n vehicle_type0 = 2\r\n elif itr <= small_veh_cnt + medium_veh_cnt:\r\n vehicle_type0 = 3\r\n else:\r\n vehicle_type0 = 5\r\n\r\n sol_veh_type.append(vehicle_type0)\r\n\r\n used_res = [0, 0, 0, 0] # used volume, and travel time of the vehicle, leave time, travel distance\r\n veh_rout = [0]\r\n\r\n # print '\\nA new vehicle will be used.'\r\n way_time = 0 # travel time of coming to the store + wait time at the store + operation time at this store\r\n while True:\r\n curr_cust = veh_rout[-1]\r\n\r\n next_one, way_time = self.time_nn(way_time, curr_cust, to_vist, used_res, len(veh_rout), vehicle_type0)\r\n next_cust, next_start = next_one[0], next_one[1]\r\n # print('next start', next_cust, next_start)\r\n if next_cust == 0: # next visiting customer is depot\r\n # print 'Get back to the depot, and ready for a new round.'\r\n veh_rout.append(next_cust)\r\n break\r\n\r\n else: # next visiting customer is a store\r\n used_res[0] += (num_demd[next_cust][0] * bskt_vol + num_demd[next_cust][1] * trsf_vol + (num_demd[next_cust][2] + \\\r\n num_demd[next_cust][3]) * milk_vol + num_demd[next_cust][4] * paper_bskt)\r\n used_res[2] = (next_start + oprt_t)\r\n used_res[3] += dist_mat[curr_cust, next_cust]\r\n\r\n\r\n veh_rout.append(next_cust)\r\n # print 'Vehicle used resource: ', used_res\r\n to_vist.remove(next_cust)\r\n\r\n sol.append(veh_rout)\r\n route_way_time.append(way_time)\r\n\r\n # print 'Last point 0 earliest leave time: ', int(used_res[-1]) / 60, ':', int(used_res[-1]) % 60\r\n # print 'Route %s is: ' % itr, veh_rout\r\n print('*'*10, 'Iteration:', itr, '*'*10)\r\n\r\n\r\n if len(to_vist) > 0:\r\n print('number of stores remained: ', len(to_vist))\r\n\r\n return sol, sol_veh_type, route_way_time","def sample_from_ibp(K, alpha, sigma, c):\n pp = poissonparams(K, alpha, sigma, c)\n new_nodes = np.random.poisson(pp)\n Ncols = new_nodes.sum()\n node_count = np.zeros(Ncols)\n\n # used to build sparse matrix, entries of each Zij=1\n colidx = [] \n rowidx = []\n rightmost_node = 0\n\n # for each clique\n for n in range(K):\n # revisit each previously seen node\n for k in range(rightmost_node):\n prob_repeat = (node_count[k] - sigma) / (n + c)\n r = np.random.rand()\n if r < prob_repeat:\n rowidx.append(n)\n colidx.append(k)\n node_count[k] += 1\n\n for k in range(rightmost_node, rightmost_node + new_nodes[n]):\n rowidx.append(n)\n colidx.append(k)\n node_count[k] += 1\n \n rightmost_node += new_nodes[n]\n\n # build sparse matrix\n data = np.ones(len(rowidx), int)\n shape = (K, Ncols)\n Z = csr_matrix((data, (rowidx, colidx)), shape)\n\n return Z","def mk_sen_circuit_plastic(task_info):\n # load params from task_info\n N_E = task_info['sen']['N_E'] # number of exc neurons (1600)\n N_I = task_info['sen']['N_I'] # number of inh neurons (400)\n N_X = task_info['sen']['N_X'] # size of external population\n sub = task_info['sen']['sub'] # fraction of stim-selective exc neurons\n N_E1 = int(N_E * sub) # size of exc sub-pop 1, 2\n num_method = task_info['sim']['num_method']\n\n # define namespace\n paramplastic = params.get_plasticity_params(task_info)\n tau_update = paramplastic['tau_update']\n\n # equations\n if task_info['sim']['online_stim']:\n eqs_soma_plastic = nm.eqs_naud_soma + nm.eqs_stim_linked\n paramstim = params.get_stim_params(task_info)\n paramplastic = {**paramplastic, **paramstim}\n else:\n eqs_soma_plastic = nm.eqs_naud_soma + nm.eqs_stim_array\n\n # neuron groups\n eqs_dend_plastic = nm.eqs_naud_dend + nm.eqs_plasticity\n senE = NeuronGroup(N_E, model=eqs_soma_plastic, method=num_method, threshold='V>=Vt',\n reset='''V = Vl\n w_s += bws''',\n refractory='tau_refE', namespace=paramplastic, name='senE')\n dend = NeuronGroup(N_E, model=eqs_dend_plastic, method=num_method, threshold='burst_start > 1 + min_burst_stop',\n reset='''B += 1\n burst_start = 0''',\n refractory='burst_stop >= min_burst_stop', namespace=paramplastic, name='dend')\n senI = NeuronGroup(N_I, model=nm.eqs_wimmer_inh, method=num_method, threshold='V>=Vt', reset='V=Vr',\n refractory='tau_refI', namespace=paramplastic, name='senI')\n extS = PoissonGroup(N_X, rates='nu_ext', namespace=paramplastic)\n\n # subgroups\n senE1 = senE[:N_E1]\n senE2 = senE[N_E1:]\n dend1 = dend[:N_E1]\n dend2 = dend[N_E1:]\n\n # linked variables\n senE.V_d = linked_var(dend, 'V_d')\n dend.lastspike_soma = linked_var(senE, 'lastspike')\n\n # soma-dendrite synapse\n syn_burst_trace = Synapses(senE, dend, method=num_method, on_pre='''burst_start +=1\n burst_stop = 1''',\n namespace=paramplastic, name='syn_burst_trace')\n syn_burst_trace.connect(j='i')\n\n # stim\n if task_info['sim']['online_stim']:\n stim_dt = paramstim['stim_dt']\n stim_common = NeuronGroup(2, model=nm.eqs_stim_common, method=num_method,\n dt=stim_dt, namespace=paramstim, name='stim_common')\n stimE = NeuronGroup(N_E, model=nm.eqs_stim_online, method=num_method,\n dt=stim_dt, namespace=paramstim, name='stimE')\n stimE1 = stimE[:N_E1]\n stimE2 = stimE[N_E1:]\n stimE.z = linked_var(stim_common, 'z', index=np.hstack((np.zeros(N_E1, dtype=int), np.ones(N_E1, dtype=int))))\n stimE1.mu = paramstim['mu1']\n stimE2.mu = paramstim['mu2']\n senE.I = linked_var(stimE, 'I')\n\n # update rule\n dend1.muOUd = 0*amp #'-95*pA - rand()*10*pA' # random initialisation in [-105:-95 pA], 0*amp\n dend1.run_regularly('muOUd = clip(muOUd - eta * (B - B0), -100*amp, 0)', dt=tau_update)\n\n # connections\n sen_synapses = mk_sen_synapses(task_info, senE, senI, extS, paramplastic)\n extD1, synDXdend1 = mk_poisson_fb(task_info, dend1)\n\n # variables to return\n groups = {'SE': senE, 'dend': dend, 'SI': senI, 'SX': extS, 'DX': extD1}\n subgroups = {'SE1': senE1, 'SE2': senE2,\n 'dend1': dend1, 'dend2': dend2}\n synapses = {**sen_synapses, **{'synDXdend': synDXdend1, 'syn_burst_trace': syn_burst_trace}}\n\n if task_info['sim']['online_stim']:\n groups = {**groups, **{'stim_common': stim_common, 'stimE': stimE}}\n\n return groups, synapses, subgroups","def __getitem__(self, ind):\n # This is used to make discrete sampling without replacement memory\n # efficient.\n for sub_grid in self.param_grid:\n # XXX: could memoize information used here\n if not sub_grid:\n if ind == 0:\n return {}\n else:\n ind -= 1\n continue\n\n # Reverse so most frequent cycling parameter comes first\n keys, values_lists = zip(*sorted(sub_grid.items())[::-1])\n sizes = [len(v_list) for v_list in values_lists]\n total = np.product(sizes)\n\n if ind >= total:\n # Try the next grid\n ind -= total\n else:\n out = {}\n for key, v_list, n in zip(keys, values_lists, sizes):\n ind, offset = divmod(ind, n)\n out[key] = v_list[offset]\n return out\n\n raise IndexError('ParameterGrid index out of range')","def test_indices(self, circuit):\n gate = jet.GateFactory.create(\"H\")\n circuit.append_gate(gate, wire_ids=[0])\n assert list(circuit.indices([0])) == [\"0-1\"]\n assert list(circuit.indices([1, 2, 3])) == [\"1-0\", \"2-0\", \"3-0\"]","def main(edges=[(0, 1, 3), (1, 3, 4), (2, 3, 3), (0, 2, 2) ], num=4):\n\n # initialize routers array\n routers = []\n for x in range(num):\n routers.append([1000] * num)\n routers[x][x] = 0\n \n # set distance to all neighbours \n for edge in edges:\n routers[edge[0]][edge[1]] = edge[2]\n routers[edge[1]][edge[0]] = edge[2]\n\n start_table = routers.copy()\n\n flag = True\n while flag:\n upflag = False\n for nbrs in edges:\n routers[nbrs[0]], up_flag1 = update_table(routers[nbrs[0]], routers[nbrs[1]], dist=nbrs[2])\n routers[nbrs[1]], up_flag2 = update_table(routers[nbrs[1]], routers[nbrs[0]], dist=nbrs[2])\n upflag = upflag or up_flag1 or up_flag2\n\n flag = upflag\n\n return start_table, routers","def main():\n G = nx.gnp_random_graph(100, 0.5)\n centrality = nx.eigenvector_centrality(G)\n avg_centrality = sum(centrality.values()) / len(G)\n\n def has_high_centrality(v):\n return centrality[v] >= avg_centrality\n\n source = 0\n value = centrality.get\n condition = has_high_centrality\n\n found_node = progressive_widening_search(G, source, value, condition)\n c = centrality[found_node]\n print('found node {0} with centrality {1}'.format(found_node, c))","def get_weight_development_random_sample(synapses, n_synapses):\n n_epochs, n_possible_synapses = synapses.shape\n rand_indices = np.random.choice(n_possible_synapses, size=(n_synapses,), replace=False)\n return synapses[:, rand_indices]","def multi_velo_inspec(self, n = 60, lat0 = 60, lat1 = 90, pole = \"north\"):\n inds = self.mlat_finder(lat1, lat0, pole)[1]\n NeA = self.NeA[inds]\n NeB = self.NeB[inds]\n NeC = self.NeC[inds]\n\n secondsA = self.secondsA[inds]\n secondsB = self.secondsB[inds]\n secondsC = self.secondsC[inds]\n\n\n mlatA = self.mlatA[inds]\n mlatB = self.mlatB[inds]\n mlatC = self.mlatC[inds]\n\n mean_range = 5\n NeA = self.meanie(NeA, mean_range)\n NeB = self.meanie(NeB, mean_range)\n NeC = self.meanie(NeC, mean_range)\n \n \n N = int((len(NeA)/n*2) - 1) #nr of windows\n \n dx = (secondsB[1]-secondsB[0])*self.velB[0]\n \n nBAs = []\n nBCs = []\n nACs = []\n \n for i in range(N):\n startind = int(i/2*n)\n stopind = int((i/2+1)*n)\n temp_NeA = NeA[startind:stopind]\n temp_NeB = NeB[startind:stopind]\n temp_NeC = NeC[startind:stopind]\n \n temp_secondsA = secondsA[startind:stopind]\n temp_secondsB = secondsB[startind:stopind]\n temp_secondsC = secondsC[startind:stopind]\n \n \n curr_timediff = np.round((temp_secondsB[1:] - temp_secondsB[:-1])-(1/self.fs))\n if np.sum(curr_timediff) > 2:\n continue\n \n gradA = (temp_NeA[1:] - temp_NeA[:-1])/dx\n gradB = (temp_NeB[1:] - temp_NeB[:-1])/dx\n gradC = (temp_NeC[1:] - temp_NeC[:-1])/dx\n \n if np.max(gradA) < 0.9:\n continue\n \n stdA = np.std(gradA)\n stdB = np.std(gradB)\n stdC = np.std(gradC)\n \n meanA = temp_secondsB[np.where(gradA == np.max(gradA))][0]\n meanB = temp_secondsB[np.where(gradB == np.max(gradB))][0]\n meanC = temp_secondsB[np.where(gradC == np.max(gradC))][0]\n \n p0A = [1, meanA, stdA]\n p0B = [1, meanB, stdB]\n p0C = [1, meanB, stdB]\n \n poptA, pcovA = curve_fit(self.gaussian, temp_secondsB[:-1], gradA, p0 = p0A)\n poptB, pcovB = curve_fit(self.gaussian, temp_secondsB[:-1], gradB, p0 = p0B)\n poptC, pcovC = curve_fit(self.gaussian, temp_secondsB[:-1], gradC, p0 = p0C)\n \n nBA = poptB[1] - poptA[1]\n nBC = poptB[1] - poptC[1]\n nAC = poptA[1] - poptC[1]\n \n nBAs.append(nBA)\n nBCs.append(nBC)\n nACs.append(nAC)\n \n \n sBA = self.BA_shift/2 #time delay BA\n sBC = self.BC_shift/2 #time delay BC\n sAC = (self.BC_shift - self.BA_shift)/2\n V = self.velA[0]\n for i in range(len(nBAs)):\n VBA = self.along_track_velo(V, sBA, nBAs[i])\n VBC = self.along_track_velo(V, sBC, nBCs[i])\n VAC = self.along_track_velo(V, sAC, nACs[i])\n \n print(VBA)\n print(VBC)\n print(VAC)\n print(\"________________________________________\")","def up_sampling(stl_vertices_list, num_of_new_vertices):\n temp_stl_vertices_list = copy.deepcopy(stl_vertices_list)\n for i in range(num_of_new_vertices):\n rand_index = random.randint(0, len(temp_stl_vertices_list) - 1)\n rand_vertex = temp_stl_vertices_list.pop(rand_index)\n index_list = [j for j in range(len(temp_stl_vertices_list))]\n\n distance_of_rand_vertex_to_rest_vertices = euclidean_distance(rand_vertex, temp_stl_vertices_list)\n temp_dict = dict(zip(distance_of_rand_vertex_to_rest_vertices, index_list))\n nearest_index = temp_dict[np.min(distance_of_rand_vertex_to_rest_vertices)]\n nearest_vertex = temp_stl_vertices_list[nearest_index]\n middle_vertex = list(np.average((np.array(rand_vertex), np.array(nearest_vertex)), axis=0))\n stl_vertices_list.append(middle_vertex)\n\n return stl_vertices_list","def _pick_network(self, network_type, count):\n possible_networks = self.config[\"networks\"][network_type]\n networks = [self._provider.get_network(net) for net in possible_networks]\n usable = []\n for network in networks:\n ips = self._provider.get_ips(ref=network.get(\"id\"))\n available = ips[\"total_ips\"] - ips[\"used_ips\"]\n if available > count:\n usable.append((network[\"name\"], available))\n\n if not usable:\n logger.error(\n f\"{self.dsp_name}: Error: no usable network\"\n f\" for {count} hosts with {network_type}\"\n )\n return None\n\n # sort networks by number of available IPs\n usable = sorted(usable, key=lambda u: u[1])\n logger.debug(f\"{self.dsp_name}: Listing usable networks: {usable}\")\n res_network = usable[-1][0]\n logger.debug(\n f\"{self.dsp_name}: Picking network \"\n f\"with the most available adresses: {res_network}\"\n )\n return res_network # Pick the one with most IPs","def determine_offer_tuple_NN(nn, ti, ca, eps, eps_ran, revenues, A, arrival_probabilities, preference_weights, no_purchase_preference):\n\n\n # opportunity costs\n opp_costs = 1.0*np.zeros_like(revenues)\n for pro in products:\n if functools.reduce(operator.or_, ca - A[:, pro] < 0):\n # set opp costs to infty if not enough capacity for product\n opp_costs[pro] = np.inf\n else:\n # calculate opportunity costs via Bellman: V(t+1, c) - V(t+1, c-A[i])\n t_df = pd.DataFrame([np.zeros(T + 1)] * 1)\n t_df.columns = [\"t\" + str(i) for i in t_df.columns]\n t_df.iloc[0, ti+1] = 1\n\n cs_unsold = {}\n for h in resources:\n c_df = pd.DataFrame([np.zeros(T +1)] * 1)\n c_df.columns = [\"c-h\" + str(h) + \"-t\" + str(i) for i in c_df.columns]\n c_df.iloc[0, ti+1] = ca[h]\n cs_unsold[h] = c_df\n\n cs_sold = {}\n for h in resources:\n c_df = pd.DataFrame([np.zeros(T + 1)] * 1)\n c_df.columns = [\"c-h\" + str(h) + \"-t\" + str(i) for i in c_df.columns]\n c_df.iloc[0, ti + 1] = ca[h] - A[h, pro]\n cs_sold[h] = c_df\n\n X_unsold = pd.concat([t_df, *[cs_unsold[h] for h in resources]], axis=1)\n X_sold = pd.concat([t_df, *[cs_sold[h] for h in resources]], axis=1)\n\n opp_costs[pro] = nn.predict(X_unsold) - nn.predict(X_sold)\n\n # epsilon greedy strategy - offer no products\n if eps_ran < eps / 2:\n return tuple(np.zeros_like(revenues))\n\n # epsilon greedy strategy - offer all products\n if eps_ran < eps:\n offer_tuple = np.ones_like(revenues)\n offer_tuple[opp_costs == np.inf] = 0 # one resource not available => don't offer product\n return tuple(offer_tuple)\n\n # setup\n offer_tuple = np.zeros_like(revenues)\n\n # line 1\n s_prime = revenues - opp_costs > 0\n if all(np.invert(s_prime)):\n return tuple(offer_tuple)\n\n # line 2-3\n # offer_sets_to_test has in each row an offer set, we want to test\n offer_sets_to_test = np.zeros((sum(s_prime), len(revenues)))\n offer_sets_to_test[np.arange(sum(s_prime)), np.where(s_prime)] = 1\n offer_sets_to_test += offer_tuple\n offer_sets_to_test = (offer_sets_to_test > 0)\n\n value_marginal = np.apply_along_axis(calc_value_marginal_nn, 1, offer_sets_to_test, opp_costs, revenues,\n arrival_probabilities, preference_weights, no_purchase_preference)\n\n offer_tuple = offer_sets_to_test[np.argmax(value_marginal)]*1\n s_prime = s_prime & offer_tuple == 0\n v_s = np.amax(value_marginal)\n\n # line 4\n while True:\n # 4a\n # offer_sets_to_test has in each row an offer set, we want to test\n offer_sets_to_test = np.zeros((sum(s_prime), len(revenues)))\n offer_sets_to_test[np.arange(sum(s_prime)), np.where(s_prime)] = 1\n offer_sets_to_test += offer_tuple\n offer_sets_to_test = (offer_sets_to_test > 0)\n\n # 4b\n value_marginal = np.apply_along_axis(calc_value_marginal_nn, 1, offer_sets_to_test, opp_costs, revenues,\n arrival_probabilities, preference_weights, no_purchase_preference)\n\n if np.amax(value_marginal) >= v_s:\n v_s = np.amax(value_marginal)\n offer_tuple = offer_sets_to_test[np.argmax(value_marginal)]*1 # to get 1 for product offered\n s_prime = (s_prime - offer_tuple) == 1 # only those products remain, that are neither in the offer_tuple\n if all(offer_tuple == 1):\n break\n else:\n break\n return tuple(offer_tuple)","def _selected_indices(self, subset):\n # We want the DataFrame to be indexed the same way its values array is\n ftr = self.frametracks.reset_index(drop=True)\n if subset is not None:\n ftr['tmpindex'] = ftr.index.values\n ftr = ftr.set_index('particle').reindex(subset).set_index('tmpindex')\n if self.autoclip:\n # Boundaries are computed for the whole system\n xmin = self.frametracks.x.min() + self.nncutoff\n xmax = self.frametracks.x.max() - self.nncutoff\n ymin = self.frametracks.y.min() + self.nncutoff\n ymax = self.frametracks.y.max() - self.nncutoff\n r = ftr.index[ (ftr.x > xmin) & (ftr.x < xmax) & \\\n (ftr.y > ymin) & (ftr.y < ymax) ].values.astype(int)\n else:\n r = ftr.index.values.astype(int)\n if self.fast:\n return np.random.permutation(r)[:int(len(r) / 10)]\n else:\n return r","def get_sensor_bool_dryspot_runlevel(self, filename, threshold_min_counted_dryspots=5):\n f = h5py.File(filename, \"r\")\n meta_file = h5py.File(str(filename).replace(\"RESULT.erfh5\", \"meta_data.hdf5\"), 'r')\n\n try:\n single_states, set_of_states, useless_states = self.__get_dryspot_data(f, meta_file)\n multi_states = self.__get_pressure_data(f)\n multi_states = multi_states.squeeze()\n\n activated_sensors = np.count_nonzero(multi_states, axis=1)\n percentage_of_all_sensors = activated_sensors / 1140\n len_wanted_seq = 100\n current = 0\n sequence = np.zeros((len_wanted_seq, self.num_sensors))\n frame_labels = []\n\n if self.aux_info:\n original_frame_idxs = np.full(len_wanted_seq, np.nan, np.int16)\n frame_labels_aux = np.full(len_wanted_seq, np.nan, np.int8)\n sample_percentages = np.full(len_wanted_seq, np.nan)\n single_state_indices = np.full(len_wanted_seq, np.nan, np.int16)\n # flowfronts = np.zeros((len_wanted_seq, self.image_size[0], self.image_size[1]))\n # _coords, flat_fillings = self.__get_filling_data(f, single_states)\n\n for i, sample in enumerate(single_states):\n state_num = int(str(sample).replace(\"state\", \"0\"))\n try:\n sample_percentage = percentage_of_all_sensors[state_num - 1]\n if sample_percentage >= current / len_wanted_seq:\n data = multi_states[state_num - 1, :]\n data = np.log(np.add(data, 1)) # TODO make log optional\n if self.sensor_indizes != ((0, 1), (0, 1)):\n rect = data.reshape(38, 30)\n sel = rect[self.sensor_indizes[0][0]::self.sensor_indizes[0][1],\n self.sensor_indizes[1][0]::self.sensor_indizes[1][1]]\n data = sel.flatten()\n sequence[current, :] = data\n\n frame_label = 0\n if state_num in set_of_states:\n frame_label = 1\n frame_labels.append(frame_label)\n\n if self.aux_info:\n original_frame_idxs[current] = state_num\n frame_labels_aux[current] = frame_label\n sample_percentages[current] = sample_percentage\n single_state_indices[current] = i\n # flowfronts[current, :, :] = create_np_image(target_shape=self.image_size,\n # norm_coords=_coords, data=flat_fillings[i])\n current += 1\n except IndexError:\n continue\n\n # determine runlevel label using frame labels and threshold\n lens_of_runs_of_dryspots = [sum(1 for _ in group) for key, group in\n groupby(np.array(frame_labels) == 1) if key]\n max_len = 0 if len(lens_of_runs_of_dryspots) == 0 else max(lens_of_runs_of_dryspots)\n label = 0 if max_len < threshold_min_counted_dryspots else 1\n\n f.close()\n meta_file.close()\n\n if self.aux_info:\n # framelabels, original_frame_idx, original_num_frames, flowfronts, filling_percentage\n aux = {\"framelabel\": frame_labels_aux,\n \"original_frame_idx\": original_frame_idxs,\n \"original_num_multi_states\": len(multi_states),\n \"percent_of_sensors_filled\": sample_percentages,\n \"single_state_indices\": single_state_indices,\n }\n return [(sequence, label, aux)]\n\n return [(sequence, label)]\n except KeyError:\n f.close()\n meta_file.close()\n return None","def __getitem__(self, index):\n d = self._signal_object[index]\n d = bootstrap_data_voxel(d, self._H, self._R)\n d.clip(self._min_signal, 1., d)\n return d","def local_optimize(X, nrounds=1, cost_weights=(1.,1.,1.), use_all=True, use_subset=False):\n\n old_cost = cost_total(X, cost_weights=cost_weights)\n\n orig_cost = old_cost\n\n configs = [X.names_seats_dict.copy()]\n\n # loop through number of rounds\n for ind1 in range(nrounds):\n\n # loop through randomly\n for ind in np.random.choice(range(len(X.seats)), len(X.seats), replace=True):\n # print(old_cost)\n # get a candidate\n\n if not use_all:\n neighbours_to_check = np.random.choice(X.seats_graph[X.seats[ind]],len(X.seats_graph[X.seats[ind]]), False)\n else:\n if use_subset:\n neighbours_to_check = [st for st in X.seats if np.random.rand() > .5]\n else:\n neighbours_to_check = X.seats\n\n for ind_n in neighbours_to_check:\n\n X_new = X.copy()\n X_new.update(swap_neighbour(X_new, p1=X.seats[ind], p2=ind_n))\n\n new_cost = cost_total(X_new, cost_weights=cost_weights)\n\n # accept if better\n if new_cost < old_cost:\n old_cost = new_cost\n configs.append(X.names_seats_dict)\n X = X_new.copy()\n\n return X, orig_cost, old_cost, configs","def select_best_chanels():\r\n \r\n \r\n all_paths = [['data_bci\\\\row_data\\\\subject1\\\\'], ['data_bci\\\\row_data\\\\subject2\\\\'],['data_bci\\\\row_data\\\\subject3\\\\']]\r\n\r\n train_subjects = ['01']\r\n test_subject = '02'\r\n freq = 512\r\n\r\n cutoff_beggining = 0\r\n columns_to_read = ['Fp1', 'AF3' ,'F7', 'F3', 'FC1', 'FC5', 'T7', 'C3', 'CP1', 'CP5',\r\n 'P7', 'P3', 'Pz', 'PO3', 'O1', 'Oz', 'O2', 'PO4', 'P4', 'P8', 'CP6',\r\n 'CP2', 'C4', 'T8', 'FC6', 'FC2', 'F4', 'F8', 'AF4', 'Fp2', 'Fz', 'Cz','class']\r\n seq_len = 0\r\n cut_step = 0\r\n num_perseg = freq\r\n num_overlap = int(num_perseg/2)\r\n min_freq=8\r\n max_freq=45\r\n \r\n chanels_rank = rank_chanels()\r\n \r\n result = []\r\n for i in range(1, len(chanels_rank)):\r\n intermidiate_result = []\r\n for path in all_paths:\r\n train_full_data, train_full_data_filtered, train_full_anots, test_full_data, test_full_filtered, test_full_annoations = read_filter(path, train_subjects,test_subject, columns_to_read, cutoff_beggining, seq_len, cut_step)\r\n\r\n train_psd_signals = eval_psd_not_modulated(train_full_data, num_perseg, num_overlap, freq, min_freq, max_freq)\r\n test_psd_signals = eval_psd_not_modulated(test_full_data, num_perseg, num_overlap, freq, min_freq, max_freq) \r\n\r\n train_psd_signals = flatten_data(train_psd_signals[:,:,chanels_rank[:i]])\r\n test_psd_signals = flatten_data(test_psd_signals[:,:,chanels_rank[:i]])\r\n \r\n acc = evalute_subset(train_psd_signals, test_psd_signals, train_full_anots, test_full_annoations)\r\n intermidiate_result.append(acc)\r\n \r\n result.append(intermidiate_result)\r\n #mean_subject_acc = np.array([sum(humans_acc)/len(humans_acc) for humans_acc in result])\r\n #best_idx = np.argmax(mean_subject_acc)\r\n\r\n return result, chanels_rank","def calc_nearest_ind(self, robot_pose):\n pass","def test_index_nas_shares_by_pool(self):\n pass","def SOM(args):\n\n # Obtain the normalized set of cities (w/ coord in [0,1])\n cities = pd.read_csv(Path(args.data_dir) / 'data1.csv')\n\n iteration = args.iteration\n learning_rate = args.learning_rate\n decay = args.decay\n\n out_dir = Path(args.out_dir)\n out_dir.mkdir_p()\n\n cities_nm = cities.copy()\n\n cities_nm[['x', 'y']] = normalize(cities_nm[['x', 'y']])\n cities_nm.to_csv(out_dir/'cities_nm.csv')\n cities.to_csv(out_dir/'cities.csv')\n\n\n depot = cities_nm.query('city==0')[['x','y']].to_numpy()\n # The population size is 8 times the number of cities\n #n = cities_cp.shape[0] * 2# a single route's neurons\n n=100\n # Generate an adequate network of neurons:\n #network = generate_network(n)\n neuron_chains =init_neurons(size=n,depot=depot)\n print('--> Network of {} neurons created. Starting the iterations:'.format(n))\n best_routes=np.array([0])\n\n #save\n losses_sum_log={}#每个循环losses_sum值\n min_losses_sum_log = {}##保存最小值的路径losses\n min_losses_log={}#存储最好情况下四条路径的距离值\n min_routes_log={}\n best_id=0\n min_losses_sum=0\n\n for i in tqdm(range(iteration)):\n if not i % args.neuro_plot_freq:\n print('\\t> Iteration {}/{}'.format(i, iteration), end=\"\\r\")\n # Choose a random city\n sample = cities_nm.sample(1)\n if int(sample['city']) in args.depot_idxs:\n continue\n city = sample[['x', 'y']].values#随机抽样 random sampling\n group_idx,winner_idx = select_closest_gpid(neuron_chains, city)\n\n # Generate a filter that applies changes to the winner's gaussian\n gaussian = get_neighborhood(center=winner_idx, radix=n//10, domain=neuron_chains[0].shape[0])\n # Update the network's weights (closer to the city)\n neuron_chains[group_idx] += gaussian[:,np.newaxis] * learning_rate * (city - neuron_chains[group_idx])\n # Decay the variables\n learning_rate = learning_rate * decay\n n = n * decay\n\n\n if i % args.evaluate_freq==0:\n cities_od = rebuild_cities(cities_nm,neuron_chains,args.num_depots)\n cities_od[['x','y']] =cities.reindex(cities_od['city'])[['x','y']]\n losses = routes_distances(cities_od)\n losses_sum = sum(losses)\n losses_sum_log[i] = losses_sum\n\n if min_losses_sum == 0 or min_losses_sum > losses_sum:\n min_losses_sum = losses_sum\n best_id = i\n routes = get_routes(cities_od)\n routes = [list(item.astype(np.float64)) for item in routes]\n min_routes_log[i] = routes\n\n min_losses_sum_log[i] = losses_sum\n min_losses_log[i] = losses\n cities_od.to_csv(out_dir/'data_out_{:04d}.csv'.format(i))\n save_neuron_chains(neuron_chains,out_dir/\"neuron_chains_{:04d}.npy\".format(i))\n\n #end for\n\n # Check if any parameter has completely decayed.\n if n < 1:\n print('Radius has completely decayed, finishing execution',\n 'at {} iterations'.format(i))\n break\n if learning_rate < 0.001:\n print('Learning rate has completely decayed, finishing execution',\n 'at {} iterations'.format(i))\n break\n\n\n print('Completed {} iterations.'.format(iteration))\n\n results = {}\n\n results['losses_sum_log']=losses_sum_log\n results['best_id'] = best_id\n\n results['min_losses_sum_log']=min_losses_sum_log\n results['min_losses_log']=min_losses_log\n results['min_routes_log'] = min_routes_log\n\n\n p = Path(out_dir/'results.json')\n with open(p, 'w') as fp:\n json.dump(results, fp)\n print('ok')\n\n\n return results","def neighborhood_sample(solution, ssize):\n n_runs = len(solution)\n n_clusters = len(solution[0])\n \n swaps_per_run = n_clusters * (n_clusters-1) // 2\n max_size = n_runs * swaps_per_run\n \n ssize = min(ssize, max_size)\n \n combinations = list(itertools.combinations(range(n_clusters), 2))\n selection = random.sample(range(max_size), ssize)\n \n nb = [0] * ssize\n \n for i_nb, i_sel in enumerate(selection):\n i_run = i_sel // swaps_per_run\n i_comb = i_sel % swaps_per_run\n \n i1, i2 = combinations[i_comb]\n swapped = solution[i_run][:]\n swapped[i1], swapped[i2] = swapped[i2], swapped[i1]\n nb[i_nb] = solution[:i_run] + [swapped] + solution[i_run+1:]\n \n return selection, nb"],"string":"[\n \"def test(indices_to_visit = None):\\n ##0 Chicago\\n ##1 New York City\\n ##2 Los Angeles\\n ##3 Minneapolis\\n ##4 Denver\\n ##5 Dallas\\n ##6 Seattle\\n ##7 Boston\\n ##8 San Francisco\\n ##9 St. Louis\\n ##10 Houston\\n ##11 Phoenix\\n ##12 Salt Lake City\\n ##13 Miami\\n ##14 Atlanta\\n ##15 Kansas City\\n home_index = 15 # Kansas city\\n # 15x15 matrix with main diagonal consisting of 0s and to which data is mirrored along\\n # (values are derived from external resource and multiplied by 1000 for higher accuracy)\\n matrix = np.array([[0.0, 1148413.3550047704, 2813453.6297408855, 572861.4368351421, 1483440.7452179305, 1296355.2188721865, 2801269.1215845253, 1370943.3069385102, 2996683.256068982, 422589.4697157836, 1515737.0196676727, 2343639.7107855356, 2031500.319603397, 1913900.3015914203, 946854.1020487415, 665894.0336505901],\\n [1148413.3550047704, 0.0, 3949451.153672887, 1642119.4792808082, 2628946.6435325537, 2212019.1209020815, 3882177.952930788, 306997.0343229422, 4144977.810718553, 1408454.3261387087, 2286054.8575902223, 3455343.3108375454, 3179102.5335818897, 1754834.3710577146, 1202616.154562711, 1766599.1336905772],\\n [2813453.6297408855, 3949451.153672887, 0.0, 2455296.3791196346, 1339227.410707824, 1998182.1420783552, 1545364.434045008, 4184394.186016967, 559978.4273194656, 2560790.9591738936, 2212581.51715849, 575975.8749662543, 933602.6426595236, 3767490.41517038, 3120118.850020503, 2186473.1552241463],\\n [572861.4368351421, 1642119.4792808082, 2455296.3791196346, 0.0, 1127312.7583590776, 1390159.7734006236, 2249169.1308160927, 1811513.5290266906, 2554165.8167895717, 750916.7305340832, 1701189.1538312144, 2062079.2399570548, 1590460.9488364782, 2434801.332310659, 1462408.5353501518, 662752.1291133759],\\n [1483440.7452179305, 2628946.6435325537, 1339227.410707824, 1127312.7583590776, 0.0, 1067257.7993323756, 1646308.7967673023, 2852307.4164419994, 1530510.2790658756, 1283707.511393525, 1414308.8805983758, 943721.1931707633, 598728.757362067, 2779561.192116527, 1952618.0544916363, 899656.1020173575],\\n [1296355.2188721865, 2212019.1209020815, 1998182.1420783552, 1390159.7734006236, 1067257.7993323756, 0.0, 2709804.112590561, 2500314.4507069485, 2390841.4329337194, 882457.80942383, 361482.7025425731, 1427995.4150203674, 1610768.421819668, 1788903.6065106322, 1161480.3557326929, 730446.8613086065],\\n [2801269.1215845253, 3882177.952930788, 1545364.434045008, 2249169.1308160927, 1646308.7967673023, 2709804.112590561, 0.0, 4018059.834330202, 1093104.7332788548, 2778905.575804111, 3046648.362755992, 1794989.6453295103, 1129464.5539648102, 4404737.747850686, 3516794.375197078, 2427457.036285458],\\n [1370943.3069385102, 306997.0343229422, 4184394.186016967, 1811513.5290266906, 2852307.4164419994, 2500314.4507069485, 4018059.834330202, 0.0, 4350710.853063807, 1673216.4080939887, 2586942.3262796295, 3706392.097841614, 3382851.415271485, 2022974.6418062754, 1509585.60107986, 2015770.1390589625],\\n [2996683.256068982, 4144977.810718553, 559978.4273194656, 2554165.8167895717, 1530510.2790658756, 2390841.4329337194, 1093104.7332788548, 4350710.853063807, 0.0, 2812916.3098878833, 2650547.941880299, 1053620.7288649315, 967859.8344376946, 4179636.203479384, 3448359.745690545, 2428862.4239271535],\\n [422589.4697157836, 1408454.3261387087, 2560790.9591738936, 750916.7305340832, 1283707.511393525, 882457.80942383, 2778905.575804111, 1673216.4080939887, 2812916.3098878833, 0.0, 1093601.4408876144, 2050115.5214378452, 1872971.1741522516, 1708236.6189296674, 752855.8488125347, 384122.2000072272],\\n [1515737.0196676727, 2286054.8575902223, 2212581.51715849, 1701189.1538312144, 1414308.8805983758, 361482.7025425731, 3046648.362755992, 2586942.3262796295, 2650547.941880299, 1093601.4408876144, 0.0, 1636770.4499809493, 1932616.2801687205, 1559260.024532222, 1130480.278513877, 1039856.4844335921],\\n [2343639.7107855356, 3455343.3108375454, 575975.8749662543, 2062079.2399570548, 943721.1931707633, 1427995.4150203674, 1794989.6453295103, 3706392.097841614, 1053620.7288649315, 2050115.5214378452, 1636770.4499809493, 0.0, 812548.5062332726, 3191662.5092484164, 2564665.4531581327, 1690942.142157212],\\n [2031500.319603397, 3179102.5335818897, 933602.6426595236, 1590460.9488364782, 598728.757362067, 1610768.421819668, 1129464.5539648102, 3382851.415271485, 967859.8344376946, 1872971.1741522516, 1932616.2801687205, 812548.5062332726, 0.0, 3364908.7076308434, 2551338.215149899, 1490589.7393085626],\\n [1913900.3015914203, 1754834.3710577146, 3767490.41517038, 2434801.332310659, 2779561.192116527, 1788903.6065106322, 4404737.747850686, 2022974.6418062754, 4179636.203479384, 1708236.6189296674, 1559260.024532222, 3191662.5092484164, 3364908.7076308434, 0.0, 973244.7750437199, 2000112.4162614697],\\n [946854.1020487415, 1202616.154562711, 3120118.850020503, 1462408.5353501518, 1952618.0544916363, 1161480.3557326929, 3516794.375197078, 1509585.60107986, 3448359.745690545, 752855.8488125347, 1130480.278513877, 2564665.4531581327, 2551338.215149899, 973244.7750437199, 0.0, 1089830.6426635552],\\n [665894.0336505901, 1766599.1336905772, 2186473.1552241463, 662752.1291133759, 899656.1020173575, 730446.8613086065, 2427457.036285458, 2015770.1390589625, 2428862.4239271535, 384122.2000072272, 1039856.4844335921, 1690942.142157212, 1490589.7393085626, 2000112.4162614697, 1089830.6426635552, 0.0]])\\n\\n solver = FacilityOrderSolver(matrix, home_index)\\n \\n return solver.solve(indices_to_visit)\",\n \"def get_tuned_excitatory_weights(self):\\n \\n self.W_ee=np.zeros((self.N_e,self.N_e))\\n \\n if not hasattr(self,'fixed_connectivity_tuning'):\\n self.fixed_connectivity_tuning=1\\n \\n num_tuned_conns=int(np.floor(self.fixed_connectivity_tuning*self.num_conns_ee))\\n num_untuned_conns=self.num_conns_ee-num_tuned_conns\\n \\n for i in xrange(self.N_e):\\n ref_phase=self.gp.phases[i,:]\\n dists=gl.get_periodic_dist_on_rhombus(self.n_e,ref_phase,self.gp.phases,self.gp.u1,self.gp.u2)\\n sorted_idxs=np.argsort(dists)\\n \\n tuned_idxs=sorted_idxs[:self.num_conns_ee]\\n np.random.shuffle(tuned_idxs)\\n\\n #untuned_idxs=np.setdiff1d(np.arange(self.N_e),tuned_idxs)\\n all_idxs=np.arange(self.N_e)\\n np.random.shuffle(all_idxs)\\n \\n self.W_ee[i,tuned_idxs[0:num_tuned_conns]]=self.W_max_ee\\n self.W_ee[i,all_idxs[:num_untuned_conns]]=self.W_max_ee\\n \\n \\n self.W[:self.N_e,:self.N_e]=self.W_ee\",\n \"def get_random_inhibitory_weights(self):\\n \\n self.W_ei=np.zeros((self.N_e,self.N_i))\\n self.W_ie=np.zeros((self.N_i,self.N_e)) \\n self. W_ii=np.zeros((self.N_i,self.N_i))\\n\\n \\n # connections to the excitatory neurons \\n for row_idx in xrange(self.N_e):\\n \\n # from ihibitory\\n all_idxs_ei=np.arange(self.N_i)\\n np.random.shuffle(all_idxs_ei)\\n self.W_ei[row_idx,all_idxs_ei[0:self.num_conns_ei]]=self.W_max_ei \\n \\n # connections to inhibitory neurons\\n for row_idx in range(self.N_i):\\n \\n # from exitatory \\n all_idxs_ie=np.arange(self.N_e)\\n np.random.shuffle(all_idxs_ie)\\n self.W_ie[row_idx,all_idxs_ie[0:self.num_conns_ie]]=self.W_max_ie\\n \\n # from inhibitory\\n all_idxs_ii=np.arange(self.N_i)\\n np.random.shuffle(all_idxs_ii)\\n self.W_ii[row_idx,all_idxs_ii[0:self.num_conns_ii]]=self.W_max_ii\\n \\n \\n self.W[:self.N_e,self.N_e:]=self.W_ei\\n self.W[self.N_e:,:self.N_e]=self.W_ie\\n self.W[self.N_e:,self.N_e:]=self.W_ii\",\n \"def random_subsample(neuron, num):\\n\\n I = np.arange(neuron.n_soma, neuron.n_node)\\n np.random.shuffle(I)\\n selected_index = I[0:num - 1]\\n selected_index = np.union1d([0], selected_index)\\n selected_index = selected_index.astype(int)\\n selected_index = np.unique(np.sort(selected_index))\\n\\n return neuron_with_selected_nodes(neuron, selected_index)\",\n \"def shortest_tips(neuron):\\n (branch_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 2)\\n (endpoint_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 0)\\n selected_index = np.union1d(endpoint_index + 1,\\n branch_index + 1)\\n selected_index = np.append(0, selected_index)\",\n \"def get_neigh_demand(city):\\n\\n # get station set S with more than 10 charge equipment\\n static_file_path = exp_data_path + os.sep + 'static' + os.sep + 'static_feature_{}.csv'.format(city)\\n static_feature = pd.read_csv(static_file_path, header=0)\\n station_set = set(static_feature[static_feature.num >= 10].index)\\n\\n # calculate 10 nearest neighborhoods for each station, sort by distance and store their index, get a map\\n neighbor_distance_map = {}\\n matrix_distance = np.load(exp_data_path + os.sep + 'similarity' + os.sep + 'similarity_distance_{}_numpy.npy'.format(city), allow_pickle=True)\\n all_distance_map = {i: [] for i in range(station_count[city])}\\n for i in range(station_count[city]):\\n if i not in station_set:\\n continue\\n for j in range(station_count[city]):\\n if j not in station_set:\\n continue\\n all_distance_map[i].append((j, matrix_distance[i][j]))\\n all_distance_map[i].sort(key=lambda x : x[1], reverse=True)\\n neighbor_distance_map[i] = [idx for idx, distance in all_distance_map[i][:10]]\\n\\n # 11 times header, get static neighborhood feature for each station(in S), get csv: neighbor_feature_{city}.csv\\n ALL_HEADER = ['index']\\n ALL_HEADER.extend(GENERAL_HEADER)\\n for i in range(10):\\n for j in GENERAL_HEADER:\\n ALL_HEADER.append('{}_{}'.format(j, i))\\n\\n raw_data = np.empty((len(neighbor_distance_map), len(ALL_HEADER)))\\n for i, idx in enumerate(neighbor_distance_map.keys()):\\n raw_data[i][0] = idx\\n raw_data[i][1:1+len(GENERAL_HEADER)] = static_feature.iloc[idx]['num':'mall']\\n for j in range(10):\\n neighbor_idx = neighbor_distance_map[idx][j]\\n raw_data[i][1+len(GENERAL_HEADER)*(j+1):1+len(GENERAL_HEADER)*(j+2)] = static_feature.iloc[neighbor_idx]['num':'mall']\\n neighbor_feature_data = pd.DataFrame(raw_data, columns=ALL_HEADER)\\n print('neighbor feature')\\n print(neighbor_feature_data)\\n\\n neighbor_feature_path = exp_data_path + os.sep + 'static' + os.sep + 'static_neighor_feature_{}.csv'.format(city)\\n if os.path.exists(neighbor_feature_path):\\n os.remove(neighbor_feature_path)\\n neighbor_feature_data.to_csv(neighbor_feature_path)\\n\\n # create final csv(11 times header with basic info(time_index + time_embed_index))\\n # if index in S, fill basic info, neighbor_feature and demand\\n\\n demand = np.load(exp_data_path + os.sep + 'station' + os.sep + 'demand_{}.npy'.format(city), allow_pickle=True)\\n time_count = demand.shape[1]\\n\\n DEMAND_HEADER = []\\n DEMAND_HEADER.extend(ALL_HEADER)\\n DEMAND_HEADER.extend(['time_index', 'time_embed', 'demand'])\\n neighbor_demand_raw_data = np.empty(((len(neighbor_distance_map)*time_count, len(DEMAND_HEADER))))\\n\\n # get time map like {\\\"0800\\\": 1, \\\"0830\\\": 2, ....}\\n time_index_map = np.load(exp_data_path + os.sep + 'station_list' + os.sep + 'time_index.npy', allow_pickle=True)\\n time_index_map = dict(time_index_map.tolist())\\n time_map = {t: i for i, t in enumerate(sorted(set([k[-4:] for k in time_index_map['rev_index'].keys()])))}\\n\\n cur_idx = 0\\n for time_idx in range(time_count):\\n time_embed_idx = time_map[time_index_map['index'][time_idx][-4:]]\\n for station_idx in station_set:\\n neighbor_demand_raw_data[cur_idx][0:len(ALL_HEADER)] = neighbor_feature_data.loc[neighbor_feature_data['index']==station_idx, 'index':'mall_9']\\n neighbor_demand_raw_data[cur_idx][len(ALL_HEADER)] = time_idx\\n neighbor_demand_raw_data[cur_idx][len(ALL_HEADER)+1] = time_embed_idx\\n neighbor_demand_raw_data[cur_idx][len(ALL_HEADER)+2] = demand[station_idx][time_idx][-1]\\n # todo add slow demand and quick demand here\\n cur_idx = cur_idx + 1\\n print(cur_idx, neighbor_demand_raw_data.shape)\\n\\n neighbor_demand_data = pd.DataFrame(neighbor_demand_raw_data, columns=DEMAND_HEADER)\\n print('neighbor demand')\\n print(neighbor_demand_data)\\n\\n neighbor_demand_path = exp_data_path + os.sep + 'static' + os.sep + 'neighbor_demand_{}.csv'.format(city)\\n if os.path.exists(neighbor_demand_path):\\n os.remove(neighbor_demand_path)\\n neighbor_demand_data.to_csv(neighbor_demand_path)\",\n \"def get_approx_preRes(self, connectivity_threshold):\\n #print(\\\"sparse_keys\\\", self.sparse_keys_, \\\"connectivity_threshold\\\", connectivity_threshold )\\n key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]\\n val = self.sparse_book[key_].clone()\\n return val\",\n \"def get_approx_preRes_old(self, connectivity_threshold, i):\\n key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]\\n val = np.array(sparse_dict[key_]).copy()\\n return val\",\n \"def connection(self, sampleseq, num):\\n self.Adjmatrix = np.zeros((self.nodenum, self.nodenum), dtype = int)\\n \\n for i in range(self.supplynum):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.trandemandseries], sampleseq[self.supplyseries[i]]))\\n self.Adjmatrix[self.supplyseries[i], self.trandemandseries[minindex]] = 1\\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\\n \\n for i in range(self.trannum):\\n if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) == 0):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\\n self.Adjmatrix[minindex, self.transeries[i]] = 1\\n# self.Adjmatrix[self.transeries[i], minindex] = 1\\n \\n \\n# for i in range(self.supplynum):\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries[i], self.supplyseries], num))\\n# self.Adjmatrix[self.supplyseries[i], minindex] = 1\\n# self.Adjmatrix[minindex, self.supplyseries[i]] = 1\\n \\n# for i in range(self.trannum):\\n# if(np.sum(self.Adjmatrix[self.supplyseries, self.transeries[i]]) != 0):\\n# continue\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.supplyseries, self.transeries[i]], num))\\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\\n## self.Adjmatrix[self.transeries[i], minindex] = 1\\n# \\n for i in range(self.trannum):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.demandseries], min(sampleseq[self.transeries[i]], self.demandnum))) + self.supplynum + self.trannum\\n self.Adjmatrix[self.transeries[i], minindex] = 1\\n# self.Adjmatrix[minindex, self.transeries[i]] = 1\\n \\n# for i in range(self.demandnum):\\n# if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], 1)) + self.supplynum\\n# self.Adjmatrix[minindex, self.demandseries[i]] = 1\\n \\n# for i in range(self.trannum):\\n# minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries[i], self.transeries], num)) + self.supplynum\\n# self.Adjmatrix[self.transeries[i], minindex] = 1\\n \\n for i in range(self.demandnum):\\n if(np.sum(self.Adjmatrix[self.transeries, self.demandseries[i]]) == 0):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.transeries, self.demandseries[i]], num)) + self.supplynum\\n self.Adjmatrix[minindex, self.demandseries[i]] = 1\\n# self.Adjmatrix[self.demandseries[i], minindex] = 1\\n \\n for i in range(self.demandnum):\\n minindex = np.array(sf.minimumk(self.Dismatrix[self.demandseries[i], self.demandseries], min(sampleseq[self.demandseries[i]] + 1, self.demandnum))) + self.supplynum + self.trannum\\n minindex = minindex[1:-1]\\n for j in range(len(minindex)):\\n if(self.Adjmatrix[self.demandseries[i], minindex[j]] == 1 or self.Adjmatrix[minindex[j], self.demandseries[i]] == 1):\\n continue\\n self.Adjmatrix[self.demandseries[i], minindex[j]] = 1\",\n \"def find_standby2(model, limit, w_a, w_b, w_m, demand_path, demand_dict, slink_dict):\\n #print slink_dict\\n #print \\\"FIND\\\"\\n failed_dict = model.failed_dict\\n #print failed_dict, limit\\n dist_matrix = model.cost_dict['dist']\\n rtt_matrix = model.cost_dict['rtt']\\n bw_matrix = model.cost_dict['bw']\\n #cpu_vector = model.cost_dict['cpu']\\n selected_dict = {}\\n \\n # get aggregated residual bw for all substrate nodes, and store it as a list\\n snode_bw_list = total_bw(bw_matrix)\\n \\n # get total capacity and used bw for each snode\\n node_port_list, used_bw_list = total_port(model)\\n #vnet_set = model.vnets\\n sorted_vn = sort_vnet(model)\\n\\n #for vnet in vnet_set:\\n if w_m[2] >= 10*w_m[1]:\\n threshold = 0.8\\n else:\\n threshold = 0.8\\n snode_traffic = {}\\n for vn_traffic in sorted_vn:\\n vnet = vn_traffic[0]\\n failed_vr = failed_dict[vnet.vnet_id]\\n if failed_vr != -1: \\n # this node is failed\\n standby_list = vnet.get_standby_ids()\\n standby_cost = {}\\n for s_vr in standby_list:\\n dist_f = float(dist_matrix[s_vr][failed_vr + 1])\\n failed_node = vnet.vnodes[failed_vr]\\n vneighbors = failed_node.vneighbors\\n dist_k = 0\\n rtt_k = 0\\n for k in vneighbors:\\n dist_k += float(dist_matrix[s_vr][k + 1])\\n rtt_k += float(rtt_matrix[s_vr][k + 1])\\n\\n connect_cost = w_b[0] * (w_a[0] * dist_f + w_a[1] * dist_k) +\\\\\\n w_b[1] * rtt_k\\n res_cost = snode_bw_list[s_vr]\\n req_bw = sum(failed_node.neighbor_traffic.values())\\n total = w_m[1] * connect_cost + w_m[2] * req_bw / res_cost\\n standby_cost[s_vr] = total\\n sorted_x = sorted(standby_cost.iteritems(), key=operator.itemgetter(1))\\n #print \\\"SORTED\\\", sorted_x\\n \\n for item in sorted_x:\\n if item[0] not in snode_traffic:\\n #utilization = vn_traffic[1] / total_bw(bw_matrix)[item[0]]\\n utilization = (vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\\n else:\\n #utilization = (snode_traffic[item[0]] + vn_traffic[1]) / total_bw(bw_matrix)[item[0]]\\n utilization = (snode_traffic[item[0]] + vn_traffic[1] + used_bw_list[item[0]])/node_port_list[item[0]]\\n #print utilization\\n # Link-Path selsection add-on\\n path_alloc = 1\\n for k in vneighbors:\\n demand_id = find_demand_id(demand_dict, vnet.vnet_id, failed_vr + 1,\\n item[0] + 1, k + 1)\\n demand = demand_dict[demand_id]['capacity']\\n find, path = find_path(demand_path, demand_id, \\n slink_dict, demand) \\n if find == 0:\\n print \\\"No available path between svr and nbr on the substrate network\\\" \\n path_alloc = 0\\n #print \\\"FIND PATH\\\", find, path\\n # End link-path block \\n #print \\\"ALLOCATED: \\\", path_alloc\\n if path_alloc == 1:\\n if selected_dict.values().count(item[0]) < limit:\\n if utilization < threshold and w_m[2] >= 10*w_m[1]:\\n if item[0] not in snode_traffic: \\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n snode_traffic[item[0]] = vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1], slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n break;\\n else:\\n min_id = find_min(sorted_x, bw_matrix, snode_traffic, vn_traffic[1]) \\n if min_id == item[0]:\\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n snode_traffic[item[0]] += vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n #threshold = (threshold + 0.01)/2\\n break\\n elif utilization < threshold:\\n selected_dict[vnet.vnet_id] = item[0]\\n snode_bw_list[item[0]] -= vn_traffic[1]\\n if item[0] not in snode_traffic: \\n snode_traffic[item[0]] = vn_traffic[1]\\n else:\\n snode_traffic[item[0]] += vn_traffic[1]\\n for slink_id in path:\\n #print vn_traffic[1],slink_dict[slink_id]['capacity']\\n slink_dict[slink_id]['capacity'] = slink_dict[slink_id]['capacity'] - vn_traffic[1]\\n #print slink_dict[slink_id]['capacity']\\n break\\n else:\\n print \\\"does not satisfy the threshold\\\" \\n # if a svr is selected -- item[0]\\n \\n \\n \\n else:\\n print \\\"cannot allocate paths\\\"\\n \\n #print slink_dict \\n return selected_dict, slink_dict\",\n \"def get_obj_new(model_old, demand_path, slink_dict, demand_dict, w_a, w_b, theta, s_limit):\\n model = copy.deepcopy(model_old)\\n \\n #cpu_vector = model.cost_dict['cpu']\\n dist_matrix = model.cost_dict['dist']\\n rtt_matrix = model.cost_dict['rtt']\\n #bw_matrix = model.cost_dict['bw']\\n w_a1, w_a2 = w_a\\n w_b1, w_b2 = w_b\\n theta1, theta2, theta3 = theta\\n # find total capacity and used bw on substrate nodes\\n node_port_list, used_bw_list = total_port(model)\\n #print \\\"CHECK POINT-1\\\", used_bw_list, node_port_list\\n vnet_info = model.get_vnet_info()\\n infeasible = 0\\n\\n fail_nodes = model.failed_dict\\n start_time = time.time()\\n select_dict, slink_dict = find_standby2(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\\n # random selection\\n #select_dict, slink_dict = find_random(model, s_limit, w_a, w_b, theta, demand_path, demand_dict, slink_dict)\\n #print \\\"selection takes: \\\", time.time() - start_time\\n #print \\\"Selected\\\", select_dict\\n sum_cost_1_2 = 0\\n r_list = {}\\n \\n for node_id in range(0,len(used_bw_list)):\\n r_list[node_id] = used_bw_list[node_id]/node_port_list[node_id]\\n #print \\\"INITIAL\\\", r_list\\n svr_subset = {}\\n for vnet in model.vnets:\\n j = vnet.vnet_id\\n f = fail_nodes[j]\\n # only count the failed virtual network\\n if f == -1:\\n pass\\n else:\\n for node_id in vnet_info[j]['standby']:\\n svr_subset[node_id] = r_list[node_id]\\n #print \\\"Subset SVR: \\\", svr_subset\\n \\n if j in select_dict:\\n #print \\\"FEASIBLE FOUND\\\"\\n #print vnet_info[j]['standby']\\n i = select_dict[j]\\n failed_node = vnet.vnodes[f]\\n vneighbors = failed_node.vneighbors\\n for k in vneighbors: \\n eta = operation_cost()\\n #print \\\"a1: \\\", w_a1, \\\"a2: \\\", w_a2, \\\"b1: \\\", w_b1, \\\"b2: \\\", w_b2\\n dist_c = dist_cost(i, f, k, dist_matrix, w_a1, w_a2)\\n rtt_c = rtt_cost(i, k, rtt_matrix)\\n sigma = connect_cost(dist_c, rtt_c, w_b1, w_b2)\\n sum_cost_1_2 += theta1 * eta + theta2 * sigma\\n #find residual bw on substrate node\\n #xi = resource_cost(bw_matrix, i)\\n req_bw = sum(failed_node.neighbor_traffic.values())\\n #util = req_bw / xi\\n #print req_bw, i, used_bw_list[i], node_port_list[i]\\n util = req_bw/node_port_list[i]\\n \\n if i not in r_list:\\n r_list[i] = util #+ used_bw_list[i]/node_port_list[i]\\n else:\\n r_list[i] += util\\n svr_subset[i] = r_list[i]\\n #print sigma, \\\" v_\\\" + str(vnet.vnet_id) + \\\"_\\\" + str(f) + \\\"_\\\" + str(i) + \\\"_\\\" + str(k) + \\\"_\\\" + str(k)\\n else:\\n print \\\"INFEASIBLE at vnet: \\\", j\\n infeasible = 1\\n #print \\\"DONE\\\"\\n \\n if infeasible == 0:\\n #print svr_subset\\n max_util = max(svr_subset.values())\\n obj = sum_cost_1_2 + theta3 * max_util\\n else:\\n obj = \\\"infeasible\\\"\\n max_util = \\\"none\\\"\\n #print obj\\n used_time = time.time() - start_time\\n return obj, select_dict, max_util, used_time\",\n \"def straigh_subsample(neuorn, distance):\\n\\n # Selecting the main points: branching nodes and end nodes\\n selected_index = get_main_points()\\n\\n # for each segment between two consecuative main points, a few nodes from the segment will be added to the selected node.\\n # These new nodes will be selected base on the fact that neural distance of two consecuative nodes is around 'distance'.\\n # Specifically, it starts from the far main point, and goes on the segment toward the near main point. Then the first node which is\\n # going to add has the property that it is the farest node from begining on the segment such that its distance from begining is\\n # less than 'distance'. The next nodes will be selected similarly.\\n\\n for i in selected_index:\\n upList = np.array([i], dtype = int)\\n index = neuorn.parent_index[i]\\n dist = neuorn.distance_from_parent[i]\\n while(~np.any(selected_index == index)):\\n upList = np.append(upList,index)\\n index = neuorn.parent_index[index]\\n dist = np.append(dist, sum(neuorn.distance_from_parent[upList]))\\n dist = np.append(0, dist)\\n (I,) = np.where(np.diff(np.floor(dist/distance))>0)\\n I = upList[I]\\n selected_index = np.append(selected_index, I)\\n selected_index = np.unique(selected_index)\\n neuron = neuron_with_selected_nodes(selected_index)\\n return neuron\",\n \"def __call__(self, circuit):\\n gates_qubits_pairs = find_gates_qubits_pairs(circuit)\\n nodes = self.connectivity.number_of_nodes()\\n keys = list(self.connectivity.nodes())\\n final_mapping = dict(zip(keys, range(nodes)))\\n final_graph = nx.relabel_nodes(self.connectivity, final_mapping)\\n final_cost = self.cost(final_graph, gates_qubits_pairs)\\n for _ in range(self.samples):\\n mapping = dict(zip(keys, random.sample(range(nodes), nodes)))\\n graph = nx.relabel_nodes(self.connectivity, mapping)\\n cost = self.cost(graph, gates_qubits_pairs)\\n if cost == 0:\\n return mapping\\n if cost < final_cost:\\n final_graph = graph\\n final_mapping = mapping\\n final_cost = cost\\n return final_mapping\",\n \"def regular_subsample(neuron):\\n # select all the main points\\n selected_index = get_main_points(neuorn)\\n\\n # Computing the parent id of the selected nodes\\n neuron = neuron_with_selected_nodes(selected_index)\\n return neuron\",\n \"def sampleIndex(self):\\r\\n x=random.random()\\r\\n i = 0\\r\\n n = len(self.weights)-1\\r\\n cummulativeWeight = 0\\r\\n if len(self.sampledActions) == 0:\\r\\n explorationWeight = 0\\r\\n else:\\r\\n explorationWeight = self.explorationFund / len(self.sampledActions)\\r\\n if n < 0:\\r\\n normalizationFactor = self.priorBelief\\r\\n else:\\r\\n normalizationFactor = sum(self.weights) + self.explorationFund + \\\\\\r\\n self.priorBelief*(1-self.priorTopicDistr.cummulative[n])\\r\\n while True:\\r\\n w = self.__getitem__(i)\\r\\n if i in self.sampledActions:\\r\\n w += explorationWeight\\r\\n cummulativeWeight += w\\r\\n if x <= cummulativeWeight/normalizationFactor:\\r\\n if i not in self.sampledActions:\\r\\n self.sampledActions.append(i)\\r\\n return i\\r\\n i += 1\",\n \"def get_main_points(neuron):\\n (branch_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 2)\\n (endpoint_index,) = np.where(neuron.branch_order[neuron.n_soma:] == 0)\\n selected_index = np.union1d(branch_index + neuron.n_soma,\\n endpoint_index + neuron.n_soma)\\n selected_index = np.append(range(neuron.n_soma), selected_index)\\n return selected_index\",\n \"def neighbours(indexing, random_stream=None):\\n\\n # pre-compute some necessary values\\n counts = compute_index_counts(indexing)\\n binary_sm = compute_binary_set_mappings(indexing, counts)\\n unary_sm = compute_unary_set_mappings(indexing, counts)\\n empty = find_empty(counts)\\n image = [idx for idx,count in enumerate(counts) if count != 0]\\n \\n def candidates(vertex, index, image, binary_sm, unary_sm, counts, empty):\\n \\\"\\\"\\\"generates the set of possible target indices for a given vertex\\n\\n :param vertex: the vertex\\n :type vertex: int\\n :param index: the current index of the vertex\\n :type index: int\\n :param image: the image of the current indexing\\n :type image: list\\n :param binary_sm: result of `compute_binary_set_mappings`\\n :type binary_sm: np.array[n,dtype=int]\\n :param unary_sm: result of `compute_unary_set_mappings`\\n :type unary_sm: np.array[n,dtype=int]\\n :param counts: number of vertices/index\\n :type counts: np.array[n,dtype=int]\\n :param empty: an index that is assigned no vertex, None is also allowed\\n :type empty: int/None\\n :yield: iterator over target indices\\n :rtype: Iterator[int]\\n \\\"\\\"\\\"\\n for k in image:\\n if k == index:\\n continue\\n if counts[index] > 1 or counts[k] > 1:\\n yield k\\n elif vertex < unary_sm[k]: # implicitly: counts[index]==1 and counts[k]==1\\n yield k\\n if counts[index] > 2 or (counts[index] == 2 and vertex==binary_sm[index]):\\n yield empty\\n \\n if random_stream is not None:\\n # Random Move-Enumeration\\n pweights = compute_probability_weights(indexing, counts, image, binary_sm)\\n vertices = np.random.choice(indexing.shape[0], random_stream, p=pweights)\\n for vertex in vertices:\\n index = indexing[vertex]\\n ks = list(candidates(vertex, index, image, binary_sm, unary_sm, counts, empty))\\n k = random.choice(ks)\\n yield vertex, k\\n else:\\n # Move-Enumeration\\n for vertex, index in enumerate(indexing):\\n for k in candidates(vertex, index, image, binary_sm, unary_sm, counts, empty):\\n yield vertex, k\",\n \"def test_extreme_neighborhoods(self):\\n\\n ## Radius = 0 ==> all points are noise\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.0,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 0)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"noise\\\"), self.n)\\n\\n ## Min_neighbors > 30 ==> all points are noise\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.0,\\n min_core_neighbors=31,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 0)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"noise\\\"), self.n)\\n\\n ## Radius very large ==> all points are core points\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=100.0,\\n min_core_neighbors=3,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 1)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"core\\\"), self.n)\\n\\n ## Min_neighbors = 0 ==> all points are core points\\n m = tc.dbscan.create(\\n self.sf,\\n distance=\\\"euclidean\\\",\\n radius=0.5,\\n min_core_neighbors=0,\\n verbose=False,\\n )\\n\\n self.assertEqual(m.num_clusters, 1)\\n self.assertEqual(sum(m.cluster_id[\\\"type\\\"] == \\\"core\\\"), self.n)\",\n \"def test_indexes_connectivity(epochs):\\n electrodes = analyses.indices_connectivity_intrabrain(epochs.epo1)\\n length = len(epochs.epo1.info['ch_names'])\\n L = []\\n for i in range(1, length):\\n L.append(length-i)\\n tot = sum(L)\\n assert len(electrodes) == tot\\n electrodes_hyper = analyses.indices_connectivity_interbrain(\\n epochs.epoch_merge)\\n assert len(electrodes_hyper) == length*length\\n # format that do not work for mne.spectral_connectivity\",\n \"def random_index(\\r\\n ngrid: int, nt: int, dim_subset: Union[tuple, list], warmup_length=0\\r\\n) -> tuple:\\r\\n batch_size, rho = dim_subset\\r\\n i_grid = np.random.randint(0, ngrid, [batch_size])\\r\\n i_t = np.random.randint(0 + warmup_length, nt - rho, [batch_size])\\r\\n return i_grid, i_t\",\n \"def get_random_neighbor(self):\\r\\n r_mask = np.random.randint(0, 2, 7)\\r\\n r_exp = np.random.randint(0, 2, 7)\\r\\n changes = r_mask*self.attr_factors*np.power(-1.0, r_exp)\\r\\n Sp = self.S + changes\\r\\n basal_C = Sp[4]\\r\\n Sp = np.maximum(Sp, 0.0)\\r\\n Sp[4] = basal_C\\r\\n return Sp\",\n \"def prepare4iCSD(self, index=0):\\n if (\\n self.surveys[index].x0_ini_guess == True\\n or self.surveys[index].x0_prior == True\\n ):\\n self._estimateM0_(index=index)\\n\\n # CONSTRAINSTED INVERSION\\n # -----------------------\\n # Create vector with weight (data weigth, constrainsts weight and regularisation weigth)\\n if self.surveys[index].x0_prior == True: # if relative smallness\\n self.reg_w_0_b, self.reg_w_0_A = regularize_w(\\n self.surveys[index].reg_A,\\n self.wr,\\n self.surveys[index].x0_prior,\\n x0=self.x0,\\n )\\n\\n # stack weight matrix\\n self.W_s_A, self.W_s_b = stack_w(\\n self.surveys[index].obs_w,\\n self.surveys[index].con_w,\\n self.surveys[index].x0_prior,\\n reg_w_0_A=self.reg_w_0_A,\\n reg_w_0_b=self.reg_w_0_b,\\n )\\n\\n # apply weight to A and b (data weigth, constrainsts weight and regularisation weigth)\\n self.A_w = weight_A(\\n self.surveys[index].x0_prior, self.surveys[index].A_s, W_s_A=self.W_s_A\\n )\\n self.b_w = weight_b(\\n self.surveys[index].x0_prior, self.surveys[index].b_s, W_s_b=self.W_s_b\\n )\\n\\n # UNCONSTRAINSTED INVERSION\\n # -------------------------\\n else:\\n self.reg_w = regularize_w(self.surveys[index].reg_A, self.wr, self.x0_prior)\\n\\n self.W_s = stack_w(\\n self.surveys[index].obs_w,\\n self.surveys[index].con_w,\\n self.x0_prior,\\n reg_w=self.reg_w,\\n )\\n self.A_w = weight_A(self.x0_prior, self.surveys[index].A_s, W_s=self.W_s)\\n self.b_w = weight_b(self.x0_prior, self.surveys[index].b_s, W_s=self.W_s)\",\n \"def n_finder_v2(gt_mat, x, eps):\\n numsnps = int(0.9*gt_mat.shape[0])\\n assert(x < numsnps)\\n assert(eps > 0 and eps<= 1.0)\\n n = 0\\n avg_array = np.zeros(gt_mat.shape[0])\\n going = True\\n while going:\\n indices = np.random.choice(numsnps, size=x, replace=False)\\n r2_list = [np.corrcoef(gt_mat[i,:],gt_mat[i+n,:])[0,1]**2 for i in indices]\\n avg_array[n] = np.nanmean(r2_list)\\n n += 1\\n if np.mean(r2_list) < eps:\\n going = False \\n return n,avg_array[:n]\",\n \"def omission_index(n, sample_size):\\n \\n \\\"randomly pick some subset of sample_size agents\\\"\\n index = np.sort(np.random.choice(n,sample_size,replace=False))\\n \\\"double up index to choose x and y positions columns. both are used.\\\"\\n index2 = np.repeat(2*index,2) \\n \\\"nudge every second item to take the ith+1 column (y coordinate corresponding to chosen x)\\\"\\n index2[1::2] += 1\\n return index, index2\",\n \"def get_state(tip_speed):\\n states = np.linspace(-3,3,num=discretization) # Discretized table of tip speeds. Range of 3 indicates possible speeds\\n for rounded_tip_speed in states:\\n if rounded_tip_speed >= tip_speed:\\n index = np.where(states == rounded_tip_speed)\\n index = index[0][0]\\n return index\",\n \"def _choose_sample(self):\\n\\n \\t #periodically generate a new reconstruction for the purposes of sampling\",\n \"def select_move(self, from_search=False, verbose=False) -> Tuple[int, str]:\\n node = self.current\\n c0 = 1\\n N = sum(e.visits for e in node.edges) + c0\\n eps = self.cpuct * len(node.edges) * np.sqrt(N)\\n ucb = [e.value + eps * e.prior / (c0 + e.visits) for e in node.edges]\\n\\n if from_search:\\n #\\n tau = 0.01 + self.temperature *\\\\\\n (1.0 - self.current.level() / self.max_steps)\\n\\n probs = [(e.search_outcome + 0.01)**(1/tau) for e in node.edges]\\n probs = np.array(probs) / sum(probs)\\n dnoise = np.random.dirichlet(np.ones(len(probs)))\\n eps = self.dnoise\\n probs = (1.0 - eps) * probs + eps * dnoise\\n\\n # chooce proportionally\\n index = np.random.choice(np.arange(len(probs)), p=probs)\\n # index = np.argmax(probs)\\n msg = \\\"Chooosing {} with probability {:.4f}\\\"\\n print(msg.format(node.edges[index].cmd, probs[index]))\\n else:\\n node = self.current\\n index = np.argmax(ucb)\\n\\n if verbose:\\n msg = \\\"NODE: Visits: {}, Reward: {:.2f}, \\\" +\\\\\\n \\\"Score: {:.2f}, Envscore: {}\\\"\\n print(msg.format(\\n node.visits, node.reward, node.score, node.envscore))\\n # print(\\\"CMD HISTORY:\\\", node.cmd_history(cmds_only=True))\\n\\n values = [e.value for e in node.edges]\\n counts = [e.search_outcome for e in node.edges]\\n cmds = [e.cmd for e in node.edges]\\n priors = [e.prior for e in node.edges]\\n ix = range(len(node.edges))\\n\\n msg = ''.join((\\\"EDGE {}: V: {:.2f}, P: {:.2f}, S: {}, \\\",\\n \\\"UCB: {:.2f}, cmd: {} SP: {:.2f}\\\"))\\n if not from_search:\\n probs = np.zeros(len(node.edges))\\n\\n for i, c, p, v, n, u, r in zip(ix, cmds, priors,\\n values, counts, ucb, probs):\\n print(msg.format(i, v, p, n, u, c, r))\\n\\n edge = node.edges[index]\\n edge.search_outcome += 1\\n\\n return index, edge.cmd\",\n \"def greedy_selector(self):\\n r_k = 0 \\n best_route = []\\n cities_to_visit = [i for i in range(1, self.city_count)]\\n for _ in range(1, self.city_count):\\n s_ind = np.argmax([self.tau[(r_k, u)] for u in cities_to_visit])\\n s_k = cities_to_visit.pop(s_ind)\\n best_route.append((r_k, s_k))\\n r_k = s_k\\n best_route.append((r_k, 0))\\n \\n shortest_path = np.sum([self.phi[(p)] for p in best_route])\\n return best_route, shortest_path\",\n \"def n_finder(gt_mat, x, eps):\\n numsnps = int(0.9*gt_mat.shape[0])\\n assert(x < numsnps)\\n assert(eps > 0 and eps<= 1.0)\\n indices = np.random.choice(numsnps, size=x, replace=False)\\n n = 0\\n avg_array = np.zeros(gt_mat.shape[0])\\n going = True\\n while going:\\n r2_list = [np.corrcoef(gt_mat[i,:],gt_mat[i+n,:])[0,1]**2 for i in indices]\\n avg_array[n] = np.nanmean(r2_list)\\n n += 1\\n if np.mean(r2_list) < eps:\\n going = False \\n return n,avg_array[:n]\",\n \"def select(self, batch_size):\\n\\n #if self.tree.filled_size() < batch_size:\\n # print('CALLING REPLAY SAMPLING WHEN NOT FULL ENOUGH')\\n # #return None, None\\n\\n out = []\\n indices = []\\n #weights = []\\n priorities = []\\n avoid_resampling = False\\n for _ in range(batch_size):\\n r = random.random()\\n #return (idx, self.tree[idx], self.data[dataIdx])\\n data, priority, index = self.tree.find(r)\\n #index, priority, data = self.tree.find(r)\\n #print(index)\\n #print(\\\"d: {}, \\\\n priority: {}, \\\\n index: {}\\\".format(data, priority, index))\\n priorities.append(priority)\\n #weights.append((1. / self.memory_size / priority) ** beta if priority > 1e-16 else 0)\\n indices.append(index)\\n out.append(data)\\n if avoid_resampling: self.priority_update([index], [self.epsilon_priority]) # To avoid resampling same transition too much\\n\\n for i in range(len(priorities)):\\n if priorities[i] >= self.bonus_priority: # remove priority bonus\\n priorities[i] -= self.bonus_priority\\n self.priority_update([indices[i]],[priorities[i]])\\n\\n # avoid resampling part self.priority_update(indices, priorities) # Revert priorities\\n #weights /= max(weights) # Normalize for stability\\n return out, indices\",\n \"def test_subset_reconstruction_iterable(self, wires):\\n circuit = hadamard_circuit(wires)\\n bits, recipes = circuit()\\n shadow = ClassicalShadow(bits, recipes)\\n\\n # choose 1000 random indices\\n snapshots = np.random.choice(np.arange(10000, dtype=np.int64), size=1000, replace=False)\\n state = shadow.global_snapshots(snapshots=snapshots)\\n assert state.shape == (len(snapshots), 2**wires, 2**wires)\\n\\n # check the results against obtaining the full global snapshots\\n expected = shadow.global_snapshots()\\n for i, t in enumerate(snapshots):\\n assert np.allclose(expected[t], state[i])\",\n \"def select_random_node(cluster_ips):\\n return random.choice(cluster_ips)\",\n \"def __init__(self, n4, L, k, randomize=False, non_k=-1, given_weight_matrix = None):\\n\\n self.n4 = n4\\n self.L = L\\n self.k = k\\n self.weightMatrix = numpy.full((self.n4, self.L), non_k, dtype=numpy.int16)\\n\\n # initializing from the start\\n if given_weight_matrix == None: \\n if randomize == \\\"True\\\":\\n #initialize weight matrix: for each stimulus, pick k neurons that respond randomly\\n for stim in range(self.L):\\n # randomly samples k neurons to respond (out of n4)\\n responds = random.sample(range(n4), k=self.k)\\n # updates the values of those k neurons' responses to stimulus \\n for nrn in responds: \\n self.weightMatrix[nrn][stim] = 1\\n else:\\n start_nrn = 0\\n # the first k neurons respond to first stimulus, and so on\\n for stim in range(self.L):\\n for nrn_offset in range(self.k):\\n self.weightMatrix[start_nrn + nrn_offset][stim] = 1\\n start_nrn += self.k\\n\\n # initializing from previous weight matrix, given as string or as prepared weight matrix\\n else: \\n if type(given_weight_matrix) is str:\\n l4_weight_list = [int(i) for i in given_weight_matrix.split(\\\",\\\")]\\n \\n if len(l4_weight_list) != (self.n4 * self.L):\\n print(\\\"Error! String provided to initialize L4 weight matrix must have length n4 * L.\\\")\\n sys.exit(1)\\n\\n for nrn in range(self.n4):\\n start = nrn * self.L \\n end = start + self.L\\n self.weightMatrix[nrn] = numpy.array(l4_weight_list[start:end])\\n else:\\n if given_weight_matrix.shape != (n4, L):\\n print(\\\"Error! Matrix provided to initialize L4 weight matrix must have shape (n4, L)\\\")\\n sys.exit(1)\\n self.weightMatrix = given_weight_matrix\",\n \"def _sample(self, rnn_output, temperature):\\n pass\",\n \"def best_move(data, indexing, cf, cf_prime, N=20, M=30): \\n stats = {}\\n timer = time()\\n ns = list(neighbours(indexing, random_stream=N))\\n stats[\\\"n_neighbours\\\"] = len(ns)\\n stats[\\\"t_neighbours\\\"] = 1000*(time() - timer)\\n\\n dt_rcs = []\\n bestpair, best_rcost = None, None\\n for v,k in ns:\\n timer = time()\\n rc = reduced_cost(data, indexing, cf, cf_prime, v, k, uw_sample_count=M)\\n dt_rcs.append(1000*(time() - timer))\\n if bestpair is None or rc > best_rcost:\\n bestpair = v,k\\n best_rcost = rc\\n\\n stats[\\\"t_rcs_mean\\\"] = np.mean(dt_rcs)\\n stats[\\\"t_rcs_std\\\"] = np.std(dt_rcs)\\n stats[\\\"t_rcs_sum\\\"] = np.sum(dt_rcs)\\n stats[\\\"rc\\\"] = best_rcost\\n stats[\\\"partcount\\\"] = np.unique(indexing).shape[0]\\n return bestpair, best_rcost, stats\",\n \"def test_lifted_index():\\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\\n 400.]) * units.hPa\\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\\n -23.5]) * units.degC\\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\\n -57.5]) * units.degC\\n parcel_prof = parcel_profile(pressure, temperature[0], dewpoint[0])\\n li = lifted_index(pressure, temperature, parcel_prof)\\n assert_almost_equal(li, -7.9115691 * units.delta_degree_Celsius, 2)\",\n \"def two_temps(L, n_cycles, temp):\\n\\n E = np.zeros((2, len(temp), n_cycles))\\n Mag = np.zeros((2, len(temp), n_cycles))\\n MagAbs = np.zeros((2, len(temp), n_cycles))\\n SH = np.zeros((2, len(temp), n_cycles))\\n Suscept = np.zeros((2, len(temp), n_cycles))\\n\\n Naccept = np.zeros((2, len(temp), n_cycles))\\n\\n ground_spin_mat = np.ones((L, L), np.int8) # initial state (ground state)\\n\\n for m in range(2):\\n for t in range(len(temp)):\\n\\n #m=0 is ground state, all spin-up\\n #m=1 is random state\\n if m==0:\\n spin_matrix = ground_spin_mat\\n else:\\n s_mat_random = np.ones((L, L), np.int8) # spin matrix of ones\\n #random indices switched to -1\\n for sw in range(len(s_mat_random)):\\n for sl in range(len(s_mat_random)):\\n rint = np.random.randint(-1,1)\\n if rint == -1:\\n s_mat_random[sw,sl] *= -1\\n spin_matrix = s_mat_random\\n\\n\\n print(\\\"hi\\\")#; sys.exit(1)\\n Energy, Magnetization, MagnetizationAbs, SpecificHeat, Susceptibility, Nacc \\\\\\n = numerical_solution(spin_matrix, n_cycles, temp[t], L, abs=False)\\n\\n\\n E[m,t,:] = Energy\\n Mag[m,t,:] = Magnetization\\n MagAbs[m,t,:] = MagnetizationAbs\\n SH[m,t,:] = SpecificHeat\\n Suscept[m,t,:] = Susceptibility\\n\\n Naccept[m,t,:] = Nacc\\n\\n return E, Mag, MagAbs, SH, Suscept, Naccept\",\n \"def choose_best_neighbour_simple(self):\\n\\t\\trejected = set([]) #list of prohibited indexes which are rejected because of tabu and energy\\n\\t\\tnIndex = -1\\n\\t\\twhile(True):\\n\\t\\t\\tnIndex = self._find_min_diff(rejected=rejected)\\t\\t#index of best neighbor\\n\\n\\t\\t\\tif self.is_tabu(nIndex):\\n\\t\\t\\t\\toutput(message=\\\"\\\\t Neuron is in tabu. Need to check the aspiration criteria\\\",isDebug=True)\\n\\t\\t\\t\\tif self.aspiration_criteria_satisfied(nIndex):\\n\\t\\t\\t\\t\\tbreak\\n\\t\\t\\t\\telse:\\n\\t\\t\\t\\t\\trejected.add(nIndex)\\n\\t\\t\\telse:\\n\\t\\t\\t\\tbreak\\n\\t\\t# output(\\\"Neuron is found\\\",isDebug=True)\\n\\t\\treturn nIndex\",\n \"def test_sweat_index():\\n pressure = np.array([1008., 1000., 947., 925., 921., 896., 891., 889., 866.,\\n 858., 850., 835., 820., 803., 733., 730., 700., 645.,\\n 579., 500., 494., 466., 455., 441., 433., 410., 409.,\\n 402., 400., 390., 388., 384., 381., 349., 330., 320.,\\n 306., 300., 278., 273., 250., 243., 208., 200., 196.,\\n 190., 179., 159., 151., 150., 139.]) * units.hPa\\n temperature = np.array([27.4, 26.4, 22.9, 21.4, 21.2, 20.7, 20.6, 21.2, 19.4,\\n 19.1, 18.8, 17.8, 17.4, 16.3, 11.4, 11.2, 10.2, 6.1,\\n 0.6, -4.9, -5.5, -8.5, -9.9, -11.7, -12.3, -13.7, -13.8,\\n -14.9, -14.9, -16.1, -16.1, -16.9, -17.3, -21.7, -24.5, -26.1,\\n -28.3, -29.5, -33.1, -34.2, -39.3, -41., -50.2, -52.5, -53.5,\\n -55.2, -58.6, -65.2, -68.1, -68.5, -72.5]) * units.degC\\n dewpoint = np.array([24.9, 24.6, 22., 20.9, 20.7, 14.8, 13.6, 12.2, 16.8,\\n 16.6, 16.5, 15.9, 13.6, 13.2, 11.3, 11.2, 8.6, 4.5,\\n -0.8, -8.1, -9.5, -12.7, -12.7, -12.8, -13.1, -24.7, -24.4,\\n -21.9, -24.9, -36.1, -31.1, -26.9, -27.4, -33., -36.5, -47.1,\\n -31.4, -33.5, -40.1, -40.8, -44.1, -45.6, -54., -56.1, -56.9,\\n -58.6, -61.9, -68.4, -71.2, -71.6, -77.2]) * units.degC\\n speed = np.array([0., 3., 10., 12., 12., 14., 14., 14., 12.,\\n 12., 12., 12., 11., 11., 12., 12., 10., 10.,\\n 8., 5., 4., 1., 0., 3., 5., 10., 10.,\\n 11., 11., 13., 14., 14., 15., 23., 23., 24.,\\n 24., 24., 26., 27., 28., 30., 25., 24., 26.,\\n 28., 33., 29., 32., 26., 26.]) * units.knot\\n direction = np.array([0., 170., 200., 205., 204., 200., 197., 195., 180.,\\n 175., 175., 178., 181., 185., 160., 160., 165., 165.,\\n 203., 255., 268., 333., 0., 25., 40., 83., 85.,\\n 89., 90., 100., 103., 107., 110., 90., 88., 87.,\\n 86., 85., 85., 85., 60., 55., 60., 50., 46.,\\n 40., 45., 35., 50., 50., 50.]) * units.degree\\n\\n sweat = sweat_index(pressure, temperature, dewpoint, speed, direction)\\n assert_almost_equal(sweat, 227., 2)\",\n \"def select(individuals, n):\\r\\n # return selBest(individuals, n)\\r\\n return individuals[:n]\",\n \"def compute_rwse(self, traffic_density):\\r\\n # Ensure experiment has not beem done before\\r\\n np.random.seed(2020)\\r\\n file_names = os.listdir(self.dirName)\\r\\n if traffic_density+'rwse' in file_names:\\r\\n print(\\\"This experiment has been done already!\\\")\\r\\n return None\\r\\n elif traffic_density == '':\\r\\n print(\\\"select a traffic dinsity level!\\\")\\r\\n return None\\r\\n rwse_dict = {'vel_m':0,\\r\\n 'lat_vel':1,\\r\\n 'vel_y':2,\\r\\n 'vel_f':3,\\r\\n 'vel_fadj':4}\\r\\n\\r\\n pred_step_n = self.pred_h*10+1\\r\\n splits_n = 6 # number of splits across an entire trajectory\\r\\n pred_arrs = [np.zeros([self.episode_n*self.traj_n*6,\\r\\n pred_step_n]) for i in range(5)]\\r\\n truth_arrs = [np.zeros([self.episode_n*self.traj_n*6,\\r\\n pred_step_n]) for i in range(5)]\\r\\n _row = 0\\r\\n\\r\\n for episode_id in self.test_data.test_episodes[:self.episode_n]:\\r\\n # for episode_id in [1289]:\\r\\n st_seq, cond_seq, st_arr, targ_arr = self.episodeSetup(episode_id)\\r\\n self.gen_model.max_pc = max(st_arr[:, self.gen_model.indx_m['pc']])\\r\\n self.gen_model.min_pc = min(st_arr[:, self.gen_model.indx_m['pc']])\\r\\n if len(st_seq) >= 6:\\r\\n splits_n = 6\\r\\n else:\\r\\n splits_n = len(st_seq)\\r\\n obs_n = self.test_data.data_obj.obs_n\\r\\n traj_splits = np.random.choice(range(19, 19+len(st_seq)), splits_n, replace=False)\\r\\n # leave value of 19 to ensure scenarios remain consistent\\r\\n for split in traj_splits:\\r\\n st_seq_i, cond_seq_i, bc_der_i, _, st_i, targ_i = self.sceneSetup(st_seq,\\r\\n cond_seq,\\r\\n st_arr,\\r\\n targ_arr,\\r\\n current_step=split,\\r\\n pred_h=self.pred_h)\\r\\n targ_i.shape = (1, pred_step_n, 5)\\r\\n st_init = np.repeat(np.reshape(st_i[0,:], [1,17]), self.traj_n, axis=0)\\r\\n\\r\\n actions, _, _ = self.policy.get_actions([st_seq_i, cond_seq_i], bc_der_i,\\r\\n traj_n=self.traj_n, pred_h=self.pred_h)\\r\\n st_pred = self.gen_model.forwardSim(st_init, actions, pred_step_n)\\r\\n\\r\\n truth_arrs[0][_row:_row+self.traj_n, :] = \\\\\\r\\n st_i[:,self.gen_model.indx_m['vel']]\\r\\n pred_arrs[0][_row:_row+self.traj_n, :] = \\\\\\r\\n st_pred[:,:,self.gen_model.indx_m['vel']]\\r\\n\\r\\n truth_arrs[1][_row:_row+self.traj_n, :] = \\\\\\r\\n st_i[:,self.gen_model.indx_m['act_lat_p']]\\r\\n pred_arrs[1][_row:_row+self.traj_n, :] = \\\\\\r\\n st_pred[:,:,self.gen_model.indx_m['act_lat_p']]\\r\\n\\r\\n truth_arrs[2][_row:_row+self.traj_n, :] = \\\\\\r\\n st_i[:,self.gen_model.indx_y['vel']]\\r\\n pred_arrs[2][_row:_row+self.traj_n, :] = \\\\\\r\\n st_pred[:,:,self.gen_model.indx_y['vel']]\\r\\n\\r\\n truth_arrs[3][_row:_row+self.traj_n, :] = \\\\\\r\\n st_i[:,self.gen_model.indx_f['vel']]\\r\\n pred_arrs[3][_row:_row+self.traj_n, :] = \\\\\\r\\n st_pred[:,:,self.gen_model.indx_f['vel']]\\r\\n\\r\\n truth_arrs[4][_row:_row+self.traj_n, :] = \\\\\\r\\n st_i[:,self.gen_model.indx_fadj['vel']]\\r\\n pred_arrs[4][_row:_row+self.traj_n, :] = \\\\\\r\\n st_pred[:,:,self.gen_model.indx_fadj['vel']]\\r\\n\\r\\n\\r\\n _row += self.traj_n\\r\\n # return st_pred\\r\\n print('Episode ', episode_id, ' has been completed!')\\r\\n for key in rwse_dict.keys():\\r\\n rwse_dict[key] = self.root_weightet_sqr(truth_arrs[rwse_dict[key]], \\\\\\r\\n pred_arrs[rwse_dict[key]])\\r\\n\\r\\n with open(self.dirName+'/'+ traffic_density + 'rwse', \\\"wb\\\") as f:\\r\\n pickle.dump(rwse_dict, f)\\r\\n return rwse_dict\",\n \"def test_should_only_get_specific_indices(self):\\n print(\\\"Testing that get_region returns correct amount of data\\\")\\n\\n test_many = get_region_data(self.wmo_boxes, self.float_name, self.config,\\n self.index, self.pres)\\n\\n self.assertTrue(test_many[0].shape[1] == self.index.__len__())\\n\\n test_one = get_region_data(self.wmo_boxes, self.float_name, self.config,\\n [50], self.pres)\\n\\n self.assertTrue(test_one[0].shape[1] == 1)\",\n \"def constructConnMatrices(nE=4000, nI=1000, n_clusters=50,\\n pEE=.2, pEI=.5, pIE=.5, pII=.5, rEE=1.0,\\n jEE_out=0.024, jEE_in=1.9, jEI=0.014, jIE=-0.045, jII=-0.057): # Need to add synaptic strengths\\n # Structural connectivity (probabilities taken from Litwin-Kumar & Doiron, 2012)\\n if rEE==1:\\n sEE = np.random.binomial(1,pEE,size=(nE,nE))\\n wEE = sEE*jEE_out\\n else:\\n neurons_per_clust = int(nE/float(n_clusters))\\n pEE_out = (pEE*(nE-1))/(rEE*neurons_per_clust + (nE-1) - neurons_per_clust)\\n pEE_in = rEE*pEE_out\\n\\n # First define all pEE_out connections\\n sEE = np.random.binomial(1,pEE_out,size=(nE,nE))\\n wEE = sEE * jEE_out\\n # Now we will re-do clustered connections\\n neuron_count = 0\\n for clust in range(n_clusters):\\n i = int(neuron_count)\\n j = int(neuron_count + neurons_per_clust)\\n sEE[i:j,i:j] = 0\\n sEE[i:j,i:j] = np.random.binomial(1,pEE_in,size=(neurons_per_clust,neurons_per_clust))\\n wEE[i:j,i:j] = sEE[i:j,i:j] * jEE_in\\n neuron_count += neurons_per_clust\\n\\n # No self connections\\n np.fill_diagonal(wEE,0)\\n\\n # Structural matrices\\n sEI = np.random.binomial(1,pEI,size=(nE,nI))\\n sIE = np.random.binomial(1,pIE,size=(nI,nE))\\n sII = np.random.binomial(1,pII,size=(nI,nI))\\n\\n # Synaptic weights\\n wEI = sEI * jEI\\n wIE = sIE * jIE\\n wII = sII * jII\\n\\n # No self connections\\n np.fill_diagonal(wII,0)\\n\\n return wEE, wEI, wIE, wII\",\n \"def setValue(matrix, line, indexRef, noiseLevel):\\n #print \\\"getValue for \\\", value, noiseLevel\\n maxIndex = matrix.shape[0] - 1\\n sum = 0\\n summedItems = 0\\n \\n if line[0][0] == 3 and indexRef[3,0] < maxIndex:\\n return\\n if line[0][1] == 3 and indexRef[3,1] < maxIndex:\\n return\\n if line[0][2] == 3 and indexRef[3,2] < maxIndex:\\n return\\n \\n for i in range(1, len(line)):\\n point = line[i]\\n r = indexRef[point[0],0]\\n c = indexRef[point[1],1]\\n f = indexRef[point[2],2]\\n if r >= 0 and c >= 0 and f >= 0 and matrix[r,c,f] >= 0:\\n sum += matrix[r,c,f]\\n summedItems += 1\\n value = 0\\n average = 0\\n if (summedItems > 0):\\n average = sum / float(summedItems)\\n \\n # determine the target index\\n r = indexRef[line[0][0],0]\\n c = indexRef[line[0][1],1]\\n f = indexRef[line[0][2],2]\\n # set the target cell \\n matrix[r,c,f] = (noiseLevel * random.random()) + ((1-noiseLevel) * average)\\n \\n #print \\\"setting\\\", r, c, f, \\\"to \\\", matrix[r, c, f]\",\n \"def spectralIndices(\\n x: Union[ee.Image, ee.ImageCollection],\\n index: Union[str, List[str]] = \\\"NDVI\\\",\\n G: Union[float, int] = 2.5,\\n C1: Union[float, int] = 6.0,\\n C2: Union[float, int] = 7.5,\\n L: Union[float, int] = 1.0,\\n cexp: Union[float, int] = 1.16,\\n nexp: Union[float, int] = 2.0,\\n alpha: Union[float, int] = 0.1,\\n slope: Union[float, int] = 1.0,\\n intercept: Union[float, int] = 0.0,\\n gamma: Union[float, int] = 1.0,\\n kernel: str = \\\"RBF\\\",\\n sigma: Union[float, str] = \\\"0.5 * (a + b)\\\",\\n p: Union[float, int] = 2,\\n c: Union[float, int] = 1.0,\\n online: bool = False,\\n drop: bool = False,\\n) -> Union[ee.Image, ee.ImageCollection]:\\n platformDict = _get_platform_STAC(x)\\n\\n if isinstance(sigma, int) or isinstance(sigma, float):\\n if sigma < 0:\\n raise Exception(f\\\"[sigma] must be positive! Value passed: sigma = {sigma}\\\")\\n\\n if p <= 0 or c < 0:\\n raise Exception(\\n f\\\"[p] and [c] must be positive! Values passed: p = {p}, c = {c}\\\"\\n )\\n\\n additionalParameters = {\\n \\\"g\\\": float(G),\\n \\\"C1\\\": float(C1),\\n \\\"C2\\\": float(C2),\\n \\\"L\\\": float(L),\\n \\\"cexp\\\": float(cexp),\\n \\\"nexp\\\": float(nexp),\\n \\\"alpha\\\": float(alpha),\\n \\\"sla\\\": float(slope),\\n \\\"slb\\\": float(intercept),\\n \\\"gamma\\\": float(gamma),\\n \\\"p\\\": float(p),\\n \\\"c\\\": float(c),\\n }\\n\\n spectralIndices = _get_indices(online)\\n indicesNames = list(spectralIndices.keys())\\n\\n if not isinstance(index, list):\\n if index == \\\"all\\\":\\n index = list(spectralIndices.keys())\\n elif index in [\\n \\\"vegetation\\\",\\n \\\"burn\\\",\\n \\\"water\\\",\\n \\\"snow\\\",\\n \\\"drought\\\",\\n \\\"urban\\\",\\n \\\"kernel\\\",\\n ]:\\n temporalListOfIndices = []\\n for idx in indicesNames:\\n if spectralIndices[idx][\\\"type\\\"] == index:\\n temporalListOfIndices.append(idx)\\n index = temporalListOfIndices\\n else:\\n index = [index]\\n\\n for idx in index:\\n if idx not in list(spectralIndices.keys()):\\n warnings.warn(\\n f\\\"Index {idx} is not a built-in index and it won't be computed!\\\"\\n )\\n else:\\n\\n def temporalIndex(img):\\n lookupDic = _get_expression_map(img, platformDict)\\n lookupDic = {**lookupDic, **additionalParameters}\\n kernelParameters = _get_kernel_parameters(img, lookupDic, kernel, sigma)\\n lookupDic = {**lookupDic, **kernelParameters}\\n lookupDicCurated = _remove_none_dict(lookupDic)\\n if all(\\n band in list(lookupDicCurated.keys())\\n for band in spectralIndices[idx][\\\"bands\\\"]\\n ):\\n return img.addBands(\\n img.expression(\\n spectralIndices[idx][\\\"formula\\\"], lookupDicCurated\\n ).rename(idx)\\n )\\n else:\\n warnings.warn(\\n f\\\"This platform doesn't have the required bands for {idx} computation!\\\"\\n )\\n return img\\n\\n if isinstance(x, ee.imagecollection.ImageCollection):\\n x = x.map(temporalIndex)\\n elif isinstance(x, ee.image.Image):\\n x = temporalIndex(x)\\n\\n if drop:\\n x = x.select(index)\\n\\n return x\",\n \"def random_select_revealed_node(self, alpha, index1, index2):\\n same_nodes = set(self.graphs[index1].nodes()) & set(self.graphs[index2].nodes())\\n s = int(alpha * len(same_nodes))\\n logging.info(\\\"graph {}-{} random revealed nodes {}/{}.\\\".format\\n (index1, index2, s, len(same_nodes)))\\n revealed_nodes = random.sample(same_nodes, s)\\n self.revealed_nodes[(index1, index2)] = set(revealed_nodes)\\n self.same_nodes[(index1, index2)] = same_nodes\\n return revealed_nodes\",\n \"def get_neighbour(self, sol):\\n std_dev = min(np.sqrt(self._temp), (self.domain[1]-self.domain[0])/3/self.cool_rate)\\n solution = [None] * self.dimensions\\n for i in range(self.dimensions):\\n #rand = np.random.uniform(-np.pi/2, np.pi/2)\\n #solution[i] = self.bind(sol[i] + self.cool_rate * self.T * np.tan(rand))\\n solution[i] = self.bind(sol[i] + np.random.normal(0, 1) * std_dev * self.cool_rate)\\n return solution\",\n \"def select(weights):\\n r = random.random() * sum(weights)\\n s = 0.0\\n for k,w in enumerate(weights):\\n s += w\\n if r <= s:\\n return k\\n raise RuntimeError(\\\"select WTF from %s\\\" % weights)\",\n \"def weighted_random_choice(self, cands):\\n # Only consider the entries with the highest priority (lowest service priority value)\\n lowest_priority = min(conn.srv_priority for conn in cands)\\n result = [conn for conn in cands if conn.srv_priority == lowest_priority]\\n result.sort(key=lambda a: a.weight)\\n if not result:\\n raise LVPError(\\\"No connection available for cloning\\\")\\n\\n total_weight = sum(e.weight for e in result)\\n random_pos = random.random() * total_weight\\n weight_pos = 0.0\\n for conn in result:\\n weight_pos += conn.weight\\n if weight_pos >= random_pos:\\n return conn\\n\\n assert False, \\\"execution should never end up here\\\"\",\n \"def test_k_index():\\n pressure = np.array([1014., 1000., 997., 981.2, 947.4, 925., 914.9, 911.,\\n 902., 883., 850., 822.3, 816., 807., 793.2, 770.,\\n 765.1, 753., 737.5, 737., 713., 700., 688., 685.,\\n 680., 666., 659.8, 653., 643., 634., 615., 611.8,\\n 566.2, 516., 500., 487., 484.2, 481., 475., 460.,\\n 400.]) * units.hPa\\n temperature = np.array([24.2, 24.2, 24., 23.1, 21., 19.6, 18.7, 18.4,\\n 19.2, 19.4, 17.2, 15.3, 14.8, 14.4, 13.4, 11.6,\\n 11.1, 10., 8.8, 8.8, 8.2, 7., 5.6, 5.6,\\n 5.6, 4.4, 3.8, 3.2, 3., 3.2, 1.8, 1.5,\\n -3.4, -9.3, -11.3, -13.1, -13.1, -13.1, -13.7, -15.1,\\n -23.5]) * units.degC\\n dewpoint = np.array([23.2, 23.1, 22.8, 22., 20.2, 19., 17.6, 17.,\\n 16.8, 15.5, 14., 11.7, 11.2, 8.4, 7., 4.6,\\n 5., 6., 4.2, 4.1, -1.8, -2., -1.4, -0.4,\\n -3.4, -5.6, -4.3, -2.8, -7., -25.8, -31.2, -31.4,\\n -34.1, -37.3, -32.3, -34.1, -37.3, -41.1, -37.7, -58.1,\\n -57.5]) * units.degC\\n ki = k_index(pressure, temperature, dewpoint)\\n assert_almost_equal(ki, 33.5 * units.degC, 2)\",\n \"def __init__(self,\\n name,\\n vertices_location,\\n connectivity,\\n connectivity_ids=None,\\n connectivity_label=None,\\n connectivity_label_metadata=None,\\n connectivity_colormap = None,\\n connector_size=2.6,\\n global_deselect_alpha=0.2,\\n global_select_alpha=1.0,\\n skeleton_linewidth=2.0):\\n super(Microcircuit, self).__init__( name )\\n\\n if not connectivity_ids is None:\\n self.connectivity_ids = connectivity_ids\\n\\n if not connectivity_label is None:\\n self.connectivity_labels = connectivity_label\\n\\n if not connectivity_label_metadata is None:\\n\\n for semanticdict in connectivity_label_metadata:\\n # name needs to be based on convention, TODO: best from ontology id rather than string!\\n # TODO: use microcircuit convention\\n if semanticdict.has_key(\\\"name\\\"):\\n name = semanticdict[\\\"name\\\"]\\n if \\\"skeleton\\\" in name:\\n self.con_skeleton = int(semanticdict[\\\"value\\\"])\\n elif \\\"presynaptic\\\" in name:\\n self.con_pre = int(semanticdict[\\\"value\\\"])\\n elif \\\"postsynaptic\\\" in name:\\n self.con_post = int(semanticdict[\\\"value\\\"])\\n\\n else:\\n # TODO: default\\n self.con_skeleton = 1\\n self.con_pre = 2\\n self.con_post = 3\\n\\n # selection stores integer ids from connectivity_selectionID\\n # when selected\\n self.skeleton_selection = []\\n\\n # use the connectivity labels to extract the connectivity for the skeletons\\n self.index_skeleton = np.where(self.connectivity_labels == self.con_skeleton)[0]\\n self.index_allpre = np.where(self.connectivity_labels == self.con_pre)[0]\\n self.index_allpost = np.where(self.connectivity_labels == self.con_post)[0]\\n \\n self.vertices = vertices_location\\n self.connectivity = connectivity\\n\\n connectivity_skeleton = self.connectivity[self.index_skeleton]\\n self.vertices_skeleton = self.vertices[ connectivity_skeleton.ravel() ]\\n \\n # we have a simplified connectivity now\\n self.connectivity_skeleton = np.array( range(len(self.vertices_skeleton)), dtype = np.uint32 )\\n self.connectivity_skeleton = self.connectivity_skeleton.reshape( (len(self.connectivity_skeleton)/2, 2) )\\n self.connectivity_ids_skeleton = self.connectivity_ids[ self.index_skeleton ]\\n\\n # look up the start and end vertex id\\n # map these to _skeleton arrays, and further to actor???\\n\\n # colors for skeletons\\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_skeleton ):\\n self.connectivity_skeleton_colors = np.repeat(connectivity_colormap[self.con_skeleton], len(self.connectivity_skeleton), axis=0).astype( np.float32 )\\n\\n ##########\\n # Incoming connectors\\n ##########\\n\\n # extract the pre connectivity and create cones\\n # store the indices for to be used to create the vector scatter\\n # by itself, it represent implicitly the index used to select/deselect the vectors\\n if len(self.index_allpre) == 0:\\n if DEBUG:\\n print \\\"no presynaptic connection\\\"\\n self.pre_actor = None\\n else:\\n self.vertices_pre = self.vertices[ connectivity[self.index_allpre].ravel() ]\\n self.pre_p1 = self.vertices_pre[::2, :] # data is NOT copied here\\n self.pre_p2 = self.vertices_pre[1::2, :]\\n pren = len(self.index_allpre)\\n r1 = np.ones( pren, dtype = np.float32 ) * connector_size\\n r2 = np.zeros( pren, dtype = np.float32 )\\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_pre ):\\n preval = np.ones( pren, dtype = np.dtype(type(self.con_pre)) ) * self.con_pre\\n else:\\n preval = None\\n self.pre_actor = VectorScatter( \\\"PreConnector\\\", self.pre_p1, self.pre_p2, r1, r2, values = preval,\\n resolution = 8, colormap = connectivity_colormap )\\n # len(self.index_pre) = len(self.pre_p1) = len(preval)\\n\\n ##########\\n # Outgoing connectors\\n ##########\\n\\n # extract the post connectivity and create cones\\n if len(self.index_allpost) == 0:\\n if DEBUG:\\n print \\\"no postsynaptic connection\\\"\\n self.post_actor = None\\n else:\\n self.vertices_post = self.vertices[ connectivity[self.index_allpost].ravel() ]\\n self.post_p1 = self.vertices_post[::2, :]\\n self.post_p2 = self.vertices_post[1::2, :]\\n postn = len(self.index_allpost)\\n r1 = np.zeros( postn, dtype = np.float32 )\\n r2 = np.ones( postn, dtype = np.float32 ) * connector_size\\n if isinstance(connectivity_colormap, dict) and connectivity_colormap.has_key( self.con_post ):\\n postval = np.ones( postn, dtype = np.dtype(type(self.con_post)) ) * self.con_post\\n else:\\n postval = None\\n self.post_actor = VectorScatter( \\\"PostConnector\\\", self.post_p1, self.post_p2, r1, r2, values = postval,\\n resolution = 8, colormap = connectivity_colormap )\\n\\n ##########\\n # Skeletons\\n ##########\\n self.skeleton = Skeleton( name = \\\"Polygon Lines\\\",\\n vertices = self.vertices_skeleton,\\n connectivity = self.connectivity_skeleton,\\n connectivity_colors = self.connectivity_skeleton_colors,\\n connectivity_ID = self.connectivity_ids_skeleton,\\n linewidth = skeleton_linewidth,\\n global_deselect_alpha = global_deselect_alpha,\\n global_select_alpha = global_select_alpha )\\n\\n self.connectivity_skeletononly_ids = None\\n self.connectivity_preonly_ids = None\\n self.connectivity_postonly_ids = None\\n\\n self.global_deselect_alpha = global_deselect_alpha\\n self.global_select_alpha = global_select_alpha\",\n \"def CreateAtrium(L,v,d,seed): \\n Neighbours = np.ndarray(L*L, dtype = list)\\n rnd.seed(seed)\\n Phases = np.ndarray(L*L,dtype = float)\\n Phases.fill(4)\\n Functionality = np.ndarray([L*L], dtype = bool)\\n index = np.indices((1, L*L))[1][0]\\n Atrium = index.reshape(L,L) # The index for that site within the long arrays\\n for j in index:\\n z = rnd.uniform(0,1)\\n if d > z: # dysfunctional\\n Functionality[j] = False\\n if d <= z: # functional\\n Functionality[j] = True\\n if j in np.arange(0,L*L,L): # first column\\n Neighbours[j] = list()\\n Neighbours[j].extend([j+1])\\n elif j in (np.arange(0,L*L,L)+L-1): # last column\\n Neighbours[j] = list()\\n Neighbours[j].extend([j-1])\\n else: # body columns\\n Neighbours[j] = list()\\n Neighbours[j].extend([j-1,j+1])\\n w = rnd.uniform(0,1)\\n for j in np.arange(L*L):\\n if w <= v: # transverse connections\\n if j in np.arange(L*L-L,L*L):\\n Neighbours[j].extend([j-(L*L-L)])\\n Neighbours[j-(L*L-L)].extend([j])\\n else:\\n Neighbours[j].extend([j+L])\\n Neighbours[(j+L)].extend([j])\\n return Neighbours, Phases, Functionality, Atrium, index\",\n \"def scoreCirc_CmosVoltageReference(circuit, gen, indi, makeRedundancyInMatrix): #TODO 6.9.2016 napisi cost function ki se sklada z evaluateCmosVoltageRef\\n #----------#\\n VREF = 1.5\\n #----------#\\n \\n FullBigCircuitMatrix = deepcopy(circuit.fullRedundancyMatrix)\\n rowsR,columnsR,columnsC,rowsC = sortedNonZeroIndices(FullBigCircuitMatrix)\\n\\n matrixDensity = float(len(rowsR))/float((BigMatrixSize*BigMatrixSize/2))\\t#(ones/(all/2))\\n matrixQuaziID = sum(rowsR)+sum(columnsR)-BigMatrixSize*(BigMatrixSize-1)\\n OcSc, IcNc, SelfConnElm = checkConnsConnected(FullBigCircuitMatrix) #Outer connections Short cut, Inner connections Not connected\\n \\n results = None\\n if OcSc > 1:\\n score = 1e4*np.exp(OcSc)\\n else:\\n makeNetlist(circuit, gen, indi, FullBigCircuitMatrix)\\n results = runme2.evaluateCmosVoltageRef(gen, indi)\\n disfCount = 0\\n \\n \\n #Vdd sweeps on 3 temperatures - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # -20 deg\\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\\n vdd_sweep_t1 = np.array(results['vout_vdd_temp1']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_t1)):\\n disfCount = disfCount + 1\\n vdd_s_t1 = 0\\n vdd_s_t1_d = 0\\n else:\\n x = np.median(vdd_sweep_t1)\\n vdd_s_t1 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_t1_d = np.max(vdd_sweep_t1) - np.min(vdd_sweep_t1)\\n \\n \\n # 25 deg\\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\\n vdd_sweep_t2 = np.array(results['vout_vdd_temp2']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_t2)):\\n disfCount = disfCount + 1\\n vdd_s_t2 = 0\\n vdd_s_t2_d = 0\\n else:\\n x = np.median(vdd_sweep_t2)\\n vdd_s_t2 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_t2_d = np.max(vdd_sweep_t2) - np.min(vdd_sweep_t2) \\n \\n # 120 deg\\n vdd_sweep_scale = np.array(results['vout_vdd_scale']['nominal'], dtype=float)\\n vdd_sweep_t3 = np.array(results['vout_vdd_temp3']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_t3)):\\n disfCount = disfCount + 1\\n vdd_s_t3 = 0\\n vdd_s_t3_d = 0\\n else:\\n x = np.median(vdd_sweep_t3)\\n vdd_s_t3 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_t3_d = np.max(vdd_sweep_t3) - np.min(vdd_sweep_t3) \\n \\n #Vdd sweeps on 3 loads - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - - -\\n # 10e6 Ohm\\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\\n vdd_sweep_r1 = np.array(results['vout_vdd_res1']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_r1)):\\n disfCount = disfCount + 1\\n vdd_s_r1 = 0\\n vdd_s_r1_d = 0\\n else:\\n x = np.median(vdd_sweep_r1)\\n vdd_s_r1 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_r1_d = np.max(vdd_sweep_r1) - np.min(vdd_sweep_r1)\\n \\n # 10e4 Ohm\\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\\n vdd_sweep_r2 = np.array(results['vout_vdd_res2']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_r2)):\\n disfCount = disfCount + 1\\n vdd_s_r2 = 0\\n vdd_s_r2_d = 0\\n else:\\n x = np.median(vdd_sweep_r2)\\n vdd_s_r2 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_r2_d = np.max(vdd_sweep_r2) - np.min(vdd_sweep_r2) \\n \\n # 10e2 Ohm\\n vdd_sweep_scale = np.array(results['vout_vdd_res_scale']['nominal'], dtype=float)\\n vdd_sweep_r3 = np.array(results['vout_vdd_res3']['nominal'], dtype=float) #This line changes Nones to np.nans\\n # if measurement is empty \\n if np.any(np.isnan(vdd_sweep_r3)):\\n disfCount = disfCount + 1\\n vdd_s_r3 = 0\\n vdd_s_r3_d = 0\\n else:\\n x = np.median(vdd_sweep_r3)\\n vdd_s_r3 = abs(x - VREF) #if x > VREF else 0\\n vdd_s_r3_d = np.max(vdd_sweep_r3) - np.min(vdd_sweep_r3) \\n \\n power = results['power']['nominal']\\n if np.isnan(np.array(power, dtype=float)):\\n disfCount = disfCount + 1\\n powe = 0\\n else:\\n powe = power\\n \\n #---COST FUNCTION DEFINITION---#\\n score = vdd_s_t1 + vdd_s_t1_d + \\\\\\n\\t vdd_s_t2 + vdd_s_t2_d + \\\\\\n\\t vdd_s_t3 + vdd_s_t3_d + \\\\\\n\\t vdd_s_r1 + vdd_s_r1_d + \\\\\\n\\t vdd_s_r2 + vdd_s_r2_d + \\\\\\n\\t vdd_s_r3 + vdd_s_r3_d + \\\\\\n\\t (100*powe)\\n\\n #print disfCount\\n if disfCount > 0:\\n score = np.exp(disfCount) * 1e3\\n if np.isnan(score):\\n score = 2e4\\n score = score + (IcNc+1) #add small punishment if not all nodes connected\\n\\n #print \\\"\\\\t\\\\t\\\\t\\\\t\\\\tG_\\\" + str(gen) + \\\"_I_\\\" + str(indi) + \\\" SCORE:\\\", score\\n \\n filename = \\\"g_\\\" + str(gen) + \\\"_i_\\\" + str(indi) + \\\"_subckt.cir\\\"\\n os.remove(filename) #cleanup current subcircuit\\n\\n return score, matrixDensity, matrixQuaziID, results\",\n \"def __getitem__(self, ind):\\n # This is used to make discrete sampling without replacement memory\\n # efficient.\\n 1 / 0\\n for sub_grid in self.param_grid:\\n # XXX: could memoize information used here\\n if not sub_grid:\\n if ind == 0:\\n return {}\\n else:\\n ind -= 1\\n continue\\n\\n # Reverse so most frequent cycling parameter comes first\\n keys, values_lists = zip(*sorted(sub_grid.items())[::-1])\\n sizes = [len(v_list) for v_list in values_lists]\\n total = np.product(sizes)\\n\\n if ind >= total:\\n # Try the next grid\\n ind -= total\\n else:\\n out = {}\\n for key, v_list, n in zip(keys, values_lists, sizes):\\n ind, offset = divmod(ind, n)\\n out[key] = v_list[offset]\\n return out\\n\\n raise IndexError('ParameterGrid index out of range')\",\n \"def _index_select_nd(source: torch.Tensor, index: torch.Tensor) -> torch.Tensor:\\n index_size = index.size() # (num_atoms/num_bonds, max_num_bonds)\\n suffix_dim = source.size()[1:] # (hidden_size,)\\n final_size = index_size + suffix_dim # (num_atoms/num_bonds, max_num_bonds, hidden_size)\\n\\n target = source.index_select(dim=0, index=index.view(\\n -1)) # (num_atoms/num_bonds * max_num_bonds, hidden_size)\\n target = target.view(\\n final_size) # (num_atoms/num_bonds, max_num_bonds, hidden_size)\\n\\n return target\",\n \"def lns_sa(self, sol_in, veh_type_in, cost_in):\\r\\n\\r\\n itr_cost = []\\r\\n solu = copy.deepcopy(sol_in)\\r\\n solu_type = copy.deepcopy(veh_type_in)\\r\\n best_solu = sol_in\\r\\n best_val = cost_in\\r\\n tabu_list = []\\r\\n random.seed(10)\\r\\n itr = 0\\r\\n temp = initial_temp\\r\\n t_run = time.time()\\r\\n while temp > stop_temp:\\r\\n itr += 1\\r\\n print(itr)\\r\\n if itr <= 0:\\r\\n sa_lns = True # use sa or lns\\r\\n else:\\r\\n sa_lns = False\\r\\n c = random.randint(1, store_num - 1) # randomly generated moving customer\\r\\n while c in tabu_list:\\r\\n c = random.randint(1, store_num - 1) # randint(a, b), both a and b are selectable\\r\\n c_loc = cust_loc(solu, c)\\r\\n\\r\\n if len(solu[c_loc[0]]) < 4: # customer number less than 2, can only implement shift1 and exchange1 operator\\r\\n wheel_value1 = random.uniform(0, 1)\\r\\n if wheel_value1 < 0.45:\\r\\n self.shift_1_cust(solu, c, c_loc, temp, solu_type, sa_lns)\\r\\n elif wheel_value1 < 0.9:\\r\\n self.exchange_1_cust(solu, c, c_loc, temp, solu_type, sa_lns)\\r\\n else:\\r\\n self.two_opt(solu, c, c_loc, temp, solu_type, sa_lns)\\r\\n\\r\\n # customer number more than 2, can implement all operators\\r\\n elif len(solu[c_loc[0]]) >= 4 and c_loc[1] <= len(solu[c_loc[0]]) - 3:\\r\\n wheel_value2 = random.uniform(0, 1)\\r\\n if wheel_value2 < 0.2:\\r\\n self.shift_1_cust(solu, c, c_loc, temp, solu_type, sa_lns)\\r\\n elif wheel_value2 < 0.4:\\r\\n self.shift_2_cust(solu, c, c_loc, temp, solu_type, sa_lns)\\r\\n elif wheel_value2 < 0.6:\\r\\n self.exchange_1_cust(solu, c, c_loc, temp, solu_type, sa_lns)\\r\\n elif wheel_value2 < 0.8:\\r\\n self.exchange_2_cust(solu, c, c_loc, temp, solu_type, sa_lns)\\r\\n else:\\r\\n self.two_opt(solu, c, c_loc, temp, solu_type, sa_lns)\\r\\n\\r\\n\\r\\n if itr % 100 == 0: # implement two-exchange operator every 200 iteration\\r\\n self.two_exchange_sol(solu, temp, solu_type, sa_lns)\\r\\n\\r\\n\\r\\n temp -= delta\\r\\n tabu_list.append(c)\\r\\n if len(tabu_list) > 100:\\r\\n tabu_list.pop(0)\\r\\n\\r\\n\\r\\n cost_i = of.print_result(solu, solu_type, False)\\r\\n # print(solu_type)\\r\\n itr_cost.append(cost_i)\\r\\n if cost_i < best_val:\\r\\n best_solu = solu\\r\\n best_val = cost_i\\r\\n\\r\\n\\r\\n t_run = time.time()\\r\\n\\r\\n # Adjust0: delete [0, 0] routes\\r\\n adjust_sol0 = []\\r\\n for route0 in best_solu:\\r\\n if len(route0) <= 2: # [0, 0] route\\r\\n continue\\r\\n else:\\r\\n adjust_sol0.append(route0)\\r\\n\\r\\n # Adjust1: use small vehicle if posiible\\r\\n adjust_type = []\\r\\n for route1 in adjust_sol0:\\r\\n adjust_type.append(route_type(route1))\\r\\n\\r\\n\\r\\n\\r\\n return adjust_sol0, adjust_type, best_val, itr_cost\",\n \"def greedy(constraint, indexes, m_l, parallel=False):\\n\\n selected = np.array([])\\n plot = False\\n choices = np.array(indexes)\\n bar = ChargingBar(\\\"Calculating index set with greedy method\\\", max=m_l)\\n\\n for i in range(len(selected), m_l):\\n # print(\\\"i = %d\\\" % i)\\n start = time.time()\\n\\n def calc(node):\\n return constraint(np.union1d(selected, node))\\n\\n if parallel:\\n pickle_fix.calc = calc\\n available_cores = odin.config.get(\\\"available_cores\\\", 4)\\n pool = multiprocessing.Pool(processes=available_cores)\\n values = pool.map(pickle_fix, choices)\\n pool.close()\\n else:\\n # values: [float]\\n values = list(map(calc, choices))\\n\\n greedy_choice = choices[np.argmax(values)]\\n\\n if plot:\\n values = np.sort(values)\\n oplt.plot(values)\\n oplt.show()\\n # current_best = np.max(values)\\n\\n selected = np.union1d(selected, [greedy_choice])\\n choices = np.setdiff1d(choices, [greedy_choice])\\n logging.debug(\\\"selected = %s; choice = %s; time = %.5f\\\" % (\\n selected, greedy_choice, time.time() - start))\\n bar.next()\\n bar.finish()\\n\\n return selected\",\n \"def eg_sk():\\n\\n rxs = []\\n a = []\\n b = []\\n c = []\\n d = []\\n e = []\\n f = []\\n g = []\\n h = []\\n i = []\\n j = []\\n\\n for _ in range(1000):\\n a.append(utils.gaussian(10, 1))\\n\\n for _ in range(1000):\\n b.append(utils.gaussian(10.1, 1))\\n\\n for _ in range(1000):\\n c.append(utils.gaussian(20, 1))\\n\\n for _ in range(1000):\\n d.append(utils.gaussian(30, 1))\\n\\n for _ in range(1000):\\n e.append(utils.gaussian(30.1, 1))\\n\\n for _ in range(1000):\\n f.append(utils.gaussian(10, 1))\\n\\n for _ in range(1000):\\n g.append(utils.gaussian(10, 1))\\n\\n for _ in range(1000):\\n h.append(utils.gaussian(40, 1))\\n\\n for _ in range(1000):\\n i.append(utils.gaussian(40, 3))\\n\\n for _ in range(1000):\\n j.append(utils.gaussian(10, 1))\\n\\n for k, v in enumerate([a, b, c, d, e, f, g, h, i, j]):\\n rxs.append(creation.RX(v, \\\"rx{}\\\".format(k)))\\n\\n for rx in stats.tiles(stats.scottKnot(rxs)):\\n print(\\\"\\\", rx[\\\"rank\\\"], rx[\\\"name\\\"], rx[\\\"show\\\"], sep=\\\"\\\\t\\\")\",\n \"def random_element(self):\\n from sage.graphs.schnyder import minimal_schnyder_wood\\n from sage.graphs.generators.random import RandomTriangulation\\n n = self._size\\n tri = RandomTriangulation(n + 3)\\n TIP = TamariIntervalPosets\\n schnyder = minimal_schnyder_wood(tri, root_edge=('a', 'b'),\\n check=False)\\n return TIP.from_minimal_schnyder_wood(schnyder)\",\n \"def find_nearest_neighbours_SURF(averageDistance,inst,distanceArray,maxInst): \\r\\n NN=[]\\r\\n min_indices=[] \\r\\n\\r\\n for j in range(maxInst):\\r\\n if inst != j:\\r\\n locator = [inst,j]\\r\\n locator = sorted(locator, reverse=True) #Access corect half of table (result of removed table redundancy)\\r\\n d = distanceArray[locator[0]][locator[1]]\\r\\n if d<averageDistance:\\r\\n min_indices.append(j)\\r\\n \\r\\n for j in range(len(min_indices)):\\r\\n NN.append(min_indices[j])\\r\\n \\r\\n return NN\",\n \"def get_pulling_indices(self, weight):\\n pass\",\n \"def test_subset_reconstruction_integer(self, wires, snapshots):\\n circuit = hadamard_circuit(wires)\\n bits, recipes = circuit()\\n shadow = ClassicalShadow(bits, recipes)\\n\\n state = shadow.global_snapshots(snapshots=snapshots)\\n assert state.shape == (snapshots, 2**wires, 2**wires)\",\n \"def ind_sim(n,CV,BV,N,p,d): \\n dic={}\\n dic2={}\\n for i in range(N):\\n Bt=random.choices('HL', weights=(p,1-p), k=n)\\n pb=[round((1-p), 5) if x=='L' else p for x in Bt] \\n Ct=random.choices('HL', weights=(p,1-p), k=n)\\n pc=[round((1-p), 5) if x=='L' else p for x in Ct] \\n [npvt,pr]=NPV(Bt,Ct,BV,CV,d,np.prod(pb),np.prod(pc))\\n if npvt in dic.keys():\\n dic[npvt] += 1\\n else:\\n dic[npvt] = 1\\n dic2[npvt] =pr\\n return (dic, dic2)\",\n \"def select(self):\\n warnings.filterwarnings(\\\"ignore\\\", category=DeprecationWarning)\\n\\n best_bic_score = float(\\\"inf\\\")\\n best_model = self.base_model(self.n_constant)\\n for n in range(self.min_n_components, self.max_n_components + 1):\\n try:\\n # bic = - 2*log(likelihood) + p*log(N)\\n # N is number of data points\\n # p => number of parameters\\n # p = initial state occupation probabilities\\n # + transition probabilities\\n # + emission probabilities\\n # initial state occupation probabilities, can be obtained from n,\\n # as the probabilities add up to 1.0 => initial state occupation probabilities = n - 1\\n # transition probabilities => n*(n - 1)\\n # emission probabilities => n * num_features * 2 = num_means + num_covar\\n # Hence, p = n - 1 + n*(n - 1) + 2* n * num_features\\n # p = n*n + 2*n*num_features - 1\\n\\n model = self.base_model(n)\\n log_likelihood = model.score(self.X, self.lengths)\\n num_features = len(self.X[0])\\n log_n = math.log(self.X.shape[0])\\n\\n p = n*n + 2*n*num_features - 1\\n bic = -2 * log_likelihood + p * log_n\\n if bic < best_bic_score:\\n best_bic_score = bic\\n best_model = model\\n except:\\n continue\\n\\n return best_model\",\n \"def spark_index(n):\\n return int(round((clamp(n) - minimum) * coefficient))\",\n \"def initialize(N0,L,Nt,pflag):\\n qmax,qnet,enet = net.generate(N0,L,Nt)\\n N = (N0+Nt)\\n #generate initial conditions. all nodes have S,E,C=(1,0,0)\\n #except the infected node which has S,E,C=(0.1,0.05,0.05)\\n init = np.zeros(3*N)\\n for i in range(N):\\n init[i] = 1\\n #the highest degree node is infected\\n infnode = qnet.argmax(axis=0)+1\\n init[infnode-1] = 0.1\\n init[N+infnode-1] = 0.05\\n init[2*N+infnode-1] = 0.05\\n if (pflag==True):\\n #compute the transport matrix from the degree vector\\n #and the adjacency matrix\\n A = net.adjacency_matrix(N,enet)\\n P = np.zeros([N,N])\\n for j in range(N):\\n for i in range(N):\\n P[i,j] = qnet[i]*A[i,j]\\n P[:,j] = P[:,j]/sum(P[:,j])\\n return init,infnode,P\\n return init,infnode\",\n \"def screening_graph_estimate(S, lambdaL, p, maxdf, idx_scr, threshold=1e-4, max_iter=10000):\\n nlambda = lambdaL.shape[0]\\n nscr = idx_scr.shape[0]\\n x = np.zeros(p * maxdf * nlambda)\\n col_cnz = np.zeros(p + 1).astype(int)\\n row_idx = np.zeros(p * maxdf * nlambda).astype(int)\\n idx_a = np.zeros(nscr).astype(int)\\n w1 = np.zeros(p)\\n\\n cnz = 0\\n for m in range(p):\\n idx_i = np.copy(idx_scr[:, m])\\n w0 = np.zeros(p)\\n size_a = 0\\n\\n for i in range(nlambda):\\n ilambda = lambdaL[i]\\n gap_ext = 1\\n iter_ext = 0\\n while gap_ext > 0 and iter_ext < max_iter:\\n size_a_prev = size_a\\n for j in range(nscr):\\n w_idx = idx_i[j]\\n if w_idx != -1:\\n r = S[m, w_idx]\\n for k in range(size_a):\\n rss_idx = idx_a[k]\\n r -= S[w_idx, rss_idx] * w0[rss_idx]\\n\\n if abs(r) > ilambda:\\n if r >= 0:\\n w1[w_idx] = r - ilambda\\n else:\\n w1[w_idx] = r + ilambda\\n idx_a[size_a] = w_idx\\n size_a += 1\\n idx_i[j] = -1\\n else:\\n w1[w_idx] = 0\\n w0[w_idx] = w1[w_idx]\\n\\n gap_ext = size_a - size_a_prev\\n\\n gap_int = 1\\n iter_int = 0\\n while gap_int > threshold and iter_int < max_iter:\\n tmp1 = 0\\n tmp2 = 1e-4\\n for j in range(size_a):\\n w_idx = idx_a[j]\\n r = S[m, w_idx] + w0[w_idx]\\n\\n for k in range(size_a):\\n rss_idx = idx_a[k]\\n r -= S[w_idx, rss_idx] * w0[rss_idx]\\n\\n if abs(r) > ilambda:\\n if r >= 0:\\n w1[w_idx] = r - ilambda\\n else:\\n w1[w_idx] = r + ilambda\\n tmp2 += abs(w1[w_idx])\\n else:\\n w1[w_idx] = 0\\n tmp1 += abs(w1[w_idx] - w0[w_idx])\\n w0[w_idx] = w1[w_idx]\\n gap_int = tmp1 / tmp2\\n iter_int += 1\\n iter_ext += 1\\n\\n for j in range(size_a):\\n w_idx = idx_a[j]\\n x[cnz] = w1[w_idx]\\n row_idx[cnz] = i * p + w_idx\\n cnz += 1\\n col_cnz[m + 1] = cnz\\n\\n return col_cnz, row_idx, x\",\n \"def pick_next(self, STATUS, N=100, nysamples=100):\\n untested = [i for i in range(self.n) if STATUS[i] == 0]\\n if self.acquisition_function == 'Thompson':\\n alpha = self.samples()\\n \\n elif self.acquisition_function == 'Greedy_N':\\n y_samples = self.samples(nysamples)\\n alpha = np.zeros(self.n)\\n for j in range(nysamples):\\n # count number of times each point is in the top N for a sample \\n alpha[np.argpartition(y_samples[:, j], -N)[-N:]] += 1\\n \\n elif self.acquisition_function == 'Greedy_tau':\\n if np.mod(self.estimate_tau_counter, self.tau_update) == 0:\\n self.estimate_tau()\\n self.estimate_tau_counter += 1\\n else:\\n self.estimate_tau_counter += 1\\n mu_X_pos, var_X_pos = self.predict()\\n alpha = 1-norm.cdf(np.divide(self.tau-mu_X_pos,var_X_pos**0.5))\\n \\n elif self.acquisition_function == 'EI':\\n mu_X_pos, var_X_pos = self.predict()\\n sig_X_pos = var_X_pos**0.5\\n alpha = (mu_X_pos-self.y_max)*norm.cdf(np.divide(mu_X_pos-self.y_max,sig_X_pos))+sig_X_pos*norm.pdf(np.divide(mu_X_pos-self.y_max,sig_X_pos))\\n \\n else:\\n # if no valid acquisition_function entered then pick at random \\n alpha = np.random.rand(self.n)\\n print('enter a valid acquisition function - picking randomly')\\n ipick = untested[np.argmax(alpha[untested])]\\n return ipick\",\n \"def selectedRvs(self, discardedElems):\\n if not self.memory:\\n self.raiseAnError(IOError,' The distribution '+ str(self.name) + ' does not support the method selectedRVS.')\\n else:\\n rvsValue = self.selectedPpf(random(),discardedElems)\\n return rvsValue\",\n \"def getWINDNMRdefault(n):\\n # The list of spinsystems begins with empty tuples. This allows intuitive\\n # access to a particular spin system. So, spinsystem[4] is the data for the\\n # 4-spin system.\\\"\\\"\\\"\\n spinsystem = [(), (), spin2(), spin3(), spin4(), spin5(), spin6(), spin7(),\\n spin8()]\\n\\n # Changes to the tkinter GUI require frequency to be a (0,n) 2D array,\\n # and J to be an array and not a sparse matrix.\\n freq, J = spinsystem[n]\\n freq2D = np.array([freq]) # converts to 2D array\\n J = J.todense()\\n\\n return freq2D, J\",\n \"def __init__(self, neuron_count):\\n # The current state of the thermal network.\\n self.current_state = [0.0] * neuron_count\\n\\n # The weights.\\n self.weights = np.zeros( [neuron_count*neuron_count] )\\n\\n # The neuron count.\\n self.neuron_count = neuron_count\",\n \"def __optimize_configuration(self):\\r\\n index_neighbor = 0\\r\\n counter = 0\\r\\n while (index_neighbor < self.__maxneighbor):\\r\\n # get random current medoid that is to be replaced\\r\\n current_medoid_index = self.__current[random.randint(0, self.__number_clusters - 1)]\\r\\n current_medoid_cluster_index = self.__belong[current_medoid_index]\\r\\n\\r\\n # get new candidate to be medoid\\r\\n candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)\\r\\n\\r\\n while candidate_medoid_index in self.__current:\\r\\n candidate_medoid_index = random.randint(0, len(self.__pointer_data) - 1)\\r\\n\\r\\n candidate_cost = 0.0\\r\\n for point_index in range(0, len(self.__pointer_data)):\\r\\n if point_index not in self.__current:\\r\\n # get non-medoid point and its medoid\\r\\n point_cluster_index = self.__belong[point_index]\\r\\n point_medoid_index = self.__current[point_cluster_index]\\r\\n\\r\\n # get other medoid that is nearest to the point (except current and candidate)\\r\\n other_medoid_index = self.__find_another_nearest_medoid(point_index, current_medoid_index)\\r\\n other_medoid_cluster_index = self.__belong[other_medoid_index]\\r\\n\\r\\n # for optimization calculate all required distances\\r\\n # from the point to current medoid\\r\\n distance_current = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[current_medoid_index])\\r\\n\\r\\n # from the point to candidate median\\r\\n distance_candidate = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[candidate_medoid_index])\\r\\n\\r\\n # from the point to nearest (own) medoid\\r\\n distance_nearest = float('inf')\\r\\n if ( (point_medoid_index != candidate_medoid_index) and (point_medoid_index != current_medoid_cluster_index) ):\\r\\n distance_nearest = euclidean_distance_square(self.__pointer_data[point_index], self.__pointer_data[point_medoid_index])\\r\\n\\r\\n # apply rules for cost calculation\\r\\n if (point_cluster_index == current_medoid_cluster_index):\\r\\n # case 1:\\r\\n if (distance_candidate >= distance_nearest):\\r\\n candidate_cost += distance_nearest - distance_current\\r\\n\\r\\n # case 2:\\r\\n else:\\r\\n candidate_cost += distance_candidate - distance_current\\r\\n\\r\\n elif (point_cluster_index == other_medoid_cluster_index):\\r\\n # case 3 ('nearest medoid' is the representative object of that cluster and object is more similar to 'nearest' than to 'candidate'):\\r\\n if (distance_candidate > distance_nearest):\\r\\n pass;\\r\\n\\r\\n # case 4:\\r\\n else:\\r\\n candidate_cost += distance_candidate - distance_nearest\\r\\n\\r\\n if (candidate_cost < 0):\\r\\n counter+=1\\r\\n # set candidate that has won\\r\\n self.__current[current_medoid_cluster_index] = candidate_medoid_index\\r\\n\\r\\n # recalculate clusters\\r\\n self.__update_clusters(self.__current)\\r\\n\\r\\n # reset iterations and starts investigation from the begining\\r\\n index_neighbor = 0\\r\\n\\r\\n else:\\r\\n\\r\\n index_neighbor += 1\\r\\n\\r\\n print(\\\"Medoid set changed {0} times\\\".format(counter))\",\n \"def sample_from(self, weights):\\n total = sum(weights)\\n rnd = total * random.random() # uniform between 0 and total\\n for i, w in enumerate(weights):\\n rnd -= w # return the smallest i such that\\n if rnd <= 0:\\n return i # weights[0] + ... + weights[i] >= rnd\",\n \"def get_selected_subsamples(sample_func, clusters, trajs_dict, visit_profile, Nsample, false_rate=80):\\n print('The desired false rate is %f'%(false_rate/Nsample))\\n crter = 0\\n done_first_round = False\\n nclusters = len(clusters)\\n \\n print('Start the first selection until the number of potential profiles is more than Nsample')\\n while crter < Nsample:\\n i = np.random.choice(range(nclusters))\\n if len(clusters[i]) > Nsample*5 or len(clusters[i]) < Nsample: continue\\n # try sampling\\n selected_spl, plist_spl = sample_func(trajs_dict, plist=None, usrs=clusters[i])\\n # do the deterministic attack\\n a2 = get_trick_mat(clusters[i] , selected_spl, visit_profile)\\n nonzero_list = [np.sum(np.count_nonzero(ai))>=1 for ai in make_sym_mat(a2)] \\n crter = np.sum(nonzero_list)\\n \\n print('Finish the first round selection, %d candidates are selected from cluster %d'%(crter, i))\\n round_one_usrs = np.array(clusters[i])[nonzero_list]\\n \\n crter2 = 0; len_rone = len(round_one_usrs)\\n print('Start the second selection until false rate %f'%(false_rate/Nsample))\\n while crter2 < false_rate:\\n final_selected_usrs = round_one_usrs[np.random.choice(len_rone, Nsample, replace=False)]\\n tmp = get_trick_mat(final_selected_usrs, selected_spl, visit_profile)\\n crter2 = np.sum([np.sum(np.count_nonzero(ai))>=1 for ai in make_sym_mat(tmp)])\\n print('Final false rate for deterministic attack%f'%(crter2/Nsample))\\n return selected_spl, final_selected_usrs, plist_spl\",\n \"def randomSelection(self):\\n indA = self.matingPool[ random.randint(0, self.popSize-1) ]\\n indB = self.matingPool[ random.randint(0, self.popSize-1) ]\\n return [indA, indB]\",\n \"def select_action(self, env, state, **kwargs):\\n\\n self.epsilon = 1 - (len(self.memory.memory)*1.0)/self.memory.max_size + 0.05\\n if np.random.uniform() <= self.epsilon:\\n index = env.action_space.sample()\\n else:\\n index = np.argmax(self.Q.predict(state))\\n\\n return index\",\n \"def selectedRvs(self,discardedElems):\\n if self.nPoints is None:\\n self.xArray = np.arange(self.lowerBound,self.upperBound+1)\\n else:\\n self.xArray = np.linspace(self.lowerBound,self.upperBound,self.nPoints)\\n\\n self.xArray = np.setdiff1d(self.xArray,discardedElems)\\n\\n self.pdfArray = 1/self.xArray.size * np.ones(self.xArray.size)\\n paramsDict={}\\n paramsDict['outcome'] = self.xArray\\n paramsDict['state'] = self.pdfArray\\n paramsDict['strategy'] = self.strategy\\n\\n self.tempUniformDiscrete = UniformDiscrete()\\n self.tempUniformDiscrete.initializeFromDict(paramsDict)\\n\\n rvsValue = self.tempUniformDiscrete.rvs()\\n return rvsValue\",\n \"def init_solution(weight_cost,max_weight):\\r\\n solution = [] #empty list\\r\\n allowed_positions = list(range (len(weight_cost))) # (0,10)\\r\\n while len(allowed_positions)>0:\\r\\n idx = random.randint(0,len(allowed_positions)-1) # any random number between 0 to 9\\r\\n selected_position = allowed_positions.pop(idx)\\r\\n if get_cost_and_weight_of_knapsack(solution + [selected_position],weight_cost)[1] <= max_weight:\\r\\n solution.append(selected_position)\\r\\n else:\\r\\n break\\r\\n return solution\",\n \"def __optimize_configuration(self):\\n index_neighbor = 0\\n counter = 0\\n while index_neighbor < self.__maxneighbor:\\n # get random current medoid that is to be replaced\\n current_medoid_index = self.__current[\\n random.randint(0, self.__number_clusters - 1)\\n ]\\n current_medoid_cluster_index = self.__belong[current_medoid_index]\\n\\n # get new candidate to be medoid\\n candidate_medoid_index = random.randint(\\n 0, len(self.__pointer_data) - 1\\n )\\n\\n while candidate_medoid_index in self.__current:\\n candidate_medoid_index = random.randint(\\n 0, len(self.__pointer_data) - 1\\n )\\n\\n candidate_cost = 0.0\\n for point_index in range(0, len(self.__pointer_data)):\\n if point_index not in self.__current:\\n # get non-medoid point and its medoid\\n point_cluster_index = self.__belong[point_index]\\n point_medoid_index = self.__current[point_cluster_index]\\n\\n # get other medoid that is nearest to the point (except current and candidate)\\n other_medoid_index = self.__find_another_nearest_medoid(\\n point_index, current_medoid_index\\n )\\n other_medoid_cluster_index = self.__belong[\\n other_medoid_index\\n ]\\n\\n # for optimization calculate all required distances\\n # from the point to current medoid\\n distance_current = euclidean_distance_square(\\n self.__pointer_data[point_index],\\n self.__pointer_data[current_medoid_index],\\n )\\n\\n # from the point to candidate median\\n distance_candidate = euclidean_distance_square(\\n self.__pointer_data[point_index],\\n self.__pointer_data[candidate_medoid_index],\\n )\\n\\n # from the point to nearest (own) medoid\\n distance_nearest = float(\\\"inf\\\")\\n if (point_medoid_index != candidate_medoid_index) and (\\n point_medoid_index != current_medoid_cluster_index\\n ):\\n distance_nearest = euclidean_distance_square(\\n self.__pointer_data[point_index],\\n self.__pointer_data[point_medoid_index],\\n )\\n\\n # apply rules for cost calculation\\n if point_cluster_index == current_medoid_cluster_index:\\n # case 1:\\n if distance_candidate >= distance_nearest:\\n candidate_cost += (\\n distance_nearest - distance_current\\n )\\n\\n # case 2:\\n else:\\n candidate_cost += (\\n distance_candidate - distance_current\\n )\\n\\n elif point_cluster_index == other_medoid_cluster_index:\\n # case 3 ('nearest medoid' is the representative object of that cluster and object is more\\n # similar to 'nearest' than to 'candidate'):\\n if distance_candidate > distance_nearest:\\n pass\\n\\n # case 4:\\n else:\\n candidate_cost += (\\n distance_candidate - distance_nearest\\n )\\n\\n if candidate_cost < 0:\\n counter += 1\\n # set candidate that has won\\n self.__current[\\n current_medoid_cluster_index\\n ] = candidate_medoid_index\\n\\n # recalculate clusters\\n self.__update_clusters(self.__current)\\n\\n # reset iterations and starts investigation from the begining\\n index_neighbor = 0\\n\\n else:\\n\\n index_neighbor += 1\\n\\n print(\\\"Medoid set changed {0} times\\\".format(counter))\",\n \"def greedy_initial(self):\\r\\n sol = [] # [[0;2;5;0;4;6;0],[],...]\\r\\n sol_veh_type = [] # corresponding vehicle type for the solution\\r\\n route_way_time = []\\r\\n\\r\\n to_vist = [i+1 for i in range(store_num - 1)] # [1,5,8,...]\\r\\n itr = 0\\r\\n\\r\\n while len(to_vist) > 0 and itr < 500:\\r\\n itr += 1\\r\\n\\r\\n if itr <= small_veh_cnt:\\r\\n vehicle_type0 = 2\\r\\n elif itr <= small_veh_cnt + medium_veh_cnt:\\r\\n vehicle_type0 = 3\\r\\n else:\\r\\n vehicle_type0 = 5\\r\\n\\r\\n sol_veh_type.append(vehicle_type0)\\r\\n\\r\\n used_res = [0, 0, 0, 0] # used volume, and travel time of the vehicle, leave time, travel distance\\r\\n veh_rout = [0]\\r\\n\\r\\n # print '\\\\nA new vehicle will be used.'\\r\\n way_time = 0 # travel time of coming to the store + wait time at the store + operation time at this store\\r\\n while True:\\r\\n curr_cust = veh_rout[-1]\\r\\n\\r\\n next_one, way_time = self.time_nn(way_time, curr_cust, to_vist, used_res, len(veh_rout), vehicle_type0)\\r\\n next_cust, next_start = next_one[0], next_one[1]\\r\\n # print('next start', next_cust, next_start)\\r\\n if next_cust == 0: # next visiting customer is depot\\r\\n # print 'Get back to the depot, and ready for a new round.'\\r\\n veh_rout.append(next_cust)\\r\\n break\\r\\n\\r\\n else: # next visiting customer is a store\\r\\n used_res[0] += (num_demd[next_cust][0] * bskt_vol + num_demd[next_cust][1] * trsf_vol + (num_demd[next_cust][2] + \\\\\\r\\n num_demd[next_cust][3]) * milk_vol + num_demd[next_cust][4] * paper_bskt)\\r\\n used_res[2] = (next_start + oprt_t)\\r\\n used_res[3] += dist_mat[curr_cust, next_cust]\\r\\n\\r\\n\\r\\n veh_rout.append(next_cust)\\r\\n # print 'Vehicle used resource: ', used_res\\r\\n to_vist.remove(next_cust)\\r\\n\\r\\n sol.append(veh_rout)\\r\\n route_way_time.append(way_time)\\r\\n\\r\\n # print 'Last point 0 earliest leave time: ', int(used_res[-1]) / 60, ':', int(used_res[-1]) % 60\\r\\n # print 'Route %s is: ' % itr, veh_rout\\r\\n print('*'*10, 'Iteration:', itr, '*'*10)\\r\\n\\r\\n\\r\\n if len(to_vist) > 0:\\r\\n print('number of stores remained: ', len(to_vist))\\r\\n\\r\\n return sol, sol_veh_type, route_way_time\",\n \"def sample_from_ibp(K, alpha, sigma, c):\\n pp = poissonparams(K, alpha, sigma, c)\\n new_nodes = np.random.poisson(pp)\\n Ncols = new_nodes.sum()\\n node_count = np.zeros(Ncols)\\n\\n # used to build sparse matrix, entries of each Zij=1\\n colidx = [] \\n rowidx = []\\n rightmost_node = 0\\n\\n # for each clique\\n for n in range(K):\\n # revisit each previously seen node\\n for k in range(rightmost_node):\\n prob_repeat = (node_count[k] - sigma) / (n + c)\\n r = np.random.rand()\\n if r < prob_repeat:\\n rowidx.append(n)\\n colidx.append(k)\\n node_count[k] += 1\\n\\n for k in range(rightmost_node, rightmost_node + new_nodes[n]):\\n rowidx.append(n)\\n colidx.append(k)\\n node_count[k] += 1\\n \\n rightmost_node += new_nodes[n]\\n\\n # build sparse matrix\\n data = np.ones(len(rowidx), int)\\n shape = (K, Ncols)\\n Z = csr_matrix((data, (rowidx, colidx)), shape)\\n\\n return Z\",\n \"def mk_sen_circuit_plastic(task_info):\\n # load params from task_info\\n N_E = task_info['sen']['N_E'] # number of exc neurons (1600)\\n N_I = task_info['sen']['N_I'] # number of inh neurons (400)\\n N_X = task_info['sen']['N_X'] # size of external population\\n sub = task_info['sen']['sub'] # fraction of stim-selective exc neurons\\n N_E1 = int(N_E * sub) # size of exc sub-pop 1, 2\\n num_method = task_info['sim']['num_method']\\n\\n # define namespace\\n paramplastic = params.get_plasticity_params(task_info)\\n tau_update = paramplastic['tau_update']\\n\\n # equations\\n if task_info['sim']['online_stim']:\\n eqs_soma_plastic = nm.eqs_naud_soma + nm.eqs_stim_linked\\n paramstim = params.get_stim_params(task_info)\\n paramplastic = {**paramplastic, **paramstim}\\n else:\\n eqs_soma_plastic = nm.eqs_naud_soma + nm.eqs_stim_array\\n\\n # neuron groups\\n eqs_dend_plastic = nm.eqs_naud_dend + nm.eqs_plasticity\\n senE = NeuronGroup(N_E, model=eqs_soma_plastic, method=num_method, threshold='V>=Vt',\\n reset='''V = Vl\\n w_s += bws''',\\n refractory='tau_refE', namespace=paramplastic, name='senE')\\n dend = NeuronGroup(N_E, model=eqs_dend_plastic, method=num_method, threshold='burst_start > 1 + min_burst_stop',\\n reset='''B += 1\\n burst_start = 0''',\\n refractory='burst_stop >= min_burst_stop', namespace=paramplastic, name='dend')\\n senI = NeuronGroup(N_I, model=nm.eqs_wimmer_inh, method=num_method, threshold='V>=Vt', reset='V=Vr',\\n refractory='tau_refI', namespace=paramplastic, name='senI')\\n extS = PoissonGroup(N_X, rates='nu_ext', namespace=paramplastic)\\n\\n # subgroups\\n senE1 = senE[:N_E1]\\n senE2 = senE[N_E1:]\\n dend1 = dend[:N_E1]\\n dend2 = dend[N_E1:]\\n\\n # linked variables\\n senE.V_d = linked_var(dend, 'V_d')\\n dend.lastspike_soma = linked_var(senE, 'lastspike')\\n\\n # soma-dendrite synapse\\n syn_burst_trace = Synapses(senE, dend, method=num_method, on_pre='''burst_start +=1\\n burst_stop = 1''',\\n namespace=paramplastic, name='syn_burst_trace')\\n syn_burst_trace.connect(j='i')\\n\\n # stim\\n if task_info['sim']['online_stim']:\\n stim_dt = paramstim['stim_dt']\\n stim_common = NeuronGroup(2, model=nm.eqs_stim_common, method=num_method,\\n dt=stim_dt, namespace=paramstim, name='stim_common')\\n stimE = NeuronGroup(N_E, model=nm.eqs_stim_online, method=num_method,\\n dt=stim_dt, namespace=paramstim, name='stimE')\\n stimE1 = stimE[:N_E1]\\n stimE2 = stimE[N_E1:]\\n stimE.z = linked_var(stim_common, 'z', index=np.hstack((np.zeros(N_E1, dtype=int), np.ones(N_E1, dtype=int))))\\n stimE1.mu = paramstim['mu1']\\n stimE2.mu = paramstim['mu2']\\n senE.I = linked_var(stimE, 'I')\\n\\n # update rule\\n dend1.muOUd = 0*amp #'-95*pA - rand()*10*pA' # random initialisation in [-105:-95 pA], 0*amp\\n dend1.run_regularly('muOUd = clip(muOUd - eta * (B - B0), -100*amp, 0)', dt=tau_update)\\n\\n # connections\\n sen_synapses = mk_sen_synapses(task_info, senE, senI, extS, paramplastic)\\n extD1, synDXdend1 = mk_poisson_fb(task_info, dend1)\\n\\n # variables to return\\n groups = {'SE': senE, 'dend': dend, 'SI': senI, 'SX': extS, 'DX': extD1}\\n subgroups = {'SE1': senE1, 'SE2': senE2,\\n 'dend1': dend1, 'dend2': dend2}\\n synapses = {**sen_synapses, **{'synDXdend': synDXdend1, 'syn_burst_trace': syn_burst_trace}}\\n\\n if task_info['sim']['online_stim']:\\n groups = {**groups, **{'stim_common': stim_common, 'stimE': stimE}}\\n\\n return groups, synapses, subgroups\",\n \"def __getitem__(self, ind):\\n # This is used to make discrete sampling without replacement memory\\n # efficient.\\n for sub_grid in self.param_grid:\\n # XXX: could memoize information used here\\n if not sub_grid:\\n if ind == 0:\\n return {}\\n else:\\n ind -= 1\\n continue\\n\\n # Reverse so most frequent cycling parameter comes first\\n keys, values_lists = zip(*sorted(sub_grid.items())[::-1])\\n sizes = [len(v_list) for v_list in values_lists]\\n total = np.product(sizes)\\n\\n if ind >= total:\\n # Try the next grid\\n ind -= total\\n else:\\n out = {}\\n for key, v_list, n in zip(keys, values_lists, sizes):\\n ind, offset = divmod(ind, n)\\n out[key] = v_list[offset]\\n return out\\n\\n raise IndexError('ParameterGrid index out of range')\",\n \"def test_indices(self, circuit):\\n gate = jet.GateFactory.create(\\\"H\\\")\\n circuit.append_gate(gate, wire_ids=[0])\\n assert list(circuit.indices([0])) == [\\\"0-1\\\"]\\n assert list(circuit.indices([1, 2, 3])) == [\\\"1-0\\\", \\\"2-0\\\", \\\"3-0\\\"]\",\n \"def main(edges=[(0, 1, 3), (1, 3, 4), (2, 3, 3), (0, 2, 2) ], num=4):\\n\\n # initialize routers array\\n routers = []\\n for x in range(num):\\n routers.append([1000] * num)\\n routers[x][x] = 0\\n \\n # set distance to all neighbours \\n for edge in edges:\\n routers[edge[0]][edge[1]] = edge[2]\\n routers[edge[1]][edge[0]] = edge[2]\\n\\n start_table = routers.copy()\\n\\n flag = True\\n while flag:\\n upflag = False\\n for nbrs in edges:\\n routers[nbrs[0]], up_flag1 = update_table(routers[nbrs[0]], routers[nbrs[1]], dist=nbrs[2])\\n routers[nbrs[1]], up_flag2 = update_table(routers[nbrs[1]], routers[nbrs[0]], dist=nbrs[2])\\n upflag = upflag or up_flag1 or up_flag2\\n\\n flag = upflag\\n\\n return start_table, routers\",\n \"def main():\\n G = nx.gnp_random_graph(100, 0.5)\\n centrality = nx.eigenvector_centrality(G)\\n avg_centrality = sum(centrality.values()) / len(G)\\n\\n def has_high_centrality(v):\\n return centrality[v] >= avg_centrality\\n\\n source = 0\\n value = centrality.get\\n condition = has_high_centrality\\n\\n found_node = progressive_widening_search(G, source, value, condition)\\n c = centrality[found_node]\\n print('found node {0} with centrality {1}'.format(found_node, c))\",\n \"def get_weight_development_random_sample(synapses, n_synapses):\\n n_epochs, n_possible_synapses = synapses.shape\\n rand_indices = np.random.choice(n_possible_synapses, size=(n_synapses,), replace=False)\\n return synapses[:, rand_indices]\",\n \"def multi_velo_inspec(self, n = 60, lat0 = 60, lat1 = 90, pole = \\\"north\\\"):\\n inds = self.mlat_finder(lat1, lat0, pole)[1]\\n NeA = self.NeA[inds]\\n NeB = self.NeB[inds]\\n NeC = self.NeC[inds]\\n\\n secondsA = self.secondsA[inds]\\n secondsB = self.secondsB[inds]\\n secondsC = self.secondsC[inds]\\n\\n\\n mlatA = self.mlatA[inds]\\n mlatB = self.mlatB[inds]\\n mlatC = self.mlatC[inds]\\n\\n mean_range = 5\\n NeA = self.meanie(NeA, mean_range)\\n NeB = self.meanie(NeB, mean_range)\\n NeC = self.meanie(NeC, mean_range)\\n \\n \\n N = int((len(NeA)/n*2) - 1) #nr of windows\\n \\n dx = (secondsB[1]-secondsB[0])*self.velB[0]\\n \\n nBAs = []\\n nBCs = []\\n nACs = []\\n \\n for i in range(N):\\n startind = int(i/2*n)\\n stopind = int((i/2+1)*n)\\n temp_NeA = NeA[startind:stopind]\\n temp_NeB = NeB[startind:stopind]\\n temp_NeC = NeC[startind:stopind]\\n \\n temp_secondsA = secondsA[startind:stopind]\\n temp_secondsB = secondsB[startind:stopind]\\n temp_secondsC = secondsC[startind:stopind]\\n \\n \\n curr_timediff = np.round((temp_secondsB[1:] - temp_secondsB[:-1])-(1/self.fs))\\n if np.sum(curr_timediff) > 2:\\n continue\\n \\n gradA = (temp_NeA[1:] - temp_NeA[:-1])/dx\\n gradB = (temp_NeB[1:] - temp_NeB[:-1])/dx\\n gradC = (temp_NeC[1:] - temp_NeC[:-1])/dx\\n \\n if np.max(gradA) < 0.9:\\n continue\\n \\n stdA = np.std(gradA)\\n stdB = np.std(gradB)\\n stdC = np.std(gradC)\\n \\n meanA = temp_secondsB[np.where(gradA == np.max(gradA))][0]\\n meanB = temp_secondsB[np.where(gradB == np.max(gradB))][0]\\n meanC = temp_secondsB[np.where(gradC == np.max(gradC))][0]\\n \\n p0A = [1, meanA, stdA]\\n p0B = [1, meanB, stdB]\\n p0C = [1, meanB, stdB]\\n \\n poptA, pcovA = curve_fit(self.gaussian, temp_secondsB[:-1], gradA, p0 = p0A)\\n poptB, pcovB = curve_fit(self.gaussian, temp_secondsB[:-1], gradB, p0 = p0B)\\n poptC, pcovC = curve_fit(self.gaussian, temp_secondsB[:-1], gradC, p0 = p0C)\\n \\n nBA = poptB[1] - poptA[1]\\n nBC = poptB[1] - poptC[1]\\n nAC = poptA[1] - poptC[1]\\n \\n nBAs.append(nBA)\\n nBCs.append(nBC)\\n nACs.append(nAC)\\n \\n \\n sBA = self.BA_shift/2 #time delay BA\\n sBC = self.BC_shift/2 #time delay BC\\n sAC = (self.BC_shift - self.BA_shift)/2\\n V = self.velA[0]\\n for i in range(len(nBAs)):\\n VBA = self.along_track_velo(V, sBA, nBAs[i])\\n VBC = self.along_track_velo(V, sBC, nBCs[i])\\n VAC = self.along_track_velo(V, sAC, nACs[i])\\n \\n print(VBA)\\n print(VBC)\\n print(VAC)\\n print(\\\"________________________________________\\\")\",\n \"def up_sampling(stl_vertices_list, num_of_new_vertices):\\n temp_stl_vertices_list = copy.deepcopy(stl_vertices_list)\\n for i in range(num_of_new_vertices):\\n rand_index = random.randint(0, len(temp_stl_vertices_list) - 1)\\n rand_vertex = temp_stl_vertices_list.pop(rand_index)\\n index_list = [j for j in range(len(temp_stl_vertices_list))]\\n\\n distance_of_rand_vertex_to_rest_vertices = euclidean_distance(rand_vertex, temp_stl_vertices_list)\\n temp_dict = dict(zip(distance_of_rand_vertex_to_rest_vertices, index_list))\\n nearest_index = temp_dict[np.min(distance_of_rand_vertex_to_rest_vertices)]\\n nearest_vertex = temp_stl_vertices_list[nearest_index]\\n middle_vertex = list(np.average((np.array(rand_vertex), np.array(nearest_vertex)), axis=0))\\n stl_vertices_list.append(middle_vertex)\\n\\n return stl_vertices_list\",\n \"def _pick_network(self, network_type, count):\\n possible_networks = self.config[\\\"networks\\\"][network_type]\\n networks = [self._provider.get_network(net) for net in possible_networks]\\n usable = []\\n for network in networks:\\n ips = self._provider.get_ips(ref=network.get(\\\"id\\\"))\\n available = ips[\\\"total_ips\\\"] - ips[\\\"used_ips\\\"]\\n if available > count:\\n usable.append((network[\\\"name\\\"], available))\\n\\n if not usable:\\n logger.error(\\n f\\\"{self.dsp_name}: Error: no usable network\\\"\\n f\\\" for {count} hosts with {network_type}\\\"\\n )\\n return None\\n\\n # sort networks by number of available IPs\\n usable = sorted(usable, key=lambda u: u[1])\\n logger.debug(f\\\"{self.dsp_name}: Listing usable networks: {usable}\\\")\\n res_network = usable[-1][0]\\n logger.debug(\\n f\\\"{self.dsp_name}: Picking network \\\"\\n f\\\"with the most available adresses: {res_network}\\\"\\n )\\n return res_network # Pick the one with most IPs\",\n \"def determine_offer_tuple_NN(nn, ti, ca, eps, eps_ran, revenues, A, arrival_probabilities, preference_weights, no_purchase_preference):\\n\\n\\n # opportunity costs\\n opp_costs = 1.0*np.zeros_like(revenues)\\n for pro in products:\\n if functools.reduce(operator.or_, ca - A[:, pro] < 0):\\n # set opp costs to infty if not enough capacity for product\\n opp_costs[pro] = np.inf\\n else:\\n # calculate opportunity costs via Bellman: V(t+1, c) - V(t+1, c-A[i])\\n t_df = pd.DataFrame([np.zeros(T + 1)] * 1)\\n t_df.columns = [\\\"t\\\" + str(i) for i in t_df.columns]\\n t_df.iloc[0, ti+1] = 1\\n\\n cs_unsold = {}\\n for h in resources:\\n c_df = pd.DataFrame([np.zeros(T +1)] * 1)\\n c_df.columns = [\\\"c-h\\\" + str(h) + \\\"-t\\\" + str(i) for i in c_df.columns]\\n c_df.iloc[0, ti+1] = ca[h]\\n cs_unsold[h] = c_df\\n\\n cs_sold = {}\\n for h in resources:\\n c_df = pd.DataFrame([np.zeros(T + 1)] * 1)\\n c_df.columns = [\\\"c-h\\\" + str(h) + \\\"-t\\\" + str(i) for i in c_df.columns]\\n c_df.iloc[0, ti + 1] = ca[h] - A[h, pro]\\n cs_sold[h] = c_df\\n\\n X_unsold = pd.concat([t_df, *[cs_unsold[h] for h in resources]], axis=1)\\n X_sold = pd.concat([t_df, *[cs_sold[h] for h in resources]], axis=1)\\n\\n opp_costs[pro] = nn.predict(X_unsold) - nn.predict(X_sold)\\n\\n # epsilon greedy strategy - offer no products\\n if eps_ran < eps / 2:\\n return tuple(np.zeros_like(revenues))\\n\\n # epsilon greedy strategy - offer all products\\n if eps_ran < eps:\\n offer_tuple = np.ones_like(revenues)\\n offer_tuple[opp_costs == np.inf] = 0 # one resource not available => don't offer product\\n return tuple(offer_tuple)\\n\\n # setup\\n offer_tuple = np.zeros_like(revenues)\\n\\n # line 1\\n s_prime = revenues - opp_costs > 0\\n if all(np.invert(s_prime)):\\n return tuple(offer_tuple)\\n\\n # line 2-3\\n # offer_sets_to_test has in each row an offer set, we want to test\\n offer_sets_to_test = np.zeros((sum(s_prime), len(revenues)))\\n offer_sets_to_test[np.arange(sum(s_prime)), np.where(s_prime)] = 1\\n offer_sets_to_test += offer_tuple\\n offer_sets_to_test = (offer_sets_to_test > 0)\\n\\n value_marginal = np.apply_along_axis(calc_value_marginal_nn, 1, offer_sets_to_test, opp_costs, revenues,\\n arrival_probabilities, preference_weights, no_purchase_preference)\\n\\n offer_tuple = offer_sets_to_test[np.argmax(value_marginal)]*1\\n s_prime = s_prime & offer_tuple == 0\\n v_s = np.amax(value_marginal)\\n\\n # line 4\\n while True:\\n # 4a\\n # offer_sets_to_test has in each row an offer set, we want to test\\n offer_sets_to_test = np.zeros((sum(s_prime), len(revenues)))\\n offer_sets_to_test[np.arange(sum(s_prime)), np.where(s_prime)] = 1\\n offer_sets_to_test += offer_tuple\\n offer_sets_to_test = (offer_sets_to_test > 0)\\n\\n # 4b\\n value_marginal = np.apply_along_axis(calc_value_marginal_nn, 1, offer_sets_to_test, opp_costs, revenues,\\n arrival_probabilities, preference_weights, no_purchase_preference)\\n\\n if np.amax(value_marginal) >= v_s:\\n v_s = np.amax(value_marginal)\\n offer_tuple = offer_sets_to_test[np.argmax(value_marginal)]*1 # to get 1 for product offered\\n s_prime = (s_prime - offer_tuple) == 1 # only those products remain, that are neither in the offer_tuple\\n if all(offer_tuple == 1):\\n break\\n else:\\n break\\n return tuple(offer_tuple)\",\n \"def _selected_indices(self, subset):\\n # We want the DataFrame to be indexed the same way its values array is\\n ftr = self.frametracks.reset_index(drop=True)\\n if subset is not None:\\n ftr['tmpindex'] = ftr.index.values\\n ftr = ftr.set_index('particle').reindex(subset).set_index('tmpindex')\\n if self.autoclip:\\n # Boundaries are computed for the whole system\\n xmin = self.frametracks.x.min() + self.nncutoff\\n xmax = self.frametracks.x.max() - self.nncutoff\\n ymin = self.frametracks.y.min() + self.nncutoff\\n ymax = self.frametracks.y.max() - self.nncutoff\\n r = ftr.index[ (ftr.x > xmin) & (ftr.x < xmax) & \\\\\\n (ftr.y > ymin) & (ftr.y < ymax) ].values.astype(int)\\n else:\\n r = ftr.index.values.astype(int)\\n if self.fast:\\n return np.random.permutation(r)[:int(len(r) / 10)]\\n else:\\n return r\",\n \"def get_sensor_bool_dryspot_runlevel(self, filename, threshold_min_counted_dryspots=5):\\n f = h5py.File(filename, \\\"r\\\")\\n meta_file = h5py.File(str(filename).replace(\\\"RESULT.erfh5\\\", \\\"meta_data.hdf5\\\"), 'r')\\n\\n try:\\n single_states, set_of_states, useless_states = self.__get_dryspot_data(f, meta_file)\\n multi_states = self.__get_pressure_data(f)\\n multi_states = multi_states.squeeze()\\n\\n activated_sensors = np.count_nonzero(multi_states, axis=1)\\n percentage_of_all_sensors = activated_sensors / 1140\\n len_wanted_seq = 100\\n current = 0\\n sequence = np.zeros((len_wanted_seq, self.num_sensors))\\n frame_labels = []\\n\\n if self.aux_info:\\n original_frame_idxs = np.full(len_wanted_seq, np.nan, np.int16)\\n frame_labels_aux = np.full(len_wanted_seq, np.nan, np.int8)\\n sample_percentages = np.full(len_wanted_seq, np.nan)\\n single_state_indices = np.full(len_wanted_seq, np.nan, np.int16)\\n # flowfronts = np.zeros((len_wanted_seq, self.image_size[0], self.image_size[1]))\\n # _coords, flat_fillings = self.__get_filling_data(f, single_states)\\n\\n for i, sample in enumerate(single_states):\\n state_num = int(str(sample).replace(\\\"state\\\", \\\"0\\\"))\\n try:\\n sample_percentage = percentage_of_all_sensors[state_num - 1]\\n if sample_percentage >= current / len_wanted_seq:\\n data = multi_states[state_num - 1, :]\\n data = np.log(np.add(data, 1)) # TODO make log optional\\n if self.sensor_indizes != ((0, 1), (0, 1)):\\n rect = data.reshape(38, 30)\\n sel = rect[self.sensor_indizes[0][0]::self.sensor_indizes[0][1],\\n self.sensor_indizes[1][0]::self.sensor_indizes[1][1]]\\n data = sel.flatten()\\n sequence[current, :] = data\\n\\n frame_label = 0\\n if state_num in set_of_states:\\n frame_label = 1\\n frame_labels.append(frame_label)\\n\\n if self.aux_info:\\n original_frame_idxs[current] = state_num\\n frame_labels_aux[current] = frame_label\\n sample_percentages[current] = sample_percentage\\n single_state_indices[current] = i\\n # flowfronts[current, :, :] = create_np_image(target_shape=self.image_size,\\n # norm_coords=_coords, data=flat_fillings[i])\\n current += 1\\n except IndexError:\\n continue\\n\\n # determine runlevel label using frame labels and threshold\\n lens_of_runs_of_dryspots = [sum(1 for _ in group) for key, group in\\n groupby(np.array(frame_labels) == 1) if key]\\n max_len = 0 if len(lens_of_runs_of_dryspots) == 0 else max(lens_of_runs_of_dryspots)\\n label = 0 if max_len < threshold_min_counted_dryspots else 1\\n\\n f.close()\\n meta_file.close()\\n\\n if self.aux_info:\\n # framelabels, original_frame_idx, original_num_frames, flowfronts, filling_percentage\\n aux = {\\\"framelabel\\\": frame_labels_aux,\\n \\\"original_frame_idx\\\": original_frame_idxs,\\n \\\"original_num_multi_states\\\": len(multi_states),\\n \\\"percent_of_sensors_filled\\\": sample_percentages,\\n \\\"single_state_indices\\\": single_state_indices,\\n }\\n return [(sequence, label, aux)]\\n\\n return [(sequence, label)]\\n except KeyError:\\n f.close()\\n meta_file.close()\\n return None\",\n \"def __getitem__(self, index):\\n d = self._signal_object[index]\\n d = bootstrap_data_voxel(d, self._H, self._R)\\n d.clip(self._min_signal, 1., d)\\n return d\",\n \"def local_optimize(X, nrounds=1, cost_weights=(1.,1.,1.), use_all=True, use_subset=False):\\n\\n old_cost = cost_total(X, cost_weights=cost_weights)\\n\\n orig_cost = old_cost\\n\\n configs = [X.names_seats_dict.copy()]\\n\\n # loop through number of rounds\\n for ind1 in range(nrounds):\\n\\n # loop through randomly\\n for ind in np.random.choice(range(len(X.seats)), len(X.seats), replace=True):\\n # print(old_cost)\\n # get a candidate\\n\\n if not use_all:\\n neighbours_to_check = np.random.choice(X.seats_graph[X.seats[ind]],len(X.seats_graph[X.seats[ind]]), False)\\n else:\\n if use_subset:\\n neighbours_to_check = [st for st in X.seats if np.random.rand() > .5]\\n else:\\n neighbours_to_check = X.seats\\n\\n for ind_n in neighbours_to_check:\\n\\n X_new = X.copy()\\n X_new.update(swap_neighbour(X_new, p1=X.seats[ind], p2=ind_n))\\n\\n new_cost = cost_total(X_new, cost_weights=cost_weights)\\n\\n # accept if better\\n if new_cost < old_cost:\\n old_cost = new_cost\\n configs.append(X.names_seats_dict)\\n X = X_new.copy()\\n\\n return X, orig_cost, old_cost, configs\",\n \"def select_best_chanels():\\r\\n \\r\\n \\r\\n all_paths = [['data_bci\\\\\\\\row_data\\\\\\\\subject1\\\\\\\\'], ['data_bci\\\\\\\\row_data\\\\\\\\subject2\\\\\\\\'],['data_bci\\\\\\\\row_data\\\\\\\\subject3\\\\\\\\']]\\r\\n\\r\\n train_subjects = ['01']\\r\\n test_subject = '02'\\r\\n freq = 512\\r\\n\\r\\n cutoff_beggining = 0\\r\\n columns_to_read = ['Fp1', 'AF3' ,'F7', 'F3', 'FC1', 'FC5', 'T7', 'C3', 'CP1', 'CP5',\\r\\n 'P7', 'P3', 'Pz', 'PO3', 'O1', 'Oz', 'O2', 'PO4', 'P4', 'P8', 'CP6',\\r\\n 'CP2', 'C4', 'T8', 'FC6', 'FC2', 'F4', 'F8', 'AF4', 'Fp2', 'Fz', 'Cz','class']\\r\\n seq_len = 0\\r\\n cut_step = 0\\r\\n num_perseg = freq\\r\\n num_overlap = int(num_perseg/2)\\r\\n min_freq=8\\r\\n max_freq=45\\r\\n \\r\\n chanels_rank = rank_chanels()\\r\\n \\r\\n result = []\\r\\n for i in range(1, len(chanels_rank)):\\r\\n intermidiate_result = []\\r\\n for path in all_paths:\\r\\n train_full_data, train_full_data_filtered, train_full_anots, test_full_data, test_full_filtered, test_full_annoations = read_filter(path, train_subjects,test_subject, columns_to_read, cutoff_beggining, seq_len, cut_step)\\r\\n\\r\\n train_psd_signals = eval_psd_not_modulated(train_full_data, num_perseg, num_overlap, freq, min_freq, max_freq)\\r\\n test_psd_signals = eval_psd_not_modulated(test_full_data, num_perseg, num_overlap, freq, min_freq, max_freq) \\r\\n\\r\\n train_psd_signals = flatten_data(train_psd_signals[:,:,chanels_rank[:i]])\\r\\n test_psd_signals = flatten_data(test_psd_signals[:,:,chanels_rank[:i]])\\r\\n \\r\\n acc = evalute_subset(train_psd_signals, test_psd_signals, train_full_anots, test_full_annoations)\\r\\n intermidiate_result.append(acc)\\r\\n \\r\\n result.append(intermidiate_result)\\r\\n #mean_subject_acc = np.array([sum(humans_acc)/len(humans_acc) for humans_acc in result])\\r\\n #best_idx = np.argmax(mean_subject_acc)\\r\\n\\r\\n return result, chanels_rank\",\n \"def calc_nearest_ind(self, robot_pose):\\n pass\",\n \"def test_index_nas_shares_by_pool(self):\\n pass\",\n \"def SOM(args):\\n\\n # Obtain the normalized set of cities (w/ coord in [0,1])\\n cities = pd.read_csv(Path(args.data_dir) / 'data1.csv')\\n\\n iteration = args.iteration\\n learning_rate = args.learning_rate\\n decay = args.decay\\n\\n out_dir = Path(args.out_dir)\\n out_dir.mkdir_p()\\n\\n cities_nm = cities.copy()\\n\\n cities_nm[['x', 'y']] = normalize(cities_nm[['x', 'y']])\\n cities_nm.to_csv(out_dir/'cities_nm.csv')\\n cities.to_csv(out_dir/'cities.csv')\\n\\n\\n depot = cities_nm.query('city==0')[['x','y']].to_numpy()\\n # The population size is 8 times the number of cities\\n #n = cities_cp.shape[0] * 2# a single route's neurons\\n n=100\\n # Generate an adequate network of neurons:\\n #network = generate_network(n)\\n neuron_chains =init_neurons(size=n,depot=depot)\\n print('--> Network of {} neurons created. Starting the iterations:'.format(n))\\n best_routes=np.array([0])\\n\\n #save\\n losses_sum_log={}#每个循环losses_sum值\\n min_losses_sum_log = {}##保存最小值的路径losses\\n min_losses_log={}#存储最好情况下四条路径的距离值\\n min_routes_log={}\\n best_id=0\\n min_losses_sum=0\\n\\n for i in tqdm(range(iteration)):\\n if not i % args.neuro_plot_freq:\\n print('\\\\t> Iteration {}/{}'.format(i, iteration), end=\\\"\\\\r\\\")\\n # Choose a random city\\n sample = cities_nm.sample(1)\\n if int(sample['city']) in args.depot_idxs:\\n continue\\n city = sample[['x', 'y']].values#随机抽样 random sampling\\n group_idx,winner_idx = select_closest_gpid(neuron_chains, city)\\n\\n # Generate a filter that applies changes to the winner's gaussian\\n gaussian = get_neighborhood(center=winner_idx, radix=n//10, domain=neuron_chains[0].shape[0])\\n # Update the network's weights (closer to the city)\\n neuron_chains[group_idx] += gaussian[:,np.newaxis] * learning_rate * (city - neuron_chains[group_idx])\\n # Decay the variables\\n learning_rate = learning_rate * decay\\n n = n * decay\\n\\n\\n if i % args.evaluate_freq==0:\\n cities_od = rebuild_cities(cities_nm,neuron_chains,args.num_depots)\\n cities_od[['x','y']] =cities.reindex(cities_od['city'])[['x','y']]\\n losses = routes_distances(cities_od)\\n losses_sum = sum(losses)\\n losses_sum_log[i] = losses_sum\\n\\n if min_losses_sum == 0 or min_losses_sum > losses_sum:\\n min_losses_sum = losses_sum\\n best_id = i\\n routes = get_routes(cities_od)\\n routes = [list(item.astype(np.float64)) for item in routes]\\n min_routes_log[i] = routes\\n\\n min_losses_sum_log[i] = losses_sum\\n min_losses_log[i] = losses\\n cities_od.to_csv(out_dir/'data_out_{:04d}.csv'.format(i))\\n save_neuron_chains(neuron_chains,out_dir/\\\"neuron_chains_{:04d}.npy\\\".format(i))\\n\\n #end for\\n\\n # Check if any parameter has completely decayed.\\n if n < 1:\\n print('Radius has completely decayed, finishing execution',\\n 'at {} iterations'.format(i))\\n break\\n if learning_rate < 0.001:\\n print('Learning rate has completely decayed, finishing execution',\\n 'at {} iterations'.format(i))\\n break\\n\\n\\n print('Completed {} iterations.'.format(iteration))\\n\\n results = {}\\n\\n results['losses_sum_log']=losses_sum_log\\n results['best_id'] = best_id\\n\\n results['min_losses_sum_log']=min_losses_sum_log\\n results['min_losses_log']=min_losses_log\\n results['min_routes_log'] = min_routes_log\\n\\n\\n p = Path(out_dir/'results.json')\\n with open(p, 'w') as fp:\\n json.dump(results, fp)\\n print('ok')\\n\\n\\n return results\",\n \"def neighborhood_sample(solution, ssize):\\n n_runs = len(solution)\\n n_clusters = len(solution[0])\\n \\n swaps_per_run = n_clusters * (n_clusters-1) // 2\\n max_size = n_runs * swaps_per_run\\n \\n ssize = min(ssize, max_size)\\n \\n combinations = list(itertools.combinations(range(n_clusters), 2))\\n selection = random.sample(range(max_size), ssize)\\n \\n nb = [0] * ssize\\n \\n for i_nb, i_sel in enumerate(selection):\\n i_run = i_sel // swaps_per_run\\n i_comb = i_sel % swaps_per_run\\n \\n i1, i2 = combinations[i_comb]\\n swapped = solution[i_run][:]\\n swapped[i1], swapped[i2] = swapped[i2], swapped[i1]\\n nb[i_nb] = solution[:i_run] + [swapped] + solution[i_run+1:]\\n \\n return selection, nb\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.5653433","0.5381229","0.53606856","0.5151725","0.515109","0.5149648","0.5137952","0.5123968","0.5091534","0.50662845","0.50472456","0.49676326","0.49329218","0.48787913","0.48551527","0.48445284","0.48404717","0.48297074","0.48243114","0.48206934","0.48151773","0.48112148","0.4777752","0.47560576","0.47275975","0.47275907","0.47206298","0.4718929","0.4711076","0.47051686","0.46986598","0.46894407","0.46699318","0.46584612","0.46489608","0.46467438","0.46362835","0.46310663","0.462843","0.46239385","0.46193874","0.46132824","0.46035922","0.459657","0.45922136","0.45856178","0.45842752","0.457793","0.45738137","0.4573233","0.45727122","0.45634145","0.4562091","0.45534593","0.45533064","0.45502368","0.45483693","0.45477682","0.4545324","0.45383972","0.45337442","0.45304692","0.4525575","0.45245588","0.45201737","0.4516098","0.45117298","0.45056307","0.45052084","0.4504871","0.45025784","0.44930327","0.44893816","0.44807756","0.44778228","0.44753906","0.44744375","0.4473642","0.44709164","0.44676664","0.44624257","0.44597933","0.44586852","0.44564396","0.44553524","0.44468117","0.4430859","0.4429039","0.44285688","0.4425586","0.44240955","0.4415567","0.4415342","0.44149953","0.44111505","0.4410456","0.44053194","0.44045094","0.4403838","0.4402721"],"string":"[\n \"0.5653433\",\n \"0.5381229\",\n \"0.53606856\",\n \"0.5151725\",\n \"0.515109\",\n \"0.5149648\",\n \"0.5137952\",\n \"0.5123968\",\n \"0.5091534\",\n \"0.50662845\",\n \"0.50472456\",\n \"0.49676326\",\n \"0.49329218\",\n \"0.48787913\",\n \"0.48551527\",\n \"0.48445284\",\n \"0.48404717\",\n \"0.48297074\",\n \"0.48243114\",\n \"0.48206934\",\n \"0.48151773\",\n \"0.48112148\",\n \"0.4777752\",\n \"0.47560576\",\n \"0.47275975\",\n \"0.47275907\",\n \"0.47206298\",\n \"0.4718929\",\n \"0.4711076\",\n \"0.47051686\",\n \"0.46986598\",\n \"0.46894407\",\n \"0.46699318\",\n \"0.46584612\",\n \"0.46489608\",\n \"0.46467438\",\n \"0.46362835\",\n \"0.46310663\",\n \"0.462843\",\n \"0.46239385\",\n \"0.46193874\",\n \"0.46132824\",\n \"0.46035922\",\n \"0.459657\",\n \"0.45922136\",\n \"0.45856178\",\n \"0.45842752\",\n \"0.457793\",\n \"0.45738137\",\n \"0.4573233\",\n \"0.45727122\",\n \"0.45634145\",\n \"0.4562091\",\n \"0.45534593\",\n \"0.45533064\",\n \"0.45502368\",\n \"0.45483693\",\n \"0.45477682\",\n \"0.4545324\",\n \"0.45383972\",\n \"0.45337442\",\n \"0.45304692\",\n \"0.4525575\",\n \"0.45245588\",\n \"0.45201737\",\n \"0.4516098\",\n \"0.45117298\",\n \"0.45056307\",\n \"0.45052084\",\n \"0.4504871\",\n \"0.45025784\",\n \"0.44930327\",\n \"0.44893816\",\n \"0.44807756\",\n \"0.44778228\",\n \"0.44753906\",\n \"0.44744375\",\n \"0.4473642\",\n \"0.44709164\",\n \"0.44676664\",\n \"0.44624257\",\n \"0.44597933\",\n \"0.44586852\",\n \"0.44564396\",\n \"0.44553524\",\n \"0.44468117\",\n \"0.4430859\",\n \"0.4429039\",\n \"0.44285688\",\n \"0.4425586\",\n \"0.44240955\",\n \"0.4415567\",\n \"0.4415342\",\n \"0.44149953\",\n \"0.44111505\",\n \"0.4410456\",\n \"0.44053194\",\n \"0.44045094\",\n \"0.4403838\",\n \"0.4402721\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.52776587"},"document_rank":{"kind":"string","value":"3"}}},{"rowIdx":80896,"cells":{"query":{"kind":"string","value":"Generates the matrices required for generating reservoir weights"},"document":{"kind":"string","value":"def gen_ran_res_params(self):\n gen = Generator(device = self.device).manual_seed(self.random_seed)\n n = self.n_nodes_\n self.accept = rand(n, n, **self.tensorArgs, generator = gen)\n self.reservoir_pre_weights = rand(n, n, **self.tensorArgs, generator = gen) * 2 - 1"},"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 create_weight_matrices(self):\n rad = 1 / np.sqrt(self.no_of_in_nodes)\n X = truncated_normal(mean=0, \n sd=1, \n low=-rad, \n upp=rad)\n self.wih = X.rvs((self.no_of_hidden_nodes, \n self.no_of_in_nodes))\n rad = 1 / np.sqrt(self.no_of_hidden_nodes)\n X = truncated_normal(mean=0, sd=1, low=-rad, upp=rad)\n self.who = X.rvs((self.no_of_out_nodes, \n self.no_of_hidden_nodes))","def gen_in_weights(self):\n\n gen = Generator(device = self.device).manual_seed(self.random_seed)\n n, m = self.n_nodes_, self.n_inputs_\n in_w_shape_ = (n, m)\n print('m,n', m,n)\n\n #at the moment all input weight matrices use uniform bias.\n self.bias = rand( n, 1, generator = gen, device = self.device) * 2 - 1\n\n #weights\n if self.input_weight_type_ == \"uniform\":\n self.in_weights = rand((n,m), generator = gen, device = self.device)\n self.in_weights = self.in_weights * 2 - 1\n print('in_weights', self.in_weights.shape)\n\n elif self.input_weight_type_ == \"exponential\":\n printc(\"BUILDING SIGN_\", 'fail')\n sign1 = random_state.choice([-1, 1], size= (in_w_shape_[0], in_w_shape_[1]//2))\n sign2 = random_state.choice([-1, 1], size= (in_w_shape_[0], in_w_shape_[1]//2))\n\n self.sign_dual = (sign1, sign2)\n self.sign = np.concatenate((sign1, sign2), axis = 1)\n\n #regularization\n self.feedback_weights = rand(n, 1, **self.tensorArgs, generator = gen) * 2 - 1\n\n #regularization\n self.noise_z = normal(0, 1, size = (n, m), **self.tensorArgs, generator = gen)","def gen_W(users, items, ratings):\n\n # initiate graph\n user = users.tolist()\n item = items.tolist()\n rating = ratings.tolist()\n B = nx.Graph()\n B.add_nodes_from(user, bipartite=0)\n B.add_nodes_from(item, bipartite=1)\n\n # create edges\n for i in range(len(user)):\n B.add_edges_from([(user[i], item[i])])\n B[user[i]][item[i]]['weight'] = rating[i]\n\n users_unique = users.unique() \n items_unique = items.unique()\n\n # BiAdjacency matrix - for bipartite network\n W = biadjacency_matrix(B, users_unique,items_unique).toarray()\n\n # sparce form of Biadjacency matrix\n W = spa.csr_matrix(W)\n print('Shape of W: '+str(W.shape))\n\n return W, users_unique, items_unique","def _generate_weighted_matrices(self):\n self.degree_weighted_matrices = dict()\n mes = []\n args = []\n for metaedge, matrix in self.adj_matrices.items():\n mes.append(metaedge)\n args.append({'matrix': matrix, 'w': self.w, 'degree_fwd': self.out_degree[metaedge],\n 'degree_rev': self.in_degree[metaedge]})\n res = parallel_process(array=args, function=mt.weight_by_degree, use_kwargs=True, n_jobs=self.n_jobs,\n front_num=0)\n for metaedge, matrix in zip(mes, res):\n self.degree_weighted_matrices[metaedge] = matrix","def initWeights(self):\n self.weights = []\n self.bias = []\n for i, dim in enumerate(self.dimensions[1:]):\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\n self.bias.append(np.random.uniform(-1,1,dim))","def weightGenerate(self):\n\t\tfor i in range(0, self.numberOfInput):\n\t\t\tself.weight.append(random.random()-0.5)","def generate_weights(sizes):\n weights = {}\n weights[\"w\"] = []\n weights[\"b\"] = []\n for i in range(len(sizes)-2):\n weights[\"w\"].append(np.random.randn(sizes[i], sizes[i+1]))\n weights[\"b\"].append(np.random.randn(sizes[i+1]))\n weights[\"w_final\"] = np.random.randn(sizes[-2], sizes[-1])/np.sqrt(sizes[-1])\n weights[\"b_final\"] = np.random.randn(sizes[-1])\n return weights","def InitWeights(self):\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\n self.w0 = -1 + 2 * np.random.rand()","def _create_weights(self):\n\n self.mu_W = tf.get_variable(\n name=\"mu_W\", initializer=tf.random_normal_initializer(),\n shape=[self.rnn_dim, self.z_dim])\n\n self.mu_b = tf.get_variable(\n name=\"mu_b\", initializer=tf.random_normal_initializer(),\n shape=[self.z_dim])\n\n self.log_sig_sq_W = tf.get_variable(\n name=\"log_sig_sq_W\", initializer=tf.random_normal_initializer(),\n shape=[self.rnn_dim, self.z_dim])\n\n self.log_sig_sq_b = tf.get_variable(\n name=\"log_sig_sq_b\", initializer=tf.random_normal_initializer(),\n shape=[self.z_dim])\n \n self.y_W = tf.get_variable(\n name=\"y_W\", initializer=tf.random_normal_initializer(),\n shape=[self.z_dim, self.rnn_dim])\n\n self.y_b = tf.get_variable(\n name=\"y_b\", initializer=tf.random_normal_initializer(),\n shape=[self.rnn_dim])\n \n self.softmax_W = tf.get_variable(\n name=\"softmax_W\", initializer=tf.random_normal_initializer(),\n shape=[self.rnn_dim, self.vocabulary_size])\n \n self.softmax_b = tf.get_variable(\n name=\"softmax_b\", initializer=tf.random_normal_initializer(),\n shape=[self.vocabulary_size])","def init_weights(self, dims):\n self.W = np.random.normal(size=dims) * 0.0001","def _generate_weights(self):\n weights = [random.uniform(0, 1) for x in range(self.num_weights)]\n return self._normalize_weights(weights)","def init_weights(num_tilings, tiles_per_dim, num_dims, num_actions):\n weights = np.zeros((num_tilings*tiles_per_dim**num_dims*num_actions))\n return weights","def _generate_weights(self):\n weights = []\n for i in range(1, len(self.layers) - 1):\n weights.append(2 * np.random.random(\n (self.layers[i - 1] + 1, self.layers[i] + 1)) - 1)\n weights.append(2 * np.random.random(\n (self.layers[i] + 1, self.layers[i + 1])) - 1)\n return weights","def _create_weights(self):\n gate_size = self._hidden_size * self._num_gates\n # Compute the shape of weight and bias.\n matrix_shapes, bias_shapes = [], []\n for layer in range(self._num_layers):\n for direction in range(self._num_directions):\n layer_input_size = self._input_size if layer == 0 \\\n else self._hidden_size * self._num_directions\n w_ih_shape = [gate_size, layer_input_size]\n w_hh_shape = [gate_size, self._hidden_size]\n b_ih_shape, b_hh_shape = [gate_size], [gate_size]\n matrix_shapes.extend([w_ih_shape, w_hh_shape])\n bias_shapes.extend([b_ih_shape, b_hh_shape])\n # Create single float32 weights.\n weights_count = 0\n self._weights_shapes = matrix_shapes + bias_shapes\n for shape in self._weights_shapes:\n weights_count += math_util.prod(shape)\n self._weights = Tensor([weights_count])\n self._weights.requires_grad = True","def init_weights(self):\n \n self.w = np.random.randn(self.D) / np.sqrt(self.D)","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n mean = 0\n std_dev = 0.0001\n #print(in_features)\n #print(out_features)\n # create weight matrices\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\n #print(weight.shape)\n grad_weight = np.zeros((in_features, out_features))\n\n # create biases (in batches)\n bias = np.zeros(out_features)\n grad_bias = np.zeros(out_features)\n\n self.params = {'weight': weight, 'bias': bias}\n self.grads = {'weight': bias, 'bias': grad_bias}\n\n ########################\n # END OF YOUR CODE #\n #######################","def get_weights(self):","def _allocation_weights(self, write_gates, num_writes, usage):\n write_gates = write_gates.unsqueeze(-1)\n allocation_weights = []\n for i in range(num_writes):\n allocation = self._allocate(usage)\n allocation_weights.append(allocation)\n usage = usage + ((1-usage)*write_gates[:, i, :]*allocation_weights[i])\n allocation_weights = torch.stack(allocation_weights, 1)\n return allocation_weights","def generateMatrix(self):\n if self.tokenWeights and self.extraFeatures:\n nFeatures = self.wordId + self.wordId2 + len(self.EXTRA_WEIGHTS_LABELS)\n logging.info('Exporting TOKEN WEIGHTS AND EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n # iterate through 1st sentence\n for wId, val in doc['s1'].iteritems():\n mtrx[docId, wId] = val\n # then iterate thru 2nd sentence, store on 2ND PARTITION\n for wId, val in doc['s2'].iteritems():\n mtrx[docId, self.wordId + wId] = val\n # finally extra features values stored at the end of the vector\n for label, val in doc['extraFeatures'].iteritems():\n mtrx[docId, self.wordId + self.wordId2 + self.EXTRA_WEIGHTS_LABELS.index(label)] = val\n\n elif self.tokenWeights and not self.extraFeatures:\n nFeatures = self.wordId + self.wordId2\n logging.info('Exporting TOKEN WEIGHTS %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n # iterate through 1st sentence\n for wId, val in doc['s1'].iteritems():\n mtrx[docId, wId] = val\n # then iterate thru 2nd sentence, store on 2ND PARTITION\n for wId, val in doc['s2'].iteritems():\n mtrx[docId, self.wordId + wId] = val\n else:\n nFeatures = len(self.EXTRA_WEIGHTS_LABELS)\n logging.info('Exporting EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\n mtrx = np.zeros((self.docId, nFeatures))\n \n for docId, doc in self.documents.iteritems():\n for label, val in doc['extraFeatures'].iteritems():\n mtrx[docId, self.EXTRA_WEIGHTS_LABELS.index(label)] = val\n logging.info('Matrix generated')\n logging.info(mtrx.shape)\n return mtrx","def _generate_weighted_adj_matrices(self):\n self.weighted_adj_matrices = dict()\n mes = []\n args = []\n for metaedge in self.metaedges:\n mes.append(metaedge)\n args.append(self._prepare_parallel_weighted_adj_matrix_args(self.edge_df.query('abbrev == @metaedge')))\n res = parallel_process(array=args, function=mt.get_adj_matrix, use_kwargs=True, n_jobs=self.n_jobs,\n front_num=0)\n for metaedge, matrix in zip(mes, res):\n self.weighted_adj_matrices[metaedge] = matrix","def instantiate_weights(self):\n self.product_embeddings = tf.get_variable(\n name='product_embeddings',\n shape=[50000, 300],\n dtype=tf.float32\n )\n self.aisle_embeddings = tf.get_variable(\n name='aisle_embeddings',\n shape=[250, 50],\n dtype=tf.float32\n )\n self.department_embeddings = tf.get_variable(\n name='department_embeddings',\n shape=[50, 10],\n dtype=tf.float32\n )\n self.W_relu = tf.get_variable(\"W_relu\",shape=[670, 30]) #这个参数后续需要自适应\n self.b_relu = tf.get_variable(\"bias_relu\",shape=[30]) \n self.W_projection = tf.get_variable(\"W_projection\",shape=[30, 1]) \n self.b_projection = tf.get_variable(\"bias_projection\",shape=[1])","def generate(self):\n t_0 = time()\n\n if self.random_towers:\n self.towers = np.random.rand(self.number_towers, 2)\n else:\n step = np.ceil(np.sqrt(self.number_towers)).astype('int')\n\n if step ** 2 != self.number_towers:\n self.number_towers = step ** 2\n print(f'WARNING: number of towers changed to {self.number_towers}')\n\n X, Y = np.mgrid[0:1:step * 1j, 0:1:step * 1j]\n positions = np.vstack([X.ravel(), Y.ravel()])\n self.towers = positions.swapaxes(1, 0)\n\n self.towers_manager = TowersManager(self.towers, self.vel_friction)\n\n self.distances = self.towers_manager.generate_distances()\n self.print(f'Took {time() - t_0} to create distrances matrix')\n\n t = time()\n self.probabilities = self.generate_probabilities()\n self.print(f'Took {time() - t} to create probabilities matrix')\n\n t = time()\n self.traces = self.generate_weighted_users_traces()\n self.print(f'Took {time() - t} to create user traces')\n\n t = time()\n self.aggregated_data = self.generate_aggregate_data()\n self.print(f'Took {time() - t} to build aggregated data')\n\n self.print(f'Took {time() - t_0} to generate all')","def create_matrix(self):\n\n self.matrix = np.zeros((len(self.users), len(self.items)))\n\n for user in self.train_set['users']:\n for item in self.train_set['feedback'][user]:\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\n self.train_set['feedback'][user][item]","def __init__(self, n4, L, k, randomize=False, non_k=-1, given_weight_matrix = None):\n\n self.n4 = n4\n self.L = L\n self.k = k\n self.weightMatrix = numpy.full((self.n4, self.L), non_k, dtype=numpy.int16)\n\n # initializing from the start\n if given_weight_matrix == None: \n if randomize == \"True\":\n #initialize weight matrix: for each stimulus, pick k neurons that respond randomly\n for stim in range(self.L):\n # randomly samples k neurons to respond (out of n4)\n responds = random.sample(range(n4), k=self.k)\n # updates the values of those k neurons' responses to stimulus \n for nrn in responds: \n self.weightMatrix[nrn][stim] = 1\n else:\n start_nrn = 0\n # the first k neurons respond to first stimulus, and so on\n for stim in range(self.L):\n for nrn_offset in range(self.k):\n self.weightMatrix[start_nrn + nrn_offset][stim] = 1\n start_nrn += self.k\n\n # initializing from previous weight matrix, given as string or as prepared weight matrix\n else: \n if type(given_weight_matrix) is str:\n l4_weight_list = [int(i) for i in given_weight_matrix.split(\",\")]\n \n if len(l4_weight_list) != (self.n4 * self.L):\n print(\"Error! String provided to initialize L4 weight matrix must have length n4 * L.\")\n sys.exit(1)\n\n for nrn in range(self.n4):\n start = nrn * self.L \n end = start + self.L\n self.weightMatrix[nrn] = numpy.array(l4_weight_list[start:end])\n else:\n if given_weight_matrix.shape != (n4, L):\n print(\"Error! Matrix provided to initialize L4 weight matrix must have shape (n4, L)\")\n sys.exit(1)\n self.weightMatrix = given_weight_matrix","def __init__(self, n23, n4, mean, stdp_eta, given_weight_matrices = None):\n self.n23 = n23\n self.n4 = n4\n self.eta = stdp_eta\n\n # initialize from scratch\n if given_weight_matrices == None:\n # create input weight matrix with weights chosen by Gaussian distribution\n stdv = 1/math.sqrt(n4)\n self.inputWeightMatrix = numpy.random.normal(mean, stdv, (n23, n4))\n\n # create recurrent weight matrix, set diagonal to zero\n stdv = 1/math.sqrt(n23)\n self.recurrentWeightMatrix = numpy.random.normal(mean, stdv, (n23, n23))\n numpy.fill_diagonal(self.recurrentWeightMatrix, 0)\n \n # initialize from given weight matrices (should be a tuple with two elements)\n else:\n if len(given_weight_matrices) != 2:\n print(\"Error: kwarg given_weight_matrices in initializion of L23 object must be a tuple of (inputWeighMatrix, recurrentWeightMatrix)\")\n sys.exit(1)\n\n self.inputWeightMatrix = numpy.zeros((self.n23, self.n4))\n self.recurrentWeightMatrix = numpy.zeros((self.n23, self.n23))\n \n # input weight matrix: \n # given as string\n if type(given_weight_matrices[0]) is str:\n l23_weight_list = [float(i) for i in given_weight_matrices[0].split(\",\")]\n if len(l23_weight_list) != (self.n23 * self.n4):\n print(\"Error! String provided to initialize L23 input weight matrix must have length n23 * n4.\")\n sys.exit(1)\n\n for nrn in range(self.n23):\n start = nrn * self.n4 \n end = start + self.n4\n self.inputWeightMatrix[nrn] = numpy.array(l23_weight_list[start:end])\n # given as complete matrix\n else:\n if given_weight_matrices[0].shape != (self.n23, self.n4):\n print(\"Error! Matrix provided to initialize L23 input weight matrix must have shape (n23, n4)\")\n sys.exit(1)\n\n self.inputWeightMatrix = given_weight_matrices[0]\n\n #recurrent weight matrix:\n # given as string\n if type(given_weight_matrices[1]) is str:\n l23_weight_list = [float(i) for i in given_weight_matrices[1].split(\",\")]\n if len(l23_weight_list) != (self.n23 * self.n23):\n print(\"Error! String provided to initialize L23 recurrent weight matrix must have length n23 * n23. String has length %d.\" % len(l23_weight_list))\n sys.exit(1)\n for nrn in range(self.n23):\n start = nrn * self.n23\n end = start + self.n23\n self.recurrentWeightMatrix[nrn] = numpy.array(l23_weight_list[start:end])\n # given as complete matrix\n else:\n if given_weight_matrices[1].shape != (self.n23, self.n23):\n print(\"Error! Matrix provided to initialize L23 recurrent weight matrix must have shape (n23, n23)\")\n sys.exit(1) \n\n self.recurrentWeightMatrix = given_weight_matrices[1]","def _initialize_weights(self, m):\n self.w_ = np.zeros(1 + m)\n self.w_initialized = True","def _initialize_weights(self, m):\n self.w_ = np.zeros(1 + m)\n self.w_initialized = True","def _initialize_weights(self, m):\n self.w_ = np.zeros(1 + m)\n self.w_initialized = True","def reservoir_generator(\n number_of_reservoirs=None, sparsity_level=None, reservoir_dim=None\n):\n reservoir_computing = ReservoirComputing(\n reservoir_dim=reservoir_dim, sparsity_level=sparsity_level\n )\n\n return [reservoir_computing.create_reservoir() for n in range(number_of_reservoirs)]","def generate_weights(self, mag=1):\n \n if (len(self.hlayers) == 0):\n print(\"No weights to generate! Please add hidden layers.\")\n return\n \n weights = []\n \n insize = self.inputLayerSize\n if (self.inputBias == True):\n insize += 1\n \n layersize = self.hlayers[0].size\n if (self.hlayers[0].bias == True):\n layersize += 1\n \n weights.append(np.random.randn(insize, layersize)*mag)\n \n for i in range(0, len(self.hlayers)-1):\n layer1size = self.hlayers[i].size\n if (self.hlayers[i].bias == True):\n layer1size+=1\n \n layer2size = self.hlayers[i+1].size\n if (self.hlayers[i+1].bias == True):\n layer2size+=1\n \n weights.append(np.random.randn(layer1size, layer2size))\n \n \n self.weights = weights","def __initialize_weights__(num_neurons: int) -> np.ndarray:\n\n weights = np.zeros((num_neurons, num_neurons))\n\n return weights","def initializeWeights(n_hidden_units, n_inputs, n_outputs):\n W1 = np.random.randn(n_hidden_units, n_inputs) * np.sqrt(1/(n_inputs*n_hidden_units))\n W2 = np.random.randn(n_outputs, n_hidden_units) * np.sqrt(1/(n_hidden_units*n_outputs))\n b1 = np.random.randn(n_hidden_units, 1) * np.sqrt(1/n_hidden_units)\n b2 = np.random.randn(n_outputs, 1) * np.sqrt(1/n_outputs)\n return W1, b1, W2, b2","def _initialize_weights(self):\n stddev = 1.0 / math.sqrt(self._hidden_size)\n for layer_id, param_id in itertools.product(\n range(self._num_layers * (self._bidirectional + 1)),\n range(self._num_gates * 2)):\n i = layer_id * 2 + (param_id // self._num_gates)\n j = i + len(self._weights_shapes) // 2\n matrix_shape = self._weights_shapes[i][:]\n bias_shape = self._weights_shapes[j][:]\n matrix_shape[0] //= self._num_gates\n bias_shape[0] //= self._num_gates\n self._set_parameter(\n init_ops.random_uniform(matrix_shape, -stddev, stddev),\n layer_id, param_id, 'matrix')\n self._set_parameter(\n init_ops.random_uniform(bias_shape, -stddev, stddev),\n layer_id, param_id, 'bias')","def weights_initializer(self):\n self.weights = [np.random.normal(0, 1 / np.sqrt(x), (x, y)) for x, y in list(zip(self.structure[1:], self.structure[:-1]))]","def __init__(self, sizes):\n self.sizes = sizes\n self.biases = [random_matrix(1, y)[0] for y in sizes[1:]]\n self.weights = [random_matrix(y, x)\n for x, y in zip(sizes[:-1], sizes[1:])]\n\n self.weighted_layer = []\n self.activations = []","def initialize_weights(self):\n w1 = np.random.uniform(-1.0, 1.0, size = self.n_hidden * (self.n_features + 1)).reshape(self.n_hidden, (self.n_features + 1))/(self.n_features + 1)\n w2 = np.random.uniform(-1.0, 1.0, size=self.n_output*(self.n_hidden+1)).reshape(self.n_output, self.n_hidden+ 1)/(self.n_hidden + 1)\n return w1, w2","def _initialize_weights(self):\n pass","def build(self):\n\n self.W = self.init([self.n_atom_input_feat, self.n_output])\n self.b = model_ops.zeros(shape=[\n self.n_output,\n ])\n\n self.trainable_weights = self.W + self.b","def _initialize_matrix(self):\n\n try:\n # Grab the weight matrix from weight_matrices.py\n tmp_weight_matrix = copy.copy(weight_matrices.__dict__[self._weight_matrix_name])\n except KeyError:\n\n # Treat this name as a file\n data = open(self._weight_matrix_name).readlines()\n\n # Grab alphabet bits from top line\n seq = data[0].strip('/n/r').split()\n tmp_weight_matrix = dict([(s,dict([(s,0) for s in seq])) for s in seq])\n \n # Go through each line, populating weight matrix. \n for line in data[1:]:\n line = line.strip('/n/r').split()\n\n a = line[0]\n for j in range(1, len(line)):\n b = seq[j-1]\n tmp_weight_matrix[a][b] = float(line[j])\n\n # Convert tmp_weight_matrix into a numpy array, normalized between 0 \n # and 1.\n keys = list(tmp_weight_matrix.keys())\n self.weight_matrix = np.zeros((len(keys),len(keys)),dtype=float)\n for i, k1 in enumerate(keys):\n a = self._alphabet_dict[k1]\n for j, k2 in enumerate(keys):\n b = self._alphabet_dict[k2]\n self.weight_matrix[a,b] = tmp_weight_matrix[k1][k2]\n\n # Set weights to range from 0 (close) to 1 (far)\n mini = np.min(self.weight_matrix)\n maxi = np.max(self.weight_matrix)\n self.weight_matrix = 1 - (self.weight_matrix - mini)/(maxi - mini)","def initialize_weights_xavier(self):\n\t\tself.weights = [np.random.uniform(-1/sqrt(size1), 1/sqrt(size1)) for size1, size2 in zip(self.sizes[:-1], self.sizes[1:])]\n\t\tself.biases = [np.zeros([size, ]) for size in self.sizes[1:]]","def generate():","def get_random_inhibitory_weights(self):\n \n self.W_ei=np.zeros((self.N_e,self.N_i))\n self.W_ie=np.zeros((self.N_i,self.N_e)) \n self. W_ii=np.zeros((self.N_i,self.N_i))\n\n \n # connections to the excitatory neurons \n for row_idx in xrange(self.N_e):\n \n # from ihibitory\n all_idxs_ei=np.arange(self.N_i)\n np.random.shuffle(all_idxs_ei)\n self.W_ei[row_idx,all_idxs_ei[0:self.num_conns_ei]]=self.W_max_ei \n \n # connections to inhibitory neurons\n for row_idx in range(self.N_i):\n \n # from exitatory \n all_idxs_ie=np.arange(self.N_e)\n np.random.shuffle(all_idxs_ie)\n self.W_ie[row_idx,all_idxs_ie[0:self.num_conns_ie]]=self.W_max_ie\n \n # from inhibitory\n all_idxs_ii=np.arange(self.N_i)\n np.random.shuffle(all_idxs_ii)\n self.W_ii[row_idx,all_idxs_ii[0:self.num_conns_ii]]=self.W_max_ii\n \n \n self.W[:self.N_e,self.N_e:]=self.W_ei\n self.W[self.N_e:,:self.N_e]=self.W_ie\n self.W[self.N_e:,self.N_e:]=self.W_ii","def initialize_weights(self):\n # compute lmda.\n self.lmda = float(self.c)/float(self.N)\n # bias term. This should not get a regularization penalty.\n self.bias = {}\n # weight vector\n self.w = {}\n # lastW[j] = k, indicates that feature j was last updated at time k.\n self.lastW = {}\n for lbl in self.labels:\n self.bias[lbl] = 0\n self.w[lbl] = {}\n self.lastW[lbl] = {}\n pass","def initializeWeights(n_in,n_out):\r\n \r\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\r\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\r\n return W","def initializeWeights(n_in,n_out):\r\n \r\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\r\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\r\n return W","def initializeWeights(n_in,n_out):\n \n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\n return W","def _make_random_matrix(self, n_components, n_features):","def init_weight(w):\n shape = w.shape\n if len(shape) == 4:\n i, o, u, v = shape\n k = np.sqrt(6 / (i * u * v + o * u * v))\n w.data.uniform_(-k, k)\n elif len(shape) == 2:\n k = np.sqrt(6 / sum(shape))\n w.data.uniform_(-k, k)\n elif len(shape) == 1:\n w.data.zero_()","def init_weights_(self):\n raise NotImplementedError","def initialize_weights_and_bias(self, X_train):\n n_samples, n_features = np.shape(X_train)\n n_output = 1 \n \n # This is the numeber of gridcells and we want to make one prediction pr cell. \n # It this doesn't work calculate the number of griddcells.\n\n self.b_h = [] #np.ones((self.n_hidden_layers, self.n_hidden[0]))\n self.W_h = []\n\n for i in range(len(self.n_hidden)):\n if (i == 0):\n self.W_h.append(self.random.normal(loc=0.0, scale=0.1, size=(n_features, self.n_hidden[0])))\n self.b_h.append(np.ones(self.n_hidden[0]))\n else:\n self.W_h.append(self.random.normal(loc=0.0, scale=0.1, size=(self.n_hidden[i-1], self.n_hidden[i])))\n self.b_h.append(np.ones(self.n_hidden[i])) \n \n self.b_out = [1]\n self.W_out = self.random.normal(loc=0.0, scale=0.1, size=(self.n_hidden[-1], n_output))","def generate_weighted_graph():\n \n Adj_Matrix = np.array([\n [0.0, 0.2, 0.2, 0.3, 0.2, 0.1],\n [0.1, 0.0, 0.3, 0.3, 0.1, 0.2],\n [0.3, 0.2, 0.0, 0.1, 0.2, 0.2],\n [0.1, 0.4, 0.2, 0.0, 0.2, 0.1],\n [0.2, 0.2, 0.2, 0.2, 0.0, 0.2],\n [0.2, 0.1, 0.1, 0.3, 0.3, 0.0]\n ])\n\n return Adj_Matrix","def gen_tb_tb_weights(weight=1.):\r\n W = np.zeros([8, 8])\r\n sinusoid = -(np.cos(np.linspace(0, 2 * np.pi, 8, endpoint=False)) - 1) / 2\r\n for i in range(8):\r\n values = np.roll(sinusoid, i)\r\n W[i, :] = values\r\n return weight * W","def initializeWeights(n_in,n_out):\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\n return W","def initializeWeights(n_in,n_out):\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\n return W","def initializeWeights(n_in,n_out):\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\n return W","def constructCell():\n\t\tself.weightGenerate()","def start_weights(self, inv=True):\n return np.eye(self.nmoms)","def train(self):\n\n for i in range(self.c):\n mu_i = self.estimate_mu(i).T\n cov_i = self.estimate_sigma(i, mu_i)\n inv_sigma_i = np.linalg.inv(cov_i)\n P_i = self.estimate_P(i)\n Wi = -1 / 2 * inv_sigma_i\n wi = inv_sigma_i @ mu_i\n wi0 = -1 / 2 * mu_i.T @ inv_sigma_i @ mu_i - 1 / 2 * np.log(np.linalg.det(cov_i)) + np.log(P_i)\n self.weights.append([Wi, wi, wi0])\n return self.weights","def build_layer(self) :\n inputsWithBias = self.input_count + 1\n self.weights = np.random.rand(inputsWithBias, self.node_count)\n self.weights_and_activations = (self.weights, self.activations)","def build_weights_matrix(vectors, custom_vectors, index2word, size = 200):\n weights_matrix = np.zeros((len(index2word), size))\n words_found = 0\n words_found_custom = 0\n\n for i, word in index2word.items():\n try: \n weights_matrix[i] = vectors[index2word[i]]\n words_found += 1\n except KeyError:\n try:\n weights_matrix[i] = custom_vectors[index2word[i]]\n words_found_custom +=1\n except KeyError:\n weights_matrix[i] = np.random.rand(size)\n\n #initialize pad embedding to zero\n weights_matrix[0, ] = np.zeros(size)\n\n print ('words_found: ' + str(words_found/len(index2word)) + \\\n ' additional_words_found: ' + str(words_found_custom/len(index2word)))\n\n return weights_matrix","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n\n self.params = {'weight': 0.0001 * np.random.randn(out_features, in_features), 'bias': np.zeros((out_features, 1))}\n self.grads = {'weight': np.zeros((out_features, in_features)), 'bias': np.zeros((out_features, 1))}\n\n\n\n ########################\n # END OF YOUR CODE #\n #######################","def init_weights(model):\n ...","def WeightInitializer():\n return np.random.uniform(-1, 1)","def _buildWeights(self):\r\n # Compute the spatial tree\r\n kd = spatial.cKDTree(self.XYin)\r\n \r\n # Perform query on all of the points in the grid\r\n dist,self.ind=kd.query(self.XYout,distance_upper_bound=self.maxdist,k=self.NNear)\r\n \r\n self.Nc = np.size(self.ind,axis=0)\r\n print '%d interpolation points.'%self.Nc\r\n # Now loop through and get the weights for each point\r\n self.W = np.zeros((self.NNear,self.Nc))\r\n\r\n # Print percentages\r\n p0=0\r\n pstep=5\r\n for ii in range(0,self.Nc):\r\n \r\n if self.verbose:\r\n pfinish = float(ii)/float(self.Nc)*100.0\r\n if pfinish> p0:\r\n print '%3.1f %% complete...'%pfinish\r\n p0+=pstep\r\n \r\n W = self.getWeights(dist[ii,:],self.XYin[self.ind[ii,:],0],self.XYin[self.ind[ii,:],1])\r\n self.W[:,ii] = W.T","def get_weights_and_biases_from_Onnx(self):\n\t\t\n\t\tpass","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n self.params = {'weight': np.random.normal(loc = 0, scale=0.0001, size=(out_features,in_features)),\\\n 'bias': np.zeros((1, out_features))}\n \n self.grads = {'weight': np.zeros((out_features,in_features)),\\\n 'bias': np.zeros((1, out_features))}\n ########################\n # END OF YOUR CODE #\n #######################","def _init_weights(n_rows, n_cols, std_dev=0.5):\n weights = np.random.randn(n_rows, n_cols) * std_dev\n return weights","def __init__(self, structure):\n # weight matrices\n self.ws = [np.random.randn(m, n) for n, m in zip([0] + structure, structure)]\n # biases\n self.bs = [np.random.rand(n, 1) for n in structure]\n # activations\n self.ys = [np.zeros((n, 1)) for n in structure]\n # z values\n self.zs = [np.zeros((n, 1)) for n in structure]","def sparse_initialization_weights(self):\n W = []\n mu, sigma = 0, 1/self.non_zero_units\n\n for i in xrange(self.n_in):\n row = np.zeros(self.n_out)\n non_zeros = self.rng.normal(mu, sigma, self.non_zero_units)\n # non_zeros /= non_zeros.sum()\n non_zero_idxs = self.rng.permutation(\n self.n_out)[0:self.non_zero_units]\n for j in xrange(self.non_zero_units):\n row[non_zero_idxs[j]] = non_zeros[j]\n W.append(row)\n W = np.asarray(W, dtype=theano.config.floatX)\n return W","def generate_weights(n_features, hidden_layer_sizes, n_out):\n\n weights = []\n biases = []\n\n # Weights from input layer to first hidden layer\n weights.append(init_weight(hidden_layer_sizes[0], n_features))\n biases.append(init_bias(hidden_layer_sizes[0]))\n\n # Weights from one hidden layer to the next\n for i in range(1, hidden_layer_sizes.size):\n weights.append(\n init_weight(hidden_layer_sizes[i],hidden_layer_sizes[i - 1]))\n biases.append(init_bias(hidden_layer_sizes[i]))\n\n # Weights from last hidden layer to output layer\n weights.append(init_weight(n_out, hidden_layer_sizes[-1]))\n biases.append(init_bias(n_out))\n\n return weights, biases","def build(self,input_shape):\n\n self.w = self.add_weight(shape=(input_shape[-1],self.units),\n initializer='random_normal',\n trainable=True)\n self.b = self.add_weight(shape=(self.units,),\n initializer='random_normal',\n trainable=True)","def form_matrix_yt(w):\r\n M = np.zeros((len(w),len(w)))\r\n for i in range(len(w)):\r\n for j in range(len(w)):\r\n M[i,j] = YoungTableaux(w[i],w[j]).CMNR()\r\n return M","def get_weights(self):\n return []","def weights(self):\r\n\t\treturn None","def get_weight_matrix(self):\n\n\t\treturn self.weights.get_value(borrow=True)","def create_population(self):\r\n\r\n model_weights_vector = model_weights_as_vector(model=self.model)\r\n\r\n net_population_weights = []\r\n net_population_weights.append(model_weights_vector)\r\n\r\n for idx in range(self.num_solutions-1):\r\n\r\n net_weights = copy.deepcopy(model_weights_vector)\r\n net_weights = numpy.array(net_weights) + numpy.random.uniform(low=-1.0, high=1.0, size=model_weights_vector.size)\r\n\r\n # Appending the weights to the population.\r\n net_population_weights.append(net_weights)\r\n\r\n return net_population_weights","def random_weights_init(self, data):\n self._check_input_len(data)\n it = nditer(self._activation_map, flags=['multi_index'])\n while not it.finished:\n rand_i = self._random_generator.randint(len(data))\n self._weights[it.multi_index] = data[rand_i]\n it.iternext()","def init_weights(no_input, no_hidden, no_output):\r\n weight_lst = []\r\n no_of_weights = (no_input * no_hidden) + (no_hidden * no_output)\r\n\r\n for weight in range(no_of_weights):\r\n weight = 0.01 * random.random()\r\n weight_lst.append(weight)\r\n\r\n return weight_lst","def weighted_matrix(point: np.mat, training_data_x: np.mat, bandwidth: float) -> np.mat:\r\n # m is the number of training samples\r\n m, n = np.shape(training_data_x)\r\n # Initializing weights as identity matrix\r\n weights = np.mat(np.eye((m)))\r\n # calculating weights for all training examples [x(i)'s]\r\n for j in range(m):\r\n diff = point - training_data[j]\r\n weights[j, j] = np.exp(diff * diff.T / (-2.0 * bandwidth ** 2))\r\n return weights","def weights(self):\n \n n = self.n\n lambda_ = self.alpha**2 * (n +self.kappa) - n\n \n c = .5 / (n + lambda_)\n Wc = np.full(2*n + 1, c)\n Wm = np.full(2*n + 1, c)\n Wc[0] = lambda_ / (n + lambda_) + (1 - self.alpha**2 + self.beta)\n Wm[0] = lambda_ / (n + lambda_)\n \n return Wm, Wc","def _initialize_weights(self, m):\n self.rgen = np.random.RandomState(self.random_state)\n self.w_ = self.rgen.normal(loc=0.0, scale=0.01, size=m)\n self.b_ = 0\n self.w_avg = self.rgen.normal(loc=0.0, scale=0.01, size=m)\n self.b_avg = 0\n\n def net_input(self, X):\n return np.dot(X, self.w_[1:]) + self.w_[0]\n\n def activation(self, X):\n return X\n \n def predict(self, X):\n return np.where(self.net_input(X) >= 0.0, 1, -1)\n \n def get_params(self, deep=True):\n return {\"eta\":self.eta, \"max_iter\":self.max_iter, \"C\":self.C, \"random_state\":self.random_state, \"batch_size\":self.batch_size}\n \n def set_params(self, **parameters):\n for parameter, value in parameters.items():\n setattr(self, parameters, value)\n return self","def _initializeMatrices(self):\n K = self.K \n # Initialize Initia\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\n rand_initial_prob = list(rand_initial_prob[0,:])\n for i in range(K): \n self.state_initial_prob[i+1] = rand_initial_prob[i]\n\n # Initialize the transition MAtrix !\n for i in range(K):\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\n rand_initial_prob = list(rand_initial_prob[0,:]) \n\n for j in range(K):\n self.state_transition_mat[(j+1,i+1)] = rand_initial_prob[j]\n\n\n # Initialize the symbol distribution Parameters ui and si (Assuming a numeric outputs ! Modelled using a gaussian ! withmean ui and std si)\n init_mean = np.mean(self.data_matrix)\n init_std = np.std(self.data_matrix) \n \n for i in range(K):\n random_mean = gauss(init_mean,30)\n random_std = gauss(init_std,30)\n self.state_symbol_prob[i+1] = {'mean':random_mean, 'std' : random_std}","def generate(self):","def generate_design_matrix(bs, v):\n #design matrix has 1 in all first rows (to detect image b=0 SIGNAL)\n x = np.ones((bs.shape[0], 7))\n for i, b in enumerate(bs):\n if b == 0:\n x[i, 1:] = 0\n else:\n x[i, 1] = -b*v[0, i]**2\n x[i, 2] = -b*2*v[0, i]*v[1, i]\n x[i, 3] = -b*2*v[0, i]*v[2, i]\n x[i, 4] = -b*v[1, i]**2\n x[i, 5] = -b*2*v[1, i]*v[2, i]\n x[i, 6] = -b*v[2, i]**2\n return x","def NewWires(self, *args):\n return _BRepAlgo.BRepAlgo_Loop_NewWires(self, *args)","def large_weight_initializer(self):\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\n self.weights = [np.random.randn(y, x)\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]","def default_weight_initializer(self):\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\n self.weights = [np.random.randn(y, x)/np.sqrt(x)\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]","def instantiate_weights(self):\n with tf.variable_scope(\"embedding_projection\"), tf.device('/cpu:0'): # embedding matrix\n self.Embedding = tf.get_variable(\"Embedding\", shape=[self.vocab_size, self.embed_size],\n initializer=self.initializer)\n # self.Embedding_label = tf.get_variable(\"Embedding_label\", shape=[self.num_classes, self.embed_size],\n # dtype=tf.float32) # ,initializer=self.initializer\n # self.W_projection = tf.get_variable(\"W_projection\", shape=[self.sequence_length * self.d_model, self.num_classes],\n # initializer=self.initializer) # [embed_size,label_size]\n # self.b_projection = tf.get_variable(\"b_projection\", shape=[self.num_classes])","def weber_MS(I,J,x,y,w):\n M = max([((x[i]-x[j])**2 + (y[i]-y[j])**2) for i in I for j in I])\n model = Model(\"weber - multiple source\")\n X,Y,v,u = {},{},{},{}\n xaux,yaux,uaux = {},{},{}\n for j in J:\n X[j] = model.addVar(lb=-model.infinity(), vtype=\"C\", name=\"X(%s)\"%j)\n Y[j] = model.addVar(lb=-model.infinity(), vtype=\"C\", name=\"Y(%s)\"%j)\n for i in I:\n v[i,j] = model.addVar(vtype=\"C\", name=\"v(%s,%s)\"%(i,j))\n u[i,j] = model.addVar(vtype=\"B\", name=\"u(%s,%s)\"%(i,j))\n xaux[i,j] = model.addVar(lb=-model.infinity(), vtype=\"C\", name=\"xaux(%s,%s)\"%(i,j))\n yaux[i,j] = model.addVar(lb=-model.infinity(), vtype=\"C\", name=\"yaux(%s,%s)\"%(i,j))\n uaux[i,j] = model.addVar(vtype=\"C\", name=\"uaux(%s,%s)\"%(i,j))\n\n\n\n for i in I:\n model.addCons(quicksum(u[i,j] for j in J) == 1, \"Assign(%s)\"%i)\n for j in J:\n model.addCons(xaux[i,j]*xaux[i,j] + yaux[i,j]*yaux[i,j] <= v[i,j]*v[i,j], \"MinDist(%s,%s)\"%(i,j))\n model.addCons(xaux[i,j] == (x[i]-X[j]), \"xAux(%s,%s)\"%(i,j))\n model.addCons(yaux[i,j] == (y[i]-Y[j]), \"yAux(%s,%s)\"%(i,j))\n model.addCons(uaux[i,j] >= v[i,j] - M*(1-u[i,j]), \"uAux(%s,%s)\"%(i,j))\n\n model.setObjective(quicksum(w[i]*uaux[i,j] for i in I for j in J), \"minimize\")\n\n\n model.data = X,Y,v,u\n return model","def _setup(self) -> None:\n #TODO: type\n self.activation = self.params['activation']\n\n self.batchsize: int = self.params['batchsize']\n\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\n\n self.d: int = self.input_shape[1]\n assert(not self.d == 0)\n\n self.n: int = int(sqrt(self.input_shape[2]))\n assert(not self.n == 0)\n\n self.dtype: type = self.params['dtype']\n\n # initialize weights\n self.W: List[tf.Tensor] = []\n \n for i in range(3):\n #TODO: type\n w_init = self.params['initializer_w']\n if self.params['initializer_w' + str(i)] is not None:\n w_init = self.params['initializer_w' + str(i)]\n\n w_stddev: float = self.params['stddev_w']\n if self.params['stddev_w' + str(i)] is not None:\n w_stddev = self.params['stddev_w' + str(i)]\n\n self.W.append(tf.get_variable(\"weights_\" + str(i),\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\n dtype = self.dtype,\n initializer = w_init(stddev=w_stddev)))\n\n #TODO: type\n b_init = self.params['initializer_b']\n b_stddev = self.params['stddev_b']\n self.B: tf.Tensor = tf.get_variable(\"biases\", shape = (1, self.d, 1),\n dtype = self.dtype,\n initializer = b_init(stddev=b_stddev))\n\n # create/load expand matrix\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\n self.expand: tf.Tensor = tf.get_variable(\n \"expand\" + str(self.n),\n shape = (self.n, self.n * self.n),\n dtype = self.dtype,\n initializer = tf.constant_initializer(make_expand(self.n)))\n\n # create/load tile matrix\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\n for i in range(1, self.n):\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\n\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)","def init_matrix(self, train, num_features):\n user_matrix = np.random.rand(self.num_users, num_features)\n item_matrix = np.random.rand(num_features, self.num_items)\n item_nnz = train.getnnz(axis=0)\n item_sum = train.sum(axis=0)\n item_matrix[0, :] = item_sum / item_nnz\n return user_matrix, item_matrix","def __create_W_matrix(self, n, conv_weight):\n\n # The first two dimensions of the weight are the output and input depth, respectively\n # The third and fourth dimension are equal to the size of the filter -\n # we assume that all filters are square\n output_depth, input_depth, k, _ = conv_weight.shape\n\n # There are i * j blocks in the output matrix W - each block corresponds to\n # a block matrix V_ij\n num_rows_per_block = (n - k + 1) ** 2\n\n # initialize W to be an array of all zeros\n W = np.zeros((output_depth * num_rows_per_block, input_depth * n ** 2))\n # W = np.zeros((6 * num_rows_per_block, 3 * n ** 2))\n\n # i indexes the output feature map stack\n for i in range(output_depth):\n\n # j indexes the input feature map stack (i.e. number of channels in input image)\n for j in range(input_depth):\n\n # Get the filter that convolves the i^th output feature map with the\n # j^th input feature map (i.e. channel for the first layer)\n filter = conv_weight[i, j, :, :]\n\n # Each V_ij is a block circulant (topelitz) matrix - that is, each\n # block of V_ij is a circulant matrix, meaning that each entry appears\n # in each row and column exactly once. V_ij will have dimensions\n # (num_rows_per_block ** 2, n ** 2)\n V_ij = self.__filter_to_bc_matrix(filter, n)\n\n # Broadcast V_ij into the i^th block row and the j^th block column of W\n dim0, dim1 = num_rows_per_block, n ** 2\n W[i * dim0 : (i + 1) * dim0, j * dim1 : (j + 1) * dim1] = V_ij\n\n return W","def initialize_weights(self, seed=None):\r\n if seed!=None:\r\n np.random.seed(seed)\r\n self.weights = np.random.randn(self.number_of_nodes,self.input_dimensions)","def _generate_raw_environments(self, num, seed):","def generate(nextLayerUnits, FirstLayerUnits):\n array = mat.arange(start=1, stop=(nextLayerUnits * (FirstLayerUnits + 1)) + 1, step=1)\n debugWeights = mat.divide(mat.reshape(mat.sin(array), (nextLayerUnits, (FirstLayerUnits + 1))), 10)\n\n return debugWeights","def saveWeights(self, basename, generation):\n for i,wt in enumerate(self.weights):\n np.save(\"./data/\"+basename+\"/\"+basename + \"_W\"+str(i)+\"_G\" + str(generation),wt)\n for i,bs in enumerate(self.bias):\n np.save(\"./data/\"+basename+\"/\"+basename + \"_B\"+str(i)+\"_G\" + str(generation),bs)","def demand_matrices(self) -> list:\n for sample in range(self.__n_samples):\n try:\n yield self.demand_matrix(sample)\n except:\n continue","def create_training_matrices(experiment, sample_times):\n # Labels:\n location_labels = read_location_labels(experiment)\n locations = get_location_of_persons_at_samples(location_labels, sample_times, experiment)\n\n p1_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P1\")\n p2_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P2\")\n p3_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P3\")\n p4_scene_features = read_roi_scene_recognitions_for_person(experiment, \"P4\")\n\n print(p1_scene_features.loc[0]['predictions'].shape[0])\n print(len(p1_scene_features['predictions'][0]))\n data = {\n \"P1\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P2\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P3\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\n \"P4\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0]))\n }\n\n for index, loc_label in enumerate(locations):\n t = loc_label[0]\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P1_eyetracker\")\n p1 = np.mean(p1_scene_features[p1_scene_features['timestamp'].between(t_et - sample_step/2, t_et + sample_step/2)]['predictions'].as_matrix(), axis=0)\n\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P2_eyetracker\")\n p2 = np.mean(\n p2_scene_features[p2_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P3_eyetracker\")\n p3 = np.mean(\n p3_scene_features[p3_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n t_et = convert_timestamps(exp_root, t, \"video\", \"P4_eyetracker\")\n p4 = np.mean(\n p4_scene_features[p4_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\n 'predictions'].as_matrix(), axis=0)\n\n data[\"P1\"][index, 0] = t\n data[\"P1\"][index, 1:-1] = p1\n data[\"P1\"][index, -1] = loc_label[1]\n\n data[\"P2\"][index, 0] = t\n data[\"P2\"][index, 1:-1] = p2\n data[\"P2\"][index, -1] = loc_label[2]\n\n data[\"P3\"][index, 0] = t\n data[\"P3\"][index, 1:-1] = p3\n data[\"P3\"][index, -1] = loc_label[3]\n\n data[\"P4\"][index, 0] = t\n data[\"P4\"][index, 1:-1] = p4\n data[\"P4\"][index, -1] = loc_label[4]\n\n return data","def init_variables():\n weights = np.random.normal(size=2)\n bias = 0\n return weights, bias","def _make_sample_weights(n_repetitions, n_samples, random_state):\n sample_weights = np.zeros((n_repetitions, n_samples), dtype=np.float64)\n\n for repetition in range(n_repetitions):\n sample_weights[repetition] = random_state.rand(n_samples) + 1\n\n return sample_weights","def init_weights(self, num_features):\n for each_label in self.valid_labels:\n self.weights[each_label] = np.zeros(num_features)"],"string":"[\n \"def create_weight_matrices(self):\\n rad = 1 / np.sqrt(self.no_of_in_nodes)\\n X = truncated_normal(mean=0, \\n sd=1, \\n low=-rad, \\n upp=rad)\\n self.wih = X.rvs((self.no_of_hidden_nodes, \\n self.no_of_in_nodes))\\n rad = 1 / np.sqrt(self.no_of_hidden_nodes)\\n X = truncated_normal(mean=0, sd=1, low=-rad, upp=rad)\\n self.who = X.rvs((self.no_of_out_nodes, \\n self.no_of_hidden_nodes))\",\n \"def gen_in_weights(self):\\n\\n gen = Generator(device = self.device).manual_seed(self.random_seed)\\n n, m = self.n_nodes_, self.n_inputs_\\n in_w_shape_ = (n, m)\\n print('m,n', m,n)\\n\\n #at the moment all input weight matrices use uniform bias.\\n self.bias = rand( n, 1, generator = gen, device = self.device) * 2 - 1\\n\\n #weights\\n if self.input_weight_type_ == \\\"uniform\\\":\\n self.in_weights = rand((n,m), generator = gen, device = self.device)\\n self.in_weights = self.in_weights * 2 - 1\\n print('in_weights', self.in_weights.shape)\\n\\n elif self.input_weight_type_ == \\\"exponential\\\":\\n printc(\\\"BUILDING SIGN_\\\", 'fail')\\n sign1 = random_state.choice([-1, 1], size= (in_w_shape_[0], in_w_shape_[1]//2))\\n sign2 = random_state.choice([-1, 1], size= (in_w_shape_[0], in_w_shape_[1]//2))\\n\\n self.sign_dual = (sign1, sign2)\\n self.sign = np.concatenate((sign1, sign2), axis = 1)\\n\\n #regularization\\n self.feedback_weights = rand(n, 1, **self.tensorArgs, generator = gen) * 2 - 1\\n\\n #regularization\\n self.noise_z = normal(0, 1, size = (n, m), **self.tensorArgs, generator = gen)\",\n \"def gen_W(users, items, ratings):\\n\\n # initiate graph\\n user = users.tolist()\\n item = items.tolist()\\n rating = ratings.tolist()\\n B = nx.Graph()\\n B.add_nodes_from(user, bipartite=0)\\n B.add_nodes_from(item, bipartite=1)\\n\\n # create edges\\n for i in range(len(user)):\\n B.add_edges_from([(user[i], item[i])])\\n B[user[i]][item[i]]['weight'] = rating[i]\\n\\n users_unique = users.unique() \\n items_unique = items.unique()\\n\\n # BiAdjacency matrix - for bipartite network\\n W = biadjacency_matrix(B, users_unique,items_unique).toarray()\\n\\n # sparce form of Biadjacency matrix\\n W = spa.csr_matrix(W)\\n print('Shape of W: '+str(W.shape))\\n\\n return W, users_unique, items_unique\",\n \"def _generate_weighted_matrices(self):\\n self.degree_weighted_matrices = dict()\\n mes = []\\n args = []\\n for metaedge, matrix in self.adj_matrices.items():\\n mes.append(metaedge)\\n args.append({'matrix': matrix, 'w': self.w, 'degree_fwd': self.out_degree[metaedge],\\n 'degree_rev': self.in_degree[metaedge]})\\n res = parallel_process(array=args, function=mt.weight_by_degree, use_kwargs=True, n_jobs=self.n_jobs,\\n front_num=0)\\n for metaedge, matrix in zip(mes, res):\\n self.degree_weighted_matrices[metaedge] = matrix\",\n \"def initWeights(self):\\n self.weights = []\\n self.bias = []\\n for i, dim in enumerate(self.dimensions[1:]):\\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\\n self.bias.append(np.random.uniform(-1,1,dim))\",\n \"def weightGenerate(self):\\n\\t\\tfor i in range(0, self.numberOfInput):\\n\\t\\t\\tself.weight.append(random.random()-0.5)\",\n \"def generate_weights(sizes):\\n weights = {}\\n weights[\\\"w\\\"] = []\\n weights[\\\"b\\\"] = []\\n for i in range(len(sizes)-2):\\n weights[\\\"w\\\"].append(np.random.randn(sizes[i], sizes[i+1]))\\n weights[\\\"b\\\"].append(np.random.randn(sizes[i+1]))\\n weights[\\\"w_final\\\"] = np.random.randn(sizes[-2], sizes[-1])/np.sqrt(sizes[-1])\\n weights[\\\"b_final\\\"] = np.random.randn(sizes[-1])\\n return weights\",\n \"def InitWeights(self):\\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\\n self.w0 = -1 + 2 * np.random.rand()\",\n \"def _create_weights(self):\\n\\n self.mu_W = tf.get_variable(\\n name=\\\"mu_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim, self.z_dim])\\n\\n self.mu_b = tf.get_variable(\\n name=\\\"mu_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.z_dim])\\n\\n self.log_sig_sq_W = tf.get_variable(\\n name=\\\"log_sig_sq_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim, self.z_dim])\\n\\n self.log_sig_sq_b = tf.get_variable(\\n name=\\\"log_sig_sq_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.z_dim])\\n \\n self.y_W = tf.get_variable(\\n name=\\\"y_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.z_dim, self.rnn_dim])\\n\\n self.y_b = tf.get_variable(\\n name=\\\"y_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim])\\n \\n self.softmax_W = tf.get_variable(\\n name=\\\"softmax_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim, self.vocabulary_size])\\n \\n self.softmax_b = tf.get_variable(\\n name=\\\"softmax_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.vocabulary_size])\",\n \"def init_weights(self, dims):\\n self.W = np.random.normal(size=dims) * 0.0001\",\n \"def _generate_weights(self):\\n weights = [random.uniform(0, 1) for x in range(self.num_weights)]\\n return self._normalize_weights(weights)\",\n \"def init_weights(num_tilings, tiles_per_dim, num_dims, num_actions):\\n weights = np.zeros((num_tilings*tiles_per_dim**num_dims*num_actions))\\n return weights\",\n \"def _generate_weights(self):\\n weights = []\\n for i in range(1, len(self.layers) - 1):\\n weights.append(2 * np.random.random(\\n (self.layers[i - 1] + 1, self.layers[i] + 1)) - 1)\\n weights.append(2 * np.random.random(\\n (self.layers[i] + 1, self.layers[i + 1])) - 1)\\n return weights\",\n \"def _create_weights(self):\\n gate_size = self._hidden_size * self._num_gates\\n # Compute the shape of weight and bias.\\n matrix_shapes, bias_shapes = [], []\\n for layer in range(self._num_layers):\\n for direction in range(self._num_directions):\\n layer_input_size = self._input_size if layer == 0 \\\\\\n else self._hidden_size * self._num_directions\\n w_ih_shape = [gate_size, layer_input_size]\\n w_hh_shape = [gate_size, self._hidden_size]\\n b_ih_shape, b_hh_shape = [gate_size], [gate_size]\\n matrix_shapes.extend([w_ih_shape, w_hh_shape])\\n bias_shapes.extend([b_ih_shape, b_hh_shape])\\n # Create single float32 weights.\\n weights_count = 0\\n self._weights_shapes = matrix_shapes + bias_shapes\\n for shape in self._weights_shapes:\\n weights_count += math_util.prod(shape)\\n self._weights = Tensor([weights_count])\\n self._weights.requires_grad = True\",\n \"def init_weights(self):\\n \\n self.w = np.random.randn(self.D) / np.sqrt(self.D)\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n mean = 0\\n std_dev = 0.0001\\n #print(in_features)\\n #print(out_features)\\n # create weight matrices\\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\\n #print(weight.shape)\\n grad_weight = np.zeros((in_features, out_features))\\n\\n # create biases (in batches)\\n bias = np.zeros(out_features)\\n grad_bias = np.zeros(out_features)\\n\\n self.params = {'weight': weight, 'bias': bias}\\n self.grads = {'weight': bias, 'bias': grad_bias}\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def get_weights(self):\",\n \"def _allocation_weights(self, write_gates, num_writes, usage):\\n write_gates = write_gates.unsqueeze(-1)\\n allocation_weights = []\\n for i in range(num_writes):\\n allocation = self._allocate(usage)\\n allocation_weights.append(allocation)\\n usage = usage + ((1-usage)*write_gates[:, i, :]*allocation_weights[i])\\n allocation_weights = torch.stack(allocation_weights, 1)\\n return allocation_weights\",\n \"def generateMatrix(self):\\n if self.tokenWeights and self.extraFeatures:\\n nFeatures = self.wordId + self.wordId2 + len(self.EXTRA_WEIGHTS_LABELS)\\n logging.info('Exporting TOKEN WEIGHTS AND EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n # iterate through 1st sentence\\n for wId, val in doc['s1'].iteritems():\\n mtrx[docId, wId] = val\\n # then iterate thru 2nd sentence, store on 2ND PARTITION\\n for wId, val in doc['s2'].iteritems():\\n mtrx[docId, self.wordId + wId] = val\\n # finally extra features values stored at the end of the vector\\n for label, val in doc['extraFeatures'].iteritems():\\n mtrx[docId, self.wordId + self.wordId2 + self.EXTRA_WEIGHTS_LABELS.index(label)] = val\\n\\n elif self.tokenWeights and not self.extraFeatures:\\n nFeatures = self.wordId + self.wordId2\\n logging.info('Exporting TOKEN WEIGHTS %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n # iterate through 1st sentence\\n for wId, val in doc['s1'].iteritems():\\n mtrx[docId, wId] = val\\n # then iterate thru 2nd sentence, store on 2ND PARTITION\\n for wId, val in doc['s2'].iteritems():\\n mtrx[docId, self.wordId + wId] = val\\n else:\\n nFeatures = len(self.EXTRA_WEIGHTS_LABELS)\\n logging.info('Exporting EXTRA FEATURES %dx%d'%(self.docId, nFeatures))\\n mtrx = np.zeros((self.docId, nFeatures))\\n \\n for docId, doc in self.documents.iteritems():\\n for label, val in doc['extraFeatures'].iteritems():\\n mtrx[docId, self.EXTRA_WEIGHTS_LABELS.index(label)] = val\\n logging.info('Matrix generated')\\n logging.info(mtrx.shape)\\n return mtrx\",\n \"def _generate_weighted_adj_matrices(self):\\n self.weighted_adj_matrices = dict()\\n mes = []\\n args = []\\n for metaedge in self.metaedges:\\n mes.append(metaedge)\\n args.append(self._prepare_parallel_weighted_adj_matrix_args(self.edge_df.query('abbrev == @metaedge')))\\n res = parallel_process(array=args, function=mt.get_adj_matrix, use_kwargs=True, n_jobs=self.n_jobs,\\n front_num=0)\\n for metaedge, matrix in zip(mes, res):\\n self.weighted_adj_matrices[metaedge] = matrix\",\n \"def instantiate_weights(self):\\n self.product_embeddings = tf.get_variable(\\n name='product_embeddings',\\n shape=[50000, 300],\\n dtype=tf.float32\\n )\\n self.aisle_embeddings = tf.get_variable(\\n name='aisle_embeddings',\\n shape=[250, 50],\\n dtype=tf.float32\\n )\\n self.department_embeddings = tf.get_variable(\\n name='department_embeddings',\\n shape=[50, 10],\\n dtype=tf.float32\\n )\\n self.W_relu = tf.get_variable(\\\"W_relu\\\",shape=[670, 30]) #这个参数后续需要自适应\\n self.b_relu = tf.get_variable(\\\"bias_relu\\\",shape=[30]) \\n self.W_projection = tf.get_variable(\\\"W_projection\\\",shape=[30, 1]) \\n self.b_projection = tf.get_variable(\\\"bias_projection\\\",shape=[1])\",\n \"def generate(self):\\n t_0 = time()\\n\\n if self.random_towers:\\n self.towers = np.random.rand(self.number_towers, 2)\\n else:\\n step = np.ceil(np.sqrt(self.number_towers)).astype('int')\\n\\n if step ** 2 != self.number_towers:\\n self.number_towers = step ** 2\\n print(f'WARNING: number of towers changed to {self.number_towers}')\\n\\n X, Y = np.mgrid[0:1:step * 1j, 0:1:step * 1j]\\n positions = np.vstack([X.ravel(), Y.ravel()])\\n self.towers = positions.swapaxes(1, 0)\\n\\n self.towers_manager = TowersManager(self.towers, self.vel_friction)\\n\\n self.distances = self.towers_manager.generate_distances()\\n self.print(f'Took {time() - t_0} to create distrances matrix')\\n\\n t = time()\\n self.probabilities = self.generate_probabilities()\\n self.print(f'Took {time() - t} to create probabilities matrix')\\n\\n t = time()\\n self.traces = self.generate_weighted_users_traces()\\n self.print(f'Took {time() - t} to create user traces')\\n\\n t = time()\\n self.aggregated_data = self.generate_aggregate_data()\\n self.print(f'Took {time() - t} to build aggregated data')\\n\\n self.print(f'Took {time() - t_0} to generate all')\",\n \"def create_matrix(self):\\n\\n self.matrix = np.zeros((len(self.users), len(self.items)))\\n\\n for user in self.train_set['users']:\\n for item in self.train_set['feedback'][user]:\\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\\\\n self.train_set['feedback'][user][item]\",\n \"def __init__(self, n4, L, k, randomize=False, non_k=-1, given_weight_matrix = None):\\n\\n self.n4 = n4\\n self.L = L\\n self.k = k\\n self.weightMatrix = numpy.full((self.n4, self.L), non_k, dtype=numpy.int16)\\n\\n # initializing from the start\\n if given_weight_matrix == None: \\n if randomize == \\\"True\\\":\\n #initialize weight matrix: for each stimulus, pick k neurons that respond randomly\\n for stim in range(self.L):\\n # randomly samples k neurons to respond (out of n4)\\n responds = random.sample(range(n4), k=self.k)\\n # updates the values of those k neurons' responses to stimulus \\n for nrn in responds: \\n self.weightMatrix[nrn][stim] = 1\\n else:\\n start_nrn = 0\\n # the first k neurons respond to first stimulus, and so on\\n for stim in range(self.L):\\n for nrn_offset in range(self.k):\\n self.weightMatrix[start_nrn + nrn_offset][stim] = 1\\n start_nrn += self.k\\n\\n # initializing from previous weight matrix, given as string or as prepared weight matrix\\n else: \\n if type(given_weight_matrix) is str:\\n l4_weight_list = [int(i) for i in given_weight_matrix.split(\\\",\\\")]\\n \\n if len(l4_weight_list) != (self.n4 * self.L):\\n print(\\\"Error! String provided to initialize L4 weight matrix must have length n4 * L.\\\")\\n sys.exit(1)\\n\\n for nrn in range(self.n4):\\n start = nrn * self.L \\n end = start + self.L\\n self.weightMatrix[nrn] = numpy.array(l4_weight_list[start:end])\\n else:\\n if given_weight_matrix.shape != (n4, L):\\n print(\\\"Error! Matrix provided to initialize L4 weight matrix must have shape (n4, L)\\\")\\n sys.exit(1)\\n self.weightMatrix = given_weight_matrix\",\n \"def __init__(self, n23, n4, mean, stdp_eta, given_weight_matrices = None):\\n self.n23 = n23\\n self.n4 = n4\\n self.eta = stdp_eta\\n\\n # initialize from scratch\\n if given_weight_matrices == None:\\n # create input weight matrix with weights chosen by Gaussian distribution\\n stdv = 1/math.sqrt(n4)\\n self.inputWeightMatrix = numpy.random.normal(mean, stdv, (n23, n4))\\n\\n # create recurrent weight matrix, set diagonal to zero\\n stdv = 1/math.sqrt(n23)\\n self.recurrentWeightMatrix = numpy.random.normal(mean, stdv, (n23, n23))\\n numpy.fill_diagonal(self.recurrentWeightMatrix, 0)\\n \\n # initialize from given weight matrices (should be a tuple with two elements)\\n else:\\n if len(given_weight_matrices) != 2:\\n print(\\\"Error: kwarg given_weight_matrices in initializion of L23 object must be a tuple of (inputWeighMatrix, recurrentWeightMatrix)\\\")\\n sys.exit(1)\\n\\n self.inputWeightMatrix = numpy.zeros((self.n23, self.n4))\\n self.recurrentWeightMatrix = numpy.zeros((self.n23, self.n23))\\n \\n # input weight matrix: \\n # given as string\\n if type(given_weight_matrices[0]) is str:\\n l23_weight_list = [float(i) for i in given_weight_matrices[0].split(\\\",\\\")]\\n if len(l23_weight_list) != (self.n23 * self.n4):\\n print(\\\"Error! String provided to initialize L23 input weight matrix must have length n23 * n4.\\\")\\n sys.exit(1)\\n\\n for nrn in range(self.n23):\\n start = nrn * self.n4 \\n end = start + self.n4\\n self.inputWeightMatrix[nrn] = numpy.array(l23_weight_list[start:end])\\n # given as complete matrix\\n else:\\n if given_weight_matrices[0].shape != (self.n23, self.n4):\\n print(\\\"Error! Matrix provided to initialize L23 input weight matrix must have shape (n23, n4)\\\")\\n sys.exit(1)\\n\\n self.inputWeightMatrix = given_weight_matrices[0]\\n\\n #recurrent weight matrix:\\n # given as string\\n if type(given_weight_matrices[1]) is str:\\n l23_weight_list = [float(i) for i in given_weight_matrices[1].split(\\\",\\\")]\\n if len(l23_weight_list) != (self.n23 * self.n23):\\n print(\\\"Error! String provided to initialize L23 recurrent weight matrix must have length n23 * n23. String has length %d.\\\" % len(l23_weight_list))\\n sys.exit(1)\\n for nrn in range(self.n23):\\n start = nrn * self.n23\\n end = start + self.n23\\n self.recurrentWeightMatrix[nrn] = numpy.array(l23_weight_list[start:end])\\n # given as complete matrix\\n else:\\n if given_weight_matrices[1].shape != (self.n23, self.n23):\\n print(\\\"Error! Matrix provided to initialize L23 recurrent weight matrix must have shape (n23, n23)\\\")\\n sys.exit(1) \\n\\n self.recurrentWeightMatrix = given_weight_matrices[1]\",\n \"def _initialize_weights(self, m):\\n self.w_ = np.zeros(1 + m)\\n self.w_initialized = True\",\n \"def _initialize_weights(self, m):\\n self.w_ = np.zeros(1 + m)\\n self.w_initialized = True\",\n \"def _initialize_weights(self, m):\\n self.w_ = np.zeros(1 + m)\\n self.w_initialized = True\",\n \"def reservoir_generator(\\n number_of_reservoirs=None, sparsity_level=None, reservoir_dim=None\\n):\\n reservoir_computing = ReservoirComputing(\\n reservoir_dim=reservoir_dim, sparsity_level=sparsity_level\\n )\\n\\n return [reservoir_computing.create_reservoir() for n in range(number_of_reservoirs)]\",\n \"def generate_weights(self, mag=1):\\n \\n if (len(self.hlayers) == 0):\\n print(\\\"No weights to generate! Please add hidden layers.\\\")\\n return\\n \\n weights = []\\n \\n insize = self.inputLayerSize\\n if (self.inputBias == True):\\n insize += 1\\n \\n layersize = self.hlayers[0].size\\n if (self.hlayers[0].bias == True):\\n layersize += 1\\n \\n weights.append(np.random.randn(insize, layersize)*mag)\\n \\n for i in range(0, len(self.hlayers)-1):\\n layer1size = self.hlayers[i].size\\n if (self.hlayers[i].bias == True):\\n layer1size+=1\\n \\n layer2size = self.hlayers[i+1].size\\n if (self.hlayers[i+1].bias == True):\\n layer2size+=1\\n \\n weights.append(np.random.randn(layer1size, layer2size))\\n \\n \\n self.weights = weights\",\n \"def __initialize_weights__(num_neurons: int) -> np.ndarray:\\n\\n weights = np.zeros((num_neurons, num_neurons))\\n\\n return weights\",\n \"def initializeWeights(n_hidden_units, n_inputs, n_outputs):\\n W1 = np.random.randn(n_hidden_units, n_inputs) * np.sqrt(1/(n_inputs*n_hidden_units))\\n W2 = np.random.randn(n_outputs, n_hidden_units) * np.sqrt(1/(n_hidden_units*n_outputs))\\n b1 = np.random.randn(n_hidden_units, 1) * np.sqrt(1/n_hidden_units)\\n b2 = np.random.randn(n_outputs, 1) * np.sqrt(1/n_outputs)\\n return W1, b1, W2, b2\",\n \"def _initialize_weights(self):\\n stddev = 1.0 / math.sqrt(self._hidden_size)\\n for layer_id, param_id in itertools.product(\\n range(self._num_layers * (self._bidirectional + 1)),\\n range(self._num_gates * 2)):\\n i = layer_id * 2 + (param_id // self._num_gates)\\n j = i + len(self._weights_shapes) // 2\\n matrix_shape = self._weights_shapes[i][:]\\n bias_shape = self._weights_shapes[j][:]\\n matrix_shape[0] //= self._num_gates\\n bias_shape[0] //= self._num_gates\\n self._set_parameter(\\n init_ops.random_uniform(matrix_shape, -stddev, stddev),\\n layer_id, param_id, 'matrix')\\n self._set_parameter(\\n init_ops.random_uniform(bias_shape, -stddev, stddev),\\n layer_id, param_id, 'bias')\",\n \"def weights_initializer(self):\\n self.weights = [np.random.normal(0, 1 / np.sqrt(x), (x, y)) for x, y in list(zip(self.structure[1:], self.structure[:-1]))]\",\n \"def __init__(self, sizes):\\n self.sizes = sizes\\n self.biases = [random_matrix(1, y)[0] for y in sizes[1:]]\\n self.weights = [random_matrix(y, x)\\n for x, y in zip(sizes[:-1], sizes[1:])]\\n\\n self.weighted_layer = []\\n self.activations = []\",\n \"def initialize_weights(self):\\n w1 = np.random.uniform(-1.0, 1.0, size = self.n_hidden * (self.n_features + 1)).reshape(self.n_hidden, (self.n_features + 1))/(self.n_features + 1)\\n w2 = np.random.uniform(-1.0, 1.0, size=self.n_output*(self.n_hidden+1)).reshape(self.n_output, self.n_hidden+ 1)/(self.n_hidden + 1)\\n return w1, w2\",\n \"def _initialize_weights(self):\\n pass\",\n \"def build(self):\\n\\n self.W = self.init([self.n_atom_input_feat, self.n_output])\\n self.b = model_ops.zeros(shape=[\\n self.n_output,\\n ])\\n\\n self.trainable_weights = self.W + self.b\",\n \"def _initialize_matrix(self):\\n\\n try:\\n # Grab the weight matrix from weight_matrices.py\\n tmp_weight_matrix = copy.copy(weight_matrices.__dict__[self._weight_matrix_name])\\n except KeyError:\\n\\n # Treat this name as a file\\n data = open(self._weight_matrix_name).readlines()\\n\\n # Grab alphabet bits from top line\\n seq = data[0].strip('/n/r').split()\\n tmp_weight_matrix = dict([(s,dict([(s,0) for s in seq])) for s in seq])\\n \\n # Go through each line, populating weight matrix. \\n for line in data[1:]:\\n line = line.strip('/n/r').split()\\n\\n a = line[0]\\n for j in range(1, len(line)):\\n b = seq[j-1]\\n tmp_weight_matrix[a][b] = float(line[j])\\n\\n # Convert tmp_weight_matrix into a numpy array, normalized between 0 \\n # and 1.\\n keys = list(tmp_weight_matrix.keys())\\n self.weight_matrix = np.zeros((len(keys),len(keys)),dtype=float)\\n for i, k1 in enumerate(keys):\\n a = self._alphabet_dict[k1]\\n for j, k2 in enumerate(keys):\\n b = self._alphabet_dict[k2]\\n self.weight_matrix[a,b] = tmp_weight_matrix[k1][k2]\\n\\n # Set weights to range from 0 (close) to 1 (far)\\n mini = np.min(self.weight_matrix)\\n maxi = np.max(self.weight_matrix)\\n self.weight_matrix = 1 - (self.weight_matrix - mini)/(maxi - mini)\",\n \"def initialize_weights_xavier(self):\\n\\t\\tself.weights = [np.random.uniform(-1/sqrt(size1), 1/sqrt(size1)) for size1, size2 in zip(self.sizes[:-1], self.sizes[1:])]\\n\\t\\tself.biases = [np.zeros([size, ]) for size in self.sizes[1:]]\",\n \"def generate():\",\n \"def get_random_inhibitory_weights(self):\\n \\n self.W_ei=np.zeros((self.N_e,self.N_i))\\n self.W_ie=np.zeros((self.N_i,self.N_e)) \\n self. W_ii=np.zeros((self.N_i,self.N_i))\\n\\n \\n # connections to the excitatory neurons \\n for row_idx in xrange(self.N_e):\\n \\n # from ihibitory\\n all_idxs_ei=np.arange(self.N_i)\\n np.random.shuffle(all_idxs_ei)\\n self.W_ei[row_idx,all_idxs_ei[0:self.num_conns_ei]]=self.W_max_ei \\n \\n # connections to inhibitory neurons\\n for row_idx in range(self.N_i):\\n \\n # from exitatory \\n all_idxs_ie=np.arange(self.N_e)\\n np.random.shuffle(all_idxs_ie)\\n self.W_ie[row_idx,all_idxs_ie[0:self.num_conns_ie]]=self.W_max_ie\\n \\n # from inhibitory\\n all_idxs_ii=np.arange(self.N_i)\\n np.random.shuffle(all_idxs_ii)\\n self.W_ii[row_idx,all_idxs_ii[0:self.num_conns_ii]]=self.W_max_ii\\n \\n \\n self.W[:self.N_e,self.N_e:]=self.W_ei\\n self.W[self.N_e:,:self.N_e]=self.W_ie\\n self.W[self.N_e:,self.N_e:]=self.W_ii\",\n \"def initialize_weights(self):\\n # compute lmda.\\n self.lmda = float(self.c)/float(self.N)\\n # bias term. This should not get a regularization penalty.\\n self.bias = {}\\n # weight vector\\n self.w = {}\\n # lastW[j] = k, indicates that feature j was last updated at time k.\\n self.lastW = {}\\n for lbl in self.labels:\\n self.bias[lbl] = 0\\n self.w[lbl] = {}\\n self.lastW[lbl] = {}\\n pass\",\n \"def initializeWeights(n_in,n_out):\\r\\n \\r\\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\r\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\r\\n return W\",\n \"def initializeWeights(n_in,n_out):\\r\\n \\r\\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\r\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\r\\n return W\",\n \"def initializeWeights(n_in,n_out):\\n \\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\n return W\",\n \"def _make_random_matrix(self, n_components, n_features):\",\n \"def init_weight(w):\\n shape = w.shape\\n if len(shape) == 4:\\n i, o, u, v = shape\\n k = np.sqrt(6 / (i * u * v + o * u * v))\\n w.data.uniform_(-k, k)\\n elif len(shape) == 2:\\n k = np.sqrt(6 / sum(shape))\\n w.data.uniform_(-k, k)\\n elif len(shape) == 1:\\n w.data.zero_()\",\n \"def init_weights_(self):\\n raise NotImplementedError\",\n \"def initialize_weights_and_bias(self, X_train):\\n n_samples, n_features = np.shape(X_train)\\n n_output = 1 \\n \\n # This is the numeber of gridcells and we want to make one prediction pr cell. \\n # It this doesn't work calculate the number of griddcells.\\n\\n self.b_h = [] #np.ones((self.n_hidden_layers, self.n_hidden[0]))\\n self.W_h = []\\n\\n for i in range(len(self.n_hidden)):\\n if (i == 0):\\n self.W_h.append(self.random.normal(loc=0.0, scale=0.1, size=(n_features, self.n_hidden[0])))\\n self.b_h.append(np.ones(self.n_hidden[0]))\\n else:\\n self.W_h.append(self.random.normal(loc=0.0, scale=0.1, size=(self.n_hidden[i-1], self.n_hidden[i])))\\n self.b_h.append(np.ones(self.n_hidden[i])) \\n \\n self.b_out = [1]\\n self.W_out = self.random.normal(loc=0.0, scale=0.1, size=(self.n_hidden[-1], n_output))\",\n \"def generate_weighted_graph():\\n \\n Adj_Matrix = np.array([\\n [0.0, 0.2, 0.2, 0.3, 0.2, 0.1],\\n [0.1, 0.0, 0.3, 0.3, 0.1, 0.2],\\n [0.3, 0.2, 0.0, 0.1, 0.2, 0.2],\\n [0.1, 0.4, 0.2, 0.0, 0.2, 0.1],\\n [0.2, 0.2, 0.2, 0.2, 0.0, 0.2],\\n [0.2, 0.1, 0.1, 0.3, 0.3, 0.0]\\n ])\\n\\n return Adj_Matrix\",\n \"def gen_tb_tb_weights(weight=1.):\\r\\n W = np.zeros([8, 8])\\r\\n sinusoid = -(np.cos(np.linspace(0, 2 * np.pi, 8, endpoint=False)) - 1) / 2\\r\\n for i in range(8):\\r\\n values = np.roll(sinusoid, i)\\r\\n W[i, :] = values\\r\\n return weight * W\",\n \"def initializeWeights(n_in,n_out):\\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\n return W\",\n \"def initializeWeights(n_in,n_out):\\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\n return W\",\n \"def initializeWeights(n_in,n_out):\\n epsilon = sqrt(6) / sqrt(n_in + n_out + 1);\\n W = (np.random.rand(n_out, n_in + 1)*2* epsilon) - epsilon;\\n return W\",\n \"def constructCell():\\n\\t\\tself.weightGenerate()\",\n \"def start_weights(self, inv=True):\\n return np.eye(self.nmoms)\",\n \"def train(self):\\n\\n for i in range(self.c):\\n mu_i = self.estimate_mu(i).T\\n cov_i = self.estimate_sigma(i, mu_i)\\n inv_sigma_i = np.linalg.inv(cov_i)\\n P_i = self.estimate_P(i)\\n Wi = -1 / 2 * inv_sigma_i\\n wi = inv_sigma_i @ mu_i\\n wi0 = -1 / 2 * mu_i.T @ inv_sigma_i @ mu_i - 1 / 2 * np.log(np.linalg.det(cov_i)) + np.log(P_i)\\n self.weights.append([Wi, wi, wi0])\\n return self.weights\",\n \"def build_layer(self) :\\n inputsWithBias = self.input_count + 1\\n self.weights = np.random.rand(inputsWithBias, self.node_count)\\n self.weights_and_activations = (self.weights, self.activations)\",\n \"def build_weights_matrix(vectors, custom_vectors, index2word, size = 200):\\n weights_matrix = np.zeros((len(index2word), size))\\n words_found = 0\\n words_found_custom = 0\\n\\n for i, word in index2word.items():\\n try: \\n weights_matrix[i] = vectors[index2word[i]]\\n words_found += 1\\n except KeyError:\\n try:\\n weights_matrix[i] = custom_vectors[index2word[i]]\\n words_found_custom +=1\\n except KeyError:\\n weights_matrix[i] = np.random.rand(size)\\n\\n #initialize pad embedding to zero\\n weights_matrix[0, ] = np.zeros(size)\\n\\n print ('words_found: ' + str(words_found/len(index2word)) + \\\\\\n ' additional_words_found: ' + str(words_found_custom/len(index2word)))\\n\\n return weights_matrix\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n\\n self.params = {'weight': 0.0001 * np.random.randn(out_features, in_features), 'bias': np.zeros((out_features, 1))}\\n self.grads = {'weight': np.zeros((out_features, in_features)), 'bias': np.zeros((out_features, 1))}\\n\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def init_weights(model):\\n ...\",\n \"def WeightInitializer():\\n return np.random.uniform(-1, 1)\",\n \"def _buildWeights(self):\\r\\n # Compute the spatial tree\\r\\n kd = spatial.cKDTree(self.XYin)\\r\\n \\r\\n # Perform query on all of the points in the grid\\r\\n dist,self.ind=kd.query(self.XYout,distance_upper_bound=self.maxdist,k=self.NNear)\\r\\n \\r\\n self.Nc = np.size(self.ind,axis=0)\\r\\n print '%d interpolation points.'%self.Nc\\r\\n # Now loop through and get the weights for each point\\r\\n self.W = np.zeros((self.NNear,self.Nc))\\r\\n\\r\\n # Print percentages\\r\\n p0=0\\r\\n pstep=5\\r\\n for ii in range(0,self.Nc):\\r\\n \\r\\n if self.verbose:\\r\\n pfinish = float(ii)/float(self.Nc)*100.0\\r\\n if pfinish> p0:\\r\\n print '%3.1f %% complete...'%pfinish\\r\\n p0+=pstep\\r\\n \\r\\n W = self.getWeights(dist[ii,:],self.XYin[self.ind[ii,:],0],self.XYin[self.ind[ii,:],1])\\r\\n self.W[:,ii] = W.T\",\n \"def get_weights_and_biases_from_Onnx(self):\\n\\t\\t\\n\\t\\tpass\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n self.params = {'weight': np.random.normal(loc = 0, scale=0.0001, size=(out_features,in_features)),\\\\\\n 'bias': np.zeros((1, out_features))}\\n \\n self.grads = {'weight': np.zeros((out_features,in_features)),\\\\\\n 'bias': np.zeros((1, out_features))}\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def _init_weights(n_rows, n_cols, std_dev=0.5):\\n weights = np.random.randn(n_rows, n_cols) * std_dev\\n return weights\",\n \"def __init__(self, structure):\\n # weight matrices\\n self.ws = [np.random.randn(m, n) for n, m in zip([0] + structure, structure)]\\n # biases\\n self.bs = [np.random.rand(n, 1) for n in structure]\\n # activations\\n self.ys = [np.zeros((n, 1)) for n in structure]\\n # z values\\n self.zs = [np.zeros((n, 1)) for n in structure]\",\n \"def sparse_initialization_weights(self):\\n W = []\\n mu, sigma = 0, 1/self.non_zero_units\\n\\n for i in xrange(self.n_in):\\n row = np.zeros(self.n_out)\\n non_zeros = self.rng.normal(mu, sigma, self.non_zero_units)\\n # non_zeros /= non_zeros.sum()\\n non_zero_idxs = self.rng.permutation(\\n self.n_out)[0:self.non_zero_units]\\n for j in xrange(self.non_zero_units):\\n row[non_zero_idxs[j]] = non_zeros[j]\\n W.append(row)\\n W = np.asarray(W, dtype=theano.config.floatX)\\n return W\",\n \"def generate_weights(n_features, hidden_layer_sizes, n_out):\\n\\n weights = []\\n biases = []\\n\\n # Weights from input layer to first hidden layer\\n weights.append(init_weight(hidden_layer_sizes[0], n_features))\\n biases.append(init_bias(hidden_layer_sizes[0]))\\n\\n # Weights from one hidden layer to the next\\n for i in range(1, hidden_layer_sizes.size):\\n weights.append(\\n init_weight(hidden_layer_sizes[i],hidden_layer_sizes[i - 1]))\\n biases.append(init_bias(hidden_layer_sizes[i]))\\n\\n # Weights from last hidden layer to output layer\\n weights.append(init_weight(n_out, hidden_layer_sizes[-1]))\\n biases.append(init_bias(n_out))\\n\\n return weights, biases\",\n \"def build(self,input_shape):\\n\\n self.w = self.add_weight(shape=(input_shape[-1],self.units),\\n initializer='random_normal',\\n trainable=True)\\n self.b = self.add_weight(shape=(self.units,),\\n initializer='random_normal',\\n trainable=True)\",\n \"def form_matrix_yt(w):\\r\\n M = np.zeros((len(w),len(w)))\\r\\n for i in range(len(w)):\\r\\n for j in range(len(w)):\\r\\n M[i,j] = YoungTableaux(w[i],w[j]).CMNR()\\r\\n return M\",\n \"def get_weights(self):\\n return []\",\n \"def weights(self):\\r\\n\\t\\treturn None\",\n \"def get_weight_matrix(self):\\n\\n\\t\\treturn self.weights.get_value(borrow=True)\",\n \"def create_population(self):\\r\\n\\r\\n model_weights_vector = model_weights_as_vector(model=self.model)\\r\\n\\r\\n net_population_weights = []\\r\\n net_population_weights.append(model_weights_vector)\\r\\n\\r\\n for idx in range(self.num_solutions-1):\\r\\n\\r\\n net_weights = copy.deepcopy(model_weights_vector)\\r\\n net_weights = numpy.array(net_weights) + numpy.random.uniform(low=-1.0, high=1.0, size=model_weights_vector.size)\\r\\n\\r\\n # Appending the weights to the population.\\r\\n net_population_weights.append(net_weights)\\r\\n\\r\\n return net_population_weights\",\n \"def random_weights_init(self, data):\\n self._check_input_len(data)\\n it = nditer(self._activation_map, flags=['multi_index'])\\n while not it.finished:\\n rand_i = self._random_generator.randint(len(data))\\n self._weights[it.multi_index] = data[rand_i]\\n it.iternext()\",\n \"def init_weights(no_input, no_hidden, no_output):\\r\\n weight_lst = []\\r\\n no_of_weights = (no_input * no_hidden) + (no_hidden * no_output)\\r\\n\\r\\n for weight in range(no_of_weights):\\r\\n weight = 0.01 * random.random()\\r\\n weight_lst.append(weight)\\r\\n\\r\\n return weight_lst\",\n \"def weighted_matrix(point: np.mat, training_data_x: np.mat, bandwidth: float) -> np.mat:\\r\\n # m is the number of training samples\\r\\n m, n = np.shape(training_data_x)\\r\\n # Initializing weights as identity matrix\\r\\n weights = np.mat(np.eye((m)))\\r\\n # calculating weights for all training examples [x(i)'s]\\r\\n for j in range(m):\\r\\n diff = point - training_data[j]\\r\\n weights[j, j] = np.exp(diff * diff.T / (-2.0 * bandwidth ** 2))\\r\\n return weights\",\n \"def weights(self):\\n \\n n = self.n\\n lambda_ = self.alpha**2 * (n +self.kappa) - n\\n \\n c = .5 / (n + lambda_)\\n Wc = np.full(2*n + 1, c)\\n Wm = np.full(2*n + 1, c)\\n Wc[0] = lambda_ / (n + lambda_) + (1 - self.alpha**2 + self.beta)\\n Wm[0] = lambda_ / (n + lambda_)\\n \\n return Wm, Wc\",\n \"def _initialize_weights(self, m):\\n self.rgen = np.random.RandomState(self.random_state)\\n self.w_ = self.rgen.normal(loc=0.0, scale=0.01, size=m)\\n self.b_ = 0\\n self.w_avg = self.rgen.normal(loc=0.0, scale=0.01, size=m)\\n self.b_avg = 0\\n\\n def net_input(self, X):\\n return np.dot(X, self.w_[1:]) + self.w_[0]\\n\\n def activation(self, X):\\n return X\\n \\n def predict(self, X):\\n return np.where(self.net_input(X) >= 0.0, 1, -1)\\n \\n def get_params(self, deep=True):\\n return {\\\"eta\\\":self.eta, \\\"max_iter\\\":self.max_iter, \\\"C\\\":self.C, \\\"random_state\\\":self.random_state, \\\"batch_size\\\":self.batch_size}\\n \\n def set_params(self, **parameters):\\n for parameter, value in parameters.items():\\n setattr(self, parameters, value)\\n return self\",\n \"def _initializeMatrices(self):\\n K = self.K \\n # Initialize Initia\\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\\n rand_initial_prob = list(rand_initial_prob[0,:])\\n for i in range(K): \\n self.state_initial_prob[i+1] = rand_initial_prob[i]\\n\\n # Initialize the transition MAtrix !\\n for i in range(K):\\n rand_initial_prob = np.random.dirichlet(np.ones(K),size=1)\\n rand_initial_prob = list(rand_initial_prob[0,:]) \\n\\n for j in range(K):\\n self.state_transition_mat[(j+1,i+1)] = rand_initial_prob[j]\\n\\n\\n # Initialize the symbol distribution Parameters ui and si (Assuming a numeric outputs ! Modelled using a gaussian ! withmean ui and std si)\\n init_mean = np.mean(self.data_matrix)\\n init_std = np.std(self.data_matrix) \\n \\n for i in range(K):\\n random_mean = gauss(init_mean,30)\\n random_std = gauss(init_std,30)\\n self.state_symbol_prob[i+1] = {'mean':random_mean, 'std' : random_std}\",\n \"def generate(self):\",\n \"def generate_design_matrix(bs, v):\\n #design matrix has 1 in all first rows (to detect image b=0 SIGNAL)\\n x = np.ones((bs.shape[0], 7))\\n for i, b in enumerate(bs):\\n if b == 0:\\n x[i, 1:] = 0\\n else:\\n x[i, 1] = -b*v[0, i]**2\\n x[i, 2] = -b*2*v[0, i]*v[1, i]\\n x[i, 3] = -b*2*v[0, i]*v[2, i]\\n x[i, 4] = -b*v[1, i]**2\\n x[i, 5] = -b*2*v[1, i]*v[2, i]\\n x[i, 6] = -b*v[2, i]**2\\n return x\",\n \"def NewWires(self, *args):\\n return _BRepAlgo.BRepAlgo_Loop_NewWires(self, *args)\",\n \"def large_weight_initializer(self):\\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\\n self.weights = [np.random.randn(y, x)\\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]\",\n \"def default_weight_initializer(self):\\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\\n self.weights = [np.random.randn(y, x)/np.sqrt(x)\\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]\",\n \"def instantiate_weights(self):\\n with tf.variable_scope(\\\"embedding_projection\\\"), tf.device('/cpu:0'): # embedding matrix\\n self.Embedding = tf.get_variable(\\\"Embedding\\\", shape=[self.vocab_size, self.embed_size],\\n initializer=self.initializer)\\n # self.Embedding_label = tf.get_variable(\\\"Embedding_label\\\", shape=[self.num_classes, self.embed_size],\\n # dtype=tf.float32) # ,initializer=self.initializer\\n # self.W_projection = tf.get_variable(\\\"W_projection\\\", shape=[self.sequence_length * self.d_model, self.num_classes],\\n # initializer=self.initializer) # [embed_size,label_size]\\n # self.b_projection = tf.get_variable(\\\"b_projection\\\", shape=[self.num_classes])\",\n \"def weber_MS(I,J,x,y,w):\\n M = max([((x[i]-x[j])**2 + (y[i]-y[j])**2) for i in I for j in I])\\n model = Model(\\\"weber - multiple source\\\")\\n X,Y,v,u = {},{},{},{}\\n xaux,yaux,uaux = {},{},{}\\n for j in J:\\n X[j] = model.addVar(lb=-model.infinity(), vtype=\\\"C\\\", name=\\\"X(%s)\\\"%j)\\n Y[j] = model.addVar(lb=-model.infinity(), vtype=\\\"C\\\", name=\\\"Y(%s)\\\"%j)\\n for i in I:\\n v[i,j] = model.addVar(vtype=\\\"C\\\", name=\\\"v(%s,%s)\\\"%(i,j))\\n u[i,j] = model.addVar(vtype=\\\"B\\\", name=\\\"u(%s,%s)\\\"%(i,j))\\n xaux[i,j] = model.addVar(lb=-model.infinity(), vtype=\\\"C\\\", name=\\\"xaux(%s,%s)\\\"%(i,j))\\n yaux[i,j] = model.addVar(lb=-model.infinity(), vtype=\\\"C\\\", name=\\\"yaux(%s,%s)\\\"%(i,j))\\n uaux[i,j] = model.addVar(vtype=\\\"C\\\", name=\\\"uaux(%s,%s)\\\"%(i,j))\\n\\n\\n\\n for i in I:\\n model.addCons(quicksum(u[i,j] for j in J) == 1, \\\"Assign(%s)\\\"%i)\\n for j in J:\\n model.addCons(xaux[i,j]*xaux[i,j] + yaux[i,j]*yaux[i,j] <= v[i,j]*v[i,j], \\\"MinDist(%s,%s)\\\"%(i,j))\\n model.addCons(xaux[i,j] == (x[i]-X[j]), \\\"xAux(%s,%s)\\\"%(i,j))\\n model.addCons(yaux[i,j] == (y[i]-Y[j]), \\\"yAux(%s,%s)\\\"%(i,j))\\n model.addCons(uaux[i,j] >= v[i,j] - M*(1-u[i,j]), \\\"uAux(%s,%s)\\\"%(i,j))\\n\\n model.setObjective(quicksum(w[i]*uaux[i,j] for i in I for j in J), \\\"minimize\\\")\\n\\n\\n model.data = X,Y,v,u\\n return model\",\n \"def _setup(self) -> None:\\n #TODO: type\\n self.activation = self.params['activation']\\n\\n self.batchsize: int = self.params['batchsize']\\n\\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\\n\\n self.d: int = self.input_shape[1]\\n assert(not self.d == 0)\\n\\n self.n: int = int(sqrt(self.input_shape[2]))\\n assert(not self.n == 0)\\n\\n self.dtype: type = self.params['dtype']\\n\\n # initialize weights\\n self.W: List[tf.Tensor] = []\\n \\n for i in range(3):\\n #TODO: type\\n w_init = self.params['initializer_w']\\n if self.params['initializer_w' + str(i)] is not None:\\n w_init = self.params['initializer_w' + str(i)]\\n\\n w_stddev: float = self.params['stddev_w']\\n if self.params['stddev_w' + str(i)] is not None:\\n w_stddev = self.params['stddev_w' + str(i)]\\n\\n self.W.append(tf.get_variable(\\\"weights_\\\" + str(i),\\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\\n dtype = self.dtype,\\n initializer = w_init(stddev=w_stddev)))\\n\\n #TODO: type\\n b_init = self.params['initializer_b']\\n b_stddev = self.params['stddev_b']\\n self.B: tf.Tensor = tf.get_variable(\\\"biases\\\", shape = (1, self.d, 1),\\n dtype = self.dtype,\\n initializer = b_init(stddev=b_stddev))\\n\\n # create/load expand matrix\\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\\n self.expand: tf.Tensor = tf.get_variable(\\n \\\"expand\\\" + str(self.n),\\n shape = (self.n, self.n * self.n),\\n dtype = self.dtype,\\n initializer = tf.constant_initializer(make_expand(self.n)))\\n\\n # create/load tile matrix\\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\\n for i in range(1, self.n):\\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\\n\\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)\",\n \"def init_matrix(self, train, num_features):\\n user_matrix = np.random.rand(self.num_users, num_features)\\n item_matrix = np.random.rand(num_features, self.num_items)\\n item_nnz = train.getnnz(axis=0)\\n item_sum = train.sum(axis=0)\\n item_matrix[0, :] = item_sum / item_nnz\\n return user_matrix, item_matrix\",\n \"def __create_W_matrix(self, n, conv_weight):\\n\\n # The first two dimensions of the weight are the output and input depth, respectively\\n # The third and fourth dimension are equal to the size of the filter -\\n # we assume that all filters are square\\n output_depth, input_depth, k, _ = conv_weight.shape\\n\\n # There are i * j blocks in the output matrix W - each block corresponds to\\n # a block matrix V_ij\\n num_rows_per_block = (n - k + 1) ** 2\\n\\n # initialize W to be an array of all zeros\\n W = np.zeros((output_depth * num_rows_per_block, input_depth * n ** 2))\\n # W = np.zeros((6 * num_rows_per_block, 3 * n ** 2))\\n\\n # i indexes the output feature map stack\\n for i in range(output_depth):\\n\\n # j indexes the input feature map stack (i.e. number of channels in input image)\\n for j in range(input_depth):\\n\\n # Get the filter that convolves the i^th output feature map with the\\n # j^th input feature map (i.e. channel for the first layer)\\n filter = conv_weight[i, j, :, :]\\n\\n # Each V_ij is a block circulant (topelitz) matrix - that is, each\\n # block of V_ij is a circulant matrix, meaning that each entry appears\\n # in each row and column exactly once. V_ij will have dimensions\\n # (num_rows_per_block ** 2, n ** 2)\\n V_ij = self.__filter_to_bc_matrix(filter, n)\\n\\n # Broadcast V_ij into the i^th block row and the j^th block column of W\\n dim0, dim1 = num_rows_per_block, n ** 2\\n W[i * dim0 : (i + 1) * dim0, j * dim1 : (j + 1) * dim1] = V_ij\\n\\n return W\",\n \"def initialize_weights(self, seed=None):\\r\\n if seed!=None:\\r\\n np.random.seed(seed)\\r\\n self.weights = np.random.randn(self.number_of_nodes,self.input_dimensions)\",\n \"def _generate_raw_environments(self, num, seed):\",\n \"def generate(nextLayerUnits, FirstLayerUnits):\\n array = mat.arange(start=1, stop=(nextLayerUnits * (FirstLayerUnits + 1)) + 1, step=1)\\n debugWeights = mat.divide(mat.reshape(mat.sin(array), (nextLayerUnits, (FirstLayerUnits + 1))), 10)\\n\\n return debugWeights\",\n \"def saveWeights(self, basename, generation):\\n for i,wt in enumerate(self.weights):\\n np.save(\\\"./data/\\\"+basename+\\\"/\\\"+basename + \\\"_W\\\"+str(i)+\\\"_G\\\" + str(generation),wt)\\n for i,bs in enumerate(self.bias):\\n np.save(\\\"./data/\\\"+basename+\\\"/\\\"+basename + \\\"_B\\\"+str(i)+\\\"_G\\\" + str(generation),bs)\",\n \"def demand_matrices(self) -> list:\\n for sample in range(self.__n_samples):\\n try:\\n yield self.demand_matrix(sample)\\n except:\\n continue\",\n \"def create_training_matrices(experiment, sample_times):\\n # Labels:\\n location_labels = read_location_labels(experiment)\\n locations = get_location_of_persons_at_samples(location_labels, sample_times, experiment)\\n\\n p1_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P1\\\")\\n p2_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P2\\\")\\n p3_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P3\\\")\\n p4_scene_features = read_roi_scene_recognitions_for_person(experiment, \\\"P4\\\")\\n\\n print(p1_scene_features.loc[0]['predictions'].shape[0])\\n print(len(p1_scene_features['predictions'][0]))\\n data = {\\n \\\"P1\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P2\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P3\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0])),\\n \\\"P4\\\": np.zeros((len(sample_times), 2 + p1_scene_features.loc[0]['predictions'].shape[0]))\\n }\\n\\n for index, loc_label in enumerate(locations):\\n t = loc_label[0]\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P1_eyetracker\\\")\\n p1 = np.mean(p1_scene_features[p1_scene_features['timestamp'].between(t_et - sample_step/2, t_et + sample_step/2)]['predictions'].as_matrix(), axis=0)\\n\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P2_eyetracker\\\")\\n p2 = np.mean(\\n p2_scene_features[p2_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P3_eyetracker\\\")\\n p3 = np.mean(\\n p3_scene_features[p3_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n t_et = convert_timestamps(exp_root, t, \\\"video\\\", \\\"P4_eyetracker\\\")\\n p4 = np.mean(\\n p4_scene_features[p4_scene_features['timestamp'].between(t_et - sample_step / 2, t_et + sample_step / 2)][\\n 'predictions'].as_matrix(), axis=0)\\n\\n data[\\\"P1\\\"][index, 0] = t\\n data[\\\"P1\\\"][index, 1:-1] = p1\\n data[\\\"P1\\\"][index, -1] = loc_label[1]\\n\\n data[\\\"P2\\\"][index, 0] = t\\n data[\\\"P2\\\"][index, 1:-1] = p2\\n data[\\\"P2\\\"][index, -1] = loc_label[2]\\n\\n data[\\\"P3\\\"][index, 0] = t\\n data[\\\"P3\\\"][index, 1:-1] = p3\\n data[\\\"P3\\\"][index, -1] = loc_label[3]\\n\\n data[\\\"P4\\\"][index, 0] = t\\n data[\\\"P4\\\"][index, 1:-1] = p4\\n data[\\\"P4\\\"][index, -1] = loc_label[4]\\n\\n return data\",\n \"def init_variables():\\n weights = np.random.normal(size=2)\\n bias = 0\\n return weights, bias\",\n \"def _make_sample_weights(n_repetitions, n_samples, random_state):\\n sample_weights = np.zeros((n_repetitions, n_samples), dtype=np.float64)\\n\\n for repetition in range(n_repetitions):\\n sample_weights[repetition] = random_state.rand(n_samples) + 1\\n\\n return sample_weights\",\n \"def init_weights(self, num_features):\\n for each_label in self.valid_labels:\\n self.weights[each_label] = np.zeros(num_features)\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.72100776","0.7078924","0.69424677","0.6844303","0.66958326","0.6464861","0.6418851","0.64160824","0.63530934","0.6338389","0.62734073","0.6259906","0.6180129","0.61764675","0.6155642","0.61368394","0.61362815","0.6122882","0.60942763","0.60886437","0.60460615","0.6043329","0.6041521","0.60375905","0.6036824","0.60180736","0.60180736","0.60180736","0.60174656","0.6017308","0.6016619","0.5981341","0.5978943","0.59726816","0.5967081","0.59481615","0.5940659","0.59402406","0.59074396","0.5889611","0.58778876","0.5853391","0.5844353","0.58396024","0.58396024","0.58389175","0.58301336","0.5827013","0.58125347","0.5811504","0.58086056","0.58040154","0.5803416","0.5803416","0.5803416","0.57693595","0.5760595","0.57604486","0.5750337","0.5747492","0.5744894","0.5744689","0.57424146","0.57392055","0.5715759","0.57126087","0.5705972","0.5694906","0.56933904","0.5686967","0.5678696","0.567235","0.5657054","0.56482774","0.5641116","0.5637122","0.5631629","0.56251436","0.5621382","0.5618931","0.5615693","0.5612733","0.5612255","0.56115496","0.56107473","0.56033415","0.56028765","0.559842","0.5597451","0.55954725","0.55858624","0.5584283","0.5582236","0.5573958","0.55713636","0.5571199","0.5570829","0.55686677","0.5565391","0.55591744","0.55587953"],"string":"[\n \"0.72100776\",\n \"0.7078924\",\n \"0.69424677\",\n \"0.6844303\",\n \"0.66958326\",\n \"0.6464861\",\n \"0.6418851\",\n \"0.64160824\",\n \"0.63530934\",\n \"0.6338389\",\n \"0.62734073\",\n \"0.6259906\",\n \"0.6180129\",\n \"0.61764675\",\n \"0.6155642\",\n \"0.61368394\",\n \"0.61362815\",\n \"0.6122882\",\n \"0.60942763\",\n \"0.60886437\",\n \"0.60460615\",\n \"0.6043329\",\n \"0.6041521\",\n \"0.60375905\",\n \"0.6036824\",\n \"0.60180736\",\n \"0.60180736\",\n \"0.60180736\",\n \"0.60174656\",\n \"0.6017308\",\n \"0.6016619\",\n \"0.5981341\",\n \"0.5978943\",\n \"0.59726816\",\n \"0.5967081\",\n \"0.59481615\",\n \"0.5940659\",\n \"0.59402406\",\n \"0.59074396\",\n \"0.5889611\",\n \"0.58778876\",\n \"0.5853391\",\n \"0.5844353\",\n \"0.58396024\",\n \"0.58396024\",\n \"0.58389175\",\n \"0.58301336\",\n \"0.5827013\",\n \"0.58125347\",\n \"0.5811504\",\n \"0.58086056\",\n \"0.58040154\",\n \"0.5803416\",\n \"0.5803416\",\n \"0.5803416\",\n \"0.57693595\",\n \"0.5760595\",\n \"0.57604486\",\n \"0.5750337\",\n \"0.5747492\",\n \"0.5744894\",\n \"0.5744689\",\n \"0.57424146\",\n \"0.57392055\",\n \"0.5715759\",\n \"0.57126087\",\n \"0.5705972\",\n \"0.5694906\",\n \"0.56933904\",\n \"0.5686967\",\n \"0.5678696\",\n \"0.567235\",\n \"0.5657054\",\n \"0.56482774\",\n \"0.5641116\",\n \"0.5637122\",\n \"0.5631629\",\n \"0.56251436\",\n \"0.5621382\",\n \"0.5618931\",\n \"0.5615693\",\n \"0.5612733\",\n \"0.5612255\",\n \"0.56115496\",\n \"0.56107473\",\n \"0.56033415\",\n \"0.56028765\",\n \"0.559842\",\n \"0.5597451\",\n \"0.55954725\",\n \"0.55858624\",\n \"0.5584283\",\n \"0.5582236\",\n \"0.5573958\",\n \"0.55713636\",\n \"0.5571199\",\n \"0.5570829\",\n \"0.55686677\",\n \"0.5565391\",\n \"0.55591744\",\n \"0.55587953\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80897,"cells":{"query":{"kind":"string","value":"You can use the matrix returned instead of..."},"document":{"kind":"string","value":"def get_approx_preRes(self, connectivity_threshold, i):\n val = sparse_dict.get_approx_preRes(connectivity_threshold, index = i)\n return val"},"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 process(self, mat):","def lap_mat(self):","def matrix_add():","def as_matrix(self) -> types.Matrix:","def getMatrix(self) -> CMatrix4:\n ...","def get_stain_matrix(I):","def CreateMatrix(self) -> BaseMatrix:","def CreateMatrix(self) -> BaseMatrix:","def T(self) -> BaseMatrix:","def T(self) -> BaseMatrix:","def _matrix(*params):\n raise NotImplementedError","def T(self):\n # TODO - your code here\n transpose = []\n for col in range(self.w):\n new_row = []\n for row in range(self.h):\n new_row.append(self.g[row][col])\n transpose.append(new_row)\n return Matrix(transpose)\n # TODO - your code here","def getMatrix(self, frame):\n self.matrix[3, 1]=self.getValue(frame)\n return self.matrix","def getMatrix(self, frame):\n self.matrix[3, 2]=self.getValue(frame)\n return self.matrix","def getMatrix(self, frame):\n self.matrix[3, 0]=self.getValue(frame)\n return self.matrix","def __init__(self, matrix):\n self.matrix = matrix","def get_score_matrix(self) -> int:","def Matrix(arg0: List[List[complex]]) -> ngsolve.bla.MatrixC:","def initial_processing(mat):\n\tflat_arr = mat.ravel()\n\treturn mat.shape, np.matrix(flat_arr)","def test_convert_matrix():\n foo = Value(matrices=[[1.0, 2.0], [-2.0, 1.0]])\n assert foo.matrices[0][0][1].value == 2.0\n assert foo.matrices[0][1][0].value == -2.0","def get_matrix(self):\n return self._matrix[:3, :]","def wrapDBMatrix(self,mat):\n return mat.todense()","def amat(M):\n aa, _ = a_matrix(M)\n return aa","def matNew(mat):\n return matCopy(mat)","def __pos__(self):\r\n return mat4(map(lambda x: +x, self.mlist))","def take_matrix(self):\n matrix = aux.matrix(self.take_vec(), self.order)\n\n return matrix","def matrix(self):\n return self._matrix(*self.parameters)","def update(mat) -> np.ndarray:\n return mat","def __neg__(self):\n #\n # TODO - your code here\n #\n matrix_neg = []\n for i in range(self.h):\n row = []\n for j in range(self.w):\n row.append(0-self.g[i][j])\n matrix_neg.append(row)\n return Matrix(matrix_neg)\n # TODO - your code here","def writeMatrix(self):\n\t\tpass","def I_matrix(api_calls, invokes):\n i = len(api_calls)\n j = len(api_calls)\n matrix = lil_matrix((i,j), dtype=np.int8)\n for invoke in invokes:\n matrix[invoke] = 1\n matrix[(invoke[1],invoke[0])] = 1\n return matrix","def matrix(self):\n return self._matrix","def matrix(self):\n return self._matrix","def __neg__(self):\n # \n # TODO - your code here\n #\n result = [];\n for row in self.g:\n result.append([-1*n for n in row]);\n \n return Matrix(result);","def interpolate_matrix(matrix):","def _matrix_(self, R=None):\n return self.adjacency_matrix()","def to_s_matrix(w,v):\n pass","def H(self) -> BaseMatrix:","def H(self) -> BaseMatrix:","def transform(self, x: Array2D) -> Array2D:","def __init__(self, matrix):\n if len(matrix) == 0 or len(matrix[0]) == 0:\n return\n self.matrix_sum = [[matrix[r][c] for c in range(len(matrix[0]))] for r in range(len(matrix))]\n for r in range(1, len(matrix)):\n self.matrix_sum[r][0] = self.matrix_sum[r-1][0] + matrix[r][0] \n for c in range(1, len(matrix[0])):\n self.matrix_sum[0][c] = self.matrix_sum[0][c-1] + matrix[0][c]\n \n for r in range(1, len(matrix)):\n for c in range(1, len(matrix[0])):\n self.matrix_sum[r][c] = self.matrix_sum[r][c-1] + self.matrix_sum[r-1][c] + matrix[r][c] - self.matrix_sum[r-1][c-1]","def matGet(mat, r, c):\n return mat[r][c]","def _matrix_(self, R):\n from sage.matrix.all import matrix\n matlab = self.parent()\n entries = matlab.strip_answer(matlab.eval(\"mat2str({0})\".format(self.name())))\n entries = entries.strip()[1:-1].replace(';', ' ')\n entries = [R(_) for _ in entries.split(' ')]\n nrows, ncols = map(int, str(self.size()).strip().split())\n m = matrix(R, nrows, ncols, entries)\n return m","def translation_from_matrix(matrix):\r\n return numpy.array(matrix, copy=False)[:3, 3].copy()","def _buildMatrix(self, SparseMatrix, Ncells, MaxFaces, coeff):\n return (0, 0)","def __mul__(self, other):\n #\n # TODO - your code here\n #\n final_matrix = []\n for i in range(self.h):\n temp_row = []\n for j in range(other.w):\n # take dot-product of row of\n # matrix in 1st arg with col of\n # matrix in 2nd arg\n temp_row.append(dot_product(get_row(self.g, i), get_col(other.g, j)))\n final_matrix.append(temp_row)\n return Matrix(final_matrix)\n # TODO - your code here","def get5x5matrix(self): #modified from nxvasc get3x3matrix()\n try:\n i = na.identity(3)\n \n self.d124 = i.copy()\n self.ds124 = na.zeros(124,na.float64)\n \n for k in range(1,124):\n self.d124 = na.concatenate((self.d124,i))\n# print len(self.d124)\n count = 0\n a = []\n for k in range(-2,3):\n for j in range(-2,3):\n for i in range(-2,3):\n if( i != 0 or j != 0 or k != 0 ):\n self.ds124[count] = math.sqrt(i**2+j**2+k**2)\n count += 1\n a.append(i)\n a.append(j)\n a.append(k)\n# print len(a)\n a = na.reshape(na.array(a),(372,1))\n# print len(self.d124)\n self.d124 = na.concatenate((self.d124,a),axis=1)\n except Exception as error:\n print(\"failed in get5x5matrix(): \", error)","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[1, 1]=c\n self.matrix[1, 2]=s\n self.matrix[2, 1]=-s\n self.matrix[2, 2]=c\n return self.matrix","def build_stoichiometric_matrix(incidence_matrix, complexes_matrix):\n\n #@ is matrix multiplication\n\n #print(\"complexes matrix\")\n\n #This is matrix N in toric paper\n return complexes_matrix.transpose() @ incidence_matrix","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[2, 2]=c\n self.matrix[2, 0]=s\n self.matrix[0, 2]=-s\n self.matrix[0, 0]=c\n return self.matrix","def current_state(self):\n return self.matrix\n #return tuple([tuple(i) for i in self.matrix]) # + [(self.rows, self.cols)])","def process_matrix(row_count, column_count, operator):\n\n result = []\n for i in range(row_count):\n row = []\n for j in range(column_count):\n row.append(operator(i, j))\n result.append(row)\n\n return result","def jmat(ind: int):\n return _jm[ind - 1]","def _calc_matrix(self):\n\t\tz = self.zoom\n\t\talloc = self.allocation\n\t\tif self.image:\n\t\t\tiw, ih = self.image.get_width(), self.image.get_height()\n\t\telse:\n\t\t\tiw, ih = 0, 0\n#\t\tif __debug__: print self._vadj.lower, self._vadj.value, self._vadj.upper\n\t\t\n\t\ti2w = cairo.Matrix(\n\t\t\tz,0,\n\t\t\t0,z,\n\t\t\t-self._hadj.value if alloc.width < iw*z else (alloc.width - iw*z)/2, \n\t\t\t-self._vadj.value if alloc.height < ih*z else (alloc.height - ih*z)/2,\n\t\t\t)\n\t\t\n\t\tself._i2w_matrix = i2w\n\t\t\n\t\tw2i = cairo.Matrix(*i2w) #copy\n\t\tw2i.invert()\n\t\tself._w2i_matrix = w2i","def transpose(m):\n\n pass","def identity_matrix():\n return numpy.identity(4)","def matrix_table(matrix):\r\n result =\"<table id='matrix_result'>\"\r\n for line in range(len(matrix)):\r\n result += \"<tr>\"\r\n for column in range(len(matrix)):\r\n result += \"<td>\" + str(matrix[line][column]) + \"</td>\"\r\n result += \"</tr>\"\r\n result += \"</table>\"\r\n return result","def Matrix(row, col, val=0):\n\treturn [[val for _j in xrange(col)] for _i in xrange(row)]","def clone_matrix(mat):\n return [[x for x in row] for row in mat]","def identity_matrix():\r\n return numpy.identity(4)","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[0, 0]=c\n self.matrix[0, 1]=s\n self.matrix[1, 0]=-s\n self.matrix[1, 1]=c\n return self.matrix","def I(n):\n identity = Matrix(n,n)\n print identity.matrix\n index = 0 \n for i in range(identity.nrows):\n for j in range(identity.ncols):\n identity.matrix[i][index] = 1\n index += 1\n\n\n flat = []\n for i in range(identity.nrows):\n for j in range(identity.ncols):\n flat.append(identity.matrix[i][j])\n\n\n return identity","def copy_matrix(matrix):\n import numpy as np\n copy_of_m = np.copy(matrix)\n return copy_of_m","def __rmul__(self, other):\n if isinstance(other, numbers.Number):\n #\n # TODO - your code here\n #\n scaled_matrix = []\n for i in range(self.h):\n temp_row = []\n for j in range(self.w):\n temp_row.append(other * self.g[i][j])\n scaled_matrix.append(temp_row)\n return Matrix(scaled_matrix)\n # TODO - your code here","def make_matrix(rows, columns):\n\tmatrix = []\n\tfor row in range(rows):\n\t\tmatrix += [[0] * columns]\n\t\t\n\treturn matrix","def turn_matrix(self, matrix):\n if matrix[0][0] == 1:\n tab = [[(matrix[-j - 1][i] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\n elif matrix[0][1] == 1:\n tab = [[(matrix[i][j] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\n elif matrix[1][0] == 1:\n tab = [[(matrix[i][j] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\n else:\n tab = [[(matrix[j][-1 - i] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\n return tab","def __init__(self, M,):\n #transpose because we are given column vectors not row vectors\n self.M = np.transpose(np.matrix(M))","def matCopy(mat):\n shape=matShape(mat)\n return [[matGet(mat,x,y) for y in range(shape[1])] \\\n for x in range(shape[0])]","def T(self):\n # TODO - your code here\n matrix_transpose = [];\n \n for j in range(self.w):\n matrix_transpose.append(self.get_column(j));\n \n return Matrix(matrix_transpose);","def transform_mat(matrix):\n delta = 1e-5\n matrix = matrix + delta\n return matrix","def _make_random_matrix(self, n_components, n_features):","def return_adjacencyMatrix(self):\n return self.__mat","def get_direction_matrix(self) -> int:","def gram_matrix(features, normalize=True):\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n\n pass\n\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****","def upload_matrix(row_names, col_names, matrix):","def _makeWaMatrix_(self, wa, nRow, nCol):\n\t\t#print nRow, nCol\n\t\t#print wa\n\t\t#print\n\t\twaMatrix = [[0 for j in xrange(nCol)] for i in xrange(nRow)]\n\t\tfor a in wa: \n\t\t\tfor i in a[0]:\n\t\t\t\tfor j in a[1]:\n\t\t\t\t\twaMatrix[i][j] = 1\n\t\treturn waMatrix","def doubleMatrix(mat):\n\n dims = mat.shape\n myZero = np.zeros(dims)\n ans = np.block([[mat, myZero], [myZero, mat]])\n return ans","def from_matrix(matrix: types.Matrix) -> \"MatrixLieGroup\":","def matT(mat):\n shape=matShape(mat)\n return [[matGet(mat,y,x) for y in range(shape[0])] \\\n for x in range(shape[1])]","def matrix(self):\n return self.composition(self._parent.edge_to_matrix)","def array(self):","def generate_matrix(doc):\n bv_stru=doc['bv_structure']\n lattice=bv_stru['lattice']\n l_matrix=lattice['matrix']\n #manipulate over lattice matrix\n mat_list=[]\n for list_m in l_matrix:\n str_null=''\n for items in list_m:\n items=Decimal(items).quantize(Decimal('0.000000'))\n str_null=str_null+str(items)+' '\n str_null=str_null[:len(str_null)-1]\n mat_list.append(str_null)\n return mat_list","def gen_matrix(e):\n\tif e < 1:\n\t\treturn None\n\tm_list = [[[1, 2], [3, 0]]]\n\t_b = m_list[0]\n\tfor n in xrange(1, e):\n\t\tm = m_list[n - 1]\n\t\tm_list.append(\n\t\t\t[\n\t\t\t\t[4 * i + _b[0][0] for i in m[0]] + [4 * i + _b[0][1] for i in m[0]],\n\t\t\t\t[4 * i + _b[0][0] for i in m[1]] + [4 * i + _b[0][1] for i in m[1]],\n\t\t\t\t[4 * i + _b[1][0] for i in m[0]] + [4 * i + _b[1][1] for i in m[0]],\n\t\t\t\t[4 * i + _b[1][0] for i in m[1]] + [4 * i + _b[1][1] for i in m[1]],\n\t\t\t]\n\t\t)\n\treturn m_list","def get_l(m):\n L = m.copy()\n for i in range(L.shape[0]):\n L[i, i] = 1\n L[i, i+1:] = 0\n return np.matrix(L)","def matrix(self):\n return self._translation","def to_mat(self) -> np.matrix:\n raise NotImplementedError","def __repr__(self):\n return repr(self.matrix)","def traspo(*args):\r\n filas,columnas = len(args),len(args[0])\r\n matriz_r = []\r\n for i in range(0,filas):\r\n lista_aux = []\r\n for j in range(0,columnas):\r\n lista_aux.append(args[j][i])\r\n matriz_r.append(lista_aux)\r\n return matriz_r","def set_up_matrix():\n matrix= []\n row= \"1 9 3 4 5\"\n row= to_int(row)\n matrix.append(row)\n row= \"2 30 4 5 6\"\n row= to_int(row)\n matrix.append(row)\n row= \"3 8 5 6 7\"\n row= to_int(row)\n matrix.append(row)\n row= \"4 5 6 7 8\"\n row= to_int(row)\n matrix.append(row)\n row= \"5 6 7 8 9\"\n row= to_int(row)\n matrix.append(row)\n return matrix","def set_make_matrix(function: Callable) -> None:\n utilities.make_matrix = function","def dup_matrix(self):\n maxtrixcalc = importr('matrixcalc') # load matrixcalc library\n rscript = 'D.matrix( )'.replace(' ', str(self.k)) # generate R script\n rmatrix = robjects.r(rscript) # run R script\n dup_mat = np.array(rmatrix) # convert to ndarray\n return dup_mat # ndarray","def make_matrix(rows, cols, value=0):\n return Matrix([[value for i in range(cols)] for j in range(rows)])","def build_augmented_matrix(self):\r\n for row in range(self.SIZE):\r\n self.matrix[row].append(self.result[row])","def make_matrix():\n\n # this imports category, category, data, text, pptx_data\n\n if use_test_data:\n # make a test matrix using create_test_matrix\n m = matrixfuncs.create_test_matrix()\n\n else:\n # make a matrix by connecting to Slides! and connecting to a data\n # table.\n import transformations.utils.slidesconf as slidesconf\n from Forgetdata.Matrix import ConnectionDefinition\n conn = ConnectionDefinition()\n conn.ConnectionString = mtd_filepath # set at top of file\n conn.Name = \"Test\"\n conn.Provider = \"SPSS MTD File\"\n liveConnection = slidesconf.connect(conn.ConnectionString,\n name=conn.Name,\n provider_name=conn.Provider)\n\n m = liveConnection[table_selected]\n\n x = tr.MatrixManipulator(m)\n matrixfuncs.printMatrix(m)\n\n for c in m[0]:\n c.TopMember.Label = c.TopMember.Label.encode('ascii', 'ignore')\n\n return m, x","def __mul__(self,m):\n if type(m) != Matrix:\n raise TypeError('The second argument is not a matrix lol')\n if self.ncols != m.nrows:\n raise ValueError('matrix dot argument has incorrect number of rows')\n new = Matrix(self.nrows,m.ncols)\n columns = m.getCols()\n rowindex = 0\n colindex = 0 \n for row in self.matrix:\n colindex = 0 \n for col in columns:\n summ = 0\n for i,j in zip(row,col):\n summ+= i*j \n new.matrix[rowindex][colindex] = summ\n print new.matrix\n colindex += 1 \n rowindex+=1\n return new","def mutate_matrix(matrix):\n L = len(matrix)\n r_i = random.randrange(L)\n r_j = random.randrange(4)\n r = random.gauss(0,1)\n return [[matrix[i][j]+r*(i==r_i)*(j==r_j)\n for j in range(4)] for i in range(L)]","def matrix(self) -> sympy.Matrix:\n raise NotImplementedError()","def get_matrix_a(args):\n\treturn [[np.power(arg, k) for k in xrange(len(args))] for arg in args]","def c_matrix(x1,x2,x3):\n\tC = np.array([\t[\t2*(x2-x1), \t\t(x2-x1), \t\t\t0\t\t\t], \\\n\t\t\t\t\t[\t(x2-x1), \t\t2*(x3-x1), \t\t(x3-x2)\t\t], \\\n\t\t\t\t\t[\t0,\t\t\t\t(x3-x2),\t\t2*(x3-x2)\t] \t], \\\n\t\t\t\t\tfloat)\n\treturn(C)","def init_output_mat(self, y_list):","def Omat(self):\n if self.standard:\n return np.matrix(((0, -1, 0), (0, 0, 1), (-1, 0, 0)))\n else:\n return np.matrix(((0, 0, 1), (0, 1, 0), (-1, 0, 0)))"],"string":"[\n \"def process(self, mat):\",\n \"def lap_mat(self):\",\n \"def matrix_add():\",\n \"def as_matrix(self) -> types.Matrix:\",\n \"def getMatrix(self) -> CMatrix4:\\n ...\",\n \"def get_stain_matrix(I):\",\n \"def CreateMatrix(self) -> BaseMatrix:\",\n \"def CreateMatrix(self) -> BaseMatrix:\",\n \"def T(self) -> BaseMatrix:\",\n \"def T(self) -> BaseMatrix:\",\n \"def _matrix(*params):\\n raise NotImplementedError\",\n \"def T(self):\\n # TODO - your code here\\n transpose = []\\n for col in range(self.w):\\n new_row = []\\n for row in range(self.h):\\n new_row.append(self.g[row][col])\\n transpose.append(new_row)\\n return Matrix(transpose)\\n # TODO - your code here\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 1]=self.getValue(frame)\\n return self.matrix\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 2]=self.getValue(frame)\\n return self.matrix\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 0]=self.getValue(frame)\\n return self.matrix\",\n \"def __init__(self, matrix):\\n self.matrix = matrix\",\n \"def get_score_matrix(self) -> int:\",\n \"def Matrix(arg0: List[List[complex]]) -> ngsolve.bla.MatrixC:\",\n \"def initial_processing(mat):\\n\\tflat_arr = mat.ravel()\\n\\treturn mat.shape, np.matrix(flat_arr)\",\n \"def test_convert_matrix():\\n foo = Value(matrices=[[1.0, 2.0], [-2.0, 1.0]])\\n assert foo.matrices[0][0][1].value == 2.0\\n assert foo.matrices[0][1][0].value == -2.0\",\n \"def get_matrix(self):\\n return self._matrix[:3, :]\",\n \"def wrapDBMatrix(self,mat):\\n return mat.todense()\",\n \"def amat(M):\\n aa, _ = a_matrix(M)\\n return aa\",\n \"def matNew(mat):\\n return matCopy(mat)\",\n \"def __pos__(self):\\r\\n return mat4(map(lambda x: +x, self.mlist))\",\n \"def take_matrix(self):\\n matrix = aux.matrix(self.take_vec(), self.order)\\n\\n return matrix\",\n \"def matrix(self):\\n return self._matrix(*self.parameters)\",\n \"def update(mat) -> np.ndarray:\\n return mat\",\n \"def __neg__(self):\\n #\\n # TODO - your code here\\n #\\n matrix_neg = []\\n for i in range(self.h):\\n row = []\\n for j in range(self.w):\\n row.append(0-self.g[i][j])\\n matrix_neg.append(row)\\n return Matrix(matrix_neg)\\n # TODO - your code here\",\n \"def writeMatrix(self):\\n\\t\\tpass\",\n \"def I_matrix(api_calls, invokes):\\n i = len(api_calls)\\n j = len(api_calls)\\n matrix = lil_matrix((i,j), dtype=np.int8)\\n for invoke in invokes:\\n matrix[invoke] = 1\\n matrix[(invoke[1],invoke[0])] = 1\\n return matrix\",\n \"def matrix(self):\\n return self._matrix\",\n \"def matrix(self):\\n return self._matrix\",\n \"def __neg__(self):\\n # \\n # TODO - your code here\\n #\\n result = [];\\n for row in self.g:\\n result.append([-1*n for n in row]);\\n \\n return Matrix(result);\",\n \"def interpolate_matrix(matrix):\",\n \"def _matrix_(self, R=None):\\n return self.adjacency_matrix()\",\n \"def to_s_matrix(w,v):\\n pass\",\n \"def H(self) -> BaseMatrix:\",\n \"def H(self) -> BaseMatrix:\",\n \"def transform(self, x: Array2D) -> Array2D:\",\n \"def __init__(self, matrix):\\n if len(matrix) == 0 or len(matrix[0]) == 0:\\n return\\n self.matrix_sum = [[matrix[r][c] for c in range(len(matrix[0]))] for r in range(len(matrix))]\\n for r in range(1, len(matrix)):\\n self.matrix_sum[r][0] = self.matrix_sum[r-1][0] + matrix[r][0] \\n for c in range(1, len(matrix[0])):\\n self.matrix_sum[0][c] = self.matrix_sum[0][c-1] + matrix[0][c]\\n \\n for r in range(1, len(matrix)):\\n for c in range(1, len(matrix[0])):\\n self.matrix_sum[r][c] = self.matrix_sum[r][c-1] + self.matrix_sum[r-1][c] + matrix[r][c] - self.matrix_sum[r-1][c-1]\",\n \"def matGet(mat, r, c):\\n return mat[r][c]\",\n \"def _matrix_(self, R):\\n from sage.matrix.all import matrix\\n matlab = self.parent()\\n entries = matlab.strip_answer(matlab.eval(\\\"mat2str({0})\\\".format(self.name())))\\n entries = entries.strip()[1:-1].replace(';', ' ')\\n entries = [R(_) for _ in entries.split(' ')]\\n nrows, ncols = map(int, str(self.size()).strip().split())\\n m = matrix(R, nrows, ncols, entries)\\n return m\",\n \"def translation_from_matrix(matrix):\\r\\n return numpy.array(matrix, copy=False)[:3, 3].copy()\",\n \"def _buildMatrix(self, SparseMatrix, Ncells, MaxFaces, coeff):\\n return (0, 0)\",\n \"def __mul__(self, other):\\n #\\n # TODO - your code here\\n #\\n final_matrix = []\\n for i in range(self.h):\\n temp_row = []\\n for j in range(other.w):\\n # take dot-product of row of\\n # matrix in 1st arg with col of\\n # matrix in 2nd arg\\n temp_row.append(dot_product(get_row(self.g, i), get_col(other.g, j)))\\n final_matrix.append(temp_row)\\n return Matrix(final_matrix)\\n # TODO - your code here\",\n \"def get5x5matrix(self): #modified from nxvasc get3x3matrix()\\n try:\\n i = na.identity(3)\\n \\n self.d124 = i.copy()\\n self.ds124 = na.zeros(124,na.float64)\\n \\n for k in range(1,124):\\n self.d124 = na.concatenate((self.d124,i))\\n# print len(self.d124)\\n count = 0\\n a = []\\n for k in range(-2,3):\\n for j in range(-2,3):\\n for i in range(-2,3):\\n if( i != 0 or j != 0 or k != 0 ):\\n self.ds124[count] = math.sqrt(i**2+j**2+k**2)\\n count += 1\\n a.append(i)\\n a.append(j)\\n a.append(k)\\n# print len(a)\\n a = na.reshape(na.array(a),(372,1))\\n# print len(self.d124)\\n self.d124 = na.concatenate((self.d124,a),axis=1)\\n except Exception as error:\\n print(\\\"failed in get5x5matrix(): \\\", error)\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[1, 1]=c\\n self.matrix[1, 2]=s\\n self.matrix[2, 1]=-s\\n self.matrix[2, 2]=c\\n return self.matrix\",\n \"def build_stoichiometric_matrix(incidence_matrix, complexes_matrix):\\n\\n #@ is matrix multiplication\\n\\n #print(\\\"complexes matrix\\\")\\n\\n #This is matrix N in toric paper\\n return complexes_matrix.transpose() @ incidence_matrix\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[2, 2]=c\\n self.matrix[2, 0]=s\\n self.matrix[0, 2]=-s\\n self.matrix[0, 0]=c\\n return self.matrix\",\n \"def current_state(self):\\n return self.matrix\\n #return tuple([tuple(i) for i in self.matrix]) # + [(self.rows, self.cols)])\",\n \"def process_matrix(row_count, column_count, operator):\\n\\n result = []\\n for i in range(row_count):\\n row = []\\n for j in range(column_count):\\n row.append(operator(i, j))\\n result.append(row)\\n\\n return result\",\n \"def jmat(ind: int):\\n return _jm[ind - 1]\",\n \"def _calc_matrix(self):\\n\\t\\tz = self.zoom\\n\\t\\talloc = self.allocation\\n\\t\\tif self.image:\\n\\t\\t\\tiw, ih = self.image.get_width(), self.image.get_height()\\n\\t\\telse:\\n\\t\\t\\tiw, ih = 0, 0\\n#\\t\\tif __debug__: print self._vadj.lower, self._vadj.value, self._vadj.upper\\n\\t\\t\\n\\t\\ti2w = cairo.Matrix(\\n\\t\\t\\tz,0,\\n\\t\\t\\t0,z,\\n\\t\\t\\t-self._hadj.value if alloc.width < iw*z else (alloc.width - iw*z)/2, \\n\\t\\t\\t-self._vadj.value if alloc.height < ih*z else (alloc.height - ih*z)/2,\\n\\t\\t\\t)\\n\\t\\t\\n\\t\\tself._i2w_matrix = i2w\\n\\t\\t\\n\\t\\tw2i = cairo.Matrix(*i2w) #copy\\n\\t\\tw2i.invert()\\n\\t\\tself._w2i_matrix = w2i\",\n \"def transpose(m):\\n\\n pass\",\n \"def identity_matrix():\\n return numpy.identity(4)\",\n \"def matrix_table(matrix):\\r\\n result =\\\"<table id='matrix_result'>\\\"\\r\\n for line in range(len(matrix)):\\r\\n result += \\\"<tr>\\\"\\r\\n for column in range(len(matrix)):\\r\\n result += \\\"<td>\\\" + str(matrix[line][column]) + \\\"</td>\\\"\\r\\n result += \\\"</tr>\\\"\\r\\n result += \\\"</table>\\\"\\r\\n return result\",\n \"def Matrix(row, col, val=0):\\n\\treturn [[val for _j in xrange(col)] for _i in xrange(row)]\",\n \"def clone_matrix(mat):\\n return [[x for x in row] for row in mat]\",\n \"def identity_matrix():\\r\\n return numpy.identity(4)\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[0, 0]=c\\n self.matrix[0, 1]=s\\n self.matrix[1, 0]=-s\\n self.matrix[1, 1]=c\\n return self.matrix\",\n \"def I(n):\\n identity = Matrix(n,n)\\n print identity.matrix\\n index = 0 \\n for i in range(identity.nrows):\\n for j in range(identity.ncols):\\n identity.matrix[i][index] = 1\\n index += 1\\n\\n\\n flat = []\\n for i in range(identity.nrows):\\n for j in range(identity.ncols):\\n flat.append(identity.matrix[i][j])\\n\\n\\n return identity\",\n \"def copy_matrix(matrix):\\n import numpy as np\\n copy_of_m = np.copy(matrix)\\n return copy_of_m\",\n \"def __rmul__(self, other):\\n if isinstance(other, numbers.Number):\\n #\\n # TODO - your code here\\n #\\n scaled_matrix = []\\n for i in range(self.h):\\n temp_row = []\\n for j in range(self.w):\\n temp_row.append(other * self.g[i][j])\\n scaled_matrix.append(temp_row)\\n return Matrix(scaled_matrix)\\n # TODO - your code here\",\n \"def make_matrix(rows, columns):\\n\\tmatrix = []\\n\\tfor row in range(rows):\\n\\t\\tmatrix += [[0] * columns]\\n\\t\\t\\n\\treturn matrix\",\n \"def turn_matrix(self, matrix):\\n if matrix[0][0] == 1:\\n tab = [[(matrix[-j - 1][i] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\\n elif matrix[0][1] == 1:\\n tab = [[(matrix[i][j] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\\n elif matrix[1][0] == 1:\\n tab = [[(matrix[i][j] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\\n else:\\n tab = [[(matrix[j][-1 - i] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\\n return tab\",\n \"def __init__(self, M,):\\n #transpose because we are given column vectors not row vectors\\n self.M = np.transpose(np.matrix(M))\",\n \"def matCopy(mat):\\n shape=matShape(mat)\\n return [[matGet(mat,x,y) for y in range(shape[1])] \\\\\\n for x in range(shape[0])]\",\n \"def T(self):\\n # TODO - your code here\\n matrix_transpose = [];\\n \\n for j in range(self.w):\\n matrix_transpose.append(self.get_column(j));\\n \\n return Matrix(matrix_transpose);\",\n \"def transform_mat(matrix):\\n delta = 1e-5\\n matrix = matrix + delta\\n return matrix\",\n \"def _make_random_matrix(self, n_components, n_features):\",\n \"def return_adjacencyMatrix(self):\\n return self.__mat\",\n \"def get_direction_matrix(self) -> int:\",\n \"def gram_matrix(features, normalize=True):\\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n\\n pass\\n\\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\",\n \"def upload_matrix(row_names, col_names, matrix):\",\n \"def _makeWaMatrix_(self, wa, nRow, nCol):\\n\\t\\t#print nRow, nCol\\n\\t\\t#print wa\\n\\t\\t#print\\n\\t\\twaMatrix = [[0 for j in xrange(nCol)] for i in xrange(nRow)]\\n\\t\\tfor a in wa: \\n\\t\\t\\tfor i in a[0]:\\n\\t\\t\\t\\tfor j in a[1]:\\n\\t\\t\\t\\t\\twaMatrix[i][j] = 1\\n\\t\\treturn waMatrix\",\n \"def doubleMatrix(mat):\\n\\n dims = mat.shape\\n myZero = np.zeros(dims)\\n ans = np.block([[mat, myZero], [myZero, mat]])\\n return ans\",\n \"def from_matrix(matrix: types.Matrix) -> \\\"MatrixLieGroup\\\":\",\n \"def matT(mat):\\n shape=matShape(mat)\\n return [[matGet(mat,y,x) for y in range(shape[0])] \\\\\\n for x in range(shape[1])]\",\n \"def matrix(self):\\n return self.composition(self._parent.edge_to_matrix)\",\n \"def array(self):\",\n \"def generate_matrix(doc):\\n bv_stru=doc['bv_structure']\\n lattice=bv_stru['lattice']\\n l_matrix=lattice['matrix']\\n #manipulate over lattice matrix\\n mat_list=[]\\n for list_m in l_matrix:\\n str_null=''\\n for items in list_m:\\n items=Decimal(items).quantize(Decimal('0.000000'))\\n str_null=str_null+str(items)+' '\\n str_null=str_null[:len(str_null)-1]\\n mat_list.append(str_null)\\n return mat_list\",\n \"def gen_matrix(e):\\n\\tif e < 1:\\n\\t\\treturn None\\n\\tm_list = [[[1, 2], [3, 0]]]\\n\\t_b = m_list[0]\\n\\tfor n in xrange(1, e):\\n\\t\\tm = m_list[n - 1]\\n\\t\\tm_list.append(\\n\\t\\t\\t[\\n\\t\\t\\t\\t[4 * i + _b[0][0] for i in m[0]] + [4 * i + _b[0][1] for i in m[0]],\\n\\t\\t\\t\\t[4 * i + _b[0][0] for i in m[1]] + [4 * i + _b[0][1] for i in m[1]],\\n\\t\\t\\t\\t[4 * i + _b[1][0] for i in m[0]] + [4 * i + _b[1][1] for i in m[0]],\\n\\t\\t\\t\\t[4 * i + _b[1][0] for i in m[1]] + [4 * i + _b[1][1] for i in m[1]],\\n\\t\\t\\t]\\n\\t\\t)\\n\\treturn m_list\",\n \"def get_l(m):\\n L = m.copy()\\n for i in range(L.shape[0]):\\n L[i, i] = 1\\n L[i, i+1:] = 0\\n return np.matrix(L)\",\n \"def matrix(self):\\n return self._translation\",\n \"def to_mat(self) -> np.matrix:\\n raise NotImplementedError\",\n \"def __repr__(self):\\n return repr(self.matrix)\",\n \"def traspo(*args):\\r\\n filas,columnas = len(args),len(args[0])\\r\\n matriz_r = []\\r\\n for i in range(0,filas):\\r\\n lista_aux = []\\r\\n for j in range(0,columnas):\\r\\n lista_aux.append(args[j][i])\\r\\n matriz_r.append(lista_aux)\\r\\n return matriz_r\",\n \"def set_up_matrix():\\n matrix= []\\n row= \\\"1 9 3 4 5\\\"\\n row= to_int(row)\\n matrix.append(row)\\n row= \\\"2 30 4 5 6\\\"\\n row= to_int(row)\\n matrix.append(row)\\n row= \\\"3 8 5 6 7\\\"\\n row= to_int(row)\\n matrix.append(row)\\n row= \\\"4 5 6 7 8\\\"\\n row= to_int(row)\\n matrix.append(row)\\n row= \\\"5 6 7 8 9\\\"\\n row= to_int(row)\\n matrix.append(row)\\n return matrix\",\n \"def set_make_matrix(function: Callable) -> None:\\n utilities.make_matrix = function\",\n \"def dup_matrix(self):\\n maxtrixcalc = importr('matrixcalc') # load matrixcalc library\\n rscript = 'D.matrix( )'.replace(' ', str(self.k)) # generate R script\\n rmatrix = robjects.r(rscript) # run R script\\n dup_mat = np.array(rmatrix) # convert to ndarray\\n return dup_mat # ndarray\",\n \"def make_matrix(rows, cols, value=0):\\n return Matrix([[value for i in range(cols)] for j in range(rows)])\",\n \"def build_augmented_matrix(self):\\r\\n for row in range(self.SIZE):\\r\\n self.matrix[row].append(self.result[row])\",\n \"def make_matrix():\\n\\n # this imports category, category, data, text, pptx_data\\n\\n if use_test_data:\\n # make a test matrix using create_test_matrix\\n m = matrixfuncs.create_test_matrix()\\n\\n else:\\n # make a matrix by connecting to Slides! and connecting to a data\\n # table.\\n import transformations.utils.slidesconf as slidesconf\\n from Forgetdata.Matrix import ConnectionDefinition\\n conn = ConnectionDefinition()\\n conn.ConnectionString = mtd_filepath # set at top of file\\n conn.Name = \\\"Test\\\"\\n conn.Provider = \\\"SPSS MTD File\\\"\\n liveConnection = slidesconf.connect(conn.ConnectionString,\\n name=conn.Name,\\n provider_name=conn.Provider)\\n\\n m = liveConnection[table_selected]\\n\\n x = tr.MatrixManipulator(m)\\n matrixfuncs.printMatrix(m)\\n\\n for c in m[0]:\\n c.TopMember.Label = c.TopMember.Label.encode('ascii', 'ignore')\\n\\n return m, x\",\n \"def __mul__(self,m):\\n if type(m) != Matrix:\\n raise TypeError('The second argument is not a matrix lol')\\n if self.ncols != m.nrows:\\n raise ValueError('matrix dot argument has incorrect number of rows')\\n new = Matrix(self.nrows,m.ncols)\\n columns = m.getCols()\\n rowindex = 0\\n colindex = 0 \\n for row in self.matrix:\\n colindex = 0 \\n for col in columns:\\n summ = 0\\n for i,j in zip(row,col):\\n summ+= i*j \\n new.matrix[rowindex][colindex] = summ\\n print new.matrix\\n colindex += 1 \\n rowindex+=1\\n return new\",\n \"def mutate_matrix(matrix):\\n L = len(matrix)\\n r_i = random.randrange(L)\\n r_j = random.randrange(4)\\n r = random.gauss(0,1)\\n return [[matrix[i][j]+r*(i==r_i)*(j==r_j)\\n for j in range(4)] for i in range(L)]\",\n \"def matrix(self) -> sympy.Matrix:\\n raise NotImplementedError()\",\n \"def get_matrix_a(args):\\n\\treturn [[np.power(arg, k) for k in xrange(len(args))] for arg in args]\",\n \"def c_matrix(x1,x2,x3):\\n\\tC = np.array([\\t[\\t2*(x2-x1), \\t\\t(x2-x1), \\t\\t\\t0\\t\\t\\t], \\\\\\n\\t\\t\\t\\t\\t[\\t(x2-x1), \\t\\t2*(x3-x1), \\t\\t(x3-x2)\\t\\t], \\\\\\n\\t\\t\\t\\t\\t[\\t0,\\t\\t\\t\\t(x3-x2),\\t\\t2*(x3-x2)\\t] \\t], \\\\\\n\\t\\t\\t\\t\\tfloat)\\n\\treturn(C)\",\n \"def init_output_mat(self, y_list):\",\n \"def Omat(self):\\n if self.standard:\\n return np.matrix(((0, -1, 0), (0, 0, 1), (-1, 0, 0)))\\n else:\\n return np.matrix(((0, 0, 1), (0, 1, 0), (-1, 0, 0)))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73965985","0.72873676","0.7231809","0.72027314","0.68871105","0.68203425","0.6809076","0.6809076","0.6786066","0.6786066","0.6742204","0.67335075","0.6574923","0.65624046","0.65345794","0.65269136","0.65112585","0.6453542","0.6378975","0.6354362","0.6304048","0.62946355","0.6291557","0.6287873","0.62820816","0.6269495","0.6227879","0.6217925","0.6217253","0.61279845","0.61259645","0.61233145","0.61233145","0.61164194","0.606347","0.6058692","0.6046673","0.6036499","0.6036499","0.6032466","0.6028111","0.60249555","0.6002468","0.6002382","0.6001254","0.5992694","0.5990698","0.59848833","0.59832823","0.5978594","0.59776974","0.59551257","0.5950289","0.5935993","0.59337926","0.59311897","0.59306395","0.592723","0.58990455","0.58980334","0.5897465","0.589089","0.58863974","0.58793956","0.5874332","0.58700913","0.5848702","0.5847536","0.58466226","0.58285534","0.58271724","0.5826325","0.5825375","0.5820903","0.58145046","0.58137506","0.58130306","0.58107644","0.58101875","0.58090085","0.58063966","0.5804649","0.58021796","0.5797711","0.5794554","0.5783206","0.57814074","0.57804143","0.57745516","0.5771401","0.5761957","0.57614183","0.5759562","0.57575905","0.5755906","0.5746787","0.57450926","0.5737016","0.57368","0.5724077","0.57166916"],"string":"[\n \"0.73965985\",\n \"0.72873676\",\n \"0.7231809\",\n \"0.72027314\",\n \"0.68871105\",\n \"0.68203425\",\n \"0.6809076\",\n \"0.6809076\",\n \"0.6786066\",\n \"0.6786066\",\n \"0.6742204\",\n \"0.67335075\",\n \"0.6574923\",\n \"0.65624046\",\n \"0.65345794\",\n \"0.65269136\",\n \"0.65112585\",\n \"0.6453542\",\n \"0.6378975\",\n \"0.6354362\",\n \"0.6304048\",\n \"0.62946355\",\n \"0.6291557\",\n \"0.6287873\",\n \"0.62820816\",\n \"0.6269495\",\n \"0.6227879\",\n \"0.6217925\",\n \"0.6217253\",\n \"0.61279845\",\n \"0.61259645\",\n \"0.61233145\",\n \"0.61233145\",\n \"0.61164194\",\n \"0.606347\",\n \"0.6058692\",\n \"0.6046673\",\n \"0.6036499\",\n \"0.6036499\",\n \"0.6032466\",\n \"0.6028111\",\n \"0.60249555\",\n \"0.6002468\",\n \"0.6002382\",\n \"0.6001254\",\n \"0.5992694\",\n \"0.5990698\",\n \"0.59848833\",\n \"0.59832823\",\n \"0.5978594\",\n \"0.59776974\",\n \"0.59551257\",\n \"0.5950289\",\n \"0.5935993\",\n \"0.59337926\",\n \"0.59311897\",\n \"0.59306395\",\n \"0.592723\",\n \"0.58990455\",\n \"0.58980334\",\n \"0.5897465\",\n \"0.589089\",\n \"0.58863974\",\n \"0.58793956\",\n \"0.5874332\",\n \"0.58700913\",\n \"0.5848702\",\n \"0.5847536\",\n \"0.58466226\",\n \"0.58285534\",\n \"0.58271724\",\n \"0.5826325\",\n \"0.5825375\",\n \"0.5820903\",\n \"0.58145046\",\n \"0.58137506\",\n \"0.58130306\",\n \"0.58107644\",\n \"0.58101875\",\n \"0.58090085\",\n \"0.58063966\",\n \"0.5804649\",\n \"0.58021796\",\n \"0.5797711\",\n \"0.5794554\",\n \"0.5783206\",\n \"0.57814074\",\n \"0.57804143\",\n \"0.57745516\",\n \"0.5771401\",\n \"0.5761957\",\n \"0.57614183\",\n \"0.5759562\",\n \"0.57575905\",\n \"0.5755906\",\n \"0.5746787\",\n \"0.57450926\",\n \"0.5737016\",\n \"0.57368\",\n \"0.5724077\",\n \"0.57166916\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80898,"cells":{"query":{"kind":"string","value":"You can use the matrix returned instead of..."},"document":{"kind":"string","value":"def get_approx_preRes_old(self, connectivity_threshold, i):\n key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]\n val = np.array(sparse_dict[key_]).copy()\n return val"},"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 process(self, mat):","def lap_mat(self):","def matrix_add():","def as_matrix(self) -> types.Matrix:","def getMatrix(self) -> CMatrix4:\n ...","def get_stain_matrix(I):","def CreateMatrix(self) -> BaseMatrix:","def CreateMatrix(self) -> BaseMatrix:","def T(self) -> BaseMatrix:","def T(self) -> BaseMatrix:","def _matrix(*params):\n raise NotImplementedError","def T(self):\n # TODO - your code here\n transpose = []\n for col in range(self.w):\n new_row = []\n for row in range(self.h):\n new_row.append(self.g[row][col])\n transpose.append(new_row)\n return Matrix(transpose)\n # TODO - your code here","def getMatrix(self, frame):\n self.matrix[3, 1]=self.getValue(frame)\n return self.matrix","def getMatrix(self, frame):\n self.matrix[3, 2]=self.getValue(frame)\n return self.matrix","def getMatrix(self, frame):\n self.matrix[3, 0]=self.getValue(frame)\n return self.matrix","def __init__(self, matrix):\n self.matrix = matrix","def get_score_matrix(self) -> int:","def Matrix(arg0: List[List[complex]]) -> ngsolve.bla.MatrixC:","def initial_processing(mat):\n\tflat_arr = mat.ravel()\n\treturn mat.shape, np.matrix(flat_arr)","def test_convert_matrix():\n foo = Value(matrices=[[1.0, 2.0], [-2.0, 1.0]])\n assert foo.matrices[0][0][1].value == 2.0\n assert foo.matrices[0][1][0].value == -2.0","def get_matrix(self):\n return self._matrix[:3, :]","def wrapDBMatrix(self,mat):\n return mat.todense()","def amat(M):\n aa, _ = a_matrix(M)\n return aa","def matNew(mat):\n return matCopy(mat)","def __pos__(self):\r\n return mat4(map(lambda x: +x, self.mlist))","def take_matrix(self):\n matrix = aux.matrix(self.take_vec(), self.order)\n\n return matrix","def matrix(self):\n return self._matrix(*self.parameters)","def update(mat) -> np.ndarray:\n return mat","def __neg__(self):\n #\n # TODO - your code here\n #\n matrix_neg = []\n for i in range(self.h):\n row = []\n for j in range(self.w):\n row.append(0-self.g[i][j])\n matrix_neg.append(row)\n return Matrix(matrix_neg)\n # TODO - your code here","def writeMatrix(self):\n\t\tpass","def I_matrix(api_calls, invokes):\n i = len(api_calls)\n j = len(api_calls)\n matrix = lil_matrix((i,j), dtype=np.int8)\n for invoke in invokes:\n matrix[invoke] = 1\n matrix[(invoke[1],invoke[0])] = 1\n return matrix","def matrix(self):\n return self._matrix","def matrix(self):\n return self._matrix","def __neg__(self):\n # \n # TODO - your code here\n #\n result = [];\n for row in self.g:\n result.append([-1*n for n in row]);\n \n return Matrix(result);","def interpolate_matrix(matrix):","def _matrix_(self, R=None):\n return self.adjacency_matrix()","def to_s_matrix(w,v):\n pass","def H(self) -> BaseMatrix:","def H(self) -> BaseMatrix:","def transform(self, x: Array2D) -> Array2D:","def __init__(self, matrix):\n if len(matrix) == 0 or len(matrix[0]) == 0:\n return\n self.matrix_sum = [[matrix[r][c] for c in range(len(matrix[0]))] for r in range(len(matrix))]\n for r in range(1, len(matrix)):\n self.matrix_sum[r][0] = self.matrix_sum[r-1][0] + matrix[r][0] \n for c in range(1, len(matrix[0])):\n self.matrix_sum[0][c] = self.matrix_sum[0][c-1] + matrix[0][c]\n \n for r in range(1, len(matrix)):\n for c in range(1, len(matrix[0])):\n self.matrix_sum[r][c] = self.matrix_sum[r][c-1] + self.matrix_sum[r-1][c] + matrix[r][c] - self.matrix_sum[r-1][c-1]","def matGet(mat, r, c):\n return mat[r][c]","def _matrix_(self, R):\n from sage.matrix.all import matrix\n matlab = self.parent()\n entries = matlab.strip_answer(matlab.eval(\"mat2str({0})\".format(self.name())))\n entries = entries.strip()[1:-1].replace(';', ' ')\n entries = [R(_) for _ in entries.split(' ')]\n nrows, ncols = map(int, str(self.size()).strip().split())\n m = matrix(R, nrows, ncols, entries)\n return m","def translation_from_matrix(matrix):\r\n return numpy.array(matrix, copy=False)[:3, 3].copy()","def _buildMatrix(self, SparseMatrix, Ncells, MaxFaces, coeff):\n return (0, 0)","def __mul__(self, other):\n #\n # TODO - your code here\n #\n final_matrix = []\n for i in range(self.h):\n temp_row = []\n for j in range(other.w):\n # take dot-product of row of\n # matrix in 1st arg with col of\n # matrix in 2nd arg\n temp_row.append(dot_product(get_row(self.g, i), get_col(other.g, j)))\n final_matrix.append(temp_row)\n return Matrix(final_matrix)\n # TODO - your code here","def get5x5matrix(self): #modified from nxvasc get3x3matrix()\n try:\n i = na.identity(3)\n \n self.d124 = i.copy()\n self.ds124 = na.zeros(124,na.float64)\n \n for k in range(1,124):\n self.d124 = na.concatenate((self.d124,i))\n# print len(self.d124)\n count = 0\n a = []\n for k in range(-2,3):\n for j in range(-2,3):\n for i in range(-2,3):\n if( i != 0 or j != 0 or k != 0 ):\n self.ds124[count] = math.sqrt(i**2+j**2+k**2)\n count += 1\n a.append(i)\n a.append(j)\n a.append(k)\n# print len(a)\n a = na.reshape(na.array(a),(372,1))\n# print len(self.d124)\n self.d124 = na.concatenate((self.d124,a),axis=1)\n except Exception as error:\n print(\"failed in get5x5matrix(): \", error)","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[1, 1]=c\n self.matrix[1, 2]=s\n self.matrix[2, 1]=-s\n self.matrix[2, 2]=c\n return self.matrix","def build_stoichiometric_matrix(incidence_matrix, complexes_matrix):\n\n #@ is matrix multiplication\n\n #print(\"complexes matrix\")\n\n #This is matrix N in toric paper\n return complexes_matrix.transpose() @ incidence_matrix","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[2, 2]=c\n self.matrix[2, 0]=s\n self.matrix[0, 2]=-s\n self.matrix[0, 0]=c\n return self.matrix","def current_state(self):\n return self.matrix\n #return tuple([tuple(i) for i in self.matrix]) # + [(self.rows, self.cols)])","def process_matrix(row_count, column_count, operator):\n\n result = []\n for i in range(row_count):\n row = []\n for j in range(column_count):\n row.append(operator(i, j))\n result.append(row)\n\n return result","def jmat(ind: int):\n return _jm[ind - 1]","def _calc_matrix(self):\n\t\tz = self.zoom\n\t\talloc = self.allocation\n\t\tif self.image:\n\t\t\tiw, ih = self.image.get_width(), self.image.get_height()\n\t\telse:\n\t\t\tiw, ih = 0, 0\n#\t\tif __debug__: print self._vadj.lower, self._vadj.value, self._vadj.upper\n\t\t\n\t\ti2w = cairo.Matrix(\n\t\t\tz,0,\n\t\t\t0,z,\n\t\t\t-self._hadj.value if alloc.width < iw*z else (alloc.width - iw*z)/2, \n\t\t\t-self._vadj.value if alloc.height < ih*z else (alloc.height - ih*z)/2,\n\t\t\t)\n\t\t\n\t\tself._i2w_matrix = i2w\n\t\t\n\t\tw2i = cairo.Matrix(*i2w) #copy\n\t\tw2i.invert()\n\t\tself._w2i_matrix = w2i","def transpose(m):\n\n pass","def identity_matrix():\n return numpy.identity(4)","def matrix_table(matrix):\r\n result =\"<table id='matrix_result'>\"\r\n for line in range(len(matrix)):\r\n result += \"<tr>\"\r\n for column in range(len(matrix)):\r\n result += \"<td>\" + str(matrix[line][column]) + \"</td>\"\r\n result += \"</tr>\"\r\n result += \"</table>\"\r\n return result","def Matrix(row, col, val=0):\n\treturn [[val for _j in xrange(col)] for _i in xrange(row)]","def clone_matrix(mat):\n return [[x for x in row] for row in mat]","def identity_matrix():\r\n return numpy.identity(4)","def getMatrix(self, frame):\n radian=np.radians(self.getValue(frame))\n c=np.cos(radian)\n s=np.sin(radian)\n self.matrix[0, 0]=c\n self.matrix[0, 1]=s\n self.matrix[1, 0]=-s\n self.matrix[1, 1]=c\n return self.matrix","def I(n):\n identity = Matrix(n,n)\n print identity.matrix\n index = 0 \n for i in range(identity.nrows):\n for j in range(identity.ncols):\n identity.matrix[i][index] = 1\n index += 1\n\n\n flat = []\n for i in range(identity.nrows):\n for j in range(identity.ncols):\n flat.append(identity.matrix[i][j])\n\n\n return identity","def copy_matrix(matrix):\n import numpy as np\n copy_of_m = np.copy(matrix)\n return copy_of_m","def __rmul__(self, other):\n if isinstance(other, numbers.Number):\n #\n # TODO - your code here\n #\n scaled_matrix = []\n for i in range(self.h):\n temp_row = []\n for j in range(self.w):\n temp_row.append(other * self.g[i][j])\n scaled_matrix.append(temp_row)\n return Matrix(scaled_matrix)\n # TODO - your code here","def make_matrix(rows, columns):\n\tmatrix = []\n\tfor row in range(rows):\n\t\tmatrix += [[0] * columns]\n\t\t\n\treturn matrix","def turn_matrix(self, matrix):\n if matrix[0][0] == 1:\n tab = [[(matrix[-j - 1][i] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\n elif matrix[0][1] == 1:\n tab = [[(matrix[i][j] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\n elif matrix[1][0] == 1:\n tab = [[(matrix[i][j] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\n else:\n tab = [[(matrix[j][-1 - i] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\n return tab","def __init__(self, M,):\n #transpose because we are given column vectors not row vectors\n self.M = np.transpose(np.matrix(M))","def matCopy(mat):\n shape=matShape(mat)\n return [[matGet(mat,x,y) for y in range(shape[1])] \\\n for x in range(shape[0])]","def T(self):\n # TODO - your code here\n matrix_transpose = [];\n \n for j in range(self.w):\n matrix_transpose.append(self.get_column(j));\n \n return Matrix(matrix_transpose);","def transform_mat(matrix):\n delta = 1e-5\n matrix = matrix + delta\n return matrix","def _make_random_matrix(self, n_components, n_features):","def return_adjacencyMatrix(self):\n return self.__mat","def get_direction_matrix(self) -> int:","def gram_matrix(features, normalize=True):\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\n\n pass\n\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****","def upload_matrix(row_names, col_names, matrix):","def _makeWaMatrix_(self, wa, nRow, nCol):\n\t\t#print nRow, nCol\n\t\t#print wa\n\t\t#print\n\t\twaMatrix = [[0 for j in xrange(nCol)] for i in xrange(nRow)]\n\t\tfor a in wa: \n\t\t\tfor i in a[0]:\n\t\t\t\tfor j in a[1]:\n\t\t\t\t\twaMatrix[i][j] = 1\n\t\treturn waMatrix","def doubleMatrix(mat):\n\n dims = mat.shape\n myZero = np.zeros(dims)\n ans = np.block([[mat, myZero], [myZero, mat]])\n return ans","def from_matrix(matrix: types.Matrix) -> \"MatrixLieGroup\":","def matT(mat):\n shape=matShape(mat)\n return [[matGet(mat,y,x) for y in range(shape[0])] \\\n for x in range(shape[1])]","def matrix(self):\n return self.composition(self._parent.edge_to_matrix)","def array(self):","def generate_matrix(doc):\n bv_stru=doc['bv_structure']\n lattice=bv_stru['lattice']\n l_matrix=lattice['matrix']\n #manipulate over lattice matrix\n mat_list=[]\n for list_m in l_matrix:\n str_null=''\n for items in list_m:\n items=Decimal(items).quantize(Decimal('0.000000'))\n str_null=str_null+str(items)+' '\n str_null=str_null[:len(str_null)-1]\n mat_list.append(str_null)\n return mat_list","def gen_matrix(e):\n\tif e < 1:\n\t\treturn None\n\tm_list = [[[1, 2], [3, 0]]]\n\t_b = m_list[0]\n\tfor n in xrange(1, e):\n\t\tm = m_list[n - 1]\n\t\tm_list.append(\n\t\t\t[\n\t\t\t\t[4 * i + _b[0][0] for i in m[0]] + [4 * i + _b[0][1] for i in m[0]],\n\t\t\t\t[4 * i + _b[0][0] for i in m[1]] + [4 * i + _b[0][1] for i in m[1]],\n\t\t\t\t[4 * i + _b[1][0] for i in m[0]] + [4 * i + _b[1][1] for i in m[0]],\n\t\t\t\t[4 * i + _b[1][0] for i in m[1]] + [4 * i + _b[1][1] for i in m[1]],\n\t\t\t]\n\t\t)\n\treturn m_list","def get_l(m):\n L = m.copy()\n for i in range(L.shape[0]):\n L[i, i] = 1\n L[i, i+1:] = 0\n return np.matrix(L)","def matrix(self):\n return self._translation","def to_mat(self) -> np.matrix:\n raise NotImplementedError","def __repr__(self):\n return repr(self.matrix)","def traspo(*args):\r\n filas,columnas = len(args),len(args[0])\r\n matriz_r = []\r\n for i in range(0,filas):\r\n lista_aux = []\r\n for j in range(0,columnas):\r\n lista_aux.append(args[j][i])\r\n matriz_r.append(lista_aux)\r\n return matriz_r","def set_up_matrix():\n matrix= []\n row= \"1 9 3 4 5\"\n row= to_int(row)\n matrix.append(row)\n row= \"2 30 4 5 6\"\n row= to_int(row)\n matrix.append(row)\n row= \"3 8 5 6 7\"\n row= to_int(row)\n matrix.append(row)\n row= \"4 5 6 7 8\"\n row= to_int(row)\n matrix.append(row)\n row= \"5 6 7 8 9\"\n row= to_int(row)\n matrix.append(row)\n return matrix","def set_make_matrix(function: Callable) -> None:\n utilities.make_matrix = function","def dup_matrix(self):\n maxtrixcalc = importr('matrixcalc') # load matrixcalc library\n rscript = 'D.matrix( )'.replace(' ', str(self.k)) # generate R script\n rmatrix = robjects.r(rscript) # run R script\n dup_mat = np.array(rmatrix) # convert to ndarray\n return dup_mat # ndarray","def make_matrix(rows, cols, value=0):\n return Matrix([[value for i in range(cols)] for j in range(rows)])","def build_augmented_matrix(self):\r\n for row in range(self.SIZE):\r\n self.matrix[row].append(self.result[row])","def make_matrix():\n\n # this imports category, category, data, text, pptx_data\n\n if use_test_data:\n # make a test matrix using create_test_matrix\n m = matrixfuncs.create_test_matrix()\n\n else:\n # make a matrix by connecting to Slides! and connecting to a data\n # table.\n import transformations.utils.slidesconf as slidesconf\n from Forgetdata.Matrix import ConnectionDefinition\n conn = ConnectionDefinition()\n conn.ConnectionString = mtd_filepath # set at top of file\n conn.Name = \"Test\"\n conn.Provider = \"SPSS MTD File\"\n liveConnection = slidesconf.connect(conn.ConnectionString,\n name=conn.Name,\n provider_name=conn.Provider)\n\n m = liveConnection[table_selected]\n\n x = tr.MatrixManipulator(m)\n matrixfuncs.printMatrix(m)\n\n for c in m[0]:\n c.TopMember.Label = c.TopMember.Label.encode('ascii', 'ignore')\n\n return m, x","def __mul__(self,m):\n if type(m) != Matrix:\n raise TypeError('The second argument is not a matrix lol')\n if self.ncols != m.nrows:\n raise ValueError('matrix dot argument has incorrect number of rows')\n new = Matrix(self.nrows,m.ncols)\n columns = m.getCols()\n rowindex = 0\n colindex = 0 \n for row in self.matrix:\n colindex = 0 \n for col in columns:\n summ = 0\n for i,j in zip(row,col):\n summ+= i*j \n new.matrix[rowindex][colindex] = summ\n print new.matrix\n colindex += 1 \n rowindex+=1\n return new","def mutate_matrix(matrix):\n L = len(matrix)\n r_i = random.randrange(L)\n r_j = random.randrange(4)\n r = random.gauss(0,1)\n return [[matrix[i][j]+r*(i==r_i)*(j==r_j)\n for j in range(4)] for i in range(L)]","def matrix(self) -> sympy.Matrix:\n raise NotImplementedError()","def get_matrix_a(args):\n\treturn [[np.power(arg, k) for k in xrange(len(args))] for arg in args]","def c_matrix(x1,x2,x3):\n\tC = np.array([\t[\t2*(x2-x1), \t\t(x2-x1), \t\t\t0\t\t\t], \\\n\t\t\t\t\t[\t(x2-x1), \t\t2*(x3-x1), \t\t(x3-x2)\t\t], \\\n\t\t\t\t\t[\t0,\t\t\t\t(x3-x2),\t\t2*(x3-x2)\t] \t], \\\n\t\t\t\t\tfloat)\n\treturn(C)","def init_output_mat(self, y_list):","def Omat(self):\n if self.standard:\n return np.matrix(((0, -1, 0), (0, 0, 1), (-1, 0, 0)))\n else:\n return np.matrix(((0, 0, 1), (0, 1, 0), (-1, 0, 0)))"],"string":"[\n \"def process(self, mat):\",\n \"def lap_mat(self):\",\n \"def matrix_add():\",\n \"def as_matrix(self) -> types.Matrix:\",\n \"def getMatrix(self) -> CMatrix4:\\n ...\",\n \"def get_stain_matrix(I):\",\n \"def CreateMatrix(self) -> BaseMatrix:\",\n \"def CreateMatrix(self) -> BaseMatrix:\",\n \"def T(self) -> BaseMatrix:\",\n \"def T(self) -> BaseMatrix:\",\n \"def _matrix(*params):\\n raise NotImplementedError\",\n \"def T(self):\\n # TODO - your code here\\n transpose = []\\n for col in range(self.w):\\n new_row = []\\n for row in range(self.h):\\n new_row.append(self.g[row][col])\\n transpose.append(new_row)\\n return Matrix(transpose)\\n # TODO - your code here\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 1]=self.getValue(frame)\\n return self.matrix\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 2]=self.getValue(frame)\\n return self.matrix\",\n \"def getMatrix(self, frame):\\n self.matrix[3, 0]=self.getValue(frame)\\n return self.matrix\",\n \"def __init__(self, matrix):\\n self.matrix = matrix\",\n \"def get_score_matrix(self) -> int:\",\n \"def Matrix(arg0: List[List[complex]]) -> ngsolve.bla.MatrixC:\",\n \"def initial_processing(mat):\\n\\tflat_arr = mat.ravel()\\n\\treturn mat.shape, np.matrix(flat_arr)\",\n \"def test_convert_matrix():\\n foo = Value(matrices=[[1.0, 2.0], [-2.0, 1.0]])\\n assert foo.matrices[0][0][1].value == 2.0\\n assert foo.matrices[0][1][0].value == -2.0\",\n \"def get_matrix(self):\\n return self._matrix[:3, :]\",\n \"def wrapDBMatrix(self,mat):\\n return mat.todense()\",\n \"def amat(M):\\n aa, _ = a_matrix(M)\\n return aa\",\n \"def matNew(mat):\\n return matCopy(mat)\",\n \"def __pos__(self):\\r\\n return mat4(map(lambda x: +x, self.mlist))\",\n \"def take_matrix(self):\\n matrix = aux.matrix(self.take_vec(), self.order)\\n\\n return matrix\",\n \"def matrix(self):\\n return self._matrix(*self.parameters)\",\n \"def update(mat) -> np.ndarray:\\n return mat\",\n \"def __neg__(self):\\n #\\n # TODO - your code here\\n #\\n matrix_neg = []\\n for i in range(self.h):\\n row = []\\n for j in range(self.w):\\n row.append(0-self.g[i][j])\\n matrix_neg.append(row)\\n return Matrix(matrix_neg)\\n # TODO - your code here\",\n \"def writeMatrix(self):\\n\\t\\tpass\",\n \"def I_matrix(api_calls, invokes):\\n i = len(api_calls)\\n j = len(api_calls)\\n matrix = lil_matrix((i,j), dtype=np.int8)\\n for invoke in invokes:\\n matrix[invoke] = 1\\n matrix[(invoke[1],invoke[0])] = 1\\n return matrix\",\n \"def matrix(self):\\n return self._matrix\",\n \"def matrix(self):\\n return self._matrix\",\n \"def __neg__(self):\\n # \\n # TODO - your code here\\n #\\n result = [];\\n for row in self.g:\\n result.append([-1*n for n in row]);\\n \\n return Matrix(result);\",\n \"def interpolate_matrix(matrix):\",\n \"def _matrix_(self, R=None):\\n return self.adjacency_matrix()\",\n \"def to_s_matrix(w,v):\\n pass\",\n \"def H(self) -> BaseMatrix:\",\n \"def H(self) -> BaseMatrix:\",\n \"def transform(self, x: Array2D) -> Array2D:\",\n \"def __init__(self, matrix):\\n if len(matrix) == 0 or len(matrix[0]) == 0:\\n return\\n self.matrix_sum = [[matrix[r][c] for c in range(len(matrix[0]))] for r in range(len(matrix))]\\n for r in range(1, len(matrix)):\\n self.matrix_sum[r][0] = self.matrix_sum[r-1][0] + matrix[r][0] \\n for c in range(1, len(matrix[0])):\\n self.matrix_sum[0][c] = self.matrix_sum[0][c-1] + matrix[0][c]\\n \\n for r in range(1, len(matrix)):\\n for c in range(1, len(matrix[0])):\\n self.matrix_sum[r][c] = self.matrix_sum[r][c-1] + self.matrix_sum[r-1][c] + matrix[r][c] - self.matrix_sum[r-1][c-1]\",\n \"def matGet(mat, r, c):\\n return mat[r][c]\",\n \"def _matrix_(self, R):\\n from sage.matrix.all import matrix\\n matlab = self.parent()\\n entries = matlab.strip_answer(matlab.eval(\\\"mat2str({0})\\\".format(self.name())))\\n entries = entries.strip()[1:-1].replace(';', ' ')\\n entries = [R(_) for _ in entries.split(' ')]\\n nrows, ncols = map(int, str(self.size()).strip().split())\\n m = matrix(R, nrows, ncols, entries)\\n return m\",\n \"def translation_from_matrix(matrix):\\r\\n return numpy.array(matrix, copy=False)[:3, 3].copy()\",\n \"def _buildMatrix(self, SparseMatrix, Ncells, MaxFaces, coeff):\\n return (0, 0)\",\n \"def __mul__(self, other):\\n #\\n # TODO - your code here\\n #\\n final_matrix = []\\n for i in range(self.h):\\n temp_row = []\\n for j in range(other.w):\\n # take dot-product of row of\\n # matrix in 1st arg with col of\\n # matrix in 2nd arg\\n temp_row.append(dot_product(get_row(self.g, i), get_col(other.g, j)))\\n final_matrix.append(temp_row)\\n return Matrix(final_matrix)\\n # TODO - your code here\",\n \"def get5x5matrix(self): #modified from nxvasc get3x3matrix()\\n try:\\n i = na.identity(3)\\n \\n self.d124 = i.copy()\\n self.ds124 = na.zeros(124,na.float64)\\n \\n for k in range(1,124):\\n self.d124 = na.concatenate((self.d124,i))\\n# print len(self.d124)\\n count = 0\\n a = []\\n for k in range(-2,3):\\n for j in range(-2,3):\\n for i in range(-2,3):\\n if( i != 0 or j != 0 or k != 0 ):\\n self.ds124[count] = math.sqrt(i**2+j**2+k**2)\\n count += 1\\n a.append(i)\\n a.append(j)\\n a.append(k)\\n# print len(a)\\n a = na.reshape(na.array(a),(372,1))\\n# print len(self.d124)\\n self.d124 = na.concatenate((self.d124,a),axis=1)\\n except Exception as error:\\n print(\\\"failed in get5x5matrix(): \\\", error)\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[1, 1]=c\\n self.matrix[1, 2]=s\\n self.matrix[2, 1]=-s\\n self.matrix[2, 2]=c\\n return self.matrix\",\n \"def build_stoichiometric_matrix(incidence_matrix, complexes_matrix):\\n\\n #@ is matrix multiplication\\n\\n #print(\\\"complexes matrix\\\")\\n\\n #This is matrix N in toric paper\\n return complexes_matrix.transpose() @ incidence_matrix\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[2, 2]=c\\n self.matrix[2, 0]=s\\n self.matrix[0, 2]=-s\\n self.matrix[0, 0]=c\\n return self.matrix\",\n \"def current_state(self):\\n return self.matrix\\n #return tuple([tuple(i) for i in self.matrix]) # + [(self.rows, self.cols)])\",\n \"def process_matrix(row_count, column_count, operator):\\n\\n result = []\\n for i in range(row_count):\\n row = []\\n for j in range(column_count):\\n row.append(operator(i, j))\\n result.append(row)\\n\\n return result\",\n \"def jmat(ind: int):\\n return _jm[ind - 1]\",\n \"def _calc_matrix(self):\\n\\t\\tz = self.zoom\\n\\t\\talloc = self.allocation\\n\\t\\tif self.image:\\n\\t\\t\\tiw, ih = self.image.get_width(), self.image.get_height()\\n\\t\\telse:\\n\\t\\t\\tiw, ih = 0, 0\\n#\\t\\tif __debug__: print self._vadj.lower, self._vadj.value, self._vadj.upper\\n\\t\\t\\n\\t\\ti2w = cairo.Matrix(\\n\\t\\t\\tz,0,\\n\\t\\t\\t0,z,\\n\\t\\t\\t-self._hadj.value if alloc.width < iw*z else (alloc.width - iw*z)/2, \\n\\t\\t\\t-self._vadj.value if alloc.height < ih*z else (alloc.height - ih*z)/2,\\n\\t\\t\\t)\\n\\t\\t\\n\\t\\tself._i2w_matrix = i2w\\n\\t\\t\\n\\t\\tw2i = cairo.Matrix(*i2w) #copy\\n\\t\\tw2i.invert()\\n\\t\\tself._w2i_matrix = w2i\",\n \"def transpose(m):\\n\\n pass\",\n \"def identity_matrix():\\n return numpy.identity(4)\",\n \"def matrix_table(matrix):\\r\\n result =\\\"<table id='matrix_result'>\\\"\\r\\n for line in range(len(matrix)):\\r\\n result += \\\"<tr>\\\"\\r\\n for column in range(len(matrix)):\\r\\n result += \\\"<td>\\\" + str(matrix[line][column]) + \\\"</td>\\\"\\r\\n result += \\\"</tr>\\\"\\r\\n result += \\\"</table>\\\"\\r\\n return result\",\n \"def Matrix(row, col, val=0):\\n\\treturn [[val for _j in xrange(col)] for _i in xrange(row)]\",\n \"def clone_matrix(mat):\\n return [[x for x in row] for row in mat]\",\n \"def identity_matrix():\\r\\n return numpy.identity(4)\",\n \"def getMatrix(self, frame):\\n radian=np.radians(self.getValue(frame))\\n c=np.cos(radian)\\n s=np.sin(radian)\\n self.matrix[0, 0]=c\\n self.matrix[0, 1]=s\\n self.matrix[1, 0]=-s\\n self.matrix[1, 1]=c\\n return self.matrix\",\n \"def I(n):\\n identity = Matrix(n,n)\\n print identity.matrix\\n index = 0 \\n for i in range(identity.nrows):\\n for j in range(identity.ncols):\\n identity.matrix[i][index] = 1\\n index += 1\\n\\n\\n flat = []\\n for i in range(identity.nrows):\\n for j in range(identity.ncols):\\n flat.append(identity.matrix[i][j])\\n\\n\\n return identity\",\n \"def copy_matrix(matrix):\\n import numpy as np\\n copy_of_m = np.copy(matrix)\\n return copy_of_m\",\n \"def __rmul__(self, other):\\n if isinstance(other, numbers.Number):\\n #\\n # TODO - your code here\\n #\\n scaled_matrix = []\\n for i in range(self.h):\\n temp_row = []\\n for j in range(self.w):\\n temp_row.append(other * self.g[i][j])\\n scaled_matrix.append(temp_row)\\n return Matrix(scaled_matrix)\\n # TODO - your code here\",\n \"def make_matrix(rows, columns):\\n\\tmatrix = []\\n\\tfor row in range(rows):\\n\\t\\tmatrix += [[0] * columns]\\n\\t\\t\\n\\treturn matrix\",\n \"def turn_matrix(self, matrix):\\n if matrix[0][0] == 1:\\n tab = [[(matrix[-j - 1][i] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\\n elif matrix[0][1] == 1:\\n tab = [[(matrix[i][j] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\\n elif matrix[1][0] == 1:\\n tab = [[(matrix[i][j] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\\n else:\\n tab = [[(matrix[j][-1 - i] + 1) % 2 for j in range(self.size)] for i in range(self.size)]\\n return tab\",\n \"def __init__(self, M,):\\n #transpose because we are given column vectors not row vectors\\n self.M = np.transpose(np.matrix(M))\",\n \"def matCopy(mat):\\n shape=matShape(mat)\\n return [[matGet(mat,x,y) for y in range(shape[1])] \\\\\\n for x in range(shape[0])]\",\n \"def T(self):\\n # TODO - your code here\\n matrix_transpose = [];\\n \\n for j in range(self.w):\\n matrix_transpose.append(self.get_column(j));\\n \\n return Matrix(matrix_transpose);\",\n \"def transform_mat(matrix):\\n delta = 1e-5\\n matrix = matrix + delta\\n return matrix\",\n \"def _make_random_matrix(self, n_components, n_features):\",\n \"def return_adjacencyMatrix(self):\\n return self.__mat\",\n \"def get_direction_matrix(self) -> int:\",\n \"def gram_matrix(features, normalize=True):\\n # *****START OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\\n\\n pass\\n\\n # *****END OF YOUR CODE (DO NOT DELETE/MODIFY THIS LINE)*****\",\n \"def upload_matrix(row_names, col_names, matrix):\",\n \"def _makeWaMatrix_(self, wa, nRow, nCol):\\n\\t\\t#print nRow, nCol\\n\\t\\t#print wa\\n\\t\\t#print\\n\\t\\twaMatrix = [[0 for j in xrange(nCol)] for i in xrange(nRow)]\\n\\t\\tfor a in wa: \\n\\t\\t\\tfor i in a[0]:\\n\\t\\t\\t\\tfor j in a[1]:\\n\\t\\t\\t\\t\\twaMatrix[i][j] = 1\\n\\t\\treturn waMatrix\",\n \"def doubleMatrix(mat):\\n\\n dims = mat.shape\\n myZero = np.zeros(dims)\\n ans = np.block([[mat, myZero], [myZero, mat]])\\n return ans\",\n \"def from_matrix(matrix: types.Matrix) -> \\\"MatrixLieGroup\\\":\",\n \"def matT(mat):\\n shape=matShape(mat)\\n return [[matGet(mat,y,x) for y in range(shape[0])] \\\\\\n for x in range(shape[1])]\",\n \"def matrix(self):\\n return self.composition(self._parent.edge_to_matrix)\",\n \"def array(self):\",\n \"def generate_matrix(doc):\\n bv_stru=doc['bv_structure']\\n lattice=bv_stru['lattice']\\n l_matrix=lattice['matrix']\\n #manipulate over lattice matrix\\n mat_list=[]\\n for list_m in l_matrix:\\n str_null=''\\n for items in list_m:\\n items=Decimal(items).quantize(Decimal('0.000000'))\\n str_null=str_null+str(items)+' '\\n str_null=str_null[:len(str_null)-1]\\n mat_list.append(str_null)\\n return mat_list\",\n \"def gen_matrix(e):\\n\\tif e < 1:\\n\\t\\treturn None\\n\\tm_list = [[[1, 2], [3, 0]]]\\n\\t_b = m_list[0]\\n\\tfor n in xrange(1, e):\\n\\t\\tm = m_list[n - 1]\\n\\t\\tm_list.append(\\n\\t\\t\\t[\\n\\t\\t\\t\\t[4 * i + _b[0][0] for i in m[0]] + [4 * i + _b[0][1] for i in m[0]],\\n\\t\\t\\t\\t[4 * i + _b[0][0] for i in m[1]] + [4 * i + _b[0][1] for i in m[1]],\\n\\t\\t\\t\\t[4 * i + _b[1][0] for i in m[0]] + [4 * i + _b[1][1] for i in m[0]],\\n\\t\\t\\t\\t[4 * i + _b[1][0] for i in m[1]] + [4 * i + _b[1][1] for i in m[1]],\\n\\t\\t\\t]\\n\\t\\t)\\n\\treturn m_list\",\n \"def get_l(m):\\n L = m.copy()\\n for i in range(L.shape[0]):\\n L[i, i] = 1\\n L[i, i+1:] = 0\\n return np.matrix(L)\",\n \"def matrix(self):\\n return self._translation\",\n \"def to_mat(self) -> np.matrix:\\n raise NotImplementedError\",\n \"def __repr__(self):\\n return repr(self.matrix)\",\n \"def traspo(*args):\\r\\n filas,columnas = len(args),len(args[0])\\r\\n matriz_r = []\\r\\n for i in range(0,filas):\\r\\n lista_aux = []\\r\\n for j in range(0,columnas):\\r\\n lista_aux.append(args[j][i])\\r\\n matriz_r.append(lista_aux)\\r\\n return matriz_r\",\n \"def set_up_matrix():\\n matrix= []\\n row= \\\"1 9 3 4 5\\\"\\n row= to_int(row)\\n matrix.append(row)\\n row= \\\"2 30 4 5 6\\\"\\n row= to_int(row)\\n matrix.append(row)\\n row= \\\"3 8 5 6 7\\\"\\n row= to_int(row)\\n matrix.append(row)\\n row= \\\"4 5 6 7 8\\\"\\n row= to_int(row)\\n matrix.append(row)\\n row= \\\"5 6 7 8 9\\\"\\n row= to_int(row)\\n matrix.append(row)\\n return matrix\",\n \"def set_make_matrix(function: Callable) -> None:\\n utilities.make_matrix = function\",\n \"def dup_matrix(self):\\n maxtrixcalc = importr('matrixcalc') # load matrixcalc library\\n rscript = 'D.matrix( )'.replace(' ', str(self.k)) # generate R script\\n rmatrix = robjects.r(rscript) # run R script\\n dup_mat = np.array(rmatrix) # convert to ndarray\\n return dup_mat # ndarray\",\n \"def make_matrix(rows, cols, value=0):\\n return Matrix([[value for i in range(cols)] for j in range(rows)])\",\n \"def build_augmented_matrix(self):\\r\\n for row in range(self.SIZE):\\r\\n self.matrix[row].append(self.result[row])\",\n \"def make_matrix():\\n\\n # this imports category, category, data, text, pptx_data\\n\\n if use_test_data:\\n # make a test matrix using create_test_matrix\\n m = matrixfuncs.create_test_matrix()\\n\\n else:\\n # make a matrix by connecting to Slides! and connecting to a data\\n # table.\\n import transformations.utils.slidesconf as slidesconf\\n from Forgetdata.Matrix import ConnectionDefinition\\n conn = ConnectionDefinition()\\n conn.ConnectionString = mtd_filepath # set at top of file\\n conn.Name = \\\"Test\\\"\\n conn.Provider = \\\"SPSS MTD File\\\"\\n liveConnection = slidesconf.connect(conn.ConnectionString,\\n name=conn.Name,\\n provider_name=conn.Provider)\\n\\n m = liveConnection[table_selected]\\n\\n x = tr.MatrixManipulator(m)\\n matrixfuncs.printMatrix(m)\\n\\n for c in m[0]:\\n c.TopMember.Label = c.TopMember.Label.encode('ascii', 'ignore')\\n\\n return m, x\",\n \"def __mul__(self,m):\\n if type(m) != Matrix:\\n raise TypeError('The second argument is not a matrix lol')\\n if self.ncols != m.nrows:\\n raise ValueError('matrix dot argument has incorrect number of rows')\\n new = Matrix(self.nrows,m.ncols)\\n columns = m.getCols()\\n rowindex = 0\\n colindex = 0 \\n for row in self.matrix:\\n colindex = 0 \\n for col in columns:\\n summ = 0\\n for i,j in zip(row,col):\\n summ+= i*j \\n new.matrix[rowindex][colindex] = summ\\n print new.matrix\\n colindex += 1 \\n rowindex+=1\\n return new\",\n \"def mutate_matrix(matrix):\\n L = len(matrix)\\n r_i = random.randrange(L)\\n r_j = random.randrange(4)\\n r = random.gauss(0,1)\\n return [[matrix[i][j]+r*(i==r_i)*(j==r_j)\\n for j in range(4)] for i in range(L)]\",\n \"def matrix(self) -> sympy.Matrix:\\n raise NotImplementedError()\",\n \"def get_matrix_a(args):\\n\\treturn [[np.power(arg, k) for k in xrange(len(args))] for arg in args]\",\n \"def c_matrix(x1,x2,x3):\\n\\tC = np.array([\\t[\\t2*(x2-x1), \\t\\t(x2-x1), \\t\\t\\t0\\t\\t\\t], \\\\\\n\\t\\t\\t\\t\\t[\\t(x2-x1), \\t\\t2*(x3-x1), \\t\\t(x3-x2)\\t\\t], \\\\\\n\\t\\t\\t\\t\\t[\\t0,\\t\\t\\t\\t(x3-x2),\\t\\t2*(x3-x2)\\t] \\t], \\\\\\n\\t\\t\\t\\t\\tfloat)\\n\\treturn(C)\",\n \"def init_output_mat(self, y_list):\",\n \"def Omat(self):\\n if self.standard:\\n return np.matrix(((0, -1, 0), (0, 0, 1), (-1, 0, 0)))\\n else:\\n return np.matrix(((0, 0, 1), (0, 1, 0), (-1, 0, 0)))\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.73965985","0.72873676","0.7231809","0.72027314","0.68871105","0.68203425","0.6809076","0.6809076","0.6786066","0.6786066","0.6742204","0.67335075","0.6574923","0.65624046","0.65345794","0.65269136","0.65112585","0.6453542","0.6378975","0.6354362","0.6304048","0.62946355","0.6291557","0.6287873","0.62820816","0.6269495","0.6227879","0.6217925","0.6217253","0.61279845","0.61259645","0.61233145","0.61233145","0.61164194","0.606347","0.6058692","0.6046673","0.6036499","0.6036499","0.6032466","0.6028111","0.60249555","0.6002468","0.6002382","0.6001254","0.5992694","0.5990698","0.59848833","0.59832823","0.5978594","0.59776974","0.59551257","0.5950289","0.5935993","0.59337926","0.59311897","0.59306395","0.592723","0.58990455","0.58980334","0.5897465","0.589089","0.58863974","0.58793956","0.5874332","0.58700913","0.5848702","0.5847536","0.58466226","0.58285534","0.58271724","0.5826325","0.5825375","0.5820903","0.58145046","0.58137506","0.58130306","0.58107644","0.58101875","0.58090085","0.58063966","0.5804649","0.58021796","0.5797711","0.5794554","0.5783206","0.57814074","0.57804143","0.57745516","0.5771401","0.5761957","0.57614183","0.5759562","0.57575905","0.5755906","0.5746787","0.57450926","0.5737016","0.57368","0.5724077","0.57166916"],"string":"[\n \"0.73965985\",\n \"0.72873676\",\n \"0.7231809\",\n \"0.72027314\",\n \"0.68871105\",\n \"0.68203425\",\n \"0.6809076\",\n \"0.6809076\",\n \"0.6786066\",\n \"0.6786066\",\n \"0.6742204\",\n \"0.67335075\",\n \"0.6574923\",\n \"0.65624046\",\n \"0.65345794\",\n \"0.65269136\",\n \"0.65112585\",\n \"0.6453542\",\n \"0.6378975\",\n \"0.6354362\",\n \"0.6304048\",\n \"0.62946355\",\n \"0.6291557\",\n \"0.6287873\",\n \"0.62820816\",\n \"0.6269495\",\n \"0.6227879\",\n \"0.6217925\",\n \"0.6217253\",\n \"0.61279845\",\n \"0.61259645\",\n \"0.61233145\",\n \"0.61233145\",\n \"0.61164194\",\n \"0.606347\",\n \"0.6058692\",\n \"0.6046673\",\n \"0.6036499\",\n \"0.6036499\",\n \"0.6032466\",\n \"0.6028111\",\n \"0.60249555\",\n \"0.6002468\",\n \"0.6002382\",\n \"0.6001254\",\n \"0.5992694\",\n \"0.5990698\",\n \"0.59848833\",\n \"0.59832823\",\n \"0.5978594\",\n \"0.59776974\",\n \"0.59551257\",\n \"0.5950289\",\n \"0.5935993\",\n \"0.59337926\",\n \"0.59311897\",\n \"0.59306395\",\n \"0.592723\",\n \"0.58990455\",\n \"0.58980334\",\n \"0.5897465\",\n \"0.589089\",\n \"0.58863974\",\n \"0.58793956\",\n \"0.5874332\",\n \"0.58700913\",\n \"0.5848702\",\n \"0.5847536\",\n \"0.58466226\",\n \"0.58285534\",\n \"0.58271724\",\n \"0.5826325\",\n \"0.5825375\",\n \"0.5820903\",\n \"0.58145046\",\n \"0.58137506\",\n \"0.58130306\",\n \"0.58107644\",\n \"0.58101875\",\n \"0.58090085\",\n \"0.58063966\",\n \"0.5804649\",\n \"0.58021796\",\n \"0.5797711\",\n \"0.5794554\",\n \"0.5783206\",\n \"0.57814074\",\n \"0.57804143\",\n \"0.57745516\",\n \"0.5771401\",\n \"0.5761957\",\n \"0.57614183\",\n \"0.5759562\",\n \"0.57575905\",\n \"0.5755906\",\n \"0.5746787\",\n \"0.57450926\",\n \"0.5737016\",\n \"0.57368\",\n \"0.5724077\",\n \"0.57166916\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.0"},"document_rank":{"kind":"string","value":"-1"}}},{"rowIdx":80899,"cells":{"query":{"kind":"string","value":"Generates the reservoir input weight matrix This method assigns the reservoir input weights for later use downstream by the EchoStateNetworkClass."},"document":{"kind":"string","value":"def gen_in_weights(self):\n\n gen = Generator(device = self.device).manual_seed(self.random_seed)\n n, m = self.n_nodes_, self.n_inputs_\n in_w_shape_ = (n, m)\n print('m,n', m,n)\n\n #at the moment all input weight matrices use uniform bias.\n self.bias = rand( n, 1, generator = gen, device = self.device) * 2 - 1\n\n #weights\n if self.input_weight_type_ == \"uniform\":\n self.in_weights = rand((n,m), generator = gen, device = self.device)\n self.in_weights = self.in_weights * 2 - 1\n print('in_weights', self.in_weights.shape)\n\n elif self.input_weight_type_ == \"exponential\":\n printc(\"BUILDING SIGN_\", 'fail')\n sign1 = random_state.choice([-1, 1], size= (in_w_shape_[0], in_w_shape_[1]//2))\n sign2 = random_state.choice([-1, 1], size= (in_w_shape_[0], in_w_shape_[1]//2))\n\n self.sign_dual = (sign1, sign2)\n self.sign = np.concatenate((sign1, sign2), axis = 1)\n\n #regularization\n self.feedback_weights = rand(n, 1, **self.tensorArgs, generator = gen) * 2 - 1\n\n #regularization\n self.noise_z = normal(0, 1, size = (n, m), **self.tensorArgs, generator = gen)"},"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 create_weight_matrices(self):\n rad = 1 / np.sqrt(self.no_of_in_nodes)\n X = truncated_normal(mean=0, \n sd=1, \n low=-rad, \n upp=rad)\n self.wih = X.rvs((self.no_of_hidden_nodes, \n self.no_of_in_nodes))\n rad = 1 / np.sqrt(self.no_of_hidden_nodes)\n X = truncated_normal(mean=0, sd=1, low=-rad, upp=rad)\n self.who = X.rvs((self.no_of_out_nodes, \n self.no_of_hidden_nodes))","def weightGenerate(self):\n\t\tfor i in range(0, self.numberOfInput):\n\t\t\tself.weight.append(random.random()-0.5)","def InitWeights(self):\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\n self.w0 = -1 + 2 * np.random.rand()","def build_layer(self) :\n inputsWithBias = self.input_count + 1\n self.weights = np.random.rand(inputsWithBias, self.node_count)\n self.weights_and_activations = (self.weights, self.activations)","def _create_weights(self):\n\n self.mu_W = tf.get_variable(\n name=\"mu_W\", initializer=tf.random_normal_initializer(),\n shape=[self.rnn_dim, self.z_dim])\n\n self.mu_b = tf.get_variable(\n name=\"mu_b\", initializer=tf.random_normal_initializer(),\n shape=[self.z_dim])\n\n self.log_sig_sq_W = tf.get_variable(\n name=\"log_sig_sq_W\", initializer=tf.random_normal_initializer(),\n shape=[self.rnn_dim, self.z_dim])\n\n self.log_sig_sq_b = tf.get_variable(\n name=\"log_sig_sq_b\", initializer=tf.random_normal_initializer(),\n shape=[self.z_dim])\n \n self.y_W = tf.get_variable(\n name=\"y_W\", initializer=tf.random_normal_initializer(),\n shape=[self.z_dim, self.rnn_dim])\n\n self.y_b = tf.get_variable(\n name=\"y_b\", initializer=tf.random_normal_initializer(),\n shape=[self.rnn_dim])\n \n self.softmax_W = tf.get_variable(\n name=\"softmax_W\", initializer=tf.random_normal_initializer(),\n shape=[self.rnn_dim, self.vocabulary_size])\n \n self.softmax_b = tf.get_variable(\n name=\"softmax_b\", initializer=tf.random_normal_initializer(),\n shape=[self.vocabulary_size])","def _create_weights(self):\n gate_size = self._hidden_size * self._num_gates\n # Compute the shape of weight and bias.\n matrix_shapes, bias_shapes = [], []\n for layer in range(self._num_layers):\n for direction in range(self._num_directions):\n layer_input_size = self._input_size if layer == 0 \\\n else self._hidden_size * self._num_directions\n w_ih_shape = [gate_size, layer_input_size]\n w_hh_shape = [gate_size, self._hidden_size]\n b_ih_shape, b_hh_shape = [gate_size], [gate_size]\n matrix_shapes.extend([w_ih_shape, w_hh_shape])\n bias_shapes.extend([b_ih_shape, b_hh_shape])\n # Create single float32 weights.\n weights_count = 0\n self._weights_shapes = matrix_shapes + bias_shapes\n for shape in self._weights_shapes:\n weights_count += math_util.prod(shape)\n self._weights = Tensor([weights_count])\n self._weights.requires_grad = True","def initWeights(self):\n self.weights = []\n self.bias = []\n for i, dim in enumerate(self.dimensions[1:]):\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\n self.bias.append(np.random.uniform(-1,1,dim))","def init_weights(self, input_size=None, min_w=WEIGHT_MIN,\n max_w=WEIGHT_MAX):\n if input_size is None:\n input_size = self.INPUT_SIZE\n\n # Add a bias weight to each neuron\n weights_per_neuron = input_size + 1\n\n self.weights = np.random.rand(self.size, weights_per_neuron) \\\n * (max_w - min_w) + min_w","def init_weights(self):\n \n self.w = np.random.randn(self.D) / np.sqrt(self.D)","def build(self,input_shape):\n\n self.w = self.add_weight(shape=(input_shape[-1],self.units),\n initializer='random_normal',\n trainable=True)\n self.b = self.add_weight(shape=(self.units,),\n initializer='random_normal',\n trainable=True)","def _initialize_weights(self):\n stddev = 1.0 / math.sqrt(self._hidden_size)\n for layer_id, param_id in itertools.product(\n range(self._num_layers * (self._bidirectional + 1)),\n range(self._num_gates * 2)):\n i = layer_id * 2 + (param_id // self._num_gates)\n j = i + len(self._weights_shapes) // 2\n matrix_shape = self._weights_shapes[i][:]\n bias_shape = self._weights_shapes[j][:]\n matrix_shape[0] //= self._num_gates\n bias_shape[0] //= self._num_gates\n self._set_parameter(\n init_ops.random_uniform(matrix_shape, -stddev, stddev),\n layer_id, param_id, 'matrix')\n self._set_parameter(\n init_ops.random_uniform(bias_shape, -stddev, stddev),\n layer_id, param_id, 'bias')","def _initialize_weights(self):\n pass","def _generate_weights(self):\n weights = [random.uniform(0, 1) for x in range(self.num_weights)]\n return self._normalize_weights(weights)","def __initialize_weights__(num_neurons: int) -> np.ndarray:\n\n weights = np.zeros((num_neurons, num_neurons))\n\n return weights","def _initialize_matrix(self):\n\n try:\n # Grab the weight matrix from weight_matrices.py\n tmp_weight_matrix = copy.copy(weight_matrices.__dict__[self._weight_matrix_name])\n except KeyError:\n\n # Treat this name as a file\n data = open(self._weight_matrix_name).readlines()\n\n # Grab alphabet bits from top line\n seq = data[0].strip('/n/r').split()\n tmp_weight_matrix = dict([(s,dict([(s,0) for s in seq])) for s in seq])\n \n # Go through each line, populating weight matrix. \n for line in data[1:]:\n line = line.strip('/n/r').split()\n\n a = line[0]\n for j in range(1, len(line)):\n b = seq[j-1]\n tmp_weight_matrix[a][b] = float(line[j])\n\n # Convert tmp_weight_matrix into a numpy array, normalized between 0 \n # and 1.\n keys = list(tmp_weight_matrix.keys())\n self.weight_matrix = np.zeros((len(keys),len(keys)),dtype=float)\n for i, k1 in enumerate(keys):\n a = self._alphabet_dict[k1]\n for j, k2 in enumerate(keys):\n b = self._alphabet_dict[k2]\n self.weight_matrix[a,b] = tmp_weight_matrix[k1][k2]\n\n # Set weights to range from 0 (close) to 1 (far)\n mini = np.min(self.weight_matrix)\n maxi = np.max(self.weight_matrix)\n self.weight_matrix = 1 - (self.weight_matrix - mini)/(maxi - mini)","def _initialize_weights(self, m):\n self.rgen = np.random.RandomState(self.random_state)\n self.w_ = self.rgen.normal(loc=0.0, scale=0.01, size=m)\n self.b_ = 0\n self.w_avg = self.rgen.normal(loc=0.0, scale=0.01, size=m)\n self.b_avg = 0\n\n def net_input(self, X):\n return np.dot(X, self.w_[1:]) + self.w_[0]\n\n def activation(self, X):\n return X\n \n def predict(self, X):\n return np.where(self.net_input(X) >= 0.0, 1, -1)\n \n def get_params(self, deep=True):\n return {\"eta\":self.eta, \"max_iter\":self.max_iter, \"C\":self.C, \"random_state\":self.random_state, \"batch_size\":self.batch_size}\n \n def set_params(self, **parameters):\n for parameter, value in parameters.items():\n setattr(self, parameters, value)\n return self","def _set_weights(self, weights):\r\n self.weights = weights.reshape(self.output_size, self.input_size+1)","def instantiate_weights(self):\n self.product_embeddings = tf.get_variable(\n name='product_embeddings',\n shape=[50000, 300],\n dtype=tf.float32\n )\n self.aisle_embeddings = tf.get_variable(\n name='aisle_embeddings',\n shape=[250, 50],\n dtype=tf.float32\n )\n self.department_embeddings = tf.get_variable(\n name='department_embeddings',\n shape=[50, 10],\n dtype=tf.float32\n )\n self.W_relu = tf.get_variable(\"W_relu\",shape=[670, 30]) #这个参数后续需要自适应\n self.b_relu = tf.get_variable(\"bias_relu\",shape=[30]) \n self.W_projection = tf.get_variable(\"W_projection\",shape=[30, 1]) \n self.b_projection = tf.get_variable(\"bias_projection\",shape=[1])","def random_weights_init(self, data):\n self._check_input_len(data)\n it = nditer(self._activation_map, flags=['multi_index'])\n while not it.finished:\n rand_i = self._random_generator.randint(len(data))\n self._weights[it.multi_index] = data[rand_i]\n it.iternext()","def constructCell():\n\t\tself.weightGenerate()","def init_weights_(self):\n raise NotImplementedError","def initialize_weights(self):\n # compute lmda.\n self.lmda = float(self.c)/float(self.N)\n # bias term. This should not get a regularization penalty.\n self.bias = {}\n # weight vector\n self.w = {}\n # lastW[j] = k, indicates that feature j was last updated at time k.\n self.lastW = {}\n for lbl in self.labels:\n self.bias[lbl] = 0\n self.w[lbl] = {}\n self.lastW[lbl] = {}\n pass","def init_weights(self):\n self._q_neuron.h(self._weights) \n self._q_neuron.x(self._weights)","def build(self, input_shape):\n\n # get shape of input matrix x\n self.num_of_vertices = input_shape[1]\n self.num_of_features = input_shape[2]\n self.num_of_timesteps = input_shape[3]\n #self.W_1.shape = (num_of_timesteps,)\n #self.W_2.shape = (num_of_features, num_of_timesteps)\n #self.W_3.shape = (num_of_features,)\n #self.b_s.shape = (1, num_of_vertices, num_of_vertices)\n #self.V_s.shape = (num_of_vertices, num_of_vertices)\n\n self.w1 = self.add_weight(name='w1', shape=(self.num_of_timesteps, ),\n initializer='glorot_normal', trainable=True)\n self.w2 = self.add_weight(name='w2', shape=(self.num_of_features, self.num_of_timesteps),\n initializer='glorot_normal', trainable=True)\n self.w3 = self.add_weight(name='w3', shape=(self.num_of_features,),\n initializer='glorot_normal', trainable=True)\n self.b = self.add_weight(name='b', shape=(1, self.num_of_vertices, self.num_of_vertices),\n initializer='zeros', trainable=True)\n self.v = self.add_weight(name='v', shape=(self.num_of_vertices, self.num_of_vertices),\n initializer='glorot_normal', trainable=True)\n\n super(Spatial_Attention_layer, self).build(input_shape)","def init_weights(self, dims):\n self.W = np.random.normal(size=dims) * 0.0001","def __init__(self, reservoir, input_weights=None, neuron_type=\"tanh\", \n output_type=\"sigmoid\", init_state=\"zeros\", neuron_pars={}, output_neuron_pars={}):\n\n # Weights\n self.reservoir = reservoir\n self.num_neurons = self.reservoir.shape[0]\n self.input_weights = input_weights\n\n # Set neuron types (reservoir)\n self.neuron_pars = neuron_pars\n self.neuron_type = neuron_type\n if self.neuron_type == \"tanh\":\n self.activation_function = self.tanh\n elif self.neuron_type == \"sigmoid\":\n self.activation_function = partial(self.sigmoid, **neuron_pars)\n elif self.neuron_type == \"RLU\":\n self.activation_function = partial(self.rectified_linear_unit, **neuron_pars)\n elif self.neuron_type == \"heaviside\":\n self.activation_function = partial(self.heaviside, **neuron_pars)\n # Set neuron types (output neuron)\n self.output_type = output_type\n if self.output_type == \"tanh\":\n self.output_function = partial(self.tanh, **output_neuron_pars)\n elif self.output_type == \"sigmoid\":\n self.output_function = partial(self.sigmoid, **output_neuron_pars)\n elif self.output_type == \"identity\":\n self.output_function = partial(self.identity, **output_neuron_pars)\n elif self.output_type == \"heaviside\":\n self.output_function = partial(self.heaviside, **output_neuron_pars)\n\n # Generate initial system state\n self.init_state = init_state\n self.current_state = self.GenerateInitialState(self.init_state)\n self.network_history = [ ]","def init_weights(model):\n ...","def _generate_weighted_matrices(self):\n self.degree_weighted_matrices = dict()\n mes = []\n args = []\n for metaedge, matrix in self.adj_matrices.items():\n mes.append(metaedge)\n args.append({'matrix': matrix, 'w': self.w, 'degree_fwd': self.out_degree[metaedge],\n 'degree_rev': self.in_degree[metaedge]})\n res = parallel_process(array=args, function=mt.weight_by_degree, use_kwargs=True, n_jobs=self.n_jobs,\n front_num=0)\n for metaedge, matrix in zip(mes, res):\n self.degree_weighted_matrices[metaedge] = matrix","def set_output_weights(self, weight_matrix):\n pass","def update_weights(self):\n\t\tpass","def _initialize_weights(self, m):\n self.w_ = np.zeros(1 + m)\n self.w_initialized = True","def _initialize_weights(self, m):\n self.w_ = np.zeros(1 + m)\n self.w_initialized = True","def _initialize_weights(self, m):\n self.w_ = np.zeros(1 + m)\n self.w_initialized = True","def build(self):\n\n self.W = self.init([self.n_atom_input_feat, self.n_output])\n self.b = model_ops.zeros(shape=[\n self.n_output,\n ])\n\n self.trainable_weights = self.W + self.b","def initialize_weights(self, weights_initializer, bias_initializer):\n wshapes = [\n [self.input_size, self.hidden_size[0]],\n [self.hidden_size[0], self.hidden_size[1]],\n [self.hidden_size[1], self.output_size]\n ]\n\n bshapes = [\n [1, self.hidden_size[0]],\n [1, self.hidden_size[1]],\n [1, self.output_size]\n ]\n\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\n\n self.trainable_variables = self.weights + self.biases","def build(self, input_shape):\n assert len(input_shape) == 4\n assert input_shape[1] == input_shape[2]\n self.out_channel = input_shape[3]\n # Create the weight vector\n self.W_shape = (input_shape[1], self.out_dim)\n if self.initial_weights is not None:\n self.set_weights(self.initial_weights)\n del self.initial_weights\n else:\n self.W = self.init(self.W_shape, name='{}_W'.format(self.name))\n self.trainable_weights = [self.W]\n self.built = True","def weighting_calculation(self) -> None:\n if hasattr(self, \"normalized_inventory\"):\n obj = self.normalized_inventory\n else:\n obj = self.characterized_inventory\n self.weighted_inventory = self.weighting_matrix * obj","def gen_W(users, items, ratings):\n\n # initiate graph\n user = users.tolist()\n item = items.tolist()\n rating = ratings.tolist()\n B = nx.Graph()\n B.add_nodes_from(user, bipartite=0)\n B.add_nodes_from(item, bipartite=1)\n\n # create edges\n for i in range(len(user)):\n B.add_edges_from([(user[i], item[i])])\n B[user[i]][item[i]]['weight'] = rating[i]\n\n users_unique = users.unique() \n items_unique = items.unique()\n\n # BiAdjacency matrix - for bipartite network\n W = biadjacency_matrix(B, users_unique,items_unique).toarray()\n\n # sparce form of Biadjacency matrix\n W = spa.csr_matrix(W)\n print('Shape of W: '+str(W.shape))\n\n return W, users_unique, items_unique","def weights_initializer(self):\n self.weights = [np.random.normal(0, 1 / np.sqrt(x), (x, y)) for x, y in list(zip(self.structure[1:], self.structure[:-1]))]","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n mean = 0\n std_dev = 0.0001\n #print(in_features)\n #print(out_features)\n # create weight matrices\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\n #print(weight.shape)\n grad_weight = np.zeros((in_features, out_features))\n\n # create biases (in batches)\n bias = np.zeros(out_features)\n grad_bias = np.zeros(out_features)\n\n self.params = {'weight': weight, 'bias': bias}\n self.grads = {'weight': bias, 'bias': grad_bias}\n\n ########################\n # END OF YOUR CODE #\n #######################","def mutate(self):\n \n # Mutate each weight\n self.w1 = self.w1 + np.random.normal(0, 1, 8).reshape((2,4))\n self.b1 = self.b1 + np.random.normal(0, 1, 2).reshape((2,1))\n self.w2 = self.w2 + np.random.normal(0, 1, 4).reshape((2,2))\n self.b2 = self.b2 + np.random.normal(0, 1, 2).reshape((2,1))\n self.w3 = self.w3 + np.random.normal(0, 1, 2).reshape((1,2))\n self.b3 = self.b3 + np.random.normal(0, 1, 1)\n \n # Return thyself\n return self","def gen_ran_res_params(self):\n gen = Generator(device = self.device).manual_seed(self.random_seed)\n n = self.n_nodes_\n self.accept = rand(n, n, **self.tensorArgs, generator = gen)\n self.reservoir_pre_weights = rand(n, n, **self.tensorArgs, generator = gen) * 2 - 1","def init_weights(num_tilings, tiles_per_dim, num_dims, num_actions):\n weights = np.zeros((num_tilings*tiles_per_dim**num_dims*num_actions))\n return weights","def init_weights(self, load_weights=None):\n if load_weights:\n # TODO\n pass\n else:\n # x: lower layer nodes n\n # y: current layer nodes n\n x = self.weights_shape[1]\n y = self.weights_shape[0]\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member","def construct(self, weights):\n in_weights = weights # first to append zero column as the last output (no out-degree)\n weights = np.zeros((weights.shape[0], weights.shape[1]+1))\n weights[:,:-1] = in_weights\n din, dout, dhid = self.dim_in, self.dim_out, self.dim_hid # the max dim\n hid = weights.shape[0] - dout # this hidden dim\n if not (weights.shape[1]-din-dout==hid and (0<hid<=dhid)):\n raise self.ANNException('weight matrix hidden nodes not matching')\n if not (dout < weights.shape[0] <= hid+dout):\n raise self.ANNException('weight matrix row shape not matching')\n if not (din+dout < weights.shape[1] <= din+hid+dout):\n raise self.ANNException('weight matrix column shape not matching')\n\n self.weight[din:din+hid,:din+hid] = weights[:hid,:din+hid]\n self.weight[din:din+hid,din+dhid:] = weights[:hid,din+hid:]\n self.weight[din+dhid:,:din+hid] = weights[hid:,:din+hid]\n self.weight[din+dhid:,din+dhid:] = weights[hid:,din+hid:]\n\n for i in range(hid):\n self.connectivity[din+i,:din+i] = True\n self.connectivity[din+dhid:,:din+hid] = True\n for i in range(dout):\n self.connectivity[din+dhid+i,din+dhid:din+dhid+i] = True\n\n self.hidden[:hid] = True","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)\n # Tie weights if needed\n self.tie_weights()","def instantiate_weights(self):\n with tf.variable_scope(\"embedding_projection\"), tf.device('/cpu:0'): # embedding matrix\n self.Embedding = tf.get_variable(\"Embedding\", shape=[self.vocab_size, self.embed_size],\n initializer=self.initializer)\n # self.Embedding_label = tf.get_variable(\"Embedding_label\", shape=[self.num_classes, self.embed_size],\n # dtype=tf.float32) # ,initializer=self.initializer\n # self.W_projection = tf.get_variable(\"W_projection\", shape=[self.sequence_length * self.d_model, self.num_classes],\n # initializer=self.initializer) # [embed_size,label_size]\n # self.b_projection = tf.get_variable(\"b_projection\", shape=[self.num_classes])","def instantiate_weights(self):\n with tf.name_scope(\"decoder_init_state\"):\n self.W_initial_state = tf.get_variable(\"W_initial_state\", shape=[self.hidden_size, self.hidden_size*2], initializer=self.initializer)\n self.b_initial_state = tf.get_variable(\"b_initial_state\", shape=[self.hidden_size*2])\n with tf.name_scope(\"embedding_projection\"): # embedding matrix\n self.Embedding = tf.get_variable(\"Embedding\", shape=[self.vocab_size, self.embed_size],initializer=self.initializer) # [vocab_size,embed_size] tf.random_uniform([self.vocab_size, self.embed_size],-1.0,1.0)\n self.Embedding_label = tf.get_variable(\"Embedding_label\", shape=[self.num_classes, self.embed_size*2],dtype=tf.float32) #,initializer=self.initializer\n self.W_projection = tf.get_variable(\"W_projection\", shape=[self.hidden_size*2, self.num_classes],\n initializer=self.initializer) # [embed_size,label_size]\n self.b_projection = tf.get_variable(\"b_projection\", shape=[self.num_classes])\n\n # GRU parameters:update gate related\n with tf.name_scope(\"gru_weights_encoder\"):\n self.W_z = tf.get_variable(\"W_z\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\n self.U_z = tf.get_variable(\"U_z\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\n self.b_z = tf.get_variable(\"b_z\", shape=[self.hidden_size])\n # GRU parameters:reset gate related\n self.W_r = tf.get_variable(\"W_r\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\n self.U_r = tf.get_variable(\"U_r\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\n self.b_r = tf.get_variable(\"b_r\", shape=[self.hidden_size])\n\n self.W_h = tf.get_variable(\"W_h\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\n self.U_h = tf.get_variable(\"U_h\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\n self.b_h = tf.get_variable(\"b_h\", shape=[self.hidden_size])\n\n with tf.name_scope(\"gru_weights_decoder\"):\n self.W_z_decoder = tf.get_variable(\"W_z_decoder\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\n self.U_z_decoder = tf.get_variable(\"U_z_decoder\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\n self.C_z_decoder = tf.get_variable(\"C_z_decoder\", shape=[self.embed_size * 2, self.hidden_size * 2],initializer=self.initializer) #TODO\n self.b_z_decoder = tf.get_variable(\"b_z_decoder\", shape=[self.hidden_size*2])\n # GRU parameters:reset gate related\n self.W_r_decoder = tf.get_variable(\"W_r_decoder\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\n self.U_r_decoder = tf.get_variable(\"U_r_decoder\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\n self.C_r_decoder = tf.get_variable(\"C_r_decoder\", shape=[self.embed_size * 2, self.hidden_size * 2],initializer=self.initializer) #TODO\n self.b_r_decoder = tf.get_variable(\"b_r_decoder\", shape=[self.hidden_size*2])\n\n self.W_h_decoder = tf.get_variable(\"W_h_decoder\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\n self.U_h_decoder = tf.get_variable(\"U_h_decoder\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer) #TODO\n self.C_h_decoder = tf.get_variable(\"C_h_decoder\", shape=[self.embed_size * 2, self.hidden_size * 2],initializer=self.initializer)\n self.b_h_decoder = tf.get_variable(\"b_h_decoder\", shape=[self.hidden_size*2])\n\n with tf.name_scope(\"full_connected\"):\n self.W_fc=tf.get_variable(\"W_fc\",shape=[self.hidden_size*2,self.hidden_size])\n self.a_fc=tf.get_variable(\"a_fc\",shape=[self.hidden_size])","def __init__(self, weights:np.ndarray):\n self.w = weights.copy()","def inputs_weights_init(self):\n input_user, input_item, input_rating = self.inputs_init()\n user_embeddings, item_embeddings = self.embeddings_layers_init()\n\n return input_user, input_item, input_rating, user_embeddings, item_embeddings","def init_weights(self):\n # Initialize weights\n self.apply(self._init_weights)","def u_weights(self):\n for i in range(self.n_inputs):\n self._q_neuron.cx(self._weights[i], self.inputs[i])","def __init__(self, weights):\n self._weights = weights","def _setup(self) -> None:\n #TODO: type\n self.activation = self.params['activation']\n\n self.batchsize: int = self.params['batchsize']\n\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\n\n self.d: int = self.input_shape[1]\n assert(not self.d == 0)\n\n self.n: int = int(sqrt(self.input_shape[2]))\n assert(not self.n == 0)\n\n self.dtype: type = self.params['dtype']\n\n # initialize weights\n self.W: List[tf.Tensor] = []\n \n for i in range(3):\n #TODO: type\n w_init = self.params['initializer_w']\n if self.params['initializer_w' + str(i)] is not None:\n w_init = self.params['initializer_w' + str(i)]\n\n w_stddev: float = self.params['stddev_w']\n if self.params['stddev_w' + str(i)] is not None:\n w_stddev = self.params['stddev_w' + str(i)]\n\n self.W.append(tf.get_variable(\"weights_\" + str(i),\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\n dtype = self.dtype,\n initializer = w_init(stddev=w_stddev)))\n\n #TODO: type\n b_init = self.params['initializer_b']\n b_stddev = self.params['stddev_b']\n self.B: tf.Tensor = tf.get_variable(\"biases\", shape = (1, self.d, 1),\n dtype = self.dtype,\n initializer = b_init(stddev=b_stddev))\n\n # create/load expand matrix\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\n self.expand: tf.Tensor = tf.get_variable(\n \"expand\" + str(self.n),\n shape = (self.n, self.n * self.n),\n dtype = self.dtype,\n initializer = tf.constant_initializer(make_expand(self.n)))\n\n # create/load tile matrix\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\n for i in range(1, self.n):\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\n\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)","def __init__(self, weights):\r\n self.totals = []\r\n running_total = 0\r\n for w in weights:\r\n running_total += w\r\n self.totals.append(running_total)","def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):\n\n self.params = {}\n self.params['W1'] = weight_init_std * \\\n np.random.randn(input_size, hidden_size)\n self.params['b1'] = np.zeros(hidden_size)\n self.params['W2'] = weight_init_std * \\\n np.random.randn(hidden_size, output_size)\n self.params['b2'] = np.zeros(output_size)","def _generate_weights(self):\n weights = []\n for i in range(1, len(self.layers) - 1):\n weights.append(2 * np.random.random(\n (self.layers[i - 1] + 1, self.layers[i] + 1)) - 1)\n weights.append(2 * np.random.random(\n (self.layers[i] + 1, self.layers[i + 1])) - 1)\n return weights","def init_weights(self):\n\n params = torch.load(self.resnet_weight)\n\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\n\n\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\n self.fc3.out_features)\n self.fc3.weight.data.uniform_(-r, r)\n self.fc3.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\n self.fc2.out_features)\n self.fc2.weight.data.uniform_(-r, r)\n self.fc2.bias.data.fill_(0)\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\n self.fc4.out_features)\n self.fc4.weight.data.uniform_(-r, r)\n self.fc4.bias.data.fill_(0)","def random_weights_init(self, data):\n self.check_input_dimension(data)\n for i in range(self.y_axis):\n for j in range(self.x_axis):\n rand_i = self.random_generator.randint(len(data))\n self.weights[i][j] = data[rand_i]","def get_weight_matrix(self):\n\n\t\treturn self.weights.get_value(borrow=True)","def initialize_weights(self, seed=None):\r\n if seed!=None:\r\n np.random.seed(seed)\r\n self.weights = np.random.randn(self.number_of_nodes,self.input_dimensions)","def get_weights(self):","def init_sg_weights(self):\n n = self.weights_shape[0] # size of current layer\n # pylint: disable=no-member\n A = np.random.randn(n, n) / np.sqrt(n)\n B = np.random.randn(10, n) / np.sqrt(n)\n C = np.random.randn(1, n) / np.sqrt(n)\n # pylint: enable=no-member\n self.sg_weights = [A, B, C]","def build(self, input_shape):\n assert len(input_shape) == 3\n assert input_shape[1] == input_shape[2]\n\n # Create the weight vector\n kernel_shape = (input_shape[1], self.out_dim)\n # if self.initial_weights is not None:\n # self.set_weights(self.initial_weights)\n # del self.initial_weights\n # else:\n # self.W = self.init(self.W_shape, name='{}_W'.format(self.name))\n self.kernel = self.add_weight(shape=kernel_shape,\n initializer=self.kernel_initializer,\n name='kernel',\n regularizer=self.kernel_regularizer,\n constraint=self.kernel_constraint\n )\n # self.trainable_weights = [self.W]\n self.built = True","def initialize_weights_xavier(self):\n\t\tself.weights = [np.random.uniform(-1/sqrt(size1), 1/sqrt(size1)) for size1, size2 in zip(self.sizes[:-1], self.sizes[1:])]\n\t\tself.biases = [np.zeros([size, ]) for size in self.sizes[1:]]","def init_weight(self):\r\n xavier_init(self.output_proj, distribution='uniform', bias=0.)","def setWeightInitializer(self,weights):\n self.init_w = weights","def _compute_weight_matrix(self, state_vector_size, number_of_measurements):\n\n if self.weighted_estimation and self.model.use_a_priori:\n weight_matrix = np.zeros((state_vector_size + number_of_measurements,\n state_vector_size + number_of_measurements), dtype=np.float64)\n\n if self._a_priori_state_covariance is not None:\n weight_matrix[number_of_measurements:,\n number_of_measurements:] = np.linalg.inv(self.a_priori_state_covariance)\n else:\n weight_matrix[number_of_measurements:, number_of_measurements:] = np.eye(state_vector_size)\n\n if self._measurement_covariance is not None:\n if np.isscalar(self.measurement_covariance):\n measurement_info = 1 / self.measurement_covariance\n for i in range(number_of_measurements):\n weight_matrix[i, i] = measurement_info\n else:\n weight_matrix[:number_of_measurements,\n :number_of_measurements] = np.linalg.inv(self.measurement_covariance)\n else:\n for i in range(number_of_measurements):\n weight_matrix[i, i] = 1\n\n elif self.weighted_estimation:\n if self._measurement_covariance is not None:\n if np.isscalar(self.measurement_covariance):\n weight_matrix = 1/self.measurement_covariance\n else:\n weight_matrix = np.linalg.inv(self.measurement_covariance)\n else:\n weight_matrix = 1\n\n elif self.model.use_a_priori:\n weight_matrix = np.eye(state_vector_size + number_of_measurements, dtype=np.float64)\n if self._a_priori_state_covariance is not None:\n weight_matrix[number_of_measurements:,\n number_of_measurements:] = np.linalg.inv(self.a_priori_state_covariance)\n\n else:\n weight_matrix = 1\n\n return weight_matrix","def default_weight_initializer(self):\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\n self.weights = [np.random.randn(y, x)/np.sqrt(x)\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]","def __init__(self, in_units, out_units):\n np.random.seed(42)\n #self.w = None # Declare the Weight matrix\n #self.b = None # Create a placeholder for Bias\n self.x = None # Save the input to forward in this\n self.a = None # Save the output of forward pass in this (without activation)\n\n self.d_x = None # Save the gradient w.r.t x in this\n self.d_w = None # Save the gradient w.r.t w in this\n self.d_b = None # Save the gradient w.r.t b in this\n self.d_v_w = None\n self.d_v_b = None\n\n self.w = np.random.normal(0, np.sqrt(1/in_units), (in_units, out_units))\n self.b = np.zeros((1, out_units))\n self.d_v_w = np.zeros((in_units, out_units))\n self.d_v_b = np.zeros((1, out_units))","def get_weights(self, nn_weights, rov_id): # Get weights from CCEA population\n\n for w in range(self.n_weights):\n self.weights[rov_id, w] = nn_weights[w]","def initialize_weights(self, input_dim, std_dev=1e-2):\n \n self.params = {}\n\n hidden_size = self.hidden_size\n num_classes = self.num_classes\n num_layers = self.num_layers\n #############################################################################\n # TODO: Initialize the weight and bias of every layer. Store the weights W #\n # of every layer in the dictionary names self.params. #\n # For example, Weights and bias of layer 1 will be stored in #\n # self.params[\"W1\"] and self.params[\"b1\"] respectively. #\n #############################################################################\n # input_dim * hidden_size\n self.params[\"W1\"] = np.random.randn(input_dim, self.hidden_size) * std_dev\n self.params[\"b1\"] = np.zeros(self.hidden_size)\n\n # hidden_size * num_classes\n self.params[\"W2\"] = np.random.randn(self.hidden_size, self.num_classes) * std_dev\n self.params[\"b2\"] = np.zeros(self.num_classes)\n #############################################################################\n # END OF YOUR CODE #\n ############################################################################# ","def create_matrix(self):\n\n self.matrix = np.zeros((len(self.users), len(self.items)))\n\n for user in self.train_set['users']:\n for item in self.train_set['feedback'][user]:\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\n self.train_set['feedback'][user][item]","def reservoir_generator(\n number_of_reservoirs=None, sparsity_level=None, reservoir_dim=None\n):\n reservoir_computing = ReservoirComputing(\n reservoir_dim=reservoir_dim, sparsity_level=sparsity_level\n )\n\n return [reservoir_computing.create_reservoir() for n in range(number_of_reservoirs)]","def create_population(self):\r\n\r\n model_weights_vector = model_weights_as_vector(model=self.model)\r\n\r\n net_population_weights = []\r\n net_population_weights.append(model_weights_vector)\r\n\r\n for idx in range(self.num_solutions-1):\r\n\r\n net_weights = copy.deepcopy(model_weights_vector)\r\n net_weights = numpy.array(net_weights) + numpy.random.uniform(low=-1.0, high=1.0, size=model_weights_vector.size)\r\n\r\n # Appending the weights to the population.\r\n net_population_weights.append(net_weights)\r\n\r\n return net_population_weights","def _buildWeights(self):\r\n # Compute the spatial tree\r\n kd = spatial.cKDTree(self.XYin)\r\n \r\n # Perform query on all of the points in the grid\r\n dist,self.ind=kd.query(self.XYout,distance_upper_bound=self.maxdist,k=self.NNear)\r\n \r\n self.Nc = np.size(self.ind,axis=0)\r\n print '%d interpolation points.'%self.Nc\r\n # Now loop through and get the weights for each point\r\n self.W = np.zeros((self.NNear,self.Nc))\r\n\r\n # Print percentages\r\n p0=0\r\n pstep=5\r\n for ii in range(0,self.Nc):\r\n \r\n if self.verbose:\r\n pfinish = float(ii)/float(self.Nc)*100.0\r\n if pfinish> p0:\r\n print '%3.1f %% complete...'%pfinish\r\n p0+=pstep\r\n \r\n W = self.getWeights(dist[ii,:],self.XYin[self.ind[ii,:],0],self.XYin[self.ind[ii,:],1])\r\n self.W[:,ii] = W.T","def __init__(self, input_dimension):\r\n self.input_dimension = input_dimension\r\n self.weights = []\r\n self.biases = []\r\n self.transferfunction = []","def _create_generate_input(self):\n self.keep_prob = 1.","def build(self, input_shape):\n\n # get shape of input matrix x\n num_of_vertices = input_shape[1]\n num_of_features = input_shape[2]\n num_of_timesteps = input_shape[3]\n #self.U_1.shape = (num_of_vertices,)\n #self.U_2.shape = (num_of_features, num_of_vertices)\n #self.U_3.shape = (num_of_features,)\n #self.b_e.shape = (1, num_of_timesteps, num_of_timesteps)\n #self.V_e.shape = (num_of_timesteps, num_of_timesteps)\n\n self.u1 = self.add_weight(name='u1', shape=(num_of_vertices, ),\n initializer='glorot_normal', trainable=True)\n self.u2 = self.add_weight(name='u2', shape=(num_of_features, num_of_vertices),\n initializer='glorot_normal', trainable=True)\n self.u3 = self.add_weight(name='u3', shape=(num_of_features,),\n initializer='glorot_normal', trainable=True)\n self.b = self.add_weight(name='b', shape=(1, num_of_timesteps, num_of_timesteps),\n initializer='zeros', trainable=True)\n self.v = self.add_weight(name='v', shape=(num_of_timesteps, num_of_timesteps),\n initializer='glorot_normal', trainable=True)\n\n super(Temporal_Attention_layer, self).build(input_shape)","def initialize_weights(self):\n w1 = np.random.uniform(-1.0, 1.0, size = self.n_hidden * (self.n_features + 1)).reshape(self.n_hidden, (self.n_features + 1))/(self.n_features + 1)\n w2 = np.random.uniform(-1.0, 1.0, size=self.n_output*(self.n_hidden+1)).reshape(self.n_output, self.n_hidden+ 1)/(self.n_hidden + 1)\n return w1, w2","def init_weights(self):\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\n self.fc.out_features)\n self.fc.weight.data.uniform_(-r, r)\n self.fc.bias.data.fill_(0)","def init_weights(self):\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\n self.fc.out_features)\n self.fc.weight.data.uniform_(-r, r)\n self.fc.bias.data.fill_(0)","def weighted_matrix(point: np.mat, training_data_x: np.mat, bandwidth: float) -> np.mat:\r\n # m is the number of training samples\r\n m, n = np.shape(training_data_x)\r\n # Initializing weights as identity matrix\r\n weights = np.mat(np.eye((m)))\r\n # calculating weights for all training examples [x(i)'s]\r\n for j in range(m):\r\n diff = point - training_data[j]\r\n weights[j, j] = np.exp(diff * diff.T / (-2.0 * bandwidth ** 2))\r\n return weights","def my_assign_weights(context, data):\n pass","def randomize(self):\n self.weights = np.random.rand(*self.weights.shape) - 0.5","def weights(self, weights):\n\n self._weights = weights","def set_weights(self, weights):\r\n self.weights = weights","def initialize_weights_and_bias(self, X_train):\n n_samples, n_features = np.shape(X_train)\n n_output = 1 \n \n # This is the numeber of gridcells and we want to make one prediction pr cell. \n # It this doesn't work calculate the number of griddcells.\n\n self.b_h = [] #np.ones((self.n_hidden_layers, self.n_hidden[0]))\n self.W_h = []\n\n for i in range(len(self.n_hidden)):\n if (i == 0):\n self.W_h.append(self.random.normal(loc=0.0, scale=0.1, size=(n_features, self.n_hidden[0])))\n self.b_h.append(np.ones(self.n_hidden[0]))\n else:\n self.W_h.append(self.random.normal(loc=0.0, scale=0.1, size=(self.n_hidden[i-1], self.n_hidden[i])))\n self.b_h.append(np.ones(self.n_hidden[i])) \n \n self.b_out = [1]\n self.W_out = self.random.normal(loc=0.0, scale=0.1, size=(self.n_hidden[-1], n_output))","def __init__(self, sizes):\n self.sizes = sizes\n self.biases = [random_matrix(1, y)[0] for y in sizes[1:]]\n self.weights = [random_matrix(y, x)\n for x, y in zip(sizes[:-1], sizes[1:])]\n\n self.weighted_layer = []\n self.activations = []","def initialize_weights(self, seed=None):\n if seed != None:\n np.random.seed(seed)\n self.weights = np.random.randn(self.number_of_nodes, self.input_dimensions)","def init_weights(self, num_features):\n for each_label in self.valid_labels:\n self.weights[each_label] = np.zeros(num_features)","def generate_weights(self, mag=1):\n \n if (len(self.hlayers) == 0):\n print(\"No weights to generate! Please add hidden layers.\")\n return\n \n weights = []\n \n insize = self.inputLayerSize\n if (self.inputBias == True):\n insize += 1\n \n layersize = self.hlayers[0].size\n if (self.hlayers[0].bias == True):\n layersize += 1\n \n weights.append(np.random.randn(insize, layersize)*mag)\n \n for i in range(0, len(self.hlayers)-1):\n layer1size = self.hlayers[i].size\n if (self.hlayers[i].bias == True):\n layer1size+=1\n \n layer2size = self.hlayers[i+1].size\n if (self.hlayers[i+1].bias == True):\n layer2size+=1\n \n weights.append(np.random.randn(layer1size, layer2size))\n \n \n self.weights = weights","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n\n\n self.params = {'weight': 0.0001 * np.random.randn(out_features, in_features), 'bias': np.zeros((out_features, 1))}\n self.grads = {'weight': np.zeros((out_features, in_features)), 'bias': np.zeros((out_features, 1))}\n\n\n\n ########################\n # END OF YOUR CODE #\n #######################","def init_weight(self):\n init_bn(self.norm0)","def __init__(self, input, weight_init=None):\n n_in = input.get_shape()[1].value\n \n self.input = input\n \n # Initiate the weight for the input layer\n r = 4*np.sqrt(3.0/n_in)\n\n if weight_init is None:\n self.w = tf.Variable(tf.random_uniform([n_in,],-r, r), name='w')\n else: \n self.w = tf.Variable(weight_init, name='w')\n\n self.output = self.w * self.input","def _allocation_weights(self, write_gates, num_writes, usage):\n write_gates = write_gates.unsqueeze(-1)\n allocation_weights = []\n for i in range(num_writes):\n allocation = self._allocate(usage)\n allocation_weights.append(allocation)\n usage = usage + ((1-usage)*write_gates[:, i, :]*allocation_weights[i])\n allocation_weights = torch.stack(allocation_weights, 1)\n return allocation_weights","def __init__(self, layer_neuron):\n\n self.num_layers = len(layer_neuron)\n self.layer_neuron = layer_neuron\n #a list of numpy ndarrays\n self.weights = []\n self.input_len = 0\n self.target_vals = []\n self.current_guess = 0\n\n self.layer_inputs = [[]]*(len(layer_neuron))\n self.layer_outputs = [[]]*(len(layer_neuron))\n #deltas: don't include input layer but still put it in for spacing ie self.deltas[0] should always be empty\n self.deltas = [[]]*((len(layer_neuron)))\n\n #make the weight matrices, each matrix nXm matrix with m = # nodes in the ith layer (incl bias) and n = # nodes in the (i+1)th layer\n #each row represents the set of weights from all m neurons in the ith layer to a single neuron in the (i+1)th layer\n #conversely, each column is all the output weights from a node in the ith layer, to each n nodes in the (i+1)th layer\n #the right-most column represents output weights from the bias node\n for i in range(len(self.layer_neuron)-1 ):\n np.random.seed(0)\n self.weights.append(np.random.normal( scale = 0.2, size = (self.layer_neuron[i+1], self.layer_neuron[i] + 1)))","def update_weights(self):\n self._weights = self._weights + self.update_weights_value","def start_weights(self, inv=True):\n return np.eye(self.nmoms)","def __init__(self, in_features, out_features):\n \n ########################\n # PUT YOUR CODE HERE #\n #######################\n self.params = {'weight': np.random.normal(loc = 0, scale=0.0001, size=(out_features,in_features)),\\\n 'bias': np.zeros((1, out_features))}\n \n self.grads = {'weight': np.zeros((out_features,in_features)),\\\n 'bias': np.zeros((1, out_features))}\n ########################\n # END OF YOUR CODE #\n #######################"],"string":"[\n \"def create_weight_matrices(self):\\n rad = 1 / np.sqrt(self.no_of_in_nodes)\\n X = truncated_normal(mean=0, \\n sd=1, \\n low=-rad, \\n upp=rad)\\n self.wih = X.rvs((self.no_of_hidden_nodes, \\n self.no_of_in_nodes))\\n rad = 1 / np.sqrt(self.no_of_hidden_nodes)\\n X = truncated_normal(mean=0, sd=1, low=-rad, upp=rad)\\n self.who = X.rvs((self.no_of_out_nodes, \\n self.no_of_hidden_nodes))\",\n \"def weightGenerate(self):\\n\\t\\tfor i in range(0, self.numberOfInput):\\n\\t\\t\\tself.weight.append(random.random()-0.5)\",\n \"def InitWeights(self):\\n self.w = -1 + 2 * np.random.rand(self.num_of_inputs,)\\n self.w0 = -1 + 2 * np.random.rand()\",\n \"def build_layer(self) :\\n inputsWithBias = self.input_count + 1\\n self.weights = np.random.rand(inputsWithBias, self.node_count)\\n self.weights_and_activations = (self.weights, self.activations)\",\n \"def _create_weights(self):\\n\\n self.mu_W = tf.get_variable(\\n name=\\\"mu_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim, self.z_dim])\\n\\n self.mu_b = tf.get_variable(\\n name=\\\"mu_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.z_dim])\\n\\n self.log_sig_sq_W = tf.get_variable(\\n name=\\\"log_sig_sq_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim, self.z_dim])\\n\\n self.log_sig_sq_b = tf.get_variable(\\n name=\\\"log_sig_sq_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.z_dim])\\n \\n self.y_W = tf.get_variable(\\n name=\\\"y_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.z_dim, self.rnn_dim])\\n\\n self.y_b = tf.get_variable(\\n name=\\\"y_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim])\\n \\n self.softmax_W = tf.get_variable(\\n name=\\\"softmax_W\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.rnn_dim, self.vocabulary_size])\\n \\n self.softmax_b = tf.get_variable(\\n name=\\\"softmax_b\\\", initializer=tf.random_normal_initializer(),\\n shape=[self.vocabulary_size])\",\n \"def _create_weights(self):\\n gate_size = self._hidden_size * self._num_gates\\n # Compute the shape of weight and bias.\\n matrix_shapes, bias_shapes = [], []\\n for layer in range(self._num_layers):\\n for direction in range(self._num_directions):\\n layer_input_size = self._input_size if layer == 0 \\\\\\n else self._hidden_size * self._num_directions\\n w_ih_shape = [gate_size, layer_input_size]\\n w_hh_shape = [gate_size, self._hidden_size]\\n b_ih_shape, b_hh_shape = [gate_size], [gate_size]\\n matrix_shapes.extend([w_ih_shape, w_hh_shape])\\n bias_shapes.extend([b_ih_shape, b_hh_shape])\\n # Create single float32 weights.\\n weights_count = 0\\n self._weights_shapes = matrix_shapes + bias_shapes\\n for shape in self._weights_shapes:\\n weights_count += math_util.prod(shape)\\n self._weights = Tensor([weights_count])\\n self._weights.requires_grad = True\",\n \"def initWeights(self):\\n self.weights = []\\n self.bias = []\\n for i, dim in enumerate(self.dimensions[1:]):\\n self.weights.append(np.random.uniform(-1,1,(self.dimensions[i],dim)))\\n self.bias.append(np.random.uniform(-1,1,dim))\",\n \"def init_weights(self, input_size=None, min_w=WEIGHT_MIN,\\n max_w=WEIGHT_MAX):\\n if input_size is None:\\n input_size = self.INPUT_SIZE\\n\\n # Add a bias weight to each neuron\\n weights_per_neuron = input_size + 1\\n\\n self.weights = np.random.rand(self.size, weights_per_neuron) \\\\\\n * (max_w - min_w) + min_w\",\n \"def init_weights(self):\\n \\n self.w = np.random.randn(self.D) / np.sqrt(self.D)\",\n \"def build(self,input_shape):\\n\\n self.w = self.add_weight(shape=(input_shape[-1],self.units),\\n initializer='random_normal',\\n trainable=True)\\n self.b = self.add_weight(shape=(self.units,),\\n initializer='random_normal',\\n trainable=True)\",\n \"def _initialize_weights(self):\\n stddev = 1.0 / math.sqrt(self._hidden_size)\\n for layer_id, param_id in itertools.product(\\n range(self._num_layers * (self._bidirectional + 1)),\\n range(self._num_gates * 2)):\\n i = layer_id * 2 + (param_id // self._num_gates)\\n j = i + len(self._weights_shapes) // 2\\n matrix_shape = self._weights_shapes[i][:]\\n bias_shape = self._weights_shapes[j][:]\\n matrix_shape[0] //= self._num_gates\\n bias_shape[0] //= self._num_gates\\n self._set_parameter(\\n init_ops.random_uniform(matrix_shape, -stddev, stddev),\\n layer_id, param_id, 'matrix')\\n self._set_parameter(\\n init_ops.random_uniform(bias_shape, -stddev, stddev),\\n layer_id, param_id, 'bias')\",\n \"def _initialize_weights(self):\\n pass\",\n \"def _generate_weights(self):\\n weights = [random.uniform(0, 1) for x in range(self.num_weights)]\\n return self._normalize_weights(weights)\",\n \"def __initialize_weights__(num_neurons: int) -> np.ndarray:\\n\\n weights = np.zeros((num_neurons, num_neurons))\\n\\n return weights\",\n \"def _initialize_matrix(self):\\n\\n try:\\n # Grab the weight matrix from weight_matrices.py\\n tmp_weight_matrix = copy.copy(weight_matrices.__dict__[self._weight_matrix_name])\\n except KeyError:\\n\\n # Treat this name as a file\\n data = open(self._weight_matrix_name).readlines()\\n\\n # Grab alphabet bits from top line\\n seq = data[0].strip('/n/r').split()\\n tmp_weight_matrix = dict([(s,dict([(s,0) for s in seq])) for s in seq])\\n \\n # Go through each line, populating weight matrix. \\n for line in data[1:]:\\n line = line.strip('/n/r').split()\\n\\n a = line[0]\\n for j in range(1, len(line)):\\n b = seq[j-1]\\n tmp_weight_matrix[a][b] = float(line[j])\\n\\n # Convert tmp_weight_matrix into a numpy array, normalized between 0 \\n # and 1.\\n keys = list(tmp_weight_matrix.keys())\\n self.weight_matrix = np.zeros((len(keys),len(keys)),dtype=float)\\n for i, k1 in enumerate(keys):\\n a = self._alphabet_dict[k1]\\n for j, k2 in enumerate(keys):\\n b = self._alphabet_dict[k2]\\n self.weight_matrix[a,b] = tmp_weight_matrix[k1][k2]\\n\\n # Set weights to range from 0 (close) to 1 (far)\\n mini = np.min(self.weight_matrix)\\n maxi = np.max(self.weight_matrix)\\n self.weight_matrix = 1 - (self.weight_matrix - mini)/(maxi - mini)\",\n \"def _initialize_weights(self, m):\\n self.rgen = np.random.RandomState(self.random_state)\\n self.w_ = self.rgen.normal(loc=0.0, scale=0.01, size=m)\\n self.b_ = 0\\n self.w_avg = self.rgen.normal(loc=0.0, scale=0.01, size=m)\\n self.b_avg = 0\\n\\n def net_input(self, X):\\n return np.dot(X, self.w_[1:]) + self.w_[0]\\n\\n def activation(self, X):\\n return X\\n \\n def predict(self, X):\\n return np.where(self.net_input(X) >= 0.0, 1, -1)\\n \\n def get_params(self, deep=True):\\n return {\\\"eta\\\":self.eta, \\\"max_iter\\\":self.max_iter, \\\"C\\\":self.C, \\\"random_state\\\":self.random_state, \\\"batch_size\\\":self.batch_size}\\n \\n def set_params(self, **parameters):\\n for parameter, value in parameters.items():\\n setattr(self, parameters, value)\\n return self\",\n \"def _set_weights(self, weights):\\r\\n self.weights = weights.reshape(self.output_size, self.input_size+1)\",\n \"def instantiate_weights(self):\\n self.product_embeddings = tf.get_variable(\\n name='product_embeddings',\\n shape=[50000, 300],\\n dtype=tf.float32\\n )\\n self.aisle_embeddings = tf.get_variable(\\n name='aisle_embeddings',\\n shape=[250, 50],\\n dtype=tf.float32\\n )\\n self.department_embeddings = tf.get_variable(\\n name='department_embeddings',\\n shape=[50, 10],\\n dtype=tf.float32\\n )\\n self.W_relu = tf.get_variable(\\\"W_relu\\\",shape=[670, 30]) #这个参数后续需要自适应\\n self.b_relu = tf.get_variable(\\\"bias_relu\\\",shape=[30]) \\n self.W_projection = tf.get_variable(\\\"W_projection\\\",shape=[30, 1]) \\n self.b_projection = tf.get_variable(\\\"bias_projection\\\",shape=[1])\",\n \"def random_weights_init(self, data):\\n self._check_input_len(data)\\n it = nditer(self._activation_map, flags=['multi_index'])\\n while not it.finished:\\n rand_i = self._random_generator.randint(len(data))\\n self._weights[it.multi_index] = data[rand_i]\\n it.iternext()\",\n \"def constructCell():\\n\\t\\tself.weightGenerate()\",\n \"def init_weights_(self):\\n raise NotImplementedError\",\n \"def initialize_weights(self):\\n # compute lmda.\\n self.lmda = float(self.c)/float(self.N)\\n # bias term. This should not get a regularization penalty.\\n self.bias = {}\\n # weight vector\\n self.w = {}\\n # lastW[j] = k, indicates that feature j was last updated at time k.\\n self.lastW = {}\\n for lbl in self.labels:\\n self.bias[lbl] = 0\\n self.w[lbl] = {}\\n self.lastW[lbl] = {}\\n pass\",\n \"def init_weights(self):\\n self._q_neuron.h(self._weights) \\n self._q_neuron.x(self._weights)\",\n \"def build(self, input_shape):\\n\\n # get shape of input matrix x\\n self.num_of_vertices = input_shape[1]\\n self.num_of_features = input_shape[2]\\n self.num_of_timesteps = input_shape[3]\\n #self.W_1.shape = (num_of_timesteps,)\\n #self.W_2.shape = (num_of_features, num_of_timesteps)\\n #self.W_3.shape = (num_of_features,)\\n #self.b_s.shape = (1, num_of_vertices, num_of_vertices)\\n #self.V_s.shape = (num_of_vertices, num_of_vertices)\\n\\n self.w1 = self.add_weight(name='w1', shape=(self.num_of_timesteps, ),\\n initializer='glorot_normal', trainable=True)\\n self.w2 = self.add_weight(name='w2', shape=(self.num_of_features, self.num_of_timesteps),\\n initializer='glorot_normal', trainable=True)\\n self.w3 = self.add_weight(name='w3', shape=(self.num_of_features,),\\n initializer='glorot_normal', trainable=True)\\n self.b = self.add_weight(name='b', shape=(1, self.num_of_vertices, self.num_of_vertices),\\n initializer='zeros', trainable=True)\\n self.v = self.add_weight(name='v', shape=(self.num_of_vertices, self.num_of_vertices),\\n initializer='glorot_normal', trainable=True)\\n\\n super(Spatial_Attention_layer, self).build(input_shape)\",\n \"def init_weights(self, dims):\\n self.W = np.random.normal(size=dims) * 0.0001\",\n \"def __init__(self, reservoir, input_weights=None, neuron_type=\\\"tanh\\\", \\n output_type=\\\"sigmoid\\\", init_state=\\\"zeros\\\", neuron_pars={}, output_neuron_pars={}):\\n\\n # Weights\\n self.reservoir = reservoir\\n self.num_neurons = self.reservoir.shape[0]\\n self.input_weights = input_weights\\n\\n # Set neuron types (reservoir)\\n self.neuron_pars = neuron_pars\\n self.neuron_type = neuron_type\\n if self.neuron_type == \\\"tanh\\\":\\n self.activation_function = self.tanh\\n elif self.neuron_type == \\\"sigmoid\\\":\\n self.activation_function = partial(self.sigmoid, **neuron_pars)\\n elif self.neuron_type == \\\"RLU\\\":\\n self.activation_function = partial(self.rectified_linear_unit, **neuron_pars)\\n elif self.neuron_type == \\\"heaviside\\\":\\n self.activation_function = partial(self.heaviside, **neuron_pars)\\n # Set neuron types (output neuron)\\n self.output_type = output_type\\n if self.output_type == \\\"tanh\\\":\\n self.output_function = partial(self.tanh, **output_neuron_pars)\\n elif self.output_type == \\\"sigmoid\\\":\\n self.output_function = partial(self.sigmoid, **output_neuron_pars)\\n elif self.output_type == \\\"identity\\\":\\n self.output_function = partial(self.identity, **output_neuron_pars)\\n elif self.output_type == \\\"heaviside\\\":\\n self.output_function = partial(self.heaviside, **output_neuron_pars)\\n\\n # Generate initial system state\\n self.init_state = init_state\\n self.current_state = self.GenerateInitialState(self.init_state)\\n self.network_history = [ ]\",\n \"def init_weights(model):\\n ...\",\n \"def _generate_weighted_matrices(self):\\n self.degree_weighted_matrices = dict()\\n mes = []\\n args = []\\n for metaedge, matrix in self.adj_matrices.items():\\n mes.append(metaedge)\\n args.append({'matrix': matrix, 'w': self.w, 'degree_fwd': self.out_degree[metaedge],\\n 'degree_rev': self.in_degree[metaedge]})\\n res = parallel_process(array=args, function=mt.weight_by_degree, use_kwargs=True, n_jobs=self.n_jobs,\\n front_num=0)\\n for metaedge, matrix in zip(mes, res):\\n self.degree_weighted_matrices[metaedge] = matrix\",\n \"def set_output_weights(self, weight_matrix):\\n pass\",\n \"def update_weights(self):\\n\\t\\tpass\",\n \"def _initialize_weights(self, m):\\n self.w_ = np.zeros(1 + m)\\n self.w_initialized = True\",\n \"def _initialize_weights(self, m):\\n self.w_ = np.zeros(1 + m)\\n self.w_initialized = True\",\n \"def _initialize_weights(self, m):\\n self.w_ = np.zeros(1 + m)\\n self.w_initialized = True\",\n \"def build(self):\\n\\n self.W = self.init([self.n_atom_input_feat, self.n_output])\\n self.b = model_ops.zeros(shape=[\\n self.n_output,\\n ])\\n\\n self.trainable_weights = self.W + self.b\",\n \"def initialize_weights(self, weights_initializer, bias_initializer):\\n wshapes = [\\n [self.input_size, self.hidden_size[0]],\\n [self.hidden_size[0], self.hidden_size[1]],\\n [self.hidden_size[1], self.output_size]\\n ]\\n\\n bshapes = [\\n [1, self.hidden_size[0]],\\n [1, self.hidden_size[1]],\\n [1, self.output_size]\\n ]\\n\\n self.weights = [init_weights(s, weights_initializer) for s in wshapes]\\n self.biases = [init_weights(s, bias_initializer) for s in bshapes]\\n\\n self.trainable_variables = self.weights + self.biases\",\n \"def build(self, input_shape):\\n assert len(input_shape) == 4\\n assert input_shape[1] == input_shape[2]\\n self.out_channel = input_shape[3]\\n # Create the weight vector\\n self.W_shape = (input_shape[1], self.out_dim)\\n if self.initial_weights is not None:\\n self.set_weights(self.initial_weights)\\n del self.initial_weights\\n else:\\n self.W = self.init(self.W_shape, name='{}_W'.format(self.name))\\n self.trainable_weights = [self.W]\\n self.built = True\",\n \"def weighting_calculation(self) -> None:\\n if hasattr(self, \\\"normalized_inventory\\\"):\\n obj = self.normalized_inventory\\n else:\\n obj = self.characterized_inventory\\n self.weighted_inventory = self.weighting_matrix * obj\",\n \"def gen_W(users, items, ratings):\\n\\n # initiate graph\\n user = users.tolist()\\n item = items.tolist()\\n rating = ratings.tolist()\\n B = nx.Graph()\\n B.add_nodes_from(user, bipartite=0)\\n B.add_nodes_from(item, bipartite=1)\\n\\n # create edges\\n for i in range(len(user)):\\n B.add_edges_from([(user[i], item[i])])\\n B[user[i]][item[i]]['weight'] = rating[i]\\n\\n users_unique = users.unique() \\n items_unique = items.unique()\\n\\n # BiAdjacency matrix - for bipartite network\\n W = biadjacency_matrix(B, users_unique,items_unique).toarray()\\n\\n # sparce form of Biadjacency matrix\\n W = spa.csr_matrix(W)\\n print('Shape of W: '+str(W.shape))\\n\\n return W, users_unique, items_unique\",\n \"def weights_initializer(self):\\n self.weights = [np.random.normal(0, 1 / np.sqrt(x), (x, y)) for x, y in list(zip(self.structure[1:], self.structure[:-1]))]\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n mean = 0\\n std_dev = 0.0001\\n #print(in_features)\\n #print(out_features)\\n # create weight matrices\\n weight = np.random.normal(mean, std_dev, (out_features, in_features))\\n #print(weight.shape)\\n grad_weight = np.zeros((in_features, out_features))\\n\\n # create biases (in batches)\\n bias = np.zeros(out_features)\\n grad_bias = np.zeros(out_features)\\n\\n self.params = {'weight': weight, 'bias': bias}\\n self.grads = {'weight': bias, 'bias': grad_bias}\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def mutate(self):\\n \\n # Mutate each weight\\n self.w1 = self.w1 + np.random.normal(0, 1, 8).reshape((2,4))\\n self.b1 = self.b1 + np.random.normal(0, 1, 2).reshape((2,1))\\n self.w2 = self.w2 + np.random.normal(0, 1, 4).reshape((2,2))\\n self.b2 = self.b2 + np.random.normal(0, 1, 2).reshape((2,1))\\n self.w3 = self.w3 + np.random.normal(0, 1, 2).reshape((1,2))\\n self.b3 = self.b3 + np.random.normal(0, 1, 1)\\n \\n # Return thyself\\n return self\",\n \"def gen_ran_res_params(self):\\n gen = Generator(device = self.device).manual_seed(self.random_seed)\\n n = self.n_nodes_\\n self.accept = rand(n, n, **self.tensorArgs, generator = gen)\\n self.reservoir_pre_weights = rand(n, n, **self.tensorArgs, generator = gen) * 2 - 1\",\n \"def init_weights(num_tilings, tiles_per_dim, num_dims, num_actions):\\n weights = np.zeros((num_tilings*tiles_per_dim**num_dims*num_actions))\\n return weights\",\n \"def init_weights(self, load_weights=None):\\n if load_weights:\\n # TODO\\n pass\\n else:\\n # x: lower layer nodes n\\n # y: current layer nodes n\\n x = self.weights_shape[1]\\n y = self.weights_shape[0]\\n self.weights = np.random.randn(y, x) / np.sqrt(x) # pylint: disable=no-member\\n self.biases = np.random.randn(y, 1) # pylint: disable=no-member\",\n \"def construct(self, weights):\\n in_weights = weights # first to append zero column as the last output (no out-degree)\\n weights = np.zeros((weights.shape[0], weights.shape[1]+1))\\n weights[:,:-1] = in_weights\\n din, dout, dhid = self.dim_in, self.dim_out, self.dim_hid # the max dim\\n hid = weights.shape[0] - dout # this hidden dim\\n if not (weights.shape[1]-din-dout==hid and (0<hid<=dhid)):\\n raise self.ANNException('weight matrix hidden nodes not matching')\\n if not (dout < weights.shape[0] <= hid+dout):\\n raise self.ANNException('weight matrix row shape not matching')\\n if not (din+dout < weights.shape[1] <= din+hid+dout):\\n raise self.ANNException('weight matrix column shape not matching')\\n\\n self.weight[din:din+hid,:din+hid] = weights[:hid,:din+hid]\\n self.weight[din:din+hid,din+dhid:] = weights[:hid,din+hid:]\\n self.weight[din+dhid:,:din+hid] = weights[hid:,:din+hid]\\n self.weight[din+dhid:,din+dhid:] = weights[hid:,din+hid:]\\n\\n for i in range(hid):\\n self.connectivity[din+i,:din+i] = True\\n self.connectivity[din+dhid:,:din+hid] = True\\n for i in range(dout):\\n self.connectivity[din+dhid+i,din+dhid:din+dhid+i] = True\\n\\n self.hidden[:hid] = True\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\\n # Tie weights if needed\\n self.tie_weights()\",\n \"def instantiate_weights(self):\\n with tf.variable_scope(\\\"embedding_projection\\\"), tf.device('/cpu:0'): # embedding matrix\\n self.Embedding = tf.get_variable(\\\"Embedding\\\", shape=[self.vocab_size, self.embed_size],\\n initializer=self.initializer)\\n # self.Embedding_label = tf.get_variable(\\\"Embedding_label\\\", shape=[self.num_classes, self.embed_size],\\n # dtype=tf.float32) # ,initializer=self.initializer\\n # self.W_projection = tf.get_variable(\\\"W_projection\\\", shape=[self.sequence_length * self.d_model, self.num_classes],\\n # initializer=self.initializer) # [embed_size,label_size]\\n # self.b_projection = tf.get_variable(\\\"b_projection\\\", shape=[self.num_classes])\",\n \"def instantiate_weights(self):\\n with tf.name_scope(\\\"decoder_init_state\\\"):\\n self.W_initial_state = tf.get_variable(\\\"W_initial_state\\\", shape=[self.hidden_size, self.hidden_size*2], initializer=self.initializer)\\n self.b_initial_state = tf.get_variable(\\\"b_initial_state\\\", shape=[self.hidden_size*2])\\n with tf.name_scope(\\\"embedding_projection\\\"): # embedding matrix\\n self.Embedding = tf.get_variable(\\\"Embedding\\\", shape=[self.vocab_size, self.embed_size],initializer=self.initializer) # [vocab_size,embed_size] tf.random_uniform([self.vocab_size, self.embed_size],-1.0,1.0)\\n self.Embedding_label = tf.get_variable(\\\"Embedding_label\\\", shape=[self.num_classes, self.embed_size*2],dtype=tf.float32) #,initializer=self.initializer\\n self.W_projection = tf.get_variable(\\\"W_projection\\\", shape=[self.hidden_size*2, self.num_classes],\\n initializer=self.initializer) # [embed_size,label_size]\\n self.b_projection = tf.get_variable(\\\"b_projection\\\", shape=[self.num_classes])\\n\\n # GRU parameters:update gate related\\n with tf.name_scope(\\\"gru_weights_encoder\\\"):\\n self.W_z = tf.get_variable(\\\"W_z\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.U_z = tf.get_variable(\\\"U_z\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.b_z = tf.get_variable(\\\"b_z\\\", shape=[self.hidden_size])\\n # GRU parameters:reset gate related\\n self.W_r = tf.get_variable(\\\"W_r\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.U_r = tf.get_variable(\\\"U_r\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.b_r = tf.get_variable(\\\"b_r\\\", shape=[self.hidden_size])\\n\\n self.W_h = tf.get_variable(\\\"W_h\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.U_h = tf.get_variable(\\\"U_h\\\", shape=[self.embed_size, self.hidden_size], initializer=self.initializer)\\n self.b_h = tf.get_variable(\\\"b_h\\\", shape=[self.hidden_size])\\n\\n with tf.name_scope(\\\"gru_weights_decoder\\\"):\\n self.W_z_decoder = tf.get_variable(\\\"W_z_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\\n self.U_z_decoder = tf.get_variable(\\\"U_z_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\\n self.C_z_decoder = tf.get_variable(\\\"C_z_decoder\\\", shape=[self.embed_size * 2, self.hidden_size * 2],initializer=self.initializer) #TODO\\n self.b_z_decoder = tf.get_variable(\\\"b_z_decoder\\\", shape=[self.hidden_size*2])\\n # GRU parameters:reset gate related\\n self.W_r_decoder = tf.get_variable(\\\"W_r_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\\n self.U_r_decoder = tf.get_variable(\\\"U_r_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\\n self.C_r_decoder = tf.get_variable(\\\"C_r_decoder\\\", shape=[self.embed_size * 2, self.hidden_size * 2],initializer=self.initializer) #TODO\\n self.b_r_decoder = tf.get_variable(\\\"b_r_decoder\\\", shape=[self.hidden_size*2])\\n\\n self.W_h_decoder = tf.get_variable(\\\"W_h_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer)\\n self.U_h_decoder = tf.get_variable(\\\"U_h_decoder\\\", shape=[self.embed_size*2, self.hidden_size*2], initializer=self.initializer) #TODO\\n self.C_h_decoder = tf.get_variable(\\\"C_h_decoder\\\", shape=[self.embed_size * 2, self.hidden_size * 2],initializer=self.initializer)\\n self.b_h_decoder = tf.get_variable(\\\"b_h_decoder\\\", shape=[self.hidden_size*2])\\n\\n with tf.name_scope(\\\"full_connected\\\"):\\n self.W_fc=tf.get_variable(\\\"W_fc\\\",shape=[self.hidden_size*2,self.hidden_size])\\n self.a_fc=tf.get_variable(\\\"a_fc\\\",shape=[self.hidden_size])\",\n \"def __init__(self, weights:np.ndarray):\\n self.w = weights.copy()\",\n \"def inputs_weights_init(self):\\n input_user, input_item, input_rating = self.inputs_init()\\n user_embeddings, item_embeddings = self.embeddings_layers_init()\\n\\n return input_user, input_item, input_rating, user_embeddings, item_embeddings\",\n \"def init_weights(self):\\n # Initialize weights\\n self.apply(self._init_weights)\",\n \"def u_weights(self):\\n for i in range(self.n_inputs):\\n self._q_neuron.cx(self._weights[i], self.inputs[i])\",\n \"def __init__(self, weights):\\n self._weights = weights\",\n \"def _setup(self) -> None:\\n #TODO: type\\n self.activation = self.params['activation']\\n\\n self.batchsize: int = self.params['batchsize']\\n\\n self.input_shape: Tuple[int,int,int] = self.params['input_shape']\\n\\n self.d: int = self.input_shape[1]\\n assert(not self.d == 0)\\n\\n self.n: int = int(sqrt(self.input_shape[2]))\\n assert(not self.n == 0)\\n\\n self.dtype: type = self.params['dtype']\\n\\n # initialize weights\\n self.W: List[tf.Tensor] = []\\n \\n for i in range(3):\\n #TODO: type\\n w_init = self.params['initializer_w']\\n if self.params['initializer_w' + str(i)] is not None:\\n w_init = self.params['initializer_w' + str(i)]\\n\\n w_stddev: float = self.params['stddev_w']\\n if self.params['stddev_w' + str(i)] is not None:\\n w_stddev = self.params['stddev_w' + str(i)]\\n\\n self.W.append(tf.get_variable(\\\"weights_\\\" + str(i),\\n shape = (self.d, (self.d if i < 2 else 2 * self.d)),\\n dtype = self.dtype,\\n initializer = w_init(stddev=w_stddev)))\\n\\n #TODO: type\\n b_init = self.params['initializer_b']\\n b_stddev = self.params['stddev_b']\\n self.B: tf.Tensor = tf.get_variable(\\\"biases\\\", shape = (1, self.d, 1),\\n dtype = self.dtype,\\n initializer = b_init(stddev=b_stddev))\\n\\n # create/load expand matrix\\n with tf.variable_scope(tf.get_variable_scope(), reuse=tf.AUTO_REUSE):\\n self.expand: tf.Tensor = tf.get_variable(\\n \\\"expand\\\" + str(self.n),\\n shape = (self.n, self.n * self.n),\\n dtype = self.dtype,\\n initializer = tf.constant_initializer(make_expand(self.n)))\\n\\n # create/load tile matrix\\n tile: np.ndarray = np.array([([1] + [0]*(self.n-1))*self.n])\\n for i in range(1, self.n):\\n tile = np.append(tile, [([0]*i + [1] + [0]*(self.n-1-i))*self.n], 0)\\n\\n self.tile: tf.Tensor = tf.constant(tile, self.dtype)\",\n \"def __init__(self, weights):\\r\\n self.totals = []\\r\\n running_total = 0\\r\\n for w in weights:\\r\\n running_total += w\\r\\n self.totals.append(running_total)\",\n \"def __init__(self, input_size, hidden_size, output_size, weight_init_std=0.01):\\n\\n self.params = {}\\n self.params['W1'] = weight_init_std * \\\\\\n np.random.randn(input_size, hidden_size)\\n self.params['b1'] = np.zeros(hidden_size)\\n self.params['W2'] = weight_init_std * \\\\\\n np.random.randn(hidden_size, output_size)\\n self.params['b2'] = np.zeros(output_size)\",\n \"def _generate_weights(self):\\n weights = []\\n for i in range(1, len(self.layers) - 1):\\n weights.append(2 * np.random.random(\\n (self.layers[i - 1] + 1, self.layers[i] + 1)) - 1)\\n weights.append(2 * np.random.random(\\n (self.layers[i] + 1, self.layers[i + 1])) - 1)\\n return weights\",\n \"def init_weights(self):\\n\\n params = torch.load(self.resnet_weight)\\n\\n self.fc1.weight.data = params['state_dict']['module.fc.weight'].clone()\\n self.fc1.bias.data = params['state_dict']['module.fc.bias'].clone()\\n\\n\\n r = np.sqrt(1.) / np.sqrt(self.fc3.in_features +\\n self.fc3.out_features)\\n self.fc3.weight.data.uniform_(-r, r)\\n self.fc3.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc2.in_features +\\n self.fc2.out_features)\\n self.fc2.weight.data.uniform_(-r, r)\\n self.fc2.bias.data.fill_(0)\\n r = np.sqrt(1.) / np.sqrt(self.fc4.in_features +\\n self.fc4.out_features)\\n self.fc4.weight.data.uniform_(-r, r)\\n self.fc4.bias.data.fill_(0)\",\n \"def random_weights_init(self, data):\\n self.check_input_dimension(data)\\n for i in range(self.y_axis):\\n for j in range(self.x_axis):\\n rand_i = self.random_generator.randint(len(data))\\n self.weights[i][j] = data[rand_i]\",\n \"def get_weight_matrix(self):\\n\\n\\t\\treturn self.weights.get_value(borrow=True)\",\n \"def initialize_weights(self, seed=None):\\r\\n if seed!=None:\\r\\n np.random.seed(seed)\\r\\n self.weights = np.random.randn(self.number_of_nodes,self.input_dimensions)\",\n \"def get_weights(self):\",\n \"def init_sg_weights(self):\\n n = self.weights_shape[0] # size of current layer\\n # pylint: disable=no-member\\n A = np.random.randn(n, n) / np.sqrt(n)\\n B = np.random.randn(10, n) / np.sqrt(n)\\n C = np.random.randn(1, n) / np.sqrt(n)\\n # pylint: enable=no-member\\n self.sg_weights = [A, B, C]\",\n \"def build(self, input_shape):\\n assert len(input_shape) == 3\\n assert input_shape[1] == input_shape[2]\\n\\n # Create the weight vector\\n kernel_shape = (input_shape[1], self.out_dim)\\n # if self.initial_weights is not None:\\n # self.set_weights(self.initial_weights)\\n # del self.initial_weights\\n # else:\\n # self.W = self.init(self.W_shape, name='{}_W'.format(self.name))\\n self.kernel = self.add_weight(shape=kernel_shape,\\n initializer=self.kernel_initializer,\\n name='kernel',\\n regularizer=self.kernel_regularizer,\\n constraint=self.kernel_constraint\\n )\\n # self.trainable_weights = [self.W]\\n self.built = True\",\n \"def initialize_weights_xavier(self):\\n\\t\\tself.weights = [np.random.uniform(-1/sqrt(size1), 1/sqrt(size1)) for size1, size2 in zip(self.sizes[:-1], self.sizes[1:])]\\n\\t\\tself.biases = [np.zeros([size, ]) for size in self.sizes[1:]]\",\n \"def init_weight(self):\\r\\n xavier_init(self.output_proj, distribution='uniform', bias=0.)\",\n \"def setWeightInitializer(self,weights):\\n self.init_w = weights\",\n \"def _compute_weight_matrix(self, state_vector_size, number_of_measurements):\\n\\n if self.weighted_estimation and self.model.use_a_priori:\\n weight_matrix = np.zeros((state_vector_size + number_of_measurements,\\n state_vector_size + number_of_measurements), dtype=np.float64)\\n\\n if self._a_priori_state_covariance is not None:\\n weight_matrix[number_of_measurements:,\\n number_of_measurements:] = np.linalg.inv(self.a_priori_state_covariance)\\n else:\\n weight_matrix[number_of_measurements:, number_of_measurements:] = np.eye(state_vector_size)\\n\\n if self._measurement_covariance is not None:\\n if np.isscalar(self.measurement_covariance):\\n measurement_info = 1 / self.measurement_covariance\\n for i in range(number_of_measurements):\\n weight_matrix[i, i] = measurement_info\\n else:\\n weight_matrix[:number_of_measurements,\\n :number_of_measurements] = np.linalg.inv(self.measurement_covariance)\\n else:\\n for i in range(number_of_measurements):\\n weight_matrix[i, i] = 1\\n\\n elif self.weighted_estimation:\\n if self._measurement_covariance is not None:\\n if np.isscalar(self.measurement_covariance):\\n weight_matrix = 1/self.measurement_covariance\\n else:\\n weight_matrix = np.linalg.inv(self.measurement_covariance)\\n else:\\n weight_matrix = 1\\n\\n elif self.model.use_a_priori:\\n weight_matrix = np.eye(state_vector_size + number_of_measurements, dtype=np.float64)\\n if self._a_priori_state_covariance is not None:\\n weight_matrix[number_of_measurements:,\\n number_of_measurements:] = np.linalg.inv(self.a_priori_state_covariance)\\n\\n else:\\n weight_matrix = 1\\n\\n return weight_matrix\",\n \"def default_weight_initializer(self):\\n self.biases = [np.random.randn(y, 1) for y in self.sizes[1:]]\\n self.weights = [np.random.randn(y, x)/np.sqrt(x)\\n for x, y in zip(self.sizes[:-1], self.sizes[1:])]\",\n \"def __init__(self, in_units, out_units):\\n np.random.seed(42)\\n #self.w = None # Declare the Weight matrix\\n #self.b = None # Create a placeholder for Bias\\n self.x = None # Save the input to forward in this\\n self.a = None # Save the output of forward pass in this (without activation)\\n\\n self.d_x = None # Save the gradient w.r.t x in this\\n self.d_w = None # Save the gradient w.r.t w in this\\n self.d_b = None # Save the gradient w.r.t b in this\\n self.d_v_w = None\\n self.d_v_b = None\\n\\n self.w = np.random.normal(0, np.sqrt(1/in_units), (in_units, out_units))\\n self.b = np.zeros((1, out_units))\\n self.d_v_w = np.zeros((in_units, out_units))\\n self.d_v_b = np.zeros((1, out_units))\",\n \"def get_weights(self, nn_weights, rov_id): # Get weights from CCEA population\\n\\n for w in range(self.n_weights):\\n self.weights[rov_id, w] = nn_weights[w]\",\n \"def initialize_weights(self, input_dim, std_dev=1e-2):\\n \\n self.params = {}\\n\\n hidden_size = self.hidden_size\\n num_classes = self.num_classes\\n num_layers = self.num_layers\\n #############################################################################\\n # TODO: Initialize the weight and bias of every layer. Store the weights W #\\n # of every layer in the dictionary names self.params. #\\n # For example, Weights and bias of layer 1 will be stored in #\\n # self.params[\\\"W1\\\"] and self.params[\\\"b1\\\"] respectively. #\\n #############################################################################\\n # input_dim * hidden_size\\n self.params[\\\"W1\\\"] = np.random.randn(input_dim, self.hidden_size) * std_dev\\n self.params[\\\"b1\\\"] = np.zeros(self.hidden_size)\\n\\n # hidden_size * num_classes\\n self.params[\\\"W2\\\"] = np.random.randn(self.hidden_size, self.num_classes) * std_dev\\n self.params[\\\"b2\\\"] = np.zeros(self.num_classes)\\n #############################################################################\\n # END OF YOUR CODE #\\n ############################################################################# \",\n \"def create_matrix(self):\\n\\n self.matrix = np.zeros((len(self.users), len(self.items)))\\n\\n for user in self.train_set['users']:\\n for item in self.train_set['feedback'][user]:\\n self.matrix[self.user_to_user_id[user]][self.item_to_item_id[item]] = \\\\\\n self.train_set['feedback'][user][item]\",\n \"def reservoir_generator(\\n number_of_reservoirs=None, sparsity_level=None, reservoir_dim=None\\n):\\n reservoir_computing = ReservoirComputing(\\n reservoir_dim=reservoir_dim, sparsity_level=sparsity_level\\n )\\n\\n return [reservoir_computing.create_reservoir() for n in range(number_of_reservoirs)]\",\n \"def create_population(self):\\r\\n\\r\\n model_weights_vector = model_weights_as_vector(model=self.model)\\r\\n\\r\\n net_population_weights = []\\r\\n net_population_weights.append(model_weights_vector)\\r\\n\\r\\n for idx in range(self.num_solutions-1):\\r\\n\\r\\n net_weights = copy.deepcopy(model_weights_vector)\\r\\n net_weights = numpy.array(net_weights) + numpy.random.uniform(low=-1.0, high=1.0, size=model_weights_vector.size)\\r\\n\\r\\n # Appending the weights to the population.\\r\\n net_population_weights.append(net_weights)\\r\\n\\r\\n return net_population_weights\",\n \"def _buildWeights(self):\\r\\n # Compute the spatial tree\\r\\n kd = spatial.cKDTree(self.XYin)\\r\\n \\r\\n # Perform query on all of the points in the grid\\r\\n dist,self.ind=kd.query(self.XYout,distance_upper_bound=self.maxdist,k=self.NNear)\\r\\n \\r\\n self.Nc = np.size(self.ind,axis=0)\\r\\n print '%d interpolation points.'%self.Nc\\r\\n # Now loop through and get the weights for each point\\r\\n self.W = np.zeros((self.NNear,self.Nc))\\r\\n\\r\\n # Print percentages\\r\\n p0=0\\r\\n pstep=5\\r\\n for ii in range(0,self.Nc):\\r\\n \\r\\n if self.verbose:\\r\\n pfinish = float(ii)/float(self.Nc)*100.0\\r\\n if pfinish> p0:\\r\\n print '%3.1f %% complete...'%pfinish\\r\\n p0+=pstep\\r\\n \\r\\n W = self.getWeights(dist[ii,:],self.XYin[self.ind[ii,:],0],self.XYin[self.ind[ii,:],1])\\r\\n self.W[:,ii] = W.T\",\n \"def __init__(self, input_dimension):\\r\\n self.input_dimension = input_dimension\\r\\n self.weights = []\\r\\n self.biases = []\\r\\n self.transferfunction = []\",\n \"def _create_generate_input(self):\\n self.keep_prob = 1.\",\n \"def build(self, input_shape):\\n\\n # get shape of input matrix x\\n num_of_vertices = input_shape[1]\\n num_of_features = input_shape[2]\\n num_of_timesteps = input_shape[3]\\n #self.U_1.shape = (num_of_vertices,)\\n #self.U_2.shape = (num_of_features, num_of_vertices)\\n #self.U_3.shape = (num_of_features,)\\n #self.b_e.shape = (1, num_of_timesteps, num_of_timesteps)\\n #self.V_e.shape = (num_of_timesteps, num_of_timesteps)\\n\\n self.u1 = self.add_weight(name='u1', shape=(num_of_vertices, ),\\n initializer='glorot_normal', trainable=True)\\n self.u2 = self.add_weight(name='u2', shape=(num_of_features, num_of_vertices),\\n initializer='glorot_normal', trainable=True)\\n self.u3 = self.add_weight(name='u3', shape=(num_of_features,),\\n initializer='glorot_normal', trainable=True)\\n self.b = self.add_weight(name='b', shape=(1, num_of_timesteps, num_of_timesteps),\\n initializer='zeros', trainable=True)\\n self.v = self.add_weight(name='v', shape=(num_of_timesteps, num_of_timesteps),\\n initializer='glorot_normal', trainable=True)\\n\\n super(Temporal_Attention_layer, self).build(input_shape)\",\n \"def initialize_weights(self):\\n w1 = np.random.uniform(-1.0, 1.0, size = self.n_hidden * (self.n_features + 1)).reshape(self.n_hidden, (self.n_features + 1))/(self.n_features + 1)\\n w2 = np.random.uniform(-1.0, 1.0, size=self.n_output*(self.n_hidden+1)).reshape(self.n_output, self.n_hidden+ 1)/(self.n_hidden + 1)\\n return w1, w2\",\n \"def init_weights(self):\\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\\n self.fc.out_features)\\n self.fc.weight.data.uniform_(-r, r)\\n self.fc.bias.data.fill_(0)\",\n \"def init_weights(self):\\n r = np.sqrt(6.) / np.sqrt(self.fc.in_features +\\n self.fc.out_features)\\n self.fc.weight.data.uniform_(-r, r)\\n self.fc.bias.data.fill_(0)\",\n \"def weighted_matrix(point: np.mat, training_data_x: np.mat, bandwidth: float) -> np.mat:\\r\\n # m is the number of training samples\\r\\n m, n = np.shape(training_data_x)\\r\\n # Initializing weights as identity matrix\\r\\n weights = np.mat(np.eye((m)))\\r\\n # calculating weights for all training examples [x(i)'s]\\r\\n for j in range(m):\\r\\n diff = point - training_data[j]\\r\\n weights[j, j] = np.exp(diff * diff.T / (-2.0 * bandwidth ** 2))\\r\\n return weights\",\n \"def my_assign_weights(context, data):\\n pass\",\n \"def randomize(self):\\n self.weights = np.random.rand(*self.weights.shape) - 0.5\",\n \"def weights(self, weights):\\n\\n self._weights = weights\",\n \"def set_weights(self, weights):\\r\\n self.weights = weights\",\n \"def initialize_weights_and_bias(self, X_train):\\n n_samples, n_features = np.shape(X_train)\\n n_output = 1 \\n \\n # This is the numeber of gridcells and we want to make one prediction pr cell. \\n # It this doesn't work calculate the number of griddcells.\\n\\n self.b_h = [] #np.ones((self.n_hidden_layers, self.n_hidden[0]))\\n self.W_h = []\\n\\n for i in range(len(self.n_hidden)):\\n if (i == 0):\\n self.W_h.append(self.random.normal(loc=0.0, scale=0.1, size=(n_features, self.n_hidden[0])))\\n self.b_h.append(np.ones(self.n_hidden[0]))\\n else:\\n self.W_h.append(self.random.normal(loc=0.0, scale=0.1, size=(self.n_hidden[i-1], self.n_hidden[i])))\\n self.b_h.append(np.ones(self.n_hidden[i])) \\n \\n self.b_out = [1]\\n self.W_out = self.random.normal(loc=0.0, scale=0.1, size=(self.n_hidden[-1], n_output))\",\n \"def __init__(self, sizes):\\n self.sizes = sizes\\n self.biases = [random_matrix(1, y)[0] for y in sizes[1:]]\\n self.weights = [random_matrix(y, x)\\n for x, y in zip(sizes[:-1], sizes[1:])]\\n\\n self.weighted_layer = []\\n self.activations = []\",\n \"def initialize_weights(self, seed=None):\\n if seed != None:\\n np.random.seed(seed)\\n self.weights = np.random.randn(self.number_of_nodes, self.input_dimensions)\",\n \"def init_weights(self, num_features):\\n for each_label in self.valid_labels:\\n self.weights[each_label] = np.zeros(num_features)\",\n \"def generate_weights(self, mag=1):\\n \\n if (len(self.hlayers) == 0):\\n print(\\\"No weights to generate! Please add hidden layers.\\\")\\n return\\n \\n weights = []\\n \\n insize = self.inputLayerSize\\n if (self.inputBias == True):\\n insize += 1\\n \\n layersize = self.hlayers[0].size\\n if (self.hlayers[0].bias == True):\\n layersize += 1\\n \\n weights.append(np.random.randn(insize, layersize)*mag)\\n \\n for i in range(0, len(self.hlayers)-1):\\n layer1size = self.hlayers[i].size\\n if (self.hlayers[i].bias == True):\\n layer1size+=1\\n \\n layer2size = self.hlayers[i+1].size\\n if (self.hlayers[i+1].bias == True):\\n layer2size+=1\\n \\n weights.append(np.random.randn(layer1size, layer2size))\\n \\n \\n self.weights = weights\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n\\n\\n self.params = {'weight': 0.0001 * np.random.randn(out_features, in_features), 'bias': np.zeros((out_features, 1))}\\n self.grads = {'weight': np.zeros((out_features, in_features)), 'bias': np.zeros((out_features, 1))}\\n\\n\\n\\n ########################\\n # END OF YOUR CODE #\\n #######################\",\n \"def init_weight(self):\\n init_bn(self.norm0)\",\n \"def __init__(self, input, weight_init=None):\\n n_in = input.get_shape()[1].value\\n \\n self.input = input\\n \\n # Initiate the weight for the input layer\\n r = 4*np.sqrt(3.0/n_in)\\n\\n if weight_init is None:\\n self.w = tf.Variable(tf.random_uniform([n_in,],-r, r), name='w')\\n else: \\n self.w = tf.Variable(weight_init, name='w')\\n\\n self.output = self.w * self.input\",\n \"def _allocation_weights(self, write_gates, num_writes, usage):\\n write_gates = write_gates.unsqueeze(-1)\\n allocation_weights = []\\n for i in range(num_writes):\\n allocation = self._allocate(usage)\\n allocation_weights.append(allocation)\\n usage = usage + ((1-usage)*write_gates[:, i, :]*allocation_weights[i])\\n allocation_weights = torch.stack(allocation_weights, 1)\\n return allocation_weights\",\n \"def __init__(self, layer_neuron):\\n\\n self.num_layers = len(layer_neuron)\\n self.layer_neuron = layer_neuron\\n #a list of numpy ndarrays\\n self.weights = []\\n self.input_len = 0\\n self.target_vals = []\\n self.current_guess = 0\\n\\n self.layer_inputs = [[]]*(len(layer_neuron))\\n self.layer_outputs = [[]]*(len(layer_neuron))\\n #deltas: don't include input layer but still put it in for spacing ie self.deltas[0] should always be empty\\n self.deltas = [[]]*((len(layer_neuron)))\\n\\n #make the weight matrices, each matrix nXm matrix with m = # nodes in the ith layer (incl bias) and n = # nodes in the (i+1)th layer\\n #each row represents the set of weights from all m neurons in the ith layer to a single neuron in the (i+1)th layer\\n #conversely, each column is all the output weights from a node in the ith layer, to each n nodes in the (i+1)th layer\\n #the right-most column represents output weights from the bias node\\n for i in range(len(self.layer_neuron)-1 ):\\n np.random.seed(0)\\n self.weights.append(np.random.normal( scale = 0.2, size = (self.layer_neuron[i+1], self.layer_neuron[i] + 1)))\",\n \"def update_weights(self):\\n self._weights = self._weights + self.update_weights_value\",\n \"def start_weights(self, inv=True):\\n return np.eye(self.nmoms)\",\n \"def __init__(self, in_features, out_features):\\n \\n ########################\\n # PUT YOUR CODE HERE #\\n #######################\\n self.params = {'weight': np.random.normal(loc = 0, scale=0.0001, size=(out_features,in_features)),\\\\\\n 'bias': np.zeros((1, out_features))}\\n \\n self.grads = {'weight': np.zeros((out_features,in_features)),\\\\\\n 'bias': np.zeros((1, out_features))}\\n ########################\\n # END OF YOUR CODE #\\n #######################\"\n]","isConversational":false},"negative_scores":{"kind":"list like","value":["0.6588077","0.6578553","0.6390781","0.63611436","0.62566054","0.6168489","0.61538434","0.6151322","0.61275256","0.60950416","0.6008337","0.60010517","0.5981402","0.597326","0.5969377","0.59672725","0.5951049","0.5945711","0.59425867","0.5930853","0.58823884","0.5874685","0.5867976","0.58666503","0.5861858","0.58470917","0.58463806","0.58372563","0.5834285","0.5830287","0.58021635","0.58021635","0.58021635","0.5800384","0.5783221","0.57770944","0.5776825","0.57491016","0.5748755","0.5720642","0.5719141","0.5717069","0.56735903","0.56690145","0.5654642","0.5652632","0.5646057","0.56450856","0.5636543","0.56351835","0.5627896","0.56250703","0.5622735","0.5601264","0.5600812","0.5598231","0.5589869","0.55820954","0.5577472","0.5572203","0.5556443","0.554495","0.5541235","0.55392295","0.5531848","0.55179703","0.55104035","0.55099976","0.5507995","0.5496086","0.54892564","0.5488192","0.54863566","0.54791105","0.54743785","0.54737866","0.54727954","0.54617935","0.5459213","0.5459202","0.5456346","0.5456346","0.54454523","0.5439958","0.5437536","0.542733","0.5424207","0.5422732","0.5419318","0.54158115","0.54150665","0.54127985","0.5410775","0.5405828","0.5402791","0.54025096","0.5401753","0.53970873","0.53936344","0.539057"],"string":"[\n \"0.6588077\",\n \"0.6578553\",\n \"0.6390781\",\n \"0.63611436\",\n \"0.62566054\",\n \"0.6168489\",\n \"0.61538434\",\n \"0.6151322\",\n \"0.61275256\",\n \"0.60950416\",\n \"0.6008337\",\n \"0.60010517\",\n \"0.5981402\",\n \"0.597326\",\n \"0.5969377\",\n \"0.59672725\",\n \"0.5951049\",\n \"0.5945711\",\n \"0.59425867\",\n \"0.5930853\",\n \"0.58823884\",\n \"0.5874685\",\n \"0.5867976\",\n \"0.58666503\",\n \"0.5861858\",\n \"0.58470917\",\n \"0.58463806\",\n \"0.58372563\",\n \"0.5834285\",\n \"0.5830287\",\n \"0.58021635\",\n \"0.58021635\",\n \"0.58021635\",\n \"0.5800384\",\n \"0.5783221\",\n \"0.57770944\",\n \"0.5776825\",\n \"0.57491016\",\n \"0.5748755\",\n \"0.5720642\",\n \"0.5719141\",\n \"0.5717069\",\n \"0.56735903\",\n \"0.56690145\",\n \"0.5654642\",\n \"0.5652632\",\n \"0.5646057\",\n \"0.56450856\",\n \"0.5636543\",\n \"0.56351835\",\n \"0.5627896\",\n \"0.56250703\",\n \"0.5622735\",\n \"0.5601264\",\n \"0.5600812\",\n \"0.5598231\",\n \"0.5589869\",\n \"0.55820954\",\n \"0.5577472\",\n \"0.5572203\",\n \"0.5556443\",\n \"0.554495\",\n \"0.5541235\",\n \"0.55392295\",\n \"0.5531848\",\n \"0.55179703\",\n \"0.55104035\",\n \"0.55099976\",\n \"0.5507995\",\n \"0.5496086\",\n \"0.54892564\",\n \"0.5488192\",\n \"0.54863566\",\n \"0.54791105\",\n \"0.54743785\",\n \"0.54737866\",\n \"0.54727954\",\n \"0.54617935\",\n \"0.5459213\",\n \"0.5459202\",\n \"0.5456346\",\n \"0.5456346\",\n \"0.54454523\",\n \"0.5439958\",\n \"0.5437536\",\n \"0.542733\",\n \"0.5424207\",\n \"0.5422732\",\n \"0.5419318\",\n \"0.54158115\",\n \"0.54150665\",\n \"0.54127985\",\n \"0.5410775\",\n \"0.5405828\",\n \"0.5402791\",\n \"0.54025096\",\n \"0.5401753\",\n \"0.53970873\",\n \"0.53936344\",\n \"0.539057\"\n]","isConversational":false},"document_score":{"kind":"string","value":"0.688277"},"document_rank":{"kind":"string","value":"0"}}}],"truncated":false,"partial":true},"paginationData":{"pageIndex":808,"numItemsPerPage":100,"numTotalItems":95772,"offset":80800,"length":100}},"jwt":"eyJhbGciOiJFZERTQSIsImtpZCI6IjVHZDBvd0g5MTM2eDZjc1FvbE1zcktNWUZoRVFoUm5PVVVybEpjOUhaUEEifQ.eyJyZWFkIjp0cnVlLCJwZXJtaXNzaW9ucyI6eyJyZXBvLmNvbnRlbnQucmVhZCI6dHJ1ZX0sImlhdCI6MTc4NjIwMzc3NCwianRpIjoiMjAxNDFkMjMtMDgxMi00ODYzLTk1ZDUtMThjM2NhYjMzYzExIiwic3ViIjoiL2RhdGFzZXRzL25vbWljLWFpL2Nvcm5zdGFjay1weXRob24tdjEiLCJleHAiOjE3ODYyMDczNzQsImlzcyI6Imh0dHBzOi8vaHVnZ2luZ2ZhY2UuY28ifQ.aCojVCXMhLkWyUtbIHLdWmor8big_WYDnAuy3onf_Q9fWq95_TP-I28v41vXliA19sqacEMJY5iGseGP3FljDQ","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 |
|---|---|---|---|---|---|---|
Called whenever a TreeView CellRendererCombo changes. | def _callback_combo_cell(self, cell, path, row, position, treemodel):
_model = cell.get_property('model')
_text = _model.get_value(row, 0)
_index = _model.get_value(row, 1)
_row = treemodel.get_iter(path)
_position = treemodel.get_value(_row, 0)
self._file_ind... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def dtype_renderer(_, cell_combobox, tree_model, tree_iter, data):\n\n cell_data = tree_model.get(tree_iter, data)[0]\n cell_combobox.set_property('markup', cell_data)",
"def on_update(self, evt):\n print(evt)\n for name in self.widgetNames:\n try:\n widget =... | [
"0.6301629",
"0.60591346",
"0.5772276",
"0.5725532",
"0.570038",
"0.5699218",
"0.5694901",
"0.56887126",
"0.56836426",
"0.5682939",
"0.5668681",
"0.5616144",
"0.56152225",
"0.5610774",
"0.5610497",
"0.55741537",
"0.54920083",
"0.5479639",
"0.546265",
"0.542697",
"0.54137105",... | 0.58461034 | 2 |
Method to select the next page to display in the gtk.Assistant(). | def _forward_page_select(self, current_page):
if current_page == 0:
Widgets.select_source_file()
else:
self.assistant.set_current_page(current_page + 1) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def next_page(self):\n await self.checked_show_page(self.current_page + 1)",
"def on_btPageNext_clicked(self, widget, data=None):\n\n self.page += 1\n self.part = 1\n self.refresh()",
"def page_next(self):\n if self._pos >= self._npages - 1:\n # exit if we ar... | [
"0.7328594",
"0.7100112",
"0.70442396",
"0.69027823",
"0.6866997",
"0.68475306",
"0.6694222",
"0.66374034",
"0.66024095",
"0.65457445",
"0.6483976",
"0.6460912",
"0.6437389",
"0.63962895",
"0.63957286",
"0.63767684",
"0.6374295",
"0.63613486",
"0.63521147",
"0.6341415",
"0.63... | 0.7017663 | 3 |
Method to perform the import from an external file to the database. | def _import(self, __button):
# WARNING: Refactor _import; current McCabe Complexity metric = 18.
Widgets.set_cursor(self.modulebook.mdcRTK, gtk.gdk.WATCH)
_import_errors = 0
self._import_log.info('The following records could not be imported to '
'the open RTK... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def import_db(import_file):\n import_data(import_file)",
"def doImport(self,textFile):\n self.loadText(textFile)\n self.getBooks()\n #self.copyBooks()\n self.genLibData()\n self.genLibCells()\n self.sortRecords()",
"def import_datafile(db, infile):\n res = stat(i... | [
"0.7735373",
"0.7295176",
"0.697421",
"0.68624216",
"0.678745",
"0.6640836",
"0.6624564",
"0.6623868",
"0.6601897",
"0.6507418",
"0.64830714",
"0.64803714",
"0.64775556",
"0.6451412",
"0.64196897",
"0.64148647",
"0.63720393",
"0.63610643",
"0.6337512",
"0.6286383",
"0.6262567... | 0.56376576 | 88 |
Method to destroy the gtk.Assistant() when the 'Cancel' button is pressed. | def _cancel(self, __button=None):
self.destroy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _cancel(self, __button):\r\n\r\n self.assistant.destroy()",
"def _cancel(self, __button):\r\n\r\n self.assistant.destroy()",
"def _cancel(self, __button):\r\n\r\n self.assistant.destroy()\r\n\r\n return True",
"def _cancel(self, __button):\r\n\r\n self.assistant.destroy... | [
"0.8206024",
"0.8206024",
"0.79243636",
"0.79243636",
"0.778344",
"0.7699403",
"0.7565627",
"0.7277799",
"0.7239998",
"0.7185877",
"0.71814096",
"0.71814096",
"0.71814096",
"0.71814096",
"0.7146208",
"0.7134025",
"0.7118102",
"0.7106568",
"0.70976335",
"0.70909566",
"0.702251... | 0.7773188 | 5 |
Method to initialize the Dataset Creation Assistant. | def __init__(self, revision_id, dao, modulebook):
self._revision_id = revision_id
self._dao = dao
self._mdcRTK = modulebook.mdcRTK
self._user_log = self._mdcRTK.user_log
self._error_log = self._mdcRTK.debug_log
self.assistant = gtk.Assistant()
self.assi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self):\n self.args = self._prepare_args(locals())\n self.requires_full_dataset_in_memory = False",
"def __init__(self, dataset: Dataset):\n self.dataset = dataset",
"def __init__(self, config):\n logger.info(f\"{self.__class__.__name__}: Dataset initializing ...\")\n ... | [
"0.7250235",
"0.71499467",
"0.7128493",
"0.71102935",
"0.7108117",
"0.70734257",
"0.6980016",
"0.69373757",
"0.69373757",
"0.6916405",
"0.6898898",
"0.6836148",
"0.67758644",
"0.6714511",
"0.669846",
"0.6692336",
"0.66413635",
"0.657534",
"0.65685534",
"0.6556035",
"0.6534137... | 0.0 | -1 |
Method to create the desired data set. | def _create(self, __button):
_starttime = 0.01
if self.chkIncludeZeroHour.get_active():
_starttime = 0.0
_window = self.assistant.get_root_window()
_window.set_cursor(gtk.gdk.Cursor(gtk.gdk.WATCH))
self._user_log.info('The following records contained incon... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_dataset(self, df, **kwargs):\n\t\treturn df",
"def create_dataset(self, config, rng):\n raise NotImplementedError()",
"def CreateDataset(all_arrays):\n dataset = Dataset()\n\n dataset._addData(all_arrays[0])\n dataset._addData(all_arrays[1])\n dataset._addData(all_arrays[3])\n da... | [
"0.70453256",
"0.6922411",
"0.6899861",
"0.68166924",
"0.6785154",
"0.67195886",
"0.67177",
"0.66705185",
"0.66680634",
"0.6660379",
"0.66327846",
"0.6578836",
"0.6565758",
"0.65452504",
"0.6543981",
"0.654061",
"0.6494028",
"0.6439976",
"0.6436005",
"0.6413727",
"0.63693416"... | 0.0 | -1 |
Method to retrieve the needed information from the Incidents used to create the dataset. These records are selected for each unique unit (serial number). Index Field 0 Unit 1 Incident ID 2 Age at Incident 3 Failure 4 Suspension 5 CND/NFF 6 OCC 7 Initial Installation 8 Interval Censored 9 Date of the failure 10 ID of th... | def _get_unit_records(self, start_time):
if self.optMTTF.get_active():
_query = "SELECT t2.fld_unit, t1.fld_incident_id, \
t1.fld_age_at_incident, t1.fld_failure, \
t1.fld_suspension, t1.fld_cnd_nff, \
t1.f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _add_incident(self, __assistant):\r\n\r\n _report_date = int(datetime.strptime(self.txtIncidentDate.get_text(),\r\n '%Y-%m-%d').toordinal())\r\n\r\n # Retrieve the hardware ID.\r\n _model = self.cmbHardware.get_model()\r\n _row = self.cmbH... | [
"0.57536614",
"0.5481979",
"0.53963405",
"0.5357369",
"0.5326373",
"0.5305927",
"0.52503014",
"0.5235574",
"0.52347976",
"0.52118707",
"0.5211007",
"0.51795655",
"0.51644355",
"0.5160609",
"0.5141189",
"0.5104027",
"0.5090462",
"0.50888133",
"0.5073454",
"0.50615627",
"0.5048... | 0.5210027 | 11 |
Method to create the dataset in the open RTK Program database. | def _create_database_dataset(self, records):
_error_codes = {}
_n_records = len(records)
_model = self.cmbAssembly.get_model()
_row = self.cmbAssembly.get_active_iter()
if _row is not None:
_assembly_id = int(_model.get_value(_row, 1))
else:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_dataset():\n with open(\"/root/config.json\", \"r\") as f:\n config = json.load(f)\n\n # create environmental variables\n for (key, value) in config.items():\n os.environ[key] = str(value)\n\n # run blender\n command = '/usr/lib/blender/blender {} --python {} --background'.\... | [
"0.66761166",
"0.66439116",
"0.6432056",
"0.6427152",
"0.636086",
"0.63562626",
"0.63007087",
"0.6297554",
"0.6290237",
"0.6272374",
"0.62524605",
"0.61955",
"0.6192515",
"0.6177259",
"0.61664534",
"0.6138961",
"0.61388063",
"0.6124431",
"0.61214566",
"0.61212283",
"0.6097022... | 0.5956848 | 34 |
Method to write the dataset to a tabdelimited text file. | def _create_file_dataset(self, records):
_error_codes = {}
_n_inconsistent = 0
_n_records = len(records)
_dialog = gtk.FileChooserDialog(_(u"RTK: Save Data Set to File ..."),
None,
gtk.DIALOG_MODAL ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def write_tsv(self, filename):\n f = open(filename,'wb')\n wr = csv.writer(f,delimiter='\\t',quoting=csv.QUOTE_ALL)\n colrow = []\n for col in self.cols:\n colrow.append('<undefined>' if len(col) == 0 else unicode(iter(col).next()).encode('unicode-escape'))\n wr.writerow(colrow)\n for row in... | [
"0.74253374",
"0.702671",
"0.69083136",
"0.6866071",
"0.68016654",
"0.67348534",
"0.66835433",
"0.6676557",
"0.64720863",
"0.6466156",
"0.63180023",
"0.6286354",
"0.62192506",
"0.6193875",
"0.6173985",
"0.6165282",
"0.6139323",
"0.61242396",
"0.6102107",
"0.6093505",
"0.60915... | 0.0 | -1 |
Method to find the left of the censoring interval. | def _interval_left(self, current_id, previous_id, current_time,
previous_time):
_left = 0.0
# Create the next set of values to insert to the RTK Program database.
if current_id == previous_id: # Same assembly.
# Failures occurred at same time.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def left(self):\n x, y = (self.loc[0] - 1, self.loc[1])\n\n if x < 0:\n return None # None\n\n return self.garden.cells[y][x]",
"def left(self) -> float:\n points = self.get_adjusted_points()\n x_points = [point[0] for point in points]\n return min(x_points)"... | [
"0.6929066",
"0.6657257",
"0.6575676",
"0.6462427",
"0.64477015",
"0.644351",
"0.63599294",
"0.63291794",
"0.62973046",
"0.6228218",
"0.62196445",
"0.6210174",
"0.6169352",
"0.6147318",
"0.6147318",
"0.61322093",
"0.61322093",
"0.6128858",
"0.609009",
"0.609009",
"0.60566986"... | 0.55960745 | 65 |
Method to check the consistency of the data records. | def _consistency_check(self, results1, results2):
_return = False
_previous_date = Utilities.ordinal_to_date(results1[9])
_current_date = Utilities.ordinal_to_date(results2[9])
# Failure dates are descending on the same unit.
if results1[0] == results2[0] and _current_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_consistency(self):\n raise NotImplementedError()",
"def check_consistency(self, es):",
"def _check_write_consistency(self):\n self.logger.warning('Not checking write consistency')",
"def testConsistency(self):",
"def check_integrity(self):\n curves = list()\n data = li... | [
"0.76115924",
"0.70205414",
"0.6738994",
"0.6574973",
"0.6547124",
"0.6460398",
"0.6396284",
"0.63230306",
"0.6292776",
"0.62845105",
"0.6257688",
"0.6257247",
"0.62293327",
"0.61924773",
"0.61882615",
"0.61746573",
"0.6087411",
"0.608622",
"0.6084936",
"0.6073561",
"0.607011... | 0.59595335 | 27 |
Method to destroy the gtk.Assistant() when the 'Cancel' button is pressed. | def _cancel(self, __button):
self.assistant.destroy() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _cancel(self, __button):\r\n\r\n self.assistant.destroy()\r\n\r\n return True",
"def _cancel(self, __button):\r\n\r\n self.assistant.destroy()\r\n\r\n return True",
"def _cancel(self, __button):\r\n\r\n self.destroy()",
"def _cancel(self, __button=None):\r\n\r\n ... | [
"0.79243636",
"0.79243636",
"0.778344",
"0.7773188",
"0.7699403",
"0.7565627",
"0.7277799",
"0.7239998",
"0.7185877",
"0.71814096",
"0.71814096",
"0.71814096",
"0.71814096",
"0.7146208",
"0.7134025",
"0.7118102",
"0.7106568",
"0.70976335",
"0.70909566",
"0.702251",
"0.6953730... | 0.8206024 | 1 |
This function calculate the area limited by two parallels with latitude phi1 and phi2 and two meridians with longitudes lambda1 & lambda2 | def CalculateArea(**kwargs):
a = 0
b = 0
try:
if kwargs["ref"] == "local":
a = 6378249.145
b = 6356515
elif kwargs["ref"] == "global":
a = 6378137
b = 6356752.314
elif kwargs["a"] and kwargs["b"]:
a = kwargs["a"]
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_area(self):\n min_lat_point = self.latitude_min\n max_lat_point = self.latitude_max\n min_lon_point = self.longitude_min\n max_lon_point = self.longitude_max\n self.rename_latitude()\n self.rename_longitude()\n all_lat_bounds = self.cube.coord('latitude').b... | [
"0.6399715",
"0.6087621",
"0.60766757",
"0.5999493",
"0.58296216",
"0.5825475",
"0.5802816",
"0.5800075",
"0.5776443",
"0.57385135",
"0.57352257",
"0.5726864",
"0.5686812",
"0.56670666",
"0.5606422",
"0.55991405",
"0.5575907",
"0.55371463",
"0.5506155",
"0.5502419",
"0.549210... | 0.71243757 | 0 |
Delete nonASCII characters from the value and replace spaces with underscores. Also strip slashes and percent signs. | def create_filename(value):
return '%s.mp3' % slugify(value, u'_') | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sanitize(value):\n from re import sub\n from unicodedata import normalize\n value = normalize('NFKD', value).encode('ascii', 'ignore')\n value = sub('[^\\w\\s\\.-]', '', value.decode('utf-8')).strip().lower()\n return sub('[-_\\s]+', '_', value)",
"def clean(value):\r\n return re.sub('_+', ... | [
"0.7760493",
"0.737788",
"0.7278582",
"0.71347755",
"0.7038228",
"0.6997225",
"0.6973475",
"0.6943967",
"0.68070024",
"0.67693675",
"0.673018",
"0.66745275",
"0.6669343",
"0.6668114",
"0.66416174",
"0.66414165",
"0.6625625",
"0.66158426",
"0.6610128",
"0.6579192",
"0.65424407... | 0.0 | -1 |
Retrieve the YouTube videos' information without downloading it. | def get_video_info(url):
ydl = youtube_dl.YoutubeDL()
ydl.add_default_info_extractors()
try:
return ydl.extract_info(url, download=False)
except youtube_dl.DownloadError:
return None | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def download_video_data(self):\n\n def scrape_url(url):\n \"\"\"Scrape the video list, youtube_dl does all the heavy lifting\"\"\"\n ydl_opts = {\n \"ignoreerrors\": True, # Skip private and unavaliable videos\n }\n\n ydl = youtube_dl.YoutubeDL(ydl... | [
"0.73148847",
"0.7152286",
"0.70561045",
"0.6936934",
"0.68171096",
"0.6795956",
"0.67740524",
"0.6649615",
"0.663882",
"0.66018647",
"0.65990466",
"0.65833545",
"0.6548317",
"0.6514101",
"0.64686304",
"0.64671814",
"0.6407992",
"0.6407309",
"0.64061856",
"0.6404336",
"0.6380... | 0.6628065 | 9 |
Retrieve the client's IPv4 address from the request object. | def get_client_ip(request):
x_forwarded_for = request.META.get('HTTP_X_FORWARDED_FOR')
if x_forwarded_for:
ip = x_forwarded_for.split(',')[0]
else:
ip = request.META.get('REMOTE_ADDR')
return ip | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ipv4_address(self) -> str:\n return pulumi.get(self, \"ipv4_address\")",
"def ipv4_address(self) -> str:\n return pulumi.get(self, \"ipv4_address\")",
"def ipv4_address(self) -> Optional[pulumi.Input[str]]:\n return pulumi.get(self, \"ipv4_address\")",
"def get_address(self):\n ... | [
"0.79848325",
"0.79848325",
"0.7941039",
"0.757721",
"0.7535313",
"0.7535313",
"0.7535313",
"0.73409903",
"0.72676724",
"0.7096782",
"0.7019107",
"0.69941103",
"0.6992066",
"0.6960158",
"0.6907224",
"0.6884196",
"0.6871216",
"0.6774593",
"0.67610097",
"0.6737544",
"0.6726408"... | 0.67145073 | 21 |
get TranslationAnnotSlice for coordinates given by slice k | def __getitem__(self, k):
start = k.start # deal with [:stop] slices
if start is None:
start = self.start
stop = k.stop # deal with [start:] slices
if stop is None:
stop = self.stop
annoID = self._get_anno_id(start)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __getitem__(self,k):\n if type(k) is IntType: return self.data[k, 0]\n \n vec = [type(x) is SliceType for x in k]\n \n if True in vec: #suppose only one slice\n ii=vec.index(True)\n indices=[]\n k = list(k)\n import numpy\n ... | [
"0.60602176",
"0.5904046",
"0.58273673",
"0.56727195",
"0.56727195",
"0.5564237",
"0.55084896",
"0.5456498",
"0.54498935",
"0.5358629",
"0.5333956",
"0.53280276",
"0.53136736",
"0.52776814",
"0.52688247",
"0.52572376",
"0.5237321",
"0.52247524",
"0.52165806",
"0.52149373",
"0... | 0.7238009 | 0 |
get protein slice in absolute nucleotide coords; perform negation before slicing | def absolute_slice(self, start, stop):
if start<0:
return (-self)[start:stop]
else:
return self[start:stop] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def slice_pdb(self, start, stop):\n return",
"def get_slice(self, n):\n if n == 0:\n return slice(self._lo_atom, self._lo_atom + self._n_atoms)\n raise IndexError(f\"{n} is invalid for a 1 dimension Slice \")",
"def test_slice(self):\n r = self.RNA(\"UCAGG\")\n sel... | [
"0.5700618",
"0.5650147",
"0.54527736",
"0.5450388",
"0.54253125",
"0.5353585",
"0.53056103",
"0.5296624",
"0.5295448",
"0.528871",
"0.52498925",
"0.52498925",
"0.5244434",
"0.5232741",
"0.5228222",
"0.5197033",
"0.51797944",
"0.5173883",
"0.5171855",
"0.51631117",
"0.5149656... | 0.64477485 | 0 |
get SeqTranslator for the opposite strand | def __neg__(self):
try:
return self._reverse
except AttributeError:
self._reverse = self.__class__(self.db, self.id,
reversePath=self)
return self._reverse | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def translate(self) -> Seq:\n AA = \"\".join(\n self.codons[self.sequence[i : i + 3]]\n for i in range(0, len(self.sequence), 3)\n if self.codons[self.sequence[i : i + 3]] != \"Stop\"\n )\n return Seq(AA, self.id)",
"def back_translate(self):\n base = Bio.... | [
"0.6367083",
"0.63132405",
"0.621737",
"0.59582543",
"0.587932",
"0.5725467",
"0.56722116",
"0.56457007",
"0.56433344",
"0.5594834",
"0.5594834",
"0.55757517",
"0.5554063",
"0.5548373",
"0.5535726",
"0.55112606",
"0.55029726",
"0.54945356",
"0.5487586",
"0.54656327",
"0.54530... | 0.0 | -1 |
get annotation ID for frame starting at start | def _get_anno_id(self, start):
if self.orientation > 0: # positive strand
return '%s:%d' % (self.id, start % 3)
else: # negative strand
return '%s:-%d' % (self.id, (-start) % 3) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_annotations(self, frame):\n # self.annotations_timestamp = (self.vid.frame_number + self.annotations_offset) / self.vid.fps\n self.annotations_timestamp = self.vid.frame_number / self.vid.fps\n frame = self.video_annotations.get_frame(frame_num=self.vid.frame_number).show(image=frame,\... | [
"0.6424396",
"0.6209977",
"0.5938962",
"0.59239894",
"0.5912636",
"0.57275146",
"0.5695372",
"0.5637109",
"0.56301993",
"0.5578931",
"0.55571216",
"0.54928",
"0.5473145",
"0.54474056",
"0.54357296",
"0.540583",
"0.53773195",
"0.5367013",
"0.53608567",
"0.53608567",
"0.5360856... | 0.653489 | 0 |
Use cached seqDB.translationDB if already present, or create it | def get_translation_db(seqDB):
try:
return seqDB.translationDB
except AttributeError: # create a new TranslationAnnot DB
tdb = TranslationDB(seqDB)
try:
seqDB.translationDB = tdb
except AttributeError:
pass # won't let us cache? Just hand back the Translat... | {
"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 test_translation_default_language_cache(self):\n pool = Pool()\n Config = pool.get('ir.configuration')\... | [
"0.59522355",
"0.5939561",
"0.58453393",
"0.569624",
"0.5674226",
"0.560327",
"0.5590969",
"0.5586558",
"0.55840147",
"0.55140877",
"0.53780013",
"0.5314531",
"0.527767",
"0.5274716",
"0.52287686",
"0.52222425",
"0.521809",
"0.51946694",
"0.5179504",
"0.5158498",
"0.5153249",... | 0.75349766 | 0 |
input potentioal float or int number as string. Return true if string can be converted to float or int | def isfloat(string:str) -> bool:
try:
float(string)
return True
except ValueError:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isFloat(string):\n return (True)",
"def isit_float(s):\r\n try:\r\n int(s)\r\n return False\r\n except ValueError:\r\n try:\r\n float(s)\r\n return True\r\n except ValueError:\r\n return False",
"def isFloat(string):\n try: float(string... | [
"0.807928",
"0.80468637",
"0.7996885",
"0.7991415",
"0.7991415",
"0.7976601",
"0.79161644",
"0.79036456",
"0.78637165",
"0.7823357",
"0.7816794",
"0.7810914",
"0.7794406",
"0.77861154",
"0.77389413",
"0.7716778",
"0.77161455",
"0.770957",
"0.76762354",
"0.76555103",
"0.765193... | 0.8084781 | 0 |
getting str like test TITLE return TITLE | def getTitle(test:str) -> str:
return test[5:].strip() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_title():",
"def test_title(names):",
"def test_getTitle(self):\n def checkNameAndTitle(name, titlesolution):\n title = self._nameClassifierBuilder._getTitle(name)\n self.assertEquals(titlesolution, title)\n\n checkNameAndTitle(\"Mrs. ldajfhgp\", \"Mrs\")\n che... | [
"0.78204143",
"0.72284156",
"0.7191392",
"0.7058093",
"0.69778836",
"0.6975434",
"0.6827347",
"0.6767443",
"0.67635095",
"0.6747392",
"0.67466706",
"0.67249984",
"0.67033744",
"0.66948754",
"0.65919375",
"0.6564572",
"0.6545067",
"0.6512289",
"0.64957863",
"0.648631",
"0.6470... | 0.7312333 | 1 |
get string and finds from it number | def get_numbers(string:str, type_="int") -> list:
num_list = []
for word in string.split():
if type_ == "int":
try:
num_list.append(int(word))
except:
pass
elif type_ == "float":
if isfloat(word):
num_list.a... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_number(self, string):\n #string = string.encode('ascii', 'ignore')\n #return int(filter(str.isdigit, string))\n s = (re.findall('\\d+', string))\n return int(''.join(s))",
"def find_string_by_number(number, path) -> str:\n with open(path, 'r') as f:\n line =... | [
"0.74069595",
"0.72147894",
"0.6761149",
"0.6746768",
"0.6735846",
"0.66291636",
"0.6520586",
"0.641135",
"0.6338338",
"0.62304825",
"0.62230194",
"0.6165489",
"0.60952914",
"0.6060857",
"0.60447884",
"0.60340077",
"0.60206664",
"0.60114574",
"0.6010703",
"0.5960047",
"0.5946... | 0.0 | -1 |
Checking if path marks on existing file and that file is Cfile | def isCfile(path:str) -> bool:
if not isexist(path):
return False
name, ext = path.split(".")
return ext == "c" | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def isfile (self, path):\r\n pass",
"def is_file(self, path: PathLike):",
"def is_declaring_file(self, address, file_path):",
"def fileexists(cpath, create=True):\n dpath = os.path.dirname(cpath)\n if not os.path.isfile(cpath):\n if direxists(dpath) and create:\n try:\n ... | [
"0.72933257",
"0.70916677",
"0.7048014",
"0.69319016",
"0.69264036",
"0.67290795",
"0.6715949",
"0.6701889",
"0.66560394",
"0.6652754",
"0.6630722",
"0.66039884",
"0.6591077",
"0.65735334",
"0.6571813",
"0.6570691",
"0.65631735",
"0.65568924",
"0.653619",
"0.6534776",
"0.6529... | 0.7938118 | 0 |
func for gettign words from string for execution's arguments purposes | def split_args(args):
words = []
quoted_words = []
quoted = re.compile('"([^"]+)"')
for value in quoted.findall(args):
quoted_words.append(value)
new_str = args
for i in quoted_words:
new_str = re.sub('"[^"]+"', '', new_str)
for i in new_str.split():
words.app... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_word():\n return ' '.join(sys.argv[1:])",
"def extract_words(string):\n l = []\n word = ''\n for c in string+' ':\n if c.isalpha():\n word += c\n else:\n if word != '':\n l.append(word.lower())\n word = ''\n return l",
"def ma... | [
"0.69411373",
"0.64223933",
"0.6341651",
"0.6286244",
"0.62439966",
"0.6197393",
"0.61656463",
"0.6130973",
"0.60521656",
"0.60521656",
"0.60474706",
"0.60473394",
"0.5921567",
"0.5913012",
"0.5867635",
"0.5863066",
"0.5863066",
"0.5862466",
"0.5860841",
"0.5852893",
"0.58297... | 0.6378412 | 2 |
This function prints and plots the confusion matrix. Normalization can be applied by setting `normalize=True`. | def plot_confusion_matrix(y_true, y_pred, classes,
normalize=False,
title=None,
cmap=plt.cm.Blues):
if not title:
if normalize:
title = 'Normalized confusion matrix'
else:
title = 'Confusion matrix,... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def plot_confusion_matrix(cm, classes=[0,1], normalize=False, title='Confusion matrix', print_matrix=False):\n\n if normalize:\n cm = cm.astype('float') / cm.sum(axis=1)[:, np.newaxis]\n print(\"Normalized confusion matrix\")\n else:\n print('Confusion matrix, without normalization')\n\n... | [
"0.8195649",
"0.8095532",
"0.803007",
"0.8019817",
"0.7994959",
"0.7991904",
"0.79818887",
"0.79766536",
"0.7961735",
"0.7957412",
"0.79385704",
"0.7935568",
"0.79352015",
"0.7932079",
"0.79270303",
"0.7925357",
"0.79243845",
"0.7923781",
"0.792341",
"0.79226786",
"0.7918532"... | 0.0 | -1 |
Creates a list of style [PartitionOffsetFetchRequest('topic', partition_id)] | def _get_member_assignment(self, member_assignment: Dict[str, Any]) -> List[PartitionOffsetFetchRequest]:
return [
PartitionOffsetFetchRequest(topic, partition)
for member in member_assignment
for topic, partitions in member["member_assignment"]["partition"].items()
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _list_consumer_group_offsets_send_request(self, group_id, group_coordinator_id, partitions=None):\n version = self.kafka_client._matching_api_version(OffsetFetchRequest)\n if version <= 3:\n if partitions is None:\n if version <= 1:\n raise ValueError(... | [
"0.6404822",
"0.60598373",
"0.60253394",
"0.60014105",
"0.5983734",
"0.5758242",
"0.56885225",
"0.56700534",
"0.5592149",
"0.55870277",
"0.55855834",
"0.5576057",
"0.5516484",
"0.54638916",
"0.54388255",
"0.5422308",
"0.5374278",
"0.5338019",
"0.530182",
"0.5297637",
"0.52293... | 0.45333427 | 65 |
Check that all positions are within the field of view. The field of view must have 1 pixel buffer around the edge. i.e. positions must be >= 1 and < the object shape 1 probe.shape. This padding is to allow approximating gradients and to provide better interpolation near the edges of the field of view. | def check_allowed_positions(scan, psi, probe_shape):
int_scan = scan // 1
less_than_one = int_scan < 1
greater_than_psi = np.stack(
(int_scan[..., -2] >= psi.shape[-2] - probe_shape[-2],
int_scan[..., -1] >= psi.shape[-1] - probe_shape[-1]),
-1,
)
if np.any(less_than_one) or... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def check_masked (self, pos : list,) :\n count = 0\n total = 0\n for x in range(pos[0],min(pos[0] + AUTO_width1, self.m_x)) :\n for y in range(pos[1], min(pos[1] + AUTO_width1, self.m_y)) :\n total += 1\n if self.current_grid[x][y] :\n ... | [
"0.6320155",
"0.6030945",
"0.5792432",
"0.5713508",
"0.55996454",
"0.55865943",
"0.5577543",
"0.5562522",
"0.55420154",
"0.5487889",
"0.5470789",
"0.5459432",
"0.5428483",
"0.5413073",
"0.54005986",
"0.5399487",
"0.53966665",
"0.5385833",
"0.53747547",
"0.5369235",
"0.5366344... | 0.62226385 | 1 |
Return a onesinitialized object and shifted scan positions. An complex object array is initialized with shape such that the area covered by the probe is padded on each edge by a full probe width. The scan positions are shifted to be centered in this newly initialized object array. | def get_padded_object(scan, probe):
# Shift scan positions to zeros
scan[..., 0] -= np.min(scan[..., 0])
scan[..., 1] -= np.min(scan[..., 1])
# Add padding to scan positions of field-of-view / 8
span = np.max(scan[..., 0]), np.max(scan[..., 1])
scan[..., 0] += probe.shape[-2]
scan[..., 1] +... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __new__(\n cls, array, mask, original_roe_corner=(1, 0), scans=None, exposure_info=None\n ):\n\n if type(array) is list:\n array = np.asarray(array)\n\n array[mask == True] = 0.0\n\n obj = array.view(cls)\n obj.mask = mask\n obj.exposure_info = exposure_i... | [
"0.58131224",
"0.51213783",
"0.5079498",
"0.5028104",
"0.49811327",
"0.4950484",
"0.494122",
"0.49258816",
"0.49250904",
"0.492351",
"0.4919611",
"0.4918343",
"0.48927116",
"0.48808226",
"0.48763034",
"0.48542187",
"0.48492554",
"0.48279655",
"0.4818469",
"0.48093873",
"0.480... | 0.67473125 | 0 |
Return the leastsquares solution for a @ x = b. This implementation, unlike np.linalg.lstsq, allows a stack of matricies to be processed simultaneously. The input sizes of the matricies are as | def _lstsq(a, b, xp):
assert a.shape[:-1] == b.shape, (f"Leading dims of a {a.shape}"
f"and b {b.shape} must be same!")
shape = a.shape[:-2]
a = a.reshape(-1, *a.shape[-2:])
b = b.reshape(-1, *b.shape[-1:], 1)
aT = np.swapaxes(a, -1, -2)
x = xp.empty((a.shape... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def linear_least_squares(a, b, residuals=False):\n if type(a) != np.ndarray or not a.flags[\"C_CONTIGUOUS\"]:\n main_warning(\n \"Matrix a is not a C-contiguous numpy array. The solver will create a copy, which will result\"\n + \" in increased memory usage.\"\n )\n\n a = ... | [
"0.7446885",
"0.72660464",
"0.71506184",
"0.6994703",
"0.69503105",
"0.6924677",
"0.68110734",
"0.67889744",
"0.6778403",
"0.67641145",
"0.6712708",
"0.66284937",
"0.6548539",
"0.6547693",
"0.6538386",
"0.6529908",
"0.65134645",
"0.64990497",
"0.6474921",
"0.6450039",
"0.6416... | 0.7792954 | 0 |
prints the titles of the first 10 hot posts | def top_ten(subreddit):
headers = {"User-Agent": "Holberton"}
url = "https://www.reddit.com/r/{}/hot.json?limit=10".format(
subreddit)
req = requests.get(url, headers=headers)
if req.status_code != 200:
print(None)
return
redit = req.json().get("data").get("ch... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def top_ten(subreddit):\n req = get(\n \"https://www.reddit.com/r/{}/hot.json\".format(subreddit),\n headers={\n \"User-Agent\": \"alx_app\"},\n params={\n \"limit\": 10},\n allow_redirects=False)\n if req.status_code != 200:\n print(None)\n else:\n... | [
"0.7419805",
"0.7209465",
"0.71907574",
"0.716994",
"0.71192235",
"0.7089789",
"0.70455706",
"0.7008906",
"0.7000312",
"0.6992015",
"0.6947489",
"0.69119495",
"0.69093746",
"0.68866277",
"0.68074715",
"0.67921644",
"0.6764587",
"0.6674961",
"0.6588401",
"0.6194042",
"0.612289... | 0.70645916 | 6 |
Get an existing Kubernetes Source Control Configuration. | def show_k8s_configuration(client, resource_group_name, cluster_name, name, cluster_type):
# Determine ClusterRP
cluster_rp = __get_cluster_type(cluster_type)
try:
config = client.get(resource_group_name, cluster_rp, cluster_type, cluster_name, name)
return __fix_compliance_state(config)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_pnccd_config_object(env, src):\n cfg = env.configStore()\n o = cfg.get(_psana.PNCCD.ConfigV2, src)\n if o is not None: return o\n\n o = cfg.get(_psana.PNCCD.ConfigV1, src)\n if o is not None: return o\n\n return None",
"def source_configuration(self) -> pulumi.Output['outputs.ServiceSou... | [
"0.649569",
"0.64631176",
"0.6276266",
"0.62534004",
"0.61637574",
"0.61064196",
"0.6083393",
"0.5969127",
"0.5967068",
"0.59580755",
"0.5877695",
"0.5829907",
"0.57299304",
"0.5724188",
"0.5720489",
"0.56674016",
"0.5654966",
"0.5639779",
"0.56251794",
"0.5613918",
"0.558458... | 0.53083175 | 31 |
Create a new Kubernetes Source Control Configuration. | def create_k8s_configuration(client, resource_group_name, cluster_name, name, repository_url, scope, cluster_type,
operator_instance_name=None, operator_namespace='default',
helm_operator_chart_version='1.2.0', operator_type='flux', operator_params='',
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_config(self) -> None:\n pass",
"def create_config(self) -> None:\n pass",
"def create_source_config(self, index):\n source_config = index + \".source_config\"\n if not self.client.indices.exists(source_config):\n body = {\n \"settings\": {\"numbe... | [
"0.56187147",
"0.56187147",
"0.54795116",
"0.529751",
"0.5251602",
"0.5231606",
"0.52245486",
"0.52073604",
"0.51837826",
"0.5166928",
"0.51589006",
"0.5154786",
"0.5154429",
"0.51478034",
"0.512585",
"0.51165026",
"0.510743",
"0.5098092",
"0.5093743",
"0.5081327",
"0.5077801... | 0.61110246 | 0 |
Update an existing Kubernetes Source Control Configuration. | def update_k8s_configuration(client, resource_group_name, cluster_name, name, cluster_type,
repository_url=None, operator_params=None, ssh_known_hosts='',
ssh_known_hosts_file='', enable_helm_operator=None, helm_operator_chart_version=None,
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_source():\n\n require('environment', provided_by=env.environments)\n with cd(env.code_root):\n sudo('git pull', user=env.deploy_user)\n sudo('git checkout %(branch)s' % env, user=env.deploy_user)",
"def update_config(\n source,\n target,\n force=True,\n):\n\n ... | [
"0.58912355",
"0.5811905",
"0.5643692",
"0.5556213",
"0.5532521",
"0.54837143",
"0.5382294",
"0.53634936",
"0.53116333",
"0.5306757",
"0.5301925",
"0.5267546",
"0.5190358",
"0.5172564",
"0.51306444",
"0.5122302",
"0.5119971",
"0.5108999",
"0.50907415",
"0.5077623",
"0.5073569... | 0.58269465 | 1 |
Delete an existing Kubernetes Source Control Configuration. | def delete_k8s_configuration(client, resource_group_name, cluster_name, name, cluster_type):
# Determine ClusterRP
cluster_rp = __get_cluster_type(cluster_type)
source_control_configuration_name = name
return client.delete(resource_group_name, cluster_rp, cluster_type, cluster_name, source_control_con... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def delete_conf(src_ip):\n return delete_route(src_ip)",
"def kubeconfig_delete(self):\n\n self._client.delete(\n \"{}/kubeconfig\".format(LKECluster.api_endpoint), model=self\n )",
"def test_delete_hyperflex_vcenter_config_policy(self):\n pass",
"def test_delete_namespaced_d... | [
"0.626437",
"0.6239767",
"0.58826417",
"0.582381",
"0.57499677",
"0.57489693",
"0.5654267",
"0.5627715",
"0.5582473",
"0.5576249",
"0.5512736",
"0.5408252",
"0.5398997",
"0.53942674",
"0.5376546",
"0.53701496",
"0.53552383",
"0.53517985",
"0.53445673",
"0.53374743",
"0.531342... | 0.7078715 | 0 |
When timezone and language are not provided mixin should use timezone and language that are already active | def test_without_change(self, monkeypatch):
berlin = pytz.timezone("Europe/Berlin")
def check():
assert translation.get_language() == 'de'
assert timezone.get_current_timezone() == berlin
with nested(timezone.override(berlin), translation.override('de')):
mi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def timezone():\n \n pass",
"def english_speaking(timezone, lang, text):\n return 1 if timezone in EN_TIMEZONES else 0",
"def process_request(self, request):\n if request.user.is_authenticated():\n if request.user.timezone:\n timezone.activate(pytz.timezone(request.user... | [
"0.6305629",
"0.6078683",
"0.5515769",
"0.54813665",
"0.541261",
"0.5396957",
"0.53821135",
"0.5366447",
"0.5301656",
"0.5292768",
"0.5290754",
"0.5290754",
"0.52619773",
"0.5257348",
"0.52499264",
"0.52384144",
"0.52362454",
"0.52246565",
"0.5222712",
"0.52159184",
"0.521522... | 0.64543843 | 0 |
Checks if 'site' has been added to context | def test_context_data(self):
mixin = mixins.SiteMixin(site=Site(domain='test', name='test'))
ret = mixin.get_context_data()
# make sure data is just updated, not replaced
assert ret['builder'] is mixin
# check if 'site' is in context and if it's valid
assert ret['site'].d... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def add_site_to_context(self):\n g.current_site = self",
"def check_site(site):\n return _READY(site)",
"def is_request_in_themed_site():\n # We need to give priority to theming/site-configuration over microsites\n return configuration_helpers.is_site_configuration_enabled()",
"def curren... | [
"0.6862472",
"0.6629423",
"0.66158265",
"0.6284106",
"0.6206635",
"0.6142709",
"0.6007134",
"0.59886575",
"0.5917819",
"0.591397",
"0.591397",
"0.591397",
"0.5897216",
"0.5873566",
"0.5806039",
"0.578241",
"0.5759842",
"0.57438666",
"0.57122135",
"0.569605",
"0.56820613",
"... | 0.63269395 | 3 |
test API endpoint with the relevant variable | def test_api(test_name, endpoint, method, body, expected_response, expected_status_code, validation, params):
response = None
with allure.step(' '.join(['getting API response on endpoint:', str(endpoint)])):
response = APIRequestor().request(method=method, url_path=endpoint, body=body, params=params)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def testApi(self):",
"def test_api_response_data(self):",
"def test_1():\n\tassert api_call().status_code == 200",
"def test_00_api_get(self):\r\n # GET as Anonymous\r\n url = '/api/'\r\n action = 'get'\r\n self.check_limit(url, action, 'app')",
"def test_api_sample(self):\n ... | [
"0.7413242",
"0.73184425",
"0.7103814",
"0.7087691",
"0.69126666",
"0.69029206",
"0.6893685",
"0.6868759",
"0.686106",
"0.6838196",
"0.6820688",
"0.68138856",
"0.6805327",
"0.6781806",
"0.6781618",
"0.67569596",
"0.67515665",
"0.67416143",
"0.6717166",
"0.6711927",
"0.6710387... | 0.66786957 | 22 |
Main function. Run this to run the app | def main():
st.sidebar.title("Controlling")
st.markdown(
"""
# Bewegungsdaten verschiedener Datenquellen - Social Distancing
Resulate von politischen Maßnamen sowie andere Faktoren die sich auf die Anzahl der Infektionen auswirken.
"""
)
select_block_container_style()
# Map with data from... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def main():\n app = App()\n app.run()",
"def main():\n print(\"def main\")\n return APP.run()",
"def run(self):\n self.app.run()",
"def run(self):\n self.app.run()",
"def main(args=None):\n app()\n return 0",
"def main():\n CLI_APP.run()",
"def main(self) -> None:\n ... | [
"0.8298598",
"0.81067544",
"0.79186285",
"0.79186285",
"0.7852414",
"0.7793305",
"0.76040673",
"0.7545489",
"0.75222534",
"0.74684304",
"0.7402196",
"0.740148",
"0.73792434",
"0.72882473",
"0.72864336",
"0.72864336",
"0.72864336",
"0.72741276",
"0.7272972",
"0.7269209",
"0.71... | 0.0 | -1 |
Add selection section for setting setting the maxwidth and padding of the main block container | def select_block_container_style():
st.sidebar.header("Block Container Style")
max_width_100_percent = st.sidebar.checkbox("Max-width: 100%?", False)
if not max_width_100_percent:
max_width = st.sidebar.slider("Select max-width in px", 100, 2000, 1200, 100)
else:
max_width = 1200
dar... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def layout_selection(self):\n select_txt = wx.StaticText(self, -1, 'Selection Options')\n select_txt.SetForegroundColour('blue')\n self.selection_cbox = wx.ComboBox(self, -1, style=wx.CB_READONLY)\n list_of_options = ['Select all Data',\n 'Unselect all Data',\n... | [
"0.5504615",
"0.5499572",
"0.5268356",
"0.524024",
"0.51872855",
"0.5111512",
"0.5083585",
"0.507568",
"0.50537217",
"0.5052583",
"0.5034852",
"0.50306165",
"0.49910054",
"0.49860722",
"0.49823803",
"0.4976081",
"0.49657044",
"0.4940333",
"0.49394554",
"0.49240482",
"0.492404... | 0.5830852 | 0 |
Receive the local language setting from 'langConf'(E.g. "zhcn"), to render the translation of GUI elements. The translation will be stored in self.translation temporarily | def __init__(self, langConf: str) -> None:
with open(r"localization\localization.json", "rt", encoding="utf-8") as lang:
try:
self.translation = json.load(lang)[langConf]
except KeyError:
self.translation = json.load(lang)["config"]["default"] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _change_lang(self):\n lang = self.ddnGuiLanguage.get()\n self.lblProject['text'] = LOCALIZED_TEXT[lang]['Current Project>'] + \\\n ' ' + self.ddnCurProject.get()\n\n pass",
"def translate(self, language=None):",
"def translate_to(self, lang... | [
"0.679323",
"0.6563822",
"0.6341792",
"0.61459655",
"0.61015123",
"0.6086731",
"0.60347253",
"0.6019798",
"0.6009097",
"0.6002391",
"0.5989115",
"0.59671193",
"0.5892512",
"0.58748144",
"0.5870441",
"0.58494335",
"0.5792226",
"0.5770893",
"0.57640386",
"0.57636833",
"0.576100... | 0.59466743 | 12 |
Create the function "reverseString" that reverses a string, and returns the value of the reversed string. | def reverse_string(sen):
return sen[::-1] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def reverse_string(str):\n # start = 0, stop = len(str), hence range is whole string.\n # step = -1, hence go backwards through range.\n reversed_str = str[::-1]\n return reversed_str # return the reversed string to the caller",
"def reverseString(string):\n return string[::-1]",
"def reverse... | [
"0.79813826",
"0.79736084",
"0.79577136",
"0.7839222",
"0.78306365",
"0.7825854",
"0.75440544",
"0.7425964",
"0.7106993",
"0.7055854",
"0.705052",
"0.7008575",
"0.6991312",
"0.6956781",
"0.68475884",
"0.67978305",
"0.6787142",
"0.6745776",
"0.6675063",
"0.66538405",
"0.663077... | 0.73078597 | 8 |
O(k) complexity, where k == no ones | def solve_ok(number: int) -> int:
return no_ones(number) % 2 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def fn(arr, k):\n ans = []\n for i, x in enumerate(arr): \n while ans and ans[-1] < x and len(ans) + len(arr) - i > k: ans.pop()\n if len(ans) < k: ans.append(x)\n return ans",
"def beautifulSubsets(self, nums: List[int], k: int) -> int:\n\n \... | [
"0.6785851",
"0.6264644",
"0.60669446",
"0.6048191",
"0.603835",
"0.60232204",
"0.5979014",
"0.5966001",
"0.5960862",
"0.59149104",
"0.5905383",
"0.5899332",
"0.58778626",
"0.58674407",
"0.58535844",
"0.5850503",
"0.5822443",
"0.5803091",
"0.5796934",
"0.57908297",
"0.5790199... | 0.0 | -1 |
Get a user object based on event attributes | def user(self):
return resources.User(self._client, id=self.actor) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"async def get_user_from_event(event):\n args = event.pattern_match.group(1).split(' ', 1)\n extra = None\n if event.reply_to_msg_id:\n previous_message = await event.get_reply_message()\n user_obj = await event.client.get_entity(previous_message.from_id)\n extra = event.pattern_match.... | [
"0.69418275",
"0.6205706",
"0.6114066",
"0.60633534",
"0.6010524",
"0.5989375",
"0.5977147",
"0.5941867",
"0.5878637",
"0.5871201",
"0.5867785",
"0.5864181",
"0.5864181",
"0.58199185",
"0.5809417",
"0.5809417",
"0.5800145",
"0.5800145",
"0.5800145",
"0.5800145",
"0.5800145",
... | 0.0 | -1 |
Returns a filtered view of the events, | def filter(self, start_id=None, suppress=None, folder=None, types=None):
if types is not None:
types = '|'.join(types)
d = self.__dict__.copy()
d.update(base.filter_none_values(dict(start_id=start_id, suppress=suppress, folder=folder, type=types)))
return self.__class__(**d) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_queryset(self):\n\t\treturn Event.objects.filter(eDate__gte= timezone.now()).order_by('-eDate')",
"def events(self):\n return self.search(comp_class=Event)",
"def get_events(self, type_filter=None):\n\n if type_filter:\n filtered_events = self.__events.get(type_filter, [])\n ... | [
"0.67336285",
"0.6721536",
"0.66938895",
"0.6561632",
"0.65125376",
"0.65090245",
"0.64060014",
"0.6363465",
"0.63076025",
"0.62766224",
"0.6271868",
"0.6249313",
"0.62235683",
"0.6210422",
"0.61923665",
"0.6183344",
"0.6177567",
"0.61673486",
"0.6165287",
"0.61134976",
"0.61... | 0.0 | -1 |
Get detailed data about up to 'count' events 'start_id'. | def list(self, start_id, count=None):
if start_id is None:
start_id = self.start_id
params = base.filter_none_values(dict(id=start_id, suppress=self.suppress, type=self.types, count=count, folder=self.folder))
url = self._client.get_url(self._url_template_list)
json = exc.no_... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def poll(self, count=None):\n if self.start_id is None:\n self.start_id = self.latest_event_id\n results = self.list(self.start_id, count)\n if results:\n last = results[-1]\n self.start_id = last.id\n self.timestamp = last.timestamp\n return ... | [
"0.61484927",
"0.5886256",
"0.58498895",
"0.58498895",
"0.5743069",
"0.56684434",
"0.5491046",
"0.546203",
"0.5443169",
"0.5424351",
"0.53335845",
"0.52730596",
"0.5272853",
"0.5269081",
"0.52653646",
"0.5262519",
"0.5240888",
"0.5224492",
"0.5221655",
"0.52156323",
"0.520447... | 0.65827274 | 0 |
List events starting with latest_event_id, if any found, update start_id and return them. | def poll(self, count=None):
if self.start_id is None:
self.start_id = self.latest_event_id
results = self.list(self.start_id, count)
if results:
last = results[-1]
self.start_id = last.id
self.timestamp = last.timestamp
return results | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get(self, request, event_id):\n try:\n event = Event.objects.get(id=event_id)\n except Event.DoesNotExist:\n raise ResourceDoesNotExist\n\n self.check_object_permissions(request, event.group)\n\n Event.objects.bind_nodes([event], 'data')\n\n # HACK(dcram... | [
"0.5495549",
"0.53788286",
"0.5307777",
"0.5186725",
"0.50521994",
"0.5006927",
"0.4993703",
"0.49558806",
"0.49139443",
"0.49034473",
"0.4888902",
"0.48577592",
"0.48198426",
"0.47652552",
"0.47584885",
"0.47502953",
"0.47255573",
"0.47253814",
"0.4700429",
"0.46996495",
"0.... | 0.59295905 | 0 |
Never ending generator of events. Will block if necessary | def __iter__(self):
while True:
results = self.poll()
for x in results:
yield x
if not results:
time.sleep(self.poll_delay) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def yield_(cls):\n cls.sleep(0.0)\n #note that we don't use stackless.schedule() here anymore. This would still hog the CPU, never getting\n #never getting into the libevent loop again. by using sleep we prevent this",
"def emptyGenerator():\n return\n yield",
"def block(self):\n ... | [
"0.7117498",
"0.6647457",
"0.63669586",
"0.6313349",
"0.62980855",
"0.62973547",
"0.6292376",
"0.6250869",
"0.62352437",
"0.6125331",
"0.61185205",
"0.61147493",
"0.61069524",
"0.6082039",
"0.6049135",
"0.6047834",
"0.6020268",
"0.60159254",
"0.6002388",
"0.5993972",
"0.59858... | 0.55723983 | 86 |
convert data as indexes using word2index dicts. | def load_data_multilabel(traning_data_path,vocab_word2index, vocab_label2index,sentence_len,training_portion=0.95):
file_object = codecs.open(traning_data_path, mode='r', encoding='utf-8')
lines = file_object.readlines()
random.shuffle(lines)
label_size=len(vocab_label2index)
X = []
Y = []
f... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def make_idx2word():\n idx2word = {}\n d = train_data.shared['word2idx']\n for word, idx in d.items():\n print(word)\n idx2word[idx] = word\n if config.use_glove_for_unk:\n d2 = train_data.shared['new_word2idx']\n for word, idx in d2.items():\... | [
"0.70507044",
"0.67736685",
"0.65944964",
"0.6500153",
"0.6487883",
"0.6464562",
"0.64508516",
"0.64376414",
"0.6355237",
"0.6346937",
"0.62950283",
"0.6266865",
"0.6258912",
"0.62465096",
"0.62320375",
"0.62229455",
"0.61633605",
"0.6162098",
"0.6132909",
"0.61317205",
"0.61... | 0.0 | -1 |
convert to multihot style | def transform_multilabel_as_multihot(label_list,label_size):
result=np.zeros(label_size)
#set those location as 1, all else place as 0.
result[label_list] = 1
return result | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def global_class_to_one_hot(global_class):\n if global_class == 'Store':\n return [1, 0, 0, 0, 0]\n elif global_class == 'Home':\n return [0, 1, 0, 0, 0]\n elif global_class == 'Public spaces':\n return [0, 0, 1, 0, 0]\n elif global_class == 'Leisure':\n return [0, 0, 0, 1, ... | [
"0.7076578",
"0.6815769",
"0.679942",
"0.6644232",
"0.6643239",
"0.6643062",
"0.6641423",
"0.66325814",
"0.6587665",
"0.65310293",
"0.6526953",
"0.65207046",
"0.652039",
"0.65046185",
"0.6502985",
"0.64955145",
"0.64955145",
"0.64955145",
"0.64955145",
"0.6466975",
"0.6462809... | 0.74439895 | 1 |
load data from h5py and pickle cache files, which is generate by take step by step of preprocessing.ipynb | def load_data(cache_file_h5py,cache_file_pickle):
if not os.path.exists(cache_file_h5py) or not os.path.exists(cache_file_pickle):
raise RuntimeError("############################ERROR##############################\n. "
"please download cache file, it include training data and voc... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def ReadData(self, path):\n os.chdir(path)\n folders=os.listdir()\n if 'data.hdf5' in folders:\n print('Loading data from hdf5 file! Might take some time, be patient!')\n file=h5py.File('data.hdf5','r+')\n data=(np.array(list(file['imgs'])),np.array(list(file['... | [
"0.6643617",
"0.66191584",
"0.65291446",
"0.65057594",
"0.65028816",
"0.6463237",
"0.63583684",
"0.63442963",
"0.6261597",
"0.625074",
"0.62329966",
"0.62261707",
"0.6173299",
"0.6156784",
"0.6156044",
"0.6155324",
"0.6144407",
"0.6143092",
"0.6138589",
"0.612844",
"0.6127438... | 0.67722714 | 3 |
Build text dataset from valid sentences in READ_DIRECTORY Creates files 'train.npy', 'validation.npy' in DATA_SAVE_DIRECTORY and 'data_model.pickle' in DATA_MODEL_SAVE_DIRECTORY READ_DIRECTORY is directory to read processed senteces from. | def build_features_and_save_dataset(read_directory, data_save_directory, data_model_save_directory):
dataset.build_dataset_and_datamodel(
read_directory=read_directory,
data_save_directory=data_save_directory,
data_model_save_directory=data_model_save_directory,
vectorizer_params=dat... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def build_training_data():\r\n for i in range(len(FILE_NAMES)):\r\n input_text = read_file(FILE_NAMES[i])\r\n list_of_word_lines = limiting_sentence_length(input_text)\r\n data = create_training_data_file(list_of_word_lines, LANGUAGE[i])\r\n write_training_data(data, LANGUAGE[i])\r\... | [
"0.75706136",
"0.66289955",
"0.66102684",
"0.6391998",
"0.63572866",
"0.6347409",
"0.633092",
"0.6327748",
"0.6323463",
"0.6260119",
"0.62313855",
"0.62169856",
"0.62026703",
"0.61640215",
"0.61560875",
"0.61556214",
"0.6155509",
"0.6132884",
"0.6104501",
"0.6100967",
"0.6085... | 0.6795215 | 1 |
Converts each region into chunks if the chunk_size is smaller than the region size. | def region_chunker(regions: Iterable[BedRegion], chunk_size: int, overlap: int
) -> Generator[BedRegion, None, None]:
for contig, start, end in regions:
position = start
# This will cause the last chunk to be between 0.5 and 1.5
# times the chunk_size in length, this way w... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def chunks(self, list_to_chunk, size):\n for i in range(0, len(list_to_chunk), size):\n yield list_to_chunk[i:i + size]",
"def perform_chunking(self, data_size, chunk_size):\r\n\r\n chunks, i = [], 0\r\n while True:\r\n chunks.append((i * (chunk_size - self.overlap / 2)... | [
"0.6636159",
"0.65703976",
"0.65456533",
"0.6484405",
"0.64694905",
"0.63109094",
"0.6300842",
"0.6280196",
"0.60906184",
"0.60639226",
"0.6051643",
"0.6004283",
"0.60017264",
"0.5998705",
"0.5970686",
"0.59704196",
"0.5970175",
"0.5911755",
"0.59085363",
"0.58943653",
"0.588... | 0.74834573 | 0 |
Scatter regions in chunks with an overlap. It returns Lists of regions where each list of regions has the regions describe at least the amount of base pairs in minimum bas pairs. Except the last list. | def chunked_scatter(regions: Iterable[BedRegion],
chunk_size: int,
overlap: int,
list_size: int,
size_is_maximum: bool = False,
contigs_can_be_split: bool = False,
) -> Generator[List[BedRegion], None... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _find_regions(base_pairs, scores):\n # Make sure the lower residue is on the left for each row\n sorted_base_pairs = np.sort(base_pairs, axis=1)\n\n # Sort the first column in ascending order\n original_indices = np.argsort(sorted_base_pairs[:, 0])\n sorted_base_pairs = sorted_base_pairs[origina... | [
"0.62757033",
"0.6139482",
"0.6121993",
"0.6094671",
"0.60852635",
"0.5971739",
"0.5971285",
"0.5950996",
"0.58377177",
"0.5798233",
"0.5722346",
"0.569577",
"0.56510615",
"0.56162935",
"0.5603435",
"0.55737406",
"0.5572107",
"0.5565849",
"0.55580723",
"0.5515881",
"0.5509429... | 0.6774003 | 0 |
Convert lists of BedRegions to '{prefix}{number}.bed' files. The number starts at 0 and is increased with 1 for each file. | def region_lists_to_scatter_files(region_lists: Iterable[List[BedRegion]],
prefix: str) -> List[str]:
parent_dir = Path(prefix).parent
if not parent_dir.exists():
parent_dir.mkdir(parents=True)
output_files: List[str] = []
for scatter_number, region_list in enum... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def merge_regions(bed_files, out_bed):\n merge_all = (\"zcat {0} | \"\n \"sort -k1,1 -k2,2n | \"\n \"bedtools merge -i stdin | \"\n \"gzip -c \"\n \"> {1}\").format(' '.join(bed_files), out_bed)\n print merge_all\n os.system(merge_all)\n\n ... | [
"0.5811469",
"0.57198805",
"0.5622001",
"0.5562359",
"0.5456798",
"0.5386436",
"0.537686",
"0.53308827",
"0.5307604",
"0.52402455",
"0.52274424",
"0.5204288",
"0.5200815",
"0.51784396",
"0.5158024",
"0.5143059",
"0.5101236",
"0.5091111",
"0.5063313",
"0.5059401",
"0.5051228",... | 0.66358685 | 0 |
Commmon arguments for chunkedscatter and scatterregions. | def common_parser() -> argparse.ArgumentParser:
parser = argparse.ArgumentParser()
parser.add_argument("-p", "--prefix", type=str, default="scatter-",
help="The prefix of the ouput files. Output will be "
"named like: <PREFIX><N>.bed, in which N is an "
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _cmd_scatter(args):\n cnarr = read_cna(args.filename, sample_id=args.sample_id) if args.filename else None\n segarr = read_cna(args.segment, sample_id=args.sample_id) if args.segment else None\n varr = load_het_snps(\n args.vcf,\n args.sample_id,\n args.normal_id,\n args.mi... | [
"0.64741015",
"0.5842866",
"0.55324745",
"0.5439487",
"0.5385588",
"0.53329253",
"0.5324963",
"0.53106254",
"0.5304849",
"0.5217032",
"0.5203139",
"0.51827645",
"0.51780653",
"0.5165851",
"0.5165851",
"0.51186925",
"0.5099081",
"0.50974053",
"0.50931007",
"0.5066854",
"0.5066... | 0.0 | -1 |
Argument parser for the chunkedscatter program. | def parse_args():
parser = common_parser()
parser.description = (
"Given a sequence dict, fasta index or a bed file, scatter over the "
"defined contigs/regions. Each contig/region will be split into "
"multiple overlapping regions, which will be written to a new bed "
"file. Eac... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_arguments(args):",
"def parse_args():\n parser = argparse.ArgumentParser(description=\"Bandits algorithms on a click-through \"\n \"rate dataset.\")\n parser.add_argument('--plot', action='store_true')\n return parser.parse_args()",
"def parse_command_line... | [
"0.6662891",
"0.66337186",
"0.66122687",
"0.6549749",
"0.65275127",
"0.6519762",
"0.6458982",
"0.641025",
"0.63903356",
"0.63732386",
"0.63631916",
"0.6354082",
"0.6325997",
"0.63239706",
"0.63074183",
"0.62884784",
"0.62832284",
"0.62800217",
"0.6271708",
"0.62590134",
"0.62... | 0.6856216 | 0 |
Construct a reverse dependency graph for the given tables. Returns a dict which maps a table to the list of tables which depend on it. | def compute_dependencies(tables):
tables = list(tables)
graph = {}
def visit_foreign_key(fkey):
if fkey.use_alter:
return
parent_table = fkey.column.table
if parent_table in tables:
child_table = fkey.parent.table
if parent_table is not child_table... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def find_dependent_tables(tables, graph=None):\n if graph is None:\n graph = _pokedex_graph\n tables = list(tables)\n dependents = set()\n def add_dependents_of(table):\n for dependent_table in graph.get(table, []):\n if dependent_table not in dependents:\n depen... | [
"0.69427735",
"0.61397785",
"0.58996993",
"0.5879737",
"0.58512306",
"0.58380896",
"0.5765764",
"0.5514511",
"0.55016583",
"0.5487928",
"0.54594654",
"0.5439578",
"0.5423852",
"0.5391774",
"0.5357538",
"0.53466797",
"0.53311527",
"0.53097713",
"0.52684534",
"0.5259335",
"0.51... | 0.78140616 | 0 |
Recursively find all tables which depend on the given tables. The returned set does not include the original tables. | def find_dependent_tables(tables, graph=None):
if graph is None:
graph = _pokedex_graph
tables = list(tables)
dependents = set()
def add_dependents_of(table):
for dependent_table in graph.get(table, []):
if dependent_table not in dependents:
dependents.add(dep... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def compute_dependencies(tables):\n tables = list(tables)\n graph = {}\n def visit_foreign_key(fkey):\n if fkey.use_alter:\n return\n parent_table = fkey.column.table\n if parent_table in tables:\n child_table = fkey.parent.table\n if parent_table is n... | [
"0.67526245",
"0.6205177",
"0.6078723",
"0.585772",
"0.58402073",
"0.58020824",
"0.57992023",
"0.57208854",
"0.566076",
"0.5643069",
"0.56195253",
"0.55561763",
"0.5519054",
"0.54829293",
"0.53970766",
"0.53318137",
"0.5278792",
"0.52506405",
"0.52483636",
"0.5241787",
"0.522... | 0.77396166 | 0 |
Returns an unrendered representation of this strategy. | def unrendered(self) -> str: | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def render(self):\n self.increase_view_count()\n return render_to_string(self.template.template_file, {'advert':self})",
"def render(self):\n raise NotImplementedError",
"def render(self):\n raise NotImplementedError()",
"def render(self) -> str:\n with no_colors():\n ... | [
"0.6479097",
"0.6427954",
"0.6388897",
"0.63168555",
"0.62177557",
"0.61986595",
"0.61986595",
"0.61986595",
"0.61986595",
"0.61986595",
"0.61986595",
"0.61877984",
"0.6187231",
"0.6187231",
"0.6131751",
"0.610918",
"0.60881495",
"0.6065048",
"0.6021125",
"0.60132897",
"0.601... | 0.7091934 | 0 |
Render the project's build directory. If rendering is not possible, the unrendered representation is provided and an error will be loggged. | def rendered(
self,
project: tp.Optional['benchbuild.project.Project'] = None,
**kwargs: tp.Any
) -> Path:
del kwargs
if project is None:
LOG.error("Cannot render a build directory without a project.")
return Path(self.unrendered)
return Path... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rendered(\n self,\n project: tp.Optional['benchbuild.project.Project'] = None,\n **kwargs: tp.Any\n ) -> Path:\n del kwargs\n\n if project is None:\n LOG.error(\"Cannot render a source directory without a project.\")\n return Path(self.unrendered)\n\n... | [
"0.6681",
"0.6304552",
"0.60405934",
"0.599331",
"0.58563274",
"0.5839519",
"0.5824633",
"0.5738838",
"0.5692952",
"0.56889725",
"0.56846964",
"0.56190807",
"0.55945814",
"0.5566248",
"0.5494656",
"0.5475181",
"0.53834",
"0.5377323",
"0.53750783",
"0.53675413",
"0.5355115",
... | 0.7442607 | 0 |
Render the project's source directory. If rendering is not possible, the unrendered representation is provided and an error will be loggged. | def rendered(
self,
project: tp.Optional['benchbuild.project.Project'] = None,
**kwargs: tp.Any
) -> Path:
del kwargs
if project is None:
LOG.error("Cannot render a source directory without a project.")
return Path(self.unrendered)
if (src_pa... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def rendered(\n self,\n project: tp.Optional['benchbuild.project.Project'] = None,\n **kwargs: tp.Any\n ) -> Path:\n del kwargs\n\n if project is None:\n LOG.error(\"Cannot render a build directory without a project.\")\n return Path(self.unrendered)\n\n ... | [
"0.68619233",
"0.60243595",
"0.6001584",
"0.5980786",
"0.59798557",
"0.5696066",
"0.5657194",
"0.5615238",
"0.5614794",
"0.5573921",
"0.55593765",
"0.55544454",
"0.5512919",
"0.5442804",
"0.53868985",
"0.5381254",
"0.53646857",
"0.53539443",
"0.53451514",
"0.53353864",
"0.532... | 0.7361598 | 0 |
Renders the PathToken as a standard pathlib Path. Any kwargs will be forwarded to the PathRenderStrategy. | def render(self, **kwargs: tp.Any) -> Path:
token = self.renderer.rendered(**kwargs)
p = Path()
if self.left:
p = self.left.render(**kwargs)
p = p / token
if self.right:
p = p / self.right.render(**kwargs)
return p | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def DrawPath(*args, **kwargs):\n return _gdi_.GraphicsContext_DrawPath(*args, **kwargs)",
"def path(self, cmd, cls=None, style=None):\n cls_str = 'class=\"%s\" ' % cls if cls else ''\n style_str = 'style=\"%s\" ' % self._meta.make_style(style) if style else ''\n cmd_str = ' '.join(str... | [
"0.6224211",
"0.58091444",
"0.58091444",
"0.55861455",
"0.5514318",
"0.54257166",
"0.54219663",
"0.54219663",
"0.54219663",
"0.5413109",
"0.53643227",
"0.53334355",
"0.53281635",
"0.53047687",
"0.52978337",
"0.5269925",
"0.52407306",
"0.52206856",
"0.5198254",
"0.51587677",
"... | 0.7062216 | 0 |
Create a SourceRoot token for the given name. | def source_root(local_name: str) -> PathToken:
return PathToken.make_token(SourceRootRenderer(local_name)) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def createNode(self, name):\n return Node(name)",
"def create_master_token(user, repo, config, name):\n url = \"{}/repos/{}/{}/master_tokens\".format(config['url_base'], user, repo)\n postdata = (\"master_token[name]={}\".format(name))\n\n try:\n resp = (api_call(url, 'post', config['debug... | [
"0.58197236",
"0.58120185",
"0.5461257",
"0.5330099",
"0.52970916",
"0.5290789",
"0.52864885",
"0.514151",
"0.5125505",
"0.51005894",
"0.50946856",
"0.50913566",
"0.50799656",
"0.5078524",
"0.5072293",
"0.50189483",
"0.49877277",
"0.49553236",
"0.4923021",
"0.49081895",
"0.49... | 0.7293271 | 0 |
Implement the `SupportsUnwrap` protocol. WorkloadSets only implement identity. | def unwrap(self, project: "benchbuild.project.Project") -> "WorkloadSet":
del project
return self | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def unwrap(self, project: \"benchbuild.project.Project\") -> WorkloadSet:\n source = primary(*project.source)\n self.rev_range.init_cache(source.fetch())\n\n revision = project.version_of_primary\n if revision in set(self.rev_range):\n return self.workload_set\n return... | [
"0.5175993",
"0.46047267",
"0.44359973",
"0.44290382",
"0.42905238",
"0.4283248",
"0.42586493",
"0.42538634",
"0.42417073",
"0.42362952",
"0.4233518",
"0.42226675",
"0.42205516",
"0.4218237",
"0.42081583",
"0.42040357",
"0.41993237",
"0.4195591",
"0.41841477",
"0.41818616",
"... | 0.5051381 | 1 |
Provide the store WorkloadSet only if our revision is in the range. | def unwrap(self, project: "benchbuild.project.Project") -> WorkloadSet:
source = primary(*project.source)
self.rev_range.init_cache(source.fetch())
revision = project.version_of_primary
if revision in set(self.rev_range):
return self.workload_set
return WorkloadSet() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __and__(self, rs):\n revs = {}\n for r in self._revs.keys():\n if r in rs:\n revs[r] = 1\n return RevisionSet(revs)",
"def get_store(self, subset: str) -> AbstractStore:\n return self.get_source(subset).get_driver().store",
"def get_bookset(self): # pra... | [
"0.5471049",
"0.5289642",
"0.50833374",
"0.5080772",
"0.50565416",
"0.5049684",
"0.5047519",
"0.4785766",
"0.47622177",
"0.4720354",
"0.46804672",
"0.46708968",
"0.4526999",
"0.45052436",
"0.45024467",
"0.45024055",
"0.44985983",
"0.4474408",
"0.44708422",
"0.4458724",
"0.445... | 0.6174194 | 0 |
Run the command in foreground. | def __call__(self, *args: tp.Any, **kwargs: tp.Any) -> tp.Any:
cmd_w_output = self.as_plumbum(**kwargs)
return watch(cmd_w_output)(*args) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def run_current_selection(self):\n import subprocess\n name, data, _ = self.matches_copy[self.selected_item]\n try:\n needs_term = data[\"Terminal\"].lower() == \"true\"\n except KeyError:\n needs_term = False\n if needs_term:\n with open(os.devnu... | [
"0.63322735",
"0.62880206",
"0.6268796",
"0.61993796",
"0.6169974",
"0.6123801",
"0.5984392",
"0.5953493",
"0.5937315",
"0.59277993",
"0.5923064",
"0.58983076",
"0.5887867",
"0.58835435",
"0.5873847",
"0.5831763",
"0.5829652",
"0.58249116",
"0.5816179",
"0.5785724",
"0.576576... | 0.0 | -1 |
Convert this command into a plumbum compatible command. This renders all tokens in the command's path and creates a new plumbum command with the given parameters and environment. | def as_plumbum(self, **kwargs: tp.Any) -> BoundEnvCommand:
cmd_path = self.path.render(**kwargs)
assert cmd_path.exists(), f"{str(cmd_path)} doesn't exist!"
cmd = local[str(cmd_path)]
cmd_w_args = cmd[self._args]
cmd_w_output = cmd_w_args
if self.output:
outp... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _build_command(self, cmd, unit):\n return '#' + unit + cmd + NEWLINE",
"def command_create(self):\n command = []\n for macro in self.my_xml.tool_data[self.shell_dict['short_name']]['pre_tmpls']:\n command.append(self.my_xml.chth_tmpl.substitute(macro=macro))\n command.e... | [
"0.5472302",
"0.5020931",
"0.49380094",
"0.49344808",
"0.48843986",
"0.48163372",
"0.47575694",
"0.47425863",
"0.4723837",
"0.4718866",
"0.47012642",
"0.46963745",
"0.46777338",
"0.46764538",
"0.46709517",
"0.46280432",
"0.46111864",
"0.45973215",
"0.45898268",
"0.45858732",
... | 0.7630991 | 0 |
Encapsulate a command in automatic backup, restore and prune. This will wrap a ProjectCommand inside a contextmanager. All consumed files inside the project's build directory will be backed up by benchbuild. You can then run your command as usual. When you leave the context, all created paths are deleted and all consum... | def cleanup(
project_command: ProjectCommand,
backup: BackupFn = _default_backup,
restore: RestoreFn = _default_restore,
prune: PruneFn = _default_prune
):
backup_paths = backup(project_command)
yield project_command
prune(project_command)
restore(backup_paths) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def project_run_cli(\n # fmt: off\n ctx: typer.Context, # This is only used to read additional arguments\n subcommand: str = Arg(None, help=f\"Name of command defined in the {PROJECT_FILE}\"),\n project_dir: Path = Arg(Path.cwd(), help=\"Location of project directory. Defaults to current working direc... | [
"0.56189156",
"0.55472064",
"0.53668106",
"0.53224593",
"0.5310589",
"0.52562124",
"0.5201688",
"0.5180331",
"0.5120521",
"0.50925434",
"0.5060089",
"0.5042031",
"0.5035103",
"0.5023706",
"0.5018057",
"0.5006276",
"0.49892634",
"0.49649376",
"0.49586257",
"0.49490285",
"0.493... | 0.7337432 | 0 |
Unwrap all keys in a workload index. 'Empty' WorkloadSets will be removed. A WorkloadSet is empty, if it's boolean representation evaluates to `False`. | def unwrap(
index: WorkloadIndex, project: 'benchbuild.project.Project'
) -> WorkloadIndex:
return {k: v for k, v in index.items() if bool(k.unwrap(project))} | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_workload_index(\n only: tp.Optional[WorkloadSet], index: WorkloadIndex\n) -> tp.Generator[tp.List[Command], None, None]:\n\n keys = [k for k in index if k and ((only and (k & only)) or (not only))]\n for k in keys:\n yield index[k]",
"def without_keys(keys):\n keys = frozenset(keys)... | [
"0.5987424",
"0.5359634",
"0.5116948",
"0.50576454",
"0.49657622",
"0.49277607",
"0.49024755",
"0.48685038",
"0.48530674",
"0.48389393",
"0.48361847",
"0.47933555",
"0.47767672",
"0.47717446",
"0.47539616",
"0.47511247",
"0.473958",
"0.4738811",
"0.4729646",
"0.47286484",
"0.... | 0.6152042 | 0 |
Yield only commands from the index that match the filter. This removes all command lists from the index not matching `only`. | def filter_workload_index(
only: tp.Optional[WorkloadSet], index: WorkloadIndex
) -> tp.Generator[tp.List[Command], None, None]:
keys = [k for k in index if k and ((only and (k & only)) or (not only))]
for k in keys:
yield index[k] | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter(self, inputs: Iterable[Chunk]) -> Iterable[Chunk]:",
"def only(self, fields):\r\n return self._only_or_defer('only', fields)",
"def filter_all(_):\n return True",
"def filter_commands(self, how, flags=DEFAULT_FLAGS):\n # convert the filter into a function\n if isinstance(ho... | [
"0.5246415",
"0.52019507",
"0.5104248",
"0.50775677",
"0.50498474",
"0.5046479",
"0.50438625",
"0.50250715",
"0.49934337",
"0.4992865",
"0.49820873",
"0.49567518",
"0.4938405",
"0.49066398",
"0.48806572",
"0.48377234",
"0.48302686",
"0.4821006",
"0.48163643",
"0.48097342",
"0... | 0.79332024 | 0 |
Create a summary writer logging to log_dir. | def __init__(self, log_dir):
self.writer = tf.summary.FileWriter(log_dir) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __init__(self, log_dir):\n self.writer = SummaryWriter(log_dir)",
"def _create_writer(self, sess_path, log_foldername, comment=''):\n logdir = os.path.join(sess_path, log_foldername)\n print(\"LOGDIR:\", logdir)\n writer = SummaryWriter(logdir=logdir, comment=comment)\n ret... | [
"0.7565108",
"0.75489604",
"0.7339683",
"0.72330046",
"0.7162868",
"0.6932504",
"0.6791952",
"0.673854",
"0.6560298",
"0.65343267",
"0.65076673",
"0.64512265",
"0.63786143",
"0.6277499",
"0.6273053",
"0.6269045",
"0.62369066",
"0.6148293",
"0.6146728",
"0.61350995",
"0.611146... | 0.7149351 | 5 |
Log a scalar variable. | def scalar_summary(self, tag, value, step):
summary = tf.Summary(value=[tf.Summary.Value(tag=tag, simple_value=value)])
self.writer.add_summary(summary, step) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log_scalar(tag: str,\n data: float,\n global_step: int,\n walltime: Optional[float] = None,\n logger: Optional[logging.Logger] = None) -> None:\n logger = logger or _get_context_logger()\n logger.info(ScalarT(tag=tag, scalar_value=data, global_step=... | [
"0.768164",
"0.7405269",
"0.6838726",
"0.66579974",
"0.64215994",
"0.633521",
"0.633521",
"0.63333976",
"0.6205251",
"0.6186292",
"0.6127355",
"0.6097684",
"0.6094468",
"0.6078118",
"0.6052655",
"0.60229844",
"0.589007",
"0.5860449",
"0.57479894",
"0.57424384",
"0.569418",
... | 0.52661103 | 64 |
Log a list of images. | def image_summary(self, tag, images, step):
img_summaries = []
for i, img in enumerate(images):
# Write the image to a string
try:
s = StringIO()
except:
s = BytesIO()
scipy.misc.toimage(img).save(s, format="png")
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def do_stage(self, images):\n\n for i, image in enumerate(images):\n pass\n # logging_tags = logs.image_config_to_tags(image, self.group_by_keywords)",
"def log_images(self, image_dict,\n iterations, step_in_epoch=None, cur_epoch=None,\n save_to_ou... | [
"0.70306057",
"0.68595123",
"0.67045456",
"0.6475185",
"0.6469947",
"0.64632344",
"0.64393103",
"0.63934153",
"0.6360708",
"0.6312807",
"0.62935907",
"0.6290032",
"0.6252595",
"0.6245926",
"0.6154681",
"0.6133359",
"0.6130312",
"0.6108486",
"0.60504884",
"0.6026077",
"0.60188... | 0.5464511 | 70 |
Log a histogram of the tensor of values. | def histo_summary(self, tag, values, step, bins=1000):
# Create a histogram using numpy
counts, bin_edges = np.histogram(values, bins=bins)
# Fill the fields of the histogram proto
hist = tf.HistogramProto()
hist.min = float(np.min(values))
hist.max = float(np.max(value... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def log10(tensor):\n return log(tensor, base=10)",
"def log(tensor, base=np.e):\n if base == np.e:\n return _elementary_op(tensor, np.log, lambda x: 1 / x)\n return log(tensor) / log(base)",
"def plt_log_hist(v, **kwargs):\n # Handle input paramaters\n bins = kwargs.get('bins', 10)\n i... | [
"0.6635403",
"0.6599441",
"0.65499413",
"0.640473",
"0.63136995",
"0.627168",
"0.6237387",
"0.6237387",
"0.6200863",
"0.61935997",
"0.61915267",
"0.61248237",
"0.61070186",
"0.6079362",
"0.6059931",
"0.6039507",
"0.60228795",
"0.59952927",
"0.59877276",
"0.59646887",
"0.59608... | 0.5879018 | 25 |
Apply LocalPlugin to additional widgets. | def add_widgets(self, widgets):
target_widgets = []
for widget in widgets:
target_widgets.append(widget)
target_widgets.extend(widget.findChildren(QWidget))
for widget in target_widgets:
if hasattr(widget, "channels"):
for channel in widget.cha... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def register_plugin(self):\n self.create_toggle_view_action()\n\n self.main.add_dockwidget(self)",
"def Custom(\n owner: QWidget,\n name: str,\n widget: QWidget\n):\n return widget",
"def add_plugin(self, plugin):\n\n if not plugin:\n return\n\n plugin_btn = P... | [
"0.571816",
"0.54625845",
"0.5379212",
"0.525324",
"0.51787555",
"0.5162809",
"0.5156135",
"0.51529145",
"0.5135846",
"0.5132016",
"0.5131427",
"0.5126573",
"0.51148033",
"0.50824106",
"0.507493",
"0.5069745",
"0.5048146",
"0.5044024",
"0.50205326",
"0.50173813",
"0.5015853",... | 0.50230086 | 18 |
Connect signal to the update slot of the connection associated with address. This allows a user to manage update timings without polling. | def connect_to_update(self, address, signal):
try:
connection = self.connections[address]
except KeyError:
err = "No connectino with address {} found!"
raise KeyError(err.format(address))
signal.connect(connection.update) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect_to_update(self, method):\n self._update_signal.connect(method)",
"def signal_device_update(self) -> str:\n return f\"{DOMAIN}-{self._host}-device-update\"",
"def onConnect(self, *args):\n UAV_Logger.log(\"connect signal recieved\")\n self.socketIO.emit('CORE_SL_SLOTS_SET... | [
"0.67650616",
"0.60726666",
"0.60720134",
"0.56234455",
"0.5479016",
"0.54782236",
"0.5402329",
"0.5321059",
"0.5299692",
"0.5283976",
"0.527752",
"0.5272966",
"0.5239577",
"0.52377826",
"0.5206199",
"0.5197094",
"0.51910365",
"0.51896334",
"0.5172977",
"0.5171491",
"0.517149... | 0.78523546 | 0 |
Create a Connection class for connecting to fields of an object. | def connection_class_factory(obj, refresh=1.0):
class Connection(PyDMConnection):
"""
Class that manages object attribute access.
"""
def __init__(self, channel, address, parent=None):
"""
Parse address, apply options, and add the first listener.
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def construct_connection(module):\n connection = dict((k, module.params.get(k)) for k in (\n 'id',\n 'name',\n 'description',\n 'speed',\n 'billing_term',\n 'customer_networks',\n 'primary_ocid',\n 'secondary_ocid'\n ))\n connection.update(dict(\n ... | [
"0.61630636",
"0.6122042",
"0.6103119",
"0.6076694",
"0.60189474",
"0.590895",
"0.5884315",
"0.58604395",
"0.5855946",
"0.5815163",
"0.5778145",
"0.5745945",
"0.5725575",
"0.57156295",
"0.5699175",
"0.5683897",
"0.5673337",
"0.5671581",
"0.5665592",
"0.56447214",
"0.56410515"... | 0.6107817 | 2 |
Parse address, apply options, and add the first listener. Start polling the field/method if applicable. | def __init__(self, channel, address, parent=None):
super(Connection, self).__init__(channel, address, parent)
self.obj = obj
self.refresh = refresh
# remove all whitespace from address and convert to str
address = "".join(str(address).split())
# se... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def parse_address(self, address: str) -> Optional[Address]:\n raise NotImplemented",
"def listener(address):\n\n\tlisten_socket = socket(AF_INET, SOCK_DGRAM)\n\tlisten_socket.setsockopt(SOL_SOCKET, SO_REUSEADDR, 1)\n\tlisten_socket.bind(address)\n\n\twhile True:\n\t\tmessage, client_address = listen_socke... | [
"0.5272946",
"0.5252478",
"0.5049684",
"0.5013451",
"0.50115204",
"0.49883822",
"0.49749982",
"0.48436213",
"0.47963017",
"0.4780593",
"0.4727479",
"0.47240946",
"0.47194868",
"0.47181323",
"0.47080204",
"0.4702675",
"0.4695171",
"0.4688278",
"0.46875724",
"0.46641213",
"0.46... | 0.0 | -1 |
Return the current value of this connection. | def get_value(self):
attr = getattr(self.obj, self.attr)
try:
args = self.args
kwargs = self.kwargs
return attr(*args, **kwargs)
except AttributeError:
return attr | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_current_value(self):\n assert(self.is_started())\n return self.currValue",
"def value(self):\n\n\t\treturn self.__value",
"def value(self):\n return self._read()",
"def value(self):\n return self.__value",
"def value(self):\n return self.__value",
"def get(self)... | [
"0.7694323",
"0.76275814",
"0.7609642",
"0.75263494",
"0.75263494",
"0.7512191",
"0.7442435",
"0.74387866",
"0.74387866",
"0.74387866",
"0.74387866",
"0.74387866",
"0.74387866",
"0.74387866",
"0.74387866",
"0.74387866",
"0.74387866",
"0.74387866",
"0.74387866",
"0.74387866",
... | 0.0 | -1 |
Get a new value from the object and send it to all listeners. If an exception was thrown, send a disconnected signal. | def update(self):
try:
value = self.get_value()
except:
self.send_connection_state(False)
return
self.send_connection_state(True)
self.send_new_value(value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def _get_value(self):\n if self._not_connected:\n self.connect(False)\n if self._status == 1:\n self._update_value()\n elif self._status == 2:\n raise SignalValueError('The signal %r is not initialized.' % self._name)\n elif self._status == 3:\n ... | [
"0.6135663",
"0.58255106",
"0.57733446",
"0.5717795",
"0.56895155",
"0.5656427",
"0.5588149",
"0.5515135",
"0.5416162",
"0.537164",
"0.53613234",
"0.527445",
"0.5263136",
"0.52511084",
"0.52493536",
"0.52368975",
"0.5235674",
"0.5216354",
"0.5202464",
"0.5184765",
"0.5150538"... | 0.63411987 | 0 |
Send a value to every channel listening for our obj. | def send_new_value(self, value=None):
if isinstance(value, np.generic):
value = np.asscalar(value)
if isinstance(value, np.ndarray):
self.new_waveform_signal.emit(value)
elif isinstance(value, (int, float, str)):
self.new_value_signal[t... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def send(self, sender=None, *, value=NOTHING, **kwargs):\n\t\treturn [r for r in self.trigger(sender, value=value, **kwargs)]",
"def _send_value(self):\n self.new_cycle()\n if self.stop_cycle and self.cycle_count >= self.stop_cycle:\n self.finished()\n return\n msg = Mg... | [
"0.662985",
"0.64048797",
"0.63022316",
"0.6018219",
"0.60056007",
"0.59776825",
"0.5934194",
"0.5911138",
"0.58284795",
"0.5803214",
"0.5787825",
"0.5784593",
"0.5711648",
"0.5652716",
"0.56409997",
"0.56399184",
"0.56261945",
"0.56138104",
"0.5613133",
"0.5611763",
"0.55756... | 0.0 | -1 |
Send an update on our connection state to every listener. | def send_connection_state(self, conn=None):
self.connection_state_signal.emit(conn) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_state(self):\n for listener in self.listeners:\n listener['callback']()",
"def send_state(self):\n self.state = self.enigma.get_state()\n messages = self.notify_slaves()\n for message in messages:\n self.network.messages_to_slaves.append(message)",
"... | [
"0.7342474",
"0.6991233",
"0.653894",
"0.65111196",
"0.6457511",
"0.6416774",
"0.63002044",
"0.62633836",
"0.6217835",
"0.6206397",
"0.6182732",
"0.6158061",
"0.61436594",
"0.6129375",
"0.61186033",
"0.61155987",
"0.61122745",
"0.6088854",
"0.60534143",
"0.60534143",
"0.60391... | 0.6392696 | 6 |
Return True if we can get a value. | def is_connected(self):
try:
self.get_value()
return True
except:
return False | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def has_value(self):\n return hasattr(self, '_value')",
"def value(self) -> bool:",
"def hasVeryTrustedValue(self):",
"def _check_value(self, value):\n raise NotImplementedError",
"def __bool__(self):\n return bool(self.get_value())",
"def check_value(self, value):",
"def val(self)... | [
"0.7801285",
"0.7355578",
"0.70215636",
"0.68094605",
"0.6710279",
"0.66967314",
"0.6636511",
"0.66324806",
"0.662596",
"0.6607568",
"0.6605401",
"0.660154",
"0.655073",
"0.655073",
"0.655073",
"0.655073",
"0.655073",
"0.65428174",
"0.650341",
"0.64836",
"0.64632744",
"0.63... | 0.61091936 | 35 |
Set our object attribute's value. If the attribute is a function, we will execute it. | def put_value(self, value):
# Field: replace value
if self.nargs is None:
try:
setattr(obj, self.attr, value)
except:
return
# Function of zero arguments: call function
elif self.nargs == 0:
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def set(self, attribute: str, value: Any):\n return setattr(self, attribute, value)",
"def setter(self, func):\n self.fset = func\n self.set_setattr_mode(SetAttr.CallObject_ObjectValue, func)\n return self",
"def __setattr__ (self, attr, value):\n self.set_value (attr, value)",
... | [
"0.7261213",
"0.7160641",
"0.712291",
"0.70666087",
"0.70423454",
"0.69700164",
"0.69217324",
"0.6841145",
"0.68363243",
"0.6817219",
"0.6715014",
"0.6715014",
"0.6715014",
"0.6715014",
"0.6715014",
"0.6715014",
"0.6715014",
"0.67075944",
"0.66938466",
"0.6691974",
"0.6689480... | 0.7409989 | 0 |
This is a deprecated function kept temporarily for compatibility with old code. | def put_waveform(self, value):
self.put_value(value) | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def __upgrade(self):",
"def _getParameters(self):\n warnings.warn(\"This function is deprecated; parameters have been replaced with uniform inputs in 1.38.\", DeprecationWarning, stacklevel = 2)\n return list()",
"def _getParameterValueString(self, name):\n warnings.warn(\"This function is deprecated;... | [
"0.65171736",
"0.55589485",
"0.5551494",
"0.55456954",
"0.548942",
"0.5479055",
"0.54717064",
"0.5444835",
"0.5433667",
"0.5429895",
"0.542037",
"0.5416015",
"0.5385065",
"0.53743964",
"0.53695077",
"0.53270537",
"0.5313229",
"0.5311496",
"0.53075457",
"0.53075457",
"0.530754... | 0.0 | -1 |
Connect a channel's signals and slots with this object's signals and slots. | def add_listener(self, channel):
super(Connection, self).add_listener(channel)
if self.is_connected():
self.send_connection_state(conn=True)
self.update()
try:
channel.value_signal[str].connect(self.put_value, Qt.QueuedConnection)
... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def connect(self, channel, a, b):\n a.sender.channels.append(channel)\n channel.receivers.append(b)",
"def connect_slots(self):\n\n self.set_elf_sig.connect(self.set_elf)\n self.run_target_sig.connect(self.run_target)\n self.continue_target_sig.connect(self.continue_target)\n ... | [
"0.6872633",
"0.6626917",
"0.63380224",
"0.6281445",
"0.6226184",
"0.61543494",
"0.6071881",
"0.591992",
"0.5799329",
"0.5768482",
"0.5746394",
"0.5714361",
"0.5684149",
"0.5669694",
"0.5657587",
"0.5638242",
"0.5598887",
"0.5586812",
"0.5574482",
"0.5567418",
"0.5500283",
... | 0.648095 | 2 |
Return WHERE conditions for ensuring the actor isn't null | def _get_not_null_actor_condition(self) -> str:
raise NotImplementedError() | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def filter_is_not_null(self, queryobject):\n raise NotImplementedError()",
"def filter_is_null(self, queryobject):\n raise NotImplementedError()",
"def get_queryset(self):\n q_kwargs = {\n \"awardsearch__latest_transaction__isnull\": True,\n \"date_signed__isnull\": T... | [
"0.5867336",
"0.5730494",
"0.55360276",
"0.5418935",
"0.5336228",
"0.5330968",
"0.5328018",
"0.532107",
"0.5277532",
"0.52022845",
"0.51524246",
"0.5152247",
"0.511795",
"0.51002675",
"0.5090225",
"0.5083719",
"0.5032093",
"0.49824524",
"0.49707043",
"0.49696237",
"0.49655968... | 0.55624276 | 2 |
Generates interarrival times for queries with a uniform distribution. It should satisfy both min_duration and min_queries | def generate_linear_trace(self, min_queries, min_duration, qps):
timestamp = 0
arrival = []
timestep = 1 / qps
while timestamp < min_duration and len(arrival) < min_queries:
timestamp += timestep
arrival.append(timestep)
self.arrival = arrival | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_exp_trace(self, min_queries, min_duration, qps, seed=123):\n timestamp = 0\n arrival = []\n num_samples = int(qps)\n if num_samples == 0:\n num_samples = 1\n np.random.seed(seed)\n samples = np.random.exponential(scale=1.0, size=num_samples)\n ... | [
"0.6274016",
"0.5883859",
"0.56784564",
"0.5614999",
"0.54858136",
"0.5481464",
"0.54684126",
"0.54684126",
"0.5407055",
"0.540266",
"0.5378793",
"0.5353982",
"0.53470653",
"0.53143066",
"0.53066677",
"0.525709",
"0.5220114",
"0.51363957",
"0.51264083",
"0.5097455",
"0.508488... | 0.6014486 | 1 |
Generates interarrival times for queries with a poisson distribution. It should satisfy both min_duration and min_queries | def generate_exp_trace(self, min_queries, min_duration, qps, seed=123):
timestamp = 0
arrival = []
num_samples = int(qps)
if num_samples == 0:
num_samples = 1
np.random.seed(seed)
samples = np.random.exponential(scale=1.0, size=num_samples)
while times... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_poisson_workload(wid_args: dict, mix: list, n: int, t: float) -> list:\n workload = generate_workload(wid_args, mix, n)\n\n time = t * 3600 #t is in hours\n lambda_poisson = n / time\n #Generate intervals via Poisson\n intervals = rng.exponential(1.0/lambda_poisson, len(workload))\n\n ... | [
"0.61667186",
"0.60143256",
"0.58186364",
"0.5700144",
"0.55323154",
"0.53599703",
"0.5328297",
"0.530108",
"0.5251466",
"0.51380277",
"0.50701696",
"0.49611342",
"0.49417326",
"0.49405834",
"0.4938794",
"0.4935624",
"0.4934501",
"0.49250054",
"0.4906135",
"0.48757946",
"0.48... | 0.6036634 | 1 |
Updates the turbo state (checks for stopping condition) Essentially this checks our TURBO stopping condition. | def update_state(state, Y_next):
if max(Y_next) > state.best_value + 1e-3 * fabs(state.best_value):
state.success_counter += 1
state.failure_counter = 0
else:
state.success_counter = 0
state.failure_counter += 1
if state.success_counter == state.success_tolerance: # Expand ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def update_shuttle_state(self):\n if len(self.steps) > self.current_step >= 0:\n step = self.steps[self.current_step]\n if step.is_fulfilled():\n step.end(True)",
"def _update_status(self):\n if any([abs(v) > LIMITS[i] for i, v in enumerate(self.state)]):\n sel... | [
"0.625781",
"0.60271853",
"0.59617275",
"0.5868128",
"0.5811896",
"0.57584614",
"0.57368046",
"0.57330966",
"0.56894845",
"0.5651865",
"0.56268835",
"0.56053036",
"0.5596309",
"0.55944943",
"0.5593896",
"0.55907565",
"0.5581187",
"0.55652255",
"0.5562906",
"0.55497634",
"0.55... | 0.0 | -1 |
generate a batch for the Bayesian Optimization | def generate_batch(
state,
model,
X,
Y,
batch_size,
n_candidates=None,
num_restarts=10,
raw_samples=512,
acqf="ts", # "ei" or "ts",
dtype = torch.float32,
device = None
):
assert acqf in ("ts", "ei")
assert X.min() >= 0.0 and X.max() <= 1.0 and torch.all(torch.isfi... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def generate_batch():\n\n # Initialize variables\n example = np.zeros(self.batch_size)\n labels = np.zeros((self.batch_size, 1))\n alphas = np.zeros(self.batch_size)\n n_items = 0\n index = 0\n\n while index < len(data):\n ... | [
"0.7156559",
"0.6675926",
"0.6484803",
"0.64537615",
"0.6439719",
"0.63298804",
"0.6313098",
"0.629422",
"0.6292286",
"0.6282321",
"0.62772465",
"0.62722385",
"0.62591076",
"0.6255684",
"0.6244277",
"0.6213893",
"0.62077737",
"0.6185972",
"0.6175707",
"0.61558586",
"0.6106689... | 0.0 | -1 |
Given a connectivity threshold, the method will return the sparse matrix most closely matching that threshold. | def get_approx_preRes(self, connectivity_threshold):
#print("sparse_keys", self.sparse_keys_, "connectivity_threshold", connectivity_threshold )
key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]
val = self.sparse_book[key_].clone()
return val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def get_approx_preRes_old(self, connectivity_threshold, i):\n key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]\n val = np.array(sparse_dict[key_]).copy()\n return val",
"def nearest_sparse(self, query):\n self.best_dist = float(\"inf\")\n self.best_elem... | [
"0.601332",
"0.5888134",
"0.5505533",
"0.5345215",
"0.53447497",
"0.5290988",
"0.5274916",
"0.52567625",
"0.5246018",
"0.52018654",
"0.5155741",
"0.5143733",
"0.51208174",
"0.51169515",
"0.50919425",
"0.50628674",
"0.5052682",
"0.5040834",
"0.5035942",
"0.5035092",
"0.4997945... | 0.628852 | 0 |
Add a sparse reservoir set by looping through different different connectivity values and assigining one reservoir weight matrix per connetivity level and storing these for downstream use by EchoStateNetwork We generate the reservoir weights and store them in the sparse library. | def addBook(self, random_seed):
book = {}
n = self.n_nodes_
random_state = Generator(device = self.device).manual_seed(random_seed)
accept = rand(n, n, generator = random_state, device = self.device)
reservoir_pre_weights = rand(n, n, generator = random_state, device =... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def sparsify(W,conn):\n \n N = W.shape[0]\n W_sparse = sparse.lil_matrix((N,N)) \n for row, weights in itertools.izip(conn, W):\n W_sparse[row[0],row[1:]] = weights[1:]\n return W_sparse",
"def set_sparse_signals(self):\n\t\n\t\tparams_dSs = [self.mu_dSs, self.sigma_dSs]\n\t\tparams_Ss0... | [
"0.6089268",
"0.6017336",
"0.5878965",
"0.5767021",
"0.56920177",
"0.55312884",
"0.54914916",
"0.5485382",
"0.5406257",
"0.5383976",
"0.53821015",
"0.5346184",
"0.5324348",
"0.5309101",
"0.5281269",
"0.5279852",
"0.5268382",
"0.5256985",
"0.5256985",
"0.52415115",
"0.5205314"... | 0.56783235 | 5 |
This function is for use by EchoStateNetwork to access different sets of reservoir matrices. Given a connectivity threshold we access a reservoir by approximate sparcity / connectivity. But which randomly generated reservoir we select is determined by the index, which is what ESN uses if the one reservoir is nilpotent. | def get_approx_preRes(self, connectivity_threshold, index = 0):
if self.flip_the_script:
index = np.random.randint(len(self.book_indices))
#print("index", index, "book indices", self.book_indices, "self.library", self.library)
book = self.library[self.book_indices[index]]
if ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def test(indices_to_visit = None):\n ##0 Chicago\n ##1 New York City\n ##2 Los Angeles\n ##3 Minneapolis\n ##4 Denver\n ##5 Dallas\n ##6 Seattle\n ##7 Boston\n ##8 San Francisco\n ##9 St. Louis\n ##10 Houston\n ##11 Phoenix\n ##12 Salt Lake City\n ##13 Miami\n ##14 Atla... | [
"0.5653433",
"0.5381229",
"0.53606856",
"0.5151725",
"0.515109",
"0.5149648",
"0.5137952",
"0.5123968",
"0.5091534",
"0.50662845",
"0.50472456",
"0.49676326",
"0.49329218",
"0.48787913",
"0.48551527",
"0.48445284",
"0.48404717",
"0.48297074",
"0.48243114",
"0.48206934",
"0.48... | 0.52776587 | 3 |
Generates the matrices required for generating reservoir weights | def gen_ran_res_params(self):
gen = Generator(device = self.device).manual_seed(self.random_seed)
n = self.n_nodes_
self.accept = rand(n, n, **self.tensorArgs, generator = gen)
self.reservoir_pre_weights = rand(n, n, **self.tensorArgs, generator = gen) * 2 - 1 | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_weight_matrices(self):\n rad = 1 / np.sqrt(self.no_of_in_nodes)\n X = truncated_normal(mean=0, \n sd=1, \n low=-rad, \n upp=rad)\n self.wih = X.rvs((self.no_of_hidden_nodes, \n ... | [
"0.72100776",
"0.7078924",
"0.69424677",
"0.6844303",
"0.66958326",
"0.6464861",
"0.6418851",
"0.64160824",
"0.63530934",
"0.6338389",
"0.62734073",
"0.6259906",
"0.6180129",
"0.61764675",
"0.6155642",
"0.61368394",
"0.61362815",
"0.6122882",
"0.60942763",
"0.60886437",
"0.60... | 0.0 | -1 |
You can use the matrix returned instead of... | def get_approx_preRes(self, connectivity_threshold, i):
val = sparse_dict.get_approx_preRes(connectivity_threshold, index = i)
return val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self, mat):",
"def lap_mat(self):",
"def matrix_add():",
"def as_matrix(self) -> types.Matrix:",
"def getMatrix(self) -> CMatrix4:\n ...",
"def get_stain_matrix(I):",
"def CreateMatrix(self) -> BaseMatrix:",
"def CreateMatrix(self) -> BaseMatrix:",
"def T(self) -> BaseMatrix:",
... | [
"0.73965985",
"0.72873676",
"0.7231809",
"0.72027314",
"0.68871105",
"0.68203425",
"0.6809076",
"0.6809076",
"0.6786066",
"0.6786066",
"0.6742204",
"0.67335075",
"0.6574923",
"0.65624046",
"0.65345794",
"0.65269136",
"0.65112585",
"0.6453542",
"0.6378975",
"0.6354362",
"0.630... | 0.0 | -1 |
You can use the matrix returned instead of... | def get_approx_preRes_old(self, connectivity_threshold, i):
key_ = self.sparse_keys_[self.sparse_keys_ > connectivity_threshold][0]
val = np.array(sparse_dict[key_]).copy()
return val | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def process(self, mat):",
"def lap_mat(self):",
"def matrix_add():",
"def as_matrix(self) -> types.Matrix:",
"def getMatrix(self) -> CMatrix4:\n ...",
"def get_stain_matrix(I):",
"def CreateMatrix(self) -> BaseMatrix:",
"def CreateMatrix(self) -> BaseMatrix:",
"def T(self) -> BaseMatrix:",
... | [
"0.73965985",
"0.72873676",
"0.7231809",
"0.72027314",
"0.68871105",
"0.68203425",
"0.6809076",
"0.6809076",
"0.6786066",
"0.6786066",
"0.6742204",
"0.67335075",
"0.6574923",
"0.65624046",
"0.65345794",
"0.65269136",
"0.65112585",
"0.6453542",
"0.6378975",
"0.6354362",
"0.630... | 0.0 | -1 |
Generates the reservoir input weight matrix This method assigns the reservoir input weights for later use downstream by the EchoStateNetworkClass. | def gen_in_weights(self):
gen = Generator(device = self.device).manual_seed(self.random_seed)
n, m = self.n_nodes_, self.n_inputs_
in_w_shape_ = (n, m)
print('m,n', m,n)
#at the moment all input weight matrices use uniform bias.
self.bias = rand( n, 1, generator = gen, ... | {
"objective": {
"self": [],
"paired": [],
"triplet": [
[
"query",
"document",
"negatives"
]
]
}
} | [
"def create_weight_matrices(self):\n rad = 1 / np.sqrt(self.no_of_in_nodes)\n X = truncated_normal(mean=0, \n sd=1, \n low=-rad, \n upp=rad)\n self.wih = X.rvs((self.no_of_hidden_nodes, \n ... | [
"0.6588077",
"0.6578553",
"0.6390781",
"0.63611436",
"0.62566054",
"0.6168489",
"0.61538434",
"0.6151322",
"0.61275256",
"0.60950416",
"0.6008337",
"0.60010517",
"0.5981402",
"0.597326",
"0.5969377",
"0.59672725",
"0.5951049",
"0.5945711",
"0.59425867",
"0.5930853",
"0.588238... | 0.688277 | 0 |
Subsets and Splits
No community queries yet
The top public SQL queries from the community will appear here once available.